wiki-viewer 1.0.0 → 1.0.1

package/.next/standalone/src/stores/view-width-store.ts

@@ -0,0 +1,62 @@
+"use client";
+import { create } from "zustand";
+
+export type ViewWidth = "narrow" | "normal" | "wide";
+
+const STORAGE_KEY = "wiki-view-width";
+
+/** Tailwind max-width class per setting. "wide" removes the cap. */
+export const VIEW_WIDTH_CLASS: Record<ViewWidth, string> = {
+	narrow: "max-w-2xl",
+	normal: "max-w-4xl",
+	wide: "max-w-screen-xl",
+};
+
+/** CSS max-width value per setting, for use via the --editor-max-w variable. */
+export const VIEW_WIDTH_CSS: Record<ViewWidth, string> = {
+	narrow: "42rem",
+	normal: "56rem",
+	wide: "80rem",
+};
+
+export const VIEW_WIDTH_LABEL: Record<ViewWidth, string> = {
+	narrow: "Narrow",
+	normal: "Normal",
+	wide: "Wide",
+};
+
+export const VIEW_WIDTH_ORDER: ViewWidth[] = ["narrow", "normal", "wide"];
+
+function loadInitial(): ViewWidth {
+	if (typeof window === "undefined") return "normal";
+	const saved = localStorage.getItem(STORAGE_KEY);
+	if (saved === "narrow" || saved === "normal" || saved === "wide") {
+		return saved;
+	}
+	return "normal";
+}
+
+interface ViewWidthState {
+	width: ViewWidth;
+	setWidth: (width: ViewWidth) => void;
+	cycle: () => void;
+}
+
+export const useViewWidthStore = create<ViewWidthState>((set) => ({
+	width: loadInitial(),
+	setWidth: (width) => {
+		if (typeof window !== "undefined") {
+			localStorage.setItem(STORAGE_KEY, width);
+		}
+		set({ width });
+	},
+	cycle: () =>
+		set((s) => {
+			const idx = VIEW_WIDTH_ORDER.indexOf(s.width);
+			const next = VIEW_WIDTH_ORDER[(idx + 1) % VIEW_WIDTH_ORDER.length];
+			if (typeof window !== "undefined") {
+				localStorage.setItem(STORAGE_KEY, next);
+			}
+			return { width: next };
+		}),
+}));

package/.next/standalone/src/tests/proof/activity-aggregator.test.ts

