@openparachute/vault 0.7.9-rc.4 → 0.7.9-rc.6

package/core/src/history-import.test.ts

@@ -0,0 +1,82 @@
+import { test, expect } from "bun:test";
+import { Database } from "bun:sqlite";
+import { SqliteStore } from "./store.js";
+import { resolveHistoryPolicy, eraseHistory, getVersion } from "./history.js";
+import { applyImportedNote, beginImportRun, importTargetDigest, getImportedVersion, importStorageIndex, type ImportedObservation } from "./history-import.js";
+
+const run = { run_id: "manifest", source_fingerprint: "source", tip: "tip", options_digest: "options" };
+const rows: ImportedObservation[] = ["older", "newer"].map(content => ({ content, path: "history", metadata: {}, extension: "md", created_at: null, observed_at: "2026-01-01T00:00:00Z", commit: content, blob: content }));
+async function fixture() {
+  const db = new Database(":memory:");
+  const store = new SqliteStore(db);
+  const note = await store.createNote("live", { path: "history" });
+  beginImportRun(db, run);
+  const opts = { run, noteId: note.id, observations: rows, policy: resolveHistoryPolicy({ min_versions: 20 }), now: Date.parse("2026-01-02T00:00:00Z"), targetDigest: importTargetDigest(db, note.id) };
+  return { db, store, note, opts };
+}
+test("import preserves live state and native allocation; refs survive erase without resurrection", async () => {
+  const { db, store, note, opts } = await fixture();
+  try {
+    const result = applyImportedNote(db, opts);
+    expect(result.receipt.retained_count).toBe(2);
+    expect(getImportedVersion(db, note.id, 0)?.content).toBe("newer");
+    expect(getImportedVersion(db, note.id, 1)?.content).toBe("older");
+    expect((await store.getNote(note.id))?.content).toBe("live");
+    await store.updateNote(note.id, { content: "native" });
+    expect(getVersion(db, note.id, 0)?.content).toBe("live");
+    eraseHistory(db, note.id);
+    expect(applyImportedNote(db, opts).skipped).toBe(true);
+    expect(getImportedVersion(db, note.id, 0)).toBeNull();
+    expect(db.query("SELECT count(*) n FROM note_versions").get()).toEqual({ n: 0 });
+    expect(() => applyImportedNote(db, { ...opts, run: { ...run, run_id: "different" } })).toThrow("already owned");
+  } finally { db.close(); }
+});
+test("failed native-drop projection rolls back blobs, references and receipt", async () => {
+  const { db, opts } = await fixture();
+  try {
+    expect(() => applyImportedNote(db, { ...opts, expectedNativeDrops: [123] })).toThrow("deletion set");
+    for (const table of ["history_import_receipts", "history_import_refs", "note_versions", "note_blobs"]) expect(db.query(`SELECT count(*) n FROM ${table}`).get()).toEqual({ n: 0 });
+  } finally { db.close(); }
+});
+test("stale target and oversized note cannot leave a partial import", async () => {
+  const { db, store, note, opts } = await fixture();
+  try {
+    await store.updateNote(note.id, { content: "changed" });
+    expect(() => applyImportedNote(db, opts)).toThrow("Stale");
+    expect(() => applyImportedNote(db, { ...opts, targetDigest: importTargetDigest(db, note.id), observations: [...rows, { ...rows[0]!, content: "x".repeat(2_000_001) }] })).toThrow("Oversized");
+    expect(db.query("SELECT count(*) n FROM history_import_receipts").get()).toEqual({ n: 0 });
+    expect(db.query("SELECT count(*) n FROM note_versions WHERE version_ix<0").get()).toEqual({ n: 0 });
+  } finally { db.close(); }
+});
+test("import allocation rejects unsafe and negative public indices", () => {
+  expect(importStorageIndex(0)).toBe(-1);
+  for (const n of [-1, 0.5, Number.MAX_SAFE_INTEGER, Infinity, NaN]) expect(() => importStorageIndex(n)).toThrow();
+});
+
+test("native allocation starts at zero even when the newest import was removed", async () => {
+  const { db, store, note, opts } = await fixture();
+  try {
+    applyImportedNote(db, opts);
+    db.prepare("DELETE FROM note_versions WHERE note_id=? AND version_ix=-1").run(note.id);
+    await store.updateNote(note.id, { content: "native edit" });
+    expect(getVersion(db, note.id, 0)?.content).toBe("live");
+    expect(getImportedVersion(db, note.id, 1)?.content).toBe("older");
+  } finally { db.close(); }
+});
+
+test("import policy discloses native removals separately and honors disabled retention", async () => {
+  const { db, store, note, opts } = await fixture();
+  try {
+    await store.updateNote(note.id, { content: "first native" });
+    await store.updateNote(note.id, { content: "second native" });
+    const result = applyImportedNote(db, { ...opts, targetDigest: importTargetDigest(db, note.id), policy: resolveHistoryPolicy({ min_versions: 1, max_versions: 1 }), expectedNativeDrops: [0] });
+    expect(result.nativeDrops).toEqual([0]);
+    expect(result.receipt.pruned_native).toBe(1);
+    expect(result.receipt.pruned_imported).toBe(2);
+    expect(getVersion(db, note.id, 1)?.content).toBe("first native");
+    expect((await store.getNote(note.id))?.content).toBe("second native");
+    const other = await store.createNote("other");
+    const disabled = applyImportedNote(db, { ...opts, noteId: other.id, targetDigest: importTargetDigest(db, other.id), policy: resolveHistoryPolicy({ enabled: false, min_versions: 0, max_versions: 1 }) });
+    expect(disabled.receipt.retained_count).toBe(2);
+  } finally { db.close(); }
+});

