@variantlab/next 0.1.0

package/dist/client/hooks.d.cts

@@ -0,0 +1,62 @@
+import { ExperimentsConfig, VariantContext, Experiment } from '@variantlab/core';
+export { UseExperimentResult, Variant, VariantErrorBoundary, VariantErrorBoundaryProps, VariantLabContext, VariantProps, VariantValue, VariantValueProps, useExperiment, useRouteExperiments, useSetVariant, useVariant, useVariantLabEngine, useVariantValue } from '@variantlab/react';
+import { ReactNode } from 'react';
+
+/**
+ * Shared types for `@variantlab/next`.
+ *
+ * Kept in a single tiny file so every entrypoint (server barrel,
+ * app-router subpath, pages-router subpath, client provider) can
+ * import without pulling in code.
+ */
+
+/**
+ * Props accepted by the Next `VariantLabProvider` Client Component.
+ */
+interface VariantLabProviderProps {
+    /** Validated `ExperimentsConfig` or a raw JSON module import. */
+    readonly config: unknown | ExperimentsConfig;
+    /** Runtime context (userId, locale, platform, …) applied before first render. */
+    readonly initialContext?: VariantContext;
+    /**
+     * Assignments computed on the server. Seeded into the engine cache so
+     * the first `getVariant` call on the client returns the same variant
+     * that was server-rendered, without re-evaluating targeting.
+     */
+    readonly initialVariants?: Readonly<Record<string, string>>;
+    readonly children?: ReactNode;
+}
+
+/**
+ * Named `NextVariantLabProvider` internally to avoid colliding with the
+ * re-export name `VariantLabProvider` once tsup bundles
+ * `@variantlab/react` inline. Exposed publicly as `VariantLabProvider`
+ * via the barrel in `./hooks.ts`.
+ */
+declare function NextVariantLabProvider({ config, initialContext, initialVariants, children, }: VariantLabProviderProps): ReactNode;
+
+/**
+ * Client-side hooks + components for `@variantlab/next`.
+ *
+ * Re-exports the public surface of `@variantlab/react` (hooks +
+ * components) plus a Next-specific `useNextRouteExperiments()` that
+ * reads `usePathname()` from `next/navigation` so consumers don't
+ * have to thread the route through by hand.
+ *
+ * NOTE: `@variantlab/react` is bundled *into* this file (not marked
+ * external) so the symbols have local bindings in the emitted JS.
+ * Next's client-reference loader cannot follow `export { X } from
+ * "<workspace-pkg>"` chains across `transpilePackages` boundaries
+ * in dev mode, so we eliminate the boundary entirely for the client
+ * entrypoint. The server entrypoint still treats `@variantlab/react`
+ * as external because it never crosses a client boundary.
+ */
+
+/**
+ * Like `useRouteExperiments(route)`, but reads the current route from
+ * `next/navigation`'s `usePathname()` so you never need to pass it
+ * explicitly.
+ */
+declare function useNextRouteExperiments(): readonly Experiment[];
+
+export { NextVariantLabProvider as VariantLabProvider, type VariantLabProviderProps, useNextRouteExperiments };

package/dist/client/hooks.d.ts

@@ -0,0 +1,62 @@
+import { ExperimentsConfig, VariantContext, Experiment } from '@variantlab/core';
+export { UseExperimentResult, Variant, VariantErrorBoundary, VariantErrorBoundaryProps, VariantLabContext, VariantProps, VariantValue, VariantValueProps, useExperiment, useRouteExperiments, useSetVariant, useVariant, useVariantLabEngine, useVariantValue } from '@variantlab/react';
+import { ReactNode } from 'react';
+
+/**
+ * Shared types for `@variantlab/next`.
+ *
+ * Kept in a single tiny file so every entrypoint (server barrel,
+ * app-router subpath, pages-router subpath, client provider) can
+ * import without pulling in code.
+ */
+
+/**
+ * Props accepted by the Next `VariantLabProvider` Client Component.
+ */
+interface VariantLabProviderProps {
+    /** Validated `ExperimentsConfig` or a raw JSON module import. */
+    readonly config: unknown | ExperimentsConfig;
+    /** Runtime context (userId, locale, platform, …) applied before first render. */
+    readonly initialContext?: VariantContext;
+    /**
+     * Assignments computed on the server. Seeded into the engine cache so
+     * the first `getVariant` call on the client returns the same variant
+     * that was server-rendered, without re-evaluating targeting.
+     */
+    readonly initialVariants?: Readonly<Record<string, string>>;
+    readonly children?: ReactNode;
+}
+
+/**
+ * Named `NextVariantLabProvider` internally to avoid colliding with the
+ * re-export name `VariantLabProvider` once tsup bundles
+ * `@variantlab/react` inline. Exposed publicly as `VariantLabProvider`
+ * via the barrel in `./hooks.ts`.
+ */
+declare function NextVariantLabProvider({ config, initialContext, initialVariants, children, }: VariantLabProviderProps): ReactNode;
+
+/**
+ * Client-side hooks + components for `@variantlab/next`.
+ *
+ * Re-exports the public surface of `@variantlab/react` (hooks +
+ * components) plus a Next-specific `useNextRouteExperiments()` that
+ * reads `usePathname()` from `next/navigation` so consumers don't
+ * have to thread the route through by hand.
+ *
+ * NOTE: `@variantlab/react` is bundled *into* this file (not marked
+ * external) so the symbols have local bindings in the emitted JS.
+ * Next's client-reference loader cannot follow `export { X } from
+ * "<workspace-pkg>"` chains across `transpilePackages` boundaries
+ * in dev mode, so we eliminate the boundary entirely for the client
+ * entrypoint. The server entrypoint still treats `@variantlab/react`
+ * as external because it never crosses a client boundary.
+ */
+
+/**
+ * Like `useRouteExperiments(route)`, but reads the current route from
+ * `next/navigation`'s `usePathname()` so you never need to pass it
+ * explicitly.
+ */
+declare function useNextRouteExperiments(): readonly Experiment[];
+
+export { NextVariantLabProvider as VariantLabProvider, type VariantLabProviderProps, useNextRouteExperiments };