@@ -0,0 +1,146 @@
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+	aggregateActivity,
+	deriveConnections,
+	ACTIVITY_DEFAULT_LIMIT,
+	ACTIVITY_MAX_LIMIT,
+} from "../../lib/proof/activity.js";
+import type { Sidecar } from "../../lib/proof/types.js";
+
+let tmpRoot: string;
+
+function makeSidecar(filePath: string, eventCount: number, byPrefix = "agent"): Sidecar {
+	const now = Date.now();
+	return {
+		schemaVersion: 1,
+		path: filePath,
+		revision: 0,
+		createdAt: new Date(now).toISOString(),
+		updatedAt: new Date(now).toISOString(),
+		refMap: {},
+		refAliases: {},
+		comments: [],
+		suggestions: [],
+		archivedSuggestions: [],
+		events: Array.from({ length: eventCount }, (_, i) => ({
+			id: i + 1,
+			type: "block.replace",
+			at: new Date(now - (eventCount - i) * 1000).toISOString(),
+			by: `${byPrefix}-${i % 2}`,
+			ref: `b00000${i}`,
+		})),
+		nextEventId: eventCount + 1,
+		lastAck: {},
+		fingerprint: "",
+		blockProvenance: {},
+	};
+}
+
+before(async () => {
+	tmpRoot = await mkdtemp(path.join(tmpdir(), "wiki-activity-test-"));
+});
+
+after(async () => {
+	await rm(tmpRoot, { recursive: true, force: true });
+});
+
+async function writeSidecarFile(sc: Sidecar): Promise<void> {
+	const dest = path.join(tmpRoot, ".proof", sc.path + ".json");
+	await mkdir(path.dirname(dest), { recursive: true });
+	await writeFile(dest, JSON.stringify(sc), "utf-8");
+}
+
+test("aggregates events from 3 sidecar files", async () => {
+	const sc1 = makeSidecar("notes/a.md", 5, "alice");
+	const sc2 = makeSidecar("notes/b.md", 5, "bob");
+	const sc3 = makeSidecar("notes/c.md", 5, "carol");
+	await writeSidecarFile(sc1);
+	await writeSidecarFile(sc2);
+	await writeSidecarFile(sc3);
+
+	const events = await aggregateActivity(tmpRoot);
+	assert.equal(events.length, 15);
+});
+
+test("events include path field from sidecar", async () => {
+	const events = await aggregateActivity(tmpRoot);
+	for (const ev of events) {
+		assert.ok(typeof ev.path === "string", "event has path field");
+	}
+	const paths = new Set(events.map((e) => e.path));
+	assert.ok(paths.has("notes/a.md"));
+	assert.ok(paths.has("notes/b.md"));
+	assert.ok(paths.has("notes/c.md"));
+});
+
+test("events sorted newest first", async () => {
+	const events = await aggregateActivity(tmpRoot);
+	for (let i = 0; i < events.length - 1; i++) {
+		assert.ok(
+			events[i].at >= events[i + 1].at,
+			`event[${i}].at >= event[${i + 1}].at`,
+		);
+	}
+});
+
+test("limit respected", async () => {
+	const events = await aggregateActivity(tmpRoot, { limit: 7 });
+	assert.equal(events.length, 7);
+});
+
+test("limit capped at ACTIVITY_MAX_LIMIT", async () => {
+	const events = await aggregateActivity(tmpRoot, { limit: 99999 });
+	assert.ok(events.length <= ACTIVITY_MAX_LIMIT);
+});
+
+test("default limit is ACTIVITY_DEFAULT_LIMIT", async () => {
+	const events = await aggregateActivity(tmpRoot);
+	assert.ok(events.length <= ACTIVITY_DEFAULT_LIMIT);
+});
+
+test("file filter returns only matching sidecar events", async () => {
+	const events = await aggregateActivity(tmpRoot, { file: "notes/a.md" });
+	assert.ok(events.length > 0, "should have events");
+	for (const ev of events) {
+		assert.equal(ev.path, "notes/a.md");
+	}
+	assert.equal(events.length, 5);
+});
+
+test("file filter on non-existent path returns empty", async () => {
+	const events = await aggregateActivity(tmpRoot, { file: "ghost.md" });
+	assert.equal(events.length, 0);
+});
+
+test("aggregateActivity returns empty when .proof missing", async () => {
+	const emptyRoot = await mkdtemp(path.join(tmpdir(), "wiki-activity-empty-"));
+	try {
+		const events = await aggregateActivity(emptyRoot);
+		assert.equal(events.length, 0);
+	} finally {
+		await rm(emptyRoot, { recursive: true, force: true });
+	}
+});
+
+test("deriveConnections groups by 'by' field within 5 min", async () => {
+	const now = new Date().toISOString();
+	const old = new Date(Date.now() - 10 * 60 * 1000).toISOString();
+	const events = [
+		{ id: 1, type: "block.replace", at: now, by: "alice", path: "a.md" },
+		{ id: 2, type: "block.replace", at: now, by: "alice", path: "a.md" },
+		{ id: 3, type: "block.replace", at: now, by: "bob", path: "b.md" },
+		{ id: 4, type: "block.replace", at: old, by: "carol", path: "c.md" },
+	];
+	const conns = deriveConnections(events);
+	assert.equal(conns.length, 2, "carol excluded (too old)");
+	const alice = conns.find((c) => c.by === "alice");
+	assert.ok(alice, "alice present");
+	assert.equal(alice!.opCount, 2);
+	const bob = conns.find((c) => c.by === "bob");
+	assert.ok(bob, "bob present");
+	assert.equal(bob!.opCount, 1);
+});

