@replohq/sdk 2.16.0 → 2.18.0

package/_vendor/replo-utils/lib/pageRouteMatch.d.ts

@@ -0,0 +1,10 @@
+export declare function normalizePageRoute(route: string): string;
+export declare function getPageForRoute<PageType extends {
+    route: string;
+}>(pages: PageType[], route: string): PageType | undefined;
+/** The values a route fills a template with (`/r/[city]` + `/r/oakland` → `{ city: "oakland" }`), or null when it doesn't fill it; a catch-all value keeps its slashes. */
+export declare function matchPageRouteParams(template: string, route: string): Record<string, string> | null;
+/** The route a template renders for `params`; null when one is missing. An empty optional catch-all drops its segment. */
+export declare function fillPageRoute(template: string, params: Readonly<Record<string, string>>): string | null;
+/** A template's params in order (`[state]/[city]`), so two templates with the same shape render the same set of pages. */
+export declare function pageRouteParamShape(route: string): string;

package/_vendor/replo-utils/lib/sitePages.d.ts

@@ -0,0 +1,28 @@
+export declare function isDynamicRouteSegment(segment: string): boolean;
+/** Whether `route` is a template that serves many URLs, such as `/products/[slug]`. */
+export declare function isDynamicRoute(route: string): boolean;
+export declare const SITE_PAGE_FILE_NAMES: {
+    readonly legacy: "page.tsx";
+    readonly draft: "page.dev.tsx";
+    readonly live: "page.published.tsx";
+};
+export type SitePageFileKind = keyof typeof SITE_PAGE_FILE_NAMES;
+/** The project-relative page file a URL path like `/about` installs to; null for a path that can't name one. */
+export declare function getSitePageFilePath(route: string): string | null;
+export declare const SITE_PAGE_PUBLISHED_FILE_EXTENSION = ".published.tsx";
+export declare const SITE_PAGE_FILE_GLOBS: string[];
+export declare const SITE_PAGE_PUBLISH_STATES: readonly ["published", "publishedWithChanges", "unpublished", "pendingDelete", "legacy"];
+export type SitePagePublishState = (typeof SITE_PAGE_PUBLISH_STATES)[number];
+export declare function getSitePageFileKind(filepath: string): SitePageFileKind | null;
+export declare function isSupportedSitePageFilepath(filepath: string): boolean;
+export declare function deriveSitePagePublishState({ kinds, draftMatchesLive, }: {
+    kinds: ReadonlySet<SitePageFileKind>;
+    draftMatchesLive: boolean | null;
+}): SitePagePublishState | "invalid";
+export declare function groupSitePageFiles<PageFileType extends {
+    filepath: string;
+    route: string;
+    contentHash?: string;
+}>(files: PageFileType[]): (PageFileType & {
+    publishState: SitePagePublishState;
+})[];

package/_vendor/schemas/placeholderProductsProtocol.d.ts

@@ -2,6 +2,7 @@ export declare const PLACEHOLDER_PRODUCTS_IFRAME_RPC_CHANNEL_ID: "replo:placehol
 export declare const PLACEHOLDER_PRODUCTS_IFRAME_RPC_CHANNEL_VERSION: 3;
 export declare const PLACEHOLDER_HERO_PRODUCT_ID = "f0921037-e530-4e67-a612-d573b7c40b19";
 export declare const PLACEHOLDER_PRODUCT_ID = "c53f98cd-0989-4661-a7c2-a0304d184676";
+export declare const PLACEHOLDER_PRODUCT_LIMIT = 12;
 export type PlaceholderProductId = typeof PLACEHOLDER_HERO_PRODUCT_ID | typeof PLACEHOLDER_PRODUCT_ID;
 export declare const PLACEHOLDER_PRODUCTS_SOURCE_KEY = "__REPLO_PLACEHOLDER_PRODUCTS__";
 export declare const PLACEHOLDER_PRODUCTS_CHANGE_EVENT = "replo:placeholder-products";

package/_vendor/schemas/placeholderProductsProtocol.mjs

@@ -2,7 +2,8 @@ var PLACEHOLDER_PRODUCTS_IFRAME_RPC_CHANNEL_ID = "replo:placeholder-products-ifr
 var PLACEHOLDER_PRODUCTS_IFRAME_RPC_CHANNEL_VERSION = 3;
 var PLACEHOLDER_HERO_PRODUCT_ID = "f0921037-e530-4e67-a612-d573b7c40b19";
 var PLACEHOLDER_PRODUCT_ID = "c53f98cd-0989-4661-a7c2-a0304d184676";
