@sylphx/lens-server 1.11.3 → 2.0.1

package/src/server/create.test.ts

@@ -1,2361 +1,424 @@
 /**
  * @sylphx/lens-server - Server Tests
  *
- * Tests for Lens server operations and GraphStateManager integration.
+ * Tests for the pure executor server.
+ * Server only does: getMetadata() and execute()
  */
 
 import { describe, expect, it } from "bun:test";
-import { entity, mutation, query, resolver, t } from "@sylphx/lens-core";
+import { entity, mutation, query, router } from "@sylphx/lens-core";
 import { z } from "zod";
-import { createServer, type WebSocketLike } from "./create";
+import { optimisticPlugin } from "../plugin/optimistic.js";
+import { createApp } from "./create.js";
 
 // =============================================================================
-// Test Fixtures
+// Test Entities
 // =============================================================================
 
-// Entities
 const User = entity("User", {
-	id: t.id(),
-	name: t.string(),
-	email: t.string(),
-	bio: t.string().nullable(),
+	id: z.string(),
+	name: z.string(),
+	email: z.string().optional(),
 });
 
-const Post = entity("Post", {
-	id: t.id(),
-	title: t.string(),
-	content: t.string(),
-	authorId: t.string(),
-});
-
-// Mock data
-const mockUsers = [
-	{ id: "user-1", name: "Alice", email: "alice@example.com", bio: "Developer" },
-	{ id: "user-2", name: "Bob", email: "bob@example.com", bio: "Designer" },
-];
-
-const _mockPosts = [
-	{ id: "post-1", title: "Hello", content: "World", authorId: "user-1" },
-	{ id: "post-2", title: "Test", content: "Post", authorId: "user-1" },
-];
-
-// Mock WebSocket factory
-function createMockWs(): WebSocketLike & { messages: string[] } {
-	const messages: string[] = [];
-	return {
-		messages,
-		send: (data: string) => messages.push(data),
-		close: () => {},
-		onmessage: null,
-		onclose: null,
-		onerror: null,
-	};
-}
-
 // =============================================================================
-// Test: Server Creation
+// Test Queries and Mutations
 // =============================================================================
 
-describe("createServer", () => {
-	it("creates a server instance", () => {
-		const server = createServer({
-			entities: { User, Post },
-		});
+const getUser = query()
+	.input(z.object({ id: z.string() }))
+	.returns(User)
+	.resolve(({ input }) => ({
+		id: input.id,
+		name: "Test User",
+		email: "test@example.com",
+	}));
 
-		expect(server).toBeDefined();
-		expect(typeof server.executeQuery).toBe("function");
-		expect(typeof server.executeMutation).toBe("function");
-		expect(typeof server.handleWebSocket).toBe("function");
-		expect(typeof server.handleRequest).toBe("function");
-		expect(typeof server.getStateManager).toBe("function");
-	});
+const getUsers = query().resolve(() => [
+	{ id: "1", name: "User 1" },
+	{ id: "2", name: "User 2" },
+]);
 
-	it("throws for invalid query definition", () => {
-		expect(() =>
-			createServer({
-				entities: { User },
-				queries: {
-					invalidQuery: { notAQuery: true } as never,
-				},
-			}),
-		).toThrow("Invalid query definition: invalidQuery");
-	});
+const createUser = mutation()
+	.input(z.object({ name: z.string(), email: z.string().optional() }))
+	.returns(User)
+	.resolve(({ input }) => ({
+		id: "new-id",
+		name: input.name,
+		email: input.email,
+	}));
 
-	it("throws for invalid mutation definition", () => {
-		expect(() =>
-			createServer({
-				entities: { User },
-				mutations: {
-					invalidMutation: { notAMutation: true } as never,
-				},
-			}),
-		).toThrow("Invalid mutation definition: invalidMutation");
-	});
-});
+const updateUser = mutation()
+	.input(z.object({ id: z.string(), name: z.string().optional() }))
+	.returns(User)
+	.resolve(({ input }) => ({
+		id: input.id,
+		name: input.name ?? "Updated",
+	}));
+
+const deleteUser = mutation()
+	.input(z.object({ id: z.string() }))
+	.resolve(() => ({ success: true }));
 
 // =============================================================================
-// Test: Query Execution
+// createApp Tests
 // =============================================================================
 
