@replanejs/next 0.7.3 → 0.7.5

package/dist/index.d.ts

@@ -1,216 +1,56 @@
-import { ReactNode } from "react";
-import { ReplaneContextValue, useConfig, useReplane } from "@replanejs/react";
-import { ReplaneClient, ReplaneContext, ReplaneContext as ReplaneContext$1, ReplaneError, ReplaneSnapshot, ReplaneSnapshot as ReplaneSnapshot$1, restoreReplaneClient } from "@replanejs/sdk";
-import * as react_jsx_runtime0$1 from "react/jsx-runtime";
+import { GetReplaneSnapshotOptions, ReplaneProvider, ReplaneProviderProps, ReplaneProviderWithClientProps, ReplaneProviderWithOptionsProps, clearSnapshotCache, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, useConfig, useReplane } from "@replanejs/react";
+import { GetConfigOptions, ReplaneClient, ReplaneClientOptions, ReplaneClientOptions as ReplaneClientOptions$1, ReplaneContext, ReplaneError, ReplaneErrorCode, ReplaneLogger, ReplaneSnapshot, RestoreReplaneClientOptions, createInMemoryReplaneClient, createReplaneClient, restoreReplaneClient } from "@replanejs/sdk";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
+
+//#region src/root.d.ts
 
-//#region src/types.d.ts
-/**
- * Connection options for real-time updates.
- */
-interface ReplaneConnectionOptions {
-  /**
-   * Base URL of the Replane instance (no trailing slash).
-   * Use a NEXT_PUBLIC_ prefixed env var for client-side access.
-   */
-  baseUrl: string;
-  /**
-   * Project SDK key for authorization.
-   * Use a NEXT_PUBLIC_ prefixed env var for client-side access.
-   */
-  sdkKey: string;
-  /**
-   * Optional timeout in ms for requests.
-   * @default 2000
-   */
-  requestTimeoutMs?: number;
-  /**
-   * Delay between retries in ms.
-   * @default 200
-   */
-  retryDelayMs?: number;
-  /**
-   * Timeout in ms for SSE connection inactivity.
-   * @default 30000
-   */
-  inactivityTimeoutMs?: number;
-}
 /**
- * Props for ReplaneNextProvider.
+ * Props for ReplaneRoot server component
  */
