@sylphx/lens-server 2.13.2 → 2.14.1

package/src/server/create.test.ts

@@ -3,14 +3,75 @@
  *
  * Tests for the pure executor server.
  * Server only does: getMetadata() and execute()
+ *
+ * STATELESS ARCHITECTURE:
+ * - Server sends initial data via { $: "snapshot", data }
+ * - Server sends updates via { $: "ops", ops: Op[] }
+ * - Client applies updates to local state using applyOps
  */
 
 import { describe, expect, it } from "bun:test";
-import { entity, firstValueFrom, mutation, query, resolver, router, t } from "@sylphx/lens-core";
+import {
+	applyOps,
+	entity,
+	firstValueFrom,
+	isError,
+	isOps,
+	isSnapshot,
+	type Message,
+	mutation,
+	query,
+	resolver,
+	router,
+	t,
+} from "@sylphx/lens-core";
 import { z } from "zod";
 import { optimisticPlugin } from "../plugin/optimistic.js";
 import { createApp } from "./create.js";
 
+// =============================================================================
+// Test Helpers for Stateless Architecture
+// =============================================================================
+
+/**
+ * Create a results collector that simulates client behavior.
+ * Maintains current state by applying incoming Message updates.
+ *
+ * NEW PROTOCOL:
+ * - { $: "snapshot", data } → replace current state
+ * - { $: "ops", ops: Op[] } → apply operations to current state
+ * - { $: "error", error } → error message
+ */
+function createResultsCollector() {
+	let currentData: unknown = null;
+	const rawResults: Message[] = [];
+
+	return {
+		/** Raw results (Message format) */
+		get raw() {
+			return rawResults;
+		},
+		/** Current accumulated state */
+		get current() {
+			return currentData;
+		},
+		/** Number of ops messages received */
+		get updateCount() {
+			return rawResults.filter((r) => isOps(r)).length;
+		},
+		/** Push a Message result (applies ops if present) */
+		push(result: Message) {
+			rawResults.push(result);
+			if (isSnapshot(result)) {
+				currentData = result.data;
+			}
+			if (isOps(result)) {
+				currentData = applyOps(currentData, result.ops);
+			}
+		},
+	};
+}
+
 // =============================================================================
 // Test Entities
 // =============================================================================
@@ -199,12 +260,14 @@ describe("execute", () => {
 			}),
 		);
 
