@preprio/toolkit 0.6.0-alpha.6 → 0.6.0-alpha.8

package/dist/nextjs/graphql.js

@@ -1,13 +1,20 @@
 import {
+  PREPR_ANY_ITEM_TAG,
+  PREPR_SCHEMA_TAG,
   PreprError,
   createPreprMiddleware,
   getPreprHeaders,
   getPreprHeadersFromHeaders,
   isPersonalizedResponse,
+  preprCacheTags,
   preprDraftRedirect,
-  resolvePreprBucket,
+  preprModelTag,
+  preprModelTagsFor,
   validatePreprToken
-} from "./chunk-PIQF5ZI5.js";
+} from "./chunk-O2SBSBDG.js";
+
+// src/nextjs/graphql.ts
+import * as nextCache from "next/cache";
 
 // src/core/variants/constants.ts
 var PREPR_CONTEXT_ALIAS = "_preprContext";
@@ -96,7 +103,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
@@ -106,13 +116,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;
@@ -186,20 +202,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) {
@@ -773,6 +827,7 @@ function createVaryProbe(run, options) {
 }
 
 // src/core/graphql/client.ts
+var clientSchemas = /* @__PURE__ */ new WeakMap();
 function isParseableUrl(url) {
   try {
     new URL(url);
@@ -809,7 +864,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);
@@ -821,10 +876,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();
@@ -832,9 +887,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();
@@ -848,6 +901,8 @@ function createPreprClient(options) {
       (vary) => vary === null || SEGMENTS_VARY.test(vary)
     )
   };
+  clientSchemas.set(client, loadSchema);
+  return client;
 }
 
 // src/core/graphql/schema-loader.ts
@@ -874,69 +929,15 @@ 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 PREPR_DECIDE_HEADER = "Prepr-Decide";
+var DEFAULT_DECISION = "*";
 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))
-    );
-  }
-  return out;
-}
 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");
@@ -949,109 +950,16 @@ function forwardedHeaders(request, response) {
   return getPreprHeadersFromHeaders(headers);
 }
 var preprClientInternals = /* @__PURE__ */ new WeakMap();
-var DEFAULT_FRESH_FOR_MS = 1e4;
-async function decidePage(client, seenGroups, headers, document2, variables, timeoutMs = 1e3) {
-  if (!await client.hasSegments(document2, variables)) return void 0;
-  const decided = await client.decide(document2, variables, {
-    topLevelOnly: true,
-    headers,
-    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);
-    }
-    groups = /* @__PURE__ */ new Set();
-    byVariables.set(pageKey, groups);
-  }
-  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 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, headers) {
-  return headers.get("Prepr-Customer-Id-Created") === "true" || headers.has("Prepr-Segments") || [...request.nextUrl.searchParams.keys()].some(
-    (key) => key.startsWith("utm_")
-  );
-}
-async function resolveDecisionsWith(client, seenGroups, request, response, document2, variables, options) {
+async function decideView(client, headers, page, timeoutMs = 3e3) {
+  const init = { signal: AbortSignal.timeout(timeoutMs) };
   try {
-    if (options?.onlyIf && !await options.onlyIf()) return;
-    const known = seenGroups.get(document2)?.get(JSON.stringify(variables ?? null));
-    const path = pagePath(request);
-    const headers = 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, headers) && [...known].every((group) => stored.has(group))) {
-      return;
-    }
-    const decided = await decidePage(
-      client,
-      seenGroups,
-      headers,
-      document2,
-      variables,
-      options?.timeoutMs
-    );
-    if (!decided || decided.size === 0) return;
-    writeDecisions(request, response, [decided], [path]);
+    const decided = page.decision ? decisionsFrom(
+      (await client.query(page.decision, page.variables, { headers, init })).data
+    ) : await client.decide(page.document, page.variables, { headers, init });
+    return serializeDecisions(decided);
   } catch (error) {
     if (isFrameworkSignal(error)) throw error;
+    return DEFAULT_DECISION;
   }
 }
 
@@ -1069,7 +977,7 @@ function createPreprProxy(options) {
       "createPreprProxy"
     );
   }
-  const { client, seenGroups, url } = internals;
+  const { client } = internals;
   const preview = options.preview ?? false;
   const allowed = async (request) => {
     if (!options.onlyIf) return true;
@@ -1086,66 +994,31 @@ function createPreprProxy(options) {
       return null;
     }
   };