package/core/src/history-import.ts

@@ -0,0 +1,157 @@
+/** Git-independent import primitives. Callers own source parsing and offline access. */
+import type { Database } from "bun:sqlite";
+import { transaction } from "./txn.js";
+import { HistoryUnrecoverableError, hashContent, byteLength, VERSION_MAX_BYTES, pruneVersions, compactNote, getVersion, type HistoryPolicy, type VersionRow } from "./history.js";
+
+export interface ImportedObservation {
+  content: string;
+  path: string | null;
+  metadata: Record<string, unknown>;
+  extension: string;
+  created_at: string | null;
+  observed_at: string;
+  commit: string;
+  blob: string;
+}
+export interface ImportRun {
+  run_id: string;
+  source_fingerprint: string;
+  tip: string;
+  options_digest: string;
+}
+export interface ImportReceipt {
+  note_id: string;
+  run_id: string;
+  state_digest: string;
+  imported_count: number;
+  retained_count: number;
+  pruned_imported: number;
+  pruned_native: number;
+  completed_at: string;
+}
+export function canonicalJson(value: unknown): string {
+  function ordered(v: unknown): unknown {
+    if (Array.isArray(v)) return v.map(ordered);
+    if (v !== null && typeof v === "object") return Object.fromEntries(Object.entries(v).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, x]) => [k, ordered(x)]));
+    return v;
+  }
+  return JSON.stringify(ordered(value));
+}
+export function importStorageIndex(index: number): number {
+  const storage = -index - 1;
+  if (!Number.isSafeInteger(index) || index < 0 || !Number.isSafeInteger(storage)) throw new Error("Invalid import_ix");
+  return storage;
+}
+export function projectHistoryRow<T extends VersionRow>(row: T): T | (Omit<T, "version_ix"> & { origin: "git-import"; import_ix: number }) {
+  if (row.version_ix >= 0) return row;
+  const { version_ix, ...rest } = row;
+  return { ...rest, origin: "git-import", import_ix: -version_ix - 1 };
+}
+export function getImportedVersion(db: Database, id: string, index: number) {
+  const ix = importStorageIndex(index);
+  if (!db.prepare("SELECT 1 FROM history_import_refs WHERE note_id=? AND import_ix=?").get(id, index)) return null;
+  try {
+    const row = getVersion(db, id, ix);
+    return row?.op === "import" ? row : null;
+  } catch (error) {
+    if (error instanceof HistoryUnrecoverableError) throw new ImportedHistoryUnrecoverableError(id, index, error.reason);
+    throw error;
+  }
+}
+export function beginImportRun(db: Database, run: ImportRun): void {
+  transaction(db, () => {
+    const existing = db.prepare("SELECT run_id,source_fingerprint,tip,options_digest FROM history_import_runs WHERE run_id=?").get(run.run_id);
+    if (existing) {
+      if (canonicalJson(existing) !== canonicalJson(run)) throw new Error("Import run conflicts with its manifest");
+      return;
+    }
+    db.prepare("INSERT INTO history_import_runs VALUES(?,?,?,?, 'applying', ?)").run(run.run_id, run.source_fingerprint, run.tip, run.options_digest, new Date().toISOString());
+  });
+}
+export function readImportReceipt(db: Database, id: string): ImportReceipt | null {
+  return db.prepare("SELECT * FROM history_import_receipts WHERE note_id=?").get(id) as ImportReceipt | null;
+}
+/** Content-addressed global blob changes are excluded from the per-note state fingerprint. */
+export function importTargetDigest(db: Database, id: string): string {
+  return hashContent(canonicalJson({
+    note: db.prepare("SELECT id,content,path,metadata,extension,created_at,updated_at FROM notes WHERE id=?").get(id),
+    versions: db.prepare("SELECT * FROM note_versions WHERE note_id=? ORDER BY version_ix").all(id),
+  }));
+}
+export function importObservationDigest(rows: ImportedObservation[]): string {
+  return hashContent(canonicalJson(rows));
+}
+export function applyImportedNote(db: Database, opts: {
+  run: ImportRun; noteId: string; observations: ImportedObservation[];
+  policy: HistoryPolicy; now: number; targetDigest: string;
+  expectedNativeDrops?: number[];
+}): { receipt: ImportReceipt; nativeDrops: number[]; skipped: boolean } {
+  return transaction(db, () => {
+    const prior = readImportReceipt(db, opts.noteId);
+    const digest = importObservationDigest(opts.observations);
+    if (prior) {
+      if (prior.run_id !== opts.run.run_id || prior.state_digest !== digest) throw new Error("Note already owned by another import; resume its original manifest");
+      return { receipt: prior, nativeDrops: [], skipped: true };
+    }
+    if (!db.prepare("SELECT 1 FROM notes WHERE id=?").get(opts.noteId)) throw new Error("Import requires a live note");
+    if (importTargetDigest(db, opts.noteId) !== opts.targetDigest) throw new Error("Stale import manifest: target note changed");
+    if (!opts.observations.length) throw new Error("Cannot receipt an empty import");
+    if (db.prepare("SELECT 1 FROM note_versions WHERE note_id=? AND version_ix<0").get(opts.noteId)) throw new Error("Unreceipted imported history exists");
+    const nativeBefore = db.prepare("SELECT version_ix FROM note_versions WHERE note_id=? AND version_ix>=0 ORDER BY version_ix").all(opts.noteId) as { version_ix: number }[];
+    const receipt: ImportReceipt = { note_id: opts.noteId, run_id: opts.run.run_id, state_digest: digest, imported_count: opts.observations.length, retained_count: 0, pruned_imported: 0, pruned_native: 0, completed_at: new Date(opts.now).toISOString() };
+    db.prepare("INSERT INTO history_import_receipts VALUES(?,?,?,?,?,?,?,?)").run(receipt.note_id, receipt.run_id, receipt.state_digest, receipt.imported_count, 0, 0, 0, receipt.completed_at);
+    for (let i = 0; i < opts.observations.length; i++) {
+      const row = opts.observations[i]!;
+      const size = byteLength(row.content);
+      if (size > VERSION_MAX_BYTES) throw new Error("Oversized imported observation: quarantine the whole note");
+      const index = opts.observations.length - i - 1;
+      const storage = importStorageIndex(index);
+      const hash = hashContent(row.content);
+      db.prepare("INSERT OR IGNORE INTO note_blobs(hash,content,byte_size) VALUES(?,?,?)").run(hash, row.content, size);
+      db.prepare(`INSERT INTO note_versions(note_id,version_ix,content_hash,path,metadata,extension,superseded_at,actor,via,op,content_len,encoding,created_at)
+        VALUES(?,?,?,?,?,?,?,NULL,'git-import','import',?,NULL,?)`).run(opts.noteId, storage, hash, row.path, canonicalJson(row.metadata), row.extension, row.observed_at, size, row.created_at);
+      db.prepare("INSERT INTO history_import_refs VALUES(?,?,?,?)").run(opts.noteId, index, row.commit, row.blob);
+    }
+    if (opts.policy.enabled) pruneVersions(db, opts.noteId, opts.policy, opts.now);
+    compactNote(db, opts.noteId, opts.policy);
+    const after = new Set((db.prepare("SELECT version_ix FROM note_versions WHERE note_id=?").all(opts.noteId) as { version_ix: number }[]).map(r => r.version_ix));
+    for (let i = 0; i < opts.observations.length; i++) {
+      const index = opts.observations.length - i - 1;
+      if (after.has(importStorageIndex(index)) && getImportedVersion(db, opts.noteId, index)?.content !== opts.observations[i]!.content) throw new Error("Imported content failed verification");
+    }
+    const nativeDrops = nativeBefore.map(r => r.version_ix).filter(ix => !after.has(ix));
+    if (opts.expectedNativeDrops && canonicalJson(nativeDrops) !== canonicalJson(opts.expectedNativeDrops)) throw new Error("Native deletion set differs from final manifest");
+    receipt.retained_count = [...after].filter(ix => ix < 0).length;
+    receipt.pruned_imported = receipt.imported_count - receipt.retained_count;
+    receipt.pruned_native = nativeDrops.length;
+    db.prepare("UPDATE history_import_receipts SET retained_count=?,pruned_imported=?,pruned_native=? WHERE note_id=?").run(receipt.retained_count, receipt.pruned_imported, receipt.pruned_native, opts.noteId);
+    return { receipt, nativeDrops, skipped: false };
+  });
+}
+
+/** Public import errors must not expose the negative storage key, even in prose. */
+export class ImportedHistoryUnrecoverableError extends Error {
+  readonly code = "HISTORY_UNRECOVERABLE";
+  readonly error_type = "history_unrecoverable";
+  readonly origin = "git-import";
+  constructor(readonly note_id: string, readonly import_ix: number, readonly reason: "overflow" | "delta_orphan") {
+    super(`Imported version content is unrecoverable: "${note_id}" import ${import_ix}`);
+    this.name = "ImportedHistoryUnrecoverableError";
+  }
+}
+export function parseHistorySelector(value: { version_ix?: unknown; origin?: unknown; import_ix?: unknown }):
+  { version_ix: number } | { origin: "git-import"; import_ix: number } | null {
+  const imported = value.origin !== undefined || value.import_ix !== undefined;
+  if (imported) {
+    if (value.version_ix !== undefined || value.origin !== "git-import" || typeof value.import_ix !== "number"
+      || !Number.isSafeInteger(value.import_ix) || value.import_ix < 0) throw invalidHistorySelector();
+    importStorageIndex(value.import_ix);
+    return { origin: "git-import", import_ix: value.import_ix };
+  }
+  if (value.version_ix === undefined) return null;
+  if (typeof value.version_ix !== "number" || !Number.isSafeInteger(value.version_ix) || value.version_ix < 0) throw invalidHistorySelector();
+  return { version_ix: value.version_ix };
+}
+function invalidHistorySelector() {
+  return Object.assign(new Error("Specify either a nonnegative version_ix or origin git-import with a nonnegative import_ix"), { error_type: "invalid_request", field: "versions" });
+}

