@cascayd/experiment 0.3.20 → 0.3.22

package/dist/assignment.d.ts

@@ -0,0 +1,20 @@
+export type ChildVariant = {
+    id: string;
+    weight?: number;
+};
+export type WeightMap = Record<string, number>;
+export declare function buildWeights(children: ChildVariant[], weights: WeightMap | undefined): Array<{
+    id: string;
+    weight: number;
+}>;
+export declare function resolveVariant(candidate: string | null | undefined, children: Array<{
+    id: string;
+}>): string;
+/**
+ * Deterministic roll based on (experimentId + ":" + seedKey).
+ * seedKey should be stable per user, eg sessionId from cookie.
+ */
+export declare function chooseByWeightDeterministic(items: Array<{
+    id: string;
+    weight: number;
+}>, experimentId: string, seedKey: string): string;

package/dist/assignment.js

@@ -0,0 +1,56 @@
+export function buildWeights(children, weights) {
+    // Prefer server weights if present
+    if (weights && Object.keys(weights).length > 0) {
+        const subset = children
+            .map((child) => ({ id: child.id, weight: typeof weights[child.id] === 'number' ? weights[child.id] : 0 }))
+            .filter((item) => item.weight > 0);
+        if (subset.length > 0) {
+            const total = subset.reduce((sum, item) => sum + item.weight, 0) || 1;
+            return subset.map((item) => ({ id: item.id, weight: item.weight / total }));
+        }
+    }
+    // Fall back to provided per-child weights
+    const provided = children.filter((c) => typeof c.weight === 'number');
+    if (provided.length > 0) {
+        const sum = provided.reduce((acc, item) => acc + item.weight, 0) || 1;
+        return provided.map((item) => ({ id: item.id, weight: item.weight / sum }));
+    }
+    // Equal split
+    if (children.length === 0)
+        return [{ id: 'control', weight: 1 }];
+    const equal = 1 / children.length;
+    return children.map((c) => ({ id: c.id, weight: equal }));
+}
+export function resolveVariant(candidate, children) {
+    if (candidate && children.some((c) => c.id === candidate))
+        return candidate;
+    if (children.some((c) => c.id === 'control'))
+        return 'control';
+    return children[0]?.id ?? 'control';
+}
+/**
+ * Deterministic roll based on (experimentId + ":" + seedKey).
+ * seedKey should be stable per user, eg sessionId from cookie.
+ */
+export function chooseByWeightDeterministic(items, experimentId, seedKey) {
+    const total = items.reduce((sum, item) => sum + item.weight, 0) || 1;
+    const seed = `${experimentId}:${seedKey}`;
+    const roll = hashToUnit(seed) * total;
+    let acc = 0;
+    for (const item of items) {
+        acc += item.weight;
+        if (roll <= acc)
+            return item.id;
+    }
+    return items[items.length - 1]?.id || 'control';
+}
+function hashToUnit(input) {
+    // FNV-1a 32-bit hash -> [0,1)
+    let hash = 2166136261;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    // >>> 0 makes it unsigned
+    return (hash >>> 0) / 2 ** 32;
+}

package/dist/client.d.ts

@@ -1,8 +1,2 @@
-import { InitOptions, ExperimentConfigResponse, EventType, RecordOptions, VariantStatusResponse } from './types';
-export declare function initCascayd(opts: InitOptions): void;
-export declare function getVariantStatus(experimentId: string, variantId: string): Promise<VariantStatusResponse>;
-export declare function assignVariant(experimentId: string, detectedVariants?: string[], route?: string): Promise<{
-    variantId: string;
-    config: ExperimentConfigResponse;
-}>;
+import type { EventType, RecordOptions } from './types';
 export declare function record(type: EventType, opts?: RecordOptions): Promise<void>;

package/dist/client.js