+var PLACEHOLDER_PRODUCT_LIMIT = 12;
 var PLACEHOLDER_PRODUCTS_SOURCE_KEY = "__REPLO_PLACEHOLDER_PRODUCTS__";
 var PLACEHOLDER_PRODUCTS_CHANGE_EVENT = "replo:placeholder-products";
 
-export { PLACEHOLDER_HERO_PRODUCT_ID, PLACEHOLDER_PRODUCTS_CHANGE_EVENT, PLACEHOLDER_PRODUCTS_IFRAME_RPC_CHANNEL_ID, PLACEHOLDER_PRODUCTS_IFRAME_RPC_CHANNEL_VERSION, PLACEHOLDER_PRODUCTS_SOURCE_KEY, PLACEHOLDER_PRODUCT_ID };
+export { PLACEHOLDER_HERO_PRODUCT_ID, PLACEHOLDER_PRODUCTS_CHANGE_EVENT, PLACEHOLDER_PRODUCTS_IFRAME_RPC_CHANNEL_ID, PLACEHOLDER_PRODUCTS_IFRAME_RPC_CHANNEL_VERSION, PLACEHOLDER_PRODUCTS_SOURCE_KEY, PLACEHOLDER_PRODUCT_ID, PLACEHOLDER_PRODUCT_LIMIT };

package/_vendor/schemas/routing/experiments.d.ts