-  async function refresh(request, response, paths) {
-    const answer = new NextResponse(null, {
-      status: 204,
-      headers: { "Cache-Control": "no-store" }
-    });
-    for (const cookie of response.cookies.getAll()) answer.cookies.set(cookie);
+  async function answerDecision(request, response, target) {
+    let decision = DEFAULT_DECISION;
     const site = request.headers.get("sec-fetch-site");
-    if (request.method !== "GET" || site !== null && site !== "same-origin" || !await allowed(request)) {
-      return answer;
+    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 own = new Set(
-      parseRefresh(request.cookies.get(PREPR_REFRESH_COOKIE)?.value).map(
-        (entry) => entry.path
-      )
-    );
-    const basePath = request.nextUrl.basePath;
-    const headers = 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,
-            headers,
-            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)
-    );
+    const answer = new 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;
   }
   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 rendersPage = (request.method === "GET" || request.method === "HEAD") && isPagePath(request.nextUrl.pathname);
     const target = rendersPage ? lookup(request.nextUrl) : null;
-    if (target && preview) {
+    const decisionRequest = request.headers.has(PREPR_DECIDE_HEADER);
+    if (target && preview && !decisionRequest) {
       const draft = preprDraftRedirect(request, { preview });
       if (draft) return draft;
     }
@@ -1153,24 +1026,7 @@ function createPreprProxy(options) {
       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 }
-        )
-      ]);
-    }
+    if (decisionRequest) return answerDecision(request, response, target);
     return response;
   };
 }
@@ -1178,243 +1034,270 @@ function createPreprProxy(options) {
 // src/nextjs/stack.ts
 import {
   createElement,
-  Fragment,
-  Suspense
+  Fragment
 } from "react";
 
-// src/nextjs/ab-switch.ts
-function applyPreprAbBucket() {
-  const match = document.cookie.match(/(?:^|; )prepr_ab_bucket=([AB])(?:;|$)/);
-  const bucket = match ? match[1] : "A";
+// src/nextjs/decision-switch.ts
+function applyPreprDecisions(decision) {
   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;
+  const key = location.pathname + location.search;
+  if (decision !== void 0) state.__preprDecision = { key, value: decision };
+  const current = state.__preprDecision;
+  if (!current || current.key !== key) return false;
+  document.querySelectorAll("[data-prepr-decision]").forEach((marker) => {
+    marker.setAttribute("data-prepr-decided", "");
+  });
+  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 = () => {
+    try {
+      const all = JSON.parse(sessionStorage.getItem("prepr_decisions") || "{}");
+      return all && typeof all === "object" ? all : {};
+    } catch {
+      return {};
     }
-    state.__preprAbSheet.replaceSync(css);
-  } catch {
-    if (!state.__preprAbSheet) {
-      state.__preprAbSheet = document.createElement("style");
-      document.head.appendChild(state.__preprAbSheet);
+  };
+  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 {
+          const all = read();
+          const at = Date.now();
+          Object.keys(all).forEach((stored) => {
+            const entry = all[stored];
+            if (!(entry && typeof entry.at === "number" && at - entry.at < keepStatic))
+              delete all[stored];
+          });
+          const kept = all[key];
+          if (answer !== "*" || !kept || kept.value === "*")
+            all[key] = { value: answer, at };
+          sessionStorage.setItem("prepr_decisions", JSON.stringify(all));
+        } catch {
+        }
+        return answer;
+      });
     }
-    state.__preprAbSheet.textContent = css;
+    return asking[key];
+  };
+  const last = read()[key];
+  const age = last && typeof last.at === "number" ? Date.now() - last.at : -1;
+  const value = last && typeof last.value === "string" ? last.value : null;
+  if (value !== null && !(value === "" && options.personalized) && age >= 0 && age < (value === "*" ? fresh : value === "" ? keepStatic : keep)) {
+    if (value !== "" && age >= 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 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 {
-    raw = match ? decodeURIComponent(match[1]) : "";
-  } catch {
-    raw = "";
-  }
+function startPreprDecision() {
   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 key = location.pathname + location.search;
+  const apply = (answer) => {
+    if (location.pathname + location.search === key) state.__preprApply(answer);
+  };
+  const pending = state.__preprRequest(key, {
+    onChange: apply,
+    personalized: true
   });
-  try {
-    if (!state.__preprDecisionSheet) {
-      const sheet = new CSSStyleSheet();
-      document.adoptedStyleSheets = document.adoptedStyleSheets.concat(sheet);
-      state.__preprDecisionSheet = sheet;
-    }
-    state.__preprDecisionSheet.replaceSync(css);
-  } catch {
-    if (!state.__preprDecisionSheet) {
-      state.__preprDecisionSheet = document.createElement("style");
-      document.head.appendChild(state.__preprDecisionSheet);
-    }
-    state.__preprDecisionSheet.textContent = css;
-  }
+  if (pending.result !== void 0) apply(pending.result);
+  else pending.value.then(apply);
 }
 
 // src/nextjs/stack.ts
-import {
-  PreprAbSwitch,
-  PreprPersonalizationSwitch,
-  PreprVariantTracking
-} from "./components.js";
-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";
+import { PreprDecisionApplier, PreprVariantTracking } from "./components.js";
+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,
-    defaultVariant = true
-  } = options;
-  const renderVariant = (variant, key) => {
-    const resolved = resolveVariants(items, { decisions, bucket: variant });
-    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 createElement(
-        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;
     }
-    if (ab) return createElement("div", { key, [AB_ATTRIBUTE]: ab }, content);
-    return content;
-  };
-  if (!abTest || bucket) return renderVariant(bucket);
-  return AB_BUCKETS.map((variant) => renderVariant(variant, variant));
+  }
+  return void 0;
 }