@@ -1,168 +1,6 @@
-//! SSR: Imports cookie functions that use document.cookie
-import { getOrCreateSession, readVariantChoice } from './cookies.js';
-let API_KEY = '';
-let BASE_URL = 'https://ab-mvp-backend.onrender.com';
-const SDK_VERSION = '0.2.0-dev';
-export function initCascayd(opts) {
-    API_KEY = opts.apiKey;
-    const masked = API_KEY ? API_KEY.slice(0, 3) + '***' + API_KEY.slice(-3) : '(empty)';
-    // Visible init log to confirm updated SDK loaded
-    // eslint-disable-next-line no-console
-    console.log('[cascayd-sdk]', SDK_VERSION, { baseUrl: BASE_URL, apiKey: masked });
-    console.log('[cascayd-sdk] init complete', {
-        version: SDK_VERSION,
-        url: BASE_URL,
-    });
-}
-async function fetchConfig(experimentId) {
-    //! SSR: fetch works in Node 18+ but may need request context (headers, cookies) for auth
-    const res = await fetch(`${BASE_URL}/experiments/${encodeURIComponent(experimentId)}/config`);
-    if (!res.ok)
-        throw new Error(`Config load failed: ${res.status}`);
-    return (await res.json());
-}
-export async function getVariantStatus(experimentId, variantId) {
-    console.log('[cascayd-sdk] getVariantStatus', experimentId, variantId);
-    //! SSR: fetch works in Node 18+ but may need request context (headers, cookies) for auth
-    const res = await fetch(`${BASE_URL}/experiments/${encodeURIComponent(experimentId)}/variants/${encodeURIComponent(variantId)}/status`);
-    const data = (await res.json());
-    console.log('[cascayd-sdk] getVariantStatus response', data);
-    if (!res.ok) {
-        const err = new Error(`Variant status failed: ${res.status}`);
-        err.payload = data;
-        throw err;
-    }
-    return data;
-}
-// Seeded random number generator using a simple linear congruential generator
-function seededRandom(seed) {
-    // LCG parameters (same as used in many standard libraries)
-    const a = 1664525;
-    const c = 1013904223;
-    const m = Math.pow(2, 32);
-    seed = (a * seed + c) % m;
-    return seed / m;
-}
-function chooseByWeight(variants, experimentId) {
-    console.log('[cascayd-sdk] chooseByWeight called with variants:', variants);
-    const total = variants.reduce((s, v) => s + v.weight, 0);
-    console.log('[cascayd-sdk] chooseByWeight total weight:', total);
-    //! SSR: Date.now() is non-deterministic - variant will change on every render/request
-    // Create a seed based on current time (milliseconds) and experiment ID
-    // This makes it change over time while being deterministic for the same millisecond
-    const now = Date.now();
-    const seedString = `${experimentId}-${now}`;
-    // Simple hash function to convert string to number
-    let hash = 0;
-    for (let i = 0; i < seedString.length; i++) {
-        const char = seedString.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32-bit integer
-    }
-    // Use seeded random instead of Math.random()
-    const r = seededRandom(Math.abs(hash)) * total;
-    console.log('[cascayd-sdk] chooseByWeight seed:', seedString, 'hash:', Math.abs(hash), 'random value:', r, 'total:', total);
-    let acc = 0;
-    for (const v of variants) {
-        acc += v.weight;
-        console.log('[cascayd-sdk] chooseByWeight checking variant:', v.id, 'weight:', v.weight, 'acc:', acc, 'r <= acc?', r <= acc);
-        if (r <= acc) {
-            console.log('[cascayd-sdk] chooseByWeight selected:', v.id);
-            return v.id;
-        }
-    }
-    const fallback = variants[variants.length - 1]?.id ?? 'control';
-    console.log('[cascayd-sdk] chooseByWeight fallback to:', fallback);
-    return fallback;
-}
-export async function assignVariant(experimentId, detectedVariants, route) {
-    const baseStatus = await getVariantStatus(experimentId, 'control');
-    let weights = baseStatus.weights || {};
-    console.log('[cascayd-sdk] assignVariant weights received:', weights);
-    // If we have detected variants, ensure they exist in the database
-    if (detectedVariants && detectedVariants.length > 0) {
-        // Check if all detected variants exist in weights
-        const missingVariants = detectedVariants.filter(vid => !(vid in weights));
-        if (missingVariants.length > 0) {
-            console.log('[cascayd-sdk] assignVariant: Missing variants detected, ensuring they exist:', missingVariants);
-            try {
-                // Call ensure endpoint to create missing variants
-                const ensureBody = {
-                    experiment_id: experimentId,
-                    variant_ids: detectedVariants,
-                    //! SSR: window.location.pathname is browser-only, route should be passed explicitly on server
-                    route: route || (typeof window !== 'undefined' ? window.location.pathname : "/"),
-                };
-                //! SSR: fetch works in Node 18+ but may need request context (headers, cookies) for auth
-                const ensureRes = await fetch(`${BASE_URL}/experiments/ensure`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Authorization: `Bearer ${API_KEY}`,
-                    },
-                    body: JSON.stringify(ensureBody),
-                });
-                if (ensureRes.ok) {
-                    console.log('[cascayd-sdk] assignVariant: Successfully ensured variants exist');
-                    // Fetch status again to get updated weights
-                    const updatedStatus = await getVariantStatus(experimentId, 'control');
-                    weights = updatedStatus.weights || {};
-                    console.log('[cascayd-sdk] assignVariant: Updated weights after ensuring:', weights);
-                }
-                else {
-                    console.warn('[cascayd-sdk] assignVariant: Failed to ensure variants, using fallback weights');
-                }
-            }
-            catch (error) {
-                console.error('[cascayd-sdk] assignVariant: Error ensuring variants:', error);
-            }
-        }
-    }
-    // If weights only has control and we have detected variants, use detected variants with equal weights (fallback)
-    if (Object.keys(weights).length === 1 && weights.control === 1 && detectedVariants && detectedVariants.length > 1) {
-        console.log('[cascayd-sdk] assignVariant: Only control in weights, using detected variants as fallback:', detectedVariants);
-        const equalWeight = 1 / detectedVariants.length;
-        weights = {};
-        detectedVariants.forEach(vid => {
-            weights[vid] = equalWeight;
-        });
-        console.log('[cascayd-sdk] assignVariant: Created equal weights from detected variants:', weights);
-    }
-    console.log('[cascayd-sdk] assignVariant weights entries:', Object.entries(weights));
-    const variants = Object.entries(weights).map(([id, weight]) => ({ id, weight }));
-    console.log('[cascayd-sdk] assignVariant variants array:', variants);
-    let candidate = chooseByWeight(variants.length > 0 ? variants : baseStatusToVariants(baseStatus), experimentId);
-    console.log('[cascayd-sdk] assignVariant candidate selected:', candidate);
-    let finalStatus = null;
-    if (candidate) {
-        try {
-            finalStatus = await getVariantStatus(experimentId, candidate);
-        }
-        catch (error) {
-            console.error('[cascayd-sdk] getVariantStatus failed', { experimentId, candidate, error });
-            const weights = error?.payload?.weights;
-            if (weights) {
-                console.log('[cascayd-sdk] getVariantStatus failed weights', weights);
-            }
-            // swallow and fall back to candidate
-        }
-    }
-    const serving = finalStatus?.serving_variant_id || candidate || 'control';
-    const config = {
-        experiment_id: baseStatus.experiment_id,
-        variants: variants.length > 0 ? variants : baseStatusToVariants(baseStatus),
-    };
-    return { variantId: serving, config };
-}
-function baseStatusToVariants(status) {
-    const entries = Object.entries(status.weights || {});
-    if (entries.length === 0) {
-        return [{ id: 'control', weight: 1 }];
-    }
-    return entries.map(([id, weight]) => ({ id, weight }));
-}
+import { getOrCreateSession, readVariantChoice } from './cookies';
+import { BASE_URL } from './settings';
 export async function record(type, opts = {}) {
-    //! SSR: getOrCreateSession uses document.cookie
     const sessionId = getOrCreateSession();
     const body = {
         type,
@@ -170,47 +8,24 @@ export async function record(type, opts = {}) {
     };
     if (opts.experimentId) {
         body.experiment_id = opts.experimentId;
-        //! SSR: readVariantChoice uses document.cookie
         const fromCookie = readVariantChoice(opts.experimentId);
         const variantId = opts.variantId || fromCookie;
-        if (variantId) {
+        if (variantId)
             body.variant_id = variantId;
-        }
-        else if (opts.experimentId) {
-            console.warn(`[cascayd-sdk] No variant_id found for experiment ${opts.experimentId}`);
-        }
     }
     if (typeof opts.value === 'number')
         body.value = opts.value;
     if (opts.route) {
         body.route = opts.route;
-        //! SSR: window.location.pathname is browser-only, route should be passed explicitly on server
     }
-    else if (typeof window !== 'undefined' && window.location) {
+    else if (typeof window !== 'undefined') {
         body.route = window.location.pathname;
     }
-    //! SSR: fetch works in Node 18+ but may need request context (headers, cookies) for auth
     const res = await fetch(`${BASE_URL}/events`, {
         method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${API_KEY}`,
-        },
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
     });
     if (!res.ok)
         throw new Error(`Record failed: ${res.status}`);
 }
-//! SSR: Exposing to window object is browser-only, should be conditional or removed for SSR
-// Expose functions to window for browser compatibility
-if (typeof window !== 'undefined') {
-    ;
-    window.initCascayd = initCascayd;
-    window.assignVariant = assignVariant;
-    window.record = record;
-    window.Cascayd = {
-        initCascayd,
-        assignVariant,
-        record,
-    };
-}

package/dist/http.d.ts

@@ -0,0 +1,2 @@
+import type { VariantStatusResponse } from './types';
+export declare function getVariantStatus(experimentId: string, variantId: string): Promise<VariantStatusResponse>;

package/dist/http.js

@@ -0,0 +1,11 @@
+import { BASE_URL } from './settings';
+export async function getVariantStatus(experimentId, variantId) {
+    const res = await fetch(`${BASE_URL}/experiments/${encodeURIComponent(experimentId)}/variants/${encodeURIComponent(variantId)}/status`);
+    const data = (await res.json());
+    if (!res.ok) {
+        const err = new Error(`Variant status failed: ${res.status}`);
+        err.payload = data;
+        throw err;
+    }
+    return data;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { initCascayd, record, assignVariant } from './client';
 export { Experiment } from './react/Experiment';
 export { Variant } from './react/Variant';
-export type { InitOptions, EventType, RecordOptions } from './types';
+export { record } from './client';
+export type * from './types';

package/dist/index.js

@@ -1,3 +1,3 @@
-export { initCascayd, record, assignVariant } from './client';
 export { Experiment } from './react/Experiment';
 export { Variant } from './react/Variant';
+export { record } from './client';

package/dist/next-app/Experiment.d.ts

@@ -0,0 +1,5 @@
+export type ExperimentProps = {
+    id: string;
+    children: React.ReactNode;
+};
+export declare function Experiment({ id, children }: ExperimentProps): Promise<import("react/jsx-runtime").JSX.Element | null>;

package/dist/next-app/Experiment.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { cookies } from 'next/headers';
+import { getVariantStatus } from '../http';
+import { buildWeights, chooseByWeightDeterministic, resolveVariant } from '../assignment';
+import { ImpressionClient } from './ImpressionClient';
+function getVariantCookieKey(experimentId) {
+    return `cascayd:${experimentId}`;
+}
+function getOrCreateSessionId(store) {
+    const key = 'cascayd:session';
+    const existing = store.get(key)?.value;
+    if (existing)
+        return existing;
+    const id = typeof crypto !== 'undefined' && 'randomUUID' in crypto
+        ? crypto.randomUUID()
+        : `${Date.now()}-${Math.random()}`;
+    store.set(key, id, { path: '/', sameSite: 'lax' });
+    return id;
+}
+export async function Experiment({ id, children }) {
+    const store = cookies();
+    // Collect <Variant> children (with optional weights)
+    const childrenArray = [];
+    for (const child of [].concat(children)) {
+        if (!child || child.type?.displayName !== 'CascaydVariant')
+            continue;
+        childrenArray.push({ id: child.props.id, weight: child.props.weight, element: child });
+    }
+    const sessionId = getOrCreateSessionId(store);
+    const existing = store.get(getVariantCookieKey(id))?.value ?? null;
+    let chosen = null;
+    // If cookie exists, try to respect it (and resolve serving variant)
+    if (existing) {
+        try {
+            const status = await getVariantStatus(id, existing);
+            chosen = resolveVariant(status.serving_variant_id || existing, childrenArray);
+        }
+        catch {
+            // fall through to fresh assignment
+        }
+    }
+    // Fresh assignment
+    if (!chosen) {
+        const baseStatus = await getVariantStatus(id, 'control');
+        const weighted = buildWeights(childrenArray, baseStatus.weights);
+        const candidate = chooseByWeightDeterministic(weighted, id, sessionId);
+        let finalVariant = candidate;
+        try {
+            const status = await getVariantStatus(id, candidate);
+            finalVariant = status.serving_variant_id || candidate;
+        }
+        catch {
+            // keep candidate
+        }
+        chosen = resolveVariant(finalVariant, childrenArray);
+    }
+    // Persist variant choice cookie
+    store.set(getVariantCookieKey(id), chosen, { path: '/', sameSite: 'lax' });
+    // Render chosen variant immediately (SSR)
+    const match = childrenArray.find((c) => c.id === chosen) ?? childrenArray[0];
+    if (!match)
+        return null;
+    return (_jsxs(_Fragment, { children: [match.element, _jsx(ImpressionClient, { experimentId: id, variantId: chosen })] }));
+}

package/dist/next-app/ImpressionClient.d.ts

@@ -0,0 +1,4 @@
+export declare function ImpressionClient(props: {
+    experimentId: string;
+    variantId: string;
+}): null;

package/dist/next-app/ImpressionClient.js

@@ -0,0 +1,14 @@
+'use client';
+import { useEffect } from 'react';
+import { record } from '../client';
+const sent = new Set();
+export function ImpressionClient(props) {
+    useEffect(() => {
+        const key = `${props.experimentId}:${props.variantId}`;
+        if (sent.has(key))
+            return;
+        sent.add(key);
+        void record('impression', { experimentId: props.experimentId, variantId: props.variantId });
+    }, [props.experimentId, props.variantId]);
+    return null;
+}

package/dist/next-app/Variant.d.ts

@@ -0,0 +1,9 @@
+export type VariantProps = {
+    id: string;
+    weight?: number;
+    children?: React.ReactNode;
+};
+export declare function Variant({ children }: VariantProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Variant {
+    var displayName: string;
+}

package/dist/next-app/Variant.js

@@ -0,0 +1,5 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+export function Variant({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+Variant.displayName = 'CascaydVariant';

package/dist/next-app/index.d.ts

@@ -0,0 +1,2 @@
+export { Experiment } from './Experiment';
+export { Variant } from './Variant';

package/dist/next-app/index.js

@@ -0,0 +1,2 @@
+export { Experiment } from './Experiment';
+export { Variant } from './Variant';

package/dist/react/Experiment.js

@@ -1,14 +1,12 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
-//! SSR: Imports client functions that use fetch without request context
-import { getVariantStatus, record } from '../client';
-//! SSR: Imports cookie functions that use document.cookie
+import { getVariantStatus } from '../http';
+import { record } from '../client';
 import { getOrCreateSession, persistVariantChoice, readVariantChoice } from '../cookies';
+import { buildWeights, chooseByWeightDeterministic, resolveVariant } from '../assignment';
 const sentImpressions = new Set();
 export function Experiment({ id, children }) {
-    //! SSR: Initial null state causes hydration mismatch - server renders null, client renders variant
     const [active, setActive] = useState(null);
     const hasRunRef = useRef(false);
-    // collect variant children (with optional weights)
     const childrenArray = useMemo(() => {
         const arr = [];
         for (const child of [].concat(children)) {
@@ -18,134 +16,69 @@ export function Experiment({ id, children }) {
         }
         return arr;
     }, [children]);
-    //! SSR: useEffect doesn't run during SSR, variant assignment happens only on client
     useEffect(() => {
         if (hasRunRef.current)
             return;
         hasRunRef.current = true;
-        //! SSR: readVariantChoice uses document.cookie
-        const existing = readVariantChoice(id);
         let cancelled = false;
-        //! SSR: getOrCreateSession uses document.cookie
-        getOrCreateSession();
+        const existing = readVariantChoice(id);
+        // Create or read a stable session id first
+        const sessionId = getOrCreateSession();
         void (async () => {
             try {
                 if (existing) {
-                    console.log('[cascayd-sdk] fetching variant status', {
-                        experimentId: id,
-                        variantId: existing,
-                    });
-                    console.log('[cascayd-sdk] current children', childrenArray.map((c) => c.id));
                     try {
-                        //! SSR: getVariantStatus uses fetch without request context
                         const status = await getVariantStatus(id, existing);
                         if (cancelled)
                             return;
-                        console.log('[cascayd-sdk] received variant status', status);
-                        logWeights('[cascayd-sdk] existing variant weights', status.weights);
                         const serving = resolveVariant(status.serving_variant_id || existing, childrenArray);
                         applyAssignment(id, serving, setActive);
                         sendImpression(id, serving);
                         return;
                     }
-                    catch (error) {
-                        console.error('[cascayd-sdk] existing variant status fetch failed', {
-                            experimentId: id,
-                            variantId: existing,
-                            error,
-                        });
-                        logWeights('[cascayd-sdk] existing variant weights (error path)', errorWeights(error));
+                    catch {
+                        // fall through to base assignment
                     }
                 }
-                console.log('[cascayd-sdk] fetching base status', { experimentId: id, variantId: 'control' });
-                //! SSR: getVariantStatus uses fetch without request context
                 const baseStatus = await getVariantStatus(id, 'control');
                 if (cancelled)
                     return;
-                console.log('[cascayd-sdk] received base status', baseStatus);
-                logWeights('[cascayd-sdk] base weights', baseStatus.weights);
                 const weighted = buildWeights(childrenArray, baseStatus.weights);
-                console.log('[cascayd-sdk] child weights entries', weighted);
-                logWeights('[cascayd-sdk] computed child weights', Object.fromEntries(weighted.map((w) => [w.id, w.weight])));
-                const candidate = chooseByWeight(weighted, id);
+                const candidate = chooseByWeightDeterministic(weighted, id, sessionId);
                 let finalVariant = candidate;
-                if (candidate) {
-                    console.log('[cascayd-sdk] verifying candidate status', {
-                        experimentId: id,
-                        variantId: candidate,
-                    });
-                    try {
-                        //! SSR: getVariantStatus uses fetch without request context
-                        const status = await getVariantStatus(id, candidate);
-                        if (cancelled)
-                            return;
-                        console.log('[cascayd-sdk] received candidate status', status);
-                        logWeights('[cascayd-sdk] candidate weights', status.weights);
-                        finalVariant = status.serving_variant_id || candidate;
-                    }
-                    catch (error) {
-                        console.error('[cascayd-sdk] candidate status fetch failed, using fallback', {
-                            experimentId: id,
-                            variantId: candidate,
-                            error,
-                        });
-                        logWeights('[cascayd-sdk] candidate weights (error path)', errorWeights(error));
-                    }
+                try {
+                    const status = await getVariantStatus(id, candidate);
+                    if (cancelled)
+                        return;
+                    finalVariant = status.serving_variant_id || candidate;
+                }
+                catch {
+                    // keep candidate
                 }
                 const serving = resolveVariant(finalVariant, childrenArray);
                 applyAssignment(id, serving, setActive);
                 sendImpression(id, serving);
             }
             catch (err) {
-                console.error('[cascayd-sdk] variant assignment error, using fallback assignment', err);
-                console.log('[cascayd-sdk] fallback children', childrenArray);
-                const fallbackVariant = fallbackAssign(childrenArray, id);
+                // last-ditch fallback, deterministic equal weight using session id
+                const weighted = buildWeights(childrenArray, undefined);
+                const chosen = chooseByWeightDeterministic(weighted, id, sessionId);
                 if (cancelled)
                     return;
-                console.log('[cascayd-sdk] fallback assignment chosen', fallbackVariant);
-                applyAssignment(id, fallbackVariant, setActive);
-                sendImpression(id, fallbackVariant);
+                applyAssignment(id, chosen, setActive);
+                sendImpression(id, chosen);
             }
         })();
         return () => {
             cancelled = true;
         };
     }, [id, childrenArray]);
-    //! SSR: Returning null on server causes hydration mismatch - server renders null, client renders variant
     if (!active)
         return null;
     const match = childrenArray.find((c) => c.id === active);
     return match ? match.element : null;
 }
-function buildWeights(children, weights) {
-    if (weights && Object.keys(weights).length > 0) {
-        const subset = children
-            .map((child) => ({ id: child.id, weight: typeof weights[child.id] === 'number' ? weights[child.id] : 0 }))
-            .filter((item) => item.weight > 0);
-        if (subset.length > 0) {
-            const total = subset.reduce((sum, item) => sum + item.weight, 0) || 1;
-            return subset.map((item) => ({ id: item.id, weight: item.weight / total }));
-        }
-    }
-    const provided = children.filter((c) => typeof c.weight === 'number');
-    if (provided.length > 0) {
-        const sum = provided.reduce((acc, item) => acc + item.weight, 0) || 1;
-        return provided.map((item) => ({ id: item.id, weight: item.weight / sum }));
-    }
-    if (children.length === 0)
-        return [{ id: 'control', weight: 1 }];
-    const equal = 1 / children.length;
-    return children.map((c) => ({ id: c.id, weight: equal }));
-}
-function resolveVariant(candidate, children) {
-    if (candidate && children.some((c) => c.id === candidate))
-        return candidate;
-    if (children.some((c) => c.id === 'control'))
-        return 'control';
-    return children[0]?.id ?? 'control';
-}
 function applyAssignment(experimentId, variantId, setActive) {
-    //! SSR: persistVariantChoice uses document.cookie
     persistVariantChoice(experimentId, variantId);
     setActive(variantId);
 }
@@ -155,71 +88,5 @@ function sendImpression(experimentId, variantId) {
     if (sentImpressions.has(`${experimentId}:${variantId}`))
         return;
     sentImpressions.add(`${experimentId}:${variantId}`);
-    //! SSR: record uses fetch and cookies without request context
     void record('impression', { experimentId, variantId });
 }
-function fallbackAssign(children, experimentId) {
-    console.log('[cascayd-sdk] fallback assign start', children);
-    const weighted = buildWeights(children, undefined);
-    console.log('[cascayd-sdk] fallback weighted', weighted);
-    const chosen = chooseByWeight(weighted, experimentId);
-    console.log('[cascayd-sdk] fallback chosen', chosen);
-    return chosen;
-}
-// Seeded random number generator using a simple linear congruential generator
-function seededRandom(seed) {
-    const a = 1664525;
-    const c = 1013904223;
-    const m = Math.pow(2, 32);
-    seed = (a * seed + c) % m;
-    return seed / m;
-}
-function chooseByWeight(items, experimentId) {
-    console.log('[cascayd-sdk] choosing by weight', items);
-    const total = items.reduce((sum, item) => sum + item.weight, 0) || 1;
-    //! SSR: Date.now() is non-deterministic - variant will change on every render/request
-    // Create a seed based on current time (milliseconds) and experiment ID
-    const now = Date.now();
-    const seedString = `${experimentId}-${now}`;
-    // Simple hash function to convert string to number
-    let hash = 0;
-    for (let i = 0; i < seedString.length; i++) {
-        const char = seedString.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // Convert to 32-bit integer
-    }
-    // Use seeded random instead of Math.random()
-    const roll = seededRandom(Math.abs(hash)) * total;
-    console.log('[cascayd-sdk] total weight', total, 'roll', roll, 'seed', seedString);
-    let acc = 0;
-    for (const item of items) {
-        acc += item.weight;
-        console.log('[cascayd-sdk] accumulate', { item: item.id, acc });
-        if (roll <= acc)
-            return item.id;
-    }
-    return items[items.length - 1]?.id || 'control';
-}
-function logWeights(label, weights) {
-    if (!weights || Object.keys(weights).length === 0) {
-        console.log(label, '(none)');
-        return;
-    }
-    console.log(label, weights);
-    console.table(Object.entries(weights).map(([variantId, weight]) => ({
-        variantId,
-        weight: Number(weight.toFixed(4)),
-        percentage: `${(weight * 100).toFixed(2)}%`,
-    })));
-}
-function errorWeights(error) {
-    if (!error)
-        return undefined;
-    if (typeof error === 'object' && error && 'weights' in error) {
-        const weights = error.weights;
-        if (weights && typeof weights === 'object') {
-            return weights;
-        }
-    }
-    return undefined;
-}

package/dist/settings.d.ts

@@ -0,0 +1 @@
+export declare const BASE_URL = "https://ab-mvp-backend-bnqr.onrender.com";

package/dist/settings.js

@@ -0,0 +1,2 @@
+// settings.ts
+export const BASE_URL = 'https://ab-mvp-backend-bnqr.onrender.com';

package/dist/types.d.ts

@@ -1,6 +1,3 @@
-export type InitOptions = {
-    apiKey: string;
-};
 export type VariantConfig = {
     id: string;
     weight: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascayd/experiment",
-  "version": "0.3.20",
+  "version": "0.3.22",
   "description": "A lightweight A/B testing SDK for React applications with server-side analytics integration",
   "keywords": [
     "ab-testing",
@@ -25,9 +25,15 @@
       "default": "./dist/index.js"
     },
     "./react": {
-      "types": "./dist/react/Experiment.d.ts",
-      "import": "./dist/react/Experiment.js",
-      "default": "./dist/react/Experiment.js"
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js",
+      "default": "./dist/react/index.js"
+    },
+    "./next-app": {
+      "types": "./dist/next-app/index.d.ts",
+      "import": "./dist/next-app/index.js",
+      "react-server": "./dist/next-app/index.js",
+      "default": "./dist/next-app/index.js"
     },
     "./package.json": "./package.json"
   },