-interface ReplaneNextProviderProps<T extends object = object> {
+interface ReplaneRootProps<T extends object> {
   /**
-   * Serializable snapshot from the server.
-   * Obtained from `getReplaneSnapshot()` in a Server Component or getServerSideProps.
+   * Options for Replane client.
+   * Used for both server-side fetching and client-side live updates.
    */
-  snapshot: ReplaneSnapshot$1<T>;
+  options: ReplaneClientOptions$1<T>;
   /**
-   * Connection options for real-time updates.
-   * If not provided, the client will only use the snapshot data (no live updates).
-   *
-   * For SSR apps that need real-time updates, provide connection options:
-   * ```tsx
-   * <ReplaneNextProvider
-   *   snapshot={snapshot}
-   *   connection={{
-   *     baseUrl: process.env.NEXT_PUBLIC_REPLANE_BASE_URL!,
-   *     sdkKey: process.env.NEXT_PUBLIC_REPLANE_SDK_KEY!,
-   *   }}
-   * >
-   *   {children}
-   * </ReplaneNextProvider>
-   * ```
+   * React children to render inside the provider
    */
-  connection?: ReplaneConnectionOptions;
-  /**
-   * Override the context from the snapshot on the client.
-   * Useful for client-specific context like browser info.
-   */
-  context?: ReplaneContext$1;
   children: ReactNode;
 }
-//# sourceMappingURL=types.d.ts.map
-//#endregion
-//#region src/provider.d.ts
 /**
- * Next.js-optimized Replane provider with SSR hydration support.
- *
- * This component:
- * 1. Restores the Replane client from a server-side snapshot instantly (no loading state)
- * 2. Optionally connects to Replane for real-time updates
- * 3. Preserves the client across re-renders for minimal latency
+ * Server component that fetches Replane configs and provides them to the app.
+ * This is the simplest way to set up Replane in Next.js App Router.
  *
- * @example
+ * @example Basic usage in layout.tsx
  * ```tsx
  * // app/layout.tsx
- * import { getReplaneSnapshot } from "@replanejs/next/server";
- * import { ReplaneNextProvider } from "@replanejs/next";
- *
- * export default async function RootLayout({ children }) {
- *   const snapshot = await getReplaneSnapshot({
- *     baseUrl: process.env.REPLANE_BASE_URL!,
- *     sdkKey: process.env.REPLANE_SDK_KEY!,
- *   });
+ * import { ReplaneRoot } from "@replanejs/next";
  *
+ * export default function RootLayout({ children }) {
  *   return (
  *     <html>
  *       <body>
- *         <ReplaneNextProvider
- *           snapshot={snapshot}
- *           connection={{
+ *         <ReplaneRoot
+ *           options={{
  *             baseUrl: process.env.NEXT_PUBLIC_REPLANE_BASE_URL!,
  *             sdkKey: process.env.NEXT_PUBLIC_REPLANE_SDK_KEY!,
  *           }}
  *         >
  *           {children}
- *         </ReplaneNextProvider>
+ *         </ReplaneRoot>
  *       </body>
  *     </html>
  *   );
  * }
  * ```
- *
- * @example
- * ```tsx
- * // Without real-time updates (static snapshot only)
- * <ReplaneNextProvider snapshot={snapshot}>
- *   {children}
- * </ReplaneNextProvider>
- * ```
- */
-declare function ReplaneNextProvider<T extends object = Record<string, unknown>>({
-  snapshot,
-  connection,
-  context,
-  children
-}: ReplaneNextProviderProps<T>): react_jsx_runtime0$1.JSX.Element;
-//# sourceMappingURL=provider.d.ts.map
-//#endregion
-//#region src/script.d.ts
-declare const REPLANE_SNAPSHOT_KEY = "__REPLANE_SNAPSHOT__";
-type AnyConfig = Record<string, unknown>;
-declare global {
-  interface Window {
-    [REPLANE_SNAPSHOT_KEY]?: ReplaneSnapshot$1<AnyConfig>;
-  }
-}
-/**
- * Generate the script content for embedding the snapshot.
- *
- * Use this in a Server Component to embed the snapshot in the page:
- *
- * @example
- * ```tsx
- * // app/layout.tsx
- * import { getReplaneSnapshot } from "@replanejs/next/server";
- * import { getReplaneSnapshotScript, ReplaneScriptProvider } from "@replanejs/next";
- *
- * export default async function RootLayout({ children }) {
- *   const snapshot = await getReplaneSnapshot({ ... });
- *
- *   return (
- *     <html>
- *       <head>
- *         <script
- *           dangerouslySetInnerHTML={{
- *             __html: getReplaneSnapshotScript(snapshot),
- *           }}
- *         />
- *       </head>
- *       <body>
- *         <ReplaneScriptProvider connection={{ ... }}>
- *           {children}
- *         </ReplaneScriptProvider>
- *       </body>
- *     </html>
- *   );
- * }
- * ```
- */
-declare function getReplaneSnapshotScript<T extends object = AnyConfig>(snapshot: ReplaneSnapshot$1<T>): string;
-/**
- * Props for ReplaneScriptProvider.
- */
-interface ReplaneScriptProviderProps {
-  /**
-   * Connection options for real-time updates.
-   * If not provided, the client will only use the snapshot data (no live updates).
-   */
-  connection?: ReplaneConnectionOptions;
-  /**
-   * Fallback to render while waiting for the snapshot.
-   * This should rarely be needed since the script is in the head.
-   */
-  fallback?: ReactNode;
-  children: ReactNode;
-}
-/**
- * Provider that reads the snapshot from a script tag.
- *
- * Use this with `getReplaneSnapshotScript()` for an alternative hydration pattern
- * where the snapshot is embedded in a script tag instead of passed as a prop.
- *
- * This pattern can be useful for:
- * - Pages with heavy component trees where prop drilling is inconvenient
- * - Partial hydration scenarios
- * - When you want the snapshot to be available before React hydrates
- *
- * @example
- * ```tsx
- * // In app/layout.tsx (Server Component)
- * <script dangerouslySetInnerHTML={{ __html: getReplaneSnapshotScript(snapshot) }} />
- *
- * // In a client component
- * <ReplaneScriptProvider connection={{ baseUrl, sdkKey }}>
- *   <App />
- * </ReplaneScriptProvider>
- * ```
  */
-declare function ReplaneScriptProvider({
-  connection,
-  fallback,
+declare function ReplaneRoot<T extends object>({
+  options,
   children
-}: ReplaneScriptProviderProps): react_jsx_runtime0.JSX.Element;
+}: ReplaneRootProps<T>): Promise<react_jsx_runtime0.JSX.Element>;
+//# sourceMappingURL=root.d.ts.map
 //#endregion
-export { type ReplaneClient, type ReplaneConnectionOptions, type ReplaneContext, type ReplaneContextValue, type ReplaneError, ReplaneNextProvider, type ReplaneNextProviderProps, ReplaneScriptProvider, type ReplaneScriptProviderProps, type ReplaneSnapshot, getReplaneSnapshotScript, restoreReplaneClient, useConfig, useReplane };
+export { type GetConfigOptions, type GetReplaneSnapshotOptions, type ReplaneClient, type ReplaneClientOptions, type ReplaneContext, ReplaneError, ReplaneErrorCode, type ReplaneLogger, ReplaneProvider, type ReplaneProviderProps, type ReplaneProviderWithClientProps, type ReplaneProviderWithOptionsProps, ReplaneRoot, type ReplaneRootProps, type ReplaneSnapshot, type RestoreReplaneClientOptions, clearSnapshotCache, clearSuspenseCache, createConfigHook, createInMemoryReplaneClient, createReplaneClient, createReplaneHook, getReplaneSnapshot, restoreReplaneClient, 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/script.tsx"],"sourcesContent":[],"mappings":";;;;;;;;;;UAMiB,wBAAA;;AAAjB;AAmCA;;EAAyC,OAKb,EAAA,MAAA;EAAC;;;;EA2BR,MAAA,EAAA,MAAA;;;;ACpBrB;EAAmC,gBAAA,CAAA,EAAA,MAAA;EAAA;;;;EAG1B,YACP,CAAA,EAAA,MAAA;EAAQ;;;AACoB;;;;ACrD0B;AAG9B;AAEH,UF+BN,wBE/BM,CAAA,UAAA,MAAA,GAAA,MAAA,CAAA,CAAA;EAAA;;;;EAIE,QAAA,EFgCb,iBEhCa,CFgCG,CEhCH,CAAA;EAAA;AAqCzB;;;;;AAC2B;AAU3B;;;;;AAaqB;AAyBrB;;;;EAEU,UACR,CAAA,EFtCa,wBEsCb;EAAQ;;AACmB;;YFjCjB;YAEA;;;;;;;;;;;AAnEZ;AAmCA;;;;;;;AAgCqB;;;;ACpBrB;;;;;;;;;;AAK8B;;;;ACrD0B;AAG9B;AAEH;;;;;;AAIE;AAqCzB;;;;;AAC2B,iBDCX,mBCDW,CAAA,UAAA,MAAA,GDC4B,MCD5B,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,CAAA;EAAA,QAAA;EAAA,UAAA;EAAA,OAAA;EAAA;AAAA,CAAA,EDMxB,wBCNwB,CDMC,CCND,CAAA,CAAA,EDMG,oBAAA,CAAA,GAAA,CAAA,OCNH;AAU3B;;;cAtDM,oBAAA;KAED,SAAA,GAAY;;;IFJA,CEQZ,oBAAA,EFRoC,EEQZ,iBFRY,CEQI,SFRJ,CAAA;EAmCxB;;;;;;;AAgCI;;;;ACpBrB;;;;;;;;;;AAK8B;;;;ACrD0B;AAG9B;AAEH;;;;;;AAIE;AAqCzB;AAAwC,iBAAxB,wBAAwB,CAAA,UAAA,MAAA,GAAoB,SAApB,CAAA,CAAA,QAAA,EAC5B,iBAD4B,CACZ,CADY,CAAA,CAAA,EAAA,MAAA;;;;AACb,UAUV,0BAAA,CAVU;EAUV;;;;EAWK,UAEV,CAAA,EARG,wBAQH;EAAS;AAyBrB;;;EACY,QACV,CAAA,EA7BW,SA6BX;EAAQ,QACR,EA5BU,SA4BV;;;AAC2B;;;;;;;;;;;;;;;;;;;;;iBAJb,qBAAA;;;;GAIb,6BAA0B,kBAAA,CAAA,GAAA,CAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/root.tsx"],"sourcesContent":[],"mappings":";;;;;;;AAaA;;;AAKW,UALM,gBAKN,CAAA,UAAA,MAAA,CAAA,CAAA;EAAoB;AAIV;AA8BrB;;EAAiC,OAAqB,EAlC3C,sBAkC2C,CAlCtB,CAkCsB,CAAA;EAAO;;;EAA8B,QAAG,EA9BlF,SA8BkF;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAxE;;;GAAqD,iBAAiB,KAAE,QAAA,kBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/index.js

@@ -1,198 +1,44 @@
-import { useEffect, useMemo, useRef, useState } from "react";
-import { ReplaneProvider, useConfig, useReplane } from "@replanejs/react";
-import { restoreReplaneClient, restoreReplaneClient as restoreReplaneClient$1 } from "@replanejs/sdk";
-import { Fragment, jsx } from "react/jsx-runtime";
+import { ReplaneProvider, ReplaneProvider as ReplaneProvider$1, clearSnapshotCache, clearSuspenseCache, createConfigHook, createReplaneHook, getReplaneSnapshot, getReplaneSnapshot as getReplaneSnapshot$1, useConfig, useReplane } from "@replanejs/react";
+import { ReplaneError, ReplaneErrorCode, createInMemoryReplaneClient, createReplaneClient, restoreReplaneClient } from "@replanejs/sdk";
+import { jsx } from "react/jsx-runtime";
 
-//#region src/provider.tsx
+//#region src/root.tsx
 /**
-* Next.js-optimized Replane provider with SSR hydration support.
+* Server component that fetches Replane configs and provides them to the app.
+* This is the simplest way to set up Replane in Next.js App Router.
 *
-* This component:
-* 1. Restores the Replane client from a server-side snapshot instantly (no loading state)
-* 2. Optionally connects to Replane for real-time updates
-* 3. Preserves the client across re-renders for minimal latency
-*
-* @example
+* @example Basic usage in layout.tsx
 * ```tsx
 * // app/layout.tsx
-* import { getReplaneSnapshot } from "@replanejs/next/server";
-* import { ReplaneNextProvider } from "@replanejs/next";
-*
-* export default async function RootLayout({ children }) {
-*   const snapshot = await getReplaneSnapshot({
-*     baseUrl: process.env.REPLANE_BASE_URL!,
-*     sdkKey: process.env.REPLANE_SDK_KEY!,
-*   });
+* import { ReplaneRoot } from "@replanejs/next";
 *
+* export default function RootLayout({ children }) {
 *   return (
 *     <html>
 *       <body>
-*         <ReplaneNextProvider
-*           snapshot={snapshot}
-*           connection={{
+*         <ReplaneRoot
+*           options={{
 *             baseUrl: process.env.NEXT_PUBLIC_REPLANE_BASE_URL!,
 *             sdkKey: process.env.NEXT_PUBLIC_REPLANE_SDK_KEY!,
 *           }}
 *         >
 *           {children}
-*         </ReplaneNextProvider>
+*         </ReplaneRoot>
 *       </body>
 *     </html>
 *   );
 * }
 * ```
-*
-* @example
-* ```tsx
-* // Without real-time updates (static snapshot only)
-* <ReplaneNextProvider snapshot={snapshot}>
-*   {children}
-* </ReplaneNextProvider>
-* ```
 */
-function ReplaneNextProvider({ snapshot, connection, context, children }) {
-	const clientRef = useRef(null);
-	const clientKey = useMemo(() => {
-		const snapshotKey = JSON.stringify(snapshot.configs.map((c) => c.name).sort());
-		const connectionKey = connection ? `${connection.baseUrl}:${connection.sdkKey}` : "no-connection";
-		const contextKey = context ? JSON.stringify(context) : "no-context";
-		return `${snapshotKey}:${connectionKey}:${contextKey}`;
-	}, [
+async function ReplaneRoot({ options, children }) {
+	const snapshot = await getReplaneSnapshot$1(options);
+	return /* @__PURE__ */ jsx(ReplaneProvider$1, {
+		options,
 		snapshot,
-		connection,
-		context
-	]);
-	const client = useMemo(() => {
-		if (clientRef.current) {}
-		const newClient = restoreReplaneClient$1({
-			snapshot,
-			connection: connection ? {
-				baseUrl: connection.baseUrl,
-				sdkKey: connection.sdkKey,
-				requestTimeoutMs: connection.requestTimeoutMs,
-				retryDelayMs: connection.retryDelayMs,
-				inactivityTimeoutMs: connection.inactivityTimeoutMs
-			} : void 0,
-			context
-		});
-		clientRef.current = newClient;
-		return newClient;
-	}, [clientKey]);
-	useEffect(() => {
-		return () => {
-			if (clientRef.current) {
-				clientRef.current.close();
-				clientRef.current = null;
-			}
-		};
-	}, []);
-	return /* @__PURE__ */ jsx(ReplaneProvider, {
-		client,
-		children
-	});
-}
-
-//#endregion
-//#region src/script.tsx
-const REPLANE_SNAPSHOT_KEY = "__REPLANE_SNAPSHOT__";
-/**
-* Generate the script content for embedding the snapshot.
-*
-* Use this in a Server Component to embed the snapshot in the page:
-*
-* @example
-* ```tsx
-* // app/layout.tsx
-* import { getReplaneSnapshot } from "@replanejs/next/server";
-* import { getReplaneSnapshotScript, ReplaneScriptProvider } from "@replanejs/next";
-*
-* export default async function RootLayout({ children }) {
-*   const snapshot = await getReplaneSnapshot({ ... });
-*
-*   return (
-*     <html>
-*       <head>
-*         <script
-*           dangerouslySetInnerHTML={{
-*             __html: getReplaneSnapshotScript(snapshot),
-*           }}
-*         />
-*       </head>
-*       <body>
-*         <ReplaneScriptProvider connection={{ ... }}>
-*           {children}
-*         </ReplaneScriptProvider>
-*       </body>
-*     </html>
-*   );
-* }
-* ```
-*/
-function getReplaneSnapshotScript(snapshot) {
-	const json = JSON.stringify(snapshot).replace(/<\/script>/gi, "<\\/script>");
-	return `window.${REPLANE_SNAPSHOT_KEY}=${json};`;
-}
-/**
-* Provider that reads the snapshot from a script tag.
-*
-* Use this with `getReplaneSnapshotScript()` for an alternative hydration pattern
-* where the snapshot is embedded in a script tag instead of passed as a prop.
-*
-* This pattern can be useful for:
-* - Pages with heavy component trees where prop drilling is inconvenient
-* - Partial hydration scenarios
-* - When you want the snapshot to be available before React hydrates
-*
-* @example
-* ```tsx
-* // In app/layout.tsx (Server Component)
-* <script dangerouslySetInnerHTML={{ __html: getReplaneSnapshotScript(snapshot) }} />
-*
-* // In a client component
-* <ReplaneScriptProvider connection={{ baseUrl, sdkKey }}>
-*   <App />
-* </ReplaneScriptProvider>
-* ```
-*/
-function ReplaneScriptProvider({ connection, fallback, children }) {
-	const [snapshot, setSnapshot] = useState(() => {
-		if (typeof window !== "undefined" && window[REPLANE_SNAPSHOT_KEY]) return window[REPLANE_SNAPSHOT_KEY];
-		return null;
-	});
-	const clientRef = useRef(null);
-	useEffect(() => {
-		if (!snapshot && typeof window !== "undefined" && window[REPLANE_SNAPSHOT_KEY]) setSnapshot(window[REPLANE_SNAPSHOT_KEY]);
-	}, [snapshot]);
-	const client = useMemo(() => {
-		if (!snapshot) return null;
-		const newClient = restoreReplaneClient$1({
-			snapshot,
-			connection: connection ? {
-				baseUrl: connection.baseUrl,
-				sdkKey: connection.sdkKey,
-				requestTimeoutMs: connection.requestTimeoutMs,
-				retryDelayMs: connection.retryDelayMs,
-				inactivityTimeoutMs: connection.inactivityTimeoutMs
-			} : void 0
-		});
-		clientRef.current = newClient;
-		return newClient;
-	}, [snapshot, connection]);
-	useEffect(() => {
-		return () => {
-			if (clientRef.current) {
-				clientRef.current.close();
-				clientRef.current = null;
-			}
-		};
-	}, []);
-	if (!client) return /* @__PURE__ */ jsx(Fragment, { children: fallback ?? null });
-	return /* @__PURE__ */ jsx(ReplaneProvider, {
-		client,
 		children
 	});
 }
 
 //#endregion
-export { ReplaneNextProvider, ReplaneScriptProvider, getReplaneSnapshotScript, restoreReplaneClient, useConfig, useReplane };
+export { ReplaneError, ReplaneErrorCode, ReplaneProvider, ReplaneRoot, clearSnapshotCache, clearSuspenseCache, createConfigHook, createInMemoryReplaneClient, createReplaneClient, createReplaneHook, getReplaneSnapshot, restoreReplaneClient, useConfig, useReplane };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["snapshot: ReplaneSnapshot<T>"],"sources":["../src/provider.tsx","../src/script.tsx"],"sourcesContent":["\"use client\";\n\nimport { useMemo, useRef, useEffect } from \"react\";\nimport { ReplaneProvider } from \"@replanejs/react\";\nimport { restoreReplaneClient, type ReplaneClient } from \"@replanejs/sdk\";\nimport type { ReplaneNextProviderProps } from \"./types\";\n\n/**\n * Next.js-optimized Replane provider with SSR hydration support.\n *\n * This component:\n * 1. Restores the Replane client from a server-side snapshot instantly (no loading state)\n * 2. Optionally connects to Replane for real-time updates\n * 3. Preserves the client across re-renders for minimal latency\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import { getReplaneSnapshot } from \"@replanejs/next/server\";\n * import { ReplaneNextProvider } from \"@replanejs/next\";\n *\n * export default async function RootLayout({ children }) {\n *   const snapshot = await getReplaneSnapshot({\n *     baseUrl: process.env.REPLANE_BASE_URL!,\n *     sdkKey: process.env.REPLANE_SDK_KEY!,\n *   });\n *\n *   return (\n *     <html>\n *       <body>\n *         <ReplaneNextProvider\n *           snapshot={snapshot}\n *           connection={{\n *             baseUrl: process.env.NEXT_PUBLIC_REPLANE_BASE_URL!,\n *             sdkKey: process.env.NEXT_PUBLIC_REPLANE_SDK_KEY!,\n *           }}\n *         >\n *           {children}\n *         </ReplaneNextProvider>\n *       </body>\n *     </html>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // Without real-time updates (static snapshot only)\n * <ReplaneNextProvider snapshot={snapshot}>\n *   {children}\n * </ReplaneNextProvider>\n * ```\n */\nexport function ReplaneNextProvider<T extends object = Record<string, unknown>>({\n  snapshot,\n  connection,\n  context,\n  children,\n}: ReplaneNextProviderProps<T>) {\n  // Use a ref to store the client to preserve it across re-renders\n  // This is important for minimizing latency - we don't want to recreate\n  // the client on every render\n  const clientRef = useRef<ReplaneClient<T> | null>(null);\n\n  // Create a stable key for the client based on snapshot and connection\n  // We only recreate the client if these change\n  const clientKey = useMemo(() => {\n    const snapshotKey = JSON.stringify(snapshot.configs.map((c) => c.name).sort());\n    const connectionKey = connection ? `${connection.baseUrl}:${connection.sdkKey}` : \"no-connection\";\n    const contextKey = context ? JSON.stringify(context) : \"no-context\";\n    return `${snapshotKey}:${connectionKey}:${contextKey}`;\n  }, [snapshot, connection, context]);\n\n  // Memoize client creation\n  const client = useMemo(() => {\n    // If we have a cached client with the same key, reuse it\n    if (clientRef.current) {\n      // Check if we need to create a new client\n      // For simplicity, we always create a new client if the key changes\n      // This happens when snapshot or connection changes\n    }\n\n    const newClient = restoreReplaneClient<T>({\n      snapshot,\n      connection: connection\n        ? {\n            baseUrl: connection.baseUrl,\n            sdkKey: connection.sdkKey,\n            requestTimeoutMs: connection.requestTimeoutMs,\n            retryDelayMs: connection.retryDelayMs,\n            inactivityTimeoutMs: connection.inactivityTimeoutMs,\n          }\n        : undefined,\n      context,\n    });\n\n    clientRef.current = newClient;\n    return newClient;\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [clientKey]);\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      if (clientRef.current) {\n        clientRef.current.close();\n        clientRef.current = null;\n      }\n    };\n  }, []);\n\n  return <ReplaneProvider client={client}>{children}</ReplaneProvider>;\n}\n","\"use client\";\n\nimport { useEffect, useState, useMemo, useRef, type ReactNode } from \"react\";\nimport { ReplaneProvider } from \"@replanejs/react\";\nimport { restoreReplaneClient, type ReplaneSnapshot, type ReplaneClient } from \"@replanejs/sdk\";\nimport type { ReplaneConnectionOptions } from \"./types\";\n\n// Global variable name for the snapshot\nconst REPLANE_SNAPSHOT_KEY = \"__REPLANE_SNAPSHOT__\";\n\ntype AnyConfig = Record<string, unknown>;\n\ndeclare global {\n  interface Window {\n    [REPLANE_SNAPSHOT_KEY]?: ReplaneSnapshot<AnyConfig>;\n  }\n}\n\n/**\n * Generate the script content for embedding the snapshot.\n *\n * Use this in a Server Component to embed the snapshot in the page:\n *\n * @example\n * ```tsx\n * // app/layout.tsx\n * import { getReplaneSnapshot } from \"@replanejs/next/server\";\n * import { getReplaneSnapshotScript, ReplaneScriptProvider } from \"@replanejs/next\";\n *\n * export default async function RootLayout({ children }) {\n *   const snapshot = await getReplaneSnapshot({ ... });\n *\n *   return (\n *     <html>\n *       <head>\n *         <script\n *           dangerouslySetInnerHTML={{\n *             __html: getReplaneSnapshotScript(snapshot),\n *           }}\n *         />\n *       </head>\n *       <body>\n *         <ReplaneScriptProvider connection={{ ... }}>\n *           {children}\n *         </ReplaneScriptProvider>\n *       </body>\n *     </html>\n *   );\n * }\n * ```\n */\nexport function getReplaneSnapshotScript<T extends object = AnyConfig>(\n  snapshot: ReplaneSnapshot<T>\n): string {\n  // Escape script closing tags in JSON to prevent XSS\n  const json = JSON.stringify(snapshot).replace(/<\\/script>/gi, \"<\\\\/script>\");\n  return `window.${REPLANE_SNAPSHOT_KEY}=${json};`;\n}\n\n/**\n * Props for ReplaneScriptProvider.\n */\nexport interface ReplaneScriptProviderProps {\n  /**\n   * Connection options for real-time updates.\n   * If not provided, the client will only use the snapshot data (no live updates).\n   */\n  connection?: ReplaneConnectionOptions;\n\n  /**\n   * Fallback to render while waiting for the snapshot.\n   * This should rarely be needed since the script is in the head.\n   */\n  fallback?: ReactNode;\n\n  children: ReactNode;\n}\n\n/**\n * Provider that reads the snapshot from a script tag.\n *\n * Use this with `getReplaneSnapshotScript()` for an alternative hydration pattern\n * where the snapshot is embedded in a script tag instead of passed as a prop.\n *\n * This pattern can be useful for:\n * - Pages with heavy component trees where prop drilling is inconvenient\n * - Partial hydration scenarios\n * - When you want the snapshot to be available before React hydrates\n *\n * @example\n * ```tsx\n * // In app/layout.tsx (Server Component)\n * <script dangerouslySetInnerHTML={{ __html: getReplaneSnapshotScript(snapshot) }} />\n *\n * // In a client component\n * <ReplaneScriptProvider connection={{ baseUrl, sdkKey }}>\n *   <App />\n * </ReplaneScriptProvider>\n * ```\n */\nexport function ReplaneScriptProvider({\n  connection,\n  fallback,\n  children,\n}: ReplaneScriptProviderProps) {\n  const [snapshot, setSnapshot] = useState<ReplaneSnapshot<AnyConfig> | null>(() => {\n    // Try to get snapshot from window on initial render (SSR-safe)\n    if (typeof window !== \"undefined\" && window[REPLANE_SNAPSHOT_KEY]) {\n      return window[REPLANE_SNAPSHOT_KEY];\n    }\n    return null;\n  });\n\n  const clientRef = useRef<ReplaneClient<AnyConfig> | null>(null);\n\n  // Check for snapshot on mount (in case the script runs after initial render)\n  useEffect(() => {\n    if (!snapshot && typeof window !== \"undefined\" && window[REPLANE_SNAPSHOT_KEY]) {\n      setSnapshot(window[REPLANE_SNAPSHOT_KEY]);\n    }\n  }, [snapshot]);\n\n  // Create client from snapshot\n  const client = useMemo(() => {\n    if (!snapshot) return null;\n\n    const newClient = restoreReplaneClient({\n      snapshot,\n      connection: connection\n        ? {\n            baseUrl: connection.baseUrl,\n            sdkKey: connection.sdkKey,\n            requestTimeoutMs: connection.requestTimeoutMs,\n            retryDelayMs: connection.retryDelayMs,\n            inactivityTimeoutMs: connection.inactivityTimeoutMs,\n          }\n        : undefined,\n    });\n\n    clientRef.current = newClient;\n    return newClient;\n  }, [snapshot, connection]);\n\n  // Cleanup on unmount\n  useEffect(() => {\n    return () => {\n      if (clientRef.current) {\n        clientRef.current.close();\n        clientRef.current = null;\n      }\n    };\n  }, []);\n\n  if (!client) {\n    return <>{fallback ?? null}</>;\n  }\n\n  return <ReplaneProvider client={client}>{children}</ReplaneProvider>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,SAAgB,oBAAgE,EAC9E,UACA,YACA,SACA,UAC4B,EAAE;CAI9B,MAAM,YAAY,OAAgC,KAAK;CAIvD,MAAM,YAAY,QAAQ,MAAM;EAC9B,MAAM,cAAc,KAAK,UAAU,SAAS,QAAQ,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC;EAC9E,MAAM,gBAAgB,cAAc,EAAE,WAAW,QAAQ,GAAG,WAAW,OAAO,IAAI;EAClF,MAAM,aAAa,UAAU,KAAK,UAAU,QAAQ,GAAG;AACvD,UAAQ,EAAE,YAAY,GAAG,cAAc,GAAG,WAAW;CACtD,GAAE;EAAC;EAAU;EAAY;CAAQ,EAAC;CAGnC,MAAM,SAAS,QAAQ,MAAM;AAE3B,MAAI,UAAU,SAAS,CAItB;EAED,MAAM,YAAY,uBAAwB;GACxC;GACA,YAAY,aACR;IACE,SAAS,WAAW;IACpB,QAAQ,WAAW;IACnB,kBAAkB,WAAW;IAC7B,cAAc,WAAW;IACzB,qBAAqB,WAAW;GACjC;GAEL;EACD,EAAC;AAEF,YAAU,UAAU;AACpB,SAAO;CAER,GAAE,CAAC,SAAU,EAAC;AAGf,WAAU,MAAM;AACd,SAAO,MAAM;AACX,OAAI,UAAU,SAAS;AACrB,cAAU,QAAQ,OAAO;AACzB,cAAU,UAAU;GACrB;EACF;CACF,GAAE,CAAE,EAAC;AAEN,wBAAO,IAAC;EAAwB;EAAS;GAA2B;AACrE;;;;ACxGD,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2C7B,SAAgB,yBACdA,UACQ;CAER,MAAM,OAAO,KAAK,UAAU,SAAS,CAAC,QAAQ,gBAAgB,cAAc;AAC5E,SAAQ,SAAS,qBAAqB,GAAG,KAAK;AAC/C;;;;;;;;;;;;;;;;;;;;;;;AA2CD,SAAgB,sBAAsB,EACpC,YACA,UACA,UAC2B,EAAE;CAC7B,MAAM,CAAC,UAAU,YAAY,GAAG,SAA4C,MAAM;AAEhF,aAAW,WAAW,eAAe,OAAO,sBAC1C,QAAO,OAAO;AAEhB,SAAO;CACR,EAAC;CAEF,MAAM,YAAY,OAAwC,KAAK;AAG/D,WAAU,MAAM;AACd,OAAK,mBAAmB,WAAW,eAAe,OAAO,sBACvD,aAAY,OAAO,sBAAsB;CAE5C,GAAE,CAAC,QAAS,EAAC;CAGd,MAAM,SAAS,QAAQ,MAAM;AAC3B,OAAK,SAAU,QAAO;EAEtB,MAAM,YAAY,uBAAqB;GACrC;GACA,YAAY,aACR;IACE,SAAS,WAAW;IACpB,QAAQ,WAAW;IACnB,kBAAkB,WAAW;IAC7B,cAAc,WAAW;IACzB,qBAAqB,WAAW;GACjC;EAEN,EAAC;AAEF,YAAU,UAAU;AACpB,SAAO;CACR,GAAE,CAAC,UAAU,UAAW,EAAC;AAG1B,WAAU,MAAM;AACd,SAAO,MAAM;AACX,OAAI,UAAU,SAAS;AACrB,cAAU,QAAQ,OAAO;AACzB,cAAU,UAAU;GACrB;EACF;CACF,GAAE,CAAE,EAAC;AAEN,MAAK,OACH,wBAAO,0BAAG,YAAY,OAAQ;AAGhC,wBAAO,IAAC;EAAwB;EAAS;GAA2B;AACrE"}
+{"version":3,"file":"index.js","names":["ReplaneProvider"],"sources":["../src/root.tsx"],"sourcesContent":["/**\n * Server-side utilities for Next.js\n * Use this module in Server Components, getServerSideProps, or getStaticProps\n */\n\nimport type { ReactNode } from \"react\";\nimport { getReplaneSnapshot } from \"@replanejs/react\";\nimport { type ReplaneClientOptions } from \"@replanejs/sdk\";\nimport { ReplaneProvider } from \"@replanejs/react\";\n\n/**\n * Props for ReplaneRoot server component\n */\nexport interface ReplaneRootProps<T extends object> {\n  /**\n   * Options for Replane client.\n   * Used for both server-side fetching and client-side live updates.\n   */\n  options: ReplaneClientOptions<T>;\n  /**\n   * React children to render inside the provider\n   */\n  children: ReactNode;\n}\n\n/**\n * Server component that fetches Replane configs and provides them to the app.\n * This is the simplest way to set up Replane in Next.js App Router.\n *\n * @example Basic usage in layout.tsx\n * ```tsx\n * // app/layout.tsx\n * import { ReplaneRoot } from \"@replanejs/next\";\n *\n * export default function RootLayout({ children }) {\n *   return (\n *     <html>\n *       <body>\n *         <ReplaneRoot\n *           options={{\n *             baseUrl: process.env.NEXT_PUBLIC_REPLANE_BASE_URL!,\n *             sdkKey: process.env.NEXT_PUBLIC_REPLANE_SDK_KEY!,\n *           }}\n *         >\n *           {children}\n *         </ReplaneRoot>\n *       </body>\n *     </html>\n *   );\n * }\n * ```\n */\nexport async function ReplaneRoot<T extends object>({ options, children }: ReplaneRootProps<T>) {\n  const snapshot = await getReplaneSnapshot(options);\n\n  return (\n    <ReplaneProvider options={options} snapshot={snapshot}>\n      {children}\n    </ReplaneProvider>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,eAAsB,YAA8B,EAAE,SAAS,UAA+B,EAAE;CAC9F,MAAM,WAAW,MAAM,qBAAmB,QAAQ;AAElD,wBACE,IAACA;EAAyB;EAAmB;EAC1C;GACe;AAErB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@replanejs/next",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "Next.js SDK for Replane - feature flags and remote configuration with SSR support",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -11,11 +11,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
-    },
-    "./server": {
-      "types": "./dist/server.d.ts",
-      "import": "./dist/server.js",
-      "require": "./dist/server.cjs"
     }
   },
   "files": [
@@ -26,13 +21,13 @@
     "replane",
     "next",
     "nextjs",
-    "react",
     "feature-flags",
     "remote-config",
     "configuration",
     "sdk",
     "ssr",
-    "server-side-rendering"
+    "app-router",
+    "pages-router"
   ],
   "author": "",
   "license": "MIT",
@@ -50,16 +45,13 @@
     "react": ">=18.0.0"
   },
   "dependencies": {
-    "@replanejs/react": "^0.7.3",
-    "@replanejs/sdk": "^0.7.3"
+    "@replanejs/react": "^0.7.5",
+    "@replanejs/sdk": "^0.7.5"
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^6.9.1",
-    "@testing-library/react": "^16.3.1",
     "@types/node": "^22.19.3",
     "@types/react": "^18.2.0",
     "@types/react-dom": "^18.3.7",
-    "jsdom": "^27.3.0",
     "next": "^15.0.0",
     "react": "^18.2.0",
     "react-dom": "^18.3.1",
@@ -77,7 +69,7 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "test": "echo 'No tests yet'",
+    "test:watch": "echo 'No tests yet'"
   }
 }

package/dist/chunk-CUT6urMc.cjs

@@ -1,30 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});