package/dist/client/hooks.js

@@ -0,0 +1,178 @@
+"use client";
+import { createContext, Component, useContext, useCallback, useSyncExternalStore, useRef, useMemo, useLayoutEffect } from 'react';
+import { jsx } from 'react/jsx-runtime';
+import { usePathname } from 'next/navigation';
+import { createEngine } from '@variantlab/core';
+
+var VariantLabContext = createContext(null);
+function VariantLabProvider({
+  engine,
+  initialContext,
+  children
+}) {
+  const value = useMemo(() => engine, [engine]);
+  const appliedRef = useRef(null);
+  useLayoutEffect(() => {
+    if (initialContext === void 0) return;
+    const prev = appliedRef.current;
+    if (prev !== null && prev.engine === engine && prev.ctx === initialContext) {
+      return;
+    }
+    engine.updateContext(initialContext);
+    appliedRef.current = { engine, ctx: initialContext };
+  }, [engine, initialContext]);
+  return /* @__PURE__ */ jsx(VariantLabContext.Provider, { value, children });
+}
+var VariantErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, _info) {
+    const engine = this.context;
+    if (engine !== null) {
+      try {
+        engine.reportCrash(this.props.experimentId, error);
+      } catch {
+      }
+    }
+  }
+  componentDidUpdate(prevProps) {
+    if (this.state.error !== null && prevProps.children !== this.props.children) {
+      this.setState({ error: null });
+    }
+  }
+  render() {
+    const { error } = this.state;
+    if (error !== null) {
+      const { fallback } = this.props;
+      if (typeof fallback === "function") return fallback(error);
+      return fallback ?? null;
+    }
+    return this.props.children;
+  }
+};
+VariantErrorBoundary.contextType = VariantLabContext;
+function useVariantLabEngine() {
+  const engine = useContext(VariantLabContext);
+  if (engine === null) {
+    throw new Error("useVariantLabEngine: no <VariantLabProvider> found above this component.");
+  }
+  return engine;
+}
+function useVariant(experimentId) {
+  const engine = useVariantLabEngine();
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      return engine.subscribe((event) => {
+        if (shouldNotify(event, experimentId)) onStoreChange();
+      });
+    },
+    [engine, experimentId]
+  );
+  const getSnapshot = useCallback(
+    () => engine.getVariant(experimentId),
+    [engine, experimentId]
+  );
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+function shouldNotify(event, experimentId) {
+  switch (event.type) {
+    case "configLoaded":
+    case "contextUpdated":
+      return true;
+    case "variantChanged":
+    case "rollback":
+    case "assignment":
+      return event.experimentId === experimentId;
+    default:
+      return false;
+  }
+}
+function Variant({ experimentId, children, fallback }) {
+  const active = useVariant(experimentId);
+  const node = children[active];
+  if (node !== void 0) return node;
+  return fallback ?? null;
+}
+function useVariantValue(experimentId) {
+  const engine = useVariantLabEngine();
+  useVariant(experimentId);
+  return engine.getVariantValue(experimentId);
+}
+function VariantValue({
+  experimentId,
+  children
+}) {
+  const value = useVariantValue(experimentId);
+  return children(value);
+}
+function useExperiment(experimentId) {
+  const engine = useVariantLabEngine();
+  const variant = useVariant(experimentId);
+  const value = engine.getVariantValue(experimentId);
+  const track = useCallback((_eventName, _properties) => {
+  }, []);
+  return { variant, value, track };
+}
+function useRouteExperiments(route) {
+  const engine = useVariantLabEngine();
+  const cacheRef = useRef(null);
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      return engine.subscribe((event) => {
+        if (event.type === "configLoaded" || event.type === "contextUpdated") {
+          cacheRef.current = null;
+          onStoreChange();
+        }
+      });
+    },
+    [engine]
+  );
+  const getSnapshot = useCallback(() => {
+    const cached = cacheRef.current;
+    if (cached !== null && cached.route === route) return cached.snapshot;
+    const snapshot = engine.getExperiments(route);
+    cacheRef.current = { route, snapshot };
+    return snapshot;
+  }, [engine, route]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+function useSetVariant() {
+  const engine = useVariantLabEngine();
+  return useCallback(
+    (experimentId, variantId) => {
+      engine.setVariant(experimentId, variantId);
+    },
+    [engine]
+  );
+}
+function NextVariantLabProvider({
+  config,
+  initialContext,
+  initialVariants,
+  children
+}) {
+  const engine = useMemo(
+    () => createEngine(config, {
+      ...initialContext !== void 0 ? { context: initialContext } : {},
+      ...initialVariants !== void 0 ? { initialAssignments: initialVariants } : {}
+    }),
+    // Stable JSON module → stable identity → stable engine.
+    [config, initialContext, initialVariants]
+  );
+  return /* @__PURE__ */ jsx(VariantLabProvider, { engine, children });
+}
+
+// src/client/hooks.ts
+function useNextRouteExperiments() {
+  const pathname = usePathname();
+  return useRouteExperiments(pathname ?? void 0);
+}
+
+export { Variant, VariantErrorBoundary, VariantLabContext, NextVariantLabProvider as VariantLabProvider, VariantValue, useExperiment, useNextRouteExperiments, useRouteExperiments, useSetVariant, useVariant, useVariantLabEngine, useVariantValue };
+//# sourceMappingURL=hooks.js.map
+//# sourceMappingURL=hooks.js.map

package/dist/client/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../react/src/context.tsx","../../../react/src/components/error-boundary.tsx","../../../react/src/hooks/use-variant-lab-engine.ts","../../../react/src/hooks/use-variant.ts","../../../react/src/components/variant.tsx","../../../react/src/hooks/use-variant-value.ts","../../../react/src/components/variant-value.tsx","../../../react/src/hooks/use-experiment.ts","../../../react/src/hooks/use-route-experiments.ts","../../../react/src/hooks/use-set-variant.ts","../../src/client/provider.tsx","../../src/client/hooks.ts"],"names":["useCallback","useRef","useSyncExternalStore","useMemo","jsx"],"mappings":"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","file":"hooks.js","sourcesContent":["/**\n * React context and provider for variantlab.\n *\n * The provider is a thin wrapper that hands a pre-built `VariantEngine`\n * to descendants via React context. It intentionally does NOT own the\n * engine: callers construct it via `createEngine(...)` and pass it in.\n * That keeps the adapter testable (swap in a mock engine), SSR-safe\n * (server code can build an engine before render), and free of\n * lifecycle surprises — unmounting the provider never disposes the\n * engine because the provider didn't create it.\n *\n * `initialContext`, when supplied, is applied via `useLayoutEffect`\n * before the first browser paint. We use a ref to guard against\n * repeated application on re-renders so the engine cache is only\n * busted when the caller actually swaps engines.\n */\n\nimport type { VariantContext, VariantEngine } from \"@variantlab/core\";\nimport { createContext, type ReactNode, useLayoutEffect, useMemo, useRef } from \"react\";\n\n/** The raw context value. `null` until a provider wraps the tree. */\nexport const VariantLabContext = createContext<VariantEngine | null>(null);\n\nexport interface VariantLabProviderProps {\n  /** A pre-constructed engine from `createEngine(...)`. */\n  readonly engine: VariantEngine;\n  /** Optional runtime context applied once on mount. */\n  readonly initialContext?: VariantContext;\n  readonly children?: ReactNode;\n}\n\n/**\n * Wraps descendants so the hooks in this package can locate the engine.\n *\n * The value handed to `Context.Provider` is memoized on `engine` alone\n * so that unrelated parent re-renders don't force a new reference\n * (which would cascade through every `useVariant` consumer).\n */\nexport function VariantLabProvider({\n  engine,\n  initialContext,\n  children,\n}: VariantLabProviderProps): ReactNode {\n  // Stable context value: only changes when the engine itself changes.\n  const value = useMemo(() => engine, [engine]);\n\n  // Track which (engine, initialContext) pair we've already applied so\n  // re-renders don't re-invoke updateContext (which would clear the\n  // engine cache and cause unnecessary reassignment events).\n  const appliedRef = useRef<{\n    readonly engine: VariantEngine;\n    readonly ctx: VariantContext | undefined;\n  } | null>(null);\n\n  useLayoutEffect(() => {\n    if (initialContext === undefined) return;\n    const prev = appliedRef.current;\n    if (prev !== null && prev.engine === engine && prev.ctx === initialContext) {\n      return;\n    }\n    engine.updateContext(initialContext);\n    appliedRef.current = { engine, ctx: initialContext };\n  }, [engine, initialContext]);\n\n  return <VariantLabContext.Provider value={value}>{children}</VariantLabContext.Provider>;\n}\n","/**\n * `<VariantErrorBoundary>` — crash insulation for experiment render trees.\n *\n * Wraps a variant's subtree in a class-based error boundary (the only\n * remaining legitimate use of class components in modern React). When\n * a child throws, it:\n *\n *   1. reports the crash to the engine via `engine.reportCrash(id, err)`,\n *      which feeds the rollback counter defined in `config-format.md`;\n *   2. renders `fallback` (or `null`) for the rest of the current\n *      commit cycle;\n *   3. resets itself so the next render can try again with the new\n *      variant (likely the rolled-back default after N crashes).\n *\n * The engine lookup goes through `VariantLabContext` rather than a\n * prop so the ergonomics match the hook-first API. `contextType` on\n * the class makes the context value available as `this.context` in\n * `componentDidCatch`.\n */\n\nimport type { VariantEngine } from \"@variantlab/core\";\nimport { Component, type ErrorInfo, type ReactNode } from \"react\";\nimport { VariantLabContext } from \"../context.js\";\n\nexport interface VariantErrorBoundaryProps {\n  readonly experimentId: string;\n  readonly fallback?: ReactNode | ((error: Error) => ReactNode);\n  readonly children: ReactNode;\n}\n\ninterface VariantErrorBoundaryState {\n  readonly error: Error | null;\n}\n\nexport class VariantErrorBoundary extends Component<\n  VariantErrorBoundaryProps,\n  VariantErrorBoundaryState\n> {\n  static override contextType = VariantLabContext;\n  declare context: VariantEngine | null;\n  override state: VariantErrorBoundaryState = { error: null };\n\n  static getDerivedStateFromError(error: Error): VariantErrorBoundaryState {\n    return { error };\n  }\n\n  override componentDidCatch(error: Error, _info: ErrorInfo): void {\n    const engine = this.context;\n    if (engine !== null) {\n      try {\n        engine.reportCrash(this.props.experimentId, error);\n      } catch {\n        // Swallow crash-reporting failures — we must not double-throw\n        // inside an error boundary.\n      }\n    }\n  }\n\n  override componentDidUpdate(prevProps: VariantErrorBoundaryProps): void {\n    // If the children prop changes after a recovery (e.g. the engine\n    // rolled back and a parent re-rendered with a different subtree),\n    // clear the error so we attempt to render the new tree.\n    if (this.state.error !== null && prevProps.children !== this.props.children) {\n      this.setState({ error: null });\n    }\n  }\n\n  override render(): ReactNode {\n    const { error } = this.state;\n    if (error !== null) {\n      const { fallback } = this.props;\n      if (typeof fallback === \"function\") return fallback(error);\n      return fallback ?? null;\n    }\n    return this.props.children;\n  }\n}\n","/**\n * `useVariantLabEngine` — raw engine access escape hatch.\n *\n * Most consumers should reach for `useVariant` / `useVariantValue` /\n * `useExperiment` instead. This hook is for code that needs to call\n * engine methods directly (e.g. `setVariant` from a debug panel, or\n * `reportCrash` from a custom error boundary).\n *\n * Throws synchronously when called outside a `VariantLabProvider`\n * because any other behavior (returning `null`, lazy init) would hide\n * the real bug behind mysterious fallbacks elsewhere in the tree.\n */\n\nimport type { VariantEngine } from \"@variantlab/core\";\nimport { useContext } from \"react\";\nimport { VariantLabContext } from \"../context.js\";\n\nexport function useVariantLabEngine(): VariantEngine {\n  const engine = useContext(VariantLabContext);\n  if (engine === null) {\n    throw new Error(\"useVariantLabEngine: no <VariantLabProvider> found above this component.\");\n  }\n  return engine;\n}\n","/**\n * `useVariant` — read the current variant id for an experiment.\n *\n * Subscribes to engine events via `useSyncExternalStore` so that the\n * component re-renders whenever the variant for this experiment\n * actually changes (manual override, rollback, config reload, context\n * update). Events that don't affect this experiment are filtered out\n * at the listener level — React's bail-out on identical snapshots\n * handles the rest.\n *\n * The snapshot callback is `engine.getVariant(id)` directly. The\n * engine memoizes the result in an internal cache, so repeated reads\n * in the same render pass are O(1) and side-effect free — which is\n * exactly what `useSyncExternalStore` requires.\n */\n\nimport type { EngineEvent } from \"@variantlab/core\";\nimport { useCallback, useSyncExternalStore } from \"react\";\nimport { useVariantLabEngine } from \"./use-variant-lab-engine.js\";\n\nexport function useVariant(experimentId: string): string {\n  const engine = useVariantLabEngine();\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void): (() => void) => {\n      return engine.subscribe((event: EngineEvent) => {\n        if (shouldNotify(event, experimentId)) onStoreChange();\n      });\n    },\n    [engine, experimentId],\n  );\n\n  const getSnapshot = useCallback(\n    (): string => engine.getVariant(experimentId),\n    [engine, experimentId],\n  );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n/**\n * Decide whether an engine event should retrigger snapshot sampling.\n * Broad events (`configLoaded`, `contextUpdated`) always fire; targeted\n * events fire only when they name this experiment.\n */\nfunction shouldNotify(event: EngineEvent, experimentId: string): boolean {\n  switch (event.type) {\n    case \"configLoaded\":\n    case \"contextUpdated\":\n      return true;\n    case \"variantChanged\":\n    case \"rollback\":\n    case \"assignment\":\n      return event.experimentId === experimentId;\n    default:\n      return false;\n  }\n}\n","/**\n * `<Variant>` — render-prop switch for \"render\" experiments.\n *\n * Takes a plain `Record<variantId, ReactNode>` as its children. The\n * shape intentionally looks like a lookup table so grep, codegen, and\n * TypeScript exhaustiveness checks all work without any custom\n * helpers. If the active variant isn't in the table we render\n * `fallback` if provided, else `null` — silent render failures are\n * preferable to crashing the tree when a config is missing a case.\n *\n * This component is tiny on purpose: the real logic lives in\n * `useVariant`, and everything here is table lookup plus a fallback.\n */\nimport type { ReactNode } from \"react\";\nimport { useVariant } from \"../hooks/use-variant.js\";\n\nexport interface VariantProps {\n  readonly experimentId: string;\n  readonly children: Readonly<Record<string, ReactNode>>;\n  readonly fallback?: ReactNode;\n}\n\nexport function Variant({ experimentId, children, fallback }: VariantProps): ReactNode {\n  const active = useVariant(experimentId);\n  const node = children[active];\n  if (node !== undefined) return node;\n  return fallback ?? null;\n}\n","/**\n * `useVariantValue` — read a \"value\" experiment's typed payload.\n *\n * Thin wrapper around `useVariant` that looks up the matching\n * `variant.value` from the engine. Used for copy, pricing, feature\n * toggles, and any other experiment where the thing that varies is\n * data, not a React component.\n *\n * The generic `T` exists purely for type inference ergonomics. When\n * codegen is active it's filled in automatically from\n * `GeneratedExperiments[id][\"value\"]`; otherwise callers pass an\n * explicit type parameter.\n */\nimport { useVariant } from \"./use-variant.js\";\nimport { useVariantLabEngine } from \"./use-variant-lab-engine.js\";\n\nexport function useVariantValue<T = unknown>(experimentId: string): T {\n  const engine = useVariantLabEngine();\n  // Track the variant id so we re-render when it changes. The actual\n  // value is fetched via `getVariantValue` which walks the variant\n  // table; this is O(n_variants) which is fine for typical configs.\n  useVariant(experimentId);\n  return engine.getVariantValue<T>(experimentId);\n}\n","/**\n * `<VariantValue>` — function-as-child helper for \"value\" experiments.\n *\n * Lets callers declaratively render with a typed variant value without\n * having to import `useVariantValue` into a component that is\n * otherwise pure JSX. Useful inside dense markup where introducing a\n * hook would require pulling the surrounding code into a wrapper\n * component.\n */\nimport type { ReactNode } from \"react\";\nimport { useVariantValue } from \"../hooks/use-variant-value.js\";\n\nexport interface VariantValueProps<T> {\n  readonly experimentId: string;\n  readonly children: (value: T) => ReactNode;\n}\n\nexport function VariantValue<T = unknown>({\n  experimentId,\n  children,\n}: VariantValueProps<T>): ReactNode {\n  const value = useVariantValue<T>(experimentId);\n  return children(value);\n}\n","/**\n * `useExperiment` — combined read + tracker helper.\n *\n * Returns the variant id, the typed value, and a `track` function\n * bound to this experiment. `track` is a pass-through to the engine's\n * history ring buffer — it doesn't do network IO (core makes no\n * outbound calls, period) but it does give downstream telemetry\n * subscribers something to observe.\n *\n * The `track` closure is stable across re-renders via `useCallback`\n * so passing it into memoized children doesn't bust their memoization.\n */\nimport { useCallback } from \"react\";\nimport { useVariant } from \"./use-variant.js\";\nimport { useVariantLabEngine } from \"./use-variant-lab-engine.js\";\n\nexport interface UseExperimentResult<T> {\n  readonly variant: string;\n  readonly value: T;\n  readonly track: (eventName: string, properties?: Record<string, unknown>) => void;\n}\n\nexport function useExperiment<T = unknown>(experimentId: string): UseExperimentResult<T> {\n  const engine = useVariantLabEngine();\n  const variant = useVariant(experimentId);\n  const value = engine.getVariantValue<T>(experimentId);\n\n  const track = useCallback((_eventName: string, _properties?: Record<string, unknown>): void => {\n    // Telemetry forwarding is a phase-2 feature. For now `track` is\n    // a no-op sink so callers can wire up the API today without\n    // waiting for the pluggable telemetry layer.\n  }, []);\n\n  return { variant, value, track };\n}\n","/**\n * `useRouteExperiments` — list experiments active on a given route.\n *\n * Pure derivation from `engine.getExperiments(route)`. The challenge\n * is that `engine.getExperiments(route)` allocates a fresh filtered\n * array on every call, which would cause `useSyncExternalStore` to\n * flag an infinite update loop. We cache the snapshot in a ref and\n * invalidate it whenever a relevant engine event fires, so the\n * reference is stable between notifications.\n */\n\nimport type { EngineEvent, Experiment } from \"@variantlab/core\";\nimport { useCallback, useRef, useSyncExternalStore } from \"react\";\nimport { useVariantLabEngine } from \"./use-variant-lab-engine.js\";\n\ninterface Cached {\n  readonly route: string | undefined;\n  readonly snapshot: readonly Experiment[];\n}\n\nexport function useRouteExperiments(route?: string): readonly Experiment[] {\n  const engine = useVariantLabEngine();\n  const cacheRef = useRef<Cached | null>(null);\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void): (() => void) => {\n      return engine.subscribe((event: EngineEvent) => {\n        if (event.type === \"configLoaded\" || event.type === \"contextUpdated\") {\n          cacheRef.current = null;\n          onStoreChange();\n        }\n      });\n    },\n    [engine],\n  );\n\n  const getSnapshot = useCallback((): readonly Experiment[] => {\n    const cached = cacheRef.current;\n    if (cached !== null && cached.route === route) return cached.snapshot;\n    const snapshot = engine.getExperiments(route);\n    cacheRef.current = { route, snapshot };\n    return snapshot;\n  }, [engine, route]);\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n","/**\n * `useSetVariant` — dev-only imperative variant override.\n *\n * Returns a stable setter bound to the current engine. Intended for\n * debug UIs (Storybook, the overlay, dev tools) and QA scripts, not\n * for production logic. Production code should update the config or\n * targeting, not force variants from components.\n */\nimport { useCallback } from \"react\";\nimport { useVariantLabEngine } from \"./use-variant-lab-engine.js\";\n\nexport function useSetVariant(): (experimentId: string, variantId: string) => void {\n  const engine = useVariantLabEngine();\n  return useCallback(\n    (experimentId: string, variantId: string): void => {\n      engine.setVariant(experimentId, variantId);\n    },\n    [engine],\n  );\n}\n","\"use client\";\n\n/**\n * Next-specific `VariantLabProvider` Client Component.\n *\n * Wraps `@variantlab/react`'s provider. The engine is constructed via\n * `useMemo` keyed on the config/context/variants identity so a stable\n * imported JSON module yields a stable engine across renders and\n * StrictMode double-invocation.\n *\n * Crucially, `initialContext` is passed to `createEngine`, not to the\n * inner React provider. That avoids the inner provider's\n * `useLayoutEffect` branch, which would emit an SSR warning when this\n * component is rendered on the server as part of a Client Component\n * tree.\n *\n * `initialVariants` is forwarded via the new core option\n * `initialAssignments`, seeding the engine cache so the first\n * `getVariant` call short-circuits on the exact variants the server\n * rendered. Zero re-evaluation on first render → zero hydration\n * mismatches.\n */\n\nimport { createEngine } from \"@variantlab/core\";\nimport { VariantLabProvider as CoreVariantLabProvider } from \"@variantlab/react\";\nimport { type ReactNode, useMemo } from \"react\";\nimport type { VariantLabProviderProps } from \"../types.js\";\n\n/**\n * Named `NextVariantLabProvider` internally to avoid colliding with the\n * re-export name `VariantLabProvider` once tsup bundles\n * `@variantlab/react` inline. Exposed publicly as `VariantLabProvider`\n * via the barrel in `./hooks.ts`.\n */\nexport function NextVariantLabProvider({\n  config,\n  initialContext,\n  initialVariants,\n  children,\n}: VariantLabProviderProps): ReactNode {\n  const engine = useMemo(\n    () =>\n      createEngine(config, {\n        ...(initialContext !== undefined ? { context: initialContext } : {}),\n        ...(initialVariants !== undefined ? { initialAssignments: initialVariants } : {}),\n      }),\n    // Stable JSON module → stable identity → stable engine.\n    [config, initialContext, initialVariants],\n  );\n  return <CoreVariantLabProvider engine={engine}>{children}</CoreVariantLabProvider>;\n}\n","\"use client\";\n\n/**\n * Client-side hooks + components for `@variantlab/next`.\n *\n * Re-exports the public surface of `@variantlab/react` (hooks +\n * components) plus a Next-specific `useNextRouteExperiments()` that\n * reads `usePathname()` from `next/navigation` so consumers don't\n * have to thread the route through by hand.\n *\n * NOTE: `@variantlab/react` is bundled *into* this file (not marked\n * external) so the symbols have local bindings in the emitted JS.\n * Next's client-reference loader cannot follow `export { X } from\n * \"<workspace-pkg>\"` chains across `transpilePackages` boundaries\n * in dev mode, so we eliminate the boundary entirely for the client\n * entrypoint. The server entrypoint still treats `@variantlab/react`\n * as external because it never crosses a client boundary.\n */\n\nimport type { Experiment } from \"@variantlab/core\";\nimport { useRouteExperiments } from \"@variantlab/react\";\n// `next/navigation` is listed as a peer dep (via `next`) so this\n// import is resolved by Next's bundler at build time.\nimport { usePathname } from \"next/navigation\";\n\nexport type {\n  UseExperimentResult,\n  VariantErrorBoundaryProps,\n  VariantProps,\n  VariantValueProps,\n} from \"@variantlab/react\";\nexport {\n  useExperiment,\n  useRouteExperiments,\n  useSetVariant,\n  useVariant,\n  useVariantLabEngine,\n  useVariantValue,\n  Variant,\n  VariantErrorBoundary,\n  VariantLabContext,\n  VariantValue,\n} from \"@variantlab/react\";\nexport type { VariantLabProviderProps } from \"../types.js\";\nexport { NextVariantLabProvider as VariantLabProvider } from \"./provider.js\";\n\n/**\n * Like `useRouteExperiments(route)`, but reads the current route from\n * `next/navigation`'s `usePathname()` so you never need to pass it\n * explicitly.\n */\nexport function useNextRouteExperiments(): readonly Experiment[] {\n  const pathname = usePathname();\n  return useRouteExperiments(pathname ?? undefined);\n}\n"]}

