@preprio/toolkit 0.6.0-alpha.2 → 0.6.0-alpha.4

package/dist/nextjs/graphql.cjs

@@ -25,6 +25,7 @@ __export(graphql_exports, {
   PreprError: () => PreprError,
   PreprStack: () => PreprStack,
   createPreprClient: () => createPreprClient2,
+  createPreprProxy: () => createPreprProxy,
   decisionsFrom: () => decisionsFrom,
   isPersonalizedResponse: () => isPersonalizedResponse,
   loadPreprSchema: () => loadPreprSchema,
@@ -36,6 +37,27 @@ __export(graphql_exports, {
 });
 module.exports = __toCommonJS(graphql_exports);
 
+// src/version.ts
+var VERSION = "0.6.0-alpha.4";
+
+// src/core/features.ts
+function isEnabled(config) {
+  if (typeof config === "boolean") return config;
+  return config?.enabled ?? true;
+}
+function resolveFeatures(features) {
+  return {
+    segments: isEnabled(features?.segments),
+    abTesting: isEnabled(features?.abTesting),
+    editMode: isEnabled(features?.editMode)
+  };
+}
+var ALL_FEATURES_ENABLED = Object.freeze({
+  segments: true,
+  abTesting: true,
+  editMode: true
+});
+
 // src/core/server.ts
 var PreprError = class extends Error {
   constructor(message, code, context, originalError) {
@@ -965,6 +987,49 @@ async function loadPreprSchema(url, options = {}) {
   return schema;
 }
 
+// src/core/refresh.ts
+var PREPR_REFRESH_COOKIE = "prepr_refresh";
+var PREPR_REFRESH_HEADER = "Prepr-Refresh";
+var REFRESH_MAX_PATHS = 5;
+var SAFE_PATH = /^\/(?![/\\])[\w\-./%]{0,200}$/;
+function safePath(path) {
+  return SAFE_PATH.test(path) ? path : void 0;
+}
+function isFresh(at, freshFor, now = Date.now()) {
+  const age = now - at;
+  return at > 0 && age >= 0 && age < freshFor;
+}
+function cleanEntries(entries) {
+  const out = [];
+  for (const entry of entries) {
+    if (out.length === REFRESH_MAX_PATHS) break;
+    if (safePath(entry.path) && !out.some((e) => e.path === entry.path)) {
+      out.push(entry);
+    }
+  }
+  return out;
+}
+function parseRefresh(raw) {
+  return cleanEntries(
+    (raw ?? "").split("|").map((pair) => {
+      const split = pair.lastIndexOf("~");
+      const at = Number(split < 0 ? "" : pair.slice(split + 1));
+      return {
+        path: split < 0 ? pair : pair.slice(0, split),
+        at: Number.isFinite(at) && at > 0 ? Math.floor(at) : 0
+      };
+    })
+  );
+}
+function serializeRefresh(entries) {
+  return cleanEntries(entries).map((entry) => `${entry.path}~${Math.floor(entry.at)}`).join("|");
+}
+function parseRefreshPaths(header) {
+  return cleanEntries(
+    (header ?? "").split("|").map((path) => ({ path, at: 0 }))
+  ).map((entry) => entry.path);
+}
+
 // src/nextjs/decisions.ts
 var PREPR_DECISIONS_COOKIE = "prepr_decisions";
 var DECISIONS_MAX_GROUPS = 40;
@@ -996,58 +1061,108 @@ function forwardedHeaders(request, response) {
   }
   return getPreprHeadersFromHeaders(headers2);
 }
-async function resolveDecisionsWith(client, seenGroups, request, response, document2, variables, options) {
-  try {
-    if (options?.onlyIf && !await options.onlyIf()) return;
-    if (!await client.hasSegments(document2, variables)) return;
-    const headers2 = mergePreprHeaders(forwardedHeaders(request, response));
-    const stored = parseDecisions(
-      request.cookies.get(PREPR_DECISIONS_COOKIE)?.value
-    );
-    const pageKey = `${JSON.stringify(variables ?? null)}`;
-    let byVariables = seenGroups.get(document2);
-    if (!byVariables) {
-      byVariables = /* @__PURE__ */ new Map();
-      seenGroups.set(document2, byVariables);
-    }
-    const known = byVariables.get(pageKey);
-    const isNewVisitor = headers2.get("Prepr-Customer-Id-Created") === "true";
-    const contextChanged = isNewVisitor || headers2.has("Prepr-Segments") || [...request.nextUrl.searchParams.keys()].some(
-      (key) => key.startsWith("utm_")
-    );
-    if (options?.reuse !== false && !contextChanged && known && [...known].every((group) => stored.has(group))) {
-      return;
-    }
-    const decided = await client.decide(document2, variables, {
-      topLevelOnly: true,
-      headers: headers2,
-      init: { signal: AbortSignal.timeout(options?.timeoutMs ?? 1e3) }
-    });
-    if (!known && byVariables.size >= SEEN_MAX_PAGES) {
+var preprClientInternals = /* @__PURE__ */ new WeakMap();
+var DEFAULT_FRESH_FOR_MS = 1e4;
+async function decidePage(client, seenGroups, headers2, document2, variables, timeoutMs = 1e3) {
+  if (!await client.hasSegments(document2, variables)) return void 0;
+  const decided = await client.decide(document2, variables, {
+    topLevelOnly: true,
+    headers: headers2,
+    init: { signal: AbortSignal.timeout(timeoutMs) }
+  });
+  let byVariables = seenGroups.get(document2);
+  if (!byVariables) {
+    byVariables = /* @__PURE__ */ new Map();
+    seenGroups.set(document2, byVariables);
+  }
+  const pageKey = JSON.stringify(variables ?? null);
+  let groups = byVariables.get(pageKey);
+  if (!groups) {
+    if (byVariables.size >= SEEN_MAX_PAGES) {
       byVariables.delete(byVariables.keys().next().value);
     }
-    const groups = known ?? /* @__PURE__ */ new Set();
-    for (const group of decided.keys()) groups.add(group);
+    groups = /* @__PURE__ */ new Set();
     byVariables.set(pageKey, groups);
-    const next = /* @__PURE__ */ new Map();
-    for (const [group, variants] of decided) {
-      if (SAFE_ID.test(group)) {
+  }
+  for (const group of decided.keys()) groups.add(group);
+  return decided;
+}
+function writeDecisions(request, response, decided, paths) {
+  const next = /* @__PURE__ */ new Map();
+  for (const decisions of decided) {
+    for (const [group, variants] of decisions) {
+      if (SAFE_ID.test(group) && !next.has(group)) {
         next.set(
           group,
           variants.filter((v) => SAFE_ID.test(v))
         );
       }
     }
-    for (const [group, variants] of stored) {
-      if (!next.has(group)) next.set(group, variants);
+  }
+  for (const [group, variants] of parseDecisions(
+    request.cookies.get(PREPR_DECISIONS_COOKIE)?.value
+  )) {
+    if (!next.has(group)) next.set(group, variants);
+  }
+  const options = {
+    path: "/",
+    sameSite: "lax",
+    httpOnly: false,
+    secure: request.nextUrl.protocol === "https:"
+  };
+  if (next.size > 0) {
+    response.cookies.set(
+      PREPR_DECISIONS_COOKIE,
+      serializeDecisions(next),
+      options
+    );
+  }
+  if (paths.length > 0) {
+    const at = Date.now();
+    response.cookies.set(
+      PREPR_REFRESH_COOKIE,
+      serializeRefresh([
+        ...paths.map((path) => ({ path, at })),
+        ...parseRefresh(request.cookies.get(PREPR_REFRESH_COOKIE)?.value)
+      ]),
+      options
+    );
+  }
+}
+function pagePath(request) {
+  return request.nextUrl.basePath + request.nextUrl.pathname;
+}
+function contextChanged(request, headers2) {
+  return headers2.get("Prepr-Customer-Id-Created") === "true" || headers2.has("Prepr-Segments") || [...request.nextUrl.searchParams.keys()].some(
+    (key) => key.startsWith("utm_")
+  );
+}
+async function resolveDecisionsWith(client, seenGroups, request, response, document2, variables, options) {
+  try {
+    if (options?.onlyIf && !await options.onlyIf()) return;
+    const known = seenGroups.get(document2)?.get(JSON.stringify(variables ?? null));
+    const path = pagePath(request);
+    const headers2 = mergePreprHeaders(forwardedHeaders(request, response));
+    const stored = parseDecisions(
+      request.cookies.get(PREPR_DECISIONS_COOKIE)?.value
+    );
+    const decidedAt = parseRefresh(request.cookies.get(PREPR_REFRESH_COOKIE)?.value).find(
+      (entry) => entry.path === path
+    )?.at ?? 0;
+    const fresh = isFresh(decidedAt, options?.freshFor ?? DEFAULT_FRESH_FOR_MS);
+    if (fresh && known && !contextChanged(request, headers2) && [...known].every((group) => stored.has(group))) {
+      return;
     }
-    if (next.size === 0) return;
-    response.cookies.set(PREPR_DECISIONS_COOKIE, serializeDecisions(next), {
-      path: "/",
-      sameSite: "lax",
-      // Read by the inline switch script before first paint.
-      httpOnly: false
-    });
+    const decided = await decidePage(
+      client,
+      seenGroups,
+      headers2,
+      document2,
+      variables,
+      options?.timeoutMs
+    );
+    if (!decided || decided.size === 0) return;
+    writeDecisions(request, response, [decided], [path]);
   } catch (error) {
     if (isFrameworkSignal(error)) throw error;
   }
@@ -1063,6 +1178,411 @@ async function getPreprHeaders() {
   return getPreprHeadersFromHeaders(h);
 }
 
+// src/nextjs/proxy.ts
+var import_server9 = require("next/server");
+
+// src/core/constants.ts
+var COOKIE_PREVIEW_MODE = "Prepr-Preview-Mode";
+var COOKIE_SEGMENT = "Prepr-Segments";
+var COOKIE_VARIANT = "Prepr-ABtesting";
+var COOKIE_UID = "__prepr_uid";
+var COOKIE_HUBSPOT = "hubspotutk";
+var PARAM_SEGMENT = "prepr_preview_segment";
+var PARAM_VARIANT = "prepr_preview_ab";
+var PARAM_HIDE_BAR = "prepr_hide_bar";
+var ONE_YEAR_SECONDS = 60 * 60 * 24 * 365;
+
+// src/nextjs/bucket.ts
+var PREPR_BUCKET_COOKIE = "prepr_ab_bucket";
+var isBucket = (value) => value === "A" || value === "B";
+function setBucketCookie(request, response, bucket) {
+  response.cookies.set(PREPR_BUCKET_COOKIE, bucket, {
+    path: "/",
+    sameSite: "lax",
+    // Readable on purpose: PreprStack's inline switch reads it before first
+    // paint. It holds only "A" or "B".
+    httpOnly: false,
+    secure: request.nextUrl.protocol === "https:",
+    maxAge: 60 * 60 * 24 * 365
+  });
+}
+async function resolvePreprBucket(request, response, options) {
+  const stored = request.cookies.get(PREPR_BUCKET_COOKIE)?.value;
+  const forced = response.headers.get("x-middleware-request-prepr-abtesting") ?? request.cookies.get(COOKIE_VARIANT)?.value;
+  if (options.preview && isBucket(forced)) {
+    if (forced !== stored) setBucketCookie(request, response, forced);
+    return forced;
+  }
+  if (isBucket(stored)) return stored;
+  if (options.onlyIf) {
+    const needed = await Promise.resolve().then(options.onlyIf).catch(() => true);
+    if (!needed) return "A";
+  }
+  const customerId = request.cookies.get(COOKIE_UID)?.value ?? response.cookies.get(COOKIE_UID)?.value;
+  if (!customerId) return "A";
+  try {
+    const res = await fetch(options.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Prepr-Customer-Id": customerId
+      },
+      body: JSON.stringify({ query: "{ __typename }" }),
+      cache: "no-store",
+      signal: AbortSignal.timeout(options.timeoutMs ?? 1500)
+    });
+    const bucket = res.headers.get("x-prepr-customer-bucket");
+    if (isBucket(bucket)) {
+      setBucketCookie(request, response, bucket);
+      return bucket;
+    }
+  } catch {
+  }
+  return "A";
+}
+
+// src/nextjs/draft.ts
+var import_headers2 = require("next/headers");
+var import_navigation = require("next/navigation");
+var import_server7 = require("next/server");
+var DRAFT_COOKIE = "__prerender_bypass";
+var RETURN_PARAM = "prepr_draft";
+var DEFAULT_ROUTE = "/api/prepr/draft";
+function preprDraftRedirect(request, options) {
+  if (!options.preview) return null;
+  if (request.method !== "GET" && request.method !== "HEAD") return null;
+  const url = request.nextUrl;
+  if (url.pathname === (options.route ?? DEFAULT_ROUTE)) return null;
+  if (request.cookies.has(DRAFT_COOKIE)) {
+    if (!url.searchParams.has(RETURN_PARAM)) return null;
+    const clean = url.clone();
+    clean.searchParams.delete(RETURN_PARAM);
+    return import_server7.NextResponse.redirect(clean, 307);
+  }
+  if (url.searchParams.has(RETURN_PARAM)) return null;
+  const target = new URL(options.route ?? DEFAULT_ROUTE, request.url);
+  target.searchParams.set("to", url.pathname + url.search);
+  return import_server7.NextResponse.redirect(target, 307);
+}
+
+// src/nextjs/middleware.ts
+var import_server8 = require("next/server");
+
+// src/core/middleware.ts
+var UTM_PARAMS = [
+  "utm_source",
+  "utm_medium",
+  "utm_term",
+  "utm_content",
+  "utm_campaign"
+];
+var MAX_HEADER_VALUE_LENGTH = 2048;
+function sanitizeHeaderValue(value) {
+  const stripped = value.replace(/[\u0000-\u001f\u007f]/g, "");
+  return stripped.length > MAX_HEADER_VALUE_LENGTH ? stripped.slice(0, MAX_HEADER_VALUE_LENGTH) : stripped;
+}
+function parseCookies(request) {
+  const cookies2 = /* @__PURE__ */ new Map();
+  const header = request.headers.get("cookie");
+  if (!header) return cookies2;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const name2 = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (!name2) continue;
+    try {
+      cookies2.set(name2, decodeURIComponent(value));
+    } catch {
+      cookies2.set(name2, value);
+    }
+  }
+  return cookies2;
+}
+function processFrameworkRequest(request, opts, framework) {
+  const requestHeaders = new Headers(request.headers);
+  const responseCookies = [];
+  const inboundPreprHeaders = [];
+  requestHeaders.forEach((_value, key) => {
+    if (key.toLowerCase().startsWith("prepr-")) {
+      inboundPreprHeaders.push(key);
+    }
+  });
+  for (const key of inboundPreprHeaders) {
+    requestHeaders.delete(key);
+  }
+  const requestCookies = parseCookies(request);
+  const url = new URL(request.url);
+  const searchParams = url.searchParams;
+  const forwardedProto = request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
+  const isSecure = forwardedProto ? forwardedProto === "https" : url.protocol === "https:";
+  const crossSite = isSecure ? { sameSite: "None", secure: true } : {};
+  for (const key of UTM_PARAMS) {
+    const value = searchParams.get(key);
+    if (value !== null) {
+      requestHeaders.set(`Prepr-Context-${key}`, sanitizeHeaderValue(value));
+    }
+  }
+  const referer = request.headers.get("referer");
+  if (referer) {
+    requestHeaders.set(
+      "Prepr-Context-initial_referral",
+      sanitizeHeaderValue(referer)
+    );
+  }
+  const userAgent = request.headers.get("user-agent");
+  if (userAgent) {
+    requestHeaders.set("User-Agent", sanitizeHeaderValue(userAgent));
+  }
+  const packageParts = [`@preprio/toolkit@${opts?.version ?? VERSION}`];
+  if (framework) packageParts.push(`framework=${framework}`);
+  packageParts.push(`preview=${opts?.preview ? "true" : "false"}`);
+  requestHeaders.set("Prepr-Package", packageParts.join("; "));
+  const ip = request.headers.get("Cf-Connecting-Ip") ?? request.headers.get("x-real-ip");
+  if (ip) {
+    requestHeaders.set("Prepr-Visitor-IP", sanitizeHeaderValue(ip));
+  }
+  const hutkCookie = requestCookies.get(COOKIE_HUBSPOT);
+  if (hutkCookie) {
+    requestHeaders.set("Prepr-Hubspot-Id", sanitizeHeaderValue(hutkCookie));
+  }
+  let uid = sanitizeHeaderValue(requestCookies.get(COOKIE_UID) ?? "");
+  if (!uid) {
+    uid = crypto.randomUUID();
+    responseCookies.push({
+      name: COOKIE_UID,
+      value: uid,
+      maxAge: ONE_YEAR_SECONDS,
+      path: "/"
+    });
+    requestHeaders.set("Prepr-Customer-Id-Created", "true");
+  }
+  requestHeaders.set("Prepr-Customer-Id", uid);
+  if (!opts?.preview) {
+    return { requestHeaders, responseCookies };
+  }
+  const features = resolveFeatures(opts?.features);
+  const hasPreviewParams = features.segments && searchParams.has(PARAM_SEGMENT) || features.abTesting && searchParams.has(PARAM_VARIANT);
+  if (!hasPreviewParams) {
+    const previewModeCookie = requestCookies.get(COOKIE_PREVIEW_MODE);
+    const previewModeEnabled = previewModeCookie !== "false";
+    if (!previewModeEnabled) {
+      return { requestHeaders, responseCookies };
+    }
+  }
+  requestHeaders.set("Prepr-Preview-Bar", "true");
+  const isLivePreview = searchParams.get(PARAM_HIDE_BAR) === "true";
+  if (!isLivePreview && !requestCookies.has(COOKIE_PREVIEW_MODE)) {
+    responseCookies.push({
+      name: COOKIE_PREVIEW_MODE,
+      value: "true",
+      maxAge: ONE_YEAR_SECONDS,
+      path: "/",
+      ...crossSite
+    });
+  }
+  if (!isLivePreview) {
+    const segmentCookie = features.segments ? requestCookies.get(COOKIE_SEGMENT) : void 0;
+    if (segmentCookie) {
+      requestHeaders.set("Prepr-Segments", sanitizeHeaderValue(segmentCookie));
+    }
+    const abCookie = features.abTesting ? requestCookies.get(COOKIE_VARIANT) : void 0;
+    if (abCookie) {
+      requestHeaders.set("Prepr-ABtesting", sanitizeHeaderValue(abCookie));
+    }
+  }
+  const previewAb = features.abTesting ? searchParams.get(PARAM_VARIANT) : null;
+  if (previewAb !== null) {
+    requestHeaders.set("Prepr-ABtesting", sanitizeHeaderValue(previewAb));
+    if (!isLivePreview) {
+      responseCookies.push({
+        name: COOKIE_VARIANT,
+        value: previewAb,
+        maxAge: ONE_YEAR_SECONDS,
+        path: "/",
+        ...crossSite
+      });
+    }
+  }
+  const previewSegment = features.segments ? searchParams.get(PARAM_SEGMENT) : null;
+  if (previewSegment !== null) {
+    requestHeaders.set("Prepr-Segments", sanitizeHeaderValue(previewSegment));
+    if (!isLivePreview) {
+      responseCookies.push({
+        name: COOKIE_SEGMENT,
+        value: previewSegment,
+        maxAge: ONE_YEAR_SECONDS,
+        path: "/",
+        ...crossSite
+      });
+    }
+  }
+  if (requestHeaders.has("Prepr-Segments")) {
+    requestHeaders.delete("Prepr-Customer-Id");
+    requestHeaders.delete("Prepr-Customer-Id-Created");
+  }
+  return { requestHeaders, responseCookies };
+}
+
+// src/nextjs/middleware.ts
+function createPreprMiddleware(request, responseOrOptions, maybeOptions) {
+  let chainedResponse;
+  let options;
+  if (responseOrOptions instanceof import_server8.NextResponse) {
+    chainedResponse = responseOrOptions;
+    options = maybeOptions;
+  } else {
+    options = responseOrOptions;
+  }
+  const { requestHeaders, responseCookies } = processFrameworkRequest(
+    request,
+    options,
+    "nextjs"
+  );
+  const response = chainedResponse ?? import_server8.NextResponse.next({ request: { headers: requestHeaders } });
+  if (chainedResponse) {
+    const existing = response.headers.get("x-middleware-override-headers");
+    const names = new Set(
+      existing ? existing.split(",").map((name2) => name2.trim()).filter(Boolean) : []
+    );
+    requestHeaders.forEach((value, key) => {
+      names.add(key);
+      response.headers.set(`x-middleware-request-${key}`, value);
+    });
+    response.headers.set("x-middleware-override-headers", [...names].join(","));
+  }
+  for (const cookie of responseCookies) {
+    response.cookies.set(cookie.name, cookie.value, {
+      maxAge: cookie.maxAge,
+      path: cookie.path,
+      // Lower-cased: Next's cookie API expects 'none' | 'lax' | 'strict'.
+      ...cookie.sameSite ? {
+        sameSite: cookie.sameSite.toLowerCase()
+      } : {},
+      ...cookie.secure ? { secure: true } : {}
+    });
+  }
+  return response;
+}
+
+// src/nextjs/proxy.ts
+function isPagePath(pathname) {
+  return !pathname.startsWith("/_next/") && !pathname.startsWith("/api/") && !/\.[^/]*$/.test(pathname);
+}
+function createPreprProxy(options) {
+  const internals = preprClientInternals.get(options.client);
+  if (!internals) {
+    throw new PreprError(
+      "createPreprProxy needs a client made by createPreprClient from @preprio/toolkit/nextjs/graphql",
+      "CONTEXT_ERROR",
+      "createPreprProxy"
+    );
+  }
+  const { client, seenGroups, url } = internals;
+  const preview = options.preview ?? false;
+  const allowed = async (request) => {
+    if (!options.onlyIf) return true;
+    try {
+      return await options.onlyIf(request);
+    } catch {
+      return false;
+    }
+  };
+  const lookup = (target) => {
+    try {
+      return options.page(target) ?? null;
+    } catch {
+      return null;
+    }
+  };
+  async function refresh(request, response, paths) {
+    const answer = new import_server9.NextResponse(null, {
+      status: 204,
+      headers: { "Cache-Control": "no-store" }
+    });
+    for (const cookie of response.cookies.getAll()) answer.cookies.set(cookie);
+    const site = request.headers.get("sec-fetch-site");
+    if (request.method !== "GET" || site !== null && site !== "same-origin" || !await allowed(request)) {
+      return answer;
+    }
+    const own = new Set(
+      parseRefresh(request.cookies.get(PREPR_REFRESH_COOKIE)?.value).map(
+        (entry) => entry.path
+      )
+    );
+    const basePath = request.nextUrl.basePath;
+    const headers2 = mergePreprHeaders(forwardedHeaders(request, response));
+    const decided = await Promise.all(
+      paths.map(async (path) => {
+        if (!own.has(path) || !path.startsWith(basePath)) return void 0;
+        const pathname = path.slice(basePath.length) || "/";
+        if (!isPagePath(pathname)) return void 0;
+        const target = lookup(new URL(pathname, request.url));
+        if (!target) return void 0;
+        try {
+          const decisions = await decidePage(
+            client,
+            seenGroups,
+            headers2,
+            target.document,
+            target.variables,
+            options.timeoutMs
+          );
+          return decisions?.size ? [path, decisions] : void 0;
+        } catch (error) {
+          if (isFrameworkSignal(error)) throw error;
+          return void 0;
+        }
+      })
+    );
+    const found = decided.filter((entry) => entry !== void 0);
+    writeDecisions(
+      request,
+      answer,
+      found.map(([, decisions]) => decisions),
+      found.map(([path]) => path)
+    );
+    return answer;
+  }
+  return async (request) => {
+    if (request.headers.has(PREPR_REFRESH_HEADER)) {
+      return refresh(
+        request,
+        createPreprMiddleware(request, { preview, features: options.features }),
+        parseRefreshPaths(request.headers.get(PREPR_REFRESH_HEADER))
+      );
+    }
+    const target = isPagePath(request.nextUrl.pathname) ? lookup(request.nextUrl) : null;
+    if (target && preview) {
+      const draft = preprDraftRedirect(request, { preview });
+      if (draft) return draft;
+    }
+    const response = createPreprMiddleware(request, {
+      preview,
+      features: options.features
+    });
+    if (target && await allowed(request)) {
+      await Promise.all([
+        resolvePreprBucket(request, response, {
+          url,
+          preview,
+          onlyIf: () => options.client.hasAbTests(target.document, target.variables)
+        }),
+        resolveDecisionsWith(
+          client,
+          seenGroups,
+          request,
+          response,
+          target.document,
+          target.variables,
+          { freshFor: options.freshFor, timeoutMs: options.timeoutMs }
+        )
+      ]);
+    }
+    return response;
+  };
+}
+
 // src/nextjs/stack.ts
 var import_react = require("react");
 
@@ -1089,7 +1609,11 @@ function applyPreprAbBucket() {
     state.__preprAbSheet.textContent = css;
   }
 }
-function applyPreprDecisions() {
+function applyPreprDecisions(view) {
+  const viewState = window;
+  const current = view === void 0 ? location.pathname + location.search : view;
+  if (viewState.__preprDecisionsView === current) return;
+  viewState.__preprDecisionsView = current;
   const match = document.cookie.match(/(?:^|; )prepr_decisions=([^;]*)/);
   let raw;
   try {
@@ -1153,13 +1677,18 @@ function renderBuckets(items, render, options) {
     abTest,
     index,
     track,
-    placeholder = false
+    placeholder = false,
+    defaultVariant = true
   } = options;
   const renderVariant = (variant, key) => {
     const resolved = resolveVariants(items, { decisions, bucket: variant });
-    const content = render(resolved, { index, placeholder });
-    const variantKeys = track ? variantKeysOf(resolved) : [];
     const ab = abTest && !bucket ? variant : void 0;
+    const content = render(resolved, {
+      index,
+      placeholder,
+      defaultVariant: defaultVariant && (ab === void 0 || ab === "A")
+    });
+    const variantKeys = track ? variantKeysOf(resolved) : [];
     if (variantKeys.length > 0) {
       return (0, import_react.createElement)(
         import_components.PreprVariantTracking,
@@ -1197,7 +1726,8 @@ function renderAllVariants(block, render, options) {
         decisions: /* @__PURE__ */ new Map([[group, [variant]]]),
         abTest: false,
         index: block.index,
-        track: options.track
+        track: options.track,
+        defaultVariant: variant === PREPR_DEFAULT_VARIANT
       })
     )
   );
@@ -1230,7 +1760,7 @@ function PreprStack({
   bucket,
   nonce,
   trackVariants = false,
-  aboveTheFold = 0
+  aboveTheFold = 1
 }) {
   decisions.catch(() => void 0);
   const blocks = splitStack(items);
@@ -1253,7 +1783,8 @@ function PreprStack({
         nonce,
         dangerouslySetInnerHTML: { __html: AB_SWITCH_SCRIPT }
       }),
-      (0, import_react.createElement)(import_components.PreprAbSwitch)
+      (0, import_react.createElement)(import_components.PreprAbSwitch),
+      hasDecided && (0, import_react.createElement)(import_components.PreprPersonalizationSwitch, { refresh: false })
     ),
     ...blocks.map((block) => {
       if (decidedInProxy(block)) {
@@ -1302,7 +1833,7 @@ function createPreprClient2(options) {
     ...coreOptions
   });
   const seenGroups = /* @__PURE__ */ new Map();
-  return {
+  const nextClient = {
     async query(document2, variables, queryOptions = {}) {
       const { personalize = false, ...rest } = queryOptions;
       const init = rest.init;
@@ -1343,6 +1874,12 @@ function createPreprClient2(options) {
       options2
     )
   };
+  preprClientInternals.set(nextClient, {
+    client,
+    seenGroups,
+    url: coreOptions.url
+  });
+  return nextClient;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1351,6 +1888,7 @@ function createPreprClient2(options) {
   PreprError,
   PreprStack,
   createPreprClient,
+  createPreprProxy,
   decisionsFrom,
   isPersonalizedResponse,
   loadPreprSchema,