react-fate 1.1.0 → 1.2.0

package/docs/{guide/server-integration.md → integrations/server.md}

@@ -4,7 +4,7 @@ Until now, we have focused on the client-side API of fate. You'll need a backend
 
 - The native fate protocol, which is transport-agnostic and can be hosted by any Fetch-compatible server.
 - The tRPC adapter, which keeps compatibility with existing tRPC backends.
-- The [GraphQL transport](graphql-integration.md), which maps fate views and roots to an existing GraphQL schema.
+- The [GraphQL transport](graphql.md), which maps fate views and roots to an existing GraphQL schema.
 
 _fate_ currently provides database adapters for Prisma and Drizzle, but the framework itself is not coupled to a particular ORM. The adapters plug into the same source execution runtime and can be exposed through the native protocol or through tRPC.
 
@@ -185,7 +185,9 @@ app.post('/fate/live', handler);
 
 Configure the Vite plugin with the native transport:
 
-```tsx
+::: code-group
+
+```tsx [React]
 import { fate } from 'react-fate/vite';
 import { defineConfig } from 'vite';
 
@@ -199,9 +201,29 @@ export default defineConfig({
 });
 ```
 
+```ts [Vue]
+import vue from '@vitejs/plugin-vue';
+import { fate } from 'vue-fate/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    fate({
+      module: '@your-org/server/fate.ts',
+      transport: 'native',
+    }),
+  ],
+});
+```
+
+:::
+
 With the native transport, the Vite plugin handles the HTTP transport setup. If you need to create a client manually, use `createFateClient` with the same route:
 
-```tsx
+::: code-group
+
+```tsx [React]
 import { createFateClient } from 'react-fate/client';
 
 const client = createFateClient({
@@ -209,6 +231,16 @@ const client = createFateClient({
 });
 ```
 
+```ts [Vue]
+import { createFateClient } from 'vue-fate/client';
+
+const client = createFateClient({
+  url: '/fate',
+});
+```
+
+:::
+
 The HTTP transport batches operations issued in the same microtask into one `POST /fate` request. Live views use one `GET /fate/live` SSE stream per fate client and `POST /fate/live` control messages when views subscribe or unsubscribe.
 
 ### Custom Queries
@@ -585,7 +617,9 @@ export * from './views.ts';
 
 Configure the fate Vite plugin with your server module:
 
-```tsx
+::: code-group
+
+```tsx [React]
 import { fate } from 'react-fate/vite';
 import { defineConfig } from 'vite';
 
@@ -598,11 +632,28 @@ export default defineConfig({
 });
 ```
 
+```ts [Vue]
+import vue from '@vitejs/plugin-vue';
+import { fate } from 'vue-fate/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    fate({
+      module: '@your-org/server/trpc/router.ts',
+    }),
+  ],
+});
+```
+
+:::
+
 _Note: fate uses the specified server module name to find the server types it needs. Make sure that the module is available to the client package's Vite config._
 
 During development, the plugin watches the server module and the files it imports. When one of those files changes, fate updates the internal client wiring and invalidates `@nkzw/fate/client` in Vite's module graph.
 
-For a barebones client without React, import the plugin from `@nkzw/fate/vite` and the client APIs from `@nkzw/fate/client`. The plugin wires the same server types for the selected import path.
+For a barebones client without a framework adapter, import the plugin from `@nkzw/fate/vite` and the client APIs from `@nkzw/fate/client`. The plugin wires the same server types for the selected import path.
 
 The plugin writes project-local types under `.fate/`. If your TypeScript config does not already include dot-directories, extend the generated config:
 
@@ -614,9 +665,11 @@ The plugin writes project-local types under `.fate/`. If your TypeScript config
 
 ## Creating a _fate_ Client
 
-Now that the Vite plugin has connected the types, create a fate client instance and provide it to your React app with the `FateClient` context provider:
+Now that the Vite plugin has connected the types, create a fate client instance and provide it to your app with the `FateClient` provider:
 
-```tsx
+::: code-group
+
+```tsx [React]
 import { httpBatchLink } from '@trpc/client';
 import { FateClient } from 'react-fate';
 import { createFateClient } from 'react-fate/client';
@@ -642,4 +695,37 @@ export function App() {
 }
 ```
 
