@sylphx/lens-server 2.9.0 → 2.10.1

package/README.md

@@ -10,20 +10,217 @@ bun add @sylphx/lens-server
 
 ## Usage
 
+### Basic Server Setup
+
+```typescript
+import { createApp, createHandler } from "@sylphx/lens-server";
+import { model, lens, router, list, nullable } from "@sylphx/lens-core";
+import { z } from "zod";
+
+// Define context type
+interface AppContext {
+  db: Database;
+  user: User | null;
+}
+
+// Define models with inline resolvers
+const User = model<AppContext>("User", (t) => ({
+  id: t.id(),
+  name: t.string(),
+  email: t.string(),
+  posts: t.many(() => Post).resolve(({ parent, ctx }) =>
+    ctx.db.posts.filter(p => p.authorId === parent.id)
+  ),
+}));
+
+const Post = model<AppContext>("Post", (t) => ({
+  id: t.id(),
+  title: t.string(),
+  authorId: t.string(),
+}));
+
+// Create typed builders
+const { query, mutation } = lens<AppContext>();
+
+// Define operations
+const appRouter = router({
+  user: {
+    get: query()
+      .input(z.object({ id: z.string() }))
+      .returns(User)
+      .resolve(({ input, ctx }) => ctx.db.users.get(input.id)!),
+
+    find: query()
+      .input(z.object({ email: z.string() }))
+      .returns(nullable(User))  // User | null
+      .resolve(({ input, ctx }) => ctx.db.users.findByEmail(input.email)),
+
+    list: query()
+      .returns(list(User))  // User[]
+      .resolve(({ ctx }) => ctx.db.users.findMany()),
+
+    update: mutation()
+      .input(z.object({ id: z.string(), name: z.string() }))
+      .returns(User)
+      .resolve(({ input, ctx }) => ctx.db.users.update(input)),
+  },
+});
+
+// Create server - models auto-tracked from router!
+const app = createApp({
+  router: appRouter,  // Models extracted from .returns()
+  context: () => ({
+    db: database,
+    user: getCurrentUser(),
+  }),
+});
+
+// Start server
+const handler = createHandler(app);
+Bun.serve({ port: 3000, fetch: handler });
+```
+
+### With Optimistic Updates
+
 ```typescript
-import { createServer } from "@sylphx/lens-server";
-import { appRouter } from "./router";
+import { createApp, optimisticPlugin } from "@sylphx/lens-server";
+import { model, lens, router } from "@sylphx/lens-core";
+import { entity as e, temp, now } from "@sylphx/reify";
 
-const server = createServer({ router: appRouter });
+// Enable optimistic plugin
+const { query, mutation, plugins } = lens<AppContext>()
+  .withPlugins([optimisticPlugin()]);
+
+const appRouter = router({
+  user: {
+    // Sugar syntax
+    update: mutation()
+      .input(z.object({ id: z.string(), name: z.string() }))
+      .returns(User)
+      .optimistic("merge")  // Instant UI update
+      .resolve(({ input, ctx }) => ctx.db.users.update(input)),
+  },
+  message: {
+    // Reify DSL (multi-entity)
+    send: mutation()
+      .input(z.object({ content: z.string(), userId: z.string() }))
+      .returns(Message)
+      .optimistic(({ input }) => [
+        e.create(Message, {
+          id: temp(),
+          content: input.content,
+          createdAt: now(),
+        }),
+      ])
+      .resolve(({ input, ctx }) => ctx.db.messages.create(input)),
+  },
+});
+
+const app = createApp({
+  router: appRouter,
+  plugins,  // Include optimistic plugin
+  context: () => ({ ... }),
+});
+```
+
+### Live Queries
+
+```typescript
+const { query } = lens<AppContext>();
+
+// Live query with Publisher pattern
+const watchUser = query()
+  .input(z.object({ id: z.string() }))
+  .resolve(({ input, ctx }) => ctx.db.users.get(input.id)!)  // Initial value
+  .subscribe(({ input, ctx }) => ({ emit, onCleanup }) => {
+    // Publisher callback - emit/onCleanup passed here
+    const unsub = ctx.db.users.onChange(input.id, (user) => {
+      emit(user);  // Push update to clients
+    });
+    onCleanup(unsub);  // Cleanup on disconnect
+  });
+```
+
+### WebSocket Handler
+
+```typescript
+import { createApp, createHandler, createWSHandler } from "@sylphx/lens-server";
+
+const app = createApp({ ... });
+
+// HTTP handler
+const httpHandler = createHandler(app);
+
+// WebSocket handler
+const wsHandler = createWSHandler(app);
 
-// Handle WebSocket connections
 Bun.serve({
   port: 3000,
-  fetch: server.fetch,
-  websocket: server.websocket,
+  fetch(req, server) {
+    if (req.headers.get("upgrade") === "websocket") {
+      return wsHandler.upgrade(req, server);
+    }
+    return httpHandler(req);
+  },
+  websocket: wsHandler.websocket,
+});
+```
+
+## createApp Options
+
+```typescript
+createApp({
+  // Required (at least one)
+  router: RouterDef,           // Namespaced operations
+
+  // Optional (models auto-tracked from router!)
+  entities: EntitiesMap,       // Explicit models (optional, for overrides)
+  plugins: ServerPlugin[],     // Server plugins (optimistic, clientState, etc.)
+  context: () => TContext,     // Context factory
+  logger: LensLogger,          // Logging (default: silent)
+  version: string,             // Server version (default: "1.0.0")
 });
 ```
 