package/core/src/history.test.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { BunSqliteStore } from "./store.js";
+// Keep base runs executable: the absent module makes individual pins RED,
+// rather than aborting collection for the entire file.
+const history = await import("./history.js").catch(() => null);
+let db: Database;
+let store: BunSqliteStore;
+beforeEach(() => {
+  db = new Database(":memory:");
+  store = new BunSqliteStore(db);
+});
+afterEach(() => db.close());
+const count = (table: "note_versions" | "note_blobs") =>
+  (db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get() as { n: number }).n;
+
+describe("vault#524 history retention and blob integrity", () => {
+  it("P2 metadata flips share one 116 KB body after the first capture", async () => {
+    const body = "é".repeat(58_000);
+    const n = await store.createNote(body, { path: "p" });
+    await store.updateNote(n.id, { metadata: { status: 1 } });
+    const bytes = (
+      db.prepare("SELECT SUM(byte_size) AS n FROM note_blobs").get() as {
+        n: number;
+      }
+    ).n;
+    let previous = (await store.listNoteVersions(n.id))[0]!;
+    for (let i = 2; i <= 5; i++) {
+      await store.updateNote(n.id, { metadata: { status: i } });
+      expect(count("note_blobs")).toBe(1);
+      expect(
+        (
+          db.prepare("SELECT SUM(byte_size) AS n FROM note_blobs").get() as {
+            n: number;
+          }
+        ).n,
+      ).toBe(bytes);
+      const rows = await store.listNoteVersions(n.id);
+      expect(rows).toHaveLength(i);
+      expect(rows[0]!.content_hash).toBe(previous.content_hash);
+      expect(rows[0]!.content_len).toBe(116_000);
+      previous = rows[0]!;
+    }
+    const size = db
+      .prepare(
+        `SELECT LENGTH(CAST(path AS BLOB))+LENGTH(CAST(metadata AS BLOB))+LENGTH(CAST(extension AS BLOB))+
+      LENGTH(CAST(superseded_at AS BLOB))+LENGTH(CAST(COALESCE(actor,'') AS BLOB))+LENGTH(CAST(COALESCE(via,'') AS BLOB))+
+      LENGTH(CAST(op AS BLOB))+LENGTH(CAST(content_hash AS BLOB))+32 AS n FROM note_versions WHERE note_id=? AND version_ix=4`,
+      )
+      .get(n.id) as { n: number };
+    expect(size.n).toBeLessThan(1024);
+  });
+  for (const [edits, age, expected, minIx] of [
+    [4, 1, 4, 0],
+    [8, 1, 5, 3],
+    [2, 0, 2, 0],
+    [9, 0, 3, 6],
+  ]) {
+    it(`P3 retention arithmetic ${edits} edits age ${age}`, async () => {
+      store = new BunSqliteStore(db, {
+        history: { min_versions: 3, max_versions: 5, max_age_days: age },
+      });
+      const n = await store.createNote("start");
+      for (let i = 0; i < edits!; i++) {
+        await store.updateNote(n.id, { content: String(i) });
+        await new Promise((r) => setTimeout(r, 2));
+      }
+      const row = db
+        .prepare(
+          "SELECT COUNT(*) AS n, MIN(version_ix) AS lo, MAX(version_ix) AS hi FROM note_versions WHERE note_id=?",
+        )
+        .get(n.id) as { n: number; lo: number; hi: number };
+      expect(row).toEqual({ n: expected, lo: minIx, hi: edits! - 1 });
+    });
+  }
+  it("P6 shared blobs survive pruning and vanish only after the last reference", async () => {
+    const a = await store.createNote("shared"),
+      b = await store.createNote("shared");
+    await store.updateNote(a.id, { content: "a" });
+    await store.updateNote(b.id, { content: "b" });
+    expect(count("note_blobs")).toBe(1);
+    const hash = (await store.listNoteVersions(a.id))[0]!.content_hash;
+    expect(() =>
+      db.prepare("DELETE FROM note_blobs WHERE hash=?").run(hash),
+    ).toThrow(/FOREIGN KEY/);
+    db.prepare("UPDATE note_versions SET superseded_at=? WHERE note_id=?").run(
+      "2000-01-01T00:00:00.000Z",
+      a.id,
+    );
+    history!.pruneVersions(
+      db,
+      a.id,
+      history!.resolveHistoryPolicy({
+        min_versions: 0,
+        max_versions: 1,
+        max_age_days: 1,
+      }),
+    );
+    expect(count("note_versions")).toBe(1);
+    expect(count("note_blobs")).toBe(1);
+    await store.eraseNoteHistory(b.id);
+    expect(count("note_blobs")).toBe(0);
+  });
+  it("P7a null deleted retention issues no query and keeps history", async () => {
+    const n = await store.createNote("one");
+    await store.updateNote(n.id, { content: "two" });
+    await store.deleteNote(n.id);
+    const before = count("note_versions");
+    const probe = new Proxy(db, {
+      get(target, key) {
+        if (key === "prepare") throw new Error("query attempted");
+        return Reflect.get(target, key);
+      },
+    });
+    expect(
+      history!.sweepDeletedHistory(probe, history!.resolveHistoryPolicy()),
+    ).toEqual({ notesSwept: 0, versionsDeleted: 0, blobsDeleted: 0 });
+    expect(count("note_versions")).toBe(before);
+  });
+  it("P7b sweeps old deleted chains and preserves recent deleted and live chains", async () => {
+    store = new BunSqliteStore(db, { history: { deleted_retention_days: 7 } });
+    const old = await store.createNote("old"),
+      recent = await store.createNote("recent"),
+      live = await store.createNote("live");
+    await store.deleteNote(old.id);
+    await store.deleteNote(recent.id);
+    await store.updateNote(live.id, { content: "now" });
+    db.prepare(
+      "UPDATE note_versions SET superseded_at='2000-01-01T00:00:00.000Z' WHERE note_id IN (?,?)",
+    ).run(old.id, live.id);
+    expect(store.sweepDeletedHistory()).toEqual({
+      notesSwept: 1,
+      versionsDeleted: 1,
+      blobsDeleted: 1,
+    });
+    expect(await store.listNoteVersions(old.id)).toHaveLength(0);
+    expect(await store.listNoteVersions(recent.id)).toHaveLength(1);
+    expect(await store.listNoteVersions(live.id)).toHaveLength(1);
+  });
+  it("P7c tombstones survive the version ceiling", async () => {
+    store = new BunSqliteStore(db, {
+      history: { min_versions: 0, max_versions: 1 },
+    });
+    const n = await store.createNote("a");
+    await store.deleteNote(n.id);
+    await store.createNote("b", { id: n.id });
+    await store.updateNote(n.id, { content: "c" });
+    expect((await store.listNoteVersions(n.id)).map((v) => v.op)).toEqual([
+      "update",
+      "delete",
+    ]);
+  });
+  it("P13 oversized prior body rejects update with no partial history", async () => {
+    const content = "é".repeat(1_000_001),
+      n = await store.createNote(content);
+    await expect(
+      store.updateNote(n.id, { content: "small" }),
+    ).rejects.toMatchObject({ code: "HISTORY_OVERFLOW" });
+    expect((await store.getNote(n.id))!.content).toBe(content);
+    expect(count("note_versions")).toBe(0);
+    expect(count("note_blobs")).toBe(0);
+  });
+  it("P19a/b oversized delete records size and attribution without a blob", async () => {
+    const content = "é".repeat(1_000_001),
+      n = await store.createNote(content);
+    await expect(
+      store.updateNote(n.id, { content: "x" }),
+    ).rejects.toMatchObject({ code: "HISTORY_OVERFLOW" });
+    await store.deleteNote(n.id, { actor: "a", via: "v" });
+    expect(await store.getNote(n.id)).toBeNull();
+    expect(count("note_blobs")).toBe(0);
+    expect(await store.getNoteVersion(n.id, 0)).toMatchObject({
+      op: "delete",
+      content_hash: null,
+      encoding: "overflow",
+      content: null,
+      content_len: 2_000_002,
+      actor: "a",
+      via: "v",
+    });
+  });
+  it("P19d NULL overflow hash cannot poison full blob GC", async () => {
+    const n = await store.createNote("x".repeat(2_000_001));
+    await store.deleteNote(n.id);
+    const second = await store.createNote("orphan");
+    await store.updateNote(second.id, { content: "new" });
+    db.prepare("DELETE FROM note_versions WHERE note_id=?").run(second.id);
+    expect(count("note_blobs")).toBe(1);
+    const third = await store.createNote("third");
+    await store.eraseNoteHistory(third.id);
+    expect(count("note_blobs")).toBe(0);
+    expect(count("note_versions")).toBe(1);
+  });
+  it("P21 clamp preserves the 100-version floor without unbounded growth", async () => {
+    expect(
+      history!.resolveHistoryPolicy({ min_versions: 100, max_versions: 20 })
+        .max_versions,
+    ).toBe(100);
+    store = new BunSqliteStore(db, {
+      history: { min_versions: 100, max_versions: 20 },
+    });
+    const n = await store.createNote("0");
+    for (let i = 0; i < 150; i++)
+      await store.updateNote(n.id, { content: String(i) });
+    expect(count("note_versions")).toBe(100);
+  });
+  it("P21 zero ceiling keeps the newest version and absurd ages cannot break writes", async () => {
+    const policy = history!.resolveHistoryPolicy({
+      min_versions: 0,
+      max_versions: 0,
+      max_age_days: 200000000,
+      deleted_retention_days: 200000000,
+    });
+    expect(policy).toMatchObject({
+      max_versions: 1,
+      max_age_days: 36500,
+      deleted_retention_days: 36500,
+    });
+    store = new BunSqliteStore(db, { history: policy });
+    const n = await store.createNote("first");
+    await store.updateNote(n.id, { content: "second" });
+    await store.updateNote(n.id, { content: "third" });
+    expect(await store.listNoteVersions(n.id)).toHaveLength(1);
+    expect((await store.getNoteVersion(n.id, 1))!.content).toBe("second");
+    await store.deleteNote(n.id);
+    history!.sweepDeletedHistory(db, policy);
+    expect(await store.getNote(n.id)).toBeNull();
+  });
+});