+```vue [Vue]
+<script setup lang="ts">
+import { httpBatchLink } from '@trpc/client';
+import { computed } from 'vue';
+import { FateClient } from 'vue-fate';
+import { createFateClient } from 'vue-fate/client';
+import AppRoutes from './AppRoutes.vue';
+
+const fate = computed(() =>
+  createFateClient({
+    links: [
+      httpBatchLink({
+        fetch: (input, init) =>
+          fetch(input, {
+            ...init,
+            credentials: 'include',
+          }),
+        url: `${env('SERVER_URL')}/trpc`,
+      }),
+    ],
+  }),
+);
+</script>
+
+<template>
+  <FateClient :client="fate">
+    <AppRoutes />
+  </FateClient>
+</template>
+```
+
+:::
+
 _And you are all set. Happy building!_

package/docs/{guide/void-integration.md → integrations/void.md}

@@ -7,15 +7,25 @@ setup without copying its adapter glue.
 
 ## Install
 
-```sh
-pnpm add @nkzw/fate react-fate void-fate void
+::: code-group
+
+```sh [React]
+pnpm add @nkzw/fate react-fate void-fate void @void/react
+```
+
+```sh [Vue]
+pnpm add @nkzw/fate vue-fate void-fate void @void/vue
 ```
 
+:::
+
 ## Vite
 
-Use the regular `react-fate` Vite plugin with the Void transport:
+Use the framework adapter's Vite plugin with the Void transport:
 
-```tsx
+::: code-group
+
+```tsx [React]
 import { voidReact } from '@void/react/plugin';
 import { fate } from 'react-fate/vite';
 import { defineConfig } from 'vite-plus';
@@ -33,6 +43,26 @@ export default defineConfig({
 });
 ```
 
+```ts [Vue]
+import { voidVue } from '@void/vue/plugin';
+import { fate } from 'vue-fate/vite';
+import { defineConfig } from 'vite-plus';
+import { voidPlugin } from 'void';
+
+export default defineConfig({
+  plugins: [
+    voidPlugin(),
+    voidVue(),
+    fate({
+      module: './src/fate/server.ts',
+      transport: 'void',
+    }),
+  ],
+});
+```
+
+:::
+
 The Void transport uses `/fate` for RPC requests and `/fate-live` for live
 updates by default. In SSR, it calls the exported fate server directly. In the
 browser, it uses fetch and the SSE live endpoint.
@@ -104,12 +134,14 @@ export const { GET, POST } = defineVoidFateLiveRoute(fateServer, fateLive);
 The live route handles `GET /fate-live` SSE connections and `POST /fate-live`
 control messages. `void-fate` does not use WebSockets.
 
-## React Layout
+## Layout
 
-Wrap your app with `VoidFateClient` from `void-fate/react`. It creates and
-provides the fate client through `react-fate`:
+Wrap your app with the Void fate client for your framework. It creates and
+provides the fate client through the matching adapter.
 
-```tsx
+::: code-group
+
+```tsx [React]
 import { useShared } from '@void/react';
 import type { ReactNode } from 'react';
 import { VoidFateClient } from 'void-fate/react';
@@ -128,9 +160,36 @@ export default function Layout({ children }: { children: ReactNode }) {
 }
 ```
 
-`userId` is optional, but passing it lets `VoidFateClient` recreate the client
-when the signed-in user changes. Browser requests include credentials when a
-`userId` is present.
+```vue [Vue]
+<script setup lang="ts">
+import { useShared } from '@void/vue';
+import { computed } from 'vue';
+import { FateClient } from 'vue-fate';
+import { createFateClient } from 'vue-fate/client';
+import type { SharedData } from '../src/lib/shared.ts';
+
+const shared = useShared<SharedData>();
+
+const fate = computed(() =>
+  createFateClient({
+    origin: typeof window === 'undefined' ? shared.origin : window.location.origin,
+    userId: shared.auth.user?.id,
+  }),
+);
+</script>
+
+<template>
+  <FateClient :client="fate">
+    <slot />
+  </FateClient>
+</template>
+```
+
+:::
+
+`userId` is optional, but passing it lets the client be recreated when the
+signed-in user changes. Browser requests include credentials when a `userId` is
+present.
 
 ## Custom Paths
 
@@ -143,12 +202,35 @@ export const fateLive = createVoidFateLive({
 });
 ```
 