+## Auto-tracking Models
+
+Models are automatically collected from router return types:
+
+```typescript
+// These models are auto-tracked:
+const appRouter = router({
+  user: {
+    get: query().returns(User).resolve(...),     // User tracked
+    list: query().returns(list(User)).resolve(...), // User tracked
+    find: query().returns(nullable(User)).resolve(...), // User tracked
+  },
+  post: {
+    get: query().returns(Post).resolve(...),     // Post tracked
+  },
+});
+
+// No need to pass entities explicitly
+const app = createApp({
+  router: appRouter,  // User and Post auto-collected
+});
+
+// Or override/add explicit models
+const app = createApp({
+  router: appRouter,
+  entities: { User, Post, ExtraModel },  // Explicit takes priority
+});
+```
+
+## Optimistic Update Strategies
+
+| Strategy | Description | Example |
+|----------|-------------|---------|
+| `"merge"` | Merge input into entity | `.optimistic("merge")` |
+| `"create"` | Create with temp ID | `.optimistic("create")` |
+| `"delete"` | Mark entity deleted | `.optimistic("delete")` |
+| `{ merge: {...} }` | Merge with extra fields | `.optimistic({ merge: { status: "pending" } })` |
+| Reify DSL | Multi-entity operations | `.optimistic(({ input }) => [...])` |
+
 ## License
 
 MIT
