@sylphx/lens-server 3.0.1 → 4.0.0

package/src/server/create.test.ts

@@ -13,17 +13,21 @@
 import { describe, expect, it } from "bun:test";
 import {
 	applyOps,
-	entity,
+	boolean,
 	firstValueFrom,
+	id,
 	isError,
 	isOps,
 	isSnapshot,
+	list,
 	type Message,
+	model,
 	mutation,
+	nullable,
 	query,
 	resolver,
 	router,
-	t,
+	string,
 } from "@sylphx/lens-core";
 import { z } from "zod";
 import { optimisticPlugin } from "../plugin/optimistic.js";
@@ -76,10 +80,10 @@ function createResultsCollector() {
 // Test Entities
 // =============================================================================
 
-const User = entity("User", {
-	id: z.string(),
-	name: z.string(),
-	email: z.string().optional(),
+const User = model("User", {
+	id: id(),
+	name: string(),
+	email: nullable(string()),
 });
 
 // =============================================================================
@@ -89,8 +93,8 @@ const User = entity("User", {
 const getUser = query()
 	.input(z.object({ id: z.string() }))
 	.returns(User)
-	.resolve(({ input }) => ({
-		id: input.id,
+	.resolve(({ args }) => ({
+		id: args.id,
 		name: "Test User",
 		email: "test@example.com",
 	}));
@@ -103,18 +107,18 @@ const getUsers = query().resolve(() => [
 const createUser = mutation()
 	.input(z.object({ name: z.string(), email: z.string().optional() }))
 	.returns(User)
-	.resolve(({ input }) => ({
+	.resolve(({ args }) => ({
 		id: "new-id",
-		name: input.name,
-		email: input.email,
+		name: args.name,
+		email: args.email,
 	}));
 
 const updateUser = mutation()
 	.input(z.object({ id: z.string(), name: z.string().optional() }))
 	.returns(User)
-	.resolve(({ input }) => ({
-		id: input.id,
-		name: input.name ?? "Updated",
+	.resolve(({ args }) => ({
+		id: args.id,
+		name: args.name ?? "Updated",
 	}));
 
 const deleteUser = mutation()
@@ -531,17 +535,17 @@ describe("type inference", () => {
 
 describe("field resolvers", () => {
 	// Test entities for field resolver tests
-	const Author = entity("Author", {
-		id: t.id(),
-		name: t.string(),
+	const Author = model("Author", {
+		id: id(),
+		name: string(),
 	});
 
-	const Post = entity("Post", {
-		id: t.id(),
-		title: t.string(),
-		content: t.string(),
-		published: t.boolean(),
-		authorId: t.string(),
+	const Post = model("Post", {
+		id: id(),
+		title: string(),
+		content: string(),
+		published: boolean(),
+		authorId: string(),
 	});
 
 	// Mock data
@@ -562,19 +566,19 @@ describe("field resolvers", () => {
 
 	it("resolves field with nested input args (like GraphQL)", async () => {
 		// Define field resolver with args (like GraphQL)
-		const authorResolver = resolver<TestContext>()(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f
-				.many(Post)
+		const authorResolver = resolver<TestContext>()(Author, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			// New API: t.args().resolve() without type method
+			posts: t
 				.args(
 					z.object({
 						limit: z.number().optional(),
 						published: z.boolean().optional(),
 					}),
 				)
-				.resolve(({ parent, args, ctx }) => {
-					let posts = ctx.db.posts.filter((p) => p.authorId === parent.id);
+				.resolve(({ source, args, ctx }) => {
+					let posts = ctx.db.posts.filter((p) => p.authorId === source.id);
 					if (args.published !== undefined) {
 						posts = posts.filter((p) => p.published === args.published);
 					}
@@ -588,8 +592,8 @@ describe("field resolvers", () => {
 		const getAuthor = query<TestContext>()
 			.input(z.object({ id: z.string() }))
 			.returns(Author)
-			.resolve(({ input, ctx }) => {
-				const author = ctx.db.authors.find((a) => a.id === input.id);
+			.resolve(({ args, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === args.id);
 				if (!author) throw new Error("Author not found");
 				return author;
 			});
@@ -634,20 +638,21 @@ describe("field resolvers", () => {
 	it("passes context to field resolvers", async () => {
 		let capturedContext: TestContext | null = null;
 
-		const authorResolver = resolver<TestContext>()(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f.many(Post).resolve(({ parent, ctx }) => {
+		const authorResolver = resolver<TestContext>()(Author, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			// Plain function for relations (new API)
+			posts: ({ source, ctx }) => {
 				capturedContext = ctx;
-				return ctx.db.posts.filter((p) => p.authorId === parent.id);
-			}),
+				return ctx.db.posts.filter((p) => p.authorId === source.id);
+			},
 		}));
 
 		const getAuthor = query<TestContext>()
 			.input(z.object({ id: z.string() }))
 			.returns(Author)
-			.resolve(({ input, ctx }) => {
-				const author = ctx.db.authors.find((a) => a.id === input.id);
+			.resolve(({ args, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === args.id);
 				if (!author) throw new Error("Author not found");
 				return author;
 			});
@@ -677,15 +682,33 @@ describe("field resolvers", () => {
 	});
 
 	it("supports nested input at multiple levels", async () => {
-		// Comment entity for deeper nesting
-		const Comment = entity("Comment", {
-			id: t.id(),
-			body: t.string(),
-			postId: t.string(),
+		// Local models with relation fields for this test
+		const Comment = model("Comment", {
+			id: id(),
+			body: string(),
+			postId: string(),
+		});
+
+		// Post with comments relation
+		const LocalPost = model("LocalPost", {
+			id: id(),
+			title: string(),
+			comments: list(() => Comment),
+		});
+
+		// Author with posts relation
+		const LocalAuthor = model("LocalAuthor", {
+			id: id(),
+			name: string(),
+			posts: list(() => LocalPost),
 		});
 
 		const mockDbWithComments = {
-			...mockDb,
+			authors: [{ id: "a1", name: "Author 1" }],
+			posts: [
+				{ id: "p1", title: "Post 1", authorId: "a1" },
+				{ id: "p2", title: "Post 2", authorId: "a1" },
+			],
 			comments: [
 				{ id: "c1", body: "Comment 1", postId: "p1" },
 				{ id: "c2", body: "Comment 2", postId: "p1" },
@@ -695,47 +718,41 @@ describe("field resolvers", () => {
 
 		type CtxWithComments = { db: typeof mockDbWithComments };
 
-		const postResolver = resolver<CtxWithComments>()(Post, (f) => ({
-			id: f.expose("id"),
-			title: f.expose("title"),
-			comments: f
-				.many(Comment)
-				.args(z.object({ limit: z.number().optional() }))
-				.resolve(({ parent, args, ctx }) => {
-					let comments = ctx.db.comments.filter((c) => c.postId === parent.id);
-					if (args.limit !== undefined) {
-						comments = comments.slice(0, args.limit);
-					}
-					return comments;
-				}),
+		const postResolver = resolver<CtxWithComments>()(LocalPost, (t) => ({
+			id: t.expose("id"),
+			title: t.expose("title"),
+			comments: t.args(z.object({ limit: z.number().optional() })).resolve(({ source, args, ctx }) => {
+				let comments = ctx.db.comments.filter((c) => c.postId === source.id);
+				if (args.limit !== undefined) {
+					comments = comments.slice(0, args.limit);
+				}
+				return comments;
+			}),
 		}));
 
-		const authorResolver = resolver<CtxWithComments>()(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f
-				.many(Post)
-				.args(z.object({ limit: z.number().optional() }))
-				.resolve(({ parent, args, ctx }) => {
-					let posts = ctx.db.posts.filter((p) => p.authorId === parent.id);
-					if (args.limit !== undefined) {
-						posts = posts.slice(0, args.limit);
-					}
-					return posts;
-				}),
+		const authorResolver = resolver<CtxWithComments>()(LocalAuthor, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			posts: t.args(z.object({ limit: z.number().optional() })).resolve(({ source, args, ctx }) => {
+				let posts = ctx.db.posts.filter((p) => p.authorId === source.id);
+				if (args.limit !== undefined) {
+					posts = posts.slice(0, args.limit);
+				}
+				return posts;
+			}),
 		}));
 
 		const getAuthor = query<CtxWithComments>()
 			.input(z.object({ id: z.string() }))
-			.returns(Author)
-			.resolve(({ input, ctx }) => {
-				const author = ctx.db.authors.find((a) => a.id === input.id);
+			.returns(LocalAuthor)
+			.resolve(({ args, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === args.id);
 				if (!author) throw new Error("Author not found");
 				return author;
 			});
 
 		const server = createApp({
-			entities: { Author, Post, Comment },
+			entities: { LocalAuthor, LocalPost, Comment },
 			queries: { getAuthor },
 			resolvers: [authorResolver, postResolver],
 			context: () => ({ db: mockDbWithComments }),
@@ -773,22 +790,19 @@ describe("field resolvers", () => {
 	});
 
 	it("works without nested input (default args)", async () => {
-		const authorResolver = resolver<TestContext>()(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f
-				.many(Post)
-				.args(z.object({ limit: z.number().default(10) }))
-				.resolve(({ parent, args, ctx }) => {
-					return ctx.db.posts.filter((p) => p.authorId === parent.id).slice(0, args.limit);
-				}),
+		const authorResolver = resolver<TestContext>()(Author, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			posts: t.args(z.object({ limit: z.number().default(10) })).resolve(({ source, args, ctx }) => {
+				return ctx.db.posts.filter((p) => p.authorId === source.id).slice(0, args.limit);
+			}),
 		}));
 
 		const getAuthor = query<TestContext>()
 			.input(z.object({ id: z.string() }))
 			.returns(Author)
-			.resolve(({ input, ctx }) => {
-				const author = ctx.db.authors.find((a) => a.id === input.id);
+			.resolve(({ args, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === args.id);
 				if (!author) throw new Error("Author not found");
 				return author;
 			});
@@ -824,15 +838,15 @@ describe("field resolvers", () => {
 		// Emits forward commands to client - no re-resolution on server.
 		let postsResolverCallCount = 0;
 
-		const Author = entity("Author", {
-			id: t.id(),
-			name: t.string(),
+		const Author = model("Author", {
+			id: id(),
+			name: string(),
 		});
 
-		const Post = entity("Post", {
-			id: t.id(),
-			title: t.string(),
-			authorId: t.string(),
+		const Post = model("Post", {
+			id: id(),
+			title: string(),
+			authorId: string(),
 		});
 
 		const mockDb = {
@@ -843,26 +857,30 @@ describe("field resolvers", () => {
 			],
 		};
 
-		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f.many(Post).resolve(({ parent, ctx }) => {
+		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			// Plain function for relations (new API)
+			posts: ({ source, ctx }) => {
 				postsResolverCallCount++;
-				return ctx.db.posts.filter((p) => p.authorId === parent.id);
-			}),
+				return ctx.db.posts.filter((p) => p.authorId === source.id);
+			},
 		}));
 
 		type EmitFn = ((data: unknown) => void) & { merge: (partial: unknown) => void };
 		let capturedEmit: EmitFn | null = null;
 
-		const getAuthor = query<{ db: typeof mockDb; emit: EmitFn }>()
+		// Use .resolve().subscribe() pattern - emit comes through Publisher callback, NOT ctx
+		const getAuthor = query<{ db: typeof mockDb }>()
 			.input(z.object({ id: z.string() }))
 			.returns(Author)
-			.resolve(({ input, ctx }) => {
-				capturedEmit = ctx.emit as EmitFn;
-				const author = ctx.db.authors.find((a) => a.id === input.id);
+			.resolve(({ args, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === args.id);
 				if (!author) throw new Error("Author not found");
 				return author;
+			})
+			.subscribe(() => ({ emit }) => {
+				capturedEmit = emit as EmitFn;
 			});
 
 		const server = createApp({
@@ -924,15 +942,15 @@ describe("field resolvers", () => {
 		let cleanupCalled = false;
 		let resolverReceivedOnCleanup = false;
 
-		const Author = entity("Author", {
-			id: t.id(),
-			name: t.string(),
+		const Author = model("Author", {
+			id: id(),
+			name: string(),
 		});
 
-		const Post = entity("Post", {
-			id: t.id(),
-			title: t.string(),
-			authorId: t.string(),
+		const Post = model("Post", {
+			id: id(),
+			title: string(),
+			authorId: string(),
 		});
 
 		const mockDb = {
@@ -943,14 +961,13 @@ describe("field resolvers", () => {
 		// Use .resolve().subscribe() to get onCleanup access
 		// Per ADR-002: .resolve() alone is pure/batchable, no emit/onCleanup
 		// .resolve().subscribe() gives initial value + subscription capabilities
-		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f
-				.many(Post)
-				.resolve(({ parent, ctx }) => {
+		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			posts: t
+				.resolve(({ source, ctx }) => {
 					// Initial resolution (batchable, no emit/onCleanup)
-					return ctx.db.posts.filter((p) => p.authorId === parent.id);
+					return ctx.db.posts.filter((p) => p.authorId === source.id);
 				})
 				.subscribe(() => ({ onCleanup }) => {
 					// Publisher pattern: emit/onCleanup come from callback, not ctx
@@ -966,8 +983,8 @@ describe("field resolvers", () => {
 		const getAuthor = query<{ db: typeof mockDb }>()
 			.input(z.object({ id: z.string() }))
 			.returns(Author)
-			.resolve(({ input, ctx }) => {
-				const author = ctx.db.authors.find((a) => a.id === input.id);
+			.resolve(({ args, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === args.id);
 				if (!author) throw new Error("Author not found");
 				return author;
 			});
@@ -1008,15 +1025,15 @@ describe("field resolvers", () => {
 
 	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(),
+		const Author = model("Author", {
+			id: id(),
+			name: string(),
 		});
 
-		const Post = entity("Post", {
-			id: t.id(),
-			title: t.string(),
-			authorId: t.string(),
+		const Post = model("Post", {
+			id: id(),
+			title: string(),
+			authorId: string(),
 		});
 
 		const mockDb = {
@@ -1033,14 +1050,13 @@ describe("field resolvers", () => {
 		// Use .resolve().subscribe() to get emit access
 		// Per ADR-002: .resolve() alone is pure/batchable, no emit/onCleanup
 		// .resolve().subscribe() gives initial value + subscription capabilities
-		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f
-				.many(Post)
-				.resolve(({ parent, ctx }) => {
+		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			posts: t
+				.resolve(({ source, ctx }) => {
 					// Initial resolution (batchable, no emit)
-					return ctx.db.posts.filter((p) => p.authorId === parent.id);
+					return ctx.db.posts.filter((p) => p.authorId === source.id);
 				})
 				.subscribe(() => ({ emit, onCleanup }) => {
 					// Publisher pattern: emit/onCleanup come from callback
@@ -1056,8 +1072,8 @@ describe("field resolvers", () => {
 		const getAuthor = query<{ db: typeof mockDb }>()
 			.input(z.object({ id: z.string() }))
 			.returns(Author)
-			.resolve(({ input, ctx }) => {
-				const author = ctx.db.authors.find((a) => a.id === input.id);
+			.resolve(({ args, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === args.id);
 				if (!author) throw new Error("Author not found");
 				return author;
 			});
@@ -1128,13 +1144,15 @@ describe("field resolvers", () => {
 		type EmitFn = (data: { id: string; name: string }) => void;
 		let capturedEmit: EmitFn | undefined;
 
-		// Query that captures emit for external use
+		// Use .resolve().subscribe() pattern - emit comes through Publisher callback
 		const liveQuery = query()
 			.input(z.object({ id: z.string() }))
 			.returns(User)
-			.resolve(({ input, ctx }) => {
-				capturedEmit = ctx.emit as EmitFn;
-				return { id: input.id, name: "Initial" };
+			.resolve(({ args }) => {
+				return { id: args.id, name: "Initial" };
+			})
+			.subscribe(() => ({ emit }) => {
+				capturedEmit = emit as EmitFn;
 			});
 
 		const testRouter = router({ liveQuery });
@@ -1180,15 +1198,15 @@ describe("field resolvers", () => {
 		// .resolve() handles initial data (batchable)
 		// .subscribe() handles live updates (fire-and-forget)
 
-		const Author = entity("Author", {
-			id: t.id(),
-			name: t.string(),
+		const Author = model("Author", {
+			id: id(),
+			name: string(),
 		});
 
-		const Post = entity("Post", {
-			id: t.id(),
-			title: t.string(),
-			authorId: t.string(),
+		const Post = model("Post", {
+			id: id(),
+			title: string(),
+			authorId: string(),
 		});
 
 		const mockDb = {
@@ -1204,16 +1222,15 @@ describe("field resolvers", () => {
 		let subscribeCallCount = 0;
 		let capturedFieldEmit: ((value: unknown) => void) | undefined;
 
-		// Use .resolve().subscribe() pattern
-		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
-			posts: f
-				.many(Post)
-				.resolve(({ parent, ctx }) => {
+		// Use .resolve().subscribe() pattern (new API - no type method)
+		const authorResolver = resolver<{ db: typeof mockDb }>()(Author, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
+			posts: t
+				.resolve(({ source, ctx }) => {
 					// Phase 1: Initial resolution (batchable, no emit/onCleanup)
 					resolveCallCount++;
-					return ctx.db.posts.filter((p) => p.authorId === parent.id);
+					return ctx.db.posts.filter((p) => p.authorId === source.id);
 				})
 				.subscribe(() => ({ emit, onCleanup }) => {
 					// Phase 2: Publisher pattern - emit/onCleanup from callback
@@ -1229,8 +1246,8 @@ describe("field resolvers", () => {
 		const getAuthor = query<{ db: typeof mockDb }>()
 			.input(z.object({ id: z.string() }))
 			.returns(Author)
-			.resolve(({ input, ctx }) => {
-				const author = ctx.db.authors.find((a) => a.id === input.id);
+			.resolve(({ args, ctx }) => {
+				const author = ctx.db.authors.find((a) => a.id === args.id);
 				if (!author) throw new Error("Author not found");
 				return author;
 			});
@@ -1308,7 +1325,7 @@ describe("observable behavior", () => {
 	it("delivers initial result immediately for queries", async () => {
 		const simpleQuery = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Test" }));
+			.resolve(({ args }) => ({ id: args.id, name: "Test" }));
 
 		const server = createApp({ queries: { simpleQuery } });
 
@@ -1329,11 +1346,14 @@ describe("observable behavior", () => {
 		type EmitFn = (data: unknown) => void;
 		let capturedEmit: EmitFn | undefined;
 
+		// Use .resolve().subscribe() pattern - emit comes through Publisher callback
 		const liveQuery = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input, ctx }) => {
-				capturedEmit = ctx.emit as EmitFn;
-				return { id: input.id, name: "Initial" };
+			.resolve(({ args }) => {
+				return { id: args.id, name: "Initial" };
+			})
+			.subscribe(() => ({ emit }) => {
+				capturedEmit = emit as EmitFn;
 			});
 
 		const server = createApp({ queries: { liveQuery } });
@@ -1362,7 +1382,7 @@ describe("observable behavior", () => {
 	it("delivers mutation result via observable", async () => {
 		const testMutation = mutation()
 			.input(z.object({ name: z.string() }))
-			.resolve(({ input }) => ({ id: "new", name: input.name }));
+			.resolve(({ args }) => ({ id: "new", name: args.name }));
 
 		const server = createApp({ mutations: { testMutation } });
 
@@ -1384,9 +1404,9 @@ describe("observable behavior", () => {
 
 		const simpleQuery = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => {
+			.resolve(({ args }) => {
 				resolverCalls++;
-				return { id: input.id };
+				return { id: args.id };
 			});
 
 		const server = createApp({ queries: { simpleQuery } });
@@ -1416,11 +1436,14 @@ describe("emit backpressure", () => {
 		type EmitFn = (data: unknown) => void;
 		let capturedEmit: EmitFn | undefined;
 
+		// Use .resolve().subscribe() pattern - emit comes through Publisher callback
 		const liveQuery = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input, ctx }) => {
-				capturedEmit = ctx.emit as EmitFn;
-				return { id: input.id, count: 0 };
+			.resolve(({ args }) => {
+				return { id: args.id, count: 0 };
+			})
+			.subscribe(() => ({ emit }) => {
+				capturedEmit = emit as EmitFn;
 			});
 
 		const server = createApp({ queries: { liveQuery } });
@@ -1507,125 +1530,11 @@ describe("observable error handling", () => {
 });
 
 // =============================================================================
-// Unified Entity Definition (ADR-001) - Auto Resolver Conversion
+// NOTE: "Unified Entity Definition" tests for model().resolve() chain removed
+// as the chain API was deprecated in favor of standalone resolver() function.
+// See ADR-003 for the new design.
 // =============================================================================
 
-describe("Unified Entity Definition", () => {
-	describe("auto-converts entities with inline resolvers", () => {
-		it("creates resolver from entity with inline .resolve()", async () => {
-			// Entity with inline resolver - no separate resolver() needed
-			const Product = entity("Product", (t) => ({
-				id: t.id(),
-				name: t.string(),
-				price: t.float(),
-				// Computed field with inline resolver
-				displayPrice: t.string().resolve(({ parent }) => `$${(parent as { price: number }).price.toFixed(2)}`),
-			}));
-
-			const getProduct = query()
-				.input(z.object({ id: z.string() }))
-				.returns(Product)
-				.resolve(({ input }) => ({
-					id: input.id,
-					name: "Test Product",
-					price: 19.99,
-				}));
-
-			// No resolvers array needed! Server auto-detects inline resolvers
-			const server = createApp({
-				entities: { Product },
-				queries: { getProduct },
-			});
-
-			const result = await firstValueFrom(
-				server.execute({
-					path: "getProduct",
-					input: { id: "prod-1", $select: { id: true, name: true, displayPrice: true } },
-				}),
-			);
-
-			expect(result.data).toEqual({
-				id: "prod-1",
-				name: "Test Product",
-				displayPrice: "$19.99",
-			});
-		});
-
-		it("explicit resolver takes priority over inline resolver", async () => {
-			// Entity with inline resolver
-			const Item = entity("Item", (t) => ({
-				id: t.id(),
-				label: t.string().resolve(() => "inline-label"),
-			}));
-
-			// Explicit resolver overrides inline
-			const itemResolver = resolver(Item, (f) => ({
-				id: f.expose("id"),
-				label: f.string().resolve(() => "explicit-label"),
-			}));
-
-			const getItem = query()
-				.input(z.object({ id: z.string() }))
-				.returns(Item)
-				.resolve(({ input }) => ({ id: input.id }));
-
-			const server = createApp({
-				entities: { Item },
-				queries: { getItem },
-				resolvers: [itemResolver], // Explicit resolver takes priority
-			});
-
-			const result = await firstValueFrom(
-				server.execute({
-					path: "getItem",
-					input: { id: "item-1", $select: { id: true, label: true } },
-				}),
-			);
-
-			expect(result.data).toEqual({
-				id: "item-1",
-				label: "explicit-label", // From explicit resolver, not inline
-			});
-		});
-
-		it("includes inline resolver fields in metadata", () => {
-			const Task = entity("Task", (t) => ({
-				id: t.id(),
-				title: t.string(),
-				status: t.string().resolve(({ parent }) => parent.status),
-			}));
-
-			const server = createApp({
-				entities: { Task },
-				queries: {},
-			});
-
-			const metadata = server.getMetadata();
-			expect(metadata.entities.Task).toBeDefined();
-			expect(metadata.entities.Task.id).toBe("exposed");
-			expect(metadata.entities.Task.title).toBe("exposed");
-			expect(metadata.entities.Task.status).toBe("resolve");
-		});
-
-		it("skips entities without inline resolvers", () => {
-			// Plain entity without inline resolvers
-			const SimpleUser = entity("SimpleUser", {
-				id: t.id(),
-				name: t.string(),
-			});
-
-			const server = createApp({
-				entities: { SimpleUser },
-				queries: {},
-			});
-
-			const metadata = server.getMetadata();
-			// No resolver created for entities without inline resolvers
-			expect(metadata.entities.SimpleUser).toBeUndefined();
-		});
-	});
-});
-
 // =============================================================================
 // Operation-Level .resolve().subscribe() Tests (LiveQueryDef)
 // =============================================================================
@@ -1638,8 +1547,8 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const liveUser = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
-			.subscribe(({ input: _input }) => ({ emit, onCleanup }) => {
+			.resolve(({ args }) => ({ id: args.id, name: "Initial" }))
+			.subscribe(({ args: _args }) => ({ emit, onCleanup }) => {
 				subscriberCalled = true;
 				capturedEmit = emit;
 				capturedOnCleanup = onCleanup;
@@ -1678,7 +1587,7 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const liveUser = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.resolve(({ args }) => ({ id: args.id, name: "Initial" }))
 			.subscribe(() => ({ emit }) => {
 				capturedEmit = emit;
 			});
@@ -1727,7 +1636,7 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const liveUser = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.resolve(({ args }) => ({ id: args.id, name: "Initial" }))
 			.subscribe(() => ({ onCleanup }) => {
 				onCleanup(() => {
 					cleanupCalled = true;
@@ -1764,9 +1673,9 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const liveUser = query<TestContext>()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
-			.subscribe(({ input, ctx }) => ({ emit: _emit }) => {
-				receivedInput = input;
+			.resolve(({ args }) => ({ id: args.id, name: "Initial" }))
+			.subscribe(({ args, ctx }) => ({ emit: _emit }) => {
+				receivedInput = args;
 				receivedCtx = ctx;
 			});
 
@@ -1794,7 +1703,7 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 	it("handles subscriber errors gracefully", async () => {
 		const liveUser = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.resolve(({ args }) => ({ id: args.id, name: "Initial" }))
 			.subscribe(() => () => {
 				throw new Error("Subscriber error");
 			});
@@ -1837,7 +1746,7 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const liveCounter = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, count: 0 }))
+			.resolve(({ args }) => ({ id: args.id, count: 0 }))
 			.subscribe(() => ({ emit }) => {
 				capturedEmit = emit;
 			});
@@ -1889,7 +1798,7 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const liveUser = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Initial", status: "offline" }))
+			.resolve(({ args }) => ({ id: args.id, name: "Initial", status: "offline" }))
 			.subscribe(() => ({ emit }) => {
 				capturedEmit = emit as EmitFn;
 			});
@@ -1936,7 +1845,7 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const liveUser = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.resolve(({ args }) => ({ id: args.id, name: "Initial" }))
 			.subscribe(() => ({ emit }) => {
 				capturedEmit = emit;
 			});
@@ -1984,7 +1893,7 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 
 		const liveUser = query()
 			.input(z.object({ id: z.string() }))
-			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.resolve(({ args }) => ({ id: args.id, name: "Initial" }))
 			.subscribe(() => ({ emit }) => {
 				subscriberCallCount++;
 				emits.push(emit);
@@ -2032,9 +1941,9 @@ describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
 describe("scalar field subscription with emit.delta()", () => {
 	it("provides emit.delta() for string field subscriptions", async () => {
 		// UserWithBio - bio field is not provided by query, resolved by field resolver
-		const UserWithBio = entity("UserWithBio", {
-			id: t.id(),
-			name: t.string(),
+		const UserWithBio = model("UserWithBio", {
+			id: id(),
+			name: string(),
 		});
 
 		let capturedEmit: {
@@ -2042,14 +1951,13 @@ describe("scalar field subscription with emit.delta()", () => {
 			delta?: (operations: { position: number; insert: string }[]) => void;
 		} | null = null;
 
-		const userResolver = resolver(UserWithBio, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
+		const userResolver = resolver(UserWithBio, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
 			// bio is a computed field with resolve + subscribe
-			bio: f
-				.string()
+			bio: t
 				.resolve(() => "Initial bio")
-				.subscribe((_params) => ({ emit, onCleanup }) => {
+				.subscribe(() => ({ emit, onCleanup }) => {
 					capturedEmit = emit as typeof capturedEmit;
 					onCleanup(() => {});
 				}),
@@ -2061,7 +1969,7 @@ describe("scalar field subscription with emit.delta()", () => {
 				getUserWithBio: query()
 					.input(z.object({ id: z.string() }))
 					.returns(UserWithBio)
-					.resolve(({ input }) => ({ id: input.id, name: "Alice" })),
+					.resolve(({ args }) => ({ id: args.id, name: "Alice" })),
 			},
 			resolvers: [userResolver],
 		});
@@ -2096,9 +2004,9 @@ describe("scalar field subscription with emit.delta()", () => {
 
 	it("emit.delta() sends delta command (stateless)", async () => {
 		// UserWithContent - content field resolved by field resolver
-		const UserWithContent = entity("UserWithContent", {
-			id: t.id(),
-			name: t.string(),
+		const UserWithContent = model("UserWithContent", {
+			id: id(),
+			name: string(),
 		});
 
 		let capturedEmit: {
@@ -2106,14 +2014,13 @@ describe("scalar field subscription with emit.delta()", () => {
 			delta?: (operations: { position: number; insert: string }[]) => void;
 		} | null = null;
 
-		const userResolver = resolver(UserWithContent, (f) => ({
-			id: f.expose("id"),
-			name: f.expose("name"),
+		const userResolver = resolver(UserWithContent, (t) => ({
+			id: t.expose("id"),
+			name: t.expose("name"),
 			// content is a computed field with resolve + subscribe
-			content: f
-				.string()
+			content: t
 				.resolve(() => "Hello")
-				.subscribe((_params) => ({ emit, onCleanup }) => {
+				.subscribe(() => ({ emit, onCleanup }) => {
 					capturedEmit = emit as typeof capturedEmit;
 					onCleanup(() => {});
 				}),
@@ -2125,7 +2032,7 @@ describe("scalar field subscription with emit.delta()", () => {
 				getUserWithContent: query()
 					.input(z.object({ id: z.string() }))
 					.returns(UserWithContent)
-					.resolve(({ input }) => ({ id: input.id, name: "Alice" })),
+					.resolve(({ args }) => ({ id: args.id, name: "Alice" })),
 			},
 			resolvers: [userResolver],
 		});