-```tsx
+::: code-group
+
+```tsx [React]
 <VoidFateClient livePath="/custom-fate-live" origin={origin} rpcPath="/custom-fate" userId={userId}>
   {children}
 </VoidFateClient>
 ```
 
+```vue [Vue]
+<script setup lang="ts">
+const fate = computed(() =>
+  createFateClient({
+    livePath: '/custom-fate-live',
+    origin,
+    rpcPath: '/custom-fate',
+    userId,
+  }),
+);
+</script>
+
+<template>
+  <FateClient :client="fate">
+    <slot />
+  </FateClient>
+</template>
+```
+
+:::
+
 The route helper does not own the route path. Make sure your Void route filename
 or router configuration matches the paths you pass to the client.
 

package/lib/index.d.mts

@@ -1,4 +1,4 @@
-import { ConnectionRef, FateClient as FateClient$1, FateDehydratedState, FateMutations, FateRoots, GraphQLMutationDefinition, GraphQLMutationInput, GraphQLMutationMap, GraphQLMutationOutput, GraphQLTransportOptions, HydrateOptions, HydrationLimits, InferFateAPI, Pagination, Pagination as Pagination$1, Request, RequestOptions, RequestResult, View, ViewData, ViewEntity, ViewEntityName, ViewRef, ViewRef as ViewRef$1, ViewSelection, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, graphqlMutation, mutation, toEntityId, view } from "@nkzw/fate";
+import { ConnectionRef, Deferred, Deferred as Deferred$1, FateClient as FateClient$1, FateDehydratedState, FateMutations, FateRoots, GraphQLMutationDefinition, GraphQLMutationInput, GraphQLMutationMap, GraphQLMutationOutput, GraphQLTransportOptions, HydrateOptions, HydrationLimits, InferFateAPI, Pagination, Pagination as Pagination$1, Request, RequestOptions, RequestResult, View, ViewData, ViewEntity, ViewEntityName, ViewRef, ViewRef as ViewRef$1, ViewSelection, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, defer, graphqlMutation, mutation, toEntityId, view } from "@nkzw/fate";
 import { ReactNode } from "react";
 
 //#region src/useRequest.d.ts
@@ -43,6 +43,7 @@ type ViewEntityWithTypename$1<V extends View<any, any>> = ViewEntity<V> & {
  * const post = useLiveView(PostView, postRef);
  */
 declare function useLiveView<V extends View<any, any>, R extends ViewRef$1<ViewEntityName<V>> | null>(view: V, ref: R): R extends null ? null : ViewData<ViewEntityWithTypename$1<V>, ViewSelection<V>>;
+declare function useLiveView<V extends View<any, any>, R extends Deferred$1<ViewRef$1<ViewEntityName<V>>> | null>(view: V, ref: R): R extends null ? null : ViewData<ViewEntityWithTypename$1<V>, ViewSelection<V>>;
 //#endregion
 //#region src/listView.d.ts
 type ConnectionItems<C> = C extends {
@@ -56,14 +57,16 @@ type ConnectionSelection = {
 };
 //#endregion
 //#region src/useLiveListView.d.ts
+type ConnectionValue$1 = {
+  items?: ReadonlyArray<any>;
+  pagination?: Pagination$1;
+};
+type ResolvedConnection$1<C> = C extends Deferred$1<infer Value> ? Value : NonNullable<C>;
 /**
  * Subscribes to a connection field, returning live-updating items and pagination
  * helpers to load the next or previous page.
  */
-declare function useLiveListView<C extends {
-  items?: ReadonlyArray<any>;
-  pagination?: Pagination$1;
-} | null | undefined>(selection: ConnectionSelection, connection: C): [ConnectionItems<NonNullable<C>>, LoadMoreFn | null, LoadMoreFn | null];
+declare function useLiveListView<C extends ConnectionValue$1 | Deferred$1<ConnectionValue$1> | null | undefined>(selection: ConnectionSelection, connection: C): [ConnectionItems<ResolvedConnection$1<C>>, LoadMoreFn | null, LoadMoreFn | null];
 //#endregion
 //#region src/useView.d.ts
 type ViewEntityWithTypename<V extends View<any, any>> = ViewEntity<V> & {
@@ -76,15 +79,19 @@ type ViewEntityWithTypename<V extends View<any, any>> = ViewEntity<V> & {
  * const post = useView(PostView, postRef);
  */
 declare function useView<V extends View<any, any>, R extends ViewRef$1<ViewEntityName<V>> | null>(view: V, ref: R): R extends null ? null : ViewData<ViewEntityWithTypename<V>, ViewSelection<V>>;
+declare function useView<V extends View<any, any>, R extends Deferred$1<ViewRef$1<ViewEntityName<V>>> | null>(view: V, ref: R): R extends null ? null : ViewData<ViewEntityWithTypename<V>, ViewSelection<V>>;
+declare function useView<V extends View<any, any>>(view: V, ref: Deferred$1<ViewRef$1<ViewEntityName<V>>> | ViewRef$1<ViewEntityName<V>> | null): ViewData<ViewEntityWithTypename<V>, ViewSelection<V>> | null;
 //#endregion
 //#region src/useListView.d.ts
+type ConnectionValue = {
+  items?: ReadonlyArray<any>;
+  pagination?: Pagination$1;
+};
+type ResolvedConnection<C> = C extends Deferred$1<infer Value> ? Value : NonNullable<C>;
 /**
  * Subscribes to a connection field, returning the current items and pagination
  * helpers to load the next or previous page.
  */
-declare function useListView<C extends {
-  items?: ReadonlyArray<any>;
-  pagination?: Pagination$1;
-} | null | undefined>(selection: ConnectionSelection, connection: C): [ConnectionItems<NonNullable<C>>, LoadMoreFn | null, LoadMoreFn | null];
+declare function useListView<C extends ConnectionValue | Deferred$1<ConnectionValue> | null | undefined>(selection: ConnectionSelection, connection: C): [ConnectionItems<ResolvedConnection<C>>, LoadMoreFn | null, LoadMoreFn | null];
 //#endregion
-export { type ConnectionRef, FateClient, type FateDehydratedState, type GraphQLMutationDefinition, type GraphQLMutationInput, type GraphQLMutationMap, type GraphQLMutationOutput, type GraphQLTransportOptions, type HydrateOptions, type HydrationLimits, type InferFateAPI, type Pagination, type ViewRef, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, graphqlMutation, mutation, toEntityId, useFateClient, useListView, useLiveListView, useLiveView, useRequest, useView, view };
+export { type ConnectionRef, type Deferred, FateClient, type FateDehydratedState, type GraphQLMutationDefinition, type GraphQLMutationInput, type GraphQLMutationMap, type GraphQLMutationOutput, type GraphQLTransportOptions, type HydrateOptions, type HydrationLimits, type InferFateAPI, type Pagination, type ViewRef, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, defer, graphqlMutation, mutation, toEntityId, useFateClient, useListView, useLiveListView, useLiveView, useRequest, useView, view };

package/lib/index.mjs

@@ -1,4 +1,4 @@
-import { ConnectionTag, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, graphqlMutation, isViewTag, mutation, toEntityId, view } from "@nkzw/fate";
+import { ConnectionTag, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, defer, graphqlMutation, isDeferred, isViewTag, mutation, toEntityId, view } from "@nkzw/fate";
 import { createContext, use, useCallback, useDeferredValue, useEffect, useEffectEvent, useMemo, useRef, useSyncExternalStore } from "react";
 import { jsx } from "react/jsx-runtime";
 import { getListEntries } from "@nkzw/fate/list";
@@ -22,6 +22,16 @@ function useFateClient() {
 	return context;
 }
 //#endregion
+//#region src/thenable.ts
+const isFulfilledThenable = (value) => "status" in value && value.status === "fulfilled" && "value" in value;
+const fulfilledThenable = (value) => ({
+	status: "fulfilled",
+	then(onfulfilled, onrejected) {
+		return Promise.resolve(value).then(onfulfilled, onrejected);
+	},
+	value
+});
+//#endregion
 //#region src/useView.tsx
 const nullSnapshot = {
 	status: "fulfilled",
@@ -32,19 +42,99 @@ const nullSnapshot = {
 };
 function useView(view, ref) {
 	const client = useFateClient();
+	const isDeferredRef = isDeferred(ref);
 	const snapshotRef = useRef(null);
+	const mergedSnapshotRef = useRef(null);
+	const pendingRef = useRef(null);
+	const readViewSnapshot = useCallback((viewRef, coverage = [], cacheKey) => {
+		const snapshot = client.readView(view, viewRef);
+		const mergeCoverage = (value) => ({
+			...value,
+			coverage: coverage.length ? [...coverage, ...value.coverage] : value.coverage
+		});
+		if (isFulfilledThenable(snapshot)) {
+			if (coverage.length) {
+				const cached = mergedSnapshotRef.current;
+				const resolvedKey = `${viewRef.__typename}:${String(viewRef.id)}`;
+				if (cached?.source === snapshot.value && cached.cacheKey === cacheKey && cached.resolvedKey === resolvedKey) {
+					snapshotRef.current = cached.thenable.value;
+					return cached.thenable;
+				}
+				const value = mergeCoverage(snapshot.value);
+				const thenable = fulfilledThenable(value);
+				mergedSnapshotRef.current = {
+					cacheKey,
+					resolvedKey,
+					source: snapshot.value,
+					thenable
+				};
+				snapshotRef.current = value;
+				return thenable;
+			}
+			mergedSnapshotRef.current = null;
+			snapshotRef.current = snapshot.value;
+			return snapshot;
+		}
+		mergedSnapshotRef.current = null;
+		snapshotRef.current = null;
+		return Promise.resolve(snapshot).then((value) => {
+			const resolved = mergeCoverage(value);
+			snapshotRef.current = resolved;
+			return resolved;
+		});
+	}, [client, view]);
 	const getSnapshot = useCallback(() => {
 		if (ref === null) {
 			snapshotRef.current = null;
 			return nullSnapshot;
 		}
-		const snapshot = client.readView(view, ref);
-		snapshotRef.current = snapshot.status === "fulfilled" ? snapshot.value : null;
-		return snapshot;
+		if (!isDeferredRef) {
+			pendingRef.current = null;
+			return readViewSnapshot(ref);
+		}
+		const deferred = ref;
+		const deferredSnapshot = client.readDeferred(deferred);
+		if (isFulfilledThenable(deferredSnapshot)) {
+			const resolvedRef = deferredSnapshot.value.data;
+			pendingRef.current = null;
+			if (resolvedRef === null) {
+				snapshotRef.current = {
+					coverage: deferredSnapshot.value.coverage,
+					data: null
+				};
+				return fulfilledThenable(snapshotRef.current);
+			}
+			return readViewSnapshot(client.ref(resolvedRef.__typename, resolvedRef.id, view), deferredSnapshot.value.coverage, deferred);
+		}
+		if (pendingRef.current?.deferred === ref && pendingRef.current.snapshot === deferredSnapshot) return pendingRef.current.viewSnapshot;
+		snapshotRef.current = null;
+		const viewSnapshot = Promise.resolve(deferredSnapshot).then((deferredValue) => {
+			const resolvedRef = deferredValue.data;
+			if (resolvedRef === null) {
+				const value = {
+					coverage: deferredValue.coverage,
+					data: null
+				};
+				snapshotRef.current = value;
+				return value;
+			}
+			return Promise.resolve(readViewSnapshot(client.ref(resolvedRef.__typename, resolvedRef.id, view), deferredValue.coverage, deferred)).then((value) => {
+				snapshotRef.current = value;
+				return value;
+			});
+		});
+		pendingRef.current = {
+			deferred,
+			snapshot: deferredSnapshot,
+			viewSnapshot
+		};
+		return viewSnapshot;
 	}, [
 		client,
 		view,
-		ref
+		ref,
+		isDeferredRef,
+		readViewSnapshot
 	]);
 	const snapshot = use(useDeferredValue(useSyncExternalStore(useCallback((onStoreChange) => {
 		if (ref === null) {
@@ -83,12 +173,14 @@ function useView(view, ref) {
 //#region src/useLiveView.tsx
 function useLiveView(view, ref) {
 	const client = useFateClient();
-	const liveId = ref?.id;
-	const liveType = ref?.__typename;
+	const resolvedRef = isDeferred(ref) ? use(client.readDeferred(ref)).data : ref;
+	const liveRef = resolvedRef ? client.ref(resolvedRef.__typename, resolvedRef.id, view) : null;
+	const liveId = liveRef?.id;
+	const liveType = liveRef?.__typename;
 	const subscribeLiveView = useEffectEvent(() => {
-		if (ref === null) return;
+		if (liveRef === null) return;
 		client.assertLiveViewSupport();
-		return client.subscribeLiveView(view, ref);
+		return client.subscribeLiveView(view, liveRef);
 	});
 	useEffect(() => subscribeLiveView(), [
 		client,
@@ -120,11 +212,12 @@ const useListViewInfo = (selection, connection) => ({
 */
 function useListView(selection, connection) {
 	const client = useFateClient();
-	const { metadata, nodeView } = useListViewInfo(selection, connection);
+	const resolvedConnection = isDeferred(connection) ? use(client.readDeferred(connection)).data : connection;
+	const { metadata, nodeView } = useListViewInfo(selection, resolvedConnection);
 	const subscribe = useCallback((onStoreChange) => metadata ? client.store.subscribeList(metadata.key, onStoreChange) : () => {}, [client, metadata]);
 	const getSnapshot = useCallback(() => metadata ? client.store.getListState(metadata.key) : void 0, [client, metadata]);
 	const listState = useDeferredValue(useSyncExternalStore(subscribe, getSnapshot, getSnapshot));
-	const pagination = listState?.pagination ?? connection?.pagination;
+	const pagination = listState?.pagination ?? resolvedConnection?.pagination;
 	const hasNext = Boolean(pagination?.hasNext);
 	const hasPrevious = Boolean(pagination?.hasPrevious);
 	const nextCursor = pagination?.nextCursor;
@@ -135,10 +228,10 @@ function useListView(selection, connection) {
 				cursor,
 				node: client.rootListRef(id, nodeView)
 			}));
-			return connection?.items;
+			return resolvedConnection?.items;
 		}, [
 			client,
-			connection?.items,
+			resolvedConnection?.items,
 			listState,
 			metadata,
 			nodeView
@@ -193,7 +286,8 @@ function useListView(selection, connection) {
 */
 function useLiveListView(selection, connection) {
 	const client = useFateClient();
-	const { metadata, nodeView } = useListViewInfo(selection, connection);
+	const resolvedConnection = isDeferred(connection) ? use(client.readDeferred(connection)).data : connection;
+	const { metadata, nodeView } = useListViewInfo(selection, resolvedConnection);
 	const subscribeLiveListView = useEffectEvent(() => {
 		if (!metadata) return;
 		client.assertLiveConnectionSupport();
@@ -204,7 +298,7 @@ function useLiveListView(selection, connection) {
 		metadata?.key,
 		nodeView
 	]);
-	return useListView(selection, connection);
+	return useListView(selection, resolvedConnection);
 }
 //#endregion
 //#region src/useRequest.tsx
@@ -233,4 +327,4 @@ function useRequest(request, options) {
 	return use(useDeferredValue(promise));
 }
 //#endregion
-export { FateClient, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, graphqlMutation, mutation, toEntityId, useFateClient, useListView, useLiveListView, useLiveView, useRequest, useView, view };
+export { FateClient, clientRoot, createClient, createGraphQLTransport, createHTTPTransport, createTRPCTransport, defer, graphqlMutation, mutation, toEntityId, useFateClient, useListView, useLiveListView, useLiveView, useRequest, useView, view };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-fate",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "fate is a modern data client for React.",
   "homepage": "https://github.com/nkzw-tech/fate",
   "license": "MIT",
@@ -40,7 +40,7 @@
     }
   },
   "dependencies": {
-    "@nkzw/fate": "^1.1.0"
+    "@nkzw/fate": "^1.2.0"
   },
   "devDependencies": {
     "@types/react": "^19.2.16",