cursedbelt-server 1.0.0

package/src/server/retention/target.spec.ts

@@ -0,0 +1,592 @@
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	mkdirSync,
+	mkdtempSync,
+	readdirSync,
+	readFileSync,
+	rmSync,
+	utimesSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DAY_MS, resolveRetentionPolicy, type RetentionDeclaration } from "./policy";
+import { createJsonlArchive, verifyArchive } from "./archive";
+import {
+	createArchivingSqliteTableTarget,
+	createFileDirTarget,
+	createSqliteTableTarget,
+} from "./target";
+
+const NOW = 1_800_000_000_000;
+const daysAgo = (n: number): number => NOW - n * DAY_MS;
+
+const rowDecl: RetentionDeclaration = {
+	app: "orch",
+	id: "events",
+	label: "Event trail",
+	category: "event-log",
+	unit: "rows",
+	location: "orch.sqlite · events",
+	consequence: "the narrative of past runs",
+};
+
+describe("createSqliteTableTarget", () => {
+	let db: Database;
+
+	beforeEach(() => {
+		db = new Database(":memory:");
+		db.run("CREATE TABLE events (id INTEGER PRIMARY KEY, at INTEGER, task_id TEXT)");
+		db.run("CREATE TABLE tasks (id TEXT PRIMARY KEY, status TEXT)");
+	});
+	afterEach(() => db.close());
+
+	const insert = (at: number | null, taskId: string | null = null): void => {
+		db.query("INSERT INTO events (at, task_id) VALUES ($at, $task)").run({
+			$at: at,
+			$task: taskId,
+		} as never);
+	};
+
+	test("deletes rows past the cutoff and keeps the rest", () => {
+		for (const d of [40, 30, 20, 5, 1]) insert(daysAgo(d));
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+		});
+		const policy = resolveRetentionPolicy(rowDecl, { days: 14 });
+
+		expect(target.preview(policy, NOW)).toEqual({ aged: 3, overflow: 0 });
+		expect(target.sweep(policy, NOW)).toMatchObject({ aged: 3, overflow: 0 });
+		expect(target.measure().items).toBe(2);
+	});
+
+	test("preview never mutates — it is the same predicate, not a second one", () => {
+		for (const d of [40, 30, 1]) insert(daysAgo(d));
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+		});
+		const policy = resolveRetentionPolicy(rowDecl, { days: 14 });
+		target.preview(policy, NOW);
+		target.preview(policy, NOW);
+		expect(target.measure().items).toBe(3);
+		expect(target.sweep(policy, NOW).aged).toBe(2);
+	});
+
+	test("protectWhere exempts live working state from the AGE rule", () => {
+		db.query("INSERT INTO tasks (id, status) VALUES ('t-live', 'parked')").run();
+		db.query("INSERT INTO tasks (id, status) VALUES ('t-done', 'done')").run();
+		insert(daysAgo(90), "t-live"); // parked for months — the trail explains WHY
+		insert(daysAgo(90), "t-done");
+		insert(daysAgo(90), null);
+
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+			protectWhere:
+				"EXISTS (SELECT 1 FROM tasks t WHERE t.id = events.task_id AND t.status NOT IN ('done'))",
+		});
+		expect(target.sweep(resolveRetentionPolicy(rowDecl, { days: 14 }), NOW).aged).toBe(2);
+		expect(target.measure().items).toBe(1);
+	});
+
+	test("floorItems keeps the newest N at ANY age — the rule with no exceptions", () => {
+		for (const d of [400, 300, 200, 100]) insert(daysAgo(d));
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+		});
+		const policy = resolveRetentionPolicy({ ...rowDecl, floorItems: 2 }, { days: 1 });
+		expect(target.sweep(policy, NOW).aged).toBe(2);
+		expect(target.measure().items).toBe(2);
+	});
+
+	test("the floor counts the whole table, not just the deletable subset", () => {
+		// A table of protected rows plus one old row must not delete that row while
+		// claiming to keep three.
+		db.query("INSERT INTO tasks (id, status) VALUES ('t-live', 'parked')").run();
+		for (const d of [10, 9, 8]) insert(daysAgo(d), "t-live");
+		insert(daysAgo(400));
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+			protectWhere:
+				"EXISTS (SELECT 1 FROM tasks t WHERE t.id = events.task_id AND t.status NOT IN ('done'))",
+		});
+		const policy = resolveRetentionPolicy({ ...rowDecl, floorItems: 3 }, { days: 30 });
+		// Newest 3 are the protected ones; the old row is #4, so it is deletable.
+		expect(target.sweep(policy, NOW).aged).toBe(1);
+		expect(target.measure().items).toBe(3);
+	});
+
+	test("the item cap is blunt on purpose — it ignores protectWhere", () => {
+		db.query("INSERT INTO tasks (id, status) VALUES ('t-live', 'running')").run();
+		for (let i = 0; i < 10; i++) insert(daysAgo(1), "t-live"); // all live, all recent
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+			protectWhere:
+				"EXISTS (SELECT 1 FROM tasks t WHERE t.id = events.task_id AND t.status NOT IN ('done'))",
+		});
+		const policy = resolveRetentionPolicy({ ...rowDecl, defaultMaxItems: 4 });
+		expect(target.sweep(policy, NOW)).toMatchObject({ aged: 0, overflow: 6 });
+		expect(target.measure().items).toBe(4);
+	});
+
+	test("the cap never digs below the floor", () => {
+		for (let i = 0; i < 10; i++) insert(daysAgo(1));
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+		});
+		const policy = resolveRetentionPolicy({ ...rowDecl, defaultMaxItems: 2, floorItems: 6 });
+		expect(target.sweep(policy, NOW).overflow).toBe(4);
+		expect(target.measure().items).toBe(6);
+	});
+
+	test("a NULL timestamp is ageless and kept — an unknown age is not an old one", () => {
+		insert(null);
+		insert(daysAgo(400));
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+		});
+		expect(target.sweep(resolveRetentionPolicy(rowDecl, { days: 1 }), NOW).aged).toBe(1);
+		expect(target.measure().items).toBe(1);
+	});
+
+	test("a disabled policy is a no-op, and days:0 disables only the age rule", () => {
+		for (let i = 0; i < 5; i++) insert(daysAgo(400));
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+		});
+		expect(target.sweep(resolveRetentionPolicy(rowDecl, { enabled: false }), NOW)).toMatchObject({
+			aged: 0,
+		});
+		expect(target.measure().items).toBe(5);
+		expect(
+			target.sweep(resolveRetentionPolicy(rowDecl, { days: 0, maxItems: 2 }), NOW),
+		).toMatchObject({
+			aged: 0,
+			overflow: 3,
+		});
+	});
+
+	test("refuses an unsafe table or column name rather than interpolating it", () => {
+		expect(() =>
+			createSqliteTableTarget({
+				db,
+				declaration: rowDecl,
+				table: 'events"; DROP TABLE tasks; --',
+				timeColumn: "at",
+			}),
+		).toThrow(/unsafe table name/);
+		expect(() =>
+			createSqliteTableTarget({ db, declaration: rowDecl, table: "events", timeColumn: "at)" }),
+		).toThrow(/unsafe column name/);
+	});
+
+	test("measure reports the oldest timestamp so the UI can show a real age", () => {
+		insert(daysAgo(30));
+		insert(daysAgo(2));
+		const target = createSqliteTableTarget({
+			db,
+			declaration: rowDecl,
+			table: "events",
+			timeColumn: "at",
+		});
+		expect(target.measure()).toEqual({ items: 2, oldestAt: daysAgo(30) });
+	});
+});
+
+describe("createFileDirTarget", () => {
+	let dir: string;
+	const fileDecl: RetentionDeclaration = {
+		app: "orch",
+		id: "attempt-transcripts",
+		label: "Attempt transcripts",
+		category: "transcript",
+		unit: "files",
+		location: "logs/attempts/*.jsonl",
+		consequence: "the verbatim worker output for old attempts",
+	};
+
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "retention-files-"));
+	});
+	afterEach(() => rmSync(dir, { recursive: true, force: true }));
+
+	const write = (name: string, ageDays: number, bytes = 10): void => {
+		const path = join(dir, name);
+		writeFileSync(path, "x".repeat(bytes));
+		const seconds = (NOW - ageDays * DAY_MS) / 1000;
+		utimesSync(path, seconds, seconds);
+	};
+
+	test("deletes files past the cutoff and reports the bytes reclaimed", () => {
+		write("a.jsonl", 40, 100);
+		write("b.jsonl", 30, 200);
+		write("c.jsonl", 2, 50);
+		const target = createFileDirTarget({ declaration: fileDecl, dir, match: /\.jsonl$/ });
+		const policy = resolveRetentionPolicy(fileDecl, { days: 14 });
+
+		expect(target.preview(policy, NOW)).toEqual({ aged: 2, overflow: 0 });
+		expect(target.sweep(policy, NOW)).toMatchObject({ aged: 2, bytesFreed: 300 });
+		expect(target.measure()).toMatchObject({ items: 1, bytes: 50 });
+	});
+
+	test("only governs what it can prove it owns — non-matching files and subdirs are invisible", () => {
+		write("a.jsonl", 400);
+		write("keep-me.txt", 400);
+		mkdirSync(join(dir, "nested"));
+		writeFileSync(join(dir, "nested", "deep.jsonl"), "x");
+		const target = createFileDirTarget({ declaration: fileDecl, dir, match: /\.jsonl$/ });
+		expect(target.measure().items).toBe(1);
+		expect(target.sweep(resolveRetentionPolicy(fileDecl, { days: 1 }), NOW).aged).toBe(1);
+		expect(Bun.file(join(dir, "keep-me.txt")).size).toBeGreaterThan(0);
+		expect(Bun.file(join(dir, "nested", "deep.jsonl")).size).toBeGreaterThan(0);
+	});
+
+	test("floorItems keeps the newest N at any age", () => {
+		for (const d of [400, 300, 200]) write(`f${d}.jsonl`, d);
+		const target = createFileDirTarget({ declaration: fileDecl, dir, match: /\.jsonl$/ });
+		const policy = resolveRetentionPolicy({ ...fileDecl, floorItems: 2 }, { days: 1 });
+		expect(target.sweep(policy, NOW).aged).toBe(1);
+		expect(target.measure().items).toBe(2);
+	});
+
+	test("the cap removes the OLDEST survivors, never the newest", () => {
+		for (const d of [5, 4, 3, 2, 1]) write(`f${d}.jsonl`, d);
+		const target = createFileDirTarget({ declaration: fileDecl, dir, match: /\.jsonl$/ });
+		const policy = resolveRetentionPolicy({ ...fileDecl, defaultMaxItems: 2 });
+		expect(target.sweep(policy, NOW)).toMatchObject({ aged: 0, overflow: 3 });
+		expect(target.measure().items).toBe(2);
+		expect(Bun.file(join(dir, "f1.jsonl")).size).toBeGreaterThan(0);
+		expect(Bun.file(join(dir, "f2.jsonl")).size).toBeGreaterThan(0);
+	});
+
+	test("the byte budget drops oldest-first until the directory fits", () => {
+		// The right bound when items vary by orders of magnitude — one deep run is
+		// 5 MB and one trivial attempt 4 KB, so a count cap bounds nothing useful.
+		write("old.jsonl", 5, 1000);
+		write("mid.jsonl", 4, 1000);
+		write("new.jsonl", 3, 1000);
+		const target = createFileDirTarget({ declaration: fileDecl, dir, match: /\.jsonl$/ });
+		const policy = resolveRetentionPolicy({ ...fileDecl, defaultMaxBytes: 2000 });
+		expect(target.sweep(policy, NOW)).toMatchObject({ aged: 0, overflow: 1, bytesFreed: 1000 });
+		expect(target.measure()).toMatchObject({ items: 2, bytes: 2000 });
+		expect(Bun.file(join(dir, "new.jsonl")).size).toBeGreaterThan(0);
+	});
+
+	test("`protect` holds against the AGE rule and BOTH caps", () => {
+		// A live transcript unlinked out from under its writer loses the output with
+		// no error anywhere — so protection is absolute, not merely age-scoped.
+		write("live.jsonl", 400, 5000);
+		write("settled.jsonl", 400, 5000);
+		const target = createFileDirTarget({
+			declaration: fileDecl,
+			dir,
+			match: /\.jsonl$/,
+			protect: (files) => new Set(files.filter((f) => f.name === "live.jsonl").map((f) => f.path)),
+		});
+		const policy = resolveRetentionPolicy(
+			{ ...fileDecl, defaultMaxBytes: 1, defaultMaxItems: 0 },
+			{ days: 1 },
+		);
+		const report = target.sweep(policy, NOW);
+		expect(report).toMatchObject({ aged: 1, protectedItems: 1 });
+		expect(Bun.file(join(dir, "live.jsonl")).size).toBe(5000);
+		expect(target.measure().items).toBe(1);
+	});
+
+	test("`protect` is called ONCE per sweep, with every governed file", () => {
+		// One database query for the protected set, not one per file.
+		for (const d of [3, 2, 1]) write(`f${d}.jsonl`, d);
+		let calls = 0;
+		let sawNames: string[] = [];
+		const target = createFileDirTarget({
+			declaration: fileDecl,
+			dir,
+			match: /\.jsonl$/,
+			protect: (files) => {
+				calls++;
+				sawNames = files.map((f) => f.name).sort();
+				return new Set();
+			},
+		});
+		target.sweep(resolveRetentionPolicy(fileDecl), NOW);
+		expect(calls).toBe(1);
+		expect(sawNames).toEqual(["f1.jsonl", "f2.jsonl", "f3.jsonl"]);
+	});
+
+	test("preview accounts for protection exactly as the sweep does", () => {
+		write("live.jsonl", 400);
+		write("settled.jsonl", 400);
+		const target = createFileDirTarget({
+			declaration: fileDecl,
+			dir,
+			match: /\.jsonl$/,
+			protect: (files) => new Set(files.filter((f) => f.name === "live.jsonl").map((f) => f.path)),
+		});
+		const policy = resolveRetentionPolicy(fileDecl, { days: 1 });
+		expect(target.preview(policy, NOW)).toEqual({ aged: 1, overflow: 0 });
+		expect(target.sweep(policy, NOW).aged).toBe(1);
+	});
+
+	test("a missing directory is a resource with nothing in it, not an error", () => {
+		const target = createFileDirTarget({ declaration: fileDecl, dir: join(dir, "absent") });
+		expect(target.measure()).toMatchObject({ items: 0, bytes: 0 });
+		expect(target.sweep(resolveRetentionPolicy(fileDecl), NOW)).toMatchObject({ aged: 0 });
+	});
+});
+
+// ── archive-then-trim ────────────────────────────────────────────────────────
+
+const historyDecl: RetentionDeclaration = {
+	app: "notes",
+	id: "sync-history",
+	label: "Sync history",
+	category: "archived-history",
+	unit: "rows",
+	location: "notes.sqlite · ops",
+	consequence: "the older half of the sync log, which lives in the archive instead",
+};
+
+describe("🔴 an archiving category cannot be governed by a target that only deletes", () => {
+	test("createSqliteTableTarget REFUSES it, naming the target that can", () => {
+		const db = new Database(":memory:");
+		db.run("CREATE TABLE ops (seq INTEGER PRIMARY KEY, at INTEGER)");
+		expect(() =>
+			createSqliteTableTarget({ db, declaration: historyDecl, table: "ops", timeColumn: "at" }),
+		).toThrow(/createArchivingSqliteTableTarget/);
+		db.close();
+	});
+
+	test("createFileDirTarget REFUSES it too", () => {
+		expect(() => createFileDirTarget({ declaration: historyDecl, dir: "/tmp/nope" })).toThrow(
+			/only deletes/,
+		);
+	});
+
+	test("...and the archiving target refuses a category that does NOT promise an archive", () => {
+		// The other direction matters just as much: an archiving target over an
+		// `event-log` would quietly keep a second copy of data the owner agreed to
+		// lose, and grow a disk nobody is watching.
+		const db = new Database(":memory:");
+		db.run("CREATE TABLE events (id INTEGER PRIMARY KEY, at INTEGER)");
+		expect(() =>
+			createArchivingSqliteTableTarget({
+				db,
+				declaration: rowDecl,
+				table: "events",
+				timeColumn: "at",
+				archive: createJsonlArchive({
+					app: "orch",
+					resource: "events",
+					home: { dir: mkdtempSync(join(tmpdir(), "cb-tgt-")), terminal: true },
+				}),
+			}),
+		).toThrow(/does not archive before deleting/);
+		db.close();
+	});
+});
+
+describe("createArchivingSqliteTableTarget", () => {
+	let db: Database;
+	let dir: string;
+
+	beforeEach(() => {
+		db = new Database(":memory:");
+		db.run("CREATE TABLE ops (seq INTEGER PRIMARY KEY, at INTEGER, kind TEXT, payload TEXT)");
+		dir = mkdtempSync(join(tmpdir(), "cb-tgt-"));
+	});
+	afterEach(() => {
+		db.close();
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	const insert = (at: number, kind = "item.upsert"): void => {
+		db.query("INSERT INTO ops (at, kind, payload) VALUES ($at, $kind, '{}')").run({
+			$at: at,
+			$kind: kind,
+		} as never);
+	};
+
+	const target = (over: Partial<Parameters<typeof createArchivingSqliteTableTarget>[0]> = {}) =>
+		createArchivingSqliteTableTarget({
+			db,
+			declaration: historyDecl,
+			table: "ops",
+			timeColumn: "at",
+			idColumn: "seq",
+			archive: createJsonlArchive({
+				app: "notes",
+				resource: "sync-history",
+				home: { dir, terminal: true },
+			}),
+			...over,
+		});
+
+	test("aged rows are in the archive AND out of the table — in that order", () => {
+		for (const d of [40, 35, 5, 1]) insert(daysAgo(d));
+		const report = target().sweep(resolveRetentionPolicy(historyDecl, { days: 30 }), NOW);
+
+		expect(report.aged).toBe(2);
+		expect(report.archived).toBe(2);
+		expect((db.query("SELECT COUNT(*) AS n FROM ops").get() as { n: number }).n).toBe(2);
+		expect(verifyArchive(dir)).toMatchObject({ segments: 1, rows: 2, bad: [] });
+	});
+
+	test("the archived rows are the WHOLE row, every column, not a projection", () => {
+		insert(daysAgo(40), "tag.set");
+		target().sweep(resolveRetentionPolicy(historyDecl, { days: 30 }), NOW);
+		const [line] = readdirSync(dir)
+			.filter((n) => n !== "index.jsonl")
+			.map((n) => readFileSync(join(dir, n), "utf8").trim());
+		expect(JSON.parse(line as string)).toEqual({
+			seq: 1,
+			at: daysAgo(40),
+			kind: "tag.set",
+			payload: "{}",
+		});
+	});
+
+	test("🔴 an archive that cannot be written deletes NOTHING", () => {
+		// The single most important assertion in this file. A sink that throws must
+		// leave the table exactly as it was — the ordering rule prod's diskGuard.sh
+		// broke, expressed as a test.
+		for (const d of [40, 35]) insert(daysAgo(d));
+		const broken = target({
+			archive: {
+				dir: "/nowhere",
+				terminal: true,
+				pendingBytes: () => 0,
+				write: () => {
+					throw new Error("disk full");
+				},
+			},
+		});
+		expect(() => broken.sweep(resolveRetentionPolicy(historyDecl, { days: 30 }), NOW)).toThrow(
+			/disk full/,
+		);
+		expect((db.query("SELECT COUNT(*) AS n FROM ops").get() as { n: number }).n).toBe(2);
+	});
+
+	test("🔴 a STAGED archive nobody is collecting REFUSES to trim, and says why", () => {
+		for (const d of [40, 35]) insert(daysAgo(d));
+		const staged = target({
+			archive: createJsonlArchive({
+				app: "notes",
+				resource: "sync-history",
+				home: { dir, terminal: false },
+			}),
+			pendingBudgetBytes: 1,
+		});
+		// Seal one segment so there is something uncollected to notice.
+		writeFileSync(join(dir, "sync-history-20260101-000000.jsonl"), "x".repeat(64));
+
+		const report = staged.sweep(resolveRetentionPolicy(historyDecl, { days: 30 }), NOW);
+		expect(report.aged).toBe(0);
+		expect(report.blocked).toMatch(/has not been collected/);
+		expect((db.query("SELECT COUNT(*) AS n FROM ops").get() as { n: number }).n).toBe(2);
+	});
+
+	test("a TERMINAL archive never blocks, however much it holds", () => {
+		for (const d of [40, 35]) insert(daysAgo(d));
+		writeFileSync(join(dir, "sync-history-20260101-000000.jsonl"), "x".repeat(4096));
+		const report = target({ pendingBudgetBytes: 1 }).sweep(
+			resolveRetentionPolicy(historyDecl, { days: 30 }),
+			NOW,
+		);
+		expect(report.blocked).toBeUndefined();
+		expect(report.aged).toBe(2);
+	});
+
+	test("protectWhere and the floor hold, exactly as they do for a deleting target", () => {
+		for (const d of [50, 45, 40, 35]) insert(daysAgo(d));
+		insert(daysAgo(60), "pinned");
+		const report = target({ protectWhere: "ops.kind = 'pinned'" }).sweep(
+			resolveRetentionPolicy({ ...historyDecl, floorItems: 2 }, { days: 30 }),
+			NOW,
+		);
+		expect(report.aged).toBe(2);
+		const kept = db.query("SELECT kind FROM ops ORDER BY seq").all() as Array<{ kind: string }>;
+		expect(kept.map((r) => r.kind)).toEqual(["item.upsert", "item.upsert", "pinned"]);
+	});
+
+	test("🔴 the item-count backstop ARCHIVES too — the overflow path has no unarchived escape", () => {
+		// If the cap could dump rows straight to /dev/null, the one case where the
+		// history is growing fastest is the one case it is destroyed.
+		for (let i = 0; i < 6; i++) insert(daysAgo(1));
+		const report = target().sweep(
+			resolveRetentionPolicy({ ...historyDecl, defaultMaxItems: 2 }, { days: 30 }),
+			NOW,
+		);
+		expect(report.overflow).toBe(4);
+		expect(report.archived).toBe(4);
+		expect(verifyArchive(dir)).toMatchObject({ rows: 4, bad: [] });
+	});
+
+	test("maxBatch drains across sweeps rather than holding years of rows at once", () => {
+		for (let i = 0; i < 10; i++) insert(daysAgo(40));
+		const t = target({ maxBatch: 4 });
+		const policy = resolveRetentionPolicy(historyDecl, { days: 30 });
+		expect(t.sweep(policy, NOW).aged).toBe(4);
+		expect(t.sweep(policy, NOW + 1000).aged).toBe(4);
+		expect(t.sweep(policy, NOW + 2000).aged).toBe(2);
+		expect((db.query("SELECT COUNT(*) AS n FROM ops").get() as { n: number }).n).toBe(0);
+		expect(verifyArchive(dir)).toMatchObject({ rows: 10, bad: [] });
+	});
+
+	test("a sweep with nothing to move seals no segment", () => {
+		insert(daysAgo(1));
+		const report = target().sweep(resolveRetentionPolicy(historyDecl, { days: 30 }), NOW);
+		expect(report.aged).toBe(0);
+		expect(report.archived).toBeUndefined();
+		expect(readdirSync(dir)).toEqual([]);
+	});
+
+	test("a table that does not exist yet is an empty resource, not a boot failure", () => {
+		const fresh = new Database(":memory:");
+		const t = createArchivingSqliteTableTarget({
+			db: fresh,
+			declaration: historyDecl,
+			table: "ops",
+			timeColumn: "at",
+			idColumn: "seq",
+			archive: createJsonlArchive({
+				app: "notes",
+				resource: "sync-history",
+				home: { dir, terminal: true },
+			}),
+		});
+		expect(t.measure()).toEqual({ items: 0 });
+		expect(t.sweep(resolveRetentionPolicy(historyDecl), NOW)).toEqual({
+			at: NOW,
+			aged: 0,
+			overflow: 0,
+		});
+		fresh.close();
+	});
+});