9 files changed, 1009 insertions, 59 deletions

diff --git a/src/client/sync/conflict.test.ts b/src/client/sync/conflict.test.ts
index 211f410..6a10c4f 100644
--- a/src/client/sync/conflict.test.ts
+++ b/src/client/sync/conflict.test.ts
@@ -9,6 +9,29 @@ import { ConflictResolver } from "./conflict";
 import type { SyncPullResult } from "./pull";
 import type { SyncPushResult } from "./push";
 
+function createEmptyConflicts() {
+	return {
+		decks: [] as string[],
+		cards: [] as string[],
+		noteTypes: [] as string[],
+		noteFieldTypes: [] as string[],
+		notes: [] as string[],
+		noteFieldValues: [] as string[],
+	};
+}
+
+function createEmptyPullResult(
+	currentSyncVersion = 0,
+): Omit<SyncPullResult, "decks" | "cards" | "reviewLogs"> {
+	return {
+		noteTypes: [],
+		noteFieldTypes: [],
+		notes: [],
+		noteFieldValues: [],
+		currentSyncVersion,
+	};
+}
+
 describe("ConflictResolver", () => {
 	beforeEach(async () => {
 		await db.decks.clear();
@@ -31,7 +54,11 @@ describe("ConflictResolver", () => {
 				decks: [{ id: "deck-1", syncVersion: 1 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: [] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: createEmptyConflicts(),
 			};
 
 			expect(resolver.hasConflicts(pushResult)).toBe(false);
@@ -43,7 +70,11 @@ describe("ConflictResolver", () => {
 				decks: [{ id: "deck-1", syncVersion: 1 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: ["deck-1"], cards: [] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: { ...createEmptyConflicts(), decks: ["deck-1"] },
 			};
 
 			expect(resolver.hasConflicts(pushResult)).toBe(true);
@@ -55,7 +86,11 @@ describe("ConflictResolver", () => {
 				decks: [],
 				cards: [{ id: "card-1", syncVersion: 1 }],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: ["card-1"] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: { ...createEmptyConflicts(), cards: ["card-1"] },
 			};
 
 			expect(resolver.hasConflicts(pushResult)).toBe(true);
@@ -69,7 +104,11 @@ describe("ConflictResolver", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: ["deck-1", "deck-2"], cards: [] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: { ...createEmptyConflicts(), decks: ["deck-1", "deck-2"] },
 			};
 
 			expect(resolver.getConflictingDeckIds(pushResult)).toEqual([
@@ -86,7 +125,11 @@ describe("ConflictResolver", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: ["card-1", "card-2"] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: { ...createEmptyConflicts(), cards: ["card-1", "card-2"] },
 			};
 
 			expect(resolver.getConflictingCardIds(pushResult)).toEqual([
@@ -329,7 +372,14 @@ describe("ConflictResolver", () => {
 				],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [deck1.id, deck2.id], cards: [] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: {
+					...createEmptyConflicts(),
+					decks: [deck1.id, deck2.id],
+				},
 			};
 
 			const pullResult: SyncPullResult = {
@@ -359,7 +409,7 @@ describe("ConflictResolver", () => {
 				],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 6,
+				...createEmptyPullResult(6),
 			};
 
 			const resolver = new ConflictResolver({ strategy: "server_wins" });
@@ -393,7 +443,11 @@ describe("ConflictResolver", () => {
 				decks: [],
 				cards: [{ id: card.id, syncVersion: 1 }],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: [card.id] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: { ...createEmptyConflicts(), cards: [card.id] },
 			};
 
 			const pullResult: SyncPullResult = {
@@ -420,7 +474,7 @@ describe("ConflictResolver", () => {
 					},
 				],
 				reviewLogs: [],
-				currentSyncVersion: 3,
+				...createEmptyPullResult(3),
 			};
 
 			const resolver = new ConflictResolver({ strategy: "server_wins" });
@@ -438,7 +492,14 @@ describe("ConflictResolver", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: ["non-existent-deck"], cards: [] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: {
+					...createEmptyConflicts(),
+					decks: ["non-existent-deck"],
+				},
 			};
 
 			const pullResult: SyncPullResult = {
@@ -457,7 +518,7 @@ describe("ConflictResolver", () => {
 				],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 1,
+				...createEmptyPullResult(1),
 			};
 
 			const resolver = new ConflictResolver({ strategy: "server_wins" });
@@ -483,14 +544,18 @@ describe("ConflictResolver", () => {
 				decks: [{ id: deck.id, syncVersion: 1 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [deck.id], cards: [] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: { ...createEmptyConflicts(), decks: [deck.id] },
 			};
 
 			const pullResult: SyncPullResult = {
 				decks: [], // Server doesn't have this deck
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 0,
+				...createEmptyPullResult(0),
 			};
 
 			const resolver = new ConflictResolver({ strategy: "server_wins" });
@@ -516,7 +581,11 @@ describe("ConflictResolver", () => {
 				decks: [{ id: deck.id, syncVersion: 1 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [deck.id], cards: [] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: { ...createEmptyConflicts(), decks: [deck.id] },
 			};
 
 			const pullResult: SyncPullResult = {
@@ -535,7 +604,7 @@ describe("ConflictResolver", () => {
 				],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 5,
+				...createEmptyPullResult(5),
 			};
 
 			// Create resolver without explicit strategy
diff --git a/src/client/sync/conflict.ts b/src/client/sync/conflict.ts
index e4f1cbf..d9c3f55 100644
--- a/src/client/sync/conflict.ts
+++ b/src/client/sync/conflict.ts
@@ -1,6 +1,28 @@
-import type { LocalCard, LocalDeck } from "../db/index";
-import { localCardRepository, localDeckRepository } from "../db/repositories";
-import type { ServerCard, ServerDeck, SyncPullResult } from "./pull";
+import type {
+	LocalCard,
+	LocalDeck,
+	LocalNote,
+	LocalNoteFieldType,
+	LocalNoteFieldValue,
+	LocalNoteType,
+} from "../db/index";
+import {
+	localCardRepository,
+	localDeckRepository,
+	localNoteFieldTypeRepository,
+	localNoteFieldValueRepository,
+	localNoteRepository,
+	localNoteTypeRepository,
+} from "../db/repositories";
+import type {
+	ServerCard,
+	ServerDeck,
+	ServerNote,
+	ServerNoteFieldType,
+	ServerNoteFieldValue,
+	ServerNoteType,
+	SyncPullResult,
+} from "./pull";
 import type { SyncPushResult } from "./push";
 
 /**
@@ -17,6 +39,10 @@ export interface ConflictResolutionItem {
 export interface ConflictResolutionResult {
 	decks: ConflictResolutionItem[];
 	cards: ConflictResolutionItem[];
+	noteTypes: ConflictResolutionItem[];
+	noteFieldTypes: ConflictResolutionItem[];
+	notes: ConflictResolutionItem[];
+	noteFieldValues: ConflictResolutionItem[];
 }
 
 /**
@@ -87,6 +113,79 @@ function serverCardToLocal(card: ServerCard): LocalCard {
 }
 
 /**
+ * Convert server note type to local format for storage
+ */
+function serverNoteTypeToLocal(noteType: ServerNoteType): LocalNoteType {
+	return {
+		id: noteType.id,
+		userId: noteType.userId,
+		name: noteType.name,
+		frontTemplate: noteType.frontTemplate,
+		backTemplate: noteType.backTemplate,
+		isReversible: noteType.isReversible,
+		createdAt: new Date(noteType.createdAt),
+		updatedAt: new Date(noteType.updatedAt),
+		deletedAt: noteType.deletedAt ? new Date(noteType.deletedAt) : null,
+		syncVersion: noteType.syncVersion,
+		_synced: true,
+	};
+}
+
+/**
+ * Convert server note field type to local format for storage
+ */
+function serverNoteFieldTypeToLocal(
+	fieldType: ServerNoteFieldType,
+): LocalNoteFieldType {
+	return {
+		id: fieldType.id,
+		noteTypeId: fieldType.noteTypeId,
+		name: fieldType.name,
+		order: fieldType.order,
+		fieldType: fieldType.fieldType as LocalNoteFieldType["fieldType"],
+		createdAt: new Date(fieldType.createdAt),
+		updatedAt: new Date(fieldType.updatedAt),
+		deletedAt: fieldType.deletedAt ? new Date(fieldType.deletedAt) : null,
+		syncVersion: fieldType.syncVersion,
+		_synced: true,
+	};
+}
+
+/**
+ * Convert server note to local format for storage
+ */
+function serverNoteToLocal(note: ServerNote): LocalNote {
+	return {
+		id: note.id,
+		deckId: note.deckId,
+		noteTypeId: note.noteTypeId,
+		createdAt: new Date(note.createdAt),
+		updatedAt: new Date(note.updatedAt),
+		deletedAt: note.deletedAt ? new Date(note.deletedAt) : null,
+		syncVersion: note.syncVersion,
+		_synced: true,
+	};
+}
+
+/**
+ * Convert server note field value to local format for storage
+ */
+function serverNoteFieldValueToLocal(
+	fieldValue: ServerNoteFieldValue,
+): LocalNoteFieldValue {
+	return {
+		id: fieldValue.id,
+		noteId: fieldValue.noteId,
+		noteFieldTypeId: fieldValue.noteFieldTypeId,
+		value: fieldValue.value,
+		createdAt: new Date(fieldValue.createdAt),
+		updatedAt: new Date(fieldValue.updatedAt),
+		syncVersion: fieldValue.syncVersion,
+		_synced: true,
+	};
+}
+
+/**
  * Conflict Resolver
  *
  * Handles conflicts reported by the server during push operations.
@@ -109,7 +208,11 @@ export class ConflictResolver {
 	hasConflicts(pushResult: SyncPushResult): boolean {
 		return (
 			pushResult.conflicts.decks.length > 0 ||
-			pushResult.conflicts.cards.length > 0
+			pushResult.conflicts.cards.length > 0 ||
+			pushResult.conflicts.noteTypes.length > 0 ||
+			pushResult.conflicts.noteFieldTypes.length > 0 ||
+			pushResult.conflicts.notes.length > 0 ||
+			pushResult.conflicts.noteFieldValues.length > 0
 		);
 	}
 
@@ -200,6 +303,142 @@ export class ConflictResolver {
 	}
 
 	/**
+	 * Resolve note type conflict using configured strategy
+	 */
+	async resolveNoteTypeConflict(
+		localNoteType: LocalNoteType,
+		serverNoteType: ServerNoteType,
+	): Promise<ConflictResolutionItem> {
+		let resolution: "server_wins" | "local_wins";
+
+		switch (this.strategy) {
+			case "server_wins":
+				resolution = "server_wins";
+				break;
+			case "local_wins":
+				resolution = "local_wins";
+				break;
+			case "newer_wins":
+				resolution = isServerNewer(
+					new Date(serverNoteType.updatedAt),
+					localNoteType.updatedAt,
+				)
+					? "server_wins"
+					: "local_wins";
+				break;
+		}
+
+		if (resolution === "server_wins") {
+			const localData = serverNoteTypeToLocal(serverNoteType);
+			await localNoteTypeRepository.upsertFromServer(localData);
+		}
+
+		return { id: localNoteType.id, resolution };
+	}
+
+	/**
+	 * Resolve note field type conflict using configured strategy
+	 */
+	async resolveNoteFieldTypeConflict(
+		localFieldType: LocalNoteFieldType,
+		serverFieldType: ServerNoteFieldType,
+	): Promise<ConflictResolutionItem> {
+		let resolution: "server_wins" | "local_wins";
+
+		switch (this.strategy) {
+			case "server_wins":
+				resolution = "server_wins";
+				break;
+			case "local_wins":
+				resolution = "local_wins";
+				break;
+			case "newer_wins":
+				resolution = isServerNewer(
+					new Date(serverFieldType.updatedAt),
+					localFieldType.updatedAt,
+				)
+					? "server_wins"
+					: "local_wins";
+				break;
+		}
+
+		if (resolution === "server_wins") {
+			const localData = serverNoteFieldTypeToLocal(serverFieldType);
+			await localNoteFieldTypeRepository.upsertFromServer(localData);
+		}
+
+		return { id: localFieldType.id, resolution };
+	}
+
+	/**
+	 * Resolve note conflict using configured strategy
+	 */
+	async resolveNoteConflict(
+		localNote: LocalNote,
+		serverNote: ServerNote,
+	): Promise<ConflictResolutionItem> {
+		let resolution: "server_wins" | "local_wins";
+
+		switch (this.strategy) {
+			case "server_wins":
+				resolution = "server_wins";
+				break;
+			case "local_wins":
+				resolution = "local_wins";
+				break;
+			case "newer_wins":
+				resolution = isServerNewer(
+					new Date(serverNote.updatedAt),
+					localNote.updatedAt,
+				)
+					? "server_wins"
+					: "local_wins";
+				break;
+		}
+
+		if (resolution === "server_wins") {
+			const localData = serverNoteToLocal(serverNote);
+			await localNoteRepository.upsertFromServer(localData);
+		}
+
+		return { id: localNote.id, resolution };
+	}
+
+	/**
+	 * Resolve note field value conflict using configured strategy
+	 */
+	async resolveNoteFieldValueConflict(
+		localFieldValue: LocalNoteFieldValue,
+		serverFieldValue: ServerNoteFieldValue,
+	): Promise<ConflictResolutionItem> {
+		let resolution: "server_wins" | "local_wins";
+
+		switch (this.strategy) {
+			case "server_wins":
+				resolution = "server_wins";
+				break;
+			case "local_wins":
+				resolution = "local_wins";
+				break;
+			case "newer_wins":
+				resolution = isServerNewer(
+					new Date(serverFieldValue.updatedAt),
+					localFieldValue.updatedAt,
+				)
+					? "server_wins"
+					: "local_wins";
+				break;
+		}
+
+		if (resolution === "server_wins") {
+			const localData = serverNoteFieldValueToLocal(serverFieldValue);
+			await localNoteFieldValueRepository.upsertFromServer(localData);
+		}
+
+		return { id: localFieldValue.id, resolution };
+	}
+
+	/**
 	 * Resolve all conflicts from a push result
 	 * Uses pull result to get server data for conflicting items
 	 */
@@ -210,6 +449,10 @@ export class ConflictResolver {
 		const result: ConflictResolutionResult = {
 			decks: [],
 			cards: [],
+			noteTypes: [],
+			noteFieldTypes: [],
+			notes: [],
+			noteFieldValues: [],
 		};
 
 		// Resolve deck conflicts
@@ -252,6 +495,92 @@ export class ConflictResolver {
 			// If server doesn't have it but local does, keep local (will push again)
 		}
 
+		// Resolve note type conflicts
+		for (const noteTypeId of pushResult.conflicts.noteTypes) {
+			const localNoteType = await localNoteTypeRepository.findById(noteTypeId);
+			const serverNoteType = pullResult.noteTypes.find(
+				(nt) => nt.id === noteTypeId,
+			);
+
+			if (localNoteType && serverNoteType) {
+				const resolution = await this.resolveNoteTypeConflict(
+					localNoteType,
+					serverNoteType,
+				);
+				result.noteTypes.push(resolution);
+			} else if (serverNoteType) {
+				const localData = serverNoteTypeToLocal(serverNoteType);
+				await localNoteTypeRepository.upsertFromServer(localData);
+				result.noteTypes.push({ id: noteTypeId, resolution: "server_wins" });
+			}
+		}
+
+		// Resolve note field type conflicts
+		for (const fieldTypeId of pushResult.conflicts.noteFieldTypes) {
+			const localFieldType =
+				await localNoteFieldTypeRepository.findById(fieldTypeId);
+			const serverFieldType = pullResult.noteFieldTypes.find(
+				(ft) => ft.id === fieldTypeId,
+			);
+
+			if (localFieldType && serverFieldType) {
+				const resolution = await this.resolveNoteFieldTypeConflict(
+					localFieldType,
+					serverFieldType,
+				);
+				result.noteFieldTypes.push(resolution);
+			} else if (serverFieldType) {
+				const localData = serverNoteFieldTypeToLocal(serverFieldType);
+				await localNoteFieldTypeRepository.upsertFromServer(localData);
+				result.noteFieldTypes.push({
+					id: fieldTypeId,
+					resolution: "server_wins",
+				});
+			}
+		}
+
+		// Resolve note conflicts
+		for (const noteId of pushResult.conflicts.notes) {
+			const localNote = await localNoteRepository.findById(noteId);
+			const serverNote = pullResult.notes.find((n) => n.id === noteId);
+
+			if (localNote && serverNote) {
+				const resolution = await this.resolveNoteConflict(
+					localNote,
+					serverNote,
+				);
+				result.notes.push(resolution);
+			} else if (serverNote) {
+				const localData = serverNoteToLocal(serverNote);
+				await localNoteRepository.upsertFromServer(localData);
+				result.notes.push({ id: noteId, resolution: "server_wins" });
+			}
+		}
+
+		// Resolve note field value conflicts
+		for (const fieldValueId of pushResult.conflicts.noteFieldValues) {
+			const localFieldValue =
+				await localNoteFieldValueRepository.findById(fieldValueId);
+			const serverFieldValue = pullResult.noteFieldValues.find(
+				(fv) => fv.id === fieldValueId,
+			);
+
+			if (localFieldValue && serverFieldValue) {
+				const resolution = await this.resolveNoteFieldValueConflict(
+					localFieldValue,
+					serverFieldValue,
+				);
+				result.noteFieldValues.push(resolution);
+			} else if (serverFieldValue) {
+				const localData = serverNoteFieldValueToLocal(serverFieldValue);
+				await localNoteFieldValueRepository.upsertFromServer(localData);
+				result.noteFieldValues.push({
+					id: fieldValueId,
+					resolution: "server_wins",
+				});
+			}
+		}
+
 		return result;
 	}
 }
diff --git a/src/client/sync/manager.test.ts b/src/client/sync/manager.test.ts
index 96fb97d..a3799c0 100644
--- a/src/client/sync/manager.test.ts
+++ b/src/client/sync/manager.test.ts
@@ -19,6 +19,41 @@ import { PullService, type SyncPullResult } from "./pull";
 import { PushService, type SyncPushResult } from "./push";
 import { SyncQueue } from "./queue";
 
+function createEmptyConflicts() {
+	return {
+		decks: [] as string[],
+		cards: [] as string[],
+		noteTypes: [] as string[],
+		noteFieldTypes: [] as string[],
+		notes: [] as string[],
+		noteFieldValues: [] as string[],
+	};
+}
+
+function createEmptyPullResult(
+	currentSyncVersion = 0,
+): Omit<SyncPullResult, "decks" | "cards" | "reviewLogs"> {
+	return {
+		noteTypes: [],
+		noteFieldTypes: [],
+		notes: [],
+		noteFieldValues: [],
+		currentSyncVersion,
+	};
+}
+
+function createEmptyPushResult(): Omit<
+	SyncPushResult,
+	"decks" | "cards" | "reviewLogs" | "conflicts"
+> {
+	return {
+		noteTypes: [],
+		noteFieldTypes: [],
+		notes: [],
+		noteFieldValues: [],
+	};
+}
+
 describe("SyncManager", () => {
 	let syncQueue: SyncQueue;
 	let conflictResolver: ConflictResolver;
@@ -63,14 +98,15 @@ describe("SyncManager", () => {
 			decks: [],
 			cards: [],
 			reviewLogs: [],
-			conflicts: { decks: [], cards: [] },
+			...createEmptyPushResult(),
+			conflicts: createEmptyConflicts(),
 		} satisfies SyncPushResult);
 
 		pullFromServer = vi.fn().mockResolvedValue({
 			decks: [],
 			cards: [],
 			reviewLogs: [],
-			currentSyncVersion: 0,
+			...createEmptyPullResult(0),
 		} satisfies SyncPullResult);
 
 		conflictResolver = new ConflictResolver({ strategy: "server_wins" });
@@ -249,7 +285,8 @@ describe("SyncManager", () => {
 				decks: [{ id: "deck-1", syncVersion: 1 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: createEmptyConflicts(),
 			};
 			pushToServer.mockResolvedValue(expectedPushResult);
 
@@ -257,7 +294,7 @@ describe("SyncManager", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 5,
+				...createEmptyPullResult(5),
 			};
 			pullFromServer.mockResolvedValue(expectedPullResult);
 
@@ -323,7 +360,8 @@ describe("SyncManager", () => {
 									decks: [],
 									cards: [],
 									reviewLogs: [],
-									conflicts: { decks: [], cards: [] },
+									...createEmptyPushResult(),
+									conflicts: createEmptyConflicts(),
 								}),
 							100,
 						),
@@ -357,7 +395,8 @@ describe("SyncManager", () => {
 				decks: [{ id: deck.id, syncVersion: 1 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [deck.id], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: { ...createEmptyConflicts(), decks: [deck.id] },
 			};
 			pushToServer.mockResolvedValue(pushResult);
 
@@ -377,7 +416,7 @@ describe("SyncManager", () => {
 				],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 5,
+				...createEmptyPullResult(5),
 			};
 			pullFromServer.mockResolvedValue(pullResult);
 
@@ -573,7 +612,8 @@ describe("SyncManager", () => {
 									decks: [],
 									cards: [],
 									reviewLogs: [],
-									conflicts: { decks: [], cards: [] },
+									...createEmptyPushResult(),
+									conflicts: createEmptyConflicts(),
 								}),
 							100,
 						),
diff --git a/src/client/sync/pull.test.ts b/src/client/sync/pull.test.ts
index 84c22bd..baf4bca 100644
--- a/src/client/sync/pull.test.ts
+++ b/src/client/sync/pull.test.ts
@@ -5,9 +5,21 @@ import "fake-indexeddb/auto";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { CardState, db, Rating } from "../db/index";
 import { localCardRepository, localDeckRepository } from "../db/repositories";
-import { PullService, pullResultToLocalData } from "./pull";
+import { PullService, pullResultToLocalData, type SyncPullResult } from "./pull";
 import { SyncQueue } from "./queue";
 
+function createEmptyPullResult(
+	currentSyncVersion = 0,
+): Omit<SyncPullResult, "decks" | "cards" | "reviewLogs"> {
+	return {
+		noteTypes: [],
+		noteFieldTypes: [],
+		notes: [],
+		noteFieldValues: [],
+		currentSyncVersion,
+	};
+}
+
 describe("pullResultToLocalData", () => {
 	it("should convert server decks to local format", () => {
 		const serverDecks = [
@@ -28,7 +40,7 @@ describe("pullResultToLocalData", () => {
 			decks: serverDecks,
 			cards: [],
 			reviewLogs: [],
-			currentSyncVersion: 5,
+			...createEmptyPullResult(5),
 		});
 
 		expect(result.decks).toHaveLength(1);
@@ -65,7 +77,7 @@ describe("pullResultToLocalData", () => {
 			decks: serverDecks,
 			cards: [],
 			reviewLogs: [],
-			currentSyncVersion: 3,
+			...createEmptyPullResult(3),
 		});
 
 		expect(result.decks[0]?.deletedAt).toEqual(
@@ -100,7 +112,7 @@ describe("pullResultToLocalData", () => {
 			decks: [],
 			cards: serverCards,
 			reviewLogs: [],
-			currentSyncVersion: 2,
+			...createEmptyPullResult(2),
 		});
 
 		expect(result.cards).toHaveLength(1);
@@ -155,7 +167,7 @@ describe("pullResultToLocalData", () => {
 			decks: [],
 			cards: serverCards,
 			reviewLogs: [],
-			currentSyncVersion: 1,
+			...createEmptyPullResult(1),
 		});
 
 		expect(result.cards[0]?.lastReview).toBeNull();
@@ -181,7 +193,7 @@ describe("pullResultToLocalData", () => {
 			decks: [],
 			cards: [],
 			reviewLogs: serverReviewLogs,
-			currentSyncVersion: 1,
+			...createEmptyPullResult(1),
 		});
 
 		expect(result.reviewLogs).toHaveLength(1);
@@ -220,7 +232,7 @@ describe("pullResultToLocalData", () => {
 			decks: [],
 			cards: [],
 			reviewLogs: serverReviewLogs,
-			currentSyncVersion: 1,
+			...createEmptyPullResult(1),
 		});
 
 		expect(result.reviewLogs[0]?.durationMs).toBeNull();
@@ -251,7 +263,7 @@ describe("PullService", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 0,
+				...createEmptyPullResult(0),
 			});
 
 			const pullService = new PullService({
@@ -265,7 +277,7 @@ describe("PullService", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 0,
+				...createEmptyPullResult(0),
 			});
 			expect(pullFromServer).toHaveBeenCalledWith(0);
 		});
@@ -278,7 +290,7 @@ describe("PullService", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 10,
+				...createEmptyPullResult(10),
 			});
 
 			const pullService = new PullService({
@@ -308,7 +320,7 @@ describe("PullService", () => {
 				],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 5,
+				...createEmptyPullResult(5),
 			});
 
 			const pullService = new PullService({
@@ -342,6 +354,8 @@ describe("PullService", () => {
 					{
 						id: "server-card-1",
 						deckId: deck.id,
+						noteId: null,
+						isReversed: null,
 						front: "Server Question",
 						back: "Server Answer",
 						state: CardState.New,
@@ -360,7 +374,7 @@ describe("PullService", () => {
 					},
 				],
 				reviewLogs: [],
-				currentSyncVersion: 3,
+				...createEmptyPullResult(3),
 			});
 
 			const pullService = new PullService({
@@ -382,7 +396,7 @@ describe("PullService", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 15,
+				...createEmptyPullResult(15),
 			});
 
 			const pullService = new PullService({
@@ -400,7 +414,7 @@ describe("PullService", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 0,
+				...createEmptyPullResult(0),
 			});
 
 			const pullService = new PullService({
@@ -451,7 +465,7 @@ describe("PullService", () => {
 				],
 				cards: [],
 				reviewLogs: [],
-				currentSyncVersion: 10,
+				...createEmptyPullResult(10),
 			});
 
 			const pullService = new PullService({
@@ -487,6 +501,8 @@ describe("PullService", () => {
 					{
 						id: "card-1",
 						deckId: "deck-1",
+						noteId: null,
+						isReversed: null,
 						front: "Q",
 						back: "A",
 						state: CardState.New,
@@ -518,7 +534,7 @@ describe("PullService", () => {
 						syncVersion: 3,
 					},
 				],
-				currentSyncVersion: 3,
+				...createEmptyPullResult(3),
 			});
 
 			const pullService = new PullService({
diff --git a/src/client/sync/pull.ts b/src/client/sync/pull.ts
index fa0899b..55c859c 100644
--- a/src/client/sync/pull.ts
+++ b/src/client/sync/pull.ts
@@ -1,7 +1,12 @@
 import type {
 	CardStateType,
+	FieldTypeType,
 	LocalCard,
 	LocalDeck,
+	LocalNote,
+	LocalNoteFieldType,
+	LocalNoteFieldValue,
+	LocalNoteType,
 	LocalReviewLog,
 	RatingType,
 } from "../db/index";
@@ -64,12 +69,73 @@ export interface ServerReviewLog {
 }
 
 /**
+ * Server note type data format from pull response
+ */
+export interface ServerNoteType {
+	id: string;
+	userId: string;
+	name: string;
+	frontTemplate: string;
+	backTemplate: string;
+	isReversible: boolean;
+	createdAt: Date;
+	updatedAt: Date;
+	deletedAt: Date | null;
+	syncVersion: number;
+}
+
+/**
+ * Server note field type data format from pull response
+ */
+export interface ServerNoteFieldType {
+	id: string;
+	noteTypeId: string;
+	name: string;
+	order: number;
+	fieldType: string;
+	createdAt: Date;
+	updatedAt: Date;
+	deletedAt: Date | null;
+	syncVersion: number;
+}
+
+/**
+ * Server note data format from pull response
+ */
+export interface ServerNote {
+	id: string;
+	deckId: string;
+	noteTypeId: string;
+	createdAt: Date;
+	updatedAt: Date;
+	deletedAt: Date | null;
+	syncVersion: number;
+}
+
+/**
+ * Server note field value data format from pull response
+ */
+export interface ServerNoteFieldValue {
+	id: string;
+	noteId: string;
+	noteFieldTypeId: string;
+	value: string;
+	createdAt: Date;
+	updatedAt: Date;
+	syncVersion: number;
+}
+
+/**
  * Response from pull endpoint
  */
 export interface SyncPullResult {
 	decks: ServerDeck[];
 	cards: ServerCard[];
 	reviewLogs: ServerReviewLog[];
+	noteTypes: ServerNoteType[];
+	noteFieldTypes: ServerNoteFieldType[];
+	notes: ServerNote[];
+	noteFieldValues: ServerNoteFieldValue[];
 	currentSyncVersion: number;
 }
 
@@ -147,17 +213,98 @@ function serverReviewLogToLocal(log: ServerReviewLog): LocalReviewLog {
 }
 
 /**
+ * Convert server note type to local note type format
+ */
+function serverNoteTypeToLocal(noteType: ServerNoteType): LocalNoteType {
+	return {
+		id: noteType.id,
+		userId: noteType.userId,
+		name: noteType.name,
+		frontTemplate: noteType.frontTemplate,
+		backTemplate: noteType.backTemplate,
+		isReversible: noteType.isReversible,
+		createdAt: new Date(noteType.createdAt),
+		updatedAt: new Date(noteType.updatedAt),
+		deletedAt: noteType.deletedAt ? new Date(noteType.deletedAt) : null,
+		syncVersion: noteType.syncVersion,
+		_synced: true,
+	};
+}
+
+/**
+ * Convert server note field type to local note field type format
+ */
+function serverNoteFieldTypeToLocal(
+	fieldType: ServerNoteFieldType,
+): LocalNoteFieldType {
+	return {
+		id: fieldType.id,
+		noteTypeId: fieldType.noteTypeId,
+		name: fieldType.name,
+		order: fieldType.order,
+		fieldType: fieldType.fieldType as FieldTypeType,
+		createdAt: new Date(fieldType.createdAt),
+		updatedAt: new Date(fieldType.updatedAt),
+		deletedAt: fieldType.deletedAt ? new Date(fieldType.deletedAt) : null,
+		syncVersion: fieldType.syncVersion,
+		_synced: true,
+	};
+}
+
+/**
+ * Convert server note to local note format
+ */
+function serverNoteToLocal(note: ServerNote): LocalNote {
+	return {
+		id: note.id,
+		deckId: note.deckId,
+		noteTypeId: note.noteTypeId,
+		createdAt: new Date(note.createdAt),
+		updatedAt: new Date(note.updatedAt),
+		deletedAt: note.deletedAt ? new Date(note.deletedAt) : null,
+		syncVersion: note.syncVersion,
+		_synced: true,
+	};
+}
+
+/**
+ * Convert server note field value to local note field value format
+ */
+function serverNoteFieldValueToLocal(
+	fieldValue: ServerNoteFieldValue,
+): LocalNoteFieldValue {
+	return {
+		id: fieldValue.id,
+		noteId: fieldValue.noteId,
+		noteFieldTypeId: fieldValue.noteFieldTypeId,
+		value: fieldValue.value,
+		createdAt: new Date(fieldValue.createdAt),
+		updatedAt: new Date(fieldValue.updatedAt),
+		syncVersion: fieldValue.syncVersion,
+		_synced: true,
+	};
+}
+
+/**
  * Convert server pull result to local format for storage
  */
 export function pullResultToLocalData(result: SyncPullResult): {
 	decks: LocalDeck[];
 	cards: LocalCard[];
 	reviewLogs: LocalReviewLog[];
+	noteTypes: LocalNoteType[];
+	noteFieldTypes: LocalNoteFieldType[];
+	notes: LocalNote[];
+	noteFieldValues: LocalNoteFieldValue[];
 } {
 	return {
 		decks: result.decks.map(serverDeckToLocal),
 		cards: result.cards.map(serverCardToLocal),
 		reviewLogs: result.reviewLogs.map(serverReviewLogToLocal),
+		noteTypes: result.noteTypes.map(serverNoteTypeToLocal),
+		noteFieldTypes: result.noteFieldTypes.map(serverNoteFieldTypeToLocal),
+		notes: result.notes.map(serverNoteToLocal),
+		noteFieldValues: result.noteFieldValues.map(serverNoteFieldValueToLocal),
 	};
 }
 
@@ -196,7 +343,11 @@ export class PullService {
 		if (
 			result.decks.length > 0 ||
 			result.cards.length > 0 ||
-			result.reviewLogs.length > 0
+			result.reviewLogs.length > 0 ||
+			result.noteTypes.length > 0 ||
+			result.noteFieldTypes.length > 0 ||
+			result.notes.length > 0 ||
+			result.noteFieldValues.length > 0
 		) {
 			const localData = pullResultToLocalData(result);
 			await this.syncQueue.applyPulledChanges(localData);
diff --git a/src/client/sync/push.test.ts b/src/client/sync/push.test.ts
index a3ff154..ccd2c7d 100644
--- a/src/client/sync/push.test.ts
+++ b/src/client/sync/push.test.ts
@@ -9,9 +9,57 @@ import {
 	localDeckRepository,
 	localReviewLogRepository,
 } from "../db/repositories";
+import type { PendingChanges } from "./queue";
 import { PushService, pendingChangesToPushData } from "./push";
 import { SyncQueue } from "./queue";
 
+function createEmptyPending(): Omit<
+	PendingChanges,
+	"decks" | "cards" | "reviewLogs"
+> {
+	return {
+		noteTypes: [],
+		noteFieldTypes: [],
+		notes: [],
+		noteFieldValues: [],
+	};
+}
+
+function createEmptyConflicts() {
+	return {
+		decks: [] as string[],
+		cards: [] as string[],
+		noteTypes: [] as string[],
+		noteFieldTypes: [] as string[],
+		notes: [] as string[],
+		noteFieldValues: [] as string[],
+	};
+}
+
+function createEmptyPushResult(): Omit<
+	import("./push").SyncPushResult,
+	"decks" | "cards" | "reviewLogs" | "conflicts"
+> {
+	return {
+		noteTypes: [],
+		noteFieldTypes: [],
+		notes: [],
+		noteFieldValues: [],
+	};
+}
+
+function createEmptyPushData(): Omit<
+	import("./push").SyncPushData,
+	"decks" | "cards" | "reviewLogs"
+> {
+	return {
+		noteTypes: [],
+		noteFieldTypes: [],
+		notes: [],
+		noteFieldValues: [],
+	};
+}
+
 describe("pendingChangesToPushData", () => {
 	it("should convert decks to sync format", () => {
 		const decks = [
@@ -33,6 +81,7 @@ describe("pendingChangesToPushData", () => {
 			decks,
 			cards: [],
 			reviewLogs: [],
+			...createEmptyPending(),
 		});
 
 		expect(result.decks).toHaveLength(1);
@@ -67,6 +116,7 @@ describe("pendingChangesToPushData", () => {
 			decks,
 			cards: [],
 			reviewLogs: [],
+			...createEmptyPending(),
 		});
 
 		expect(result.decks[0]?.deletedAt).toBe("2024-01-03T12:00:00.000Z");
@@ -102,12 +152,15 @@ describe("pendingChangesToPushData", () => {
 			decks: [],
 			cards,
 			reviewLogs: [],
+			...createEmptyPending(),
 		});
 
 		expect(result.cards).toHaveLength(1);
 		expect(result.cards[0]).toEqual({
 			id: "card-1",
 			deckId: "deck-1",
+			noteId: null,
+			isReversed: null,
 			front: "Question",
 			back: "Answer",
 			state: CardState.Review,
@@ -155,6 +208,7 @@ describe("pendingChangesToPushData", () => {
 			decks: [],
 			cards,
 			reviewLogs: [],
+			...createEmptyPending(),
 		});
 
 		expect(result.cards[0]?.lastReview).toBeNull();
@@ -181,6 +235,7 @@ describe("pendingChangesToPushData", () => {
 			decks: [],
 			cards: [],
 			reviewLogs,
+			...createEmptyPending(),
 		});
 
 		expect(result.reviewLogs).toHaveLength(1);
@@ -217,6 +272,7 @@ describe("pendingChangesToPushData", () => {
 			decks: [],
 			cards: [],
 			reviewLogs,
+			...createEmptyPending(),
 		});
 
 		expect(result.reviewLogs[0]?.durationMs).toBeNull();
@@ -255,7 +311,8 @@ describe("PushService", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: createEmptyConflicts(),
 			});
 			expect(pushToServer).not.toHaveBeenCalled();
 		});
@@ -272,7 +329,8 @@ describe("PushService", () => {
 				decks: [{ id: deck.id, syncVersion: 1 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: createEmptyConflicts(),
 			});
 
 			const pushService = new PushService({
@@ -292,6 +350,7 @@ describe("PushService", () => {
 				],
 				cards: [],
 				reviewLogs: [],
+				...createEmptyPushData(),
 			});
 			expect(result.decks).toHaveLength(1);
 			expect(result.decks[0]?.id).toBe(deck.id);
@@ -316,7 +375,8 @@ describe("PushService", () => {
 				decks: [],
 				cards: [{ id: card.id, syncVersion: 1 }],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: createEmptyConflicts(),
 			});
 
 			const pushService = new PushService({
@@ -336,6 +396,7 @@ describe("PushService", () => {
 					}),
 				],
 				reviewLogs: [],
+				...createEmptyPushData(),
 			});
 			expect(result.cards).toHaveLength(1);
 		});
@@ -371,7 +432,8 @@ describe("PushService", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [{ id: log.id, syncVersion: 1 }],
-				conflicts: { decks: [], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: createEmptyConflicts(),
 			});
 
 			const pushService = new PushService({
@@ -390,6 +452,7 @@ describe("PushService", () => {
 						rating: Rating.Good,
 					}),
 				],
+				...createEmptyPushData(),
 			});
 			expect(result.reviewLogs).toHaveLength(1);
 		});
@@ -406,7 +469,8 @@ describe("PushService", () => {
 				decks: [{ id: deck.id, syncVersion: 5 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: createEmptyConflicts(),
 			});
 
 			const pushService = new PushService({
@@ -433,7 +497,8 @@ describe("PushService", () => {
 				decks: [{ id: deck.id, syncVersion: 3 }],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [deck.id], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: { ...createEmptyConflicts(), decks: [deck.id] },
 			});
 
 			const pushService = new PushService({
@@ -495,7 +560,8 @@ describe("PushService", () => {
 				decks: [{ id: deck.id, syncVersion: 1 }],
 				cards: [{ id: card.id, syncVersion: 1 }],
 				reviewLogs: [{ id: log.id, syncVersion: 1 }],
-				conflicts: { decks: [], cards: [] },
+				...createEmptyPushResult(),
+				conflicts: createEmptyConflicts(),
 			});
 
 			const pushService = new PushService({
diff --git a/src/client/sync/push.ts b/src/client/sync/push.ts
index 2493e4e..f5c9275 100644
--- a/src/client/sync/push.ts
+++ b/src/client/sync/push.ts
@@ -1,4 +1,12 @@
-import type { LocalCard, LocalDeck, LocalReviewLog } from "../db/index";
+import type {
+	LocalCard,
+	LocalDeck,
+	LocalNote,
+	LocalNoteFieldType,
+	LocalNoteFieldValue,
+	LocalNoteType,
+	LocalReviewLog,
+} from "../db/index";
 import type { PendingChanges, SyncQueue } from "./queue";
 
 /**
@@ -8,6 +16,10 @@ export interface SyncPushData {
 	decks: SyncDeckData[];
 	cards: SyncCardData[];
 	reviewLogs: SyncReviewLogData[];
+	noteTypes: SyncNoteTypeData[];
+	noteFieldTypes: SyncNoteFieldTypeData[];
+	notes: SyncNoteData[];
+	noteFieldValues: SyncNoteFieldValueData[];
 }
 
 export interface SyncDeckData {
@@ -23,6 +35,8 @@ export interface SyncDeckData {
 export interface SyncCardData {
 	id: string;
 	deckId: string;
+	noteId: string | null;
+	isReversed: boolean | null;
 	front: string;
 	back: string;
 	state: number;
@@ -50,6 +64,46 @@ export interface SyncReviewLogData {
 	durationMs: number | null;
 }
 
+export interface SyncNoteTypeData {
+	id: string;
+	name: string;
+	frontTemplate: string;
+	backTemplate: string;
+	isReversible: boolean;
+	createdAt: string;
+	updatedAt: string;
+	deletedAt: string | null;
+}
+
+export interface SyncNoteFieldTypeData {
+	id: string;
+	noteTypeId: string;
+	name: string;
+	order: number;
+	fieldType: string;
+	createdAt: string;
+	updatedAt: string;
+	deletedAt: string | null;
+}
+
+export interface SyncNoteData {
+	id: string;
+	deckId: string;
+	noteTypeId: string;
+	createdAt: string;
+	updatedAt: string;
+	deletedAt: string | null;
+}
+
+export interface SyncNoteFieldValueData {
+	id: string;
+	noteId: string;
+	noteFieldTypeId: string;
+	value: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
 /**
  * Response from push endpoint
  */
@@ -57,9 +111,17 @@ export interface SyncPushResult {
 	decks: { id: string; syncVersion: number }[];
 	cards: { id: string; syncVersion: number }[];
 	reviewLogs: { id: string; syncVersion: number }[];
+	noteTypes: { id: string; syncVersion: number }[];
+	noteFieldTypes: { id: string; syncVersion: number }[];
+	notes: { id: string; syncVersion: number }[];
+	noteFieldValues: { id: string; syncVersion: number }[];
 	conflicts: {
 		decks: string[];
 		cards: string[];
+		noteTypes: string[];
+		noteFieldTypes: string[];
+		notes: string[];
+		noteFieldValues: string[];
 	};
 }
 
@@ -93,6 +155,8 @@ function cardToSyncData(card: LocalCard): SyncCardData {
 	return {
 		id: card.id,
 		deckId: card.deckId,
+		noteId: card.noteId,
+		isReversed: card.isReversed,
 		front: card.front,
 		back: card.back,
 		state: card.state,
@@ -127,6 +191,70 @@ function reviewLogToSyncData(log: LocalReviewLog): SyncReviewLogData {
 }
 
 /**
+ * Convert local note type to sync format
+ */
+function noteTypeToSyncData(noteType: LocalNoteType): SyncNoteTypeData {
+	return {
+		id: noteType.id,
+		name: noteType.name,
+		frontTemplate: noteType.frontTemplate,
+		backTemplate: noteType.backTemplate,
+		isReversible: noteType.isReversible,
+		createdAt: noteType.createdAt.toISOString(),
+		updatedAt: noteType.updatedAt.toISOString(),
+		deletedAt: noteType.deletedAt?.toISOString() ?? null,
+	};
+}
+
+/**
+ * Convert local note field type to sync format
+ */
+function noteFieldTypeToSyncData(
+	fieldType: LocalNoteFieldType,
+): SyncNoteFieldTypeData {
+	return {
+		id: fieldType.id,
+		noteTypeId: fieldType.noteTypeId,
+		name: fieldType.name,
+		order: fieldType.order,
+		fieldType: fieldType.fieldType,
+		createdAt: fieldType.createdAt.toISOString(),
+		updatedAt: fieldType.updatedAt.toISOString(),
+		deletedAt: fieldType.deletedAt?.toISOString() ?? null,
+	};
+}
+
+/**
+ * Convert local note to sync format
+ */
+function noteToSyncData(note: LocalNote): SyncNoteData {
+	return {
+		id: note.id,
+		deckId: note.deckId,
+		noteTypeId: note.noteTypeId,
+		createdAt: note.createdAt.toISOString(),
+		updatedAt: note.updatedAt.toISOString(),
+		deletedAt: note.deletedAt?.toISOString() ?? null,
+	};
+}
+
+/**
+ * Convert local note field value to sync format
+ */
+function noteFieldValueToSyncData(
+	fieldValue: LocalNoteFieldValue,
+): SyncNoteFieldValueData {
+	return {
+		id: fieldValue.id,
+		noteId: fieldValue.noteId,
+		noteFieldTypeId: fieldValue.noteFieldTypeId,
+		value: fieldValue.value,
+		createdAt: fieldValue.createdAt.toISOString(),
+		updatedAt: fieldValue.updatedAt.toISOString(),
+	};
+}
+
+/**
  * Convert pending changes to sync push data format
  */
 export function pendingChangesToPushData(
@@ -136,6 +264,10 @@ export function pendingChangesToPushData(
 		decks: changes.decks.map(deckToSyncData),
 		cards: changes.cards.map(cardToSyncData),
 		reviewLogs: changes.reviewLogs.map(reviewLogToSyncData),
+		noteTypes: changes.noteTypes.map(noteTypeToSyncData),
+		noteFieldTypes: changes.noteFieldTypes.map(noteFieldTypeToSyncData),
+		notes: changes.notes.map(noteToSyncData),
+		noteFieldValues: changes.noteFieldValues.map(noteFieldValueToSyncData),
 	};
 }
 
@@ -171,13 +303,28 @@ export class PushService {
 		if (
 			pendingChanges.decks.length === 0 &&
 			pendingChanges.cards.length === 0 &&
-			pendingChanges.reviewLogs.length === 0
+			pendingChanges.reviewLogs.length === 0 &&
+			pendingChanges.noteTypes.length === 0 &&
+			pendingChanges.noteFieldTypes.length === 0 &&
+			pendingChanges.notes.length === 0 &&
+			pendingChanges.noteFieldValues.length === 0
 		) {
 			return {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
-				conflicts: { decks: [], cards: [] },
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
+				conflicts: {
+					decks: [],
+					cards: [],
+					noteTypes: [],
+					noteFieldTypes: [],
+					notes: [],
+					noteFieldValues: [],
+				},
 			};
 		}
 
@@ -192,6 +339,10 @@ export class PushService {
 			decks: result.decks,
 			cards: result.cards,
 			reviewLogs: result.reviewLogs,
+			noteTypes: result.noteTypes,
+			noteFieldTypes: result.noteFieldTypes,
+			notes: result.notes,
+			noteFieldValues: result.noteFieldValues,
 		});
 
 		return result;
diff --git a/src/client/sync/queue.test.ts b/src/client/sync/queue.test.ts
index b62ece2..2038e0d 100644
--- a/src/client/sync/queue.test.ts
+++ b/src/client/sync/queue.test.ts
@@ -303,6 +303,10 @@ describe("SyncQueue", () => {
 				decks: [{ id: deck.id, syncVersion: 5 }],
 				cards: [],
 				reviewLogs: [],
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
 			});
 
 			const found = await localDeckRepository.findById(deck.id);
@@ -327,6 +331,10 @@ describe("SyncQueue", () => {
 				decks: [],
 				cards: [{ id: card.id, syncVersion: 3 }],
 				reviewLogs: [],
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
 			});
 
 			const found = await localCardRepository.findById(card.id);
@@ -361,6 +369,10 @@ describe("SyncQueue", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [{ id: reviewLog.id, syncVersion: 2 }],
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
 			});
 
 			const found = await localReviewLogRepository.findById(reviewLog.id);
@@ -376,6 +388,10 @@ describe("SyncQueue", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
 			});
 
 			expect(listener).toHaveBeenCalled();
@@ -401,6 +417,10 @@ describe("SyncQueue", () => {
 				decks: [serverDeck],
 				cards: [],
 				reviewLogs: [],
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
 			});
 
 			const found = await localDeckRepository.findById("server-deck-1");
@@ -444,6 +464,10 @@ describe("SyncQueue", () => {
 				decks: [],
 				cards: [serverCard],
 				reviewLogs: [],
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
 			});
 
 			const found = await localCardRepository.findById("server-card-1");
@@ -482,6 +506,10 @@ describe("SyncQueue", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [serverLog],
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
 			});
 
 			const found = await localReviewLogRepository.findById("server-log-1");
@@ -497,6 +525,10 @@ describe("SyncQueue", () => {
 				decks: [],
 				cards: [],
 				reviewLogs: [],
+				noteTypes: [],
+				noteFieldTypes: [],
+				notes: [],
+				noteFieldValues: [],
 			});
 
 			expect(listener).toHaveBeenCalled();
diff --git a/src/client/sync/queue.ts b/src/client/sync/queue.ts
index 01c62cc..984edc3 100644
--- a/src/client/sync/queue.ts
+++ b/src/client/sync/queue.ts
@@ -2,11 +2,19 @@ import {
 	db,
 	type LocalCard,
 	type LocalDeck,
+	type LocalNote,
+	type LocalNoteFieldType,
+	type LocalNoteFieldValue,
+	type LocalNoteType,
 	type LocalReviewLog,
 } from "../db/index";
 import {
 	localCardRepository,
 	localDeckRepository,
+	localNoteFieldTypeRepository,
+	localNoteFieldValueRepository,
+	localNoteRepository,
+	localNoteTypeRepository,
 	localReviewLogRepository,
 } from "../db/repositories";
 
@@ -28,6 +36,10 @@ export interface PendingChanges {
 	decks: LocalDeck[];
 	cards: LocalCard[];
 	reviewLogs: LocalReviewLog[];
+	noteTypes: LocalNoteType[];
+	noteFieldTypes: LocalNoteFieldType[];
+	notes: LocalNote[];
+	noteFieldValues: LocalNoteFieldValue[];
 }
 
 /**
@@ -131,13 +143,33 @@ export class SyncQueue {
 	 * Get all pending (unsynced) changes
 	 */
 	async getPendingChanges(): Promise<PendingChanges> {
-		const [decks, cards, reviewLogs] = await Promise.all([
+		const [
+			decks,
+			cards,
+			reviewLogs,
+			noteTypes,
+			noteFieldTypes,
+			notes,
+			noteFieldValues,
+		] = await Promise.all([
 			localDeckRepository.findUnsynced(),
 			localCardRepository.findUnsynced(),
 			localReviewLogRepository.findUnsynced(),
+			localNoteTypeRepository.findUnsynced(),
+			localNoteFieldTypeRepository.findUnsynced(),
+			localNoteRepository.findUnsynced(),
+			localNoteFieldValueRepository.findUnsynced(),
 		]);
 
-		return { decks, cards, reviewLogs };
+		return {
+			decks,
+			cards,
+			reviewLogs,
+			noteTypes,
+			noteFieldTypes,
+			notes,
+			noteFieldValues,
+		};
 	}
 
 	/**
@@ -146,7 +178,13 @@ export class SyncQueue {
 	async getPendingCount(): Promise<number> {
 		const changes = await this.getPendingChanges();
 		return (
-			changes.decks.length + changes.cards.length + changes.reviewLogs.length
+			changes.decks.length +
+			changes.cards.length +
+			changes.reviewLogs.length +
+			changes.noteTypes.length +
+			changes.noteFieldTypes.length +
+			changes.notes.length +
+			changes.noteFieldValues.length
 		);
 	}
 
@@ -214,10 +252,22 @@ export class SyncQueue {
 		decks: { id: string; syncVersion: number }[];
 		cards: { id: string; syncVersion: number }[];
 		reviewLogs: { id: string; syncVersion: number }[];
+		noteTypes: { id: string; syncVersion: number }[];
+		noteFieldTypes: { id: string; syncVersion: number }[];
+		notes: { id: string; syncVersion: number }[];
+		noteFieldValues: { id: string; syncVersion: number }[];
 	}): Promise<void> {
 		await db.transaction(
 			"rw",
-			[db.decks, db.cards, db.reviewLogs],
+			[
+				db.decks,
+				db.cards,
+				db.reviewLogs,
+				db.noteTypes,
+				db.noteFieldTypes,
+				db.notes,
+				db.noteFieldValues,
+			],
 			async () => {
 				for (const deck of results.decks) {
 					await localDeckRepository.markSynced(deck.id, deck.syncVersion);
@@ -231,6 +281,27 @@ export class SyncQueue {
 						reviewLog.syncVersion,
 					);
 				}
+				for (const noteType of results.noteTypes) {
+					await localNoteTypeRepository.markSynced(
+						noteType.id,
+						noteType.syncVersion,
+					);
+				}
+				for (const fieldType of results.noteFieldTypes) {
+					await localNoteFieldTypeRepository.markSynced(
+						fieldType.id,
+						fieldType.syncVersion,
+					);
+				}
+				for (const note of results.notes) {
+					await localNoteRepository.markSynced(note.id, note.syncVersion);
+				}
+				for (const fieldValue of results.noteFieldValues) {
+					await localNoteFieldValueRepository.markSynced(
+						fieldValue.id,
+						fieldValue.syncVersion,
+					);
+				}
 			},
 		);
 		await this.notifyListeners();
@@ -243,14 +314,39 @@ export class SyncQueue {
 		decks: LocalDeck[];
 		cards: LocalCard[];
 		reviewLogs: LocalReviewLog[];
+		noteTypes: LocalNoteType[];
+		noteFieldTypes: LocalNoteFieldType[];
+		notes: LocalNote[];
+		noteFieldValues: LocalNoteFieldValue[];
 	}): Promise<void> {
 		await db.transaction(
 			"rw",
-			[db.decks, db.cards, db.reviewLogs],
+			[
+				db.decks,
+				db.cards,
+				db.reviewLogs,
+				db.noteTypes,
+				db.noteFieldTypes,
+				db.notes,
+				db.noteFieldValues,
+			],
 			async () => {
+				// Apply in dependency order: NoteTypes first, then dependent entities
+				for (const noteType of data.noteTypes) {
+					await localNoteTypeRepository.upsertFromServer(noteType);
+				}
+				for (const fieldType of data.noteFieldTypes) {
+					await localNoteFieldTypeRepository.upsertFromServer(fieldType);
+				}
 				for (const deck of data.decks) {
 					await localDeckRepository.upsertFromServer(deck);
 				}
+				for (const note of data.notes) {
+					await localNoteRepository.upsertFromServer(note);
+				}
+				for (const fieldValue of data.noteFieldValues) {
+					await localNoteFieldValueRepository.upsertFromServer(fieldValue);
+				}
 				for (const card of data.cards) {
 					await localCardRepository.upsertFromServer(card);
 				}