package/.next/standalone/src/tests/proof/agent-ownership.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Per-user agent ownership tests.
+ *
+ * User A approves an agent → only user A sees it / can revoke it.
+ * User B cannot see or revoke user A's agents.
+ */
+import { test, before, after, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+let tmpHome: string;
+
+before(async () => {
+	tmpHome = await mkdtemp(path.join(tmpdir(), "agent-ownership-test-"));
+	process.env.HOME = tmpHome;
+});
+
+after(async () => {
+	await rm(tmpHome, { recursive: true, force: true });
+});
+
+import { POST as registerPOST } from "../../app/api/agent/register/route.js";
+import { POST as approvePOST } from "../../app/api/agent/admin/registrations/[regId]/approve/route.js";
+import { GET as listAgentsGET } from "../../app/api/agent/admin/agents/route.js";
+import { POST as revokeAgentPOST } from "../../app/api/agent/admin/agents/[agentId]/revoke/route.js";
+import { ensureRegistry } from "../../lib/proof/registry.js";
+
+beforeEach(async () => {
+	const { _resetRegisterBuckets } = await import("../../lib/proof/register-rate-limit");
+	_resetRegisterBuckets();
+});
+
+async function makeUserCookie(tag: string): Promise<string> {
+	await ensureRegistry();
+	const { auth, authReady } = await import("../../lib/auth/server.js");
+	await authReady();
+	const res = await auth.api.signUpEmail({
+		body: {
+			email: `${tag}${Date.now()}@test.local`,
+			password: "test1234!",
+			name: tag,
+		},
+		asResponse: true,
+	});
+	if (!res.ok) throw new Error("signUpEmail failed: " + res.status);
+	const setCookie = res.headers.get("set-cookie") ?? "";
+	return setCookie
+		.split(/,(?=[^ ])/)
+		.map((c) => c.split(";")[0].trim())
+		.join("; ");
+}
+
+async function registerAgent(agentId: string): Promise<string> {
+	const req = new Request("http://localhost:3000/api/agent/register", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			id: agentId,
+			displayName: `Agent ${agentId}`,
+			scope: { paths: ["**/*"], ops: ["read"] },
+		}),
+	});
+	const res = await registerPOST(req);
+	const data = (await res.json()) as { registrationId: string };
+	return data.registrationId;
+}
+
+async function approveAgent(regId: string, cookie: string): Promise<void> {
+	const req = new Request(
+		`http://localhost:3000/api/agent/admin/registrations/${regId}/approve`,
+		{ method: "POST", headers: { Cookie: cookie } },
+	);
+	const res = await approvePOST(req, { params: Promise.resolve({ regId }) });
+	assert.equal(res.status, 200, `approve failed: ${await res.text()}`);
+}
+
+test("User A approves agent → appears in user A's agent list", async () => {
+	const cookieA = await makeUserCookie("usera");
+	const regId = await registerAgent("ai:agent-a1");
+	await approveAgent(regId, cookieA);
+
+	const listReq = new Request("http://localhost:3000/api/agent/admin/agents", {
+		headers: { Cookie: cookieA },
+	});
+	const res = await listAgentsGET(listReq);
+	assert.equal(res.status, 200);
+	const data = (await res.json()) as { agents: Array<{ id: string }> };
+	assert.ok(data.agents.some((a) => a.id === "ai:agent-a1"));
+});
+
+test("User B cannot see user A's agent", async () => {
+	const cookieA = await makeUserCookie("usera2");
+	const cookieB = await makeUserCookie("userb2");
+
+	const regId = await registerAgent("ai:agent-a2");
+	await approveAgent(regId, cookieA);
+
+	const listReq = new Request("http://localhost:3000/api/agent/admin/agents", {
+		headers: { Cookie: cookieB },
+	});
+	const res = await listAgentsGET(listReq);
+	assert.equal(res.status, 200);
+	const data = (await res.json()) as { agents: Array<{ id: string }> };
+	assert.ok(!data.agents.some((a) => a.id === "ai:agent-a2"), "User B should not see user A's agent");
+});
+
+test("User B cannot revoke user A's agent → 403", async () => {
+	const cookieA = await makeUserCookie("usera3");
+	const cookieB = await makeUserCookie("userb3");
+
+	const regId = await registerAgent("ai:agent-a3");
+	await approveAgent(regId, cookieA);
+
+	const revokeReq = new Request(
+		"http://localhost:3000/api/agent/admin/agents/ai:agent-a3/revoke",
+		{ method: "POST", headers: { Cookie: cookieB } },
+	);
+	const res = await revokeAgentPOST(revokeReq, {
+		params: Promise.resolve({ agentId: "ai:agent-a3" }),
+	});
+	assert.equal(res.status, 403);
+});
+
+test("User A can revoke their own agent", async () => {
+	const cookieA = await makeUserCookie("usera4");
+
+	const regId = await registerAgent("ai:agent-a4");
+	await approveAgent(regId, cookieA);
+
+	const revokeReq = new Request(
+		"http://localhost:3000/api/agent/admin/agents/ai:agent-a4/revoke",
+		{ method: "POST", headers: { Cookie: cookieA } },
+	);
+	const res = await revokeAgentPOST(revokeReq, {
+		params: Promise.resolve({ agentId: "ai:agent-a4" }),
+	});
+	assert.equal(res.status, 200);
+});

