@nkzw/fate 0.0.1

package/lib/record-DnhZuvUe.mjs

@@ -0,0 +1,5 @@
+//#region src/record.ts
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+//#endregion
+export { isRecord as t };

package/lib/server.d.mts

@@ -0,0 +1,163 @@
+import { z } from "zod";
+import { TRPCProcedureBuilder } from "@trpc/server";
+
+//#region src/server/dataView.d.ts
+declare const dataViewFieldsKey: unique symbol;
+type AnyRecord = Record<string, unknown>;
+type ResolverSelect<Context> = AnyRecord | ((options: {
+  args?: AnyRecord;
+  context?: Context;
+}) => AnyRecord | void);
+type Bivariant<Fn extends (...args: Array<any>) => unknown> = {
+  bivarianceHack(...args: Parameters<Fn>): ReturnType<Fn>;
+}['bivarianceHack'];
+type ResolverResolve<Item$1 extends AnyRecord, Context> = Bivariant<(options: {
+  args?: AnyRecord;
+  context?: Context;
+  item: Item$1;
+}) => Promise<unknown> | unknown>;
+/**
+ * Field configuration for selecting and resolving a computed value on the backend.
+ */
+type ResolverField<Item$1 extends AnyRecord, Context> = {
+  kind: 'resolver';
+  resolve: ResolverResolve<Item$1, Context>;
+  select?: ResolverSelect<Context>;
+};
+type DataField<Item$1 extends AnyRecord, Context> = true | DataView<AnyRecord, Context> | ResolverField<Item$1, Context>;
+/**
+ * Recursively serializes resolver results for transport across the network.
+ */
+type Serializable<T> = T extends Date ? string : T extends Array<infer U> ? Array<Serializable<U>> : T extends object ? { [K in keyof T]: Serializable<T[K]> } : T;
+/**
+ * Server-side mirror of a view definition describing how to select and resolve
+ * fields when fulfilling a client request.
+ */
+type DataView<Item$1 extends AnyRecord, Context = unknown> = {
+  fields: Record<string, DataField<Item$1, Context>>;
+  kind?: 'resolver' | 'list';
+  typeName: string;
+};
+/**
+ * Convenience type for declaring the fields of a server data view.
+ */
+type DataViewConfig<Item$1 extends AnyRecord, Context> = Record<string, DataField<Item$1, Context>>;
+/**
+ * Declares a server data view that exposes an object's available fields to the client.
+ *
+ * @example
+ * const Post = dataView<PostItem>('Post')({
+ *   id: true,
+ *   title: true,
+ * });
+ */
+declare function dataView<Item$1 extends AnyRecord, Context = unknown>(typeName?: string): <Fields$1 extends DataViewConfig<Item$1, Context>>(fields: Fields$1) => DataView<Item$1, Context> & {
+  readonly [dataViewFieldsKey]: Fields$1;
+};
+/**
+ * Marks a data view as a list resolver so the server can respond with
+ * connection information.
+ */
+declare const list: <Item$1 extends AnyRecord, Context>(view: DataView<Item$1, Context>) => {
+  kind: "list";
+  fields: Record<string, DataField<Item$1, Context>>;
+  typeName: string;
+};
+/**
+ * Declares a resolver field inside a data view, optionally providing a
+ * selection for any data dependencies.
+ */
+declare function resolver<Item$1 extends AnyRecord, Context = unknown>(config: {
+  resolve: ResolverResolve<Item$1, Context>;
+  select?: ResolverSelect<Context>;
+}): ResolverField<Item$1, Context>;
+type NonNullish<T> = Exclude<T, null | undefined>;
+type WithNullish<Original, Value> = null extends Original ? undefined extends Original ? Value | null | undefined : Value | null : undefined extends Original ? Value | undefined : Value;
+type ResolverResult<Field> = Field extends ResolverField<AnyRecord, unknown> ? Awaited<ReturnType<Field['resolve']>> : never;
+type RelationResult<ItemField, V extends DataView<AnyRecord, unknown>> = NonNullish<ItemField> extends Array<unknown> ? WithNullish<ItemField, Array<RawDataViewResult<V>>> : WithNullish<ItemField, RawDataViewResult<V>>;
+type ViewFieldConfig<V extends DataView<AnyRecord, unknown>> = V extends {
+  readonly [dataViewFieldsKey]: infer Fields;
+} ? Fields : V['fields'];
+type RawFieldResult<Item$1 extends AnyRecord, Key extends PropertyKey, Field extends DataField<Item$1, unknown>> = Field extends true ? Key extends keyof Item$1 ? Item$1[Key] : never : Field extends DataView<infer ChildItem, unknown> ? Key extends keyof Item$1 ? RelationResult<Item$1[Key], DataView<ChildItem, unknown>> : never : Field extends ResolverField<Item$1, unknown> ? ResolverResult<Field> : never;
+type RawDataViewResult<V extends DataView<AnyRecord, unknown>> = V extends DataView<infer Item, unknown> ? { [K in keyof ViewFieldConfig<V>]: RawFieldResult<Item, K, ViewFieldConfig<V>[K]> } : never;
+/**
+ * Resolved and serialized shape returned from a data view.
+ */
+type DataViewResult<V extends DataView<AnyRecord, unknown>> = Serializable<RawDataViewResult<V>>;
+/**
+ * Builds a resolver that applies a client's selection to a server data view,
+ * filtering fields, running nested resolvers, and shaping selects.
+ */
+declare function createResolver<Item$1 extends AnyRecord, Context = unknown>({
+  args,
+  ctx,
+  select: initialSelect,
+  view
+}: {
+  args?: AnyRecord;
+  ctx?: Context;
+  select: Iterable<string>;
+  view: DataView<Item$1, Context>;
+}): {
+  resolve: (item: Item$1) => Promise<AnyRecord>;
+  resolveMany: (items: Array<AnyRecord>) => Promise<Array<AnyRecord>>;
+  select: Record<string, unknown>;
+};
+//#endregion
+//#region src/server/connection.d.ts
+type ConnectionInput = z.infer<typeof connectionInput>;
+type AdditionalInputSchema = z.ZodObject<Record<string, z.ZodTypeAny>>;
+type ConnectionInputWithAdditional<TAdditionalInput extends AdditionalInputSchema | undefined> = ConnectionInput & {
+  args?: ConnectionInput['args'] extends infer A ? A & (TAdditionalInput extends AdditionalInputSchema ? z.infer<TAdditionalInput> : object) : never;
+};
+type ConnectionCursor = string;
+/**
+ * Connection item including the node and opaque cursor.
+ */
+
+type ProcedureLike<TContext> = TRPCProcedureBuilder<TContext, any, any, any, any, any, any, false>;
+type QueryFn<TContext, TItem, TInput extends ConnectionInput> = (options: {
+  ctx: TContext;
+  cursor?: ConnectionCursor;
+  direction: 'forward' | 'backward';
+  input: TInput;
+  skip?: number;
+  take: number;
+}) => Promise<Array<TItem>>;
+type MapFn<TContext, TItem, TNode, TInput extends ConnectionInput> = (options: {
+  ctx: TContext;
+  input: TInput;
+  items: Array<TItem>;
+}) => Promise<Array<TNode>> | Array<TNode>;
+/**
+ * Zod schema for connection args (`after`, `before`, `first`, `last`, etc.).
+ */
+declare const connectionArgs: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+declare const connectionInput: z.ZodObject<{
+  args: z.ZodOptional<z.ZodType<Record<string, unknown>, unknown, z.core.$ZodTypeInternals<Record<string, unknown>, unknown>>>;
+  select: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Converts an array of nodes into a list view connection result the client
+ * can normalize.
+ */
+
+/**
+ * Wraps a tRPC procedure to handle cursor-based pagination with consistent
+ * connection semantics.
+ */
+declare const withConnection: <TContext>(procedure: ProcedureLike<TContext>) => <TItem, TNode = TItem, TAdditionalInput extends AdditionalInputSchema | undefined = undefined>({
+  defaultSize,
+  getCursor,
+  input: additionalInput,
+  map,
+  query
+}: {
+  defaultSize?: number;
+  getCursor?: (node: TNode) => ConnectionCursor;
+  input?: TAdditionalInput;
+  map?: MapFn<TContext, TItem, TNode, ConnectionInputWithAdditional<TAdditionalInput>>;
+  query: QueryFn<TContext, TItem, ConnectionInputWithAdditional<TAdditionalInput>>;
+}) => ReturnType<ReturnType<ProcedureLike<TContext>["input"]>["query"]>;
+//#endregion
+export { type DataViewResult, connectionArgs, createResolver, dataView, list, resolver, withConnection };

package/lib/server.mjs

@@ -0,0 +1,439 @@
+import { t as isRecord } 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;
+};
+const isRecord$1 = (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$1(current)) return;
+		current = current[segment];
+	}
+	return isRecord$1(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;
+		});
+	}
+	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$1) => args$1 ? Object.fromEntries(Object.entries(args$1).filter(([key]) => paginationArgKeys.has(key))) : {};
+/**
+* Converts an array of nodes into a list view connection result the client
+* can normalize.
+*/
+function arrayToConnection(nodes, { args: args$1, getCursor = (node) => String(node.id) } = {}) {
+	if (!nodes) return;
+	const paginationArgs = paginationArgsSchema.parse(extractPaginationArgs(args$1));
+	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
+		}
+	};
+}
+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: args$1, item, path, view }) {
+	if (!isRecord(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: args$1,
+				item: item$1,
+				path: nextPath,
+				view: config
+			})), { args: getScopedArgs(args$1, nextPath) });
+			result = assignIfChanged(result, field, connection, current);
+			continue;
+		}
+		if (Array.isArray(current)) {
+			const wrapped = current.map((entry) => toConnectionResult({
+				args: args$1,
+				item: entry,
+				path: nextPath,
+				view: config
+			}));
+			result = assignIfChanged(result, field, wrapped, current);
+			continue;
+		}
+		if (isRecord(current)) {
+			const wrapped = toConnectionResult({
+				args: args$1,
+				item: current,
+				path: nextPath,
+				view: config
+			});
+			result = assignIfChanged(result, field, wrapped, current);
+		}
+	}
+	return result ? {
+		...item,
+		...result
+	} : item;
+}
+/**
+* Wraps a tRPC procedure to handle cursor-based pagination with consistent
+* connection semantics.
+*/
+const withConnection = (procedure) => ({ 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
+		});
+		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);
+		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
+			}
+		};
+	});
+};
+
+//#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.
+*
+* @example
+* const Post = dataView<PostItem>('Post')({
+*   id: true,
+*   title: true,
+* });
+*/
+function dataView(typeName) {
+	return (fields) => {
+		return {
+			[dataViewFieldsKey]: fields,
+			fields,
+			typeName
+		};
+	};
+}
+/**
+* Marks a data view as a list resolver so the server can respond with
+* connection information.
+*/
+const list = (view) => {
+	return {
+		...view,
+		kind: "list"
+	};
+};
+/**
+* Declares a resolver field inside a data view, optionally providing a
+* selection for any data dependencies.
+*/
+function resolver(config) {
+	return {
+		kind: "resolver",
+		...config
+	};
+}
+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) => {
+	if (!isRecord(item)) return item;
+	const filtered = {};
+	for (const [field, config] of Object.entries(view.fields)) {
+		if (!(field in item)) continue;
+		const value = item[field];
+		if (isDataViewField(config)) {
+			if (Array.isArray(value)) {
+				filtered[field] = value.map((entry) => isRecord(entry) ? filterToViewFields(entry, config) : entry);
+				continue;
+			}
+			if (isRecord(value)) {
+				filtered[field] = filterToViewFields(value, config);
+				continue;
+			}
+		}
+		filtered[field] = value;
+	}
+	return filtered;
+};
+const mergeObject = (target, source) => {
+	for (const [key, value] of Object.entries(source)) {
+		const existing = target[key];
+		if (isRecord(existing) && isRecord(value)) {
+			mergeObject(existing, value);
+			continue;
+		}
+		target[key] = value;
+	}
+};
+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(existing) && "select" in existing) {
+			const relation$1 = existing;
+			if (!isRecord(relation$1.select)) relation$1.select = {};
+			current = relation$1.select;
+			continue;
+		}
+		const relation = { select: {} };
+		current[segment] = relation;
+		current = relation.select;
+	}
+	return current;
+};
+const createSelectedNode = (view, path) => ({
+	path,
+	relations: /* @__PURE__ */ new Map(),
+	resolvers: /* @__PURE__ */ new Map(),
+	view
+});
+const assignPath = (node, segments, path, 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);
+		return;
+	}
+	if (isDataViewField(field)) {
+		let relationNode = node.relations.get(segment);
+		if (!relationNode) {
+			relationNode = createSelectedNode(field, nextPath);
+			node.relations.set(segment, relationNode);
+		}
+		if (rest.length === 0) {
+			collectViewPaths(nextPath, field, allowedPaths);
+			return;
+		}
+		assignPath(relationNode, rest, nextPath, field, allowedPaths);
+		return;
+	}
+	if (rest.length === 0) allowedPaths.add(nextPath);
+};
+const collectViewPaths = (basePath, view, allowedPaths) => {
+	for (const [field, child] of Object.entries(view.fields)) {
+		const nextPath = `${basePath}.${field}`;
+		if (child === true) {
+			allowedPaths.add(nextPath);
+			continue;
+		}
+		if (isDataViewField(child)) collectViewPaths(nextPath, child, allowedPaths);
+	}
+};
+const collectResolvers = (node, select, args$1, context) => {
+	for (const resolver$1 of node.resolvers.values()) {
+		if (!resolver$1.select) continue;
+		const addition = typeof resolver$1.select === "function" ? resolver$1.select({
+			args: args$1,
+			context
+		}) : resolver$1.select;
+		if (addition && isRecord(addition)) mergeObject(ensureRelationSelect(select, node.path), addition);
+	}
+	for (const relation of node.relations.values()) collectResolvers(relation, select, args$1, context);
+};
+const resolveNode = async (options) => {
+	const { item, node, options: resolverOptions } = options;
+	if (!isRecord(item)) return item;
+	let result = null;
+	const assign = (key, value) => {
+		if (!result) result = { ...item };
+		result[key] = value;
+	};
+	const base = () => result ?? item;
+	for (const [field, resolver$1] of node.resolvers) {
+		const value = await resolver$1.resolve({
+			...resolverOptions,
+			item: base()
+		});
+		if (value !== void 0) assign(field, value);
+	}
+	for (const [field, relationNode] of node.relations) {
+		const current = base()[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;
+		}
+		if (current && typeof current === "object") {
+			const resolved = await resolveNode({
+				item: current,
+				node: relationNode,
+				options: resolverOptions
+			});
+			if (resolved !== current) assign(field, resolved);
+		}
+	}
+	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 root = createSelectedNode(view, null);
+	for (const path of initialSelect) {
+		if (!path) continue;
+		assignPath(root, path.split("."), null, 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
+			}
+		}), root.view),
+		view: root.view
+	});
+	return {
+		resolve,
+		resolveMany: (items) => Promise.all(items.map((item) => resolve(item))),
+		select
+	};
+}
+
+//#endregion
+export { connectionArgs, createResolver, dataView, list, resolver, withConnection };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@nkzw/fate",
+  "version": "0.0.1",
+  "description": "fate is a modern data client for React.",
+  "homepage": "https://github.com/nkzw-tech/fate",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nkzw-tech/fate"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Christoph Nakazawa",
+    "email": "christoph.pojer@gmail.com"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.mts",
+      "development": "./src/index.ts",
+      "default": "./lib/index.mjs"
+    },
+    "./cli": {
+      "types": "./lib/cli.d.mts",
+      "development": "./src/cli.ts",
+      "default": "./lib/cli.mjs"
+    },
+    "./server": {
+      "types": "./lib/server.d.mts",
+      "development": "./src/server.ts",
+      "default": "./lib/server.mjs"
+    }
+  },
+  "main": "./lib/index.mjs",
+  "types": "./lib/index.d.mts",
+  "bin": {
+    "fate": "./lib/cli.mjs"
+  },
+  "files": [
+    "lib"
+  ],
+  "dependencies": {
+    "superjson": "^2.2.6",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@trpc/client": "^11.7.2",
+    "@trpc/server": "^11.7.2"
+  },
+  "peerDependencies": {
+    "@trpc/client": "^11.6.0"
+  },
+  "scripts": {
+    "build": "tsdown -d lib --target=node24 src/index.ts src/server.ts src/cli.ts"
+  }
+}