@@ -15,6 +15,7 @@ export declare const experimentStatusSchema: z.ZodEnum<{
 export declare const experimentSchema: z.ZodObject<{
     experimentKey: z.ZodString;
     route: z.ZodString;
+    includedRoutes: z.ZodDefault<z.ZodArray<z.ZodString>>;
     status: z.ZodEnum<{
         running: "running";
         draft: "draft";
@@ -31,6 +32,7 @@ export declare const experimentsFileSchema: z.ZodObject<{
     experiments: z.ZodArray<z.ZodObject<{
         experimentKey: z.ZodString;
         route: z.ZodString;
+        includedRoutes: z.ZodDefault<z.ZodArray<z.ZodString>>;
         status: z.ZodEnum<{
             running: "running";
             draft: "draft";
@@ -59,10 +61,29 @@ export declare function assignVariant({ visitorId, experiment, }: {
     experiment: Pick<Experiment, "experimentKey" | "variants">;
 }): ExperimentVariant;
 /** The experiment that routes `pathname`: a running one, else one that shipped a non-control variant. */
-export declare function findActiveExperiment({ experiments, pathname, }: {
+export declare function findActiveExperiment({ experiments, pathname, liveRoutes, }: {
     experiments: readonly Experiment[];
     pathname: string;
+    /** The build's page routes; a page of its own beats a template that would also fill `pathname`, as in Next.js. */
+    liveRoutes: readonly string[] | undefined;
 }): Experiment | null;
+/** Whether a visit to `pathname` is in the experiment: its route, or a page its template renders and the test includes. */
+export declare function experimentCoversPath({ experiment, pathname, liveRoutes, }: {
+    experiment: Pick<Experiment, "route" | "includedRoutes">;
+    pathname: string;
+    liveRoutes: readonly string[] | undefined;
+}): boolean;
+/** The path to render for a visit to `pathname` in `variant`: its route, with a template's params filled from the visit. */
+export declare function variantPathFor({ experiment, variant, pathname, }: {
+    experiment: Pick<Experiment, "route">;
+    variant: ExperimentVariant;
+    pathname: string;
+}): string | null;
+/** Whether `pathname` is one of a variant's pages: its route, or a page its template renders. */
+export declare function isVariantPath({ variant, pathname, }: {
+    variant: ExperimentVariant;
+    pathname: string;
+}): boolean;
 /** Whether a stopped experiment still routes every visitor to its shipped variant. */
 export declare function hasNonControlShippedVariant(experiment: Experiment): boolean;
 /** Whether the experiment routes traffic, and so belongs in the site's routing. */

package/_vendor/schemas/routing/experiments.mjs

@@ -1,6 +1,141 @@
 import { EXPERIMENT_KEY_PATTERN } from '../../../chunk-PH6IR743.mjs';
 import * as z from 'zod';
 
+var DYNAMIC_ROUTE_SEGMENT_PATTERN = /^\[{1,2}(?:\.\.\.)?[^\]]+\]{1,2}$/u;
+function isDynamicRouteSegment(segment) {
+  return DYNAMIC_ROUTE_SEGMENT_PATTERN.test(segment);
+}
+function isDynamicRoute(route) {
+  return route.split("/").some(isDynamicRouteSegment);
+}
+var SITE_PAGE_FILE_NAMES = {
+  legacy: "page.tsx",
+  draft: "page.dev.tsx",
+  live: "page.published.tsx"
+};
+Object.values(SITE_PAGE_FILE_NAMES).map(
+  (name) => `app/**/${name}`
+);
+
+function normalizePageRoute(route) {
+  const trimmedRoute = route.trim().replace(/^\/+|\/+$/gu, "");
+  return trimmedRoute ? `/${trimmedRoute}` : "/";
+}
+function routeSegments(route) {
+  return route.split("/").filter(Boolean);
+}
+function isCatchAllSegment(segment) {
+  return segment.startsWith("[...");
+}
+function isOptionalCatchAllSegment(segment) {
+  return segment.startsWith("[[...");
+}
+function routeMatchesDynamicRoute(dynamicRoute, concreteRoute) {
+  const dynamicSegments = routeSegments(dynamicRoute);
+  const concreteSegments = routeSegments(concreteRoute);
+  for (const [index, dynamicSegment] of dynamicSegments.entries()) {
+    if (isCatchAllSegment(dynamicSegment) || isOptionalCatchAllSegment(dynamicSegment)) {
+      return index === dynamicSegments.length - 1 && concreteSegments.length >= index + (isCatchAllSegment(dynamicSegment) ? 1 : 0);
+    }
+    const concreteSegment = concreteSegments[index];
+    if (!concreteSegment) {
+      return false;
+    }
+    if (!isDynamicRouteSegment(dynamicSegment) && dynamicSegment !== concreteSegment) {
+      return false;
+    }
+  }
+  return dynamicSegments.length === concreteSegments.length;
+}
+function segmentSpecificity(segment) {
+  if (isOptionalCatchAllSegment(segment)) {
+    return 3;
+  }
+  if (isCatchAllSegment(segment)) {
+    return 2;
+  }
+  return isDynamicRouteSegment(segment) ? 1 : 0;
+}
+function compareTemplateSpecificity(leftRoute, rightRoute) {
+  const leftSegments = routeSegments(leftRoute);
+  const rightSegments = routeSegments(rightRoute);
+  const length = Math.max(leftSegments.length, rightSegments.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = segmentSpecificity(leftSegments[index] ?? "") - segmentSpecificity(rightSegments[index] ?? "");
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  return 0;
+}
+function getPageForRoute(pages, route) {
+  const normalizedRoute = normalizePageRoute(route);
+  const exactMatch = pages.find((page) => {
+    return normalizePageRoute(page.route) === normalizedRoute;
+  });
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const templates = pages.filter((page) => {
+    const candidateRoute = normalizePageRoute(page.route);
+    return isDynamicRoute(candidateRoute) && routeMatchesDynamicRoute(candidateRoute, normalizedRoute);
+  });
+  return templates.sort((leftPage, rightPage) => {
+    return compareTemplateSpecificity(
+      normalizePageRoute(leftPage.route),
+      normalizePageRoute(rightPage.route)
+    );
+  })[0];
+}
+var PARAM_NAME_PATTERN = /^\[{1,2}(?:\.\.\.)?([^\]]+?)\]{1,2}$/u;
+function matchPageRouteParams(template, route) {
+  const templateSegments = routeSegments(template);
+  const segments = routeSegments(route);
+  const params = {};
+  for (const [index, templateSegment] of templateSegments.entries()) {
+    const name = PARAM_NAME_PATTERN.exec(templateSegment)?.[1];
+    if (name && (isCatchAllSegment(templateSegment) || isOptionalCatchAllSegment(templateSegment))) {
+      const rest = segments.slice(index);
+      const isLast = index === templateSegments.length - 1;
+      if (!isLast || rest.length === 0 && isCatchAllSegment(templateSegment)) {
+        return null;
+      }
+      params[name] = rest.join("/");
+      return params;
+    }
+    const segment = segments[index];
+    if (segment === void 0) {
+      return null;
+    }
+    if (name) {
+      params[name] = segment;
+    } else if (templateSegment !== segment) {
+      return null;
+    }
+  }
+  return templateSegments.length === segments.length ? params : null;
+}
+function fillPageRoute(template, params) {
+  const parts = [];
+  for (const segment of routeSegments(template)) {
+    const name = PARAM_NAME_PATTERN.exec(segment)?.[1];
+    if (!name) {
+      parts.push(segment);
+      continue;
+    }
+    const value = params[name];
+    if (value === void 0 || value === "" && !isOptionalCatchAllSegment(segment)) {
+      return null;
+    }
+    if (value !== "") {
+      parts.push(value);
+    }
+  }
+  return `/${parts.join("/")}`;
+}
+function pageRouteParamShape(route) {
+  return routeSegments(route).filter(isDynamicRouteSegment).join("/");
+}
 var MIN_VARIANTS = 2;
 var MAX_VARIANTS = 5;
 var TOTAL_ROLLOUT_PERCENTAGE = 100;
@@ -22,12 +157,17 @@ var experimentSchema = z.object({
     "The experiment's key; changing it reassigns every visitor"
   ),
   route: experimentRouteSchema.describe(
-    "The shared URL visitors land on; the control variant renders it"
+    "The shared URL visitors land on, or a template route like /restaurants/[city] for every page it renders; the control variant renders it"
+  ),
+  includedRoutes: z.array(experimentRouteSchema).default([]).describe(
+    "For a template route, the pages it renders that are in the test, e.g. /restaurants/oakland; empty includes all of them"
   ),
   status: experimentStatusSchema.describe(
     "Only running experiments, and stopped ones with a shipped variant, route traffic"
   ),
-  variants: z.array(experimentVariantSchema).min(MIN_VARIANTS).max(MAX_VARIANTS).describe("The control first, then up to four challengers"),
+  variants: z.array(experimentVariantSchema).min(MIN_VARIANTS).max(MAX_VARIANTS).describe(
+    "The control first, then up to four challengers; on a template route each challenger is a template with the same params"
+  ),
   shippedVariantKey: experimentKeySchema.nullable().describe(
     "Variant key every visitor gets once the experiment has stopped; null keeps the control"
   )
@@ -40,6 +180,7 @@ var experimentSchema = z.object({
       message: "the first variant is the control and must use the experiment's route"
     });
   }
+  addTemplateIssues({ experiment, context });
   const totalRolloutPercentage = experiment.variants.reduce(
     (sum, variant) => sum + variant.rolloutPercentage,
     0
@@ -113,14 +254,59 @@ function assignVariant({
 }
 function findActiveExperiment({
   experiments,
-  pathname
+  pathname,
+  liveRoutes
 }) {
-  const route = normalizeRoute(pathname);
   const onRoute = experiments.filter((experiment) => {
-    return normalizeRoute(experiment.route) === route;
+    return experimentCoversPath({ experiment, pathname, liveRoutes });
   });
   return onRoute.find((experiment) => experiment.status === "running") ?? onRoute.find(hasNonControlShippedVariant) ?? null;
 }
+function experimentCoversPath({
+  experiment,
+  pathname,
+  liveRoutes
+}) {
+  const path = normalizeRoute(pathname);
+  if (!isDynamicRoute(experiment.route)) {
+    return normalizeRoute(experiment.route) === path;
+  }
+  if (!matchPageRouteParams(experiment.route, path)) {
+    return false;
+  }
+  if (experiment.includedRoutes.length > 0 && !experiment.includedRoutes.some((route) => normalizeRoute(route) === path)) {
+    return false;
+  }
+  if (!liveRoutes) {
+    return true;
+  }
+  const owner = getPageForRoute(
+    liveRoutes.map((route) => ({ route })),
+    path
+  );
+  return owner !== void 0 && normalizeRoute(owner.route) === normalizeRoute(experiment.route);
+}
+function variantPathFor({
+  experiment,
+  variant,
+  pathname
+}) {
+  if (!isDynamicRoute(variant.route)) {
+    return variant.route;
+  }
+  const params = matchPageRouteParams(
+    experiment.route,
+    normalizeRoute(pathname)
+  );
+  return params ? fillPageRoute(variant.route, params) : null;
+}
+function isVariantPath({
+  variant,
+  pathname
+}) {
+  const path = normalizeRoute(pathname);
+  return isDynamicRoute(variant.route) ? matchPageRouteParams(variant.route, path) !== null : normalizeRoute(variant.route) === path;
+}
 function hasNonControlShippedVariant(experiment) {
   return experiment.status === "stopped" && experiment.shippedVariantKey !== null && experiment.shippedVariantKey !== experiment.variants[0]?.variantKey;
 }
@@ -146,6 +332,49 @@ function fnv1a32(value) {
   }
   return hash >>> 0;
 }
+function addTemplateIssues({
+  experiment,
+  context
+}) {
+  const isTemplate = isDynamicRoute(experiment.route);
+  const shape = pageRouteParamShape(experiment.route);
+  experiment.variants.forEach((variant, index) => {
+    if (isDynamicRoute(variant.route) !== isTemplate) {
+      context.addIssue({
+        code: "custom",
+        path: ["variants", index, "route"],
+        message: isTemplate ? `"${variant.route}" must be a template like the experiment's route "${experiment.route}"` : `"${variant.route}" is a template, but the experiment's route "${experiment.route}" is one page`
+      });
+    } else if (isTemplate && pageRouteParamShape(variant.route) !== shape) {
+      context.addIssue({
+        code: "custom",
+        path: ["variants", index, "route"],
+        message: `"${variant.route}" must use the same params as "${experiment.route}" (${shape})`
+      });
+    }
+  });
+  experiment.includedRoutes.forEach((route, index) => {
+    if (!isTemplate) {
+      context.addIssue({
+        code: "custom",
+        path: ["includedRoutes"],
+        message: "includedRoutes only applies to a template route"
+      });
+    } else if (isDynamicRoute(route) || !matchPageRouteParams(experiment.route, normalizeRoute(route))) {
+      context.addIssue({
+        code: "custom",
+        path: ["includedRoutes", index],
+        message: `"${route}" isn't a page "${experiment.route}" renders`
+      });
+    }
+  });
+  addDuplicateIssues({
+    context,
+    values: experiment.includedRoutes.map(normalizeRoute),
+    path: ["includedRoutes"],
+    describe: (route) => `duplicate included route "${route}"`
+  });
+}
 function addDuplicateIssues({
   context,
   values,
@@ -161,4 +390,4 @@ function addDuplicateIssues({
   }
 }
 
-export { SITE_KV_BINDING, SITE_KV_EXPERIMENTS_KEY, assignVariant, experimentKeySchema, experimentRouteSchema, experimentSchema, experimentStatusSchema, experimentVariantSchema, experimentsFileSchema, findActiveExperiment, findServedVariants, hasNonControlShippedVariant, isRoutingExperiment, normalizeRoute };
+export { SITE_KV_BINDING, SITE_KV_EXPERIMENTS_KEY, assignVariant, experimentCoversPath, experimentKeySchema, experimentRouteSchema, experimentSchema, experimentStatusSchema, experimentVariantSchema, experimentsFileSchema, findActiveExperiment, findServedVariants, hasNonControlShippedVariant, isRoutingExperiment, isVariantPath, normalizeRoute, variantPathFor };

package/lib/buildMetadata.js

@@ -1,7 +1,7 @@
 export const BUILD_METADATA = {
   "packageName": "@replohq/sdk",
-  "version": "2.16.0",
+  "version": "2.18.0",
   "branch": "HEAD",
-  "commit": "ace9e163575351a4ad987d0f0427807eaec836ee",
-  "builtAt": "2026-10-31T09:51:00.149Z"
+  "commit": "aa9296f4104e4be2271247d775a27fa69288bbe8",
+  "builtAt": "2026-11-02T03:31:48.722Z"
 };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@replohq/sdk",
-  "version": "2.16.0",
+  "version": "2.18.0",
   "reploBuild": {
     "packageName": "@replohq/sdk",
-    "version": "2.16.0",
+    "version": "2.18.0",
     "branch": "HEAD",
-    "commit": "ace9e163575351a4ad987d0f0427807eaec836ee",
-    "builtAt": "2026-10-31T09:51:00.149Z"
+    "commit": "aa9296f4104e4be2271247d775a27fa69288bbe8",
+    "builtAt": "2026-11-02T03:31:48.722Z"
   },
   "description": "Replo SDK — cart, analytics, and data loaders for agent-built Next.js sites.",
   "license": "SEE LICENSE IN LICENSE",

package/routing/experiments.js

@@ -13,7 +13,9 @@ import {
   findActiveExperiment,
   findServedVariants,
   isRoutingExperiment,
-  normalizeRoute
+  isVariantPath,
+  normalizeRoute,
+  variantPathFor
 } from "../_vendor/schemas/routing/experiments.mjs";
 import { isConsentGranted } from "../consent/cookie";
 import { ensureVisitorId } from "./visitor-id";
@@ -27,17 +29,19 @@ function decideExperiment({
   if (request.method !== "GET" && request.method !== "HEAD") {
     return null;
   }
-  const experiments = parseExperiments(rawExperiments);
-  if (!experiments) {
+  const routing = parseExperiments(rawExperiments);
+  if (!routing) {
     return null;
   }
+  const { experiments, liveRoutes } = routing;
   const isPreview = process.env.NODE_ENV === "development";
   if (isPreview && !request.nextUrl.searchParams.has(EXPERIMENT_OVERRIDE_PARAM)) {
     return null;
   }
   const experiment = findActiveExperiment({
     experiments,
-    pathname: logicalPath
+    pathname: logicalPath,
+    liveRoutes
   });
   if (!experiment) {
     return logicalPath.startsWith("/v/") && isChallengerRoute({ experiments, logicalPath }) ? { type: "variantRoute", servedPath: null } : null;
@@ -48,7 +52,11 @@ function decideExperiment({
     });
     return shippedVariant ? {
       type: "shippedVariant",
-      servedPath: servedPathFor({ variant: shippedVariant, logicalPath })
+      servedPath: servedPathFor({
+        experiment,
+        variant: shippedVariant,
+        logicalPath
+      })
     } : null;
   }
   if (!isConsentGranted({ cookies: request.cookies, requiredConsent })) {
@@ -68,7 +76,7 @@ function decideExperiment({
   const variant = forcedVariant ?? keptVariant ?? assignVariant({ visitorId, experiment });
   return {
     type: "assigned",
-    servedPath: servedPathFor({ variant, logicalPath }),
+    servedPath: servedPathFor({ experiment, variant, logicalPath }),
     visitorId,
     assignments: {
       ...keepRunningAssignments({ experiments, assignments: existing }),
@@ -140,14 +148,17 @@ function parseExperiments(rawExperiments) {
     return parsedFiles.get(rawExperiments) ?? null;
   }
   const parsed = experimentsFileSchema.safeParse(rawExperiments);
-  const experiments = parsed.success ? withLivePagesOnly({
-    experiments: parsed.data.experiments,
+  const routing = parsed.success ? {
+    experiments: withLivePagesOnly({
+      experiments: parsed.data.experiments,
+      liveRoutes: parsed.data.liveRoutes
+    }),
     liveRoutes: parsed.data.liveRoutes
-  }) : null;
+  } : null;
   if (isObject) {
-    parsedFiles.set(rawExperiments, experiments);
+    parsedFiles.set(rawExperiments, routing);
   }
-  return experiments;
+  return routing;
 }
 function withLivePagesOnly({
   experiments,
@@ -196,18 +207,19 @@ function isChallengerRoute({
   experiments,
   logicalPath
 }) {
-  const route = normalizeRoute(logicalPath);
   return experiments.filter(isRoutingExperiment).some((experiment) => {
     return experiment.variants.slice(1).some((variant) => {
-      return normalizeRoute(variant.route) === route;
+      return isVariantPath({ variant, pathname: logicalPath });
     });
   });
 }
 function servedPathFor({
+  experiment,
   variant,
   logicalPath
 }) {
-  return normalizeRoute(variant.route) === normalizeRoute(logicalPath) ? null : variant.route;
+  const path = variantPathFor({ experiment, variant, pathname: logicalPath });
+  return path === null || normalizeRoute(path) === normalizeRoute(logicalPath) ? null : path;
 }
 export {
   applyExperimentDecision,