@@ -32,4 +229,4 @@ MIT
 
 Built with [@sylphx/lens-core](https://github.com/SylphxAI/Lens).
 
-✨ Powered by Sylphx
+Powered by Sylphx

package/dist/index.js

@@ -35,14 +35,19 @@ function extendContext(current, extension) {
 }
 // src/server/create.ts
 import {
+  collectModelsFromOperations,
+  collectModelsFromRouter,
   createEmit,
   createResolverFromEntity,
   flattenRouter,
   hashValue,
   hasInlineResolvers,
   isEntityDef,
+  isLiveQueryDef,
+  isModelDef,
   isMutationDef,
   isQueryDef,
+  mergeModelCollections,
   valuesEqual
 } from "@sylphx/lens-core";
 
@@ -354,15 +359,23 @@ class LensServerImpl {
     }
     this.queries = queries;
     this.mutations = mutations;
-    const entities = { ...config.entities ?? {} };
+    const autoCollected = config.router ? collectModelsFromRouter(config.router) : collectModelsFromOperations(queries, mutations);
+    const entitiesFromConfig = config.entities ?? {};
+    const mergedModels = mergeModelCollections(autoCollected, entitiesFromConfig);
     if (config.resolvers) {
       for (const resolver of config.resolvers) {
         const entityName = resolver.entity._name;
-        if (entityName && !entities[entityName]) {
-          entities[entityName] = resolver.entity;
+        if (entityName && !mergedModels.has(entityName)) {
+          mergedModels.set(entityName, resolver.entity);
         }
       }
     }
+    const entities = {};
+    for (const [name, model] of mergedModels) {
+      if (isEntityDef(model) || isModelDef(model)) {
+        entities[name] = model;
+      }
+    }
     this.entities = entities;
     this.resolverMap = this.buildResolverMap(config.resolvers, entities);
     this.contextFactory = config.context ?? (() => ({}));
@@ -415,7 +428,7 @@ class LensServerImpl {
       }
     }
     for (const [name, entity] of Object.entries(entities)) {
-      if (!isEntityDef(entity))
+      if (!isEntityDef(entity) && !isModelDef(entity))
         continue;
       if (resolverMap.has(name))
         continue;
@@ -627,6 +640,26 @@ class LensServerImpl {
                 currentState = value;
                 const processed = isQuery ? await this.processQueryResult(path, value, select, context, onCleanup, createFieldEmit) : value;
                 emitIfChanged(processed);
+                if (isQuery && isLiveQueryDef(def) && !cancelled) {
+                  const liveQuery = def;
+                  if (liveQuery._subscriber) {
+                    try {
+                      const publisher = liveQuery._subscriber({
+                        input: cleanInput,
+                        ctx: context
+                      });
+                      if (publisher) {
+                        publisher({ emit, onCleanup });
+                      }
+                    } catch (err) {
+                      if (!cancelled) {
+                        observer.next?.({
+                          error: err instanceof Error ? err : new Error(String(err))
+                        });
+                      }
+                    }
+                  }
+                }
                 if (!isQuery && !cancelled) {
                   observer.complete?.();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sylphx/lens-server",
-	"version": "2.9.0",
+	"version": "2.10.1",
 	"description": "Server runtime for Lens API framework",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -30,7 +30,7 @@
 	"author": "SylphxAI",
 	"license": "MIT",
 	"dependencies": {
-		"@sylphx/lens-core": "^2.7.0"
+		"@sylphx/lens-core": "^2.8.0"
 	},
 	"devDependencies": {
 		"typescript": "^5.9.3",

package/src/server/create.test.ts

@@ -1725,3 +1725,379 @@ describe("Unified Entity Definition", () => {
 		});
 	});
 });
+
+// =============================================================================
+// Operation-Level .resolve().subscribe() Tests (LiveQueryDef)
+// =============================================================================
+
+describe("operation-level .resolve().subscribe() (LiveQueryDef)", () => {
+	it("calls _subscriber after initial resolve for live updates", async () => {
+		let subscriberCalled = false;
+		let capturedEmit: ((value: unknown) => void) | undefined;
+		let capturedOnCleanup: ((fn: () => void) => void) | undefined;
+
+		const liveUser = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.subscribe(({ input: _input }) => ({ emit, onCleanup }) => {
+				subscriberCalled = true;
+				capturedEmit = emit;
+				capturedOnCleanup = onCleanup;
+			});
+
+		const server = createApp({ queries: { liveUser } });
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "liveUser",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (result) => results.push(result),
+			});
+
+		// Wait for initial result and subscriber setup
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(results.length).toBe(1);
+		expect((results[0] as { data: { name: string } }).data.name).toBe("Initial");
+		expect(subscriberCalled).toBe(true);
+		expect(capturedEmit).toBeDefined();
+		expect(capturedOnCleanup).toBeDefined();
+
+		subscription.unsubscribe();
+	});
+
+	it("emits updates from subscriber emit function", async () => {
+		let capturedEmit: ((value: { id: string; name: string }) => void) | undefined;
+
+		const liveUser = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.subscribe(() => ({ emit }) => {
+				capturedEmit = emit;
+			});
+
+		const server = createApp({ queries: { liveUser } });
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "liveUser",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (result) => results.push(result),
+			});
+
+		// Wait for initial result
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(1);
+		expect((results[0] as { data: { name: string } }).data.name).toBe("Initial");
+
+		// Emit update via subscriber
+		capturedEmit!({ id: "1", name: "Updated" });
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(results.length).toBe(2);
+		expect((results[1] as { data: { name: string } }).data.name).toBe("Updated");
+
+		// Emit another update
+		capturedEmit!({ id: "1", name: "Updated Again" });
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(results.length).toBe(3);
+		expect((results[2] as { data: { name: string } }).data.name).toBe("Updated Again");
+
+		subscription.unsubscribe();
+	});
+
+	it("calls onCleanup when subscription is unsubscribed", async () => {
+		let cleanupCalled = false;
+
+		const liveUser = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.subscribe(() => ({ onCleanup }) => {
+				onCleanup(() => {
+					cleanupCalled = true;
+				});
+			});
+
+		const server = createApp({ queries: { liveUser } });
+
+		const subscription = server
+			.execute({
+				path: "liveUser",
+				input: { id: "1" },
+			})
+			.subscribe({});
+
+		// Wait for subscription setup
+		await new Promise((r) => setTimeout(r, 50));
+		expect(cleanupCalled).toBe(false);
+
+		// Unsubscribe
+		subscription.unsubscribe();
+
+		// Cleanup should be called
+		expect(cleanupCalled).toBe(true);
+	});
+
+	it("passes input and context to subscriber", async () => {
+		interface TestContext {
+			userId: string;
+		}
+
+		let receivedInput: { id: string } | undefined;
+		let receivedCtx: TestContext | undefined;
+
+		const liveUser = query<TestContext>()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.subscribe(({ input, ctx }) => ({ emit: _emit }) => {
+				receivedInput = input;
+				receivedCtx = ctx;
+			});
+
+		const server = createApp({
+			queries: { liveUser },
+			context: () => ({ userId: "ctx-user-123" }),
+		});
+
+		const subscription = server
+			.execute({
+				path: "liveUser",
+				input: { id: "input-123" },
+			})
+			.subscribe({});
+
+		// Wait for subscription setup
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(receivedInput).toEqual({ id: "input-123" });
+		expect(receivedCtx).toEqual({ userId: "ctx-user-123" });
+
+		subscription.unsubscribe();
+	});
+
+	it("handles subscriber errors gracefully", async () => {
+		const liveUser = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.subscribe(() => () => {
+				throw new Error("Subscriber error");
+			});
+
+		const server = createApp({ queries: { liveUser } });
+
+		const results: unknown[] = [];
+		const errors: Error[] = [];
+
+		const subscription = server
+			.execute({
+				path: "liveUser",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (result) => {
+					if (result.error) {
+						errors.push(result.error);
+					} else {
+						results.push(result);
+					}
+				},
+			});
+
+		// Wait for execution
+		await new Promise((r) => setTimeout(r, 50));
+
+		// Initial result should be delivered
+		expect(results.length).toBe(1);
+		// Error from subscriber should be reported
+		expect(errors.length).toBe(1);
+		expect(errors[0].message).toBe("Subscriber error");
+
+		subscription.unsubscribe();
+	});
+
+	it("works with router-based operations", async () => {
+		let capturedEmit: ((value: { id: string; count: number }) => void) | undefined;
+
+		const liveCounter = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, count: 0 }))
+			.subscribe(() => ({ emit }) => {
+				capturedEmit = emit;
+			});
+
+		const appRouter = router({
+			counter: router({
+				live: liveCounter,
+			}),
+		});
+
+		const server = createApp({ router: appRouter });
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "counter.live",
+				input: { id: "c1" },
+			})
+			.subscribe({
+				next: (result) => results.push(result),
+			});
+
+		// Wait for initial result
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(1);
+		expect((results[0] as { data: { count: number } }).data.count).toBe(0);
+
+		// Emit updates
+		capturedEmit!({ id: "c1", count: 1 });
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(2);
+		expect((results[1] as { data: { count: number } }).data.count).toBe(1);
+
+		capturedEmit!({ id: "c1", count: 5 });
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(3);
+		expect((results[2] as { data: { count: number } }).data.count).toBe(5);
+
+		subscription.unsubscribe();
+	});
+
+	it("supports emit.merge for partial updates", async () => {
+		type EmitFn = ((value: unknown) => void) & { merge: (partial: unknown) => void };
+		let capturedEmit: EmitFn | undefined;
+
+		const liveUser = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Initial", status: "offline" }))
+			.subscribe(() => ({ emit }) => {
+				capturedEmit = emit as EmitFn;
+			});
+
+		const server = createApp({ queries: { liveUser } });
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "liveUser",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (result) => results.push(result),
+			});
+
+		// Wait for initial result
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(1);
+		const initial = (results[0] as { data: { name: string; status: string } }).data;
+		expect(initial.name).toBe("Initial");
+		expect(initial.status).toBe("offline");
+
+		// Use merge for partial update
+		capturedEmit!.merge({ status: "online" });
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(results.length).toBe(2);
+		const updated = (results[1] as { data: { name: string; status: string } }).data;
+		expect(updated.name).toBe("Initial"); // Preserved
+		expect(updated.status).toBe("online"); // Updated
+
+		subscription.unsubscribe();
+	});
+
+	it("deduplicates identical emit values", async () => {
+		let capturedEmit: ((value: { id: string; name: string }) => void) | undefined;
+
+		const liveUser = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.subscribe(() => ({ emit }) => {
+				capturedEmit = emit;
+			});
+
+		const server = createApp({ queries: { liveUser } });
+
+		const results: unknown[] = [];
+		const subscription = server
+			.execute({
+				path: "liveUser",
+				input: { id: "1" },
+			})
+			.subscribe({
+				next: (result) => results.push(result),
+			});
+
+		// Wait for initial result
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(1);
+
+		// Emit same value multiple times
+		capturedEmit!({ id: "1", name: "Initial" });
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(1); // Should be deduplicated
+
+		// Emit different value
+		capturedEmit!({ id: "1", name: "Changed" });
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(2);
+
+		// Emit same changed value again
+		capturedEmit!({ id: "1", name: "Changed" });
+		await new Promise((r) => setTimeout(r, 50));
+		expect(results.length).toBe(2); // Should be deduplicated
+
+		subscription.unsubscribe();
+	});
+
+	it("multiple subscriptions each get their own subscriber instance", async () => {
+		let subscriberCallCount = 0;
+		const emits: Array<(value: { id: string; name: string }) => void> = [];
+
+		const liveUser = query()
+			.input(z.object({ id: z.string() }))
+			.resolve(({ input }) => ({ id: input.id, name: "Initial" }))
+			.subscribe(() => ({ emit }) => {
+				subscriberCallCount++;
+				emits.push(emit);
+			});
+
+		const server = createApp({ queries: { liveUser } });
+
+		const results1: unknown[] = [];
+		const results2: unknown[] = [];
+
+		const sub1 = server.execute({ path: "liveUser", input: { id: "1" } }).subscribe({ next: (r) => results1.push(r) });
+
+		const sub2 = server.execute({ path: "liveUser", input: { id: "2" } }).subscribe({ next: (r) => results2.push(r) });
+
+		// Wait for both subscriptions
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(subscriberCallCount).toBe(2);
+		expect(emits.length).toBe(2);
+		expect(results1.length).toBe(1);
+		expect(results2.length).toBe(1);
+
+		// Each emit only affects its subscription
+		emits[0]({ id: "1", name: "Updated 1" });
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(results1.length).toBe(2);
+		expect(results2.length).toBe(1); // Unchanged
+
+		emits[1]({ id: "2", name: "Updated 2" });
+		await new Promise((r) => setTimeout(r, 50));
+
+		expect(results1.length).toBe(2); // Unchanged
+		expect(results2.length).toBe(2);
+
+		sub1.unsubscribe();
+		sub2.unsubscribe();
+	});
+});

