@nkzw/fate 0.1.3 → 1.0.0

package/lib/server.mjs

@@ -1,458 +1,912 @@
-import { t as isRecord$1 } from "./record-DnhZuvUe.mjs";
-import { z } from "zod";
-
-//#region src/server/prismaSelect.ts
-const toPrismaArgs = (args$1) => {
-	const prismaArgs = {};
-	const isBackward = args$1.before !== void 0 || typeof args$1.last === "number";
-	if (typeof args$1.first === "number") prismaArgs.take = args$1.first + 1;
-	if (typeof args$1.last === "number") prismaArgs.take = -(args$1.last + 1);
-	const cursor = isBackward ? args$1.before : args$1.after;
-	if (cursor !== void 0) {
-		prismaArgs.cursor = { id: cursor };
-		prismaArgs.skip = 1;
-	}
-	return prismaArgs;
+import { t as isRecord } from "./record-AeZJC9fd.mjs";
+import { d as hashArgs, i as FateRequestError, n as liveEntityTopic, o as toProtocolError, r as liveGlobalConnectionTopic, t as liveConnectionTopic, u as filterConnectionArgs } from "./liveTopics-DzNtJaBD.mjs";
+import { C as list, D as resolveConnection, E as connectionArgs, O as withConnection, S as isDataView, T as toPrismaSelect, _ as computed, a as refetchSourceById, b as dataView, c as resolveSourceConnection, f as createSourcePlan, h as hasNestedSelection, k as getScopedArgs, m as getNestedSelection, n as createSourceProcedures, o as resolveSourceById, r as byIdInput, s as resolveSourceByIds, t as bindSourceProcedures, u as createNestedSourcePlan, v as count, w as resolver, x as field, y as createResolver } from "./sourceRouter-Bwpkr062.mjs";
+import { EventEmitter, on } from "node:events";
+//#region src/server/live.ts
+const eventName = (type, id) => `${type}:${String(id)}`;
+const globalConnectionEventName = (procedure) => `connection:${procedure}:*`;
+const normalizeConnectionArgs = (args) => {
+	const filtered = filterConnectionArgs(args);
+	if (!filtered) return;
+	const id = filtered.id;
+	return typeof id === "string" || typeof id === "number" ? {
+		...filtered,
+		id: String(id)
+	} : filtered;
 };
-const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-/**
-* Narrows nested args to the slice relevant for a particular selection path.
-*/
-function getScopedArgs(args$1, path) {
-	if (!args$1) return;
-	const segments = path.split(".");
-	let current = args$1;
-	for (const segment of segments) {
-		if (!isRecord(current)) return;
-		current = current[segment];
-	}
-	return isRecord(current) ? current : void 0;
-}
-/**
-* Builds a Prisma `select` object from flattened selection paths and optional
-* scoped args, always including the `id` field.
-*/
-function prismaSelect(paths, args$1) {
-	const allPaths = [...new Set([...paths, "id"])];
-	const select = {};
-	for (const path of allPaths) {
-		const segments = path.split(".");
-		let current = select;
-		let currentPath = "";
-		segments.forEach((segment, index) => {
-			currentPath = currentPath ? `${currentPath}.${segment}` : segment;
-			if (index === segments.length - 1) {
-				if (segment === "cursor") return;
-				current[segment] = true;
-				return;
-			}
-			const existing = current[segment];
-			const relation = existing && typeof existing === "object" && existing !== null && "select" in existing ? existing : { select: {} };
-			const scopedArgs = getScopedArgs(args$1, currentPath);
-			if (scopedArgs) Object.assign(relation, toPrismaArgs(scopedArgs));
-			current[segment] = relation;
-			current = relation.select;
+const connectionEventName = (procedure, args) => `connection:${procedure}:${hashArgs(normalizeConnectionArgs(args) ?? {})}`;
+const mergeEvents = (emitter, names, signal) => ({ [Symbol.asyncIterator]() {
+	const queue = [];
+	let pending = null;
+	let done = false;
+	const cleanup = () => {
+		done = true;
+		for (const name of names) emitter.off(name, listener);
+		signal?.removeEventListener("abort", onAbort);
+		pending?.({
+			done: true,
+			value: void 0
 		});
-	}
-	return select;
-}
-
-//#endregion
-//#region src/server/connection.ts
-const args = z.object({}).catchall(z.union([z.unknown(), z.lazy(() => args)]));
-/**
-* Zod schema for connection args (`after`, `before`, `first`, `last`, etc.).
-*/
-const connectionArgs = args.optional();
-const connectionInput = z.strictObject({
-	args: connectionArgs,
-	select: z.array(z.string())
-});
-const paginationArgKeys = new Set([
-	"after",
-	"before",
-	"first",
-	"last"
-]);
-const paginationArgsSchema = z.strictObject({
-	after: z.string().optional(),
-	before: z.string().optional(),
-	first: z.number().int().positive().optional(),
-	last: z.number().int().positive().optional()
-}).partial().refine(({ after, before }) => !(after && before), "Connection args can't include both 'after' and 'before'.").refine(({ first, last }) => !(first && last), "Connection args can't include both 'first' and 'last'.").refine(({ before, last }) => !last || before !== void 0, "Connection args using 'last' must also include 'before'.");
-const extractPaginationArgs = (args) => args ? Object.fromEntries(Object.entries(args).filter(([key]) => paginationArgKeys.has(key))) : {};
-/**
-* Converts an array of nodes into a list view connection result the client
-* can normalize.
-*/
-function arrayToConnection(nodes, { args, getCursor = (node) => String(node.id) } = {}) {
-	if (!nodes) return;
-	const paginationArgs = paginationArgsSchema.parse(extractPaginationArgs(args));
-	if (Object.keys(paginationArgs).length === 0) return {
-		items: nodes.map((node) => ({
-			cursor: getCursor(node),
-			node
-		})),
-		pagination: {
-			hasNext: false,
-			hasPrevious: false,
-			nextCursor: void 0,
-			previousCursor: void 0
-		}
-	};
-	const isBackward = paginationArgs.before !== void 0 || paginationArgs.last !== void 0;
-	const cursor = isBackward ? paginationArgs.before : paginationArgs.after;
-	const pageSize = paginationArgs.first ?? paginationArgs.last ?? nodes.length;
-	const cursorIndex = cursor === void 0 ? -1 : nodes.findIndex((node) => getCursor(node) === cursor);
-	const selectedNodes = cursorIndex < 0 ? nodes : isBackward ? nodes.slice(0, cursorIndex) : nodes.slice(cursorIndex + 1);
-	const hasNext = selectedNodes.length > pageSize;
-	const hasPrevious = nodes.length > selectedNodes.length;
-	const items = (isBackward ? selectedNodes.slice(Math.max(0, selectedNodes.length - pageSize)) : selectedNodes.slice(0, pageSize)).map((node) => ({
-		cursor: getCursor(node),
-		node
-	}));
-	const firstItem = items[0];
-	const lastItem = items.at(-1);
-	return {
-		items,
-		pagination: {
-			hasNext: isBackward ? hasPrevious : hasNext,
-			hasPrevious: isBackward ? hasNext : hasPrevious,
-			nextCursor: lastItem?.cursor,
-			previousCursor: (isBackward ? hasNext : hasPrevious) && firstItem ? firstItem.cursor : void 0
-		}
+		pending = null;
 	};
-}
-const isDataViewField$1 = (field) => Boolean(field) && typeof field === "object" && "fields" in field;
-const assignIfChanged = (current, key, next, existing) => {
-	if (next === existing) return current;
-	if (!current) return { [key]: next };
-	current[key] = next;
-	return current;
-};
-function toConnectionResult({ args, item, path, view }) {
-	if (!isRecord$1(item)) return item;
-	let result = null;
-	const base = () => result ? {
-		...item,
-		...result
-	} : item;
-	for (const [field, config] of Object.entries(view.fields)) {
-		if (!isDataViewField$1(config)) continue;
-		const current = base()[field];
-		const nextPath = path ? `${path}.${field}` : field;
-		if (config.kind === "list") {
-			if (!Array.isArray(current)) continue;
-			const connection = arrayToConnection(current.map((item$1) => toConnectionResult({
-				args,
-				item: item$1,
-				path: nextPath,
-				view: config
-			})), { args: getScopedArgs(args, nextPath) });
-			result = assignIfChanged(result, field, connection, current);
-			continue;
-		}
-		if (Array.isArray(current)) {
-			const wrapped = current.map((entry) => toConnectionResult({
-				args,
-				item: entry,
-				path: nextPath,
-				view: config
-			}));
-			result = assignIfChanged(result, field, wrapped, current);
-			continue;
-		}
-		if (isRecord$1(current)) {
-			const wrapped = toConnectionResult({
-				args,
-				item: current,
-				path: nextPath,
-				view: config
+	const listener = (value) => {
+		if (pending) {
+			const resolve = pending;
+			pending = null;
+			resolve({
+				done: false,
+				value: [value]
 			});
-			result = assignIfChanged(result, field, wrapped, current);
+			return;
 		}
-	}
-	return result ? {
-		...item,
-		...result
-	} : item;
-}
-function withConnection(procedure) {
-	return ({ defaultSize = 20, getCursor = (node) => node.id, input: additionalInput, map, query }) => {
-		const inputSchema = additionalInput ? connectionInput.extend({ args: connectionArgs.and(additionalInput) }) : connectionInput;
-		return procedure.input(inputSchema).query(async (resolverOptions) => {
-			const { ctx, input } = resolverOptions;
-			const paginationArgs = paginationArgsSchema.parse(extractPaginationArgs(input.args));
-			const isBackward = paginationArgs.before !== void 0 || paginationArgs.last !== void 0;
-			const cursor = isBackward ? paginationArgs.before : paginationArgs.after;
-			const direction = isBackward ? "backward" : "forward";
-			const pageSize = paginationArgs.first ?? paginationArgs.last ?? defaultSize;
-			const rawItems = await query({
-				ctx,
-				cursor,
-				direction,
-				input,
-				skip: cursor ? 1 : void 0,
-				take: pageSize + 1
+		queue.push(value);
+	};
+	const onAbort = () => cleanup();
+	for (const name of names) emitter.on(name, listener);
+	signal?.addEventListener("abort", onAbort, { once: true });
+	return {
+		async next() {
+			if (queue.length > 0) return {
+				done: false,
+				value: [queue.shift()]
+			};
+			if (done || signal?.aborted) {
+				cleanup();
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+			return await new Promise((resolve) => {
+				pending = resolve;
 			});
-			const hasMore = rawItems.length > pageSize;
-			const limitedItems = isBackward ? rawItems.slice(Math.max(0, rawItems.length - pageSize)) : rawItems.slice(0, pageSize);
-			const items = (map ? await map({
-				ctx,
-				input,
-				items: limitedItems
-			}) : limitedItems).map((node) => ({
-				cursor: getCursor(node),
-				node
-			}));
-			const firstItem = items[0];
-			const lastItem = items.at(-1);
+		},
+		async return() {
+			cleanup();
 			return {
-				items,
-				pagination: {
-					hasNext: isBackward ? Boolean(cursor) : hasMore,
-					hasPrevious: isBackward ? hasMore : Boolean(cursor),
-					nextCursor: lastItem?.cursor,
-					previousCursor: (isBackward ? hasMore : Boolean(cursor)) ? firstItem?.cursor : void 0
-				}
+				done: true,
+				value: void 0
 			};
-		});
+		}
 	};
-}
-
-//#endregion
-//#region src/server/dataView.ts
-const dataViewFieldsKey = Symbol("__fate__DataViewFields");
+} });
 /**
-* Declares a server data view that exposes an object's available fields to the client.
+* Creates a small in-memory event bus for Fate live view subscriptions.
 *
-* @example
-* const Post = dataView<PostItem>('Post')({
-*   id: true,
-*   title: true,
-* });
+* The bus signals that an entity changed and can optionally include changed
+* field paths. The native live handler refetches the selected record, or only
+* the changed selected fields when paths are provided, before sending it to
+* clients. It does not persist events or replay events after reconnects; provide
+* a durable custom bus for lossless `lastEventId` resume behavior.
 */
-function dataView(typeName) {
-	return (fields) => {
-		return {
-			[dataViewFieldsKey]: fields,
-			fields,
-			typeName
-		};
+function createLiveEventBus() {
+	const emitter = new EventEmitter();
+	emitter.setMaxListeners(0);
+	const emit = (type, id, options = {}) => {
+		emitter.emit(eventName(type, id), {
+			changed: options.changed,
+			data: options.data,
+			eventId: options.eventId,
+			id,
+			type: options.type ?? "update"
+		});
 	};
-}
-/**
-* Marks a data view as a list resolver so the server can respond with
-* connection information.
-*/
-const list = (view) => {
-	return {
-		...view,
-		kind: "list"
+	const listen = (names, handler, signal) => {
+		const listener = (event) => handler(event);
+		const cleanup = () => {
+			for (const name of names) emitter.off(name, listener);
+			signal?.removeEventListener("abort", cleanup);
+		};
+		for (const name of names) emitter.on(name, listener);
+		signal?.addEventListener("abort", cleanup, { once: true });
+		return cleanup;
 	};
-};
-/**
-* Declares a resolver field inside a data view, optionally providing a
-* selection for any data dependencies.
-*/
-function resolver(config) {
 	return {
-		kind: "resolver",
-		...config
+		connection(procedure, args) {
+			const emitConnection = (type, options = {}) => {
+				const event = {
+					cursor: options.cursor,
+					eventId: options.eventId,
+					id: options.id,
+					node: options.node,
+					nodeType: options.nodeType,
+					targetCursor: options.targetCursor,
+					type
+				};
+				if (args) emitter.emit(connectionEventName(procedure, args), event);
+				else emitter.emit(globalConnectionEventName(procedure), event);
+			};
+			return {
+				appendEdge(nodeType, id, options) {
+					emitConnection("appendEdge", {
+						...options,
+						id,
+						nodeType
+					});
+				},
+				appendNode(nodeType, id, options) {
+					emitConnection("appendNode", {
+						...options,
+						id,
+						nodeType
+					});
+				},
+				deleteEdge(nodeType, id, options) {
+					emitConnection("deleteEdge", {
+						...options,
+						id,
+						nodeType
+					});
+				},
+				emit: emitConnection,
+				insertEdgeAfter(nodeType, id, targetCursor, options) {
+					emitConnection("insertEdgeAfter", {
+						...options,
+						id,
+						nodeType,
+						targetCursor
+					});
+				},
+				insertEdgeBefore(nodeType, id, targetCursor, options) {
+					emitConnection("insertEdgeBefore", {
+						...options,
+						id,
+						nodeType,
+						targetCursor
+					});
+				},
+				invalidate(options) {
+					emitConnection("invalidate", options);
+				},
+				prependEdge(nodeType, id, options) {
+					emitConnection("prependEdge", {
+						...options,
+						id,
+						nodeType
+					});
+				},
+				prependNode(nodeType, id, options) {
+					emitConnection("prependNode", {
+						...options,
+						id,
+						nodeType
+					});
+				}
+			};
+		},
+		delete(type, id, options) {
+			emit(type, id, {
+				...options,
+				type: "delete"
+			});
+		},
+		emit,
+		listen(type, id, handler, options) {
+			return listen([eventName(type, id)], handler, options?.signal);
+		},
+		listenConnection(target, handler, options) {
+			return listen([connectionEventName(target.procedure, target.args), globalConnectionEventName(target.procedure)], handler, options?.signal);
+		},
+		subscribe(type, id, options) {
+			return on(emitter, eventName(type, id), { signal: options?.signal });
+		},
+		subscribeConnection(target, options) {
+			return mergeEvents(emitter, [connectionEventName(target.procedure, target.args), globalConnectionEventName(target.procedure)], options?.signal);
+		},
+		update(type, id, options) {
+			emit(type, id, {
+				...options,
+				type: "update"
+			});
+		}
 	};
 }
-const isResolverField = (field) => Boolean(field) && typeof field === "object" && "kind" in field && field.kind === "resolver";
-const isDataViewField = (field) => Boolean(field) && typeof field === "object" && "fields" in field;
-const filterToViewFields = (item, view, selectedPaths, prefix = null) => {
-	if (!isRecord$1(item)) return item;
-	const filtered = {};
-	for (const [field, config] of Object.entries(view.fields)) {
-		const path = prefix ? `${prefix}.${field}` : field;
-		let hasSelection = selectedPaths.has(path);
-		if (!hasSelection) {
-			for (const selected of selectedPaths) if (selected.startsWith(`${path}.`)) {
-				hasSelection = true;
-				break;
-			}
-		}
-		if (!hasSelection) continue;
-		if (!(field in item)) continue;
-		const value = item[field];
-		if (isDataViewField(config)) {
-			if (Array.isArray(value)) {
-				filtered[field] = value.map((entry) => isRecord$1(entry) ? filterToViewFields(entry, config, selectedPaths, path) : entry);
-				continue;
-			}
-			if (isRecord$1(value)) {
-				filtered[field] = filterToViewFields(value, config, selectedPaths, path);
-				continue;
-			}
-		}
-		filtered[field] = value;
+//#endregion
+//#region src/server/http.ts
+const jsonHeaders = { "content-type": "application/json; charset=utf-8" };
+const sseHeaders = {
+	"cache-control": "no-cache",
+	connection: "keep-alive",
+	"content-type": "text/event-stream; charset=utf-8"
+};
+const normalizeRootConfig = (root) => isDataView(root) ? { view: root } : root;
+const rootProcedureName = (name, _root) => {
+	return name;
+};
+const getLiveBus = (live) => {
+	if (!live) return null;
+	if ("subscribe" in live) return live;
+	return live.bus;
+};
+const getWaitUntil = (adapterContext) => {
+	const context = adapterContext;
+	if (!context) return;
+	try {
+		const executionCtx = context.executionCtx;
+		const waitUntil = executionCtx?.waitUntil;
+		if (waitUntil) return waitUntil.bind(executionCtx);
+	} catch {}
+	try {
+		return context.waitUntil?.bind(context);
+	} catch {
+		return;
 	}
-	return filtered;
 };
-const mergeObject = (target, source) => {
-	for (const [key, value] of Object.entries(source)) {
-		const existing = target[key];
-		if (isRecord$1(existing) && isRecord$1(value)) {
-			mergeObject(existing, value);
-			continue;
-		}
-		target[key] = value;
+const parseJSON = async (request) => {
+	try {
+		return await request.json();
+	} catch {
+		throw new FateRequestError("BAD_REQUEST", "Request body must be valid JSON.");
 	}
 };
-const ensureRelationSelect = (select, path) => {
-	if (!path) return select;
-	const segments = path.split(".");
-	let current = select;
-	for (const segment of segments) {
-		const existing = current[segment];
-		if (isRecord$1(existing) && "select" in existing) {
-			const relation$1 = existing;
-			if (!isRecord$1(relation$1.select)) relation$1.select = {};
-			current = relation$1.select;
-			continue;
-		}
-		const relation = { select: {} };
-		current[segment] = relation;
-		current = relation.select;
+const validationError = (issues) => new FateRequestError("VALIDATION_ERROR", "Validation failed.", { issues });
+const parseInput = async (schema, value) => {
+	if (!schema) return value;
+	const standard = schema["~standard"];
+	if (standard) try {
+		const result = await standard.validate(value);
+		if (isRecord(result) && "issues" in result) throw validationError(result.issues);
+		return isRecord(result) && "value" in result ? result.value : value;
+	} catch (error) {
+		if (error instanceof FateRequestError) throw error;
+		throw validationError(isRecord(error) ? error.issues : void 0);
+	}
+	if (schema.parse) try {
+		return schema.parse(value);
+	} catch (error) {
+		throw validationError(isRecord(error) ? error.issues : void 0);
 	}
-	return current;
+	return value;
 };
-const createSelectedNode = (view, path) => ({
-	path,
-	relations: /* @__PURE__ */ new Map(),
-	resolvers: /* @__PURE__ */ new Map(),
-	view
-});
-const assignPath = (node, segments, path, selectedPaths, view, allowedPaths) => {
-	if (segments.length === 0) return;
-	const [segment, ...rest] = segments;
-	const field = view.fields[segment];
-	if (!field) return;
-	const nextPath = path ? `${path}.${segment}` : segment;
-	if (isResolverField(field)) {
-		if (rest.length === 0) {
-			node.resolvers.set(segment, field);
-			selectedPaths.add(nextPath);
-		}
-		return;
+const isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+const isProtocolId = (value) => typeof value === "string" || typeof value === "number";
+const operationKinds = new Set([
+	"byId",
+	"list",
+	"mutation",
+	"query"
+]);
+const assertProtocolRequest = (value) => {
+	if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.operations)) throw new FateRequestError("BAD_REQUEST", "Invalid Fate protocol request.");
+	for (const operation of value.operations) {
+		if (!isRecord(operation) || typeof operation.id !== "string" || typeof operation.kind !== "string" || !operationKinds.has(operation.kind) || !isStringArray(operation.select) || "args" in operation && operation.args !== void 0 && !isRecord(operation.args)) throw new FateRequestError("BAD_REQUEST", "Invalid Fate protocol operation.");
+		if (operation.kind === "byId" && (typeof operation.type !== "string" || !Array.isArray(operation.ids) || !operation.ids.every(isProtocolId))) throw new FateRequestError("BAD_REQUEST", "Invalid Fate byId operation.");
+		if ((operation.kind === "list" || operation.kind === "mutation" || operation.kind === "query") && typeof operation.name !== "string") throw new FateRequestError("BAD_REQUEST", "Invalid Fate named operation.");
 	}
-	if (isDataViewField(field)) {
-		let relationNode = node.relations.get(segment);
-		if (!relationNode) {
-			relationNode = createSelectedNode(field, nextPath);
-			node.relations.set(segment, relationNode);
-		}
-		if (field.fields.id === true) {
-			allowedPaths.add(`${nextPath}.id`);
-			selectedPaths.add(`${nextPath}.id`);
+	return value;
+};
+const assertLiveControlRequest = (value) => {
+	if (!isRecord(value) || value.version !== 1 || typeof value.connectionId !== "string" || !Array.isArray(value.operations)) throw new FateRequestError("BAD_REQUEST", "Invalid Fate live request.");
+	for (const operation of value.operations) {
+		if (!isRecord(operation) || typeof operation.id !== "string" || typeof operation.kind !== "string") throw new FateRequestError("BAD_REQUEST", "Invalid Fate live operation.");
+		if (operation.kind === "subscribe") {
+			if (typeof operation.type !== "string" || !isProtocolId(operation.entityId) || "args" in operation && operation.args !== void 0 && !isRecord(operation.args) || "lastEventId" in operation && operation.lastEventId !== void 0 && typeof operation.lastEventId !== "string" || !isStringArray(operation.select)) throw new FateRequestError("BAD_REQUEST", "Invalid Fate live subscribe operation.");
+			continue;
 		}
-		if (rest.length === 0) {
-			selectedPaths.add(nextPath);
-			return;
+		if (operation.kind === "subscribeConnection") {
+			if (typeof operation.type !== "string" || typeof operation.procedure !== "string" || "args" in operation && operation.args !== void 0 && !isRecord(operation.args) || "selectionArgs" in operation && operation.selectionArgs !== void 0 && !isRecord(operation.selectionArgs) || "lastEventId" in operation && operation.lastEventId !== void 0 && typeof operation.lastEventId !== "string" || !isStringArray(operation.select)) throw new FateRequestError("BAD_REQUEST", "Invalid Fate live connection subscribe operation.");
+			continue;
 		}
-		assignPath(relationNode, rest, nextPath, selectedPaths, field, allowedPaths);
-		return;
+		if (operation.kind !== "unsubscribe") throw new FateRequestError("BAD_REQUEST", "Invalid Fate live operation.");
+	}
+	return value;
+};
+const sse = (message, eventId) => {
+	const lines = [];
+	if (eventId) lines.push(`id: ${eventId}`);
+	lines.push(`event: ${message.kind}`);
+	lines.push(`data: ${JSON.stringify(message)}`);
+	return `${lines.join("\n")}\n\n`;
+};
+const sseComment = (message) => `: ${message}\n\n`;
+const livePayload = (event, data, select) => event.type === "delete" || data == null ? {
+	delete: true,
+	id: event.id
+} : {
+	data,
+	...select ? { select: [...select] } : void 0
+};
+const pathsIntersect = (left, right) => left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
+const filterLiveSelection = (source, select, changed) => {
+	if (!changed) return null;
+	const changedPaths = changed.filter((path) => path.length > 0);
+	if (changedPaths.length === 0) return [];
+	const selected = select.filter((path) => changedPaths.some((changedPath) => pathsIntersect(path, changedPath)));
+	if (selected.length === 0) return [];
+	const result = new Set(selected);
+	result.add(source.id);
+	for (const path of select) {
+		if (!path.endsWith(".id")) continue;
+		const parentPath = path.slice(0, -3);
+		if (selected.some((selectedPath) => pathsIntersect(selectedPath, parentPath))) result.add(path);
 	}
-	if (rest.length === 0) {
-		allowedPaths.add(nextPath);
-		selectedPaths.add(nextPath);
+	return [...result];
+};
+const hasSelectedDataPath = (value, segments) => {
+	if (segments.length === 0) return true;
+	if (Array.isArray(value)) return value.every((entry) => hasSelectedDataPath(entry, segments));
+	if (!isRecord(value)) return false;
+	const [field, ...rest] = segments;
+	return field in value && hasSelectedDataPath(value[field], rest);
+};
+const canUseLiveEventData = (data, selectedPaths) => {
+	if (!isRecord(data)) return false;
+	for (const path of selectedPaths) if (!hasSelectedDataPath(data, path.split("."))) return false;
+	return true;
+};
+const resolveLiveSourceData = async ({ ctx, data, id, input, registry, source }) => {
+	if (data !== void 0) {
+		if (data == null) return data;
+		const plan = createSourcePlan({
+			...input,
+			ctx,
+			source
+		});
+		if (canUseLiveEventData(data, plan.selectedPaths)) return await plan.resolve(data);
 	}
+	return id == null ? null : await resolveSourceById({
+		ctx,
+		id: String(id),
+		input,
+		registry,
+		source
+	});
 };
-const collectResolvers = (node, select, args$1, context) => {
-	for (const resolver of node.resolvers.values()) {
-		if (!resolver.select) continue;
-		const addition = typeof resolver.select === "function" ? resolver.select({
-			args: args$1,
-			context
-		}) : resolver.select;
-		if (addition && isRecord$1(addition)) mergeObject(ensureRelationSelect(select, node.path), addition);
+const liveConnectionPayload = (event, node) => {
+	switch (event.type) {
+		case "deleteEdge": return {
+			id: event.id,
+			nodeType: event.nodeType,
+			type: "deleteEdge"
+		};
+		case "invalidate": return { type: "invalidate" };
+		default: return {
+			edge: {
+				cursor: event.cursor,
+				node
+			},
+			nodeType: event.nodeType,
+			targetCursor: event.targetCursor,
+			type: event.type
+		};
 	}
-	for (const relation of node.relations.values()) collectResolvers(relation, select, args$1, context);
 };
-const resolveNode = async ({ item, node, options: resolverOptions }) => {
-	if (!isRecord$1(item)) return item;
-	let result = null;
-	const assign = (key, value) => {
-		if (!result) result = { ...item };
-		result[key] = value;
+const sourceScore = (source) => Object.keys(source.view.fields).length + Object.keys(source.relations ?? {}).length;
+function createFateServer({ context, lists, live, mutations, queries, roots, sources }) {
+	const rootLists = /* @__PURE__ */ new Map();
+	const rootQueries = /* @__PURE__ */ new Map();
+	const sourcesByType = /* @__PURE__ */ new Map();
+	const registerSourceByType = (source) => {
+		const existing = sourcesByType.get(source.view.typeName);
+		if (!existing || sourceScore(source) > sourceScore(existing)) sourcesByType.set(source.view.typeName, source);
+	};
+	const visit = (view) => {
+		registerSourceByType(sources.getSource(view));
+		for (const field of Object.values(view.fields)) if (isDataView(field)) visit(field);
 	};
-	const getItem = () => result ?? item;
-	for (const [field, resolver] of node.resolvers) {
-		if (resolver.authorize) {
-			if (!await resolver.authorize(getItem(), resolverOptions.context, resolverOptions.args)) {
-				assign(field, null);
-				continue;
+	for (const [name, root] of Object.entries(roots)) {
+		const config = normalizeRootConfig(root);
+		const procedure = rootProcedureName(name, root);
+		const source = sources.getSource(config.view);
+		visit(config.view);
+		if (config.view.kind === "list") rootLists.set(procedure, {
+			source,
+			view: config.view
+		});
+		else rootQueries.set(procedure, {
+			source,
+			view: config.view
+		});
+	}
+	for (const name of rootQueries.keys()) if (!queries?.[name]) throw new Error(`Native fate root query '${name}' requires a matching resolver in createFateServer({ queries }).`);
+	const liveBus = getLiveBus(live);
+	const getContext = async (request, adapterContext) => context ? await context({
+		adapterContext,
+		request
+	}) : void 0;
+	const executeOperation = async (operation, ctx) => {
+		try {
+			const input = {
+				args: operation.args,
+				select: operation.select
+			};
+			if (operation.kind === "byId") {
+				if (!operation.type || !operation.ids) throw new FateRequestError("BAD_REQUEST", "byId operations require type and ids.");
+				const source = sourcesByType.get(operation.type);
+				if (!source) throw new FateRequestError("NOT_FOUND", `No source registered for '${operation.type}'.`);
+				return {
+					data: await resolveSourceByIds({
+						ctx,
+						ids: operation.ids.map(String),
+						input,
+						registry: sources.registry,
+						source
+					}),
+					id: operation.id,
+					ok: true
+				};
+			}
+			if (!operation.name) throw new FateRequestError("BAD_REQUEST", `${operation.kind} operations require a name.`);
+			if (operation.kind === "list") {
+				const customList = lists?.[operation.name];
+				if (customList) return {
+					data: await customList.resolve({
+						ctx,
+						input: { args: operation.args },
+						select: operation.select
+					}),
+					id: operation.id,
+					ok: true
+				};
+				const root = rootLists.get(operation.name);
+				if (!root) throw new FateRequestError("NOT_FOUND", `No list registered for '${operation.name}'.`);
+				return {
+					data: await resolveConnection({
+						ctx,
+						input,
+						query: ({ ctx, cursor, direction, input, skip, take }) => resolveSourceConnection({
+							ctx,
+							cursor,
+							direction,
+							input,
+							registry: sources.registry,
+							skip,
+							source: root.source,
+							take
+						})
+					}),
+					id: operation.id,
+					ok: true
+				};
 			}
+			if (operation.kind === "query") {
+				const customQuery = queries?.[operation.name];
+				if (customQuery) return {
+					data: await customQuery.resolve({
+						ctx,
+						input: { args: operation.args },
+						select: operation.select
+					}),
+					id: operation.id,
+					ok: true
+				};
+				throw new FateRequestError("NOT_FOUND", `No query registered for '${operation.name}'.`);
+			}
+			const mutation = mutations?.[operation.name];
+			if (!mutation) throw new FateRequestError("NOT_FOUND", `No mutation registered for '${operation.name}'.`);
+			return {
+				data: await mutation.resolve({
+					ctx,
+					input: await parseInput(mutation.input, operation.input),
+					select: operation.select
+				}),
+				id: operation.id,
+				ok: true
+			};
+		} catch (error) {
+			return {
+				error: toProtocolError(error),
+				id: operation.id,
+				ok: false
+			};
 		}
-		const value = await resolver.resolve(getItem(), resolverOptions.context, resolverOptions.args);
-		if (value !== void 0) assign(field, value);
-	}
-	for (const [field, relationNode] of node.relations) {
-		const current = getItem()[field];
-		if (Array.isArray(current)) {
-			const resolved = await Promise.all(current.map((entry) => resolveNode({
-				item: entry,
-				node: relationNode,
-				options: resolverOptions
-			})));
-			if (resolved.some((value, index) => value !== current[index])) assign(field, resolved);
-			continue;
+	};
+	const manifest = {
+		lists: Object.fromEntries([...[...rootLists.entries()].map(([name, entry]) => [name, { type: entry.view.typeName }]), ...Object.entries(lists ?? {}).map(([name, list]) => [name, { type: list.type ?? rootLists.get(name)?.view.typeName ?? "Unknown" }])].sort(([a], [b]) => a.localeCompare(b))),
+		live: liveBus ? Object.fromEntries([...sourcesByType.keys()].sort().map((type) => [type, true])) : {},
+		mutations: Object.fromEntries(Object.entries(mutations ?? {}).map(([name, mutation]) => [name, { type: mutation.type }]).sort(([a], [b]) => a.localeCompare(b))),
+		queries: Object.fromEntries([...[...rootQueries.entries()].map(([name, entry]) => [name, { type: entry.view.typeName }]), ...Object.entries(queries ?? {}).map(([name, query]) => [name, { type: query.type ?? rootQueries.get(name)?.view.typeName ?? "Unknown" }])].sort(([a], [b]) => a.localeCompare(b))),
+		types: Object.fromEntries([...sourcesByType.keys()].sort().map((type) => [type, true]))
+	};
+	const liveConnections = /* @__PURE__ */ new Map();
+	const encoder = new TextEncoder();
+	const cleanupLiveConnection = (connectionId) => {
+		const connection = liveConnections.get(connectionId);
+		if (!connection) return;
+		connection.closed = true;
+		liveConnections.delete(connectionId);
+		for (const subscription of connection.subscriptions.values()) subscription.abort();
+		connection.subscriptions.clear();
+		if (connection.drainInterval) {
+			clearInterval(connection.drainInterval);
+			connection.drainInterval = void 0;
+		}
+		if (connection.drainTimeout) {
+			clearTimeout(connection.drainTimeout);
+			connection.drainTimeout = void 0;
+		}
+		if (connection.heartbeat) {
+			clearInterval(connection.heartbeat);
+			connection.heartbeat = void 0;
+		}
+		try {
+			connection.controller?.close();
+		} catch {}
+		connection.abort();
+	};
+	const sendLiveMessage = (connection, message, eventId) => {
+		if (connection.closed || !connection.controller) return;
+		try {
+			connection.controller.enqueue(encoder.encode(sse(message, eventId)));
+		} catch {
+			connection.closed = true;
+		}
+	};
+	const sendLiveComment = (connection, message) => {
+		if (connection.closed || !connection.controller) return;
+		try {
+			connection.controller.enqueue(encoder.encode(sseComment(message)));
+		} catch {
+			connection.closed = true;
+		}
+	};
+	const drainLiveConnection = async (connection) => {
+		if (connection.closed || connection.draining) return;
+		connection.draining = true;
+		let activeOperationId = null;
+		try {
+			while (!connection.closed && connection.queue.length > 0) {
+				const item = connection.queue.shift();
+				activeOperationId = item.operation.id;
+				if (!item.subscription.active || connection.subscriptions.get(item.operation.id) !== item.subscription) continue;
+				if (item.kind === "entity") {
+					const { event, operation, source } = item;
+					const select = filterLiveSelection(source, operation.select, event.changed);
+					if (select?.length === 0) continue;
+					const input = {
+						args: operation.args,
+						select: select ?? operation.select
+					};
+					sendLiveMessage(connection, {
+						event: livePayload(event, event.type === "delete" ? null : await resolveLiveSourceData({
+							ctx: connection.ctx,
+							data: event.data,
+							id: event.id,
+							input,
+							registry: sources.registry,
+							source
+						}), select ?? void 0),
+						id: operation.id,
+						kind: "next"
+					}, event.eventId);
+					continue;
+				}
+				const { event, operation } = item;
+				const nodeType = event.nodeType ?? operation.type;
+				const source = nodeType ? sourcesByType.get(nodeType) : null;
+				const node = event.type === "deleteEdge" || event.type === "invalidate" ? null : source ? await resolveLiveSourceData({
+					ctx: connection.ctx,
+					data: event.node,
+					id: event.id,
+					input: {
+						args: operation.selectionArgs,
+						select: operation.select
+					},
+					registry: sources.registry,
+					source
+				}) : null;
+				if (event.type !== "invalidate" && (!nodeType || event.type !== "deleteEdge" && node == null)) throw new FateRequestError("NOT_FOUND", `No source registered for live connection node type '${nodeType}'.`);
+				sendLiveMessage(connection, {
+					event: liveConnectionPayload(event, node),
+					id: operation.id,
+					kind: "connection"
+				}, event.eventId);
+			}
+			const now = Date.now();
+			if (!connection.closed && now - connection.lastHeartbeat >= 25e3) {
+				connection.lastHeartbeat = now;
+				sendLiveComment(connection, "heartbeat");
+			}
+		} catch (error) {
+			sendLiveMessage(connection, {
+				error: toProtocolError(error),
+				id: activeOperationId ?? "live",
+				kind: "error"
+			});
+		} finally {
+			connection.draining = false;
 		}
-		if (current && typeof current === "object") {
-			const resolved = await resolveNode({
-				item: current,
-				node: relationNode,
-				options: resolverOptions
+	};
+	const scheduleLiveDrain = (connection) => {
+		if (connection.closed || connection.drainTimeout) return;
+		connection.drainTimeout = setTimeout(() => {
+			connection.drainTimeout = void 0;
+			drainLiveConnection(connection);
+		}, 0);
+	};
+	const subscribeLiveOperation = (connection, operation, waitUntil) => {
+		const source = sourcesByType.get(operation.type);
+		if (!source) throw new FateRequestError("NOT_FOUND", `No source registered for '${operation.type}'.`);
+		connection.subscriptions.get(operation.id)?.abort();
+		const subscriptionController = new AbortController();
+		const subscription = {
+			abort: () => {
+				subscription.active = false;
+				subscriptionController.abort();
+			},
+			active: true
+		};
+		connection.subscriptions.set(operation.id, subscription);
+		const handleEvent = async (event) => {
+			try {
+				const select = filterLiveSelection(source, operation.select, event.changed);
+				if (select?.length === 0) return;
+				const input = {
+					args: operation.args,
+					select: select ?? operation.select
+				};
+				sendLiveMessage(connection, {
+					event: livePayload(event, event.type === "delete" ? null : await resolveLiveSourceData({
+						ctx: connection.ctx,
+						data: event.data,
+						id: event.id,
+						input,
+						registry: sources.registry,
+						source
+					}), select ?? void 0),
+					id: operation.id,
+					kind: "next"
+				}, event.eventId);
+			} catch (error) {
+				if (!subscriptionController.signal.aborted) sendLiveMessage(connection, {
+					error: toProtocolError(error),
+					id: operation.id,
+					kind: "error"
+				});
+			}
+		};
+		if (liveBus.listen) {
+			const unsubscribe = liveBus.listen(operation.type, operation.entityId, (event) => {
+				connection.queue.push({
+					event,
+					kind: "entity",
+					operation,
+					source,
+					subscription
+				});
+				scheduleLiveDrain(connection);
+			}, {
+				lastEventId: operation.lastEventId,
+				signal: subscriptionController.signal
 			});
-			if (resolved !== current) assign(field, resolved);
+			const abort = () => {
+				subscription.active = false;
+				unsubscribe();
+				subscriptionController.abort();
+			};
+			subscription.abort = abort;
+			connection.subscriptions.set(operation.id, subscription);
+			return;
 		}
-	}
-	return result ?? item;
-};
-/**
-* Builds a resolver that applies a client's selection to a server data view,
-* filtering fields, running nested resolvers, and shaping selects.
-*/
-function createResolver({ args: args$1, ctx, select: initialSelect, view }) {
-	const allowedPaths = /* @__PURE__ */ new Set();
-	const selectedPaths = /* @__PURE__ */ new Set();
-	selectedPaths.add("id");
-	const root = createSelectedNode(view, null);
-	for (const path of initialSelect) {
-		if (!path) continue;
-		assignPath(root, path.split("."), null, selectedPaths, view, allowedPaths);
-	}
-	const select = prismaSelect([...allowedPaths], args$1);
-	collectResolvers(root, select, args$1, ctx);
-	const resolve = async (item) => toConnectionResult({
-		args: args$1,
-		item: filterToViewFields(await resolveNode({
-			item,
-			node: root,
-			options: {
-				args: args$1,
-				context: ctx
+		const task = (async () => {
+			try {
+				const iterable = liveBus.subscribe(operation.type, operation.entityId, {
+					lastEventId: operation.lastEventId,
+					signal: subscriptionController.signal
+				});
+				for await (const [event] of iterable) await handleEvent(event);
+			} catch (error) {
+				if (!subscriptionController.signal.aborted) sendLiveMessage(connection, {
+					error: toProtocolError(error),
+					id: operation.id,
+					kind: "error"
+				});
+			} finally {
+				if (connection.subscriptions.get(operation.id) === subscription) connection.subscriptions.delete(operation.id);
 			}
-		}), root.view, selectedPaths),
-		view: root.view
-	});
+		})();
+		waitUntil?.(task);
+	};
+	const subscribeLiveConnectionOperation = (connection, operation, waitUntil) => {
+		connection.subscriptions.get(operation.id)?.abort();
+		const subscriptionController = new AbortController();
+		const subscription = {
+			abort: () => {
+				subscription.active = false;
+				subscriptionController.abort();
+			},
+			active: true
+		};
+		connection.subscriptions.set(operation.id, subscription);
+		const handleEvent = async (event) => {
+			try {
+				const nodeType = event.nodeType ?? operation.type;
+				const source = nodeType ? sourcesByType.get(nodeType) : null;
+				const node = event.type === "deleteEdge" || event.type === "invalidate" ? null : source ? await resolveLiveSourceData({
+					ctx: connection.ctx,
+					data: event.node,
+					id: event.id,
+					input: {
+						args: operation.selectionArgs,
+						select: operation.select
+					},
+					registry: sources.registry,
+					source
+				}) : null;
+				if (event.type !== "invalidate" && (!nodeType || event.type !== "deleteEdge" && node == null)) throw new FateRequestError("NOT_FOUND", `No source registered for live connection node type '${nodeType}'.`);
+				sendLiveMessage(connection, {
+					event: liveConnectionPayload(event, node),
+					id: operation.id,
+					kind: "connection"
+				}, event.eventId);
+			} catch (error) {
+				if (!subscriptionController.signal.aborted) sendLiveMessage(connection, {
+					error: toProtocolError(error),
+					id: operation.id,
+					kind: "error"
+				});
+			}
+		};
+		if (liveBus.listenConnection) {
+			const unsubscribe = liveBus.listenConnection({
+				args: operation.args,
+				procedure: operation.procedure
+			}, (event) => {
+				connection.queue.push({
+					event,
+					kind: "connection",
+					operation,
+					subscription
+				});
+				scheduleLiveDrain(connection);
+			}, {
+				lastEventId: operation.lastEventId,
+				signal: subscriptionController.signal
+			});
+			const abort = () => {
+				subscription.active = false;
+				unsubscribe();
+				subscriptionController.abort();
+			};
+			subscription.abort = abort;
+			connection.subscriptions.set(operation.id, subscription);
+			return;
+		}
+		const task = (async () => {
+			try {
+				const iterable = liveBus.subscribeConnection({
+					args: operation.args,
+					procedure: operation.procedure
+				}, {
+					lastEventId: operation.lastEventId,
+					signal: subscriptionController.signal
+				});
+				for await (const [event] of iterable) await handleEvent(event);
+			} catch (error) {
+				if (!subscriptionController.signal.aborted) sendLiveMessage(connection, {
+					error: toProtocolError(error),
+					id: operation.id,
+					kind: "error"
+				});
+			} finally {
+				if (connection.subscriptions.get(operation.id) === subscription) connection.subscriptions.delete(operation.id);
+			}
+		})();
+		waitUntil?.(task);
+	};
+	const controlLiveConnection = async (request, adapterContext) => {
+		const body = assertLiveControlRequest(await parseJSON(request));
+		const connection = liveConnections.get(body.connectionId);
+		if (!connection || connection.closed) throw new FateRequestError("NOT_FOUND", "Live connection not found.");
+		const results = [];
+		const waitUntil = getWaitUntil(adapterContext);
+		for (const operation of body.operations) try {
+			if (operation.kind === "subscribe") subscribeLiveOperation(connection, operation, waitUntil);
+			else if (operation.kind === "subscribeConnection") subscribeLiveConnectionOperation(connection, operation, waitUntil);
+			else {
+				connection.subscriptions.get(operation.id)?.abort();
+				connection.subscriptions.delete(operation.id);
+			}
+			results.push({
+				data: null,
+				id: operation.id,
+				ok: true
+			});
+		} catch (error) {
+			results.push({
+				error: toProtocolError(error),
+				id: operation.id,
+				ok: false
+			});
+		}
+		return {
+			results,
+			version: 1
+		};
+	};
 	return {
-		resolve,
-		resolveMany: (items) => Promise.all(items.map((item) => resolve(item))),
-		select
+		async handleLiveRequest(request, adapterContext) {
+			try {
+				if (!liveBus) throw new FateRequestError("NOT_FOUND", "Live views are not enabled.");
+				if (request.method === "POST") return Response.json(await controlLiveConnection(request, adapterContext), { headers: jsonHeaders });
+				if (request.method !== "GET") throw new FateRequestError("BAD_REQUEST", "Invalid Fate live request.");
+				const connectionId = new URL(request.url).searchParams.get("connectionId");
+				if (!connectionId) throw new FateRequestError("BAD_REQUEST", "Invalid Fate live request.");
+				const ctx = await getContext(request, adapterContext);
+				const liveController = new AbortController();
+				const abortLive = () => liveController.abort();
+				if (request.signal.aborted) abortLive();
+				else request.signal.addEventListener("abort", abortLive, { once: true });
+				cleanupLiveConnection(connectionId);
+				const stream = new ReadableStream({
+					cancel() {
+						cleanupLiveConnection(connectionId);
+					},
+					pull() {
+						const connection = liveConnections.get(connectionId);
+						if (connection) drainLiveConnection(connection);
+					},
+					start(controller) {
+						const connection = {
+							abort: abortLive,
+							closed: false,
+							controller,
+							ctx,
+							lastHeartbeat: Date.now(),
+							queue: [],
+							subscriptions: /* @__PURE__ */ new Map()
+						};
+						connection.drainInterval = setInterval(() => void drainLiveConnection(connection), 100);
+						liveConnections.set(connectionId, connection);
+						controller.enqueue(encoder.encode(sseComment("connected")));
+					}
+				});
+				liveController.signal.addEventListener("abort", () => {
+					request.signal.removeEventListener("abort", abortLive);
+					cleanupLiveConnection(connectionId);
+				}, { once: true });
+				return new Response(stream, { headers: sseHeaders });
+			} catch (error) {
+				const protocolError = toProtocolError(error);
+				return Response.json({
+					results: [{
+						error: protocolError,
+						id: "live",
+						ok: false
+					}],
+					version: 1
+				}, {
+					headers: jsonHeaders,
+					status: error instanceof FateRequestError ? error.status : 500
+				});
+			}
+		},
+		async handleRequest(request, adapterContext) {
+			try {
+				const body = assertProtocolRequest(await parseJSON(request));
+				const ctx = await getContext(request, adapterContext);
+				const results = await Promise.all(body.operations.map((operation) => executeOperation(operation, ctx)));
+				return Response.json({
+					results,
+					version: 1
+				}, { headers: jsonHeaders });
+			} catch (error) {
+				const protocolError = toProtocolError(error);
+				return Response.json({
+					results: [{
+						error: protocolError,
+						id: "request",
+						ok: false
+					}],
+					version: 1
+				}, {
+					headers: jsonHeaders,
+					status: error instanceof FateRequestError ? error.status : 500
+				});
+			}
+		},
+		manifest
+	};
+}
+function createFateFetchHandler(server) {
+	return (request, adapterContext) => {
+		return new URL(request.url).pathname.endsWith("/live") ? server.handleLiveRequest(request, adapterContext) : server.handleRequest(request, adapterContext);
+	};
+}
+function createHonoFateHandler(server) {
+	return (context) => {
+		return new URL(context.req.raw.url).pathname.endsWith("/live") ? server.handleLiveRequest(context.req.raw, context) : server.handleRequest(context.req.raw, context);
 	};
 }
-
-//#endregion
-//#region src/server/input.ts
-const byIdInput = z.object({
-	args: connectionArgs,
-	ids: z.array(z.string().min(1)).nonempty(),
-	select: z.array(z.string())
-});
-
 //#endregion
-export { byIdInput, connectionArgs, createResolver, dataView, list, resolver, withConnection };
+export { FateRequestError, bindSourceProcedures, byIdInput, computed, connectionArgs, count, createFateFetchHandler, createFateServer, createHonoFateHandler, createLiveEventBus, createNestedSourcePlan, createResolver, createSourcePlan, createSourceProcedures, dataView, field, getNestedSelection, getScopedArgs, hasNestedSelection, isRecord, list, liveConnectionTopic, liveEntityTopic, liveGlobalConnectionTopic, refetchSourceById, resolveSourceById, resolveSourceByIds, resolveSourceConnection, resolver, toPrismaSelect, withConnection };