-		expect(result.data).toEqual({
-			id: "123",
-			name: "Test User",
-			email: "test@example.com",
-		});
-		expect(result.error).toBeUndefined();
+		expect(isSnapshot(result)).toBe(true);
+		if (isSnapshot(result)) {
+			expect(result.data).toEqual({
+				id: "123",
+				name: "Test User",
+				email: "test@example.com",
+			});
+		}
 	});
 
 	it("executes mutation successfully", async () => {
@@ -219,12 +282,14 @@ describe("execute", () => {
 			}),
 		);
 
-		expect(result.data).toEqual({
-			id: "new-id",
-			name: "New User",
-			email: "new@example.com",
-		});
-		expect(result.error).toBeUndefined();
+		expect(isSnapshot(result)).toBe(true);
+		if (isSnapshot(result)) {
+			expect(result.data).toEqual({
+				id: "new-id",
+				name: "New User",
+				email: "new@example.com",
+			});
+		}
 	});
 
 	it("returns error for unknown operation", async () => {
@@ -239,9 +304,10 @@ describe("execute", () => {
 			}),
 		);
 
-		expect(result.data).toBeUndefined();
-		expect(result.error).toBeInstanceOf(Error);
-		expect(result.error?.message).toContain("not found");
+		expect(isError(result)).toBe(true);
+		if (isError(result)) {
+			expect(result.error).toContain("not found");
+		}
 	});
 
 	it("returns error for invalid input", async () => {
@@ -256,8 +322,7 @@ describe("execute", () => {
 			}),
 		);
 
-		expect(result.data).toBeUndefined();
-		expect(result.error).toBeInstanceOf(Error);
+		expect(isError(result)).toBe(true);
 	});
 
 	it("executes router operations with dot notation", async () => {
@@ -277,11 +342,14 @@ describe("execute", () => {
 			}),
 		);
 
-		expect(queryResult.data).toEqual({
-			id: "456",
-			name: "Test User",
-			email: "test@example.com",
-		});
+		expect(isSnapshot(queryResult)).toBe(true);
+		if (isSnapshot(queryResult)) {
+			expect(queryResult.data).toEqual({
+				id: "456",
+				name: "Test User",
+				email: "test@example.com",
+			});
+		}
 
 		const mutationResult = await firstValueFrom(
 			server.execute({
@@ -290,11 +358,14 @@ describe("execute", () => {
 			}),
 		);
 
-		expect(mutationResult.data).toEqual({
-			id: "new-id",
-			name: "Router User",
-			email: undefined,
-		});
+		expect(isSnapshot(mutationResult)).toBe(true);
+		if (isSnapshot(mutationResult)) {
+			expect(mutationResult.data).toEqual({
+				id: "new-id",
+				name: "Router User",
+				email: undefined,
+			});
+		}
 	});
 
 	it("handles resolver errors gracefully", async () => {
@@ -315,9 +386,10 @@ describe("execute", () => {
 			}),
 		);
 
-		expect(result.data).toBeUndefined();
-		expect(result.error).toBeInstanceOf(Error);
-		expect(result.error?.message).toBe("Resolver error");
+		expect(isError(result)).toBe(true);
+		if (isError(result)) {
+			expect(result.error).toBe("Resolver error");
+		}
 	});
 
 	it("executes query without input", async () => {
@@ -331,7 +403,10 @@ describe("execute", () => {
 			}),
 		);
 
-		expect(result.data).toHaveLength(2);
+		expect(isSnapshot(result)).toBe(true);
+		if (isSnapshot(result)) {
+			expect(result.data).toHaveLength(2);
+		}
 	});
 });
 
@@ -419,11 +494,14 @@ describe("selection", () => {
 			}),
 		);
 
-		expect(result.data).toEqual({
-			id: "123", // id always included
-			name: "Test User",
-		});
-		expect((result.data as Record<string, unknown>).email).toBeUndefined();
+		expect(isSnapshot(result)).toBe(true);
+		if (isSnapshot(result)) {
+			expect(result.data).toEqual({
+				id: "123", // id always included
+				name: "Test User",
+			});
+			expect((result.data as Record<string, unknown>).email).toBeUndefined();
+		}
 	});
 });
 
@@ -541,14 +619,16 @@ describe("field resolvers", () => {
 			}),
 		);
 