package/.next/standalone/src/tests/proof/agents-install.test.ts

@@ -0,0 +1,57 @@
+/**
+ * Tests for /api/agents/install, /api/agents/skill, /api/agents/skill.tar.gz
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+function makeMockRequest(url: string): Request {
+	return new Request(url, { method: "GET" });
+}
+
+// Import routes
+import { GET as installGET } from "../../app/api/agents/install/route.js";
+import { GET as skillGET } from "../../app/api/agents/skill/route.js";
+import { GET as tarGET } from "../../app/api/agents/skill.tar.gz/route.js";
+
+test("GET /api/agents/install returns 200 with expected shape", async () => {
+	const req = makeMockRequest("http://localhost:3000/api/agents/install");
+	const res = await installGET(req as Parameters<typeof installGET>[0]);
+	assert.equal(res.status, 200);
+
+	const body = await res.json() as Record<string, unknown>;
+	assert.equal(body.name, "wiki-viewer");
+	assert.ok(typeof body.version === "string" && body.version.length > 0);
+	assert.ok(typeof body.endpoint === "string" && body.endpoint.startsWith("http"));
+	assert.ok(Array.isArray(body.routes) && (body.routes as unknown[]).length > 0);
+	assert.ok(typeof body.skillTarball === "string");
+	assert.ok(typeof body.bootstrapPrompt === "string" && body.bootstrapPrompt.length > 0);
+	assert.ok(typeof body.humanInstructions === "string" && body.humanInstructions.length > 0);
+	assert.ok(Array.isArray(body.ops) && (body.ops as unknown[]).length > 0);
+});
+
+test("GET /api/agents/skill returns 200 text/markdown with SKILL.md content", async () => {
+	const req = makeMockRequest("http://localhost:3000/api/agents/skill");
+	const res = await skillGET(req as Parameters<typeof skillGET>[0]);
+	assert.equal(res.status, 200);
+
+	const ct = res.headers.get("content-type") ?? "";
+	assert.ok(ct.startsWith("text/markdown"), `Expected text/markdown, got: ${ct}`);
+
+	const body = await res.text();
+	assert.ok(body.startsWith("---\nname: wiki-viewer"), `Unexpected start: ${body.slice(0, 40)}`);
+});
+
+test("GET /api/agents/skill.tar.gz returns 200 gzip with magic bytes", async () => {
+	const req = makeMockRequest("http://localhost:3000/api/agents/skill.tar.gz");
+	const res = await tarGET(req as Parameters<typeof tarGET>[0]);
+	assert.equal(res.status, 200);
+
+	const ct = res.headers.get("content-type") ?? "";
+	assert.equal(ct, "application/gzip");
+
+	const buf = Buffer.from(await res.arrayBuffer());
+	assert.ok(buf.length > 0, "tarball should not be empty");
+	// gzip magic bytes
+	assert.equal(buf[0], 0x1f);
+	assert.equal(buf[1], 0x8b);
+});

package/.next/standalone/src/tests/proof/better-auth.test.ts

@@ -0,0 +1,68 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { isEmailAllowed } from "../../lib/auth/allowlist";
+
+function resetEnv() {
+	delete process.env.AUTH_ALLOWED_EMAILS;
+	delete process.env.AUTH_ALLOWED_DOMAIN;
+}
+
+// These tests exercise the env-fallback path. They assume no allowlist is set
+// in ~/.wiki-viewer/config.json (config takes precedence over env when present).
+
+test("isEmailAllowed: no env vars allows any email", async () => {
+	resetEnv();
+	assert.equal(await isEmailAllowed("anyone@example.com"), true);
+	assert.equal(await isEmailAllowed("eve@evil.com"), true);
+});
+
+test("isEmailAllowed: explicit allowlist (case-insensitive)", async () => {
+	resetEnv();
+	process.env.AUTH_ALLOWED_EMAILS = "alice@example.com,bob@example.com";
+	try {
+		assert.equal(await isEmailAllowed("alice@example.com"), true);
+		assert.equal(await isEmailAllowed("ALICE@EXAMPLE.COM"), true);
+		assert.equal(await isEmailAllowed("bob@example.com"), true);
+		assert.equal(await isEmailAllowed("eve@example.com"), false);
+	} finally {
+		resetEnv();
+	}
+});
+
+test("isEmailAllowed: domain allowlist", async () => {
+	resetEnv();
+	process.env.AUTH_ALLOWED_DOMAIN = "example.com,trusted.org";
+	try {
+		assert.equal(await isEmailAllowed("anyone@example.com"), true);
+		assert.equal(await isEmailAllowed("user@trusted.org"), true);
+		assert.equal(await isEmailAllowed("user@TRUSTED.ORG"), true);
+		assert.equal(await isEmailAllowed("eve@evil.com"), false);
+	} finally {
+		resetEnv();
+	}
+});
+
+test("isEmailAllowed: both lists, either match wins", async () => {
+	resetEnv();
+	process.env.AUTH_ALLOWED_EMAILS = "guest@anywhere.com";
+	process.env.AUTH_ALLOWED_DOMAIN = "example.com";
+	try {
+		assert.equal(await isEmailAllowed("alice@example.com"), true);
+		assert.equal(await isEmailAllowed("guest@anywhere.com"), true);
+		assert.equal(await isEmailAllowed("eve@evil.com"), false);
+	} finally {
+		resetEnv();
+	}
+});
+
+test("isEmailAllowed: handles whitespace and empty entries", async () => {
+	resetEnv();
+	process.env.AUTH_ALLOWED_EMAILS = " alice@example.com , , bob@example.com ";
+	try {
+		assert.equal(await isEmailAllowed("alice@example.com"), true);
+		assert.equal(await isEmailAllowed("bob@example.com"), true);
+		assert.equal(await isEmailAllowed("eve@example.com"), false);
+	} finally {
+		resetEnv();
+	}
+});

package/.next/standalone/src/tests/proof/block-refs.test.ts

@@ -0,0 +1,108 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseBlocks } from "../../lib/proof/blocks.js";
+import { assignRefs, resolveRef } from "../../lib/proof/block-refs.js";
+import { emptySidecar } from "../../lib/proof/sidecar.js";
+import type { Sidecar } from "../../lib/proof/types.js";
+
+function makeSidecar(refMap: Sidecar["refMap"]): Sidecar {
+	return { ...emptySidecar("test.md"), refMap };
+}
+
+test("first parse assigns refs deterministically", () => {
+	const md = "# Title\n\nParagraph.\n";
+	const nodes = parseBlocks(md);
+	const { blocks } = assignRefs(nodes, null);
+
+	const { blocks: blocks2 } = assignRefs(nodes, null);
+	assert.equal(blocks[0].ref, blocks2[0].ref, "heading ref should be deterministic");
+	assert.equal(blocks[1].ref, blocks2[1].ref, "paragraph ref should be deterministic");
+});
+
+test("re-parse with same content reuses refs", () => {
+	const md = "# Title\n\nParagraph.\n";
+	const nodes = parseBlocks(md);
+	const { blocks: first, newRefMap } = assignRefs(nodes, null);
+
+	const sidecar = makeSidecar(newRefMap);
+	const { blocks: second } = assignRefs(nodes, sidecar);
+
+	assert.equal(first[0].ref, second[0].ref, "heading ref should be reused");
+	assert.equal(first[1].ref, second[1].ref, "paragraph ref should be reused");
+});
+
+test("edit one block, others keep refs", () => {
+	const md = "# Title\n\nOriginal paragraph.\n\n## Section\n";
+	const nodes = parseBlocks(md);
+	const { blocks: original, newRefMap } = assignRefs(nodes, null);
+
+	// Edit the paragraph
+	const md2 = "# Title\n\nEdited paragraph.\n\n## Section\n";
+	const nodes2 = parseBlocks(md2);
+	const sidecar = makeSidecar(newRefMap);
+	const { blocks: updated } = assignRefs(nodes2, sidecar);
+
+	assert.equal(updated[0].ref, original[0].ref, "heading ref should be preserved");
+	assert.equal(updated[2].ref, original[2].ref, "second heading ref should be preserved");
+	// Middle block changed, so it gets a new ref
+	assert.notEqual(updated[1].ref, original[1].ref, "edited block should get new ref");
+});
+
+test("insert a block in middle, others keep refs", () => {
+	const md = "# Title\n\nParagraph.\n";
+	const nodes = parseBlocks(md);
+	const { blocks: original, newRefMap } = assignRefs(nodes, null);
+
+	// Insert a new block in the middle
+	const md2 = "# Title\n\nNew block.\n\nParagraph.\n";
+	const nodes2 = parseBlocks(md2);
+	const sidecar = makeSidecar(newRefMap);
+	const { blocks: updated } = assignRefs(nodes2, sidecar);
+
+	assert.equal(updated[0].ref, original[0].ref, "heading ref preserved after insert");
+	assert.equal(updated[2].ref, original[1].ref, "paragraph ref preserved after insert");
+	assert.notEqual(updated[1].ref, original[0].ref, "new block has distinct ref");
+	assert.notEqual(updated[1].ref, original[1].ref, "new block has distinct ref");
+});
+
+test("aliases populated after replace", () => {
+	const md = "# Title\n\nOriginal.\n";
+	const nodes = parseBlocks(md);
+	const { blocks: original, newRefMap } = assignRefs(nodes, null);
+
+	const md2 = "# Title\n\nReplaced.\n";
+	const nodes2 = parseBlocks(md2);
+	const sidecar = makeSidecar(newRefMap);
+	const { blocks: updated, newRefMap: newMap } = assignRefs(nodes2, sidecar);
+
+	// Old ref for the paragraph should not appear in new refMap
+	const oldRef = original[1].ref;
+	const newRef = updated[1].ref;
+	assert.ok(oldRef !== newRef, "replaced block should have different ref");
+	assert.ok(!(oldRef in newMap), "old ref should not be in new refMap");
+});
+
+test("resolveRef resolves via aliases", () => {
+	const md = "Paragraph.\n";
+	const nodes = parseBlocks(md);
+	const { blocks, newRefMap } = assignRefs(nodes, null);
+	const oldRef = blocks[0].ref;
+
+	// Simulate a replacement: new content
+	const md2 = "Replaced.\n";
+	const nodes2 = parseBlocks(md2);
+	const sidecarWithAlias: Sidecar = {
+		...makeSidecar(newRefMap),
+		refAliases: { [oldRef]: "bnewref" },
+	};
+
+	const current = new Set(["bnewref"]);
+	const resolved = resolveRef(sidecarWithAlias, oldRef, current);
+	assert.equal(resolved, "bnewref", "should resolve via alias");
+});
+
+test("resolveRef returns null for unknown ref", () => {
+	const sidecar = makeSidecar({});
+	const resolved = resolveRef(sidecar, "bdeadbeef", new Set(["babc123"]));
+	assert.equal(resolved, null);
+});

package/.next/standalone/src/tests/proof/blocks.test.ts

@@ -0,0 +1,92 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseBlocks, blockToMarkdown, blocksToMarkdown, blockType } from "../../lib/proof/blocks.js";
+
+test("roundtrip preserves <proof-span> exactly", () => {
+	const md = `<proof-span id="p001" origin="ai" by="ai:claude" at="2026-01-01T00:00:00Z">The AI wrote this.</proof-span>`;
+	const nodes = parseBlocks(md);
+	assert.equal(nodes.length, 1, "should parse as 1 block");
+	const roundtripped = blockToMarkdown(nodes[0]);
+	assert.ok(
+		roundtripped.includes('<proof-span id="p001"'),
+		`proof-span not preserved: ${roundtripped}`,
+	);
+	assert.ok(
+		roundtripped.includes("The AI wrote this."),
+		`content not preserved: ${roundtripped}`,
+	);
+	assert.ok(
+		roundtripped.includes("</proof-span>"),
+		`closing tag not preserved: ${roundtripped}`,
+	);
+});
+
+test("list with checkboxes detected as taskList", () => {
+	const md = `- [x] Done\n- [ ] Todo`;
+	const nodes = parseBlocks(md);
+	assert.equal(nodes.length, 1);
+	const { type } = blockType(nodes[0]);
+	assert.equal(type, "taskList");
+});
+
+test("ordered list detected as orderedList", () => {
+	const md = `1. First\n2. Second`;
+	const nodes = parseBlocks(md);
+	assert.equal(nodes.length, 1);
+	const { type } = blockType(nodes[0]);
+	assert.equal(type, "orderedList");
+});
+
+test("bullet list detected as bulletList", () => {
+	const md = `- one\n- two`;
+	const nodes = parseBlocks(md);
+	const { type } = blockType(nodes[0]);
+	assert.equal(type, "bulletList");
+});
+
+test("code block with lang preserved", () => {
+	const md = "```typescript\nconst x = 1;\n```";
+	const nodes = parseBlocks(md);
+	assert.equal(nodes.length, 1);
+	const { type, lang } = blockType(nodes[0]);
+	assert.equal(type, "codeBlock");
+	assert.equal(lang, "typescript");
+	const out = blockToMarkdown(nodes[0]);
+	assert.ok(out.includes("typescript"), `lang not preserved: ${out}`);
+	assert.ok(out.includes("const x = 1;"), `code not preserved: ${out}`);
+});
+
+test("table preserved", () => {
+	const md = "| A | B |\n|---|---|\n| 1 | 2 |";
+	const nodes = parseBlocks(md);
+	assert.equal(nodes.length, 1);
+	const { type } = blockType(nodes[0]);
+	assert.equal(type, "table");
+	const out = blockToMarkdown(nodes[0]);
+	assert.ok(out.includes("| A |"), `table not preserved: ${out}`);
+});
+
+test("blocksToMarkdown joins multiple blocks", () => {
+	const md = "# Title\n\nSome text.\n\n- item1\n- item2";
+	const nodes = parseBlocks(md);
+	assert.equal(nodes.length, 3);
+	const out = blocksToMarkdown(nodes);
+	assert.ok(out.includes("# Title"), `heading missing: ${out}`);
+	assert.ok(out.includes("Some text."), `paragraph missing: ${out}`);
+	assert.ok(out.includes("item1"), `list missing: ${out}`);
+});
+
+test("heading block type detected", () => {
+	const md = "## Section";
+	const nodes = parseBlocks(md);
+	const { type, level } = blockType(nodes[0]);
+	assert.equal(type, "heading");
+	assert.equal(level, 2);
+});
+
+test("hr block type detected", () => {
+	const md = "---";
+	const nodes = parseBlocks(md);
+	const { type } = blockType(nodes[0]);
+	assert.equal(type, "hr");
+});