Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.
JavaScript aianthropiccross-platformgeminigroqlinuxmacosnvidiaopen-sourceopenaiparakeetspeech-to-texttranscribewhisperwindows
// Whole-pass kill chains: the real SyncService drives the real service stack over
// one real SQLite database per device, with the fake cloud as the only boundary.
// Each scenario is a story a user could tell end to end, and every one of them
// finishes on the content-regression invariant.
const test = require("node:test");
const assert = require("node:assert/strict");
const { createDb } = require("./harness/db.js");
const {
installBrowserGlobals,
resetBrowserGlobals,
establishValidatedAuth,
stopSyncTimers,
localStorage: browserLocalStorage,
window: browserWindow,
} = require("./harness/browserGlobals.js");
const { createElectronApi } = require("./harness/electronApiBridge.js");
const { createFakeCloud } = require("./harness/fakeCloud.js");
const { assertNoContentRegression, snapshotNotes } = require("./harness/invariants.js");
const { SyncService } = require("../../src/services/SyncService.ts");
installBrowserGlobals();
// Mirrors BATCH_SIZE in SyncService.ts.
const BATCH_SIZE = 50;
const CAN_SYNC = { isSignedIn: "true", cloudBackupEnabled: "true", isSubscribed: "true" };
// SQLite's datetime() shape, which is what local rows actually carry. Every
// timestamp in this file is pinned by SQL; nothing here waits or fakes a clock.
const T_SHELL = "2026-07-20 10:00:00";
const T_TRANSCRIPT = "2026-07-20 11:00:00";
const T_PEER = "2026-07-20 13:00:00";
const T_FUTURE = "2027-01-01 00:00:00";
// S2 keeps its sync cursors across every relaunch, so its edits have to be newer
// than the wall-clock stamp a completed pass leaves behind, as real edits are.
const F_SHELL = "2027-03-01 10:00:00";
const F_TITLE = "2027-03-01 10:30:00";
const F_TRANSCRIPT = "2027-03-01 11:00:00";
function iso(sqliteTimestamp) {
return `${sqliteTimestamp.replace(" ", "T")}.000Z`;
}
function shift(isoString, hours) {
return new Date(Date.parse(isoString) + hours * 3600_000).toISOString();
}
function queryParam(path, name) {
const [, query] = path.split("?");
return new URLSearchParams(query ?? "").get(name);
}
function silenceConsoleErrors(t) {
t.mock.method(console, "error", () => {});
}
// The incident's payload was a real meeting transcript, not a token string; a
// small body would not exercise the same batch and clone paths.
function largeBody(label) {
return `${label} speaker turn long enough to make the payload realistic. `.repeat(1000);
}
function readStorage() {
const values = {};
for (let i = 0; i < browserLocalStorage.length; i += 1) {
const key = browserLocalStorage.key(i);
values[key] = browserLocalStorage.getItem(key);
}
return values;
}
function writeStorage(values) {
browserLocalStorage.clear();
for (const [key, value] of Object.entries(values)) browserLocalStorage.setItem(key, value);
}
function freshCloud(config) {
resetBrowserGlobals();
return createFakeCloud(config);
}
// One machine: its own SQLite file and its own localStorage, sharing the cloud.
// Devices never see each other's cursors, which is the whole point of S2.
function createDevice(t, cloud) {
const db = createDb(t);
if (!db) return null;
return { db, api: createElectronApi(db, { cloud }), storage: { ...CAN_SYNC } };
}
// One app launch: the device's stored localStorage comes back, its IPC surface is
// installed, and a brand new SyncService runs against them.
async function launch(device, body) {
writeStorage(device.storage);
browserWindow.electronAPI = device.api;
// Every launch re-validates the session, exactly as the renderer does.
await establishValidatedAuth();
const service = new SyncService();
try {
return await body(service);
} finally {
stopSyncTimers(service);
device.storage = readStorage();
}
}
function syncOnce(device) {
return launch(device, (service) => service.syncAll(true));
}
// A relaunch onto a wiped profile: the database survives, every sync cursor is
// gone, so the next pull starts from the full snapshot again.
function wipeCursors(device) {
device.storage = { ...CAN_SYNC };
}
function setNoteRow(db, id, columns) {
const keys = Object.keys(columns);
db.db
.prepare(`UPDATE notes SET ${keys.map((k) => `${k} = ?`).join(", ")} WHERE id = ?`)
.run(...keys.map((k) => columns[k]), id);
return db.getNote(id);
}
function noteByClientId(db, clientNoteId) {
return db.db.prepare("SELECT * FROM notes WHERE client_note_id = ?").get(clientNoteId) ?? null;
}
function noteCount(db) {
return db.db.prepare("SELECT COUNT(*) AS c FROM notes").get().c;
}
function folderByName(db, name) {
return db.db.prepare("SELECT * FROM folders WHERE name = ?").get(name) ?? null;
}
// A local row already bound to a cloud note, exactly as an earlier pull left it.
function linkLocalNote(db, cloudRow, title, content) {
const local = db.saveNote(title, content, "personal").note;
return setNoteRow(db, local.id, {
client_note_id: cloudRow.client_note_id,
cloud_id: cloudRow.id,
sync_status: "synced",
created_at: cloudRow.created_at,
updated_at: cloudRow.updated_at,
});
}
test("S1 a meeting shell that gains a large transcript survives a relaunch and reaches the cloud", async (t) => {
const cloud = freshCloud();
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
// Byte-faithful to meetingDetectionEngine.js: saveNote(eventSummary, "", "meeting").
const eventSummary = "Weekly Product Sync";
const shell = db.saveNote(eventSummary, "", "meeting").note;
setNoteRow(db, shell.id, { created_at: T_SHELL, updated_at: T_SHELL });
await syncOnce(device);
const cloudId = db.getNote(shell.id).cloud_id;
assert.ok(cloudId, "the shell must reach the cloud on the first pass");
assert.equal(cloud.note(cloudId).content, "", "the shell goes up empty, because it is empty");
// Transcription lands after the shell was already synced, so the row is pending
// again while carrying a cloud_id. That combination is the migration shape.
const content = largeBody("cleaned");
const transcript = largeBody("raw");
assert.ok(content.length > 60000, "the payload must be the incident's size");
db.updateNote(shell.id, { content, transcript });
setNoteRow(db, shell.id, { updated_at: T_TRANSCRIPT });
assert.equal(db.getNote(shell.id).sync_status, "pending");
const before = snapshotNotes(db);
wipeCursors(device);
await launch(device, async (service) => {
await service.syncAll(true);
await service.syncAll(true);
});
const row = db.getNote(shell.id);
assert.equal(row.content, content, "the local body must survive the relaunch untouched");
assert.equal(row.transcript, transcript);
assert.equal(row.title, eventSummary);
assert.equal(row.sync_status, "synced");
assert.equal(row.cloud_id, cloudId, "the note keeps its cloud identity across the relaunch");
const remote = cloud.note(cloudId);
assert.equal(remote.content, content, "the cloud must end up holding the transcript");
assert.equal(remote.transcript, transcript);
assert.equal(cloud.notes().length, 1, "two passes must not fork a second cloud note");
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});
test("S1 the same migration holds the line on a legacy cloud with a stale peer overwriting it", async (t) => {
const cloud = freshCloud({
materialPatchGate: false,
coalesceOnConflict: false,
staleWriteGuard: false,
updatedAtClamp: false,
});
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
const shell = db.saveNote("Weekly Product Sync", "", "meeting").note;
setNoteRow(db, shell.id, { created_at: T_SHELL, updated_at: T_SHELL });
await syncOnce(device);
const cloudId = db.getNote(shell.id).cloud_id;
assert.ok(cloudId);
const content = largeBody("cleaned");
const transcript = largeBody("raw");
db.updateNote(shell.id, { content, transcript });
setNoteRow(db, shell.id, { updated_at: T_TRANSCRIPT });
wipeCursors(device);
await syncOnce(device);
assert.equal(
cloud.note(cloudId).content,
content,
"the client's full-content PATCH must not depend on the server's no-op gate"
);
// A second device still on the pre-fix build pushes its own copy of the shell:
// empty, and on a legacy server that write lands and wins the timestamp.
const peer = await cloud.request({
method: "PATCH",
path: "/api/notes/update",
body: { id: cloudId, content: "", transcript: null, updated_at: iso(T_PEER) },
});
assert.equal(peer.success, true);
assert.equal(cloud.note(cloudId).content, "", "the legacy server accepted the empty overwrite");
const before = snapshotNotes(db);
wipeCursors(device);
await syncOnce(device);
const row = db.getNote(shell.id);
assert.equal(
row.content,
content,
"a strictly newer but empty cloud copy must never replace local text"
);
assert.equal(
row.transcript,
transcript,
"an absent cloud transcript must not blank the local one"
);
assert.equal(row.updated_at, iso(T_PEER), "the row still accepts the newer copy's timestamp");
assert.equal(row.sync_status, "synced");
// The cloud copy stays lost here: recovering it is what the server-side
// hardening is for, and the desktop's job is to keep the user's text.
assert.equal(cloud.note(cloudId).content, "");
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});
test("S2 two devices: an older empty shell never destroys the transcript and the clash surfaces as a conflict", async (t) => {
const cloud = freshCloud();
const deviceA = createDevice(t, cloud);
if (!deviceA) return;
const deviceB = createDevice(t, cloud);
if (!deviceB) return;
const shell = deviceA.db.saveNote("Weekly Product Sync", "", "meeting").note;
setNoteRow(deviceA.db, shell.id, { created_at: F_SHELL, updated_at: F_SHELL });
await syncOnce(deviceA);
const clientNoteId = deviceA.db.getNote(shell.id).client_note_id;
const cloudId = deviceA.db.getNote(shell.id).cloud_id;
await syncOnce(deviceB);
const pulled = noteByClientId(deviceB.db, clientNoteId);
assert.ok(pulled, "device B must receive the shell through the cloud");
assert.equal(pulled.content, "");
assert.equal(pulled.cloud_id, cloudId);
// B does the recording, so B is the device that actually holds the transcript.
const content = largeBody("device B cleaned");
deviceB.db.updateNote(pulled.id, { content });
setNoteRow(deviceB.db, pulled.id, { updated_at: F_TRANSCRIPT });
await syncOnce(deviceB);
assert.equal(cloud.note(cloudId).content, content, "B's transcript must reach the cloud");
// Meanwhile A, still holding the empty shell, renames it. That re-queues A's row
// as pending with no content and a basis older than B's upload.
deviceA.db.updateNote(shell.id, { title: "Weekly Product Sync (rescheduled)" });
setNoteRow(deviceA.db, shell.id, { updated_at: F_TITLE });
const beforeA = snapshotNotes(deviceA.db);
const mark = cloud.log.length;
await syncOnce(deviceA);
const patches = cloud.log
.slice(mark)
.filter((c) => c.method === "PATCH" && c.path === "/api/notes/update");
assert.equal(patches.length, 1, "A must attempt exactly one push for its stale shell");
assert.equal(
patches[0].body.content,
undefined,
"A's empty body is unconfirmed, so it is left out rather than offered as a clear"
);
assert.equal(
patches[0].body.updated_at,
F_TITLE,
"the push must carry A's own older basis, or nothing can reject it as stale"
);
assert.equal(cloud.note(cloudId).content, content, "B's transcript must still be in the cloud");
// A's unpushed rename collided with B's newer cloud copy: the pass surfaces a
// conflict and leaves both sides intact until the user picks Keep or Refresh,
// instead of silently electing a winner.
const rowA = deviceA.db.getNote(shell.id);
assert.equal(rowA.content, "", "A's local row is not silently overwritten");
assert.equal(rowA.title, "Weekly Product Sync (rescheduled)", "A keeps its unpushed rename");
assert.notEqual(rowA.sync_status, "synced", "the row must not settle while the conflict is open");
const conflicts = JSON.parse(deviceA.storage["noteConflicts.clientIds"] ?? "{}");
assert.ok(conflicts[clientNoteId], "the conflict must be surfaced for this note");
assert.equal(
conflicts[clientNoteId].content,
content,
"the registry holds B's cloud copy for the Refresh choice"
);
// The conflicted row is gated from later pushes, so A can never clobber B.
const mark2 = cloud.log.length;
await syncOnce(deviceA);
assert.equal(
cloud.log.slice(mark2).filter((c) => c.method === "PATCH" && c.path === "/api/notes/update")
.length,
0,
"a conflicted row must not be re-pushed before the user resolves it"
);
assert.equal(cloud.note(cloudId).content, content);
const beforeB = snapshotNotes(deviceB.db);
await syncOnce(deviceB);
assert.equal(noteByClientId(deviceB.db, clientNoteId).content, content, "B keeps its own text");
assertNoContentRegression(beforeA, snapshotNotes(deviceA.db), cloud.notes());
assertNoContentRegression(beforeB, snapshotNotes(deviceB.db), cloud.notes());
});
test("S3 a delete travels to the cloud and back down to the other device", async (t) => {
const cloud = freshCloud();
const deviceA = createDevice(t, cloud);
if (!deviceA) return;
const deviceB = createDevice(t, cloud);
if (!deviceB) return;
const note = deviceA.db.saveNote("Shared note", "shared body", "personal").note;
setNoteRow(deviceA.db, note.id, { created_at: T_SHELL, updated_at: T_SHELL });
await syncOnce(deviceA);
const clientNoteId = deviceA.db.getNote(note.id).client_note_id;
const cloudId = deviceA.db.getNote(note.id).cloud_id;
await syncOnce(deviceB);
assert.ok(noteByClientId(deviceB.db, clientNoteId), "B must have the note before it is deleted");
const bCursor = deviceB.storage["lastSyncedAt.notes"];
assert.ok(bCursor, "B's first pass must leave a delta cursor");
// The server stamps the tombstone; wall-clock would land in B's cursor
// millisecond and the delta page would then hide it.
cloud.setClock(() => shift(bCursor, 1));
deviceA.db.deleteNote(note.id);
const beforeA = snapshotNotes(deviceA.db);
await syncOnce(deviceA);
const deletes = cloud.logFor("/api/notes/delete");
assert.equal(deletes.length, 1, "the delete must reach the cloud exactly once");
assert.deepEqual(deletes[0].body, { id: cloudId });
assert.equal(deviceA.db.getNote(note.id), null, "A drops the row only after the cloud ack");
assert.ok(cloud.note(cloudId).deleted_at, "the cloud row must be tombstoned");
const beforeB = snapshotNotes(deviceB.db);
const mark = cloud.log.length;
await syncOnce(deviceB);
const lists = cloud.log.slice(mark).filter((c) => c.path.split("?")[0] === "/api/notes/list");
assert.equal(
queryParam(lists[0].path, "since"),
bCursor,
"only the delta page carries tombstones, so B must send its cursor"
);
assert.equal(noteByClientId(deviceB.db, clientNoteId), null, "the delete must reach B");
assert.equal(noteCount(deviceB.db), 0);
assertNoContentRegression(beforeA, snapshotNotes(deviceA.db), cloud.notes());
assertNoContentRegression(beforeB, snapshotNotes(deviceB.db), cloud.notes());
});
test("S3 a delete racing an unsynced edit is won by the cloud tombstone", async (t) => {
const cloud = freshCloud();
const deviceA = createDevice(t, cloud);
if (!deviceA) return;
const deviceB = createDevice(t, cloud);
if (!deviceB) return;
const note = deviceA.db.saveNote("Contested note", "original body", "personal").note;
setNoteRow(deviceA.db, note.id, { created_at: T_SHELL, updated_at: T_SHELL });
await syncOnce(deviceA);
const clientNoteId = deviceA.db.getNote(note.id).client_note_id;
const cloudId = deviceA.db.getNote(note.id).cloud_id;
await syncOnce(deviceB);
const onB = noteByClientId(deviceB.db, clientNoteId);
assert.ok(onB);
const bCursor = deviceB.storage["lastSyncedAt.notes"];
// B edits while offline; A deletes and gets to the cloud first.
deviceB.db.updateNote(onB.id, { content: "B's late edit that never shipped" });
setNoteRow(deviceB.db, onB.id, { updated_at: T_TRANSCRIPT });
cloud.setClock(() => shift(bCursor, 1));
deviceA.db.deleteNote(note.id);
await syncOnce(deviceA);
assert.ok(cloud.note(cloudId).deleted_at);
const beforeB = snapshotNotes(deviceB.db);
const mark = cloud.log.length;
await syncOnce(deviceB);
const patches = cloud.log
.slice(mark)
.filter((c) => c.method === "PATCH" && c.path === "/api/notes/update");
assert.equal(patches.length, 1, "B still tries to push its edit onto the tombstoned row");
assert.equal(patches[0].body.content, "B's late edit that never shipped");
// Documented current behaviour, not a preference: the tombstone wins and the
// edit that never reached the cloud is destroyed.
assert.equal(noteByClientId(deviceB.db, clientNoteId), null, "the tombstone removes B's row");
assert.equal(noteCount(deviceB.db), 0);
assert.ok(cloud.note(cloudId).deleted_at, "the cloud row stays deleted");
assertNoContentRegression(beforeB, snapshotNotes(deviceB.db), cloud.notes());
});
test("S4 a quit before the push loses nothing and the next launch uploads the note", async (t) => {
const cloud = freshCloud();
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
const note = db.saveNote(
"Recorded then quit",
"body written just before the quit",
"personal"
).note;
setNoteRow(db, note.id, { created_at: T_SHELL, updated_at: T_SHELL });
assert.equal(cloud.log.length, 0, "the quit happened before any request went out");
const before = snapshotNotes(db);
wipeCursors(device);
await syncOnce(device);
const row = db.getNote(note.id);
assert.equal(row.sync_status, "synced", "the pending row must be picked up on the next launch");
assert.ok(row.cloud_id);
assert.equal(cloud.note(row.cloud_id).content, "body written just before the quit");
await syncOnce(device);
assert.equal(cloud.notes().length, 1, "a second launch must not upload the note again");
assert.equal(cloud.logFor("/api/notes/batch-create").length, 1, "and must not re-push it");
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});
test("S4 a quit between the cloud ack and the local mark does not fork a duplicate", async (t) => {
const cloud = freshCloud();
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
const note = db.saveNote("Acked but unmarked", "body the cloud already has", "personal").note;
setNoteRow(db, note.id, { created_at: T_SHELL, updated_at: T_SHELL });
// The crash window: the cloud accepted the batch, then the process died before
// markNoteSynced ran, so the row is still pending with no cloud_id.
const pending = db.getPendingNotes();
assert.equal(pending.length, 1);
const acked = await cloud.request({
method: "POST",
path: "/api/notes/batch-create",
body: {
notes: [
{
client_note_id: pending[0].client_note_id,
title: pending[0].title,
content: pending[0].content,
created_at: pending[0].created_at,
updated_at: pending[0].updated_at,
},
],
},
});
const orphanCloudId = acked.data.created[0].id;
assert.equal(db.getNote(note.id).cloud_id, null);
const before = snapshotNotes(db);
wipeCursors(device);
await syncOnce(device);
assert.equal(cloud.notes().length, 1, "the retry must re-use the stable client id, not fork");
const row = db.getNote(note.id);
assert.equal(
row.cloud_id,
orphanCloudId,
"the local row must adopt the already-created cloud row"
);
assert.equal(row.sync_status, "synced");
assert.equal(row.content, "body the cloud already has");
assert.equal(noteCount(db), 1, "the pull must not insert a second local copy either");
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});
test("S4 a 500 mid-batch leaves error rows that the next pass retries on its own", async (t) => {
const cloud = freshCloud();
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
for (let i = 0; i < BATCH_SIZE + 3; i += 1) {
const saved = db.saveNote(`Note ${i}`, `body ${i}`, "personal").note;
setNoteRow(db, saved.id, { created_at: T_SHELL, updated_at: T_SHELL });
}
const doomed = db.getPendingNotes().slice(BATCH_SIZE);
assert.equal(doomed.length, 3);
// Only the trailing chunk is short, so this fires on the second request alone.
cloud.failNext(
(call) => call.path === "/api/notes/batch-create" && call.body?.notes?.length === 3,
{ status: 500, error: "chunk rejected" }
);
const before = snapshotNotes(db);
await syncOnce(device);
for (const note of doomed) {
assert.equal(db.getNote(note.id).sync_status, "error");
}
assert.equal(cloud.notes().length, BATCH_SIZE, "only the healthy chunk landed");
// Errored rows are pushable again on the very next pass: the retry needs no
// re-edit, and its chunk carries exactly the rows that failed.
await syncOnce(device);
const batches = cloud.logFor("/api/notes/batch-create");
assert.equal(batches.length, 3, "the next pass must retry the failed chunk");
assert.equal(batches[2].body.notes.length, 3, "only the errored rows go out again");
for (const note of doomed) {
const row = db.getNote(note.id);
assert.equal(row.sync_status, "synced", "a clean retry settles the row");
assert.ok(row.cloud_id, "the retried row gains its cloud identity");
assert.equal(row.content, note.content, "the local body survives the error round-trip");
}
assert.equal(cloud.notes().length, BATCH_SIZE + 3, "every note reaches the cloud in the end");
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});
test("S5 a snapshot pull of exactly BATCH_SIZE notes still asks for the page after it", async (t) => {
const cloud = freshCloud();
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
const base = Date.parse("2026-07-20T08:00:00.000Z");
const seeded = [];
for (let i = 0; i < BATCH_SIZE; i += 1) {
const at = new Date(base + i * 60000).toISOString();
seeded.push(
cloud.seedNote({
client_note_id: `cn-${String(i).padStart(3, "0")}`,
title: `Cloud note ${i}`,
content: `cloud body ${i}`,
created_at: at,
updated_at: at,
})
);
}
const before = snapshotNotes(db);
await syncOnce(device);
const lists = cloud.logFor("/api/notes/list");
assert.equal(
lists.length,
2,
"a full last page is indistinguishable from a full middle one, so the pull must probe again"
);
assert.equal(queryParam(lists[0].path, "before"), null);
assert.equal(
queryParam(lists[1].path, "before"),
seeded[0].created_at,
"the probe must carry the oldest row of the full page as its cursor"
);
assert.equal(noteCount(db), BATCH_SIZE, "every seeded note must be applied exactly once");
assert.equal(noteByClientId(db, "cn-000").content, "cloud body 0");
assert.equal(noteByClientId(db, "cn-049").content, "cloud body 49");
assert.ok(device.storage["lastSyncedAt.notes"], "a clean pull stamps the cursor");
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});
test("S5 a tombstone as the last row of a delta page still hands the next page a cursor", async (t) => {
const cloud = freshCloud();
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
const cursor = "2026-07-20T07:00:00.000Z";
const base = Date.parse("2026-07-20T08:00:00.000Z");
const seeded = [];
for (let i = 0; i < BATCH_SIZE + 10; i += 1) {
const at = new Date(base + i * 60000).toISOString();
seeded.push(
cloud.seedNote({
client_note_id: `cn-${String(i).padStart(3, "0")}`,
title: `Cloud note ${i}`,
content: `cloud body ${i}`,
created_at: at,
updated_at: at,
})
);
}
const boundary = seeded[BATCH_SIZE - 1];
const local = linkLocalNote(db, boundary, "Boundary note", "local boundary body");
// Pinning the server clock to the row's own stamp keeps the tombstone in the
// last slot of page one instead of sorting it to the end of the delta.
cloud.setClock(() => boundary.updated_at);
await cloud.request({ method: "DELETE", path: "/api/notes/delete", body: { id: boundary.id } });
cloud.setClock(() => new Date().toISOString());
device.storage["lastSyncedAt.notes"] = cursor;
const before = snapshotNotes(db);
await syncOnce(device);
const lists = cloud.logFor("/api/notes/list");
assert.equal(lists.length, 2, "60 delta rows at a page size of 50 must take two requests");
assert.equal(queryParam(lists[0].path, "since"), cursor);
assert.equal(
queryParam(lists[1].path, "since"),
boundary.updated_at,
"a tombstone in the last slot must still supply the next cursor"
);
assert.equal(db.getNote(local.id), null, "the boundary tombstone must delete the local row");
assert.equal(
noteByClientId(db, "cn-059").content,
"cloud body 59",
"the page after the tombstone must still be applied"
);
assert.equal(noteCount(db), BATCH_SIZE + 9, "every row but the tombstoned one must be local");
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});
// A full delta page whose rows all carry the cursor's own updated_at trips the
// stall guard in pullNotes and silently skips everything past that page.
test.todo("S5 a full delta page tied on updated_at must not abandon the rest of the pull");
test("S6 a fresh device adopts the cloud's default folders and both note directions land in them", async (t) => {
const cloud = freshCloud();
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
const cloudPersonal = cloud.seedFolder({
client_folder_id: "cf-personal",
name: "Personal",
is_default: true,
sort_order: 0,
});
const cloudMeetings = cloud.seedFolder({
client_folder_id: "cf-meetings",
name: "Meetings",
is_default: true,
sort_order: 1,
});
cloud.seedNote({
client_note_id: "cn-remote",
title: "Meeting from the other device",
content: "remote meeting body",
folder_id: cloudMeetings.id,
created_at: iso(T_SHELL),
updated_at: iso(T_SHELL),
});
const localMeeting = db.saveNote(
"Meeting from this device",
"local meeting body",
"meeting"
).note;
setNoteRow(db, localMeeting.id, { created_at: T_SHELL, updated_at: T_SHELL });
const before = snapshotNotes(db);
await syncOnce(device);
const meetings = folderByName(db, "Meetings");
assert.equal(
meetings.cloud_id,
cloudMeetings.id,
"the local default must adopt the cloud folder"
);
assert.equal(meetings.client_folder_id, "cf-meetings");
assert.equal(folderByName(db, "Personal").cloud_id, cloudPersonal.id);
assert.equal(
cloud.folders().filter((f) => f.name === "Meetings").length,
1,
"adoption exists so a second device never forks a duplicate folder"
);
const [batch] = cloud.logFor("/api/notes/batch-create");
assert.equal(
batch.body.notes[0].folder_id,
cloudMeetings.id,
"the pushed note must carry the adopted cloud folder id, never the local integer"
);
assert.notEqual(batch.body.notes[0].folder_id, meetings.id);
assert.equal(
noteByClientId(db, "cn-remote").folder_id,
meetings.id,
"the pulled note must map back onto the same local folder"
);
assert.equal(noteByClientId(db, localMeeting.client_note_id).folder_id, meetings.id);
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});
test("S6 a note in a never-synced folder pushes without one and re-pushes once the folder is mapped", async (t) => {
const cloud = freshCloud();
const device = createDevice(t, cloud);
if (!device) return;
const { db } = device;
silenceConsoleErrors(t);
cloud.failWith("POST /api/folders/batch-create", { status: 500, error: "folder push down" });
const folder = db.createFolder("Field Notes").folder;
const note = db.saveNote("Interview", "interview body", "personal", null, null, folder.id).note;
setNoteRow(db, note.id, { created_at: T_SHELL, updated_at: T_SHELL });
const before = snapshotNotes(db);
await syncOnce(device);
const [batch] = cloud.logFor("/api/notes/batch-create");
assert.equal(
batch.body.notes[0].folder_id,
null,
"an unmapped folder must null the reference, never leak the local integer id"
);
const cloudId = db.getNote(note.id).cloud_id;
assert.ok(cloudId, "the note must reach the cloud even with its folder stuck");
assert.equal(cloud.note(cloudId).folder_id, null);
assert.equal(db.db.prepare("SELECT * FROM folders WHERE id = ?").get(folder.id).cloud_id, null);
// The folder push recovers, and the next edit is what carries the mapping up.
cloud.clearFailures();
db.updateNote(note.id, { content: "interview body, second draft" });
setNoteRow(db, note.id, { updated_at: T_FUTURE });
const mark = cloud.log.length;
await syncOnce(device);
const folderCloudId = db.db.prepare("SELECT * FROM folders WHERE id = ?").get(folder.id).cloud_id;
assert.ok(folderCloudId, "the retried folder push must land");
const patches = cloud.log
.slice(mark)
.filter((c) => c.method === "PATCH" && c.path === "/api/notes/update");
assert.equal(patches.length, 1);
assert.equal(
patches[0].body.folder_id,
folderCloudId,
"once the folder is mapped the note must be filed under it in the cloud"
);
assert.equal(patches[0].body.content, "interview body, second draft");
assert.equal(cloud.note(cloudId).folder_id, folderCloudId);
assert.equal(cloud.note(cloudId).content, "interview body, second draft");
assert.equal(db.getNote(note.id).sync_status, "synced");
assertNoContentRegression(before, snapshotNotes(db), cloud.notes());
});