package/src/server/create.ts

@@ -17,6 +17,8 @@
 
 import {
 	type ContextValue,
+	collectModelsFromOperations,
+	collectModelsFromRouter,
 	createEmit,
 	createResolverFromEntity,
 	type Emit,
@@ -27,8 +29,12 @@ import {
 	hasInlineResolvers,
 	type InferRouterContext,
 	isEntityDef,
+	isLiveQueryDef,
+	isModelDef,
 	isMutationDef,
 	isQueryDef,
+	type LiveQueryDef,
+	mergeModelCollections,
 	type Observable,
 	type ResolverDef,
 	type RouterDef,
@@ -192,16 +198,34 @@ class LensServerImpl<
 		this.queries = queries as Q;
 		this.mutations = mutations as M;
 
-		// Build entities map: explicit config + auto-extracted from resolvers
-		const entities: EntitiesMap = { ...(config.entities ?? {}) };
+		// Build entities map (priority: explicit config > router > resolvers)
+		// Auto-track models from router return types (new behavior)
+		const autoCollected = config.router
+			? collectModelsFromRouter(config.router)
+			: collectModelsFromOperations(queries, mutations);
+
+		// Merge: explicit entities override auto-collected
+		const entitiesFromConfig = config.entities ?? {};
+		const mergedModels = mergeModelCollections(autoCollected, entitiesFromConfig);
+
+		// Also extract from explicit resolvers (legacy)
 		if (config.resolvers) {
 			for (const resolver of config.resolvers) {
 				const entityName = resolver.entity._name;
-				if (entityName && !entities[entityName]) {
-					entities[entityName] = resolver.entity;
+				if (entityName && !mergedModels.has(entityName)) {
+					mergedModels.set(entityName, resolver.entity);
 				}
 			}
 		}
+
+		// Convert Map to Record for entities (supports both EntityDef and ModelDef)
+		const entities: EntitiesMap = {};
+		for (const [name, model] of mergedModels) {
+			// Both ModelDef and EntityDef work as EntitiesMap values
+			if (isEntityDef(model) || isModelDef(model)) {
+				entities[name] = model as EntityDef<string, any>;
+			}
+		}
 		this.entities = entities;
 
 		// Build resolver map: explicit resolvers + auto-converted from entities with inline resolvers
@@ -278,12 +302,13 @@ class LensServerImpl<
 			}
 		}
 
-		// 2. Auto-convert entities with inline resolvers (if not already in map)
+		// 2. Auto-convert entities/models with inline resolvers (if not already in map)
 		for (const [name, entity] of Object.entries(entities)) {
-			if (!isEntityDef(entity)) continue;
+			// Support both EntityDef and ModelDef
+			if (!isEntityDef(entity) && !isModelDef(entity)) continue;
 			if (resolverMap.has(name)) continue; // Explicit resolver takes priority
 
-			// Check if entity has inline resolvers
+			// Check if entity/model has inline resolvers
 			if (hasInlineResolvers(entity)) {
 				const resolver = createResolverFromEntity(entity);
 				resolverMap.set(name, resolver);
@@ -668,6 +693,31 @@ class LensServerImpl<
 									: value;
 								emitIfChanged(processed);
 
+								// LiveQueryDef: Call _subscriber for live updates (Publisher pattern)
+								// ADR-002: .resolve().subscribe() pattern for operation-level live queries
+								if (isQuery && isLiveQueryDef(def) && !cancelled) {
+									const liveQuery = def as LiveQueryDef<unknown, unknown, TContext>;
+									if (liveQuery._subscriber) {
+										try {
+											// Get publisher function from subscriber
+											const publisher = liveQuery._subscriber({
+												input: cleanInput as never, // Type-safe at runtime via input validation
+												ctx: context as TContext,
+											});
+											// Call publisher with emit/onCleanup callbacks
+											if (publisher) {
+												publisher({ emit, onCleanup });
+											}
+										} catch (err) {
+											if (!cancelled) {
+												observer.next?.({
+													error: err instanceof Error ? err : new Error(String(err)),
+												});
+											}
+										}
+									}
+								}
+
 								// Mutations complete immediately - they're truly one-shot
 								// Queries stay open for potential emit calls from field resolvers
 								if (!isQuery && !cancelled) {