@replanejs/react 0.9.0 → 0.9.2

package/README.md

@@ -29,7 +29,7 @@ import { ReplaneProvider, useConfig } from "@replanejs/react";
 function App() {
   return (
     <ReplaneProvider
-      options={{
+      connection={{
         baseUrl: "https://your-replane-server.com",
         sdkKey: "your-sdk-key",
       }}
@@ -51,9 +51,9 @@ function MyComponent() {
 
 ### ReplaneProvider
 
-Provider component that makes the Replane client available to your component tree. Supports four usage patterns:
+Provider component that makes the Replane client available to your component tree. Supports multiple usage patterns:
 
-#### 1. With options (recommended)
+#### 1. With connection (recommended)
 
 The provider creates and manages the client internally. Use an Error Boundary to handle initialization errors:
 
@@ -62,7 +62,7 @@ import { ErrorBoundary } from "react-error-boundary";
 
 <ErrorBoundary fallback={<div>Failed to load configuration</div>}>
   <ReplaneProvider
-    options={{
+    connection={{
       baseUrl: "https://your-replane-server.com",
       sdkKey: "your-sdk-key",
     }}
@@ -73,22 +73,32 @@ import { ErrorBoundary } from "react-error-boundary";
 </ErrorBoundary>;
 ```
 
-#### Client Options
+#### Provider Props
 
-The `options` prop accepts the following options:
+| Prop         | Type                        | Required | Description                                             |
+| ------------ | --------------------------- | -------- | ------------------------------------------------------- |
+| `connection` | `ConnectOptions \| null`    | Yes      | Connection options (see below), or `null` to skip connection |
+| `defaults`   | `Record<string, unknown>`   | No       | Default values if server is unavailable                 |
+| `context`    | `Record<string, unknown>`   | No       | Default context for override evaluations                |
+| `snapshot`   | `ReplaneSnapshot`           | No       | Snapshot for SSR hydration                              |
+| `logger`     | `ReplaneLogger`             | No       | Custom logger (default: console)                        |
+| `loader`     | `ReactNode`                 | No       | Component to show while loading                         |
+| `suspense`   | `boolean`                   | No       | Use React Suspense for loading state                    |
+| `async`      | `boolean`                   | No       | Connect asynchronously (renders immediately with defaults) |
+
+#### Connection Options
+
+The `connection` prop accepts the following options:
 
 | Option               | Type                  | Required | Description                                  |
 | -------------------- | --------------------- | -------- | -------------------------------------------- |
 | `baseUrl`            | `string`              | Yes      | Replane server URL                           |
 | `sdkKey`             | `string`              | Yes      | SDK key for authentication                   |
-| `context`            | `Record<string, any>` | No       | Default context for override evaluations     |
-| `defaults`           | `Record<string, any>` | No       | Default values if server is unavailable      |
 | `connectTimeoutMs`   | `number`              | No       | SDK connection timeout (default: 5000)       |
 | `requestTimeoutMs`   | `number`              | No       | Timeout for SSE requests (default: 2000)     |
 | `retryDelayMs`       | `number`              | No       | Base delay between retries (default: 200)    |
 | `inactivityTimeoutMs`| `number`              | No       | SSE inactivity timeout (default: 30000)      |
 | `fetchFn`            | `typeof fetch`        | No       | Custom fetch implementation                  |
-| `logger`             | `ReplaneLogger`       | No       | Custom logger (default: console)             |
 
 See [`@replanejs/sdk` documentation](https://github.com/replane-dev/replane-javascript/tree/main/packages/sdk#api) for more details.
 
@@ -118,7 +128,7 @@ Integrates with React Suspense for loading states:
 <ErrorBoundary fallback={<div>Failed to load configuration</div>}>
   <Suspense fallback={<LoadingSpinner />}>
     <ReplaneProvider
-      options={{
+      connection={{
         baseUrl: "https://your-replane-server.com",
         sdkKey: "your-sdk-key",
       }}
@@ -130,7 +140,24 @@ Integrates with React Suspense for loading states:
 </ErrorBoundary>
 ```
 
-#### 4. With snapshot (for SSR/hydration)
+#### 4. With async mode
+
+Connect in the background while rendering immediately with defaults:
+
+```tsx
+<ReplaneProvider
+  connection={{
+    baseUrl: "https://your-replane-server.com",
+    sdkKey: "your-sdk-key",
+  }}
+  defaults={{ featureEnabled: false }}
+  async
+>
+  <App />
+</ReplaneProvider>
+```
+
+#### 5. With snapshot (for SSR/hydration)
 
 Restore a client from a snapshot obtained on the server. This is synchronous and useful for SSR scenarios:
 
@@ -143,7 +170,7 @@ const snapshot = serverClient.getSnapshot();
 
 // On the client
 <ReplaneProvider
-  options={{
+  connection={{
     baseUrl: "https://your-replane-server.com",
     sdkKey: "your-sdk-key",
   }}
@@ -353,7 +380,7 @@ class ErrorBoundary extends Component<
 
 // Usage
 <ErrorBoundary fallback={<div>Configuration failed to load</div>}>
-  <ReplaneProvider options={options} loader={<Loading />}>
+  <ReplaneProvider connection={connection} loader={<Loading />}>
     <App />
   </ReplaneProvider>
 </ErrorBoundary>;
@@ -373,7 +400,7 @@ import { ErrorBoundary } from "react-error-boundary";
   )}
   onReset={() => clearSuspenseCache()}
 >
-  <ReplaneProvider options={options} loader={<Loading />}>
+  <ReplaneProvider connection={connection} loader={<Loading />}>
     <App />
   </ReplaneProvider>
 </ErrorBoundary>;

package/dist/index.cjs

@@ -31,11 +31,6 @@ const react_jsx_runtime = __toESM(require("react/jsx-runtime"));
 //#region src/context.ts
 const ReplaneContext = (0, react.createContext)(null);
 
-//#endregion
-//#region src/version.ts
-const VERSION = "0.9.0";
-const DEFAULT_AGENT = `replane-js-react/${VERSION}`;
-
 //#endregion
 //#region src/useReplaneClient.ts
 const suspenseCache = new Map();
@@ -45,29 +40,21 @@ function getCacheKey(options) {
 /**
 * Creates a Replane client and connects it.
 */
-async function createAndConnectClient(options) {
+async function createAndConnectClient(options, connection) {
 	const client = new __replanejs_sdk.Replane({
 		logger: options.logger,
 		context: options.context,
 		defaults: options.defaults
 	});
-	await client.connect({
-		baseUrl: options.baseUrl,
-		sdkKey: options.sdkKey,
-		connectTimeoutMs: options.connectTimeoutMs,
-		retryDelayMs: options.retryDelayMs,
-		requestTimeoutMs: options.requestTimeoutMs,
-		inactivityTimeoutMs: options.inactivityTimeoutMs,
-		fetchFn: options.fetchFn,
-		agent: options.agent ?? DEFAULT_AGENT
-	});
+	if (!connection) return client;
+	await client.connect(connection);
 	return client;
 }
 /**
 * Hook to manage Replane client creation internally.
 * Handles loading state and cleanup.
 */
-function useReplaneClientInternal(options) {
+function useReplaneClientInternal(options, originalConnection) {
 	const [state, setState] = (0, react.useState)({
 		status: "loading",
 		client: null,
@@ -75,11 +62,13 @@ function useReplaneClientInternal(options) {
 	});
 	const clientRef = (0, react.useRef)(null);
 	const optionsRef = (0, react.useRef)(options);
+	const connectionJson = JSON.stringify(originalConnection);
 	(0, react.useEffect)(() => {
+		const connection = JSON.parse(connectionJson);
 		let cancelled = false;
 		async function initClient() {
 			try {
-				const client = await createAndConnectClient(optionsRef.current);
+				const client = await createAndConnectClient(optionsRef.current, connection);
 				if (cancelled) {
 					client.disconnect();
 					return;
@@ -108,22 +97,22 @@ function useReplaneClientInternal(options) {
 				clientRef.current = null;
 			}
 		};
-	}, []);
+	}, [connectionJson]);
 	return state;
 }
 /**
 * Hook for Suspense-based client creation.
 * Throws a promise while loading, throws error on failure.
 */
-function useReplaneClientSuspense(options) {
-	const cacheKey = getCacheKey(options);
+function useReplaneClientSuspense(options, connection) {
+	const cacheKey = getCacheKey(connection);
 	const cached = suspenseCache.get(cacheKey);
 	if (cached) {
 		if (cached.error) throw cached.error;
 		if (cached.result) return cached.result;
 		throw cached.promise;
 	}
-	const promise = createAndConnectClient(options).then((client) => {
+	const promise = createAndConnectClient(options, connection).then((client) => {
 		const entry = suspenseCache.get(cacheKey);
 		if (entry) entry.result = client;
 		return client;
@@ -136,11 +125,11 @@ function useReplaneClientSuspense(options) {
 	throw promise;
 }
 /**
-* Clear the suspense cache for a specific options configuration.
+* Clear the suspense cache for a specific connection configuration.
 * Useful for testing or when you need to force re-initialization.
 */
-function clearSuspenseCache(options) {
-	if (options) suspenseCache.delete(getCacheKey(options));
+function clearSuspenseCache(connection) {
+	if (connection) suspenseCache.delete(getCacheKey(connection));
 	else suspenseCache.clear();
 }
 
@@ -150,9 +139,14 @@ function clearSuspenseCache(options) {
 * Type guard to check if props contain a pre-created client.
 */
 function hasClient(props) {
-	return "client" in props && props.client !== void 0;
+	return "client" in props && !!props.client;
 }
 
+//#endregion
+//#region src/version.ts
+const VERSION = "0.9.2";
+const DEFAULT_AGENT = `replane-js-react/${VERSION}`;
+
 //#endregion
 //#region src/provider.tsx
 /**
@@ -166,44 +160,23 @@ function ReplaneProviderWithClient({ client, children }) {
 	});
 }
 /**
-* Internal provider component for restoring client from snapshot.
+* Internal provider component for creating a Replane client asynchronously.
 * Creates a Replane client synchronously and connects in background.
 */
-function ReplaneProviderWithSnapshot({ options, snapshot, children }) {
+function AsyncReplaneProvider({ children, connection,...options }) {
 	const replaneRef = (0, react.useRef)(void 0);
-	if (!replaneRef.current) replaneRef.current = new __replanejs_sdk.Replane({
-		snapshot,
-		logger: options.logger,
-		context: options.context,
-		defaults: options.defaults
-	});
+	if (!replaneRef.current) replaneRef.current = new __replanejs_sdk.Replane(options);
+	const connectionJson = connection ? JSON.stringify(connection) : void 0;
 	(0, react.useEffect)(() => {
-		replaneRef.current.connect({
-			baseUrl: options.baseUrl,
-			sdkKey: options.sdkKey,
-			connectTimeoutMs: options.connectTimeoutMs,
-			retryDelayMs: options.retryDelayMs,
-			requestTimeoutMs: options.requestTimeoutMs,
-			inactivityTimeoutMs: options.inactivityTimeoutMs,
-			fetchFn: options.fetchFn,
-			agent: options.agent ?? DEFAULT_AGENT
-		}).catch((err) => {
+		const parsedConnection = connectionJson ? JSON.parse(connectionJson) : void 0;
+		if (!parsedConnection) return;
+		replaneRef.current.connect(parsedConnection).catch((err) => {
 			(options.logger ?? console)?.error("Failed to connect Replane client", err);
 		});
 		return () => {
 			replaneRef.current.disconnect();
 		};
-	}, [
-		options.agent,
-		options.baseUrl,
-		options.connectTimeoutMs,
-		options.fetchFn,
-		options.inactivityTimeoutMs,
-		options.logger,
-		options.requestTimeoutMs,
-		options.retryDelayMs,
-		options.sdkKey
-	]);
+	}, [connectionJson, options.logger]);
 	const value = (0, react.useMemo)(() => ({ replane: replaneRef.current }), []);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneContext.Provider, {
 		value,
@@ -214,8 +187,9 @@ function ReplaneProviderWithSnapshot({ options, snapshot, children }) {
 * Internal provider component for options-based client creation (non-suspense).
 * Throws errors during rendering so they can be caught by Error Boundaries.
 */
-function ReplaneProviderWithOptions({ options, children, loader }) {
-	const state = useReplaneClientInternal(options);
+function LoaderReplaneProvider({ children, loader, connection,...options }) {
+	if (!connection) throw new Error("Connection is required when using Loader");
+	const state = useReplaneClientInternal(options, connection);
 	if (state.status === "loading") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: loader ?? null });
 	if (state.status === "error") throw state.error;
 	const value = { replane: state.client };
@@ -227,8 +201,9 @@ function ReplaneProviderWithOptions({ options, children, loader }) {
 /**
 * Internal provider component for options-based client creation with Suspense.
 */
-function ReplaneProviderWithSuspense({ options, children }) {
-	const client = useReplaneClientSuspense(options);
+function SuspenseReplaneProvider({ connection, children,...options }) {
+	if (!connection) throw new Error("Connection is required when using Suspense");
+	const client = useReplaneClientSuspense(options, connection);
 	const value = (0, react.useMemo)(() => ({ replane: client }), [client]);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneContext.Provider, {
 		value,
@@ -293,13 +268,21 @@ function ReplaneProviderWithSuspense({ options, children }) {
 * allowing them to be caught by React Error Boundaries.
 */
 function ReplaneProvider(props) {
+	const originalConnection = props.connection;
+	const connection = (0, react.useMemo)(() => originalConnection ? {
+		...originalConnection,
+		agent: originalConnection.agent ?? DEFAULT_AGENT
+	} : void 0, [originalConnection]);
 	if (hasClient(props)) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneProviderWithClient, { ...props });
-	if (props.snapshot) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneProviderWithSnapshot, {
+	if (props.snapshot || !connection || props.async) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AsyncReplaneProvider, { ...props });
+	if (props.suspense) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SuspenseReplaneProvider, {
+		...props,
+		connection
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LoaderReplaneProvider, {
 		...props,
-		snapshot: props.snapshot
+		connection
 	});
-	if (props.suspense) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneProviderWithSuspense, { ...props });
-	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReplaneProviderWithOptions, { ...props });
 }
 
 //#endregion

package/dist/index.d.cts

@@ -1,66 +1,9 @@
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import { ConnectOptions, GetConfigOptions, GetConfigOptions as GetConfigOptions$1, GetReplaneSnapshotOptions, Replane, Replane as Replane$1, ReplaneContext, ReplaneContext as ReplaneContext$1, ReplaneError, ReplaneErrorCode, ReplaneLogger, ReplaneLogger as ReplaneLogger$1, ReplaneOptions, ReplaneSnapshot, ReplaneSnapshot as ReplaneSnapshot$1, getReplaneSnapshot } from "@replanejs/sdk";
+import { ConnectOptions, ConnectOptions as ConnectOptions$1, GetConfigOptions, GetConfigOptions as GetConfigOptions$1, GetReplaneSnapshotOptions, Replane, Replane as Replane$1, ReplaneContext, ReplaneError, ReplaneErrorCode, ReplaneLogger, ReplaneOptions, ReplaneOptions as ReplaneOptions$1, ReplaneSnapshot, getReplaneSnapshot } from "@replanejs/sdk";
 import { ReactNode } from "react";
 
 //#region src/types.d.ts
 type UntypedReplaneConfig = Record<string, unknown>;
-/**
- * Combined options for ReplaneProvider.
- * Includes both constructor options (context, logger, defaults) and connection options.
- */
-interface ReplaneProviderOptions<T extends object = UntypedReplaneConfig> {
-  /**
-   * Base URL of the Replane instance (no trailing slash).
-   * @example "https://app.replane.dev"
-   */
-  baseUrl: string;
-  /**
-   * Project SDK key for authorization.
-   * @example "rp_XXXXXXXXX"
-   */
-  sdkKey: string;
-  /**
-   * Default context for all config evaluations.
-   * Can be overridden per-request in `client.get()`.
-   */
-  context?: ReplaneContext$1;
-  /**
-   * Optional logger (defaults to console).
-   */
-  logger?: ReplaneLogger$1;
-  /**
-   * Default values to use before connection is established.
-   */
-  defaults?: { [K in keyof T]?: T[K] };
-  /**
-   * Optional timeout in ms for the initial connection.
-   * @default 5000
-   */
-  connectTimeoutMs?: number;
-  /**
-   * Delay between retries in ms.
-   * @default 200
-   */
-  retryDelayMs?: number;
-  /**
-   * Optional timeout in ms for individual requests.
-   * @default 2000
-   */
-  requestTimeoutMs?: number;
-  /**
-   * Timeout in ms for SSE connection inactivity.
-   * @default 30000
-   */
-  inactivityTimeoutMs?: number;
-  /**
-   * Custom fetch implementation (useful for tests / polyfills).
-   */
-  fetchFn?: typeof fetch;
-  /**
-   * Agent identifier sent in User-Agent header.
-   */
-  agent?: string;
-}
 /**
  * Props for ReplaneProvider when using a pre-created client.
  */
@@ -72,17 +15,13 @@ interface ReplaneProviderWithClientProps<T extends object = UntypedReplaneConfig
 /**
  * Props for ReplaneProvider when letting it manage the client internally.
  */
-interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> {
-  /** Options to create or restore the Replane client */
-  options: ReplaneProviderOptions<T>;
+interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> extends ReplaneOptions$1<T> {
   children: ReactNode;
   /**
-   * Optional snapshot from server-side rendering.
-   * When provided, the client will be restored from the snapshot synchronously
-   * instead of fetching configs from the server.
-   * The `options` will be used for live updates connection if provided.
+   * Connection options for connecting to the Replane server.
+   * Pass null to explicitly skip connection (client will use defaults/snapshot only).
    */
-  snapshot?: ReplaneSnapshot$1<T>;
+  connection: ConnectOptions$1 | null;
   /**
    * Optional loading component to show while the client is initializing.
    * If not provided and suspense is false/undefined, children will not render until ready.
@@ -96,11 +35,17 @@ interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfi
    * @default false
    */
   suspense?: boolean;
+  /**
+   * If true, the client will be connected asynchronously. Make sure to provide defaults or snapshot.
+   * @default false
+   */
+  async?: boolean;
 }
 type ReplaneProviderProps<T extends object = UntypedReplaneConfig> = ReplaneProviderWithClientProps<T> | ReplaneProviderWithOptionsProps<T>;
 /**
  * Type guard to check if props contain a pre-created client.
  */
+
 //#endregion
 //#region src/provider.d.ts
 /**
@@ -208,10 +153,10 @@ declare function createConfigHook<TConfigs extends object>(): <K extends keyof T
 //#endregion
 //#region src/useReplaneClient.d.ts
 /**
- * Clear the suspense cache for a specific options configuration.
+ * Clear the suspense cache for a specific connection configuration.
  * Useful for testing or when you need to force re-initialization.
  */
-declare function clearSuspenseCache<T extends object>(options?: ReplaneProviderOptions<T>): void;
+declare function clearSuspenseCache(connection?: ConnectOptions$1): void;
 //#endregion
-export { type ConnectOptions, type GetConfigOptions, type GetReplaneSnapshotOptions, Replane, type ReplaneContext, ReplaneError, ReplaneErrorCode, type ReplaneLogger, type ReplaneOptions, ReplaneProvider, type ReplaneProviderOptions, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, type ReplaneSnapshot, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
+export { type ConnectOptions, type GetConfigOptions, type GetReplaneSnapshotOptions, Replane, type ReplaneContext, ReplaneError, ReplaneErrorCode, type ReplaneLogger, type ReplaneOptions, ReplaneProvider, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, type ReplaneSnapshot, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/provider.tsx","../src/hooks.ts","../src/useReplaneClient.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,oBAAA,GAAuB;AAUnC;;;;AAmBW,UAnBM,sBAmBN,CAAA,UAAA,MAAA,GAnBgD,oBAmBhD,CAAA,CAAA;EAAa;;;;EA4BA,OAAA,EAAA,MAAA;EAUP;;;;EAEE,MAAT,EAAA,MAAA;EAAO;AACI;AAMrB;;EAAgD,OAAoB,CAAA,EAnDxD,gBAmDwD;EAAoB;;;EAGnE,MAOQ,CAAA,EAzDlB,eAyDkB;EAAC;;AAMV;EAUR,QAAA,CAAA,EAAA,QAAoB,MArEL,CAqEK,IArEA,CAqEA,CArEE,CAqEF,CAAA,EAAA;EAAwC;;;;EAErC,gBAAA,CAAA,EAAA,MAAA;;;;ACqEnC;EAA+B,YAAA,CAAA,EAAA,MAAA;EAAA;;;AAAiD;;;;ACzKhF;;EAA0B,mBAAoB,CAAA,EAAA,MAAA;EAAoB;;AAAY;EAQ9D,OAAA,CAAA,EAAA,OF6CG,KE7CM;EAAA;;;EAA4C,KAAM,CAAA,EAAA,MAAA;AAAC;AAqC5E;;;AACqC,UFiBpB,8BEjBoB,CAAA,UAAA,MAAA,GFiB8B,oBEjB9B,CAAA,CAAA;EAAO;EAuB5B,MAAA,EFJN,SEIM,CFJE,CEIF,CAAA;EAAgB,QAAA,EFHpB,SEGoB;;;;;AAGlB,UFAG,+BEAH,CAAA,UAAA,MAAA,GFAsD,oBEAtD,CAAA,CAAA;EAAgB;EACjB,OAAC,EFCH,sBEDG,CFCoB,CEDpB,CAAA;EAAC,QAAA,EFEH,SEFG;;;;ACyEf;;;EAAuF,QAAxB,CAAA,EHhElD,iBGgEkD,CHhElC,CGgEkC,CAAA;EAAsB;;;;;WH1D1E;;;;;;;;;KAUC,wCAAwC,wBAChD,+BAA+B,KAC/B,gCAAgC;;;;;;;;;;AAxGpC;AAUA;;;;;;;;;AA+CwB;AAUxB;;;;;;AAGqB;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;;;;ACqEnC;;;;;AAAgF;;;;ACzKhF;;;;;AAA8E,iBDyK9D,eCzK8D,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EDyKrB,oBCzKqB,CDyKA,CCzKA,CAAA,CAAA,EDyKE,kBAAA,CAAA,GAAA,CAAA,OCzKF;AAQ9E;;;iBARgB,8BAA8B,yBAAyB,UAAQ;iBAQ/D,qCAAqC,mBAAiB,KAAK;;AFZ3E;AAUA;;;;;;;;;AA+CwB;AAUxB;;;;;;AAGqB,iBErBL,iBFqBK,CAAA,iBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,GAAA,GEpBgB,SFoBhB,CEpBwB,QFoBxB,CAAA;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;iBE/BnB,8DACiC,gBACvC,aACI,mBAAiB,SAAS,QACnC,SAAS;;;;;;;;AFSe,iBGgEb,kBHhEa,CAAA,UAAA,MAAA,CAAA,CAAA,OAAA,CAAA,EGgEkC,sBHhElC,CGgEyD,CHhEzD,CAAA,CAAA,EAAA,IAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/provider.tsx","../src/hooks.ts","../src/useReplaneClient.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,oBAAA,GAAuB;AASnC;;;AAEkB,UAFD,8BAEC,CAAA,UAAA,MAAA,GAFiD,oBAEjD,CAAA,CAAA;EAAC;EAAF,MACL,EADF,SACE,CADM,CACN,CAAA;EAAS,QAAA,EAAT,SAAS;AAMrB;;;;AAGY,UAHK,+BAGL,CAAA,UAAA,MAAA,GAFS,oBAET,CAAA,SADF,gBACE,CADa,CACb,CAAA,CAAA;EAAS,QAKP,EALF,SAKE;EAAc;;AANJ;AA2BxB;EAAgC,UAAA,EArBlB,gBAqBkB,GAAA,IAAA;EAAA;;;;;EAEG,MAAA,CAAA,EAjBxB,SAiBwB;;;;AC+GnC;;;EAA+E,QAAtB,CAAA,EAAA,OAAA;EAAoB;AAAG;;;;AC5JhF;AAA0B,KF2Cd,oBE3Cc,CAAA,UAAA,MAAA,GF2C0B,oBE3C1B,CAAA,GF4CtB,8BE5CsB,CF4CS,CE5CT,CAAA,GF6CtB,+BE7CsB,CF6CU,CE7CV,CAAA;;;;;;;;;;;AFJ1B;AASA;;;;;;AAGqB;AAMrB;;;;;;;;AAEwB;AA2BxB;;;;;;;AAEmC;;;;AC+GnC;;;;;AAAgF;;;;AC5JhF;;;;;AAA8E;AAQ9E;;;;;AAA4E;AAqC5E;;;;AAC4C,iBD8G5B,eC9G4B,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,ED8Ga,oBC9Gb,CD8GkC,CC9GlC,CAAA,CAAA,ED8GoC,kBAAA,CAAA,GAAA,CAAA,OC9GpC;AAuB5C;;;iBArEgB,8BAA8B,yBAAyB,UAAQ;iBAQ/D,qCAAqC,mBAAiB,KAAK;;AFZ3E;AASA;;;;;;AAGqB;AAMrB;;;;;;;;AAEwB;AA2BZ,iBEEI,iBFFgB,CAAA,iBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,GAAA,GEGK,SFHL,CEGa,QFHb,CAAA;;;;;;;AAEG;;;;AC+GnC;;;;;AAAgF;;;iBCvFhE,8DACiC,gBACvC,aACI,mBAAiB,SAAS,QACnC,SAAS;AAzEd;;;;;;;AF6CI,iBGmGY,kBAAA,CHnGZ,UAAA,CAAA,EGmG4C,gBHnG5C,CAAA,EAAA,IAAA"}

package/dist/index.d.ts

@@ -1,66 +1,9 @@
 import { ReactNode } from "react";
-import { ConnectOptions, GetConfigOptions, GetConfigOptions as GetConfigOptions$1, GetReplaneSnapshotOptions, Replane, Replane as Replane$1, ReplaneContext, ReplaneContext as ReplaneContext$1, ReplaneError, ReplaneErrorCode, ReplaneLogger, ReplaneLogger as ReplaneLogger$1, ReplaneOptions, ReplaneSnapshot, ReplaneSnapshot as ReplaneSnapshot$1, getReplaneSnapshot } from "@replanejs/sdk";
+import { ConnectOptions, ConnectOptions as ConnectOptions$1, GetConfigOptions, GetConfigOptions as GetConfigOptions$1, GetReplaneSnapshotOptions, Replane, Replane as Replane$1, ReplaneContext, ReplaneError, ReplaneErrorCode, ReplaneLogger, ReplaneOptions, ReplaneOptions as ReplaneOptions$1, ReplaneSnapshot, getReplaneSnapshot } from "@replanejs/sdk";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
 
 //#region src/types.d.ts
 type UntypedReplaneConfig = Record<string, unknown>;
-/**
- * Combined options for ReplaneProvider.
- * Includes both constructor options (context, logger, defaults) and connection options.
- */
-interface ReplaneProviderOptions<T extends object = UntypedReplaneConfig> {
-  /**
-   * Base URL of the Replane instance (no trailing slash).
-   * @example "https://app.replane.dev"
-   */
-  baseUrl: string;
-  /**
-   * Project SDK key for authorization.
-   * @example "rp_XXXXXXXXX"
-   */
-  sdkKey: string;
-  /**
-   * Default context for all config evaluations.
-   * Can be overridden per-request in `client.get()`.
-   */
-  context?: ReplaneContext$1;
-  /**
-   * Optional logger (defaults to console).
-   */
-  logger?: ReplaneLogger$1;
-  /**
-   * Default values to use before connection is established.
-   */
-  defaults?: { [K in keyof T]?: T[K] };
-  /**
-   * Optional timeout in ms for the initial connection.
-   * @default 5000
-   */
-  connectTimeoutMs?: number;
-  /**
-   * Delay between retries in ms.
-   * @default 200
-   */
-  retryDelayMs?: number;
-  /**
-   * Optional timeout in ms for individual requests.
-   * @default 2000
-   */
-  requestTimeoutMs?: number;
-  /**
-   * Timeout in ms for SSE connection inactivity.
-   * @default 30000
-   */
-  inactivityTimeoutMs?: number;
-  /**
-   * Custom fetch implementation (useful for tests / polyfills).
-   */
-  fetchFn?: typeof fetch;
-  /**
-   * Agent identifier sent in User-Agent header.
-   */
-  agent?: string;
-}
 /**
  * Props for ReplaneProvider when using a pre-created client.
  */
@@ -72,17 +15,13 @@ interface ReplaneProviderWithClientProps<T extends object = UntypedReplaneConfig
 /**
  * Props for ReplaneProvider when letting it manage the client internally.
  */
-interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> {
-  /** Options to create or restore the Replane client */
-  options: ReplaneProviderOptions<T>;
+interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> extends ReplaneOptions$1<T> {
   children: ReactNode;
   /**
-   * Optional snapshot from server-side rendering.
-   * When provided, the client will be restored from the snapshot synchronously
-   * instead of fetching configs from the server.
-   * The `options` will be used for live updates connection if provided.
+   * Connection options for connecting to the Replane server.
+   * Pass null to explicitly skip connection (client will use defaults/snapshot only).
    */
-  snapshot?: ReplaneSnapshot$1<T>;
+  connection: ConnectOptions$1 | null;
   /**
    * Optional loading component to show while the client is initializing.
    * If not provided and suspense is false/undefined, children will not render until ready.
@@ -96,11 +35,17 @@ interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfi
    * @default false
    */
   suspense?: boolean;
+  /**
+   * If true, the client will be connected asynchronously. Make sure to provide defaults or snapshot.
+   * @default false
+   */
+  async?: boolean;
 }
 type ReplaneProviderProps<T extends object = UntypedReplaneConfig> = ReplaneProviderWithClientProps<T> | ReplaneProviderWithOptionsProps<T>;
 /**
  * Type guard to check if props contain a pre-created client.
  */
+
 //#endregion
 //#region src/provider.d.ts
 /**
@@ -208,10 +153,10 @@ declare function createConfigHook<TConfigs extends object>(): <K extends keyof T
 //#endregion
 //#region src/useReplaneClient.d.ts
 /**
- * Clear the suspense cache for a specific options configuration.
+ * Clear the suspense cache for a specific connection configuration.
  * Useful for testing or when you need to force re-initialization.
  */
-declare function clearSuspenseCache<T extends object>(options?: ReplaneProviderOptions<T>): void;
+declare function clearSuspenseCache(connection?: ConnectOptions$1): void;
 //#endregion
-export { type ConnectOptions, type GetConfigOptions, type GetReplaneSnapshotOptions, Replane, type ReplaneContext, ReplaneError, ReplaneErrorCode, type ReplaneLogger, type ReplaneOptions, ReplaneProvider, type ReplaneProviderOptions, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, type ReplaneSnapshot, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
+export { type ConnectOptions, type GetConfigOptions, type GetReplaneSnapshotOptions, Replane, type ReplaneContext, ReplaneError, ReplaneErrorCode, type ReplaneLogger, type ReplaneOptions, ReplaneProvider, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, type ReplaneSnapshot, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/provider.tsx","../src/hooks.ts","../src/useReplaneClient.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,oBAAA,GAAuB;AAUnC;;;;AAmBW,UAnBM,sBAmBN,CAAA,UAAA,MAAA,GAnBgD,oBAmBhD,CAAA,CAAA;EAAa;;;;EA4BA,OAAA,EAAA,MAAA;EAUP;;;;EAEE,MAAT,EAAA,MAAA;EAAO;AACI;AAMrB;;EAAgD,OAAoB,CAAA,EAnDxD,gBAmDwD;EAAoB;;;EAGnE,MAOQ,CAAA,EAzDlB,eAyDkB;EAAC;;AAMV;EAUR,QAAA,CAAA,EAAA,QAAoB,MArEL,CAqEK,IArEA,CAqEA,CArEE,CAqEF,CAAA,EAAA;EAAwC;;;;EAErC,gBAAA,CAAA,EAAA,MAAA;;;;ACqEnC;EAA+B,YAAA,CAAA,EAAA,MAAA;EAAA;;;AAAiD;;;;ACzKhF;;EAA0B,mBAAoB,CAAA,EAAA,MAAA;EAAoB;;AAAY;EAQ9D,OAAA,CAAA,EAAA,OF6CG,KE7CM;EAAA;;;EAA4C,KAAM,CAAA,EAAA,MAAA;AAAC;AAqC5E;;;AACqC,UFiBpB,8BEjBoB,CAAA,UAAA,MAAA,GFiB8B,oBEjB9B,CAAA,CAAA;EAAO;EAuB5B,MAAA,EFJN,SEIM,CFJE,CEIF,CAAA;EAAgB,QAAA,EFHpB,SEGoB;;;;;AAGlB,UFAG,+BEAH,CAAA,UAAA,MAAA,GFAsD,oBEAtD,CAAA,CAAA;EAAgB;EACjB,OAAC,EFCH,sBEDG,CFCoB,CEDpB,CAAA;EAAC,QAAA,EFEH,SEFG;;;;ACyEf;;;EAAuF,QAAxB,CAAA,EHhElD,iBGgEkD,CHhElC,CGgEkC,CAAA;EAAsB;;;;;WH1D1E;;;;;;;;;KAUC,wCAAwC,wBAChD,+BAA+B,KAC/B,gCAAgC;;;;;;;;;;AAxGpC;AAUA;;;;;;;;;AA+CwB;AAUxB;;;;;;AAGqB;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;;;;ACqEnC;;;;;AAAgF;;;;ACzKhF;;;;;AAA8E,iBDyK9D,eCzK8D,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,EDyKrB,oBCzKqB,CDyKA,CCzKA,CAAA,CAAA,EDyKE,kBAAA,CAAA,GAAA,CAAA,OCzKF;AAQ9E;;;iBARgB,8BAA8B,yBAAyB,UAAQ;iBAQ/D,qCAAqC,mBAAiB,KAAK;;AFZ3E;AAUA;;;;;;;;;AA+CwB;AAUxB;;;;;;AAGqB,iBErBL,iBFqBK,CAAA,iBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,GAAA,GEpBgB,SFoBhB,CEpBwB,QFoBxB,CAAA;AAMrB;;;;;;;;;AAgBoB;AAUpB;;;;;;;AAEmC;iBE/BnB,8DACiC,gBACvC,aACI,mBAAiB,SAAS,QACnC,SAAS;;;;;;;;AFSe,iBGgEb,kBHhEa,CAAA,UAAA,MAAA,CAAA,CAAA,OAAA,CAAA,EGgEkC,sBHhElC,CGgEyD,CHhEzD,CAAA,CAAA,EAAA,IAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/provider.tsx","../src/hooks.ts","../src/useReplaneClient.ts"],"sourcesContent":[],"mappings":";;;;;KAGY,oBAAA,GAAuB;AASnC;;;AAEkB,UAFD,8BAEC,CAAA,UAAA,MAAA,GAFiD,oBAEjD,CAAA,CAAA;EAAC;EAAF,MACL,EADF,SACE,CADM,CACN,CAAA;EAAS,QAAA,EAAT,SAAS;AAMrB;;;;AAGY,UAHK,+BAGL,CAAA,UAAA,MAAA,GAFS,oBAET,CAAA,SADF,gBACE,CADa,CACb,CAAA,CAAA;EAAS,QAKP,EALF,SAKE;EAAc;;AANJ;AA2BxB;EAAgC,UAAA,EArBlB,gBAqBkB,GAAA,IAAA;EAAA;;;;;EAEG,MAAA,CAAA,EAjBxB,SAiBwB;;;;AC+GnC;;;EAA+E,QAAtB,CAAA,EAAA,OAAA;EAAoB;AAAG;;;;AC5JhF;AAA0B,KF2Cd,oBE3Cc,CAAA,UAAA,MAAA,GF2C0B,oBE3C1B,CAAA,GF4CtB,8BE5CsB,CF4CS,CE5CT,CAAA,GF6CtB,+BE7CsB,CF6CU,CE7CV,CAAA;;;;;;;;;;;AFJ1B;AASA;;;;;;AAGqB;AAMrB;;;;;;;;AAEwB;AA2BxB;;;;;;;AAEmC;;;;AC+GnC;;;;;AAAgF;;;;AC5JhF;;;;;AAA8E;AAQ9E;;;;;AAA4E;AAqC5E;;;;AAC4C,iBD8G5B,eC9G4B,CAAA,UAAA,MAAA,CAAA,CAAA,KAAA,ED8Ga,oBC9Gb,CD8GkC,CC9GlC,CAAA,CAAA,ED8GoC,kBAAA,CAAA,GAAA,CAAA,OC9GpC;AAuB5C;;;iBArEgB,8BAA8B,yBAAyB,UAAQ;iBAQ/D,qCAAqC,mBAAiB,KAAK;;AFZ3E;AASA;;;;;;AAGqB;AAMrB;;;;;;;;AAEwB;AA2BZ,iBEEI,iBFFgB,CAAA,iBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,GAAA,GEGK,SFHL,CEGa,QFHb,CAAA;;;;;;;AAEG;;;;AC+GnC;;;;;AAAgF;;;iBCvFhE,8DACiC,gBACvC,aACI,mBAAiB,SAAS,QACnC,SAAS;AAzEd;;;;;;;AF6CI,iBGmGY,kBAAA,CHnGZ,UAAA,CAAA,EGmG4C,gBHnG5C,CAAA,EAAA,IAAA"}

package/dist/index.js

@@ -6,12 +6,7 @@ import { Replane, Replane as Replane$1, ReplaneError, ReplaneErrorCode, getRepla
 import { Fragment, jsx } from "react/jsx-runtime";
 
 //#region src/context.ts
-const ReplaneContext$1 = createContext(null);
-
-//#endregion
-//#region src/version.ts
-const VERSION = "0.9.0";
-const DEFAULT_AGENT = `replane-js-react/${VERSION}`;
+const ReplaneContext = createContext(null);
 
 //#endregion
 //#region src/useReplaneClient.ts
@@ -22,29 +17,21 @@ function getCacheKey(options) {
 /**
 * Creates a Replane client and connects it.
 */
-async function createAndConnectClient(options) {
+async function createAndConnectClient(options, connection) {
 	const client = new Replane$1({
 		logger: options.logger,
 		context: options.context,
 		defaults: options.defaults
 	});
-	await client.connect({
-		baseUrl: options.baseUrl,
-		sdkKey: options.sdkKey,
-		connectTimeoutMs: options.connectTimeoutMs,
-		retryDelayMs: options.retryDelayMs,
-		requestTimeoutMs: options.requestTimeoutMs,
-		inactivityTimeoutMs: options.inactivityTimeoutMs,
-		fetchFn: options.fetchFn,
-		agent: options.agent ?? DEFAULT_AGENT
-	});
+	if (!connection) return client;
+	await client.connect(connection);
 	return client;
 }
 /**
 * Hook to manage Replane client creation internally.
 * Handles loading state and cleanup.
 */
-function useReplaneClientInternal(options) {
+function useReplaneClientInternal(options, originalConnection) {
 	const [state, setState] = useState({
 		status: "loading",
 		client: null,
@@ -52,11 +39,13 @@ function useReplaneClientInternal(options) {
 	});
 	const clientRef = useRef(null);
 	const optionsRef = useRef(options);
+	const connectionJson = JSON.stringify(originalConnection);
 	useEffect(() => {
+		const connection = JSON.parse(connectionJson);
 		let cancelled = false;
 		async function initClient() {
 			try {
-				const client = await createAndConnectClient(optionsRef.current);
+				const client = await createAndConnectClient(optionsRef.current, connection);
 				if (cancelled) {
 					client.disconnect();
 					return;
@@ -85,22 +74,22 @@ function useReplaneClientInternal(options) {
 				clientRef.current = null;
 			}
 		};
-	}, []);
+	}, [connectionJson]);
 	return state;
 }
 /**
 * Hook for Suspense-based client creation.
 * Throws a promise while loading, throws error on failure.
 */
-function useReplaneClientSuspense(options) {
-	const cacheKey = getCacheKey(options);
+function useReplaneClientSuspense(options, connection) {
+	const cacheKey = getCacheKey(connection);
 	const cached = suspenseCache.get(cacheKey);
 	if (cached) {
 		if (cached.error) throw cached.error;
 		if (cached.result) return cached.result;
 		throw cached.promise;
 	}
-	const promise = createAndConnectClient(options).then((client) => {
+	const promise = createAndConnectClient(options, connection).then((client) => {
 		const entry = suspenseCache.get(cacheKey);
 		if (entry) entry.result = client;
 		return client;
@@ -113,11 +102,11 @@ function useReplaneClientSuspense(options) {
 	throw promise;
 }
 /**
-* Clear the suspense cache for a specific options configuration.
+* Clear the suspense cache for a specific connection configuration.
 * Useful for testing or when you need to force re-initialization.
 */
-function clearSuspenseCache(options) {
-	if (options) suspenseCache.delete(getCacheKey(options));
+function clearSuspenseCache(connection) {
+	if (connection) suspenseCache.delete(getCacheKey(connection));
 	else suspenseCache.clear();
 }
 
@@ -127,9 +116,14 @@ function clearSuspenseCache(options) {
 * Type guard to check if props contain a pre-created client.
 */
 function hasClient(props) {
-	return "client" in props && props.client !== void 0;
+	return "client" in props && !!props.client;
 }
 
+//#endregion
+//#region src/version.ts
+const VERSION = "0.9.2";
+const DEFAULT_AGENT = `replane-js-react/${VERSION}`;
+
 //#endregion
 //#region src/provider.tsx
 /**
@@ -137,52 +131,31 @@ function hasClient(props) {
 */
 function ReplaneProviderWithClient({ client, children }) {
 	const value = useMemo(() => ({ replane: client }), [client]);
-	return /* @__PURE__ */ jsx(ReplaneContext$1.Provider, {
+	return /* @__PURE__ */ jsx(ReplaneContext.Provider, {
 		value,
 		children
 	});
 }
 /**
-* Internal provider component for restoring client from snapshot.
+* Internal provider component for creating a Replane client asynchronously.
 * Creates a Replane client synchronously and connects in background.
 */
-function ReplaneProviderWithSnapshot({ options, snapshot, children }) {
+function AsyncReplaneProvider({ children, connection,...options }) {
 	const replaneRef = useRef(void 0);
-	if (!replaneRef.current) replaneRef.current = new Replane$1({
-		snapshot,
-		logger: options.logger,
-		context: options.context,
-		defaults: options.defaults
-	});
+	if (!replaneRef.current) replaneRef.current = new Replane$1(options);
+	const connectionJson = connection ? JSON.stringify(connection) : void 0;
 	useEffect(() => {
-		replaneRef.current.connect({
-			baseUrl: options.baseUrl,
-			sdkKey: options.sdkKey,
-			connectTimeoutMs: options.connectTimeoutMs,
-			retryDelayMs: options.retryDelayMs,
-			requestTimeoutMs: options.requestTimeoutMs,
-			inactivityTimeoutMs: options.inactivityTimeoutMs,
-			fetchFn: options.fetchFn,
-			agent: options.agent ?? DEFAULT_AGENT
-		}).catch((err) => {
+		const parsedConnection = connectionJson ? JSON.parse(connectionJson) : void 0;
+		if (!parsedConnection) return;
+		replaneRef.current.connect(parsedConnection).catch((err) => {
 			(options.logger ?? console)?.error("Failed to connect Replane client", err);
 		});
 		return () => {
 			replaneRef.current.disconnect();
 		};
-	}, [
-		options.agent,
-		options.baseUrl,
-		options.connectTimeoutMs,
-		options.fetchFn,
-		options.inactivityTimeoutMs,
-		options.logger,
-		options.requestTimeoutMs,
-		options.retryDelayMs,
-		options.sdkKey
-	]);
+	}, [connectionJson, options.logger]);
 	const value = useMemo(() => ({ replane: replaneRef.current }), []);
-	return /* @__PURE__ */ jsx(ReplaneContext$1.Provider, {
+	return /* @__PURE__ */ jsx(ReplaneContext.Provider, {
 		value,
 		children
 	});
@@ -191,12 +164,13 @@ function ReplaneProviderWithSnapshot({ options, snapshot, children }) {
 * Internal provider component for options-based client creation (non-suspense).
 * Throws errors during rendering so they can be caught by Error Boundaries.
 */
-function ReplaneProviderWithOptions({ options, children, loader }) {
-	const state = useReplaneClientInternal(options);
+function LoaderReplaneProvider({ children, loader, connection,...options }) {
+	if (!connection) throw new Error("Connection is required when using Loader");
+	const state = useReplaneClientInternal(options, connection);
 	if (state.status === "loading") return /* @__PURE__ */ jsx(Fragment, { children: loader ?? null });
 	if (state.status === "error") throw state.error;
 	const value = { replane: state.client };
-	return /* @__PURE__ */ jsx(ReplaneContext$1.Provider, {
+	return /* @__PURE__ */ jsx(ReplaneContext.Provider, {
 		value,
 		children
 	});
@@ -204,10 +178,11 @@ function ReplaneProviderWithOptions({ options, children, loader }) {
 /**
 * Internal provider component for options-based client creation with Suspense.
 */
-function ReplaneProviderWithSuspense({ options, children }) {
-	const client = useReplaneClientSuspense(options);
+function SuspenseReplaneProvider({ connection, children,...options }) {
+	if (!connection) throw new Error("Connection is required when using Suspense");
+	const client = useReplaneClientSuspense(options, connection);
 	const value = useMemo(() => ({ replane: client }), [client]);
-	return /* @__PURE__ */ jsx(ReplaneContext$1.Provider, {
+	return /* @__PURE__ */ jsx(ReplaneContext.Provider, {
 		value,
 		children
 	});
@@ -270,19 +245,27 @@ function ReplaneProviderWithSuspense({ options, children }) {
 * allowing them to be caught by React Error Boundaries.
 */
 function ReplaneProvider(props) {
+	const originalConnection = props.connection;
+	const connection = useMemo(() => originalConnection ? {
+		...originalConnection,
+		agent: originalConnection.agent ?? DEFAULT_AGENT
+	} : void 0, [originalConnection]);
 	if (hasClient(props)) return /* @__PURE__ */ jsx(ReplaneProviderWithClient, { ...props });
-	if (props.snapshot) return /* @__PURE__ */ jsx(ReplaneProviderWithSnapshot, {
+	if (props.snapshot || !connection || props.async) return /* @__PURE__ */ jsx(AsyncReplaneProvider, { ...props });
+	if (props.suspense) return /* @__PURE__ */ jsx(SuspenseReplaneProvider, {
+		...props,
+		connection
+	});
+	return /* @__PURE__ */ jsx(LoaderReplaneProvider, {
 		...props,
-		snapshot: props.snapshot
+		connection
 	});
-	if (props.suspense) return /* @__PURE__ */ jsx(ReplaneProviderWithSuspense, { ...props });
-	return /* @__PURE__ */ jsx(ReplaneProviderWithOptions, { ...props });
 }
 
 //#endregion
 //#region src/hooks.ts
 function useReplane() {
-	const context = useContext(ReplaneContext$1);
+	const context = useContext(ReplaneContext);
 	if (!context) throw new Error("useReplane must be used within a ReplaneProvider");
 	return context.replane;
 }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["ReplaneContext","options: ReplaneProviderOptions<T>","Replane","err: unknown","options?: ReplaneProviderOptions<T>","props: ReplaneProviderProps<T>","ReplaneContext","Replane","value: ReplaneContextValue<T>","props: ReplaneProviderProps<T>","ReplaneContext","name: string","options?: GetConfigOptions<T>","callback: () => void","name: K","options?: GetConfigOptions<TConfigs[K]>"],"sources":["../src/context.ts","../src/version.ts","../src/useReplaneClient.ts","../src/types.ts","../src/provider.tsx","../src/hooks.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport type { ReplaneContextValue } from \"./types\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const ReplaneContext = createContext<ReplaneContextValue<any> | null>(null);\n","// Auto-generated - do not edit manually\nexport const VERSION = \"0.9.0\";\nexport const DEFAULT_AGENT = `replane-js-react/${VERSION}`;\n","\"use client\";\n\nimport { useEffect, useRef, useState } from \"react\";\nimport { Replane } from \"@replanejs/sdk\";\nimport { DEFAULT_AGENT } from \"./version\";\nimport type { ReplaneProviderOptions } from \"./types\";\n\ntype ClientState<T extends object> =\n  | { status: \"loading\"; client: null; error: null }\n  | { status: \"ready\"; client: Replane<T>; error: null }\n  | { status: \"error\"; client: null; error: Error };\n\n// Cache for suspense promise tracking\nconst suspenseCache = new Map<\n  string,\n  {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    promise: Promise<Replane<any>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    result?: Replane<any>;\n    error?: Error;\n  }\n>();\n\nfunction getCacheKey<T extends object>(options: ReplaneProviderOptions<T>): string {\n  return `${options.baseUrl}:${options.sdkKey}`;\n}\n\n/**\n * Creates a Replane client and connects it.\n */\nasync function createAndConnectClient<T extends object>(\n  options: ReplaneProviderOptions<T>\n): Promise<Replane<T>> {\n  const client = new Replane<T>({\n    logger: options.logger,\n    context: options.context,\n    defaults: options.defaults,\n  });\n\n  await client.connect({\n    baseUrl: options.baseUrl,\n    sdkKey: options.sdkKey,\n    connectTimeoutMs: options.connectTimeoutMs,\n    retryDelayMs: options.retryDelayMs,\n    requestTimeoutMs: options.requestTimeoutMs,\n    inactivityTimeoutMs: options.inactivityTimeoutMs,\n    fetchFn: options.fetchFn,\n    agent: options.agent ?? DEFAULT_AGENT,\n  });\n\n  return client;\n}\n\ntype ErrorConstructor = new (message: string, options?: { cause?: unknown }) => Error;\n\n/**\n * Hook to manage Replane client creation internally.\n * Handles loading state and cleanup.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useReplaneClientInternal<T extends object = any>(\n  options: ReplaneProviderOptions<T>\n): ClientState<T> {\n  const [state, setState] = useState<ClientState<T>>({\n    status: \"loading\",\n    client: null,\n    error: null,\n  });\n  const clientRef = useRef<Replane<T> | null>(null);\n  const optionsRef = useRef(options);\n\n  useEffect(() => {\n    let cancelled = false;\n\n    async function initClient() {\n      try {\n        const client = await createAndConnectClient<T>(optionsRef.current);\n        if (cancelled) {\n          client.disconnect();\n          return;\n        }\n        clientRef.current = client;\n        setState({ status: \"ready\", client, error: null });\n      } catch (err) {\n        if (cancelled) return;\n        const error =\n          err instanceof Error ? err : new (Error as ErrorConstructor)(String(err), { cause: err });\n        setState({ status: \"error\", client: null, error });\n      }\n    }\n\n    initClient();\n\n    return () => {\n      cancelled = true;\n      if (clientRef.current) {\n        clientRef.current.disconnect();\n        clientRef.current = null;\n      }\n    };\n  }, []);\n\n  return state;\n}\n\n/**\n * Hook for Suspense-based client creation.\n * Throws a promise while loading, throws error on failure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useReplaneClientSuspense<T extends object = any>(\n  options: ReplaneProviderOptions<T>\n): Replane<T> {\n  const cacheKey = getCacheKey(options);\n  const cached = suspenseCache.get(cacheKey);\n\n  if (cached) {\n    if (cached.error) {\n      throw cached.error;\n    }\n    if (cached.result) {\n      return cached.result as Replane<T>;\n    }\n    // Still loading, throw the promise\n    throw cached.promise;\n  }\n\n  // First time - create the promise\n  const promise = createAndConnectClient<T>(options)\n    .then((client) => {\n      const entry = suspenseCache.get(cacheKey);\n      if (entry) {\n        entry.result = client;\n      }\n      return client;\n    })\n    .catch((err: unknown) => {\n      const entry = suspenseCache.get(cacheKey);\n      if (entry) {\n        entry.error = err instanceof Error ? err : new Error(String(err));\n      }\n      throw err;\n    });\n\n  suspenseCache.set(cacheKey, { promise });\n  throw promise;\n}\n\n/**\n * Clear the suspense cache for a specific options configuration.\n * Useful for testing or when you need to force re-initialization.\n */\nexport function clearSuspenseCache<T extends object>(options?: ReplaneProviderOptions<T>): void {\n  if (options) {\n    suspenseCache.delete(getCacheKey(options));\n  } else {\n    suspenseCache.clear();\n  }\n}\n","import type { Replane, ReplaneSnapshot, ReplaneContext, ReplaneLogger } from \"@replanejs/sdk\";\nimport type { ReactNode } from \"react\";\n\nexport type UntypedReplaneConfig = Record<string, unknown>;\n\nexport interface ReplaneContextValue<T extends object = UntypedReplaneConfig> {\n  replane: Replane<T>;\n}\n\n/**\n * Combined options for ReplaneProvider.\n * Includes both constructor options (context, logger, defaults) and connection options.\n */\nexport interface ReplaneProviderOptions<T extends object = UntypedReplaneConfig> {\n  /**\n   * Base URL of the Replane instance (no trailing slash).\n   * @example \"https://app.replane.dev\"\n   */\n  baseUrl: string;\n  /**\n   * Project SDK key for authorization.\n   * @example \"rp_XXXXXXXXX\"\n   */\n  sdkKey: string;\n  /**\n   * Default context for all config evaluations.\n   * Can be overridden per-request in `client.get()`.\n   */\n  context?: ReplaneContext;\n  /**\n   * Optional logger (defaults to console).\n   */\n  logger?: ReplaneLogger;\n  /**\n   * Default values to use before connection is established.\n   */\n  defaults?: { [K in keyof T]?: T[K] };\n  /**\n   * Optional timeout in ms for the initial connection.\n   * @default 5000\n   */\n  connectTimeoutMs?: number;\n  /**\n   * Delay between retries in ms.\n   * @default 200\n   */\n  retryDelayMs?: number;\n  /**\n   * Optional timeout in ms for individual requests.\n   * @default 2000\n   */\n  requestTimeoutMs?: number;\n  /**\n   * Timeout in ms for SSE connection inactivity.\n   * @default 30000\n   */\n  inactivityTimeoutMs?: number;\n  /**\n   * Custom fetch implementation (useful for tests / polyfills).\n   */\n  fetchFn?: typeof fetch;\n  /**\n   * Agent identifier sent in User-Agent header.\n   */\n  agent?: string;\n}\n\n/**\n * Props for ReplaneProvider when using a pre-created client.\n */\nexport interface ReplaneProviderWithClientProps<T extends object = UntypedReplaneConfig> {\n  /** Pre-created Replane client instance */\n  client: Replane<T>;\n  children: ReactNode;\n}\n\n/**\n * Props for ReplaneProvider when letting it manage the client internally.\n */\nexport interface ReplaneProviderWithOptionsProps<T extends object = UntypedReplaneConfig> {\n  /** Options to create or restore the Replane client */\n  options: ReplaneProviderOptions<T>;\n  children: ReactNode;\n  /**\n   * Optional snapshot from server-side rendering.\n   * When provided, the client will be restored from the snapshot synchronously\n   * instead of fetching configs from the server.\n   * The `options` will be used for live updates connection if provided.\n   */\n  snapshot?: ReplaneSnapshot<T>;\n  /**\n   * Optional loading component to show while the client is initializing.\n   * If not provided and suspense is false/undefined, children will not render until ready.\n   * Ignored when snapshot is provided (restoration is synchronous).\n   */\n  loader?: ReactNode;\n  /**\n   * If true, uses React Suspense for loading state.\n   * The provider will throw a promise that Suspense can catch.\n   * Ignored when snapshot is provided (restoration is synchronous).\n   * @default false\n   */\n  suspense?: boolean;\n}\n\nexport type ReplaneProviderProps<T extends object = UntypedReplaneConfig> =\n  | ReplaneProviderWithClientProps<T>\n  | ReplaneProviderWithOptionsProps<T>;\n\n/**\n * Type guard to check if props contain a pre-created client.\n */\nexport function hasClient<T extends object>(\n  props: ReplaneProviderProps<T>\n): props is ReplaneProviderWithClientProps<T> {\n  return \"client\" in props && props.client !== undefined;\n}\n\n/**\n * Type guard to check if props contain options (with or without snapshot).\n */\nexport function hasOptions<T extends object>(\n  props: ReplaneProviderProps<T>\n): props is ReplaneProviderWithOptionsProps<T> {\n  return \"options\" in props && props.options !== undefined;\n}\n","\"use client\";\n\nimport { useEffect, useMemo, useRef } from \"react\";\nimport { Replane } from \"@replanejs/sdk\";\nimport { ReplaneContext } from \"./context\";\nimport { useReplaneClientInternal, useReplaneClientSuspense } from \"./useReplaneClient\";\nimport type {\n  ReplaneProviderProps,\n  ReplaneProviderWithClientProps,\n  ReplaneProviderWithOptionsProps,\n  ReplaneContextValue,\n} from \"./types\";\nimport { hasClient } from \"./types\";\nimport { DEFAULT_AGENT } from \"./version\";\n\n/**\n * Internal provider component for pre-created client.\n */\nfunction ReplaneProviderWithClient<T extends object>({\n  client,\n  children,\n}: ReplaneProviderWithClientProps<T>) {\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for restoring client from snapshot.\n * Creates a Replane client synchronously and connects in background.\n */\nfunction ReplaneProviderWithSnapshot<T extends object>({\n  options,\n  snapshot,\n  children,\n}: ReplaneProviderWithOptionsProps<T> & {\n  snapshot: NonNullable<ReplaneProviderWithOptionsProps<T>[\"snapshot\"]>;\n}) {\n  const replaneRef = useRef<Replane<T>>(undefined as unknown as Replane<T>);\n\n  if (!replaneRef.current) {\n    replaneRef.current = new Replane<T>({\n      snapshot,\n      logger: options.logger,\n      context: options.context,\n      defaults: options.defaults,\n    });\n  }\n\n  useEffect(() => {\n    replaneRef.current\n      .connect({\n        baseUrl: options.baseUrl,\n        sdkKey: options.sdkKey,\n        connectTimeoutMs: options.connectTimeoutMs,\n        retryDelayMs: options.retryDelayMs,\n        requestTimeoutMs: options.requestTimeoutMs,\n        inactivityTimeoutMs: options.inactivityTimeoutMs,\n        fetchFn: options.fetchFn,\n        agent: options.agent ?? DEFAULT_AGENT,\n      })\n      .catch((err) => {\n        (options.logger ?? console)?.error(\"Failed to connect Replane client\", err);\n      });\n\n    return () => {\n      replaneRef.current.disconnect();\n    };\n  }, [\n    options.agent,\n    options.baseUrl,\n    options.connectTimeoutMs,\n    options.fetchFn,\n    options.inactivityTimeoutMs,\n    options.logger,\n    options.requestTimeoutMs,\n    options.retryDelayMs,\n    options.sdkKey,\n  ]);\n\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: replaneRef.current }), []);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for options-based client creation (non-suspense).\n * Throws errors during rendering so they can be caught by Error Boundaries.\n */\nfunction ReplaneProviderWithOptions<T extends object>({\n  options,\n  children,\n  loader,\n}: ReplaneProviderWithOptionsProps<T>) {\n  const state = useReplaneClientInternal<T>(options);\n\n  if (state.status === \"loading\") {\n    return <>{loader ?? null}</>;\n  }\n\n  if (state.status === \"error\") {\n    // Throw error during render so it can be caught by Error Boundary\n    throw state.error;\n  }\n\n  const value: ReplaneContextValue<T> = { replane: state.client };\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for options-based client creation with Suspense.\n */\nfunction ReplaneProviderWithSuspense<T extends object>({\n  options,\n  children,\n}: ReplaneProviderWithOptionsProps<T>) {\n  const client = useReplaneClientSuspense<T>(options);\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Provider component that makes a Replane client available to the component tree.\n *\n * Can be used in several ways:\n *\n * 1. With a pre-created client:\n * ```tsx\n * const client = new Replane({ defaults: { ... } });\n * await client.connect({ baseUrl: '...', sdkKey: '...' });\n * <ReplaneProvider client={client}>\n *   <App />\n * </ReplaneProvider>\n * ```\n *\n * 2. With options (client managed internally):\n * ```tsx\n * <ErrorBoundary fallback={<ErrorMessage />}>\n *   <ReplaneProvider\n *     options={{ baseUrl: '...', sdkKey: '...' }}\n *     loader={<LoadingSpinner />}\n *   >\n *     <App />\n *   </ReplaneProvider>\n * </ErrorBoundary>\n * ```\n *\n * 3. With Suspense:\n * ```tsx\n * <ErrorBoundary fallback={<ErrorMessage />}>\n *   <Suspense fallback={<LoadingSpinner />}>\n *     <ReplaneProvider\n *       options={{ baseUrl: '...', sdkKey: '...' }}\n *       suspense\n *     >\n *       <App />\n *     </ReplaneProvider>\n *   </Suspense>\n * </ErrorBoundary>\n * ```\n *\n * 4. With a snapshot (for SSR/hydration):\n * ```tsx\n * // On the server, get a snapshot from the client\n * const snapshot = serverClient.getSnapshot();\n *\n * // On the client, restore from the snapshot with live updates\n * <ReplaneProvider\n *   options={{ baseUrl: '...', sdkKey: '...' }}\n *   snapshot={snapshot}\n * >\n *   <App />\n * </ReplaneProvider>\n * ```\n *\n * Errors during client initialization are thrown during rendering,\n * allowing them to be caught by React Error Boundaries.\n */\nexport function ReplaneProvider<T extends object>(props: ReplaneProviderProps<T>) {\n  if (hasClient(props)) {\n    return <ReplaneProviderWithClient {...props} />;\n  }\n\n  // Has options - check if snapshot is provided\n  if (props.snapshot) {\n    return <ReplaneProviderWithSnapshot {...props} snapshot={props.snapshot} />;\n  }\n\n  if (props.suspense) {\n    return <ReplaneProviderWithSuspense {...props} />;\n  }\n\n  return <ReplaneProviderWithOptions {...props} />;\n}\n","\"use client\";\n\nimport { useCallback, useContext, useSyncExternalStore } from \"react\";\nimport { ReplaneContext } from \"./context\";\nimport type { UntypedReplaneConfig } from \"./types\";\nimport type { Replane, GetConfigOptions } from \"@replanejs/sdk\";\n\nexport function useReplane<T extends object = UntypedReplaneConfig>(): Replane<T> {\n  const context = useContext(ReplaneContext);\n  if (!context) {\n    throw new Error(\"useReplane must be used within a ReplaneProvider\");\n  }\n  return context.replane as Replane<T>;\n}\n\nexport function useConfig<T>(name: string, options?: GetConfigOptions<T>): T {\n  const client = useReplane();\n\n  const subscribe = useCallback(\n    (callback: () => void) => {\n      return client.subscribe(name, callback);\n    },\n    [client, name]\n  );\n\n  const get = useCallback(() => {\n    return client.get(name, options) as T;\n  }, [client, name, options]);\n\n  const value = useSyncExternalStore(subscribe, get, get);\n\n  return value;\n}\n\n/**\n * Creates a typed version of useReplane hook.\n *\n * @example\n * ```tsx\n * interface AppConfigs {\n *   theme: { darkMode: boolean };\n *   features: { beta: boolean };\n * }\n *\n * const useAppReplane = createReplaneHook<AppConfigs>();\n *\n * function MyComponent() {\n *   const replane = useAppReplane();\n *   // replane.get(\"theme\") returns { darkMode: boolean }\n * }\n * ```\n */\nexport function createReplaneHook<TConfigs extends object>() {\n  return function useTypedReplane(): Replane<TConfigs> {\n    return useReplane<TConfigs>();\n  };\n}\n\n/**\n * Creates a typed version of useConfig hook.\n *\n * @example\n * ```tsx\n * interface AppConfigs {\n *   theme: { darkMode: boolean };\n *   features: { beta: boolean };\n * }\n *\n * const useAppConfig = createConfigHook<AppConfigs>();\n *\n * function MyComponent() {\n *   const theme = useAppConfig(\"theme\");\n *   // theme is typed as { darkMode: boolean }\n * }\n * ```\n */\nexport function createConfigHook<TConfigs extends object>() {\n  return function useTypedConfig<K extends keyof TConfigs>(\n    name: K,\n    options?: GetConfigOptions<TConfigs[K]>\n  ): TConfigs[K] {\n    return useConfig<TConfigs[K]>(String(name), options);\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["options: ConnectOptions","options: ReplaneOptions<T>","connection: ConnectOptions","Replane","originalConnection: ConnectOptions","err: unknown","connection?: ConnectOptions","props: ReplaneProviderProps<T>","Replane","value: ReplaneContextValue<T>","props: ReplaneProviderProps<T>","name: string","options?: GetConfigOptions<T>","callback: () => void","name: K","options?: GetConfigOptions<TConfigs[K]>"],"sources":["../src/context.ts","../src/useReplaneClient.ts","../src/types.ts","../src/version.ts","../src/provider.tsx","../src/hooks.ts"],"sourcesContent":["\"use client\";\n\nimport { createContext } from \"react\";\nimport type { ReplaneContextValue } from \"./types\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const ReplaneContext = createContext<ReplaneContextValue<any> | null>(null);\n","\"use client\";\n\nimport { useEffect, useRef, useState } from \"react\";\nimport { Replane, type ConnectOptions, type ReplaneOptions } from \"@replanejs/sdk\";\n\ntype ClientState<T extends object> =\n  | { status: \"loading\"; client: null; error: null }\n  | { status: \"ready\"; client: Replane<T>; error: null }\n  | { status: \"error\"; client: null; error: Error };\n\n// Cache for suspense promise tracking\nconst suspenseCache = new Map<\n  string,\n  {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    promise: Promise<Replane<any>>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    result?: Replane<any>;\n    error?: Error;\n  }\n>();\n\nfunction getCacheKey(options: ConnectOptions): string {\n  return `${options.baseUrl}:${options.sdkKey}`;\n}\n\n/**\n * Creates a Replane client and connects it.\n */\nasync function createAndConnectClient<T extends object>(\n  options: ReplaneOptions<T>,\n  connection: ConnectOptions\n): Promise<Replane<T>> {\n  const client = new Replane<T>({\n    logger: options.logger,\n    context: options.context,\n    defaults: options.defaults,\n  });\n\n  if (!connection) {\n    return client;\n  }\n\n  await client.connect(connection);\n\n  return client;\n}\n\ntype ErrorConstructor = new (message: string, options?: { cause?: unknown }) => Error;\n\n/**\n * Hook to manage Replane client creation internally.\n * Handles loading state and cleanup.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useReplaneClientInternal<T extends object = any>(\n  options: ReplaneOptions<T>,\n  originalConnection: ConnectOptions\n): ClientState<T> {\n  const [state, setState] = useState<ClientState<T>>({\n    status: \"loading\",\n    client: null,\n    error: null,\n  });\n  const clientRef = useRef<Replane<T> | null>(null);\n  const optionsRef = useRef(options);\n\n  const connectionJson = JSON.stringify(originalConnection);\n  useEffect(() => {\n    const connection = JSON.parse(connectionJson);\n    let cancelled = false;\n\n    async function initClient() {\n      try {\n        const client = await createAndConnectClient<T>(optionsRef.current, connection);\n        if (cancelled) {\n          client.disconnect();\n          return;\n        }\n        clientRef.current = client;\n        setState({ status: \"ready\", client, error: null });\n      } catch (err) {\n        if (cancelled) return;\n        const error =\n          err instanceof Error ? err : new (Error as ErrorConstructor)(String(err), { cause: err });\n        setState({ status: \"error\", client: null, error });\n      }\n    }\n\n    initClient();\n\n    return () => {\n      cancelled = true;\n      if (clientRef.current) {\n        clientRef.current.disconnect();\n        clientRef.current = null;\n      }\n    };\n  }, [connectionJson]);\n\n  return state;\n}\n\n/**\n * Hook for Suspense-based client creation.\n * Throws a promise while loading, throws error on failure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useReplaneClientSuspense<T extends object = any>(\n  options: ReplaneOptions<T>,\n  connection: ConnectOptions\n): Replane<T> {\n  const cacheKey = getCacheKey(connection);\n  const cached = suspenseCache.get(cacheKey);\n\n  if (cached) {\n    if (cached.error) {\n      throw cached.error;\n    }\n    if (cached.result) {\n      return cached.result as Replane<T>;\n    }\n    // Still loading, throw the promise\n    throw cached.promise;\n  }\n\n  // First time - create the promise\n  const promise = createAndConnectClient<T>(options, connection)\n    .then((client) => {\n      const entry = suspenseCache.get(cacheKey);\n      if (entry) {\n        entry.result = client;\n      }\n      return client;\n    })\n    .catch((err: unknown) => {\n      const entry = suspenseCache.get(cacheKey);\n      if (entry) {\n        entry.error = err instanceof Error ? err : new Error(String(err));\n      }\n      throw err;\n    });\n\n  suspenseCache.set(cacheKey, { promise });\n  throw promise;\n}\n\n/**\n * Clear the suspense cache for a specific connection configuration.\n * Useful for testing or when you need to force re-initialization.\n */\nexport function clearSuspenseCache(connection?: ConnectOptions): void {\n  if (connection) {\n    suspenseCache.delete(getCacheKey(connection));\n  } else {\n    suspenseCache.clear();\n  }\n}\n","import type { Replane, ReplaneOptions, ConnectOptions } from \"@replanejs/sdk\";\nimport type { ReactNode } from \"react\";\n\nexport type UntypedReplaneConfig = Record<string, unknown>;\n\nexport interface ReplaneContextValue<T extends object = UntypedReplaneConfig> {\n  replane: Replane<T>;\n}\n\n/**\n * Props for ReplaneProvider when using a pre-created client.\n */\nexport interface ReplaneProviderWithClientProps<T extends object = UntypedReplaneConfig> {\n  /** Pre-created Replane client instance */\n  client: Replane<T>;\n  children: ReactNode;\n}\n\n/**\n * Props for ReplaneProvider when letting it manage the client internally.\n */\nexport interface ReplaneProviderWithOptionsProps<\n  T extends object = UntypedReplaneConfig,\n> extends ReplaneOptions<T> {\n  children: ReactNode;\n  /**\n   * Connection options for connecting to the Replane server.\n   * Pass null to explicitly skip connection (client will use defaults/snapshot only).\n   */\n  connection: ConnectOptions | null;\n  /**\n   * Optional loading component to show while the client is initializing.\n   * If not provided and suspense is false/undefined, children will not render until ready.\n   * Ignored when snapshot is provided (restoration is synchronous).\n   */\n  loader?: ReactNode;\n  /**\n   * If true, uses React Suspense for loading state.\n   * The provider will throw a promise that Suspense can catch.\n   * Ignored when snapshot is provided (restoration is synchronous).\n   * @default false\n   */\n  suspense?: boolean;\n  /**\n   * If true, the client will be connected asynchronously. Make sure to provide defaults or snapshot.\n   * @default false\n   */\n  async?: boolean;\n}\n\nexport type ReplaneProviderProps<T extends object = UntypedReplaneConfig> =\n  | ReplaneProviderWithClientProps<T>\n  | ReplaneProviderWithOptionsProps<T>;\n\n/**\n * Type guard to check if props contain a pre-created client.\n */\nexport function hasClient<T extends object>(\n  props: ReplaneProviderProps<T>\n): props is ReplaneProviderWithClientProps<T> {\n  return \"client\" in props && !!props.client;\n}\n\n/**\n * Type guard to check if props contain options (with or without snapshot).\n */\nexport function hasOptions<T extends object>(\n  props: ReplaneProviderProps<T>\n): props is ReplaneProviderWithOptionsProps<T> {\n  return !hasClient(props);\n}\n","// Auto-generated - do not edit manually\nexport const VERSION = \"0.9.2\";\nexport const DEFAULT_AGENT = `replane-js-react/${VERSION}`;\n","\"use client\";\n\nimport { useEffect, useMemo, useRef } from \"react\";\nimport { Replane, type ConnectOptions } from \"@replanejs/sdk\";\nimport { ReplaneContext } from \"./context\";\nimport { useReplaneClientInternal, useReplaneClientSuspense } from \"./useReplaneClient\";\nimport type {\n  ReplaneProviderProps,\n  ReplaneProviderWithClientProps,\n  ReplaneProviderWithOptionsProps,\n  ReplaneContextValue,\n} from \"./types\";\nimport { hasClient } from \"./types\";\nimport { DEFAULT_AGENT } from \"./version\";\n\n/**\n * Internal provider component for pre-created client.\n */\nfunction ReplaneProviderWithClient<T extends object>({\n  client,\n  children,\n}: ReplaneProviderWithClientProps<T>) {\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for creating a Replane client asynchronously.\n * Creates a Replane client synchronously and connects in background.\n */\nfunction AsyncReplaneProvider<T extends object>({\n  children,\n  connection,\n  ...options\n}: ReplaneProviderWithOptionsProps<T>) {\n  const replaneRef = useRef<Replane<T>>(undefined as unknown as Replane<T>);\n\n  if (!replaneRef.current) {\n    replaneRef.current = new Replane<T>(options);\n  }\n\n  const connectionJson = connection ? JSON.stringify(connection) : undefined;\n\n  useEffect(() => {\n    const parsedConnection = connectionJson ? JSON.parse(connectionJson) : undefined;\n    if (!parsedConnection) {\n      return;\n    }\n\n    replaneRef.current.connect(parsedConnection).catch((err) => {\n      (options.logger ?? console)?.error(\"Failed to connect Replane client\", err);\n    });\n\n    return () => {\n      replaneRef.current.disconnect();\n    };\n  }, [connectionJson, options.logger]);\n\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: replaneRef.current }), []);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for options-based client creation (non-suspense).\n * Throws errors during rendering so they can be caught by Error Boundaries.\n */\nfunction LoaderReplaneProvider<T extends object>({\n  children,\n  loader,\n  connection,\n  ...options\n}: ReplaneProviderWithOptionsProps<T> & { connection: ConnectOptions }) {\n  if (!connection) {\n    throw new Error(\"Connection is required when using Loader\");\n  }\n  const state = useReplaneClientInternal<T>(options, connection);\n\n  if (state.status === \"loading\") {\n    return <>{loader ?? null}</>;\n  }\n\n  if (state.status === \"error\") {\n    // Throw error during render so it can be caught by Error Boundary\n    throw state.error;\n  }\n\n  const value: ReplaneContextValue<T> = { replane: state.client };\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Internal provider component for options-based client creation with Suspense.\n */\nfunction SuspenseReplaneProvider<T extends object>({\n  connection,\n  children,\n  ...options\n}: ReplaneProviderWithOptionsProps<T> & { connection: ConnectOptions }) {\n  if (!connection) {\n    throw new Error(\"Connection is required when using Suspense\");\n  }\n  const client = useReplaneClientSuspense<T>(options, connection);\n  const value = useMemo<ReplaneContextValue<T>>(() => ({ replane: client }), [client]);\n  return <ReplaneContext.Provider value={value}>{children}</ReplaneContext.Provider>;\n}\n\n/**\n * Provider component that makes a Replane client available to the component tree.\n *\n * Can be used in several ways:\n *\n * 1. With a pre-created client:\n * ```tsx\n * const client = new Replane({ defaults: { ... } });\n * await client.connect({ baseUrl: '...', sdkKey: '...' });\n * <ReplaneProvider client={client}>\n *   <App />\n * </ReplaneProvider>\n * ```\n *\n * 2. With options (client managed internally):\n * ```tsx\n * <ErrorBoundary fallback={<ErrorMessage />}>\n *   <ReplaneProvider\n *     options={{ baseUrl: '...', sdkKey: '...' }}\n *     loader={<LoadingSpinner />}\n *   >\n *     <App />\n *   </ReplaneProvider>\n * </ErrorBoundary>\n * ```\n *\n * 3. With Suspense:\n * ```tsx\n * <ErrorBoundary fallback={<ErrorMessage />}>\n *   <Suspense fallback={<LoadingSpinner />}>\n *     <ReplaneProvider\n *       options={{ baseUrl: '...', sdkKey: '...' }}\n *       suspense\n *     >\n *       <App />\n *     </ReplaneProvider>\n *   </Suspense>\n * </ErrorBoundary>\n * ```\n *\n * 4. With a snapshot (for SSR/hydration):\n * ```tsx\n * // On the server, get a snapshot from the client\n * const snapshot = serverClient.getSnapshot();\n *\n * // On the client, restore from the snapshot with live updates\n * <ReplaneProvider\n *   options={{ baseUrl: '...', sdkKey: '...' }}\n *   snapshot={snapshot}\n * >\n *   <App />\n * </ReplaneProvider>\n * ```\n *\n * Errors during client initialization are thrown during rendering,\n * allowing them to be caught by React Error Boundaries.\n */\nexport function ReplaneProvider<T extends object>(props: ReplaneProviderProps<T>) {\n  const originalConnection = (props as { connection?: ConnectOptions }).connection;\n  const connection = useMemo(\n    () =>\n      originalConnection\n        ? {\n            ...originalConnection,\n            agent: originalConnection.agent ?? DEFAULT_AGENT,\n          }\n        : undefined,\n    [originalConnection]\n  );\n\n  if (hasClient(props)) {\n    return <ReplaneProviderWithClient {...props} />;\n  }\n\n  if (props.snapshot || !connection || props.async) {\n    return <AsyncReplaneProvider {...props} />;\n  }\n\n  if (props.suspense) {\n    return <SuspenseReplaneProvider {...props} connection={connection} />;\n  }\n\n  return <LoaderReplaneProvider {...props} connection={connection} />;\n}\n","\"use client\";\n\nimport { useCallback, useContext, useSyncExternalStore } from \"react\";\nimport { ReplaneContext } from \"./context\";\nimport type { UntypedReplaneConfig } from \"./types\";\nimport type { Replane, GetConfigOptions } from \"@replanejs/sdk\";\n\nexport function useReplane<T extends object = UntypedReplaneConfig>(): Replane<T> {\n  const context = useContext(ReplaneContext);\n  if (!context) {\n    throw new Error(\"useReplane must be used within a ReplaneProvider\");\n  }\n  return context.replane as Replane<T>;\n}\n\nexport function useConfig<T>(name: string, options?: GetConfigOptions<T>): T {\n  const client = useReplane();\n\n  const subscribe = useCallback(\n    (callback: () => void) => {\n      return client.subscribe(name, callback);\n    },\n    [client, name]\n  );\n\n  const get = useCallback(() => {\n    return client.get(name, options) as T;\n  }, [client, name, options]);\n\n  const value = useSyncExternalStore(subscribe, get, get);\n\n  return value;\n}\n\n/**\n * Creates a typed version of useReplane hook.\n *\n * @example\n * ```tsx\n * interface AppConfigs {\n *   theme: { darkMode: boolean };\n *   features: { beta: boolean };\n * }\n *\n * const useAppReplane = createReplaneHook<AppConfigs>();\n *\n * function MyComponent() {\n *   const replane = useAppReplane();\n *   // replane.get(\"theme\") returns { darkMode: boolean }\n * }\n * ```\n */\nexport function createReplaneHook<TConfigs extends object>() {\n  return function useTypedReplane(): Replane<TConfigs> {\n    return useReplane<TConfigs>();\n  };\n}\n\n/**\n * Creates a typed version of useConfig hook.\n *\n * @example\n * ```tsx\n * interface AppConfigs {\n *   theme: { darkMode: boolean };\n *   features: { beta: boolean };\n * }\n *\n * const useAppConfig = createConfigHook<AppConfigs>();\n *\n * function MyComponent() {\n *   const theme = useAppConfig(\"theme\");\n *   // theme is typed as { darkMode: boolean }\n * }\n * ```\n */\nexport function createConfigHook<TConfigs extends object>() {\n  return function useTypedConfig<K extends keyof TConfigs>(\n    name: K,\n    options?: GetConfigOptions<TConfigs[K]>\n  ): TConfigs[K] {\n    return useConfig<TConfigs[K]>(String(name), options);\n  };\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@replanejs/react",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "React SDK for Replane - feature flags and remote configuration",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -40,7 +40,7 @@
     "react": ">=18.0.0"
   },
   "dependencies": {
-    "@replanejs/sdk": "^0.9.0"
+    "@replanejs/sdk": "^0.9.2"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.9.1",