@preprio/toolkit 0.6.0-alpha.1 → 0.6.0-alpha.10

package/dist/nextjs/graphql.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name2 in all)
@@ -15,19 +17,30 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/nextjs/graphql.ts
 var graphql_exports = {};
 __export(graphql_exports, {
-  PREPR_DECISIONS_COOKIE: () => PREPR_DECISIONS_COOKIE,
+  PREPR_ANY_ITEM_TAG: () => PREPR_ANY_ITEM_TAG,
   PREPR_DEFAULT_VARIANT: () => PREPR_DEFAULT_VARIANT,
   PreprError: () => PreprError,
   PreprStack: () => PreprStack,
   createPreprClient: () => createPreprClient2,
+  createPreprProxy: () => createPreprProxy,
   decisionsFrom: () => decisionsFrom,
   isPersonalizedResponse: () => isPersonalizedResponse,
   loadPreprSchema: () => loadPreprSchema,
+  preprCacheTags: () => preprCacheTags,
+  preprModelTag: () => preprModelTag,
   preprVariantProps: () => preprVariantProps,
   resolveVariants: () => resolveVariants,
   splitStack: () => splitStack,
@@ -35,6 +48,78 @@ __export(graphql_exports, {
   toVariantsQuery: () => toVariantsQuery
 });
 module.exports = __toCommonJS(graphql_exports);
+var nextCache = __toESM(require("next/cache"), 1);
+
+// src/core/graphql/cache-tags.ts
+var MAX_TAGS = 128;
+var MAX_TAG_LENGTH = 256;
+var PREPR_ANY_ITEM_TAG = "prepr:any";
+var PREPR_SCHEMA_TAG = "prepr:schema";
+var preprItemTag = (id) => `prepr:${id}`;
+var NOT_ALPHANUMERIC = /[^a-z0-9]/g;
+var preprModelTag = (model) => `prepr:model:${model.toLowerCase().replace(NOT_ALPHANUMERIC, "")}`;
+function preprModelTagsFor(document2, data, schema) {
+  const operation = document2.definitions.find(
+    (definition) => definition.kind === "OperationDefinition" && definition.operation === "query"
+  );
+  const root = schema.types[schema.queryType];
+  if (!operation || !root) return [];
+  const models = (type) => {
+    const members = schema.types[type]?.possibleTypes ?? [];
+    return members.length > 0 ? members : [type];
+  };
+  const tags = /* @__PURE__ */ new Set();
+  for (const selection of operation.selectionSet.selections) {
+    if (selection.kind !== "Field") continue;
+    const type = root.fields[selection.name.value]?.type;
+    const info = type ? schema.types[type] : void 0;
+    if (!type || !info) continue;
+    const items = info.fields.items?.type;
+    const key = (selection.alias ?? selection.name).value;
+    const found = typeof data === "object" && data !== null && data[key] != null;
+    const affected = items ? models(items) : found ? [] : models(type);
+    for (const model of affected) tags.add(preprModelTag(model));
+  }
+  return [...tags];
+}
+function preprCacheTags(data) {
+  const tags = /* @__PURE__ */ new Set();
+  const stack = [data];
+  while (stack.length > 0) {
+    const value = stack.pop();
+    if (typeof value !== "object" || value === null) continue;
+    const id = value._id;
+    if (typeof id === "string" && id !== "") {
+      const tag = preprItemTag(id);
+      if (tag.length > MAX_TAG_LENGTH) return [PREPR_ANY_ITEM_TAG];
+      tags.add(tag);
+      if (tags.size > MAX_TAGS) return [PREPR_ANY_ITEM_TAG];
+    }
+    for (const child of Object.values(value)) stack.push(child);
+  }
+  return [...tags];
+}
+
+// src/version.ts
+var VERSION = "0.6.0-alpha.10";
+
+// 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 {
@@ -180,7 +265,10 @@ function decisionSelectionSet(set, typeName, path, ctx) {
         path,
         ctx
       );
-      if (pruned) {
+      if (!pruned) continue;
+      if (fragment.typeCondition.name.value === typeName) {
+        selections.push(...pruned.selections);
+      } else {
         selections.push(
           inlineFragment(fragment.typeCondition.name.value, [
             ...pruned.selections
@@ -190,13 +278,19 @@ function decisionSelectionSet(set, typeName, path, ctx) {
       continue;
     }
     if (selection.kind === "InlineFragment") {
+      const condition = selection.typeCondition?.name.value ?? typeName;
       const pruned = decisionSelectionSet(
         selection.selectionSet,
-        selection.typeCondition?.name.value ?? typeName,
+        condition,
         path,
         ctx
       );
-      if (pruned) selections.push({ ...selection, selectionSet: pruned });
+      if (!pruned) continue;
+      if (condition === typeName && !selection.directives?.length) {
+        selections.push(...pruned.selections);
+      } else {
+        selections.push({ ...selection, selectionSet: pruned });
+      }
       continue;
     }
     if (!selection.selectionSet) continue;
@@ -270,20 +364,58 @@ function toDecisionDocument(document2, schema, groupPaths, options) {
   const used = /* @__PURE__ */ new Set();
   collectVariables(pruned, used);
   collectVariables(operation.directives, used);
+  const shared = sharedContextFragment(schema);
   return {
     kind: "Document",
     definitions: [
+      ...shared ? [shared.definition] : [],
       {
         ...operation,
         name: operation.name && name(`${operation.name.value}Decision`),
         variableDefinitions: (operation.variableDefinitions ?? []).filter(
           (definition) => used.has(definition.variable.name.value)
         ),
-        selectionSet: pruned
+        selectionSet: shared ? shared.apply(pruned) : pruned
       }
     ]
   };
 }
+function sharedContextFragment(schema) {
+  const contextTypes = new Set(
+    Object.values(schema.types).flatMap(
+      (type) => type.hasContext ? [type.fields._context.type] : []
+    )
+  );
+  if (contextTypes.size !== 1) return null;
+  const [contextType] = contextTypes;
+  const fragmentName = "c";
+  const definition = {
+    kind: "FragmentDefinition",
+    name: name(fragmentName),
+    typeCondition: { kind: "NamedType", name: name(contextType) },
+    selectionSet: selectionSet(
+      ["kind", "group_id", "variant_id"].map(
+        (field) => ({ kind: "Field", name: name(field) })
+      )
+    )
+  };
+  const spread = {
+    kind: "FragmentSpread",
+    name: name(fragmentName)
+  };
+  const apply = (set) => selectionSet(
+    set.selections.map((selection) => {
+      if (selection.kind === "Field" && selection.alias?.value === PREPR_CONTEXT_ALIAS) {
+        return { ...selection, selectionSet: selectionSet([spread]) };
+      }
+      return "selectionSet" in selection && selection.selectionSet ? {
+        ...selection,
+        selectionSet: apply(selection.selectionSet)
+      } : selection;
+    })
+  );
+  return { definition, apply };
+}
 
 // src/core/variants/probe-document.ts
 function probeSelectionSet(set, fragments) {
@@ -864,6 +996,7 @@ function createVaryProbe(run, options) {
 }
 
 // src/core/graphql/client.ts
+var clientSchemas = /* @__PURE__ */ new WeakMap();
 function isParseableUrl(url) {
   try {
     new URL(url);
@@ -900,7 +1033,7 @@ function createPreprClient(options) {
   ));
   const variantsDocuments = /* @__PURE__ */ new Map();
   const decisionDocuments = /* @__PURE__ */ new Map();
-  return {
+  const client = {
     async query(document2, variables, queryOptions = {}) {
       const { variants, ...rest } = queryOptions;
       if (!variants) return run(document2, variables, rest);
@@ -912,10 +1045,10 @@ function createPreprClient(options) {
       return run(derived, variables, rest);
     },
     async decide(document2, variables, queryOptions = {}) {
-      const { from, topLevelOnly, ...rest } = queryOptions;
+      const { from, ...rest } = queryOptions;
       const paths = from === void 0 ? void 0 : personalizationPaths(from);
       if (paths && paths.size === 0) return /* @__PURE__ */ new Map();
-      const signature = paths ? [...paths].map(([path, types]) => `${path}:${[...types].sort().join(",")}`).sort().join("|") : topLevelOnly ? "top" : "*";
+      const signature = paths ? [...paths].map(([path, types]) => `${path}:${[...types].sort().join(",")}`).sort().join("|") : "*";
       let byPaths = decisionDocuments.get(document2);
       if (!byPaths) {
         byPaths = /* @__PURE__ */ new Map();
@@ -923,9 +1056,7 @@ function createPreprClient(options) {
       }
       let derived = byPaths.get(signature);
       if (derived === void 0) {
-        derived = toDecisionDocument(document2, await loadSchema(), paths, {
-          topLevelOnly: !paths && topLevelOnly
-        });
+        derived = toDecisionDocument(document2, await loadSchema(), paths);
         byPaths.set(signature, derived);
       }
       if (!derived) return /* @__PURE__ */ new Map();
@@ -939,6 +1070,8 @@ function createPreprClient(options) {
       (vary) => vary === null || SEGMENTS_VARY.test(vary)
     )
   };
+  clientSchemas.set(client, loadSchema);
+  return client;
 }
 
 // src/core/graphql/schema-loader.ts
@@ -966,25 +1099,62 @@ async function loadPreprSchema(url, options = {}) {
 }
 
 // src/nextjs/decisions.ts
+var PREPR_DECIDE_HEADER = "Prepr-Decide";
+var DEFAULT_DECISION = "*";
 var PREPR_DECISIONS_COOKIE = "prepr_decisions";
-var DECISIONS_MAX_GROUPS = 40;
-var SAFE_ID = /^[\w-]+$/;
-var SEEN_MAX_PAGES = 1e3;
-function parseDecisions(raw) {
-  const out = /* @__PURE__ */ new Map();
-  for (const pair of (raw ?? "").split("~")) {
-    const at = pair.indexOf(":");
-    const group = pair.slice(0, at);
-    if (at < 1 || !SAFE_ID.test(group)) continue;
-    out.set(
-      group,
-      pair.slice(at + 1).split("|").filter((variant) => SAFE_ID.test(variant))
-    );
+var DECISION_FRESH_MS = 1e4;
+var DECISION_KEEP_MS = 18e5;
+var DECISION_KEEP_STATIC_MS = 36e5;
+var STORED_MAX_ENTRIES = 20;
+var STORED_MAX_LENGTH = 3e3;
+function readStoredDecisions(raw) {
+  const stored = /* @__PURE__ */ Object.create(null);
+  if (!raw) return stored;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return stored;
+    for (const [key, entry] of Object.entries(parsed)) {
+      if (key.startsWith("/") && Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "number") {
+        stored[key] = [entry[0], entry[1]];
+      }
+    }
+  } catch {
+  }
+  return stored;
+}
+function usableDecision(stored, key, now) {
+  const entry = stored[key];
+  if (!entry) return void 0;
+  const [value, at] = entry;
+  const age = now - at;
+  const keep = value === DEFAULT_DECISION ? DECISION_FRESH_MS : value === "" ? DECISION_KEEP_STATIC_MS : DECISION_KEEP_MS;
+  return age >= 0 && age < keep ? value : void 0;
+}
+function writeStoredDecisions(stored, key, value, now) {
+  const kept = usableDecision(stored, key, now);
+  const entries = Object.entries(stored).filter(
+    ([stale]) => stale !== key && usableDecision(stored, stale, now) !== void 0
+  );
+  entries.push([
+    key,
+    value === DEFAULT_DECISION && kept !== void 0 && kept !== DEFAULT_DECISION ? stored[key] : [value, now]
+  ]);
+  entries.sort((a, b) => b[1][1] - a[1][1]);
+  entries.length = Math.min(entries.length, STORED_MAX_ENTRIES);
+  let json = JSON.stringify(Object.fromEntries(entries));
+  while (entries.length > 1 && encodeURIComponent(json).length > STORED_MAX_LENGTH) {
+    entries.pop();
+    json = JSON.stringify(Object.fromEntries(entries));
   }
-  return out;
+  return json;
 }
+var DECISIONS_MAX_GROUPS = 40;
+var SAFE_ID = /^[\w-]+$/;
 function serializeDecisions(decisions) {
-  return [...decisions].slice(0, DECISIONS_MAX_GROUPS).map(([group, variants]) => `${group}:${variants.join("|")}`).join("~");
+  return [...decisions].filter(([group]) => SAFE_ID.test(group)).slice(0, DECISIONS_MAX_GROUPS).map(
+    ([group, variants]) => `${group}:${variants.filter((v) => SAFE_ID.test(v)).join("|")}`
+  ).join("~");
 }
 function forwardedHeaders(request, response) {
   const overridden = response.headers.get("x-middleware-override-headers");
@@ -996,60 +1166,17 @@ function forwardedHeaders(request, response) {
   }
   return getPreprHeadersFromHeaders(headers2);
 }
-async function resolveDecisionsWith(client, seenGroups, request, response, document2, variables, options) {
+var preprClientInternals = /* @__PURE__ */ new WeakMap();
+async function decideView(client, headers2, page, timeoutMs = 1e3) {
+  const init = { signal: AbortSignal.timeout(timeoutMs) };
   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) {
-      byVariables.delete(byVariables.keys().next().value);
-    }
-    const groups = known ?? /* @__PURE__ */ new Set();
-    for (const group of decided.keys()) groups.add(group);
-    byVariables.set(pageKey, groups);
-    const next = /* @__PURE__ */ new Map();
-    for (const [group, variants] of decided) {
-      if (SAFE_ID.test(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);
-    }
-    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 = page.decision ? decisionsFrom(
+      (await client.query(page.decision, page.variables, { headers: headers2, init })).data
+    ) : await client.decide(page.document, page.variables, { headers: headers2, init });
+    return serializeDecisions(decided);
   } catch (error) {
     if (isFrameworkSignal(error)) throw error;
+    return DEFAULT_DECISION;
   }
 }
 
@@ -1063,227 +1190,668 @@ async function getPreprHeaders() {
   return getPreprHeadersFromHeaders(h);
 }
 
-// src/nextjs/stack.ts
-var import_react = require("react");
+// src/nextjs/proxy.ts
+var import_server9 = require("next/server");
 
-// src/nextjs/ab-switch.ts
-function applyPreprAbBucket() {
-  const match = document.cookie.match(/(?:^|; )prepr_ab_bucket=([AB])(?:;|$)/);
-  const bucket = match ? match[1] : "A";
-  const state = window;
-  if (state.__preprAbBucket === bucket) return;
-  state.__preprAbBucket = bucket;
-  const css = bucket === "A" ? "" : '[data-prepr-ab="A"]{display:none!important}[data-prepr-ab="' + bucket + '"]{display:contents!important}';
-  try {
-    if (!state.__preprAbSheet) {
-      const sheet = new CSSStyleSheet();
-      document.adoptedStyleSheets = document.adoptedStyleSheets.concat(sheet);
-      state.__preprAbSheet = sheet;
+// 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/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/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);
     }
-    state.__preprAbSheet.replaceSync(css);
-  } catch {
-    if (!state.__preprAbSheet) {
-      state.__preprAbSheet = document.createElement("style");
-      document.head.appendChild(state.__preprAbSheet);
+  }
+  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
+      });
     }
-    state.__preprAbSheet.textContent = css;
   }
+  if (requestHeaders.has("Prepr-Segments")) {
+    requestHeaders.delete("Prepr-Customer-Id");
+    requestHeaders.delete("Prepr-Customer-Id-Created");
+  }
+  return { requestHeaders, responseCookies };
 }
-function applyPreprDecisions() {
-  const match = document.cookie.match(/(?:^|; )prepr_decisions=([^;]*)/);
-  let raw;
-  try {
-    raw = match ? decodeURIComponent(match[1]) : "";
-  } catch {
-    raw = "";
+
+// 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 state = window;
-  if (state.__preprDecisions === raw) return;
-  state.__preprDecisions = raw;
-  const id = /^[\w-]+$/;
-  let css = "";
-  raw.split("~").forEach((pair) => {
-    const at = pair.indexOf(":");
-    const group = pair.slice(0, at);
-    if (at < 1 || !id.test(group)) return;
-    const selector = '[data-prepr-group="' + group + '"]';
-    css += selector + "{display:none!important}";
-    pair.slice(at + 1).split("|").forEach((variant) => {
-      if (id.test(variant)) {
-        css += selector + '[data-prepr-variant="' + variant + '"]{display:contents!important}';
+  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 isRouterFetch(request) {
+  return request.headers.has("rsc") || request.headers.has("next-url") || request.headers.get("sec-fetch-dest") === "empty";
+}
+var STATIC_PAGE_MS = 3e5;
+var STATIC_PAGES_MAX = 1e3;
+var staticPages = /* @__PURE__ */ new Map();
+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 } = 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 answerDecision(request, response, target) {
+    let decision = DEFAULT_DECISION;
+    const site = request.headers.get("sec-fetch-site");
+    if (target && request.method === "GET" && (site === null || site === "same-origin") && await allowed(request)) {
+      decision = await decideView(
+        client,
+        mergePreprHeaders(forwardedHeaders(request, response)),
+        target,
+        options.timeoutMs
+      );
+    }
+    const answer = new import_server9.NextResponse(decision, {
+      headers: {
+        "Cache-Control": "private, no-store",
+        "Content-Type": "text/plain; charset=utf-8"
+      }
+    });
+    for (const cookie of response.cookies.getAll()) answer.cookies.set(cookie);
+    return answer;
+  }
+  async function decidePageLoad(request, response, target) {
+    const { basePath, pathname, search } = request.nextUrl;
+    const key = basePath + pathname + search;
+    const now = Date.now();
+    if ((staticPages.get(key) ?? 0) > now) return response;
+    const stored = readStoredDecisions(
+      request.cookies.get(PREPR_DECISIONS_COOKIE)?.value
+    );
+    if (!preview && usableDecision(stored, key, now) !== void 0)
+      return response;
+    if (!await allowed(request)) return response;
+    const decision = await decideView(
+      client,
+      mergePreprHeaders(forwardedHeaders(request, response)),
+      target,
+      options.timeoutMs
+    );
+    if (decision === "") {
+      if (staticPages.size >= STATIC_PAGES_MAX) staticPages.clear();
+      staticPages.set(key, now + STATIC_PAGE_MS);
+      return response;
+    }
+    response.cookies.set(
+      PREPR_DECISIONS_COOKIE,
+      writeStoredDecisions(stored, key, decision, now),
+      {
+        path: "/",
+        maxAge: 3600,
+        sameSite: "lax",
+        secure: request.nextUrl.protocol === "https:"
       }
+    );
+    return response;
+  }
+  return async (request) => {
+    const rendersPage = (request.method === "GET" || request.method === "HEAD") && isPagePath(request.nextUrl.pathname);
+    const target = rendersPage ? lookup(request.nextUrl) : null;
+    const decisionRequest = request.headers.has(PREPR_DECIDE_HEADER);
+    if (target && preview && !decisionRequest) {
+      const draft = preprDraftRedirect(request, { preview });
+      if (draft) return draft;
+    }
+    const response = createPreprMiddleware(request, {
+      preview,
+      features: options.features
+    });
+    if (decisionRequest) return answerDecision(request, response, target);
+    if (target && request.method === "GET" && !isRouterFetch(request))
+      return decidePageLoad(request, response, target);
+    return response;
+  };
+}
+
+// src/nextjs/stack.ts
+var import_react = require("react");
+
+// src/nextjs/decision-switch.ts
+function applyPreprDecisions(decision, options = {}) {
+  const state = window;
+  const key = location.pathname + location.search;
+  const previous = state.__preprDecision;
+  let value = decision;
+  if (value !== void 0 && value !== "*" && options.refresh && previous && previous.key === key && previous.value !== "*") {
+    const pairs = (from) => {
+      const out = {};
+      from.split("~").forEach((pair) => {
+        const colon = pair.indexOf(":");
+        if (colon > 0) out[pair.slice(0, colon)] = pair;
+      });
+      return out;
+    };
+    const before = pairs(previous.value);
+    const after = pairs(value);
+    document.querySelectorAll("[data-prepr-v][data-prepr-show]").forEach((element) => {
+      const range = document.createRange();
+      range.selectNodeContents(element);
+      if (range.getBoundingClientRect().top >= window.innerHeight) return;
+      (element.getAttribute("data-prepr-v") || "").split(" ").forEach((token) => {
+        const group = token.slice(0, token.indexOf(":"));
+        if (before[group]) after[group] = before[group];
+      });
     });
+    value = Object.keys(after).map((group) => after[group]).join("~");
+  }
+  if (value !== void 0) state.__preprDecision = { key, value };
+  const current = state.__preprDecision;
+  if (!current || current.key !== key) return false;
+  document.querySelectorAll("[data-prepr-decision]").forEach((marker) => {
+    marker.setAttribute("data-prepr-decided", "");
   });
-  try {
-    if (!state.__preprDecisionSheet) {
-      const sheet = new CSSStyleSheet();
-      document.adoptedStyleSheets = document.adoptedStyleSheets.concat(sheet);
-      state.__preprDecisionSheet = sheet;
+  const defaults = current.value === "*";
+  const chosen = {};
+  current.value.split("~").forEach((pair) => {
+    const colon = pair.indexOf(":");
+    if (colon > 0)
+      chosen[pair.slice(0, colon)] = pair.slice(colon + 1).split("|");
+  });
+  document.querySelectorAll("[data-prepr-v]").forEach((element) => {
+    const nested = element.hasAttribute("data-prepr-nested");
+    const show = defaults ? element.hasAttribute("data-prepr-default") : (element.getAttribute("data-prepr-v") || "").split(" ").every((token) => {
+      const colon = token.indexOf(":");
+      const variant = token.slice(colon + 1);
+      const variants = chosen[token.slice(0, colon)];
+      return !!variants && (nested ? variants[0] === variant : variants.indexOf(variant) >= 0);
+    });
+    if (show) element.setAttribute("data-prepr-show", "");
+    else element.removeAttribute("data-prepr-show");
+  });
+  return true;
+}
+function requestPreprDecision(key, options = {}) {
+  const fresh = 1e4;
+  const keep = 18e5;
+  const keepStatic = 36e5;
+  const state = window;
+  const asking = state.__preprAsking = state.__preprAsking || {};
+  const read = () => {
+    const all = {};
+    try {
+      const match = document.cookie.match(/(?:^|; )prepr_decisions=([^;]*)/);
+      const parsed = match ? JSON.parse(decodeURIComponent(match[1])) : null;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+        Object.keys(parsed).forEach((stored) => {
+          const entry = parsed[stored];
+          if (stored.charAt(0) === "/" && Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "number")
+            all[stored] = [entry[0], entry[1]];
+        });
+    } catch {
     }
-    state.__preprDecisionSheet.replaceSync(css);
-  } catch {
-    if (!state.__preprDecisionSheet) {
-      state.__preprDecisionSheet = document.createElement("style");
-      document.head.appendChild(state.__preprDecisionSheet);
+    return all;
+  };
+  const usable = (entry, now) => {
+    if (!entry) return false;
+    const age = now - entry[1];
+    return age >= 0 && age < (entry[0] === "*" ? fresh : entry[0] === "" ? keepStatic : keep);
+  };
+  const store = (answer) => {
+    const all = read();
+    const now = Date.now();
+    const kept = all[key];
+    const entries = Object.keys(all).filter((stored) => stored !== key && usable(all[stored], now)).map((stored) => [stored, all[stored]]);
+    entries.push([
+      key,
+      answer === "*" && kept && usable(kept, now) && kept[0] !== "*" ? kept : [answer, now]
+    ]);
+    entries.sort((a, b) => b[1][1] - a[1][1]);
+    entries.length = Math.min(entries.length, 20);
+    const encode = () => {
+      const out = {};
+      entries.forEach((entry) => {
+        out[entry[0]] = entry[1];
+      });
+      return encodeURIComponent(JSON.stringify(out));
+    };
+    let value = encode();
+    while (entries.length > 1 && value.length > 3e3) {
+      entries.pop();
+      value = encode();
+    }
+    document.cookie = "prepr_decisions=" + value + "; path=/; max-age=3600; samesite=lax" + (location.protocol === "https:" ? "; secure" : "");
+  };
+  const ask = () => {
+    if (!asking[key]) {
+      asking[key] = fetch(key, {
+        headers: { "Prepr-Decide": "1" },
+        cache: "no-store",
+        credentials: "same-origin",
+        // The proxy gives up on Prepr after its own `timeoutMs`; this only
+        // covers a proxy that never answers.
+        signal: AbortSignal.timeout ? AbortSignal.timeout(6e3) : void 0
+      }).then((response) => response.ok ? response.text() : "*").catch(() => "*").then((answer) => {
+        delete asking[key];
+        try {
+          store(answer);
+        } catch {
+        }
+        return answer;
+      });
     }
-    state.__preprDecisionSheet.textContent = css;
+    return asking[key];
+  };
+  const last = read()[key];
+  if (last && !(last[0] === "" && options.personalized) && usable(last, Date.now())) {
+    const value = last[0];
+    if (value !== "" && Date.now() - last[1] >= fresh) {
+      ask().then((answer) => {
+        if (answer !== "*" && answer !== value && options.onChange)
+          options.onChange(answer);
+      });
+    }
+    return { result: value, value: Promise.resolve(value) };
   }
+  const pending = {
+    value: ask()
+  };
+  pending.value.then((answer) => {
+    pending.result = answer;
+  });
+  return pending;
+}
+function startPreprDecision() {
+  const state = window;
+  const key = location.pathname + location.search;
+  const apply = (answer, refresh) => {
+    if (location.pathname + location.search === key)
+      state.__preprApply(answer, { refresh });
+  };
+  const pending = state.__preprRequest(key, {
+    onChange: (answer) => apply(answer, true),
+    personalized: true
+  });
+  if (pending.result !== void 0) apply(pending.result);
+  else pending.value.then((answer) => apply(answer));
 }
 
 // src/nextjs/stack.ts
 var import_components = require("./components.cjs");
-var AB_ATTRIBUTE = "data-prepr-ab";
-var AB_BUCKETS = ["A", "B"];
-var AB_BASE_CSS = `[${AB_ATTRIBUTE}]{display:contents}[${AB_ATTRIBUTE}]:not([${AB_ATTRIBUTE}="A"]){display:none}`;
-var AB_SWITCH_SCRIPT = `(${applyPreprAbBucket.toString()})();(${applyPreprDecisions.toString()})()`;
-var GROUP_ATTRIBUTE = "data-prepr-group";
-var VARIANT_ATTRIBUTE = "data-prepr-variant";
+var VARIANT_ATTRIBUTE = "data-prepr-v";
 var DEFAULT_ATTRIBUTE = "data-prepr-default";
-var GROUP_BASE_CSS = `[${GROUP_ATTRIBUTE}]{display:contents}[${GROUP_ATTRIBUTE}]:not([${DEFAULT_ATTRIBUTE}]){display:none}`;
+var NESTED_ATTRIBUTE = "data-prepr-nested";
+var GROUP_BASE_CSS = `[${VARIANT_ATTRIBUTE}]{display:none}[${VARIANT_ATTRIBUTE}][data-prepr-show]{display:contents}[data-prepr-decision]:not([data-prepr-decided])~[${VARIANT_ATTRIBUTE}][${DEFAULT_ATTRIBUTE}]{display:contents;visibility:hidden}`;
+var NOSCRIPT_HTML = `<style>[${VARIANT_ATTRIBUTE}][${DEFAULT_ATTRIBUTE}]{display:contents!important;visibility:visible!important}</style>`;
+var DECISION_SCRIPT = `window.__preprApply=${applyPreprDecisions.toString()};window.__preprRequest=${requestPreprDecision.toString()};(${startPreprDecision.toString()})();`;
+var APPLY_SCRIPT = "__preprApply()";
 function variantKeysOf(items) {
   return items.flatMap((item) => {
-    const key = preprVariantProps(item)["data-prepr-variant-key"];
+    const key = preprVariantProps(item)["data-prepr-variant-key"] ?? nestedKeyOf(item);
     return key ? [key] : [];
   });
 }
-function renderBuckets(items, render, options) {
-  const {
-    bucket,
-    decisions,
-    abTest,
-    index,
-    track,
-    placeholder = false
-  } = 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;
-    if (variantKeys.length > 0) {
-      return (0, import_react.createElement)(
-        import_components.PreprVariantTracking,
-        { key, variantKeys, ab },
-        content
-      );
+function nestedKeyOf(value) {
+  if (!value || typeof value !== "object") return void 0;
+  for (const child of Object.values(value)) {
+    const items = Array.isArray(child) ? child : [child];
+    for (const item of items) {
+      const key = contextOf(item)?.variant_key ?? (item && nestedKeyOf(item));
+      if (key) return key;
+    }
+  }
+  return void 0;
+}
+function renderItems(items, render, options) {
+  const resolved = resolveVariants(items, {
+    decisions: options.decisions,
+    bucket: options.bucket
+  });
+  const content = render(resolved, {
+    index: options.index,
+    defaultVariant: options.defaultVariant
+  });
+  const variantKeys = options.track ? variantKeysOf(resolved) : [];
+  return variantKeys.length > 0 ? (0, import_react.createElement)(import_components.PreprVariantTracking, { variantKeys }, content) : content;
+}
+function decidedGroups(items, bucket) {
+  const groups = /* @__PURE__ */ new Map();
+  const walk = (value) => {
+    if (Array.isArray(value)) return value.forEach(walk);
+    if (!value || typeof value !== "object") return;
+    const ctx = contextOf(value);
+    const decided = ctx?.kind === "PERSONALIZATION" || ctx?.kind === "AB_TEST" && !bucket;
+    if (decided && ctx.variant_id) {
+      const group = groups.get(ctx.group_id) ?? {
+        variants: /* @__PURE__ */ new Set(),
+        fallback: ctx.kind === "AB_TEST" ? "A" : PREPR_DEFAULT_VARIANT
+      };
+      group.variants.add(ctx.variant_id);
+      groups.set(ctx.group_id, group);
     }
-    if (ab) return (0, import_react.createElement)("div", { key, [AB_ATTRIBUTE]: ab }, content);
-    return content;
+    Object.values(value).forEach(walk);
   };
-  if (!abTest || bucket) return renderVariant(bucket);
-  return AB_BUCKETS.map((variant) => renderVariant(variant, variant));
-}
-function renderAllVariants(block, render, options) {
-  const group = block.key.slice("group:".length);
-  const variants = [
-    ...new Set(
-      block.items.flatMap((item) => {
-        const ctx = item[PREPR_CONTEXT_ALIAS];
-        return ctx?.variant_id ? [ctx.variant_id] : [];
-      })
-    )
-  ];
-  return variants.map(
-    (variant) => (0, import_react.createElement)(
+  walk(items);
+  return groups;
+}
+function renderVariants(block, groups, render, options) {
+  const top = block.key.startsWith("group:") ? block.key.slice("group:".length) : void 0;
+  const nested = !(top !== void 0 && groups.size === 1);
+  const choices = [...groups].map(([group, { variants, fallback }]) => {
+    const ids = nested ? [fallback, ...variants] : [...variants];
+    return [...new Set(ids)].map((variant) => [group, variant]);
+  });
+  const combinations = choices.reduce(
+    (all, pairs) => all.flatMap((combo) => pairs.map((p) => [...combo, p])),
+    [[]]
+  );
+  return combinations.map((combination) => {
+    const pairs = combination.map(([group, variant]) => `${group}:${variant}`);
+    const isDefault = combination.every(
+      ([group, variant]) => variant === groups.get(group).fallback
+    );
+    return (0, import_react.createElement)(
       "div",
       {
-        key: variant,
-        [GROUP_ATTRIBUTE]: group,
-        [VARIANT_ATTRIBUTE]: variant,
-        ...variant === PREPR_DEFAULT_VARIANT ? { [DEFAULT_ATTRIBUTE]: "" } : {}
+        key: pairs.join(" "),
+        [VARIANT_ATTRIBUTE]: pairs.join(" "),
+        ...isDefault ? { [DEFAULT_ATTRIBUTE]: "" } : {},
+        ...nested ? { [NESTED_ATTRIBUTE]: "" } : {},
+        // The decision script marks the shown wrapper before hydration.
+        suppressHydrationWarning: true
       },
-      renderBuckets(block.items, render, {
+      renderItems(block.items, render, {
         bucket: options.bucket,
-        decisions: /* @__PURE__ */ new Map([[group, [variant]]]),
-        abTest: false,
+        decisions: new Map(combination.map(([g, v]) => [g, [v]])),
         index: block.index,
-        track: options.track
+        track: options.track,
+        defaultVariant: isDefault
       })
-    )
-  );
-}
-async function PersonalizedBlock({
-  items,
-  decisions,
-  bucket,
-  abTest,
-  index,
-  render,
-  track
-}) {
-  const decided = await decisions.catch((error) => {
-    if (isFrameworkSignal(error)) throw error;
-    return void 0;
-  });
-  return renderBuckets(items, render, {
-    bucket,
-    decisions: decided,
-    abTest,
-    index,
-    track
+    );
   });
 }
 function PreprStack({
   items,
-  decisions,
   render,
   bucket,
   nonce,
-  trackVariants = false,
-  aboveTheFold = 0
+  trackVariants = false
 }) {
-  decisions.catch(() => void 0);
-  const blocks = splitStack(items);
-  const decidedInProxy = (block) => block.index < aboveTheFold && block.personalized && !block.abTest && block.key.startsWith("group:");
-  const hasDecided = blocks.some(decidedInProxy);
-  const needsSwitch = !bucket && blocks.some((block) => block.abTest) || hasDecided;
+  const blocks = splitStack(items).map((block) => ({
+    ...block,
+    groups: decidedGroups(block.items, bucket)
+  }));
+  const varies = blocks.some((block) => block.groups.size > 0);
   return (0, import_react.createElement)(
     import_react.Fragment,
     null,
-    needsSwitch && (0, import_react.createElement)(
+    varies && (0, import_react.createElement)(
       import_react.Fragment,
-      { key: "prepr-ab" },
+      { key: "prepr-switch" },
       (0, import_react.createElement)("style", {
         nonce,
-        dangerouslySetInnerHTML: {
-          __html: AB_BASE_CSS + (hasDecided ? GROUP_BASE_CSS : "")
-        }
+        dangerouslySetInnerHTML: { __html: GROUP_BASE_CSS }
+      }),
+      (0, import_react.createElement)("noscript", {
+        dangerouslySetInnerHTML: { __html: NOSCRIPT_HTML }
       }),
       (0, import_react.createElement)("script", {
         nonce,
-        dangerouslySetInnerHTML: { __html: AB_SWITCH_SCRIPT }
+        dangerouslySetInnerHTML: { __html: DECISION_SCRIPT }
       }),
-      (0, import_react.createElement)(import_components.PreprAbSwitch)
+      (0, import_react.createElement)(import_components.PreprDecisionApplier),
+      // Marked decided by the decision switch; never laid out.
+      (0, import_react.createElement)("template", {
+        "data-prepr-decision": "",
+        suppressHydrationWarning: true
+      })
     ),
     ...blocks.map((block) => {
-      if (decidedInProxy(block)) {
+      if (block.groups.size === 0) {
         return (0, import_react.createElement)(
           import_react.Fragment,
           { key: block.key },
-          renderAllVariants(block, render, { bucket, track: trackVariants })
+          renderItems(block.items, render, {
+            bucket,
+            index: block.index,
+            track: trackVariants,
+            defaultVariant: true
+          })
         );
       }
-      const fallback = renderBuckets(block.items, render, {
-        bucket,
-        abTest: block.abTest,
-        index: block.index,
-        track: trackVariants && !block.personalized,
-        placeholder: block.personalized
-      });
-      if (!block.personalized) {
-        return (0, import_react.createElement)(import_react.Fragment, { key: block.key }, fallback);
-      }
       return (0, import_react.createElement)(
-        import_react.Suspense,
-        { key: block.key, fallback },
-        (0, import_react.createElement)(PersonalizedBlock, {
-          items: block.items,
-          decisions,
+        import_react.Fragment,
+        { key: block.key },
+        renderVariants(block, block.groups, render, {
           bucket,
-          abTest: block.abTest,
-          index: block.index,
-          render,
           track: trackVariants
+        }),
+        (0, import_react.createElement)("script", {
+          nonce,
+          dangerouslySetInnerHTML: { __html: APPLY_SCRIPT }
         })
       );
     })
@@ -1295,33 +1863,59 @@ function createPreprClient2(options) {
   const { cacheTags = ["prepr"], revalidate, ...coreOptions } = options;
   const client = createPreprClient({
     // The schema introspection goes through the Data Cache: shared across
-    // server instances, refreshed hourly and by revalidateTag on publish.
+    // server instances, refreshed hourly and by a `schema.changed` webhook.
     schemaInit: {
-      next: { tags: cacheTags, revalidate: 3600 }
+      next: { tags: [...cacheTags, PREPR_SCHEMA_TAG], revalidate: 3600 }
     },
     ...coreOptions
   });
-  const seenGroups = /* @__PURE__ */ new Map();
-  return {
+  const nextClient = {
     async query(document2, variables, queryOptions = {}) {
-      const { personalize = false, ...rest } = queryOptions;
-      const init = rest.init;
-      const tagged = {
+      const { personalize = false, tagItems = false, ...rest } = queryOptions;
+      const { next, ...init } = rest.init ?? {};
+      if (tagItems && typeof nextCache.cacheTag !== "function") {
+        throw new Error("tagItems requires Next.js 16 or later.");
+      }
+      const options2 = {
         ...rest,
-        init: {
+        // With tagItems, `next` is dropped too: tags or revalidate alongside
+        // `no-store` are a conflict Next.js resolves by ignoring the store.
+        // Otherwise tags are attached unconditionally; the core client drops
+        // them again whenever the request ends up `no-store` (personalized,
+        // per-request headers, or preview).
+        init: tagItems ? { ...init, cache: "no-store" } : {
           ...init,
           next: {
-            tags: cacheTags,
             ...revalidate === void 0 ? {} : { revalidate },
-            ...init?.next
+            ...next,
+            // Merged, so a per-query tag never drops the client's own,
+            // which the publish webhook relies on.
+            tags: [...cacheTags, ...next?.tags ?? []]
           }
         }
       };
-      if (!personalize) return client.query(document2, variables, tagged);
-      return client.query(document2, variables, {
-        ...tagged,
-        headers: mergePreprHeaders(await getPreprHeaders(), rest.headers)
-      });
+      if (personalize) {
+        options2.headers = mergePreprHeaders(
+          await getPreprHeaders(),
+          rest.headers
+        );
+      }
+      const result = await client.query(document2, variables, options2);
+      if (tagItems) {
+        let modelTags;
+        try {
+          modelTags = preprModelTagsFor(
+            documentOf(document2),
+            result.data,
+            await clientSchemas.get(client)()
+          );
+        } catch {
+          modelTags = [PREPR_ANY_ITEM_TAG];
+        }
+        nextCache.cacheTag(...cacheTags, ...next?.tags ?? [], ...modelTags);
+        nextCache.cacheTag(...preprCacheTags(result.data));
+      }
+      return result;
     },
     async decide(document2, variables, queryOptions = {}) {
       return client.decide(document2, variables, {
@@ -1332,28 +1926,24 @@ function createPreprClient2(options) {
         )
       });
     },
-    hasAbTests: (document2, variables) => client.hasAbTests(document2, variables),
-    resolveDecisions: (request, response, document2, variables, options2) => resolveDecisionsWith(
-      client,
-      seenGroups,
-      request,
-      response,
-      document2,
-      variables,
-      options2
-    )
+    hasAbTests: (document2, variables) => client.hasAbTests(document2, variables)
   };
+  preprClientInternals.set(nextClient, { client });
+  return nextClient;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PREPR_DECISIONS_COOKIE,
+  PREPR_ANY_ITEM_TAG,
   PREPR_DEFAULT_VARIANT,
   PreprError,
   PreprStack,
   createPreprClient,
+  createPreprProxy,
   decisionsFrom,
   isPersonalizedResponse,
   loadPreprSchema,
+  preprCacheTags,
+  preprModelTag,
   preprVariantProps,
   resolveVariants,
   splitStack,