-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) => createElement(
+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 ? createElement(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);
+    }
+    Object.values(value).forEach(walk);
+  };
+  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 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,
-        defaultVariant: variant === PREPR_DEFAULT_VARIANT
+        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 = 1
+  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 createElement(
     Fragment,
     null,
-    needsSwitch && createElement(
+    varies && createElement(
       Fragment,
-      { key: "prepr-ab" },
+      { key: "prepr-switch" },
       createElement("style", {
         nonce,
-        dangerouslySetInnerHTML: {
-          __html: AB_BASE_CSS + (hasDecided ? GROUP_BASE_CSS : "")
-        }
+        dangerouslySetInnerHTML: { __html: GROUP_BASE_CSS }
+      }),
+      createElement("noscript", {
+        dangerouslySetInnerHTML: { __html: NOSCRIPT_HTML }
       }),
       createElement("script", {
         nonce,
-        dangerouslySetInnerHTML: { __html: AB_SWITCH_SCRIPT }
+        dangerouslySetInnerHTML: { __html: DECISION_SCRIPT }
       }),
-      createElement(PreprAbSwitch),
-      hasDecided && createElement(PreprPersonalizationSwitch, { refresh: false })
+      createElement(PreprDecisionApplier),
+      // Marked decided by the decision switch; never laid out.
+      createElement("template", {
+        "data-prepr-decision": "",
+        suppressHydrationWarning: true
+      })
     ),
     ...blocks.map((block) => {
-      if (decidedInProxy(block)) {
+      if (block.groups.size === 0) {
         return createElement(
           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 createElement(Fragment, { key: block.key }, fallback);
-      }
       return createElement(
-        Suspense,
-        { key: block.key, fallback },
-        createElement(PersonalizedBlock, {
-          items: block.items,
-          decisions,
+        Fragment,
+        { key: block.key },
+        renderVariants(block, block.groups, render, {
           bucket,
-          abTest: block.abTest,
-          index: block.index,
-          render,
           track: trackVariants
+        }),
+        createElement("script", {
+          nonce,
+          dangerouslySetInnerHTML: { __html: APPLY_SCRIPT }
         })
       );
     })
@@ -1426,33 +1309,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();
   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, {
@@ -1463,26 +1372,13 @@ 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,
-    seenGroups,
-    url: coreOptions.url
-  });
+  preprClientInternals.set(nextClient, { client });
   return nextClient;
 }
 export {
-  PREPR_DECISIONS_COOKIE,
+  PREPR_ANY_ITEM_TAG,
   PREPR_DEFAULT_VARIANT,
   PreprError,
   PreprStack,
@@ -1491,6 +1387,8 @@ export {
   decisionsFrom,
   isPersonalizedResponse,
   loadPreprSchema,
+  preprCacheTags,
+  preprModelTag,
   preprVariantProps,
   resolveVariants,
   splitStack,