-describe("executeQuery", () => {
-	it("executes a simple query", async () => {
-		const getUsers = query()
-			.returns([User])
-			.resolve(() => mockUsers);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUsers },
-		});
-
-		const result = await server.executeQuery("getUsers");
-		expect(result).toEqual(mockUsers);
-	});
-
-	it("executes a query with input", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => {
-				return mockUsers.find((u) => u.id === input.id) ?? null;
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const result = await server.executeQuery("getUser", { id: "user-1" });
-		expect(result).toEqual(mockUsers[0]);
-	});
-
-	it("validates query input", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
+describe("createApp", () => {
+	it("creates a server instance", () => {
+		const server = createApp({
 			entities: { User },
 			queries: { getUser },
+			mutations: { createUser },
 		});
 
-		await expect(server.executeQuery("getUser", { id: 123 as unknown as string })).rejects.toThrow("Invalid input");
-	});
-
-	it("throws for unknown query", async () => {
-		const server = createServer({
-			entities: { User },
-			queries: {},
-		});
-
-		await expect(server.executeQuery("unknownQuery")).rejects.toThrow("Query not found: unknownQuery");
+		expect(server).toBeDefined();
+		expect(typeof server.getMetadata).toBe("function");
+		expect(typeof server.execute).toBe("function");
 	});
-});
 
-// =============================================================================
-// Test: Mutation Execution
-// =============================================================================
-
-describe("executeMutation", () => {
-	it("executes a simple mutation", async () => {
-		const createUser = mutation()
-			.input(z.object({ name: z.string(), email: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => ({
-				id: "user-new",
-				name: input.name,
-				email: input.email,
-			}));
-
-		const server = createServer({
-			entities: { User },
-			mutations: { createUser },
+	it("creates server with router", () => {
+		const appRouter = router({
+			user: {
+				get: getUser,
+				create: createUser,
+			},
 		});
 
-		const result = await server.executeMutation("createUser", {
-			name: "Charlie",
-			email: "charlie@example.com",
-		});
+		const server = createApp({ router: appRouter });
 
-		expect(result).toEqual({
-			id: "user-new",
-			name: "Charlie",
-			email: "charlie@example.com",
-		});
+		expect(server).toBeDefined();
+		const metadata = server.getMetadata();
+		expect(metadata.operations.user).toBeDefined();
 	});
 
-	it("validates mutation input", async () => {
-		const createUser = mutation()
-			.input(z.object({ name: z.string(), email: z.string().email() }))
-			.returns(User)
-			.resolve(({ input }) => ({ id: "new", ...input }));
-
-		const server = createServer({
-			entities: { User },
-			mutations: { createUser },
+	it("creates server with custom version", () => {
+		const server = createApp({
+			queries: { getUser },
+			version: "2.0.0",
 		});
 
-		await expect(server.executeMutation("createUser", { name: "Test", email: "invalid-email" })).rejects.toThrow(
-			"Invalid input",
-		);
+		const metadata = server.getMetadata();
+		expect(metadata.version).toBe("2.0.0");
 	});
 
-	it("throws for unknown mutation", async () => {
-		const server = createServer({
-			entities: { User },
-			mutations: {},
-		});
+	it("creates server with empty config", () => {
+		const server = createApp({});
 
-		await expect(server.executeMutation("unknownMutation", {})).rejects.toThrow("Mutation not found: unknownMutation");
+		expect(server).toBeDefined();
+		const metadata = server.getMetadata();
+		expect(metadata.version).toBe("1.0.0");
+		expect(metadata.operations).toEqual({});
 	});
 });
 
 // =============================================================================
-// Test: WebSocket Protocol
+// getMetadata Tests
 // =============================================================================
 
-describe("WebSocket Protocol", () => {
-	it("handles handshake message", () => {
-		const server = createServer({
-			entities: { User },
-			queries: {},
-			mutations: {},
-			version: "2.1.0",
+describe("getMetadata", () => {
+	it("returns correct metadata structure", () => {
+		const server = createApp({
+			queries: { getUser, getUsers },
+			mutations: { createUser, updateUser },
+			version: "1.2.3",
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Simulate handshake
-		ws.onmessage?.({ data: JSON.stringify({ type: "handshake", id: "hs-1" }) });
+		const metadata = server.getMetadata();
 
-		expect(ws.messages.length).toBe(1);
-		const response = JSON.parse(ws.messages[0]);
-		expect(response.type).toBe("handshake");
-		expect(response.id).toBe("hs-1");
-		expect(response.version).toBe("2.1.0");
+		expect(metadata.version).toBe("1.2.3");
+		expect(metadata.operations.getUser).toEqual({ type: "query" });
+		expect(metadata.operations.getUsers).toEqual({ type: "query" });
+		expect(metadata.operations.createUser.type).toBe("mutation");
+		expect(metadata.operations.updateUser.type).toBe("mutation");
 	});
 
-	it("handles query message", async () => {
-		const getUsers = query()
-			.returns([User])
-			.resolve(() => mockUsers);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUsers },
+	it("includes optimistic hints for mutations with optimisticPlugin", () => {
+		const server = createApp({
+			mutations: { createUser, updateUser, deleteUser },
+			plugins: [optimisticPlugin()],
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Simulate query
-		ws.onmessage?.({ data: JSON.stringify({ type: "query", id: "q-1", operation: "getUsers" }) });
-
-		await new Promise((r) => setTimeout(r, 20));
+		const metadata = server.getMetadata();
 
-		expect(ws.messages.length).toBe(1);
-		const response = JSON.parse(ws.messages[0]);
-		expect(response.type).toBe("result");
-		expect(response.id).toBe("q-1");
-		expect(response.data).toEqual(mockUsers);
+		// Auto-derived from naming convention when using optimisticPlugin
+		expect(metadata.operations.createUser.optimistic).toBeDefined();
+		expect(metadata.operations.updateUser.optimistic).toBeDefined();
+		expect(metadata.operations.deleteUser.optimistic).toBeDefined();
 	});
 
-	it("handles mutation message", async () => {
-		const createUser = mutation()
-			.input(z.object({ name: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => ({ id: "new", name: input.name, email: "" }));
-
-		const server = createServer({
-			entities: { User },
-			mutations: { createUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Simulate mutation
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "mutation",
-				id: "m-1",
-				operation: "createUser",
-				input: { name: "Test" },
-			}),
+	it("does not include optimistic hints without optimisticPlugin", () => {
+		const server = createApp({
+			mutations: { createUser, updateUser, deleteUser },
 		});
 
-		await new Promise((r) => setTimeout(r, 20));
+		const metadata = server.getMetadata();
 
-		expect(ws.messages.length).toBe(1);
-		const response = JSON.parse(ws.messages[0]);
-		expect(response.type).toBe("result");
-		expect(response.id).toBe("m-1");
-		expect(response.data).toEqual({ id: "new", name: "Test", email: "" });
+		// Without plugin, no optimistic hints
+		expect(metadata.operations.createUser.optimistic).toBeUndefined();
+		expect(metadata.operations.updateUser.optimistic).toBeUndefined();
+		expect(metadata.operations.deleteUser.optimistic).toBeUndefined();
 	});
 
-	it("handles parse error", () => {
-		const server = createServer({
-			entities: { User },
+	it("handles nested router paths", () => {
+		const appRouter = router({
+			user: {
+				get: getUser,
+				create: createUser,
+				profile: {
+					update: updateUser,
+				},
+			},
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Send invalid JSON
-		ws.onmessage?.({ data: "invalid json" });
+		const server = createApp({ router: appRouter });
+		const metadata = server.getMetadata();
 
-		expect(ws.messages.length).toBe(1);
-		const response = JSON.parse(ws.messages[0]);
-		expect(response.type).toBe("error");
-		expect(response.error.code).toBe("PARSE_ERROR");
+		expect(metadata.operations.user).toBeDefined();
+		expect((metadata.operations.user as Record<string, unknown>).get).toEqual({ type: "query" });
+		expect((metadata.operations.user as Record<string, unknown>).create).toBeDefined();
 	});
 });
 
 // =============================================================================
-// Test: Subscribe Protocol (Field-Level)
+// execute Tests
 // =============================================================================
 
-describe("Subscribe Protocol", () => {
-	it("handles subscribe message", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe to user
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				fields: ["name", "email"],
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 50));
-
-		// Should receive messages (either from GraphStateManager or operation-level)
-		expect(ws.messages.length).toBeGreaterThan(0);
-
-		// Find the operation-level data message (has subscription id)
-		const dataMessage = ws.messages.map((m) => JSON.parse(m)).find((m) => m.type === "data" && m.id === "sub-1");
-
-		// Should have received operation-level data
-		expect(dataMessage).toBeDefined();
-		expect(dataMessage.data).toMatchObject({ name: "Alice" });
-	});
-
-	it("handles unsubscribe message", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
+describe("execute", () => {
+	it("executes query successfully", async () => {
+		const server = createApp({
 			queries: { getUser },
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				fields: "*",
-			}),
+		const result = await server.execute({
+			path: "getUser",
+			input: { id: "123" },
 		});
 
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Unsubscribe
-		ws.onmessage?.({
-			data: JSON.stringify({ type: "unsubscribe", id: "sub-1" }),
+		expect(result.data).toEqual({
+			id: "123",
+			name: "Test User",
+			email: "test@example.com",
 		});
-
-		// Should not throw
-		expect(true).toBe(true);
+		expect(result.error).toBeUndefined();
 	});
 
-	it("handles updateFields message", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe with partial fields
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				fields: ["name"],
-			}),
+	it("executes mutation successfully", async () => {
+		const server = createApp({
+			mutations: { createUser },
 		});
 
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Update fields
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "updateFields",
-				id: "sub-1",
-				addFields: ["email"],
-				removeFields: [],
-			}),
+		const result = await server.execute({
+			path: "createUser",
+			input: { name: "New User", email: "new@example.com" },
 		});
 
-		// Should not throw
-		expect(true).toBe(true);
-	});
-});
-
-// =============================================================================
-// Test: GraphStateManager Integration
-// =============================================================================
-
-describe("GraphStateManager Integration", () => {
-	it("provides access to state manager", () => {
-		const server = createServer({
-			entities: { User },
+		expect(result.data).toEqual({
+			id: "new-id",
+			name: "New User",
+			email: "new@example.com",
 		});
-
-		const stateManager = server.getStateManager();
-		expect(stateManager).toBeDefined();
-		expect(typeof stateManager.emit).toBe("function");
-		expect(typeof stateManager.subscribe).toBe("function");
+		expect(result.error).toBeUndefined();
 	});
 
-	it("tracks client state after subscribe", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
+	it("returns error for unknown operation", async () => {
+		const server = createApp({
 			queries: { getUser },
 		});
 
-		const stateManager = server.getStateManager();
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				fields: "*",
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 50));
-
-		// State manager should have the client registered
-		const stats = stateManager.getStats();
-		expect(stats.clients).toBe(1);
-	});
-
-	it("removes client state on disconnect", async () => {
-		const server = createServer({
-			entities: { User },
+		const result = await server.execute({
+			path: "unknownOperation",
+			input: {},
 		});
 
-		const stateManager = server.getStateManager();
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Simulate disconnect
-		ws.onclose?.();
-
-		const stats = stateManager.getStats();
-		expect(stats.clients).toBe(0);
+		expect(result.data).toBeUndefined();
+		expect(result.error).toBeInstanceOf(Error);
+		expect(result.error?.message).toContain("not found");
 	});
-});
-
-// =============================================================================
-// Test: HTTP Handler
-// =============================================================================
-
-describe("handleRequest", () => {
-	it("handles query request", async () => {
-		const getUsers = query()
-			.returns([User])
-			.resolve(() => mockUsers);
 
-		const server = createServer({
-			entities: { User },
-			queries: { getUsers },
+	it("returns error for invalid input", async () => {
+		const server = createApp({
+			queries: { getUser },
 		});
 
-		const request = new Request("http://localhost/api", {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ type: "query", operation: "getUsers" }),
+		const result = await server.execute({
+			path: "getUser",
+			input: { invalid: true }, // Missing required 'id'
 		});
 
-		const response = await server.handleRequest(request);
-		expect(response.status).toBe(200);
-
-		const body = await response.json();
-		expect(body.data).toEqual(mockUsers);
+		expect(result.data).toBeUndefined();
+		expect(result.error).toBeInstanceOf(Error);
 	});
 
-	it("handles mutation request", async () => {
-		const createUser = mutation()
-			.input(z.object({ name: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => ({ id: "new", name: input.name, email: "" }));
-
-		const server = createServer({
-			entities: { User },
-			mutations: { createUser },
-		});
-
-		const request = new Request("http://localhost/api", {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ type: "mutation", operation: "createUser", input: { name: "Test" } }),
+	it("executes router operations with dot notation", async () => {
+		const appRouter = router({
+			user: {
+				get: getUser,
+				create: createUser,
+			},
 		});
 
-		const response = await server.handleRequest(request);
-		expect(response.status).toBe(200);
-
-		const body = await response.json();
-		expect(body.data).toEqual({ id: "new", name: "Test", email: "" });
-	});
+		const server = createApp({ router: appRouter });
 
-	it("rejects non-POST requests", async () => {
-		const server = createServer({
-			entities: { User },
+		const queryResult = await server.execute({
+			path: "user.get",
+			input: { id: "456" },
 		});
 
-		const request = new Request("http://localhost/api", { method: "GET" });
-		const response = await server.handleRequest(request);
-
-		expect(response.status).toBe(405);
-	});
-});
-
-// =============================================================================
-// Test: Streaming (Async Generator) Support
-// =============================================================================
-
-describe("Streaming Support", () => {
-	it("handles async generator query", async () => {
-		const streamQuery = query()
-			.returns(User)
-			.resolve(async function* () {
-				yield mockUsers[0];
-				yield mockUsers[1];
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { streamQuery },
+		expect(queryResult.data).toEqual({
+			id: "456",
+			name: "Test User",
+			email: "test@example.com",
 		});
 
-		// executeQuery returns first value
-		const result = await server.executeQuery("streamQuery");
-		expect(result).toEqual(mockUsers[0]);
-	});
-
-	it("streams values via WebSocket subscribe", async () => {
-		let yieldCount = 0;
-
-		const streamQuery = query()
-			.returns(User)
-			.resolve(async function* () {
-				yieldCount++;
-				yield mockUsers[0];
-				yieldCount++;
-				yield mockUsers[1];
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { streamQuery },
+		const mutationResult = await server.execute({
+			path: "user.create",
+			input: { name: "Router User" },
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe to stream
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "streamQuery",
-				fields: "*",
-			}),
+		expect(mutationResult.data).toEqual({
+			id: "new-id",
+			name: "Router User",
+			email: undefined,
 		});
-
-		await new Promise((r) => setTimeout(r, 50));
-
-		expect(yieldCount).toBe(2);
-		expect(ws.messages.length).toBeGreaterThanOrEqual(1);
 	});
-});
-
-// =============================================================================
-// Test: Minimum Transfer (Diff Computation)
-// =============================================================================
 
-describe("Minimum Transfer", () => {
-	it("sends initial data on subscribe", async () => {
-		let _emitFn: ((data: unknown) => void) | null = null;
-
-		const liveQuery = query()
-			.returns(User)
-			.resolve(({ emit }) => {
-				_emitFn = emit;
-				return { id: "1", name: "Alice", email: "alice@example.com" };
+	it("handles resolver errors gracefully", async () => {
+		const errorQuery = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(() => {
+				throw new Error("Resolver error");
 			});
 
-		const server = createServer({
-			entities: { User },
-			queries: { liveQuery },
+		const server = createApp({
+			queries: { errorQuery },
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "liveQuery",
-				fields: "*",
-			}),
+		const result = await server.execute({
+			path: "errorQuery",
+			input: { id: "1" },
 		});
 
-		await new Promise((r) => setTimeout(r, 50));
-
-		// First message should have data
-		expect(ws.messages.length).toBeGreaterThan(0);
-		const firstUpdate = JSON.parse(ws.messages[0]);
-		// Can be "data" or "update" with value strategy for initial
-		expect(["data", "update"]).toContain(firstUpdate.type);
-		// Verify we got the data
-		if (firstUpdate.type === "data") {
-			expect(firstUpdate.data).toMatchObject({ name: "Alice" });
-		} else {
-			expect(firstUpdate.updates).toBeDefined();
-		}
+		expect(result.data).toBeUndefined();
+		expect(result.error).toBeInstanceOf(Error);
+		expect(result.error?.message).toBe("Resolver error");
 	});
 
-	it("sends updates via emit", async () => {
-		let emitFn: ((data: unknown) => void) | null = null;
-
-		const liveQuery = query()
-			.returns(User)
-			.resolve(({ emit }) => {
-				emitFn = emit;
-				return { id: "1", name: "Alice", email: "alice@example.com" };
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { liveQuery },
+	it("executes query without input", async () => {
+		const server = createApp({
+			queries: { getUsers },
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "liveQuery",
-				fields: "*",
-			}),
+		const result = await server.execute({
+			path: "getUsers",
 		});
 
-		await new Promise((r) => setTimeout(r, 50));
-
-		const initialCount = ws.messages.length;
-
-		// Emit update with changed data
-		emitFn?.({ id: "1", name: "Bob", email: "bob@example.com" });
-
-		await new Promise((r) => setTimeout(r, 50));
-
-		// Should have received additional messages
-		expect(ws.messages.length).toBeGreaterThanOrEqual(initialCount);
+		expect(result.data).toHaveLength(2);
 	});
 });
 
 // =============================================================================
-// Test: onCleanup
+// Context Tests
 // =============================================================================
 
-describe("onCleanup", () => {
-	it("calls cleanup function on unsubscribe", async () => {
-		let cleanedUp = false;
+describe("context", () => {
+	it("passes context to resolvers", async () => {
+		let capturedContext: unknown = null;
 
-		const liveQuery = query()
-			.returns(User)
+		const contextQuery = query()
+			.input(z.object({ id: z.string() }))
 			.resolve(({ ctx }) => {
-				ctx.onCleanup(() => {
-					cleanedUp = true;
-				});
-				return mockUsers[0];
+				capturedContext = ctx;
+				return { id: "1", name: "test" };
 			});
 
-		const server = createServer({
-			entities: { User },
-			queries: { liveQuery },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "liveQuery",
-				fields: "*",
-			}),
+		const server = createApp({
+			queries: { contextQuery },
+			context: () => ({ userId: "user-123", role: "admin" }),
 		});
 
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Unsubscribe
-		ws.onmessage?.({
-			data: JSON.stringify({ type: "unsubscribe", id: "sub-1" }),
-		});
-
-		expect(cleanedUp).toBe(true);
-	});
-
-	it("calls cleanup on client disconnect", async () => {
-		let cleanedUp = false;
-
-		const liveQuery = query()
-			.returns(User)
-			.resolve(({ ctx }) => {
-				ctx.onCleanup(() => {
-					cleanedUp = true;
-				});
-				return mockUsers[0];
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { liveQuery },
+		await server.execute({
+			path: "contextQuery",
+			input: { id: "1" },
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "liveQuery",
-				fields: "*",
-			}),
+		expect(capturedContext).toMatchObject({
+			userId: "user-123",
+			role: "admin",
 		});
-
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Disconnect
-		ws.onclose?.();
-
-		expect(cleanedUp).toBe(true);
 	});
 
-	it("allows cleanup removal via returned function", async () => {
-		let cleanedUp = false;
+	it("supports async context factory", async () => {
+		let capturedContext: unknown = null;
 
-		const liveQuery = query()
-			.returns(User)
+		const contextQuery = query()
+			.input(z.object({ id: z.string() }))
 			.resolve(({ ctx }) => {
-				const remove = ctx.onCleanup(() => {
-					cleanedUp = true;
-				});
-				// Remove the cleanup before unsubscribe
-				remove();
-				return mockUsers[0];
+				capturedContext = ctx;
+				return { id: "1", name: "test" };
 			});
 
-		const server = createServer({
-			entities: { User },
-			queries: { liveQuery },
+		const server = createApp({
+			queries: { contextQuery },
+			context: async () => {
+				await new Promise((r) => setTimeout(r, 10));
+				return { userId: "async-user" };
+			},
 		});
 
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "liveQuery",
-				fields: "*",
-			}),
+		await server.execute({
+			path: "contextQuery",
+			input: { id: "1" },
 		});
 
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Unsubscribe
-		ws.onmessage?.({
-			data: JSON.stringify({ type: "unsubscribe", id: "sub-1" }),
+		expect(capturedContext).toMatchObject({
+			userId: "async-user",
 		});
-
-		// Should not have cleaned up since we removed it
-		expect(cleanedUp).toBe(false);
 	});
 });
 
 // =============================================================================
-// Test: execute() method (for in-process transport)
+// Selection Tests
 // =============================================================================
 
-describe("execute method", () => {
-	it("executes a query operation", async () => {
-		const getUsers = query()
-			.returns([User])
-			.resolve(() => mockUsers);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUsers },
+describe("selection", () => {
+	it("supports $select in input", async () => {
+		const server = createApp({
+			queries: { getUser },
 		});
 
-		const result = await server.execute({ path: "getUsers" });
-		expect(result.data).toEqual(mockUsers);
-		expect(result.error).toBeUndefined();
-	});
-
-	it("executes a mutation operation", async () => {
-		const createUser = mutation()
-			.input(z.object({ name: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => ({ id: "new", name: input.name, email: "" }));
-
-		const server = createServer({
-			entities: { User },
-			mutations: { createUser },
+		const result = await server.execute({
+			path: "getUser",
+			input: {
+				id: "123",
+				$select: { name: true },
+			},
 		});
 
-		const result = await server.execute({ path: "createUser", input: { name: "Test" } });
-		expect(result.data).toEqual({ id: "new", name: "Test", email: "" });
-		expect(result.error).toBeUndefined();
-	});
-
-	it("returns error for unknown operation", async () => {
-		const server = createServer({
-			entities: { User },
+		expect(result.data).toEqual({
+			id: "123", // id always included
+			name: "Test User",
 		});
-
-		const result = await server.execute({ path: "unknownOp" });
-		expect(result.data).toBeUndefined();
-		expect(result.error).toBeDefined();
-		expect(result.error?.message).toBe("Operation not found: unknownOp");
+		expect((result.data as Record<string, unknown>).email).toBeUndefined();
 	});
+});
 
-	it("catches and returns errors from operations", async () => {
-		const errorQuery = query()
-			.returns(User)
-			.resolve(() => {
-				throw new Error("Test error");
-			});
+// =============================================================================
+// Type Inference Tests
+// =============================================================================
 
-		const server = createServer({
-			entities: { User },
-			queries: { errorQuery },
-		});
-
-		const result = await server.execute({ path: "errorQuery" });
-		expect(result.data).toBeUndefined();
-		expect(result.error).toBeDefined();
-		expect(result.error?.message).toBe("Test error");
-	});
-
-	it("converts non-Error exceptions to Error objects", async () => {
-		const errorQuery = query()
-			.returns(User)
-			.resolve(() => {
-				throw "String error";
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { errorQuery },
-		});
-
-		const result = await server.execute({ path: "errorQuery" });
-		expect(result.error).toBeDefined();
-		expect(result.error?.message).toBe("String error");
-	});
-});
-
-// =============================================================================
-// Test: getMetadata() and buildOperationsMap()
-// =============================================================================
-
-describe("getMetadata", () => {
-	it("returns server metadata with version and operations", () => {
-		const getUser = query()
-			.returns(User)
-			.resolve(() => mockUsers[0]);
-
-		const createUser = mutation()
-			.input(z.object({ name: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => ({ id: "new", name: input.name, email: "" }));
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-			mutations: { createUser },
-			version: "1.2.3",
-		});
-
-		const metadata = server.getMetadata();
-		expect(metadata.version).toBe("1.2.3");
-		expect(metadata.operations).toBeDefined();
-		expect(metadata.operations.getUser).toEqual({ type: "query" });
-		// createUser auto-derives optimistic "create" from naming convention (converted to Pipeline)
-		expect((metadata.operations.createUser as any).type).toBe("mutation");
-		expect((metadata.operations.createUser as any).optimistic.$pipe).toBeDefined();
-		expect((metadata.operations.createUser as any).optimistic.$pipe[0].$do).toBe("entity.create");
-	});
-
-	it("builds nested operations map from namespaced routes", () => {
-		const getUserQuery = query()
-			.returns(User)
-			.resolve(() => mockUsers[0]);
-
-		const createUserMutation = mutation()
-			.input(z.object({ name: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => ({ id: "new", name: input.name, email: "" }));
-
-		const server = createServer({
-			entities: { User },
-			queries: { "user.get": getUserQuery },
-			mutations: { "user.create": createUserMutation },
+describe("type inference", () => {
+	it("infers types correctly", () => {
+		const server = createApp({
+			queries: { getUser },
+			mutations: { createUser },
 		});
 
+		// Type check - if this compiles, types are working
 		const metadata = server.getMetadata();
-		expect(metadata.operations.user).toBeDefined();
-		expect((metadata.operations.user as any).get).toEqual({ type: "query" });
-		// Auto-derives optimistic "create" from naming convention (converted to Pipeline)
-		expect((metadata.operations.user as any).create.type).toBe("mutation");
-		expect((metadata.operations.user as any).create.optimistic.$pipe).toBeDefined();
-		expect((metadata.operations.user as any).create.optimistic.$pipe[0].$do).toBe("entity.create");
-	});
-
-	it("includes optimistic config in mutation metadata", () => {
-		const updateUser = mutation()
-			.input(z.object({ id: z.string(), name: z.string() }))
-			.returns(User)
-			.optimistic("merge")
-			.resolve(({ input }) => ({ id: input.id, name: input.name, email: "" }));
-
-		const server = createServer({
-			entities: { User },
-			mutations: { updateUser },
-		});
-
-		const metadata = server.getMetadata();
-		// Sugar "merge" is converted to Reify Pipeline
-		expect(metadata.operations.updateUser).toEqual({
-			type: "mutation",
-			optimistic: {
-				$pipe: [
-					{
-						$do: "entity.update",
-						$with: {
-							type: "User",
-							id: { $input: "id" },
-							name: { $input: "name" },
-						},
-					},
-				],
-			},
-		});
-	});
-
-	it("handles deeply nested namespaced operations", () => {
-		const deepQuery = query()
-			.returns(User)
-			.resolve(() => mockUsers[0]);
-
-		const server = createServer({
-			entities: { User },
-			queries: { "api.v1.user.get": deepQuery },
-		});
-
-		const metadata = server.getMetadata();
-		const operations = metadata.operations as any;
-		expect(operations.api.v1.user.get).toEqual({ type: "query" });
-	});
-});
-
-// =============================================================================
-// Test: HTTP handleRequest edge cases
-// =============================================================================
-
-describe("handleRequest edge cases", () => {
-	it("returns metadata on GET /__lens/metadata", async () => {
-		const server = createServer({
-			entities: { User },
-			version: "1.0.0",
-		});
-
-		const request = new Request("http://localhost/__lens/metadata", { method: "GET" });
-		const response = await server.handleRequest(request);
-
-		expect(response.status).toBe(200);
-		const body = await response.json();
-		expect(body.version).toBe("1.0.0");
-		expect(body.operations).toBeDefined();
-	});
-
-	it("returns 404 for unknown operation", async () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const request = new Request("http://localhost/api", {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ operation: "unknownOp" }),
-		});
-
-		const response = await server.handleRequest(request);
-		expect(response.status).toBe(404);
-
-		const body = await response.json();
-		expect(body.error).toBe("Operation not found: unknownOp");
-	});
-
-	it("returns 500 for operation errors", async () => {
-		const errorQuery = query()
-			.returns(User)
-			.resolve(() => {
-				throw new Error("Internal error");
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { errorQuery },
-		});
-
-		const request = new Request("http://localhost/api", {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ operation: "errorQuery" }),
-		});
-
-		const response = await server.handleRequest(request);
-		expect(response.status).toBe(500);
-
-		const body = await response.json();
-		expect(body.error).toContain("Internal error");
-	});
-
-	it("handles POST requests for queries", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const request = new Request("http://localhost/api", {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({ operation: "getUser", input: { id: "user-1" } }),
-		});
-
-		const response = await server.handleRequest(request);
-		expect(response.status).toBe(200);
-
-		const body = await response.json();
-		expect(body.data).toEqual(mockUsers[0]);
-	});
-});
-
-// =============================================================================
-// Test: Context creation errors
-// =============================================================================
-
-describe("Context creation errors", () => {
-	it("handles context factory errors in executeQuery", async () => {
-		const getUser = query()
-			.returns(User)
-			.resolve(() => mockUsers[0]);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-			context: () => {
-				throw new Error("Context creation failed");
-			},
-		});
-
-		await expect(server.executeQuery("getUser")).rejects.toThrow("Context creation failed");
-	});
-
-	it("handles async context factory errors in executeMutation", async () => {
-		const createUser = mutation()
-			.input(z.object({ name: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => ({ id: "new", name: input.name, email: "" }));
-
-		const server = createServer({
-			entities: { User },
-			mutations: { createUser },
-			context: async () => {
-				throw new Error("Async context error");
-			},
-		});
-
-		await expect(server.executeMutation("createUser", { name: "Test" })).rejects.toThrow("Async context error");
-	});
-
-	it("handles context errors in subscription", async () => {
-		const liveQuery = query()
-			.returns(User)
-			.resolve(() => mockUsers[0]);
-
-		const server = createServer({
-			entities: { User },
-			queries: { liveQuery },
-			context: () => {
-				throw new Error("Context error in subscription");
-			},
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "liveQuery",
-				fields: "*",
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 50));
-
-		// Should receive error message
-		const errorMsg = ws.messages.find((m) => {
-			const parsed = JSON.parse(m);
-			return parsed.type === "error" && parsed.id === "sub-1";
-		});
-
-		expect(errorMsg).toBeDefined();
-		const parsed = JSON.parse(errorMsg!);
-		expect(parsed.error.message).toContain("Context error in subscription");
-	});
-});
-
-// =============================================================================
-// Test: Subscription edge cases
-// =============================================================================
-
-describe("Subscription edge cases", () => {
-	it("handles subscription input validation errors", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string().min(5) }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "getUser",
-				input: { id: "a" }, // Too short
-				fields: "*",
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 50));
-
-		const errorMsg = ws.messages.find((m) => {
-			const parsed = JSON.parse(m);
-			return parsed.type === "error";
-		});
-
-		expect(errorMsg).toBeDefined();
-		const parsed = JSON.parse(errorMsg!);
-		expect(parsed.error.message).toContain("Invalid input");
-	});
-
-	it("handles updateFields for non-existent subscription", () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Try to update fields for non-existent subscription
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "updateFields",
-				id: "non-existent",
-				addFields: ["name"],
-			}),
-		});
-
-		// Should not throw - just be a no-op
-		expect(true).toBe(true);
-	});
-
-	it("handles unsubscribe for non-existent subscription", () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Try to unsubscribe from non-existent subscription
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "unsubscribe",
-				id: "non-existent",
-			}),
-		});
-
-		// Should not throw - just be a no-op
-		expect(true).toBe(true);
-	});
-
-	it("upgrades to full subscription with wildcard", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe with partial fields
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				fields: ["name"],
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Upgrade to full subscription
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "updateFields",
-				id: "sub-1",
-				addFields: ["*"],
-			}),
-		});
-
-		// Should not throw
-		expect(true).toBe(true);
-	});
-
-	it("downgrades from wildcard to specific fields", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe with wildcard
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				fields: "*",
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Downgrade to specific fields
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "updateFields",
-				id: "sub-1",
-				setFields: ["name", "email"],
-			}),
-		});
-
-		// Should not throw
-		expect(true).toBe(true);
-	});
-
-	it("ignores add/remove when already subscribed to wildcard", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe with wildcard
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				fields: "*",
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Try to add fields (should be ignored)
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "updateFields",
-				id: "sub-1",
-				addFields: ["bio"],
-			}),
-		});
-
-		// Should not throw
-		expect(true).toBe(true);
-	});
-
-	it("handles async generator with empty stream", async () => {
-		const emptyStream = query()
-			.returns(User)
-			.resolve(async function* () {
-				// Empty generator - yields nothing
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { emptyStream },
-		});
-
-		await expect(server.executeQuery("emptyStream")).rejects.toThrow("returned empty stream");
-	});
-});
-
-// =============================================================================
-// Test: Query with $select
-// =============================================================================
-
-describe("Query with $select", () => {
-	it("handles query with $select parameter", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		// Use $select to trigger selection processing
-		const result = await server.executeQuery("getUser", {
-			id: "user-1",
-			$select: { name: true, email: true },
-		});
-
-		expect(result).toBeDefined();
-		expect((result as any).id).toBe("user-1");
-		expect((result as any).name).toBe("Alice");
-	});
-
-	it("processes WebSocket query message with select", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Query with select
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "query",
-				id: "q-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				select: { name: true, email: true },
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 20));
-
-		expect(ws.messages.length).toBe(1);
-		const response = JSON.parse(ws.messages[0]);
-		expect(response.type).toBe("result");
-		expect(response.data.name).toBe("Alice");
-	});
-
-	it("applies field selection with fields array", async () => {
-		const getUser = query()
-			.input(z.object({ id: z.string() }))
-			.returns(User)
-			.resolve(({ input }) => mockUsers.find((u) => u.id === input.id) ?? null);
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Query with fields array (backward compat)
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "query",
-				id: "q-1",
-				operation: "getUser",
-				input: { id: "user-1" },
-				fields: ["name"],
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 20));
-
-		expect(ws.messages.length).toBe(1);
-		const response = JSON.parse(ws.messages[0]);
-		expect(response.type).toBe("result");
-		expect(response.data.id).toBe("user-1"); // id is always included
-		expect(response.data.name).toBe("Alice");
-	});
-});
-
-// =============================================================================
-// Test: Logger integration
-// =============================================================================
-
-describe("Logger integration", () => {
-	it("calls logger.error on cleanup errors", async () => {
-		const errorLogs: string[] = [];
-		const liveQuery = query()
-			.returns(User)
-			.resolve(({ ctx }) => {
-				ctx.onCleanup(() => {
-					throw new Error("Cleanup failed");
-				});
-				return mockUsers[0];
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { liveQuery },
-			logger: {
-				error: (msg, ...args) => {
-					errorLogs.push(`${msg} ${args.join(" ")}`);
-				},
-			},
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "liveQuery",
-				fields: "*",
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Unsubscribe (triggers cleanup error)
-		ws.onmessage?.({
-			data: JSON.stringify({ type: "unsubscribe", id: "sub-1" }),
-		});
-
-		expect(errorLogs.length).toBeGreaterThan(0);
-		expect(errorLogs[0]).toContain("Cleanup error");
-	});
-
-	it("calls logger.error on disconnect cleanup errors", async () => {
-		const errorLogs: string[] = [];
-		const liveQuery = query()
-			.returns(User)
-			.resolve(({ ctx }) => {
-				ctx.onCleanup(() => {
-					throw new Error("Disconnect cleanup failed");
-				});
-				return mockUsers[0];
-			});
-
-		const server = createServer({
-			entities: { User },
-			queries: { liveQuery },
-			logger: {
-				error: (msg, ...args) => {
-					errorLogs.push(`${msg} ${args.join(" ")}`);
-				},
-			},
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Subscribe
-		ws.onmessage?.({
-			data: JSON.stringify({
-				type: "subscribe",
-				id: "sub-1",
-				operation: "liveQuery",
-				fields: "*",
-			}),
-		});
-
-		await new Promise((r) => setTimeout(r, 20));
-
-		// Disconnect (triggers cleanup)
-		ws.onclose?.();
-
-		expect(errorLogs.length).toBeGreaterThan(0);
-		expect(errorLogs[0]).toContain("Cleanup error");
-	});
-});
-
-// =============================================================================
-// Test: DataLoader Batching
-// =============================================================================
-
-describe("DataLoader Batching", () => {
-	it("batches multiple load calls into single batch function call", async () => {
-		let batchCallCount = 0;
-		let receivedKeys: string[] = [];
-
-		class TestDataLoader {
-			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
-			private scheduled = false;
-
-			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
-
-			async load(key: string): Promise<string | null> {
-				return new Promise((resolve, reject) => {
-					const existing = this.batch.get(key);
-					if (existing) {
-						existing.push({ resolve, reject });
-					} else {
-						this.batch.set(key, [{ resolve, reject }]);
-					}
-					this.scheduleDispatch();
-				});
-			}
-
-			private scheduleDispatch(): void {
-				if (this.scheduled) return;
-				this.scheduled = true;
-				queueMicrotask(() => this.dispatch());
-			}
-
-			private async dispatch(): Promise<void> {
-				this.scheduled = false;
-				const batch = this.batch;
-				this.batch = new Map();
-
-				const keys = Array.from(batch.keys());
-				if (keys.length === 0) return;
-
-				try {
-					const results = await this.batchFn(keys);
-					keys.forEach((key, index) => {
-						const callbacks = batch.get(key)!;
-						const result = results[index] ?? null;
-						for (const { resolve } of callbacks) resolve(result);
-					});
-				} catch (error) {
-					for (const callbacks of batch.values()) {
-						for (const { reject } of callbacks) reject(error as Error);
-					}
-				}
-			}
-
-			clear(): void {
-				this.batch.clear();
-			}
-		}
-
-		const loader = new TestDataLoader(async (keys) => {
-			batchCallCount++;
-			receivedKeys = keys;
-			return keys.map((k) => `value-${k}`);
-		});
-
-		// Load multiple keys in same tick
-		const promises = [loader.load("key1"), loader.load("key2"), loader.load("key3")];
-
-		const results = await Promise.all(promises);
-
-		// Should batch all calls into single batch function call
-		expect(batchCallCount).toBe(1);
-		expect(receivedKeys).toEqual(["key1", "key2", "key3"]);
-		expect(results).toEqual(["value-key1", "value-key2", "value-key3"]);
-	});
-
-	it("handles duplicate keys in same batch", async () => {
-		class TestDataLoader {
-			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
-			private scheduled = false;
-
-			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
-
-			async load(key: string): Promise<string | null> {
-				return new Promise((resolve, reject) => {
-					const existing = this.batch.get(key);
-					if (existing) {
-						existing.push({ resolve, reject });
-					} else {
-						this.batch.set(key, [{ resolve, reject }]);
-					}
-					this.scheduleDispatch();
-				});
-			}
-
-			private scheduleDispatch(): void {
-				if (this.scheduled) return;
-				this.scheduled = true;
-				queueMicrotask(() => this.dispatch());
-			}
-
-			private async dispatch(): Promise<void> {
-				this.scheduled = false;
-				const batch = this.batch;
-				this.batch = new Map();
-
-				const keys = Array.from(batch.keys());
-				if (keys.length === 0) return;
-
-				try {
-					const results = await this.batchFn(keys);
-					keys.forEach((key, index) => {
-						const callbacks = batch.get(key)!;
-						const result = results[index] ?? null;
-						for (const { resolve } of callbacks) resolve(result);
-					});
-				} catch (error) {
-					for (const callbacks of batch.values()) {
-						for (const { reject } of callbacks) reject(error as Error);
-					}
-				}
-			}
-
-			clear(): void {
-				this.batch.clear();
-			}
-		}
-
-		const loader = new TestDataLoader(async (keys) => {
-			return keys.map((k) => `value-${k}`);
-		});
-
-		// Load same key multiple times
-		const promises = [loader.load("key1"), loader.load("key1"), loader.load("key1")];
-
-		const results = await Promise.all(promises);
-
-		// All should resolve with same value
-		expect(results).toEqual(["value-key1", "value-key1", "value-key1"]);
-	});
-
-	it("handles batch function errors", async () => {
-		class TestDataLoader {
-			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
-			private scheduled = false;
-
-			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
-
-			async load(key: string): Promise<string | null> {
-				return new Promise((resolve, reject) => {
-					const existing = this.batch.get(key);
-					if (existing) {
-						existing.push({ resolve, reject });
-					} else {
-						this.batch.set(key, [{ resolve, reject }]);
-					}
-					this.scheduleDispatch();
-				});
-			}
-
-			private scheduleDispatch(): void {
-				if (this.scheduled) return;
-				this.scheduled = true;
-				queueMicrotask(() => this.dispatch());
-			}
-
-			private async dispatch(): Promise<void> {
-				this.scheduled = false;
-				const batch = this.batch;
-				this.batch = new Map();
-
-				const keys = Array.from(batch.keys());
-				if (keys.length === 0) return;
-
-				try {
-					const results = await this.batchFn(keys);
-					keys.forEach((key, index) => {
-						const callbacks = batch.get(key)!;
-						const result = results[index] ?? null;
-						for (const { resolve } of callbacks) resolve(result);
-					});
-				} catch (error) {
-					for (const callbacks of batch.values()) {
-						for (const { reject } of callbacks) reject(error as Error);
-					}
-				}
-			}
-
-			clear(): void {
-				this.batch.clear();
-			}
-		}
-
-		const loader = new TestDataLoader(async () => {
-			throw new Error("Batch function error");
-		});
-
-		const promises = [loader.load("key1"), loader.load("key2")];
-
-		// All loads should reject with same error
-		await expect(Promise.all(promises)).rejects.toThrow("Batch function error");
-	});
-
-	it("does not schedule dispatch twice if already scheduled", async () => {
-		let dispatchCount = 0;
-
-		class TestDataLoader {
-			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
-			private scheduled = false;
-
-			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
-
-			async load(key: string): Promise<string | null> {
-				return new Promise((resolve, reject) => {
-					const existing = this.batch.get(key);
-					if (existing) {
-						existing.push({ resolve, reject });
-					} else {
-						this.batch.set(key, [{ resolve, reject }]);
-					}
-					this.scheduleDispatch();
-				});
-			}
-
-			private scheduleDispatch(): void {
-				if (this.scheduled) return;
-				this.scheduled = true;
-				queueMicrotask(() => this.dispatch());
-			}
-
-			private async dispatch(): Promise<void> {
-				dispatchCount++;
-				this.scheduled = false;
-				const batch = this.batch;
-				this.batch = new Map();
-
-				const keys = Array.from(batch.keys());
-				if (keys.length === 0) return;
-
-				try {
-					const results = await this.batchFn(keys);
-					keys.forEach((key, index) => {
-						const callbacks = batch.get(key)!;
-						const result = results[index] ?? null;
-						for (const { resolve } of callbacks) resolve(result);
-					});
-				} catch (error) {
-					for (const callbacks of batch.values()) {
-						for (const { reject } of callbacks) reject(error as Error);
-					}
-				}
-			}
-
-			clear(): void {
-				this.batch.clear();
-			}
-		}
-
-		const loader = new TestDataLoader(async (keys) => {
-			return keys.map((k) => `value-${k}`);
-		});
-
-		// Load multiple keys
-		await Promise.all([loader.load("key1"), loader.load("key2"), loader.load("key3")]);
-
-		// Should only dispatch once despite multiple load calls
-		expect(dispatchCount).toBe(1);
-	});
-
-	it("clears pending batches when clear is called", () => {
-		class TestDataLoader {
-			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
-			private scheduled = false;
-
-			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
-
-			async load(key: string): Promise<string | null> {
-				return new Promise((resolve, reject) => {
-					const existing = this.batch.get(key);
-					if (existing) {
-						existing.push({ resolve, reject });
-					} else {
-						this.batch.set(key, [{ resolve, reject }]);
-					}
-					this.scheduleDispatch();
-				});
-			}
-
-			private scheduleDispatch(): void {
-				if (this.scheduled) return;
-				this.scheduled = true;
-				queueMicrotask(() => this.dispatch());
-			}
-
-			private async dispatch(): Promise<void> {
-				this.scheduled = false;
-				const batch = this.batch;
-				this.batch = new Map();
-
-				const keys = Array.from(batch.keys());
-				if (keys.length === 0) return;
-
-				try {
-					const results = await this.batchFn(keys);
-					keys.forEach((key, index) => {
-						const callbacks = batch.get(key)!;
-						const result = results[index] ?? null;
-						for (const { resolve } of callbacks) resolve(result);
-					});
-				} catch (error) {
-					for (const callbacks of batch.values()) {
-						for (const { reject } of callbacks) reject(error as Error);
-					}
-				}
-			}
-
-			clear(): void {
-				this.batch.clear();
-			}
-
-			getBatchSize(): number {
-				return this.batch.size;
-			}
-		}
-
-		const loader = new TestDataLoader(async (keys) => {
-			return keys.map((k) => `value-${k}`);
-		});
-
-		// Add some items to batch (but don't await - they won't dispatch yet)
-		loader.load("key1");
-		loader.load("key2");
-
-		// Clear should remove pending items
-		loader.clear();
-
-		// Batch should be empty
-		expect(loader.getBatchSize()).toBe(0);
-	});
-
-	it("handles null results from batch function", async () => {
-		class TestDataLoader {
-			private batch: Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }[]> = new Map();
-			private scheduled = false;
-
-			constructor(private batchFn: (keys: string[]) => Promise<(string | null)[]>) {}
-
-			async load(key: string): Promise<string | null> {
-				return new Promise((resolve, reject) => {
-					const existing = this.batch.get(key);
-					if (existing) {
-						existing.push({ resolve, reject });
-					} else {
-						this.batch.set(key, [{ resolve, reject }]);
-					}
-					this.scheduleDispatch();
-				});
-			}
-
-			private scheduleDispatch(): void {
-				if (this.scheduled) return;
-				this.scheduled = true;
-				queueMicrotask(() => this.dispatch());
-			}
-
-			private async dispatch(): Promise<void> {
-				this.scheduled = false;
-				const batch = this.batch;
-				this.batch = new Map();
-
-				const keys = Array.from(batch.keys());
-				if (keys.length === 0) return;
-
-				try {
-					const results = await this.batchFn(keys);
-					keys.forEach((key, index) => {
-						const callbacks = batch.get(key)!;
-						const result = results[index] ?? null;
-						for (const { resolve } of callbacks) resolve(result);
-					});
-				} catch (error) {
-					for (const callbacks of batch.values()) {
-						for (const { reject } of callbacks) reject(error as Error);
-					}
-				}
-			}
-
-			clear(): void {
-				this.batch.clear();
-			}
-		}
-
-		const loader = new TestDataLoader(async (keys) => {
-			// Return null for some keys
-			return keys.map((k) => (k === "key2" ? null : `value-${k}`));
-		});
-
-		const results = await Promise.all([loader.load("key1"), loader.load("key2"), loader.load("key3")]);
-
-		expect(results).toEqual(["value-key1", null, "value-key3"]);
-	});
-});
-
-// =============================================================================
-// Test: HTTP Server Lifecycle (listen, close, findConnectionByWs)
-// =============================================================================
-
-describe("HTTP Server Lifecycle", () => {
-	it("handles GET requests that are not metadata endpoint", async () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const request = new Request("http://localhost/some-other-path", { method: "GET" });
-		const response = await server.handleRequest(request);
-
-		expect(response.status).toBe(405);
-		const text = await response.text();
-		expect(text).toBe("Method not allowed");
-	});
-
-	it("handles PUT requests", async () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const request = new Request("http://localhost/api", { method: "PUT" });
-		const response = await server.handleRequest(request);
-
-		expect(response.status).toBe(405);
-		const text = await response.text();
-		expect(text).toBe("Method not allowed");
-	});
-
-	it("handles DELETE requests", async () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const request = new Request("http://localhost/api", { method: "DELETE" });
-		const response = await server.handleRequest(request);
-
-		expect(response.status).toBe(405);
-		const text = await response.text();
-		expect(text).toBe("Method not allowed");
-	});
-
-	it("handles PATCH requests", async () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const request = new Request("http://localhost/api", { method: "PATCH" });
-		const response = await server.handleRequest(request);
-
-		expect(response.status).toBe(405);
-		const text = await response.text();
-		expect(text).toBe("Method not allowed");
-	});
-
-	it("handles OPTIONS requests", async () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const request = new Request("http://localhost/api", { method: "OPTIONS" });
-		const response = await server.handleRequest(request);
-
-		expect(response.status).toBe(405);
-		const text = await response.text();
-		expect(text).toBe("Method not allowed");
-	});
-
-	it("handles HEAD requests", async () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const request = new Request("http://localhost/api", { method: "HEAD" });
-		const response = await server.handleRequest(request);
-
-		expect(response.status).toBe(405);
-	});
-
-	it("can start and stop server with listen/close", async () => {
-		const server = createServer({
-			entities: { User },
-			logger: {
-				info: () => {}, // Silent logger for test
-			},
-		});
-
-		// Start server on a random high port to avoid conflicts
-		const port = 30000 + Math.floor(Math.random() * 10000);
-
-		try {
-			await server.listen(port);
-
-			// Verify server is running by making a request
-			const response = await fetch(`http://localhost:${port}/__lens/metadata`);
-			expect(response.status).toBe(200);
-			const data = await response.json();
-			expect(data.version).toBeDefined();
-		} finally {
-			// Always close the server
-			await server.close();
-		}
-	});
-
-	it("handles method not allowed via real HTTP server", async () => {
-		const server = createServer({
-			entities: { User },
-			logger: {
-				info: () => {}, // Silent logger for test
-			},
-		});
-
-		const port = 30000 + Math.floor(Math.random() * 10000);
-
-		try {
-			await server.listen(port);
-
-			// Make a PUT request which should return 405
-			const response = await fetch(`http://localhost:${port}/api`, { method: "PUT" });
-			expect(response.status).toBe(405);
-			const text = await response.text();
-			expect(text).toBe("Method not allowed");
-		} finally {
-			await server.close();
-		}
-	});
-
-	// Note: WebSocket integration via Bun.serve's native WebSocket upgrade (lines 1184-1193)
-	// is tested through unit tests using mock WebSockets. Full integration tests with real
-	// WebSocket clients would require additional setup and are better suited for E2E tests.
-});
-
-// =============================================================================
-// Test: SSE Handler Edge Cases
-// =============================================================================
-
-describe("SSE Handler Edge Cases", () => {
-	it("handles WebSocket error callback", async () => {
-		const server = createServer({
-			entities: { User },
-		});
-
-		const ws = createMockWs();
-		server.handleWebSocket(ws);
-
-		// Trigger error callback (if set)
-		if (ws.onerror) {
-			ws.onerror(new Error("WebSocket error"));
-		}
-
-		// Should not crash
-		expect(true).toBe(true);
-	});
-});
-
-// =============================================================================
-// Test: Entity Resolvers
-// =============================================================================
-
-describe("Entity Resolvers", () => {
-	it("executes field resolvers with select", async () => {
-		const Author = entity("Author", {
-			id: t.id(),
-			name: t.string(),
-		});
-
-		const Article = entity("Article", {
-			id: t.id(),
-			title: t.string(),
-			authorId: t.string(),
-			// author relation is resolved
-		});
-
-		const mockAuthors = [
-			{ id: "author-1", name: "Alice" },
-			{ id: "author-2", name: "Bob" },
-		];
-
-		const mockArticles = [
-			{ id: "article-1", title: "First Post", authorId: "author-1" },
-			{ id: "article-2", title: "Second Post", authorId: "author-2" },
-		];
-
-		// Create resolver for Article entity
-		const articleResolver = resolver(Article, (f) => ({
-			id: f.expose("id"),
-			title: f.expose("title"),
-			author: f.one(Author).resolve(({ parent }) => {
-				return mockAuthors.find((a) => a.id === parent.authorId) ?? null;
-			}),
-		}));
-
-		const getArticle = query()
-			.input(z.object({ id: z.string() }))
-			.returns(Article)
-			.resolve(({ input }) => {
-				return mockArticles.find((a) => a.id === input.id) ?? null;
-			});
-
-		const server = createServer({
-			entities: { Article, Author },
-			queries: { getArticle },
-			resolvers: [articleResolver],
-		});
-
-		const result = await server.executeQuery("getArticle", {
-			id: "article-1",
-			$select: {
-				title: true,
-				author: {
-					select: {
-						name: true,
-					},
-				},
-			},
-		});
-
-		expect(result).toBeDefined();
-		expect((result as any).title).toBe("First Post");
-		expect((result as any).author).toBeDefined();
-		expect((result as any).author.name).toBe("Alice");
-	});
-
-	it("handles array relations in resolvers", async () => {
-		const Author = entity("Author", {
-			id: t.id(),
-			name: t.string(),
-		});
-
-		const Article = entity("Article", {
-			id: t.id(),
-			title: t.string(),
-			authorId: t.string(),
-		});
-
-		const mockArticles = [
-			{ id: "article-1", title: "First Post", authorId: "author-1" },
-			{ id: "article-2", title: "Second Post", authorId: "author-1" },
-			{ id: "article-3", title: "Third Post", authorId: "author-2" },
-		];
-
-		// Create resolver for Author entity with articles relation
-		const authorResolver = resolver(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			articles: f.many(Article).resolve(({ parent }) => {
-				return mockArticles.filter((a) => a.authorId === parent.id);
-			}),
-		}));
-
-		const getAuthor = query()
-			.input(z.object({ id: z.string() }))
-			.returns(Author)
-			.resolve(({ input }) => {
-				return { id: input.id, name: input.id === "author-1" ? "Alice" : "Bob" };
-			});
-
-		const server = createServer({
-			entities: { Article, Author },
-			queries: { getAuthor },
-			resolvers: [authorResolver],
-		});
-
-		const result = await server.executeQuery("getAuthor", {
-			id: "author-1",
-			$select: {
-				name: true,
-				articles: {
-					select: {
-						title: true,
-					},
-				},
-			},
-		});
-
-		expect(result).toBeDefined();
-		expect((result as any).name).toBe("Alice");
-		expect((result as any).articles).toBeDefined();
-		expect(Array.isArray((result as any).articles)).toBe(true);
-		expect((result as any).articles.length).toBe(2);
-		expect((result as any).articles[0].title).toBe("First Post");
-	});
-
-	it("handles field resolver with args", async () => {
-		const User = entity("User", {
-			id: t.id(),
-			name: t.string(),
-		});
-
-		const userResolver = resolver(User, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			greeting: f
-				.string()
-				.args<{ formal: boolean }>()
-				.resolve(({ parent, args }) => {
-					return args.formal ? `Good day, ${parent.name}` : `Hey ${parent.name}!`;
-				}),
-		}));
-
-		const getUser = query()
-			.returns(User)
-			.resolve(() => ({ id: "1", name: "Alice" }));
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-			resolvers: [userResolver],
-		});
-
-		const result = await server.executeQuery("getUser", {
-			$select: {
-				name: true,
-				greeting: {
-					args: { formal: true },
-				},
-			},
-		});
-
-		expect(result).toBeDefined();
-		expect((result as any).greeting).toBe("Good day, Alice");
-	});
-
-	it("returns data unchanged when no select provided", async () => {
-		const User = entity("User", {
-			id: t.id(),
-			name: t.string(),
-		});
-
-		const userResolver = resolver(User, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			bio: f.string().resolve(({ parent }) => `Biography of ${parent.name}`),
-		}));
-
-		const getUser = query()
-			.returns(User)
-			.resolve(() => ({ id: "1", name: "Alice" }));
-
-		const server = createServer({
-			entities: { User },
-			queries: { getUser },
-			resolvers: [userResolver],
-		});
-
-		const result = await server.executeQuery("getUser");
+		expect(metadata.version).toBeDefined();
 
-		expect(result).toBeDefined();
-		expect((result as any).name).toBe("Alice");
-		// bio should not be resolved without select
-		expect((result as any).bio).toBeUndefined();
+		// The _types property exists for type inference
+		expect((server as { _types?: unknown })._types).toBeUndefined(); // Runtime undefined, compile-time exists
 	});
 });