-		expect(result.error).toBeUndefined();
-		expect(result.data).toBeDefined();
+		expect(isSnapshot(result)).toBe(true);
+		if (isSnapshot(result)) {
+			expect(result.data).toBeDefined();
 
-		const data = result.data as { id: string; name: string; posts: { id: string; title: string }[] };
-		expect(data.id).toBe("a1");
-		expect(data.name).toBe("Alice");
-		expect(data.posts).toHaveLength(2); // limit: 2
-		expect(data.posts.every((p) => p.title)).toBe(true); // only selected fields
+			const data = result.data as { id: string; name: string; posts: { id: string; title: string }[] };
+			expect(data.id).toBe("a1");
+			expect(data.name).toBe("Alice");
+			expect(data.posts).toHaveLength(2); // limit: 2
+			expect(data.posts.every((p) => p.title)).toBe(true); // only selected fields
+		}
 	});
 
 	it("passes context to field resolvers", async () => {
@@ -739,8 +819,9 @@ describe("field resolvers", () => {
 		expect(data.posts).toHaveLength(3); // All of Alice's posts (default limit 10)
 	});
 
-	it("emit() goes through field resolvers", async () => {
-		// Track how many times posts resolver is called
+	it("emit() sends update command (stateless architecture)", async () => {
+		// STATELESS: Field resolvers only run on initial resolve.
+		// Emits forward commands to client - no re-resolution on server.
 		let postsResolverCallCount = 0;
 
 		const Author = entity("Author", {
@@ -792,7 +873,7 @@ describe("field resolvers", () => {
 		});
 
 		// Subscribe to query with nested posts
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "getAuthor",
@@ -807,31 +888,34 @@ describe("field resolvers", () => {
 			})
 			.subscribe({
 				next: (result) => {
-					results.push(result);
+					collector.push(result as Message);
 				},
 			});
 
 		// Wait for initial result
 		await new Promise((resolve) => setTimeout(resolve, 50));
 
-		expect(results.length).toBe(1);
+		expect(collector.raw.length).toBe(1);
 		expect(postsResolverCallCount).toBe(1); // Called once for initial query
 
-		// Add a new post to the mock DB
-		mockDb.posts.push({ id: "p3", title: "Post 3", authorId: "a1" });
-
-		// Emit updated author (this should trigger field resolvers)
+		// Emit updated author
 		capturedEmit!({ id: "a1", name: "Alice Updated" });
 
 		// Wait for emit to process
 		await new Promise((resolve) => setTimeout(resolve, 50));
 
-		expect(results.length).toBe(2);
-		expect(postsResolverCallCount).toBe(2); // Called again after emit!
+		// STATELESS: Server sends ops command, not re-resolved data
+		expect(collector.raw.length).toBe(2);
+		expect(postsResolverCallCount).toBe(1); // NOT called again - stateless!
 
-		// Verify the emitted result includes the new post (from re-running posts resolver)
-		const latestResult = results[1] as { data: { posts: { id: string }[] } };
-		expect(latestResult.data.posts).toHaveLength(3); // Should have 3 posts now
+		// Second result should be an ops command
+		const updateResult = collector.raw[1];
+		expect(isOps(updateResult)).toBe(true);
+
+		// Client applies update: name is updated, posts preserved from initial
+		const currentState = collector.current as { name: string; posts: { id: string }[] };
+		expect(currentState.name).toBe("Alice Updated");
+		expect(currentState.posts).toHaveLength(2); // Original 2 posts preserved
 
 		subscription.unsubscribe();
 	});
@@ -922,7 +1006,8 @@ describe("field resolvers", () => {
 		expect(cleanupCalled).toBe(true);
 	});
 
-	it("field-level emit updates specific field and notifies observer", async () => {
+	it("field-level emit sends update command (stateless)", async () => {
+		// STATELESS: Field emit sends update command with field path prefix
 		const Author = entity("Author", {
 			id: t.id(),
 			name: t.string(),
@@ -984,7 +1069,7 @@ describe("field resolvers", () => {
 			context: () => ({ db: mockDb }),
 		});
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "getAuthor",
@@ -999,18 +1084,21 @@ describe("field resolvers", () => {
 			})
 			.subscribe({
 				next: (result) => {
-					results.push(result);
+					collector.push(result as Message);
 				},
 			});
 
 		// Wait for initial result
 		await new Promise((resolve) => setTimeout(resolve, 50));
 
-		expect(results.length).toBe(1);
+		expect(collector.raw.length).toBe(1);
 		expect(capturedFieldEmit).toBeDefined();
 
-		const initialResult = results[0] as { data: { posts: { id: string }[] } };
-		expect(initialResult.data.posts).toHaveLength(2);
+		const initialResult = collector.raw[0];
+		expect(isSnapshot(initialResult)).toBe(true);
+		if (isSnapshot(initialResult)) {
+			expect((initialResult.data as { posts: { id: string }[] }).posts).toHaveLength(2);
+		}
 
 		// Use field-level emit to update just the posts field
 		const newPosts = [
@@ -1023,15 +1111,20 @@ describe("field resolvers", () => {
 		// Wait for field emit to process
 		await new Promise((resolve) => setTimeout(resolve, 50));
 
-		expect(results.length).toBe(2);
-		const updatedResult = results[1] as { data: { posts: { id: string; title: string }[] } };
-		expect(updatedResult.data.posts).toHaveLength(3);
-		expect(updatedResult.data.posts[2].title).toBe("New Post 3");
+		// STATELESS: Second result should be ops command
+		expect(collector.raw.length).toBe(2);
+		expect(isOps(collector.raw[1])).toBe(true);
+
+		// Client applies update to get final state
+		const currentState = collector.current as { posts: { id: string; title: string }[] };
+		expect(currentState.posts).toHaveLength(3);
+		expect(currentState.posts[2].title).toBe("New Post 3");
 
 		subscription.unsubscribe();
 	});
 
-	it("emit skips observer notification when value unchanged", async () => {
+	it("stateless server forwards all emit commands (no deduplication)", async () => {
+		// STATELESS: Server forwards all commands. Deduplication is client/plugin responsibility.
 		type EmitFn = (data: { id: string; name: string }) => void;
 		let capturedEmit: EmitFn | undefined;
 
@@ -1047,42 +1140,37 @@ describe("field resolvers", () => {
 		const testRouter = router({ liveQuery });
 		const app = createApp({ router: testRouter });
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const observable = app.execute({
 			path: "liveQuery",
 			input: { id: "1" },
 		});
 
 		const subscription = observable.subscribe({
-			next: (value) => results.push(value),
+			next: (value) => collector.push(value as Message),
 		});
 
 		// Wait for initial result
 		await new Promise((resolve) => setTimeout(resolve, 50));
-		expect(results.length).toBe(1);
-		const firstResult = results[0] as { data: { id: string; name: string } };
-		expect(firstResult.data.name).toBe("Initial");
-
-		// Emit same value - should be skipped (equality check)
-		capturedEmit!({ id: "1", name: "Initial" });
-		await new Promise((resolve) => setTimeout(resolve, 50));
-		expect(results.length).toBe(1); // Still 1, not 2
+		expect(collector.raw.length).toBe(1);
+		const firstResult = collector.raw[0];
+		expect(isSnapshot(firstResult)).toBe(true);
+		if (isSnapshot(firstResult)) {
+			expect(firstResult.data.name).toBe("Initial");
+		}
 
-		// Emit same value again - should be skipped
+		// STATELESS: All emits are forwarded (no deduplication)
 		capturedEmit!({ id: "1", name: "Initial" });
 		await new Promise((resolve) => setTimeout(resolve, 50));
-		expect(results.length).toBe(1); // Still 1
+		expect(collector.raw.length).toBe(2); // Command forwarded
 
-		// Emit different value - should emit
+		// Emit different value
 		capturedEmit!({ id: "1", name: "Changed" });
 		await new Promise((resolve) => setTimeout(resolve, 50));
-		expect(results.length).toBe(2); // Now 2
-		expect((results[1] as { data: { name: string } }).data.name).toBe("Changed");
+		expect(collector.raw.length).toBe(3); // Another command
 
-		// Emit same "Changed" value again - should be skipped
-		capturedEmit!({ id: "1", name: "Changed" });
-		await new Promise((resolve) => setTimeout(resolve, 50));
-		expect(results.length).toBe(2); // Still 2
+		// Client applies all updates to get final state
+		expect((collector.current as { name: string }).name).toBe("Changed");
 
 		subscription.unsubscribe();
 	});
@@ -1154,7 +1242,7 @@ describe("field resolvers", () => {
 			context: () => ({ db: mockDb }),
 		});
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "getAuthor",
@@ -1169,7 +1257,7 @@ describe("field resolvers", () => {
 			})
 			.subscribe({
 				next: (result) => {
-					results.push(result);
+					collector.push(result as Message);
 				},
 			});
 
@@ -1177,13 +1265,16 @@ describe("field resolvers", () => {
 		await new Promise((resolve) => setTimeout(resolve, 50));
 
 		// Verify initial resolution
-		expect(results.length).toBe(1);
+		expect(collector.raw.length).toBe(1);
 		expect(resolveCallCount).toBe(1); // Resolver called once
 		expect(subscribeCallCount).toBe(1); // Subscriber called once
 		expect(capturedFieldEmit).toBeDefined(); // Emit captured from subscribe phase
 
-		const initialResult = results[0] as { data: { posts: { id: string }[] } };
-		expect(initialResult.data.posts).toHaveLength(2);
+		const initialResult = collector.raw[0];
+		expect(isSnapshot(initialResult)).toBe(true);
+		if (isSnapshot(initialResult)) {
+			expect((initialResult.data as { posts: { id: string }[] }).posts).toHaveLength(2);
+		}
 
 		// Use field emit to push update (from subscribe phase)
 		const updatedPosts = [
@@ -1196,10 +1287,14 @@ describe("field resolvers", () => {
 		// Wait for update
 		await new Promise((resolve) => setTimeout(resolve, 50));
 
-		expect(results.length).toBe(2);
-		const updatedResult = results[1] as { data: { posts: { id: string; title: string }[] } };
-		expect(updatedResult.data.posts).toHaveLength(3);
-		expect(updatedResult.data.posts[2].title).toBe("New Post");
+		// STATELESS: Second result is ops command
+		expect(collector.raw.length).toBe(2);
+		expect(isOps(collector.raw[1])).toBe(true);
+
+		// Client applies update to get final state
+		const currentState = collector.current as { posts: { id: string; title: string }[] };
+		expect(currentState.posts).toHaveLength(3);
+		expect(currentState.posts[2].title).toBe("New Post");
 
 		subscription.unsubscribe();
 	});
@@ -1224,8 +1319,10 @@ describe("observable behavior", () => {
 			}),
 		);
 
-		expect(result.data).toEqual({ id: "1", name: "Test" });
-		expect(result.error).toBeUndefined();
+		expect(isSnapshot(result)).toBe(true);
+		if (isSnapshot(result)) {
+			expect(result.data).toEqual({ id: "1", name: "Test" });
+		}
 	});
 
 	it("keeps subscription open for potential emit", async () => {
@@ -1276,7 +1373,10 @@ describe("observable behavior", () => {
 			}),
 		);
 
-		expect(result.data).toEqual({ id: "new", name: "Test" });
+		expect(isSnapshot(result)).toBe(true);
+		if (isSnapshot(result)) {
+			expect(result.data).toEqual({ id: "new", name: "Test" });
+		}
 	});
 
 	it("can be unsubscribed", async () => {
@@ -1311,7 +1411,8 @@ describe("observable behavior", () => {
 // =============================================================================
 
 describe("emit backpressure", () => {
-	it("handles rapid emit calls without losing data", async () => {
+	it("handles rapid emit calls (stateless - forwards all commands)", async () => {
+		// STATELESS: Server forwards all emit commands synchronously
 		type EmitFn = (data: unknown) => void;
 		let capturedEmit: EmitFn | undefined;
 
@@ -1324,14 +1425,14 @@ describe("emit backpressure", () => {
 
 		const server = createApp({ queries: { liveQuery } });
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "liveQuery",
 				input: { id: "1" },
 			})
 			.subscribe({
-				next: (value) => results.push(value),
+				next: (value) => collector.push(value as Message),
 			});
 
 		await new Promise((r) => setTimeout(r, 50));
@@ -1344,13 +1445,11 @@ describe("emit backpressure", () => {
 		// Wait for all emits to process
 		await new Promise((r) => setTimeout(r, 100));
 
-		// Should have received all unique values
-		// Note: deduplication may reduce count if emit is too fast
-		expect(results.length).toBeGreaterThan(1);
+		// STATELESS: Should receive 1 initial + 10 updates (all forwarded)
+		expect(collector.raw.length).toBe(11);
 
-		// The last result should have count = 10
-		const lastResult = results[results.length - 1] as { data: { count: number } };
-		expect(lastResult.data.count).toBe(10);
+		// Final state after applying all updates
+		expect((collector.current as { count: number }).count).toBe(10);
 
 		subscription.unsubscribe();
 	});
@@ -1377,8 +1476,10 @@ describe("observable error handling", () => {
 			}),
 		);
 
-		expect(result.error).toBeDefined();
-		expect(result.error?.message).toBe("Test error");
+		expect(isError(result)).toBe(true);
+		if (isError(result)) {
+			expect(result.error).toBe("Test error");
+		}
 	});
 
 	it("handles async resolver errors", async () => {
@@ -1398,8 +1499,10 @@ describe("observable error handling", () => {
 			}),
 		);
 
-		expect(result.error).toBeDefined();
-		expect(result.error?.message).toBe("Async error");
+		expect(isError(result)).toBe(true);
+		if (isError(result)) {
+			expect(result.error).toBe("Async error");
+		}
 	});
 });
 
@@ -1747,21 +1850,25 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const server = createApp({ queries: { liveUser } });
 
-		const results: unknown[] = [];
+		const results: Message[] = [];
 		const subscription = server
 			.execute({
 				path: "liveUser",
 				input: { id: "1" },
 			})
 			.subscribe({
-				next: (result) => results.push(result),
+				next: (result) => results.push(result as Message),
 			});
 
 		// Wait for initial result and subscriber setup
 		await new Promise((r) => setTimeout(r, 50));
 
 		expect(results.length).toBe(1);
-		expect((results[0] as { data: { name: string } }).data.name).toBe("Initial");
+		const firstResult = results[0];
+		expect(isSnapshot(firstResult)).toBe(true);
+		if (isSnapshot(firstResult)) {
+			expect(firstResult.data.name).toBe("Initial");
+		}
 		expect(subscriberCalled).toBe(true);
 		expect(capturedEmit).toBeDefined();
 		expect(capturedOnCleanup).toBeDefined();
@@ -1769,7 +1876,7 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 		subscription.unsubscribe();
 	});
 
-	it("emits updates from subscriber emit function", async () => {
+	it("emits updates from subscriber emit function (stateless)", async () => {
 		let capturedEmit: ((value: { id: string; name: string }) => void) | undefined;
 
 		const liveUser = query()
@@ -1781,34 +1888,39 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const server = createApp({ queries: { liveUser } });
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "liveUser",
 				input: { id: "1" },
 			})
 			.subscribe({
-				next: (result) => results.push(result),
+				next: (result) => collector.push(result as Message),
 			});
 
 		// Wait for initial result
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(1);
-		expect((results[0] as { data: { name: string } }).data.name).toBe("Initial");
+		expect(collector.raw.length).toBe(1);
+		const firstResult = collector.raw[0];
+		expect(isSnapshot(firstResult)).toBe(true);
+		if (isSnapshot(firstResult)) {
+			expect(firstResult.data.name).toBe("Initial");
+		}
 
-		// Emit update via subscriber
+		// Emit update via subscriber - STATELESS: sends ops command
 		capturedEmit!({ id: "1", name: "Updated" });
 		await new Promise((r) => setTimeout(r, 50));
 
-		expect(results.length).toBe(2);
-		expect((results[1] as { data: { name: string } }).data.name).toBe("Updated");
+		expect(collector.raw.length).toBe(2);
+		expect(isOps(collector.raw[1])).toBe(true); // Ops command
+		expect((collector.current as { name: string }).name).toBe("Updated");
 
 		// Emit another update
 		capturedEmit!({ id: "1", name: "Updated Again" });
 		await new Promise((r) => setTimeout(r, 50));
 
-		expect(results.length).toBe(3);
-		expect((results[2] as { data: { name: string } }).data.name).toBe("Updated Again");
+		expect(collector.raw.length).toBe(3);
+		expect((collector.current as { name: string }).name).toBe("Updated Again");
 
 		subscription.unsubscribe();
 	});
@@ -1892,8 +2004,8 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const server = createApp({ queries: { liveUser } });
 
-		const results: unknown[] = [];
-		const errors: Error[] = [];
+		const results: Message[] = [];
+		const errors: string[] = [];
 
 		const subscription = server
 			.execute({
@@ -1902,10 +2014,11 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 			})
 			.subscribe({
 				next: (result) => {
-					if (result.error) {
-						errors.push(result.error);
+					const msg = result as Message;
+					if (isError(msg)) {
+						errors.push(msg.error);
 					} else {
-						results.push(result);
+						results.push(msg);
 					}
 				},
 			});
@@ -1917,12 +2030,12 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 		expect(results.length).toBe(1);
 		// Error from subscriber should be reported
 		expect(errors.length).toBe(1);
-		expect(errors[0].message).toBe("Subscriber error");
+		expect(errors[0]).toBe("Subscriber error");
 
 		subscription.unsubscribe();
 	});
 
-	it("works with router-based operations", async () => {
+	it("works with router-based operations (stateless)", async () => {
 		let capturedEmit: ((value: { id: string; count: number }) => void) | undefined;
 
 		const liveCounter = query()
@@ -1940,36 +2053,40 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const server = createApp({ router: appRouter });
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "counter.live",
 				input: { id: "c1" },
 			})
 			.subscribe({
-				next: (result) => results.push(result),
+				next: (result) => collector.push(result as Message),
 			});
 
 		// Wait for initial result
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(1);
-		expect((results[0] as { data: { count: number } }).data.count).toBe(0);
+		expect(collector.raw.length).toBe(1);
+		const firstResult = collector.raw[0];
+		expect(isSnapshot(firstResult)).toBe(true);
+		if (isSnapshot(firstResult)) {
+			expect(firstResult.data.count).toBe(0);
+		}
 
-		// Emit updates
+		// Emit updates - STATELESS: sends ops commands
 		capturedEmit!({ id: "c1", count: 1 });
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(2);
-		expect((results[1] as { data: { count: number } }).data.count).toBe(1);
+		expect(collector.raw.length).toBe(2);
+		expect((collector.current as { count: number }).count).toBe(1);
 
 		capturedEmit!({ id: "c1", count: 5 });
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(3);
-		expect((results[2] as { data: { count: number } }).data.count).toBe(5);
+		expect(collector.raw.length).toBe(3);
+		expect((collector.current as { count: number }).count).toBe(5);
 
 		subscription.unsubscribe();
 	});
 
-	it("supports emit.merge for partial updates", async () => {
+	it("supports emit.merge for partial updates (stateless)", async () => {
 		type EmitFn = ((value: unknown) => void) & { merge: (partial: unknown) => void };
 		let capturedEmit: EmitFn | undefined;
 
@@ -1982,36 +2099,42 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const server = createApp({ queries: { liveUser } });
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "liveUser",
 				input: { id: "1" },
 			})
 			.subscribe({
-				next: (result) => results.push(result),
+				next: (result) => collector.push(result as Message),
 			});
 
 		// Wait for initial result
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(1);
-		const initial = (results[0] as { data: { name: string; status: string } }).data;
-		expect(initial.name).toBe("Initial");
-		expect(initial.status).toBe("offline");
+		expect(collector.raw.length).toBe(1);
+		const initialResult = collector.raw[0];
+		expect(isSnapshot(initialResult)).toBe(true);
+		if (isSnapshot(initialResult)) {
+			expect(initialResult.data.name).toBe("Initial");
+			expect(initialResult.data.status).toBe("offline");
+		}
 
-		// Use merge for partial update
+		// Use merge for partial update - STATELESS: sends ops command
 		capturedEmit!.merge({ status: "online" });
 		await new Promise((r) => setTimeout(r, 50));
 
-		expect(results.length).toBe(2);
-		const updated = (results[1] as { data: { name: string; status: string } }).data;
+		expect(collector.raw.length).toBe(2);
+		expect(isOps(collector.raw[1])).toBe(true); // Ops command
+		const updated = collector.current as { name: string; status: string };
 		expect(updated.name).toBe("Initial"); // Preserved
 		expect(updated.status).toBe("online"); // Updated
 
 		subscription.unsubscribe();
 	});
 
-	it("deduplicates identical emit values", async () => {
+	it("stateless server forwards all emits (deduplication is client responsibility)", async () => {
+		// STATELESS: Server forwards all emit commands without deduplication.
+		// Deduplication can be done by client or via optional plugins.
 		let capturedEmit: ((value: { id: string; name: string }) => void) | undefined;
 
 		const liveUser = query()
@@ -2023,34 +2146,37 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const server = createApp({ queries: { liveUser } });
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "liveUser",
 				input: { id: "1" },
 			})
 			.subscribe({
-				next: (result) => results.push(result),
+				next: (result) => collector.push(result as Message),
 			});
 
 		// Wait for initial result
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(1);
+		expect(collector.raw.length).toBe(1);
 
-		// Emit same value multiple times
+		// STATELESS: All emits are forwarded (no server-side deduplication)
 		capturedEmit!({ id: "1", name: "Initial" });
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(1); // Should be deduplicated
+		expect(collector.raw.length).toBe(2); // Forwarded, not deduplicated
 
 		// Emit different value
 		capturedEmit!({ id: "1", name: "Changed" });
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(2);
+		expect(collector.raw.length).toBe(3);
 
-		// Emit same changed value again
+		// Emit same value again - still forwarded
 		capturedEmit!({ id: "1", name: "Changed" });
 		await new Promise((r) => setTimeout(r, 50));
-		expect(results.length).toBe(2); // Should be deduplicated
+		expect(collector.raw.length).toBe(4); // All forwarded
+
+		// Final state is correct after applying all updates
+		expect((collector.current as { name: string }).name).toBe("Changed");
 
 		subscription.unsubscribe();
 	});
@@ -2143,14 +2269,14 @@ describe("scalar field subscription with emit.delta()", () => {
 			resolvers: [userResolver],
 		});
 
-		const results: unknown[] = [];
+		const results: Message[] = [];
 		const subscription = server
 			.execute({
 				path: "getUserWithBio",
 				input: { id: "1" },
 			})
 			.subscribe({
-				next: (result) => results.push(result),
+				next: (result) => results.push(result as Message),
 			});
 
 		// Wait for subscription setup
@@ -2158,7 +2284,11 @@ describe("scalar field subscription with emit.delta()", () => {
 
 		// Initial result
 		expect(results.length).toBe(1);
-		expect((results[0] as { data: { bio: string } }).data.bio).toBe("Initial bio");
+		const firstResult = results[0];
+		expect(isSnapshot(firstResult)).toBe(true);
+		if (isSnapshot(firstResult)) {
+			expect((firstResult.data as { bio: string }).bio).toBe("Initial bio");
+		}
 
 		// Check that emit has delta method (EmitScalar)
 		expect(capturedEmit).toBeDefined();
@@ -2167,7 +2297,7 @@ describe("scalar field subscription with emit.delta()", () => {
 		subscription.unsubscribe();
 	});
 
-	it("emit.delta() appends text to string field", async () => {
+	it("emit.delta() sends delta command (stateless)", async () => {
 		// UserWithContent - content field resolved by field resolver
 		const UserWithContent = entity("UserWithContent", {
 			id: t.id(),
@@ -2203,32 +2333,40 @@ describe("scalar field subscription with emit.delta()", () => {
 			resolvers: [userResolver],
 		});
 
-		const results: unknown[] = [];
+		const collector = createResultsCollector();
 		const subscription = server
 			.execute({
 				path: "getUserWithContent",
 				input: { id: "1" },
 			})
 			.subscribe({
-				next: (result) => results.push(result),
+				next: (result) => collector.push(result as Message),
 			});
 
 		// Wait for subscription setup
 		await new Promise((r) => setTimeout(r, 50));
 
 		// Initial result
-		expect(results.length).toBe(1);
-		expect((results[0] as { data: { content: string } }).data.content).toBe("Hello");
+		expect(collector.raw.length).toBe(1);
+		const initialResult = collector.raw[0];
+		expect(isSnapshot(initialResult)).toBe(true);
+		if (isSnapshot(initialResult)) {
+			expect((initialResult.data as { content: string }).content).toBe("Hello");
+		}
 
-		// Use emit.delta() to append text
+		// Use emit.delta() to append text - STATELESS: sends ops command
 		capturedEmit?.delta?.([{ position: Infinity, insert: " World" }]);
 
 		// Wait for update
 		await new Promise((r) => setTimeout(r, 50));
 
-		// Should have received update with delta applied
-		expect(results.length).toBe(2);
-		expect((results[1] as { data: { content: string } }).data.content).toBe("Hello World");
+		// STATELESS: Received ops command
+		expect(collector.raw.length).toBe(2);
+		expect(isOps(collector.raw[1])).toBe(true);
+
+		// Client applies delta to get final state
+		const currentState = collector.current as { content: string };
+		expect(currentState.content).toBe("Hello World");
 
 		subscription.unsubscribe();
 	});