package/dist/index.cjs

@@ -0,0 +1,319 @@
+'use strict';
+
+var core = require('@variantlab/core');
+
+// src/types.ts
+var DEFAULT_COOKIE_NAME = "__variantlab_sticky";
+var DEFAULT_MAX_AGE = 60 * 60 * 24 * 365;
+
+// src/server/cookie.ts
+var MAX_COOKIE_HEADER_BYTES = 8192;
+var MAX_PAYLOAD_BYTES = 4096;
+var RESERVED_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function base64urlEncode(input) {
+  const bytes = textEncoder.encode(input);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  const b64 = btoa(binary);
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64urlDecode(input) {
+  if (!/^[A-Za-z0-9\-_]*$/.test(input)) return null;
+  const pad = input.length % 4;
+  const padded = input.replace(/-/g, "+").replace(/_/g, "/") + "====".slice(pad === 0 ? 4 : pad);
+  try {
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return textDecoder.decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function encodePayload(payload) {
+  const json = JSON.stringify({ v: payload.v, u: payload.u, a: payload.a });
+  return base64urlEncode(json);
+}
+function decodePayload(raw) {
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  if (raw.length > MAX_PAYLOAD_BYTES) return null;
+  const json = base64urlDecode(raw);
+  if (json === null) return null;
+  if (json.length > MAX_PAYLOAD_BYTES) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const obj = parsed;
+  if (obj["v"] !== 1) return null;
+  if (typeof obj["u"] !== "string" || obj["u"].length === 0 || obj["u"].length > 256) return null;
+  const rawA = obj["a"];
+  if (rawA === null || typeof rawA !== "object" || Array.isArray(rawA)) return null;
+  const src = rawA;
+  const a = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(src)) {
+    if (RESERVED_NAMES.has(key)) continue;
+    if (key.length === 0 || key.length > 128) continue;
+    const val = src[key];
+    if (typeof val !== "string" || val.length === 0 || val.length > 128) continue;
+    a[key] = val;
+  }
+  return { v: 1, u: obj["u"], a };
+}
+function parseCookieHeader(header) {
+  const out = /* @__PURE__ */ Object.create(null);
+  if (typeof header !== "string" || header.length === 0) return out;
+  if (header.length > MAX_COOKIE_HEADER_BYTES) return out;
+  let i = 0;
+  const n = header.length;
+  while (i < n) {
+    while (i < n && (header.charCodeAt(i) === 32 || header.charCodeAt(i) === 9)) i++;
+    const start = i;
+    while (i < n && header.charCodeAt(i) !== 59) i++;
+    const segment = header.slice(start, i);
+    if (i < n) i++;
+    if (segment.length === 0) continue;
+    const eq = segment.indexOf("=");
+    if (eq <= 0) continue;
+    const name = segment.slice(0, eq).trim();
+    if (name.length === 0) continue;
+    if (RESERVED_NAMES.has(name)) continue;
+    let value = segment.slice(eq + 1).trim();
+    if (value.length >= 2 && value.charCodeAt(0) === 34 && value.charCodeAt(value.length - 1) === 34) {
+      value = value.slice(1, -1);
+    }
+    if (out[name] === void 0) {
+      out[name] = safeDecodeURIComponent(value);
+    }
+  }
+  return out;
+}
+function safeDecodeURIComponent(s) {
+  try {
+    return decodeURIComponent(s);
+  } catch {
+    return s;
+  }
+}
+function serializeCookie(name, value, options = {}) {
+  const parts = [`${name}=${encodeURIComponent(value)}`];
+  const maxAge = options.maxAge ?? DEFAULT_MAX_AGE;
+  if (maxAge > 0) parts.push(`Max-Age=${Math.floor(maxAge)}`);
+  parts.push(`Path=${options.path ?? "/"}`);
+  const sameSite = options.sameSite ?? "lax";
+  parts.push(`SameSite=${capitalize(sameSite)}`);
+  if (options.httpOnly !== false) parts.push("HttpOnly");
+  if (options.secure === true) parts.push("Secure");
+  if (options.domain !== void 0) parts.push(`Domain=${options.domain}`);
+  return parts.join("; ");
+}
+function capitalize(s) {
+  if (s.length === 0) return s;
+  return s[0].toUpperCase() + s.slice(1);
+}
+function readCookieFromSource(source, name = DEFAULT_COOKIE_NAME) {
+  if (source === null || source === void 0) return void 0;
+  if (typeof source === "string") {
+    const parsed = parseCookieHeader(source);
+    return parsed[name];
+  }
+  if (typeof source.get === "function") {
+    const entry = source.get(name);
+    return entry === void 0 ? void 0 : entry.value;
+  }
+  if (typeof source.headers?.get === "function") {
+    const header = source.headers.get("cookie");
+    if (header === null) return void 0;
+    return parseCookieHeader(header)[name];
+  }
+  const pagesReq = source;
+  if (pagesReq.cookies !== void 0) {
+    const fromBag = pagesReq.cookies[name];
+    if (typeof fromBag === "string" && fromBag.length > 0) return fromBag;
+  }
+  if (pagesReq.headers !== void 0) {
+    const header = pagesReq.headers["cookie"];
+    if (typeof header === "string") return parseCookieHeader(header)[name];
+    if (Array.isArray(header) && typeof header[0] === "string") {
+      return parseCookieHeader(header[0])[name];
+    }
+  }
+  return void 0;
+}
+function readPayloadFromSource(source, name = DEFAULT_COOKIE_NAME) {
+  const raw = readCookieFromSource(source, name);
+  return decodePayload(raw);
+}
+function generateUserId() {
+  const g = globalThis;
+  if (g.crypto?.randomUUID !== void 0) return g.crypto.randomUUID();
+  if (g.crypto?.getRandomValues !== void 0) {
+    const bytes = new Uint8Array(16);
+    g.crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = [];
+    for (let i = 0; i < 16; i++) {
+      hex.push(bytes[i].toString(16).padStart(2, "0"));
+    }
+    return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+  }
+  return `u-${Date.now().toString(36)}-${Math.floor(Math.random() * 1e9).toString(36)}`;
+}
+function createVariantLabServer(rawConfig, options = {}) {
+  const config = core.validateConfig(rawConfig);
+  const cookieName = options.cookieName ?? DEFAULT_COOKIE_NAME;
+  const onError = options.onError ?? (() => {
+  });
+  function readPayload(source) {
+    try {
+      return readPayloadFromSource(source, cookieName);
+    } catch (error) {
+      onError(error);
+      return null;
+    }
+  }
+  function buildContext(payload, extras) {
+    const userId = payload?.u ?? extras?.userId;
+    if (userId === void 0) return { ...extras };
+    return { ...extras, userId };
+  }
+  function getVariant(experimentId, source, context) {
+    try {
+      const payload = readPayload(source);
+      const engine = core.createEngine(config, {
+        context: buildContext(payload, context),
+        ...payload?.a !== void 0 ? { initialAssignments: payload.a } : {}
+      });
+      return engine.getVariant(experimentId);
+    } catch (error) {
+      onError(error);
+      return experimentDefault(config, experimentId);
+    }
+  }
+  function getVariantValue(experimentId, source, context) {
+    try {
+      const payload = readPayload(source);
+      const engine = core.createEngine(config, {
+        context: buildContext(payload, context),
+        ...payload?.a !== void 0 ? { initialAssignments: payload.a } : {}
+      });
+      return engine.getVariantValue(experimentId);
+    } catch (error) {
+      onError(error);
+      return void 0;
+    }
+  }
+  function writePayload(payload, secure) {
+    const value = encodePayload(payload);
+    return serializeCookie(cookieName, value, {
+      ...options,
+      ...secure !== void 0 ? { secure } : {}
+    });
+  }
+  function toProviderProps(source, contextExtras) {
+    const payload = readPayload(source);
+    const initialContext = buildContext(payload, contextExtras);
+    const initialVariants = payload?.a ? { ...payload.a } : {};
+    return { initialContext, initialVariants };
+  }
+  return {
+    config,
+    getVariant,
+    getVariantValue,
+    readPayload,
+    writePayload,
+    toProviderProps
+  };
+}
+function experimentDefault(config, experimentId) {
+  const exp = config.experiments.find((e) => e.id === experimentId);
+  return exp?.default ?? "";
+}
+
+// src/server/get-variant-ssr.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function resolveServer(rawConfig, options) {
+  if (rawConfig !== null && typeof rawConfig === "object") {
+    const hit = cache.get(rawConfig);
+    if (hit !== void 0) return hit;
+  }
+  const server = createVariantLabServer(rawConfig, options);
+  if (rawConfig !== null && typeof rawConfig === "object") {
+    cache.set(rawConfig, server);
+  }
+  return server;
+}
+function getVariantSSR(experimentId, source, config, options) {
+  const server = resolveServer(config, options);
+  return server.getVariant(experimentId, source, options?.context);
+}
+function getVariantValueSSR(experimentId, source, config, options) {
+  const server = resolveServer(config, options);
+  return server.getVariantValue(experimentId, source, options?.context);
+}
+function variantLabMiddleware(rawConfig, options = {}) {
+  let frozen = true;
+  try {
+    core.validateConfig(rawConfig);
+  } catch (error) {
+    options.onError?.(error);
+    frozen = false;
+  }
+  const cookieName = options.cookieName ?? DEFAULT_COOKIE_NAME;
+  const onError = options.onError ?? (() => {
+  });
+  return function apply(req, response) {
+    if (!frozen) return response;
+    try {
+      const header = req.headers.get("cookie");
+      const cookies = parseCookieHeader(header ?? "");
+      const existing = decodePayload(cookies[cookieName]);
+      if (existing !== null) return response;
+      const payload = {
+        v: 1,
+        u: generateUserId(),
+        a: {}
+      };
+      const secure = req.nextUrl.protocol === "https:";
+      const setCookie = serializeCookie(cookieName, encodePayload(payload), {
+        ...options,
+        secure
+      });
+      response.headers.append("set-cookie", setCookie);
+      return response;
+    } catch (error) {
+      onError(error);
+      return response;
+    }
+  };
+}
+
+// src/index.ts
+var VERSION = "0.0.0";
+
+exports.DEFAULT_COOKIE_NAME = DEFAULT_COOKIE_NAME;
+exports.DEFAULT_MAX_AGE = DEFAULT_MAX_AGE;
+exports.VERSION = VERSION;
+exports.createVariantLabServer = createVariantLabServer;
+exports.decodePayload = decodePayload;
+exports.encodePayload = encodePayload;
+exports.generateUserId = generateUserId;
+exports.getVariantSSR = getVariantSSR;
+exports.getVariantValueSSR = getVariantValueSSR;
+exports.parseCookieHeader = parseCookieHeader;
+exports.readCookieFromSource = readCookieFromSource;
+exports.readPayloadFromSource = readPayloadFromSource;
+exports.serializeCookie = serializeCookie;
+exports.variantLabMiddleware = variantLabMiddleware;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map