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

package/dist/nextjs/graphql.js

@@ -1,10 +1,20 @@
 import {
+  PREPR_ANY_ITEM_TAG,
+  PREPR_SCHEMA_TAG,
   PreprError,
+  createPreprMiddleware,
   getPreprHeaders,
   getPreprHeadersFromHeaders,
   isPersonalizedResponse,
+  preprCacheTags,
+  preprDraftRedirect,
+  preprModelTag,
+  preprModelTagsFor,
   validatePreprToken
-} from "./chunk-U4HXENF7.js";
+} from "./chunk-B4GVZEOL.js";
+
+// src/nextjs/graphql.ts
+import * as nextCache from "next/cache";
 
 // src/core/variants/constants.ts
 var PREPR_CONTEXT_ALIAS = "_preprContext";
@@ -93,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
@@ -103,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;
@@ -183,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) {
@@ -483,6 +540,63 @@ function toVariantsDocument(document2, schema) {
   };
 }
 
+// src/core/graphql/document.ts
+import { print } from "graphql/language/printer.js";
+import { stripIgnoredCharacters } from "graphql/utilities/stripIgnoredCharacters.js";
+var printed = /* @__PURE__ */ new WeakMap();
+function isDocumentNode(value) {
+  return typeof value === "object" && value !== null && value.kind === "Document" && Array.isArray(value.definitions);
+}
+function invalidDocument(originalError) {
+  return new PreprError(
+    "Expected a GraphQL query string, TypedDocumentString or DocumentNode",
+    "INVALID_DOCUMENT",
+    "createPreprClient",
+    originalError
+  );
+}
+var minified = /* @__PURE__ */ new Map();
+var MINIFIED_CACHE_LIMIT = 500;
+function minify(query) {
+  const cached = minified.get(query);
+  if (cached !== void 0) return cached;
+  let result = query;
+  try {
+    result = stripIgnoredCharacters(query);
+  } catch {
+  }
+  if (minified.size < MINIFIED_CACHE_LIMIT) minified.set(query, result);
+  return result;
+}
+function resolveQuery(document2) {
+  if (typeof document2 === "string") return minify(document2);
+  if (document2 instanceof String) return minify(document2.toString());
+  if (!isDocumentNode(document2)) throw invalidDocument();
+  let query = printed.get(document2);
+  if (query === void 0) {
+    try {
+      query = minify(print(document2));
+    } catch (error) {
+      throw invalidDocument(error instanceof Error ? error : void 0);
+    }
+    printed.set(document2, query);
+  }
+  return query;
+}
+
+// src/core/variants/queries.ts
+function toVariantsQuery(document2, schema) {
+  return resolveQuery(toVariantsDocument(document2, schema));
+}
+function toDecisionQuery(document2, schema, options = {}) {
+  const paths = options.from === void 0 ? void 0 : personalizationPaths(options.from);
+  if (paths && paths.size === 0) return null;
+  const decision = toDecisionDocument(document2, schema, paths, {
+    topLevelOnly: !paths && options.topLevelOnly
+  });
+  return decision ? resolveQuery(decision) : null;
+}
+
 // src/core/graphql/transport.ts
 import { VERCEL_STEGA_REGEX } from "@vercel/stega";
 
@@ -535,50 +649,6 @@ function stegaClean(text) {
   return vercelStegaClean(text);
 }
 
-// src/core/graphql/document.ts
-import { print } from "graphql/language/printer.js";
-import { stripIgnoredCharacters } from "graphql/utilities/stripIgnoredCharacters.js";
-var printed = /* @__PURE__ */ new WeakMap();
-function isDocumentNode(value) {
-  return typeof value === "object" && value !== null && value.kind === "Document" && Array.isArray(value.definitions);
-}
-function invalidDocument(originalError) {
-  return new PreprError(
-    "Expected a GraphQL query string, TypedDocumentString or DocumentNode",
-    "INVALID_DOCUMENT",
-    "createPreprClient",
-    originalError
-  );
-}
-var minified = /* @__PURE__ */ new Map();
-var MINIFIED_CACHE_LIMIT = 500;
-function minify(query) {
-  const cached = minified.get(query);
-  if (cached !== void 0) return cached;
-  let result = query;
-  try {
-    result = stripIgnoredCharacters(query);
-  } catch {
-  }
-  if (minified.size < MINIFIED_CACHE_LIMIT) minified.set(query, result);
-  return result;
-}
-function resolveQuery(document2) {
-  if (typeof document2 === "string") return minify(document2);
-  if (document2 instanceof String) return minify(document2.toString());
-  if (!isDocumentNode(document2)) throw invalidDocument();
-  let query = printed.get(document2);
-  if (query === void 0) {
-    try {
-      query = minify(print(document2));
-    } catch (error) {
-      throw invalidDocument(error instanceof Error ? error : void 0);
-    }
-    printed.set(document2, query);
-  }
-  return query;
-}
-
 // src/core/graphql/transport.ts
 var OPERATION_NAME = /\b(?:query|mutation|subscription)\s+([_A-Za-z][_0-9A-Za-z]*)/;
 var STEGA_RAW = new RegExp(
@@ -757,6 +827,7 @@ function createVaryProbe(run, options) {
 }
 
 // src/core/graphql/client.ts
+var clientSchemas = /* @__PURE__ */ new WeakMap();
 function isParseableUrl(url) {
   try {
     new URL(url);
@@ -765,16 +836,18 @@ function isParseableUrl(url) {
     return false;
   }
 }
-function createPreprClient(options) {
-  const { url } = options;
+function assertPreprUrl(url, source) {
   validatePreprToken(url);
   if (!isParseableUrl(url)) {
     throw new PreprError(
       "Prepr GraphQL URL is not a valid URL",
       "INVALID_TOKEN",
-      "createPreprClient"
+      source
     );
   }
+}
+function createPreprClient(options) {
+  assertPreprUrl(options.url, "createPreprClient");
   const run = createTransport(options);
   const probeVary = createVaryProbe(run, options);
   let schema;
@@ -791,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);
@@ -803,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();
@@ -814,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();
@@ -830,28 +901,91 @@ function createPreprClient(options) {
       (vary) => vary === null || SEGMENTS_VARY.test(vary)
     )
   };
+  clientSchemas.set(client, loadSchema);
+  return client;
+}
+
+// src/core/graphql/schema-loader.ts
+var schemas = /* @__PURE__ */ new Map();
+async function loadPreprSchema(url, options = {}) {
+  assertPreprUrl(url, "loadPreprSchema");
+  let schema = schemas.get(url);
+  if (!schema) {
+    const run = createTransport({ url, fetch: options.fetch, stega: "none" });
+    schema = run(
+      PREPR_SCHEMA_QUERY
+    ).then((result) => toSchemaInfo(result.data)).catch((error) => {
+      schemas.delete(url);
+      if (error instanceof PreprError) throw error;
+      throw new PreprError(
+        "Prepr schema response is not an introspection result",
+        "INVALID_RESPONSE",
+        "loadPreprSchema",
+        error instanceof Error ? error : void 0
+      );
+    });
+    schemas.set(url, schema);
+  }
+  return schema;
 }
 
 // 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 out;
+  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 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");
@@ -863,288 +997,448 @@ function forwardedHeaders(request, response) {
   }
   return getPreprHeadersFromHeaders(headers);
 }
-async function resolveDecisionsWith(client, seenGroups, request, response, document2, variables, options) {
+var preprClientInternals = /* @__PURE__ */ new WeakMap();
+async function decideView(client, headers, 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 headers = mergePreprHeaders(forwardedHeaders(request, response));
-    const stored = parseDecisions(
-      request.cookies.get(PREPR_DECISIONS_COOKIE)?.value
+    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;
+  }
+}
+
+// src/nextjs/proxy.ts
+import { NextResponse } from "next/server";
+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 pageKey = `${JSON.stringify(variables ?? null)}`;
-    let byVariables = seenGroups.get(document2);
-    if (!byVariables) {
-      byVariables = /* @__PURE__ */ new Map();
-      seenGroups.set(document2, byVariables);
+  }
+  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 known = byVariables.get(pageKey);
-    const isNewVisitor = headers.get("Prepr-Customer-Id-Created") === "true";
-    const contextChanged = isNewVisitor || headers.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 lookup = (target) => {
+    try {
+      return options.page(target) ?? null;
+    } catch {
+      return null;
     }
-    const decided = await client.decide(document2, variables, {
-      topLevelOnly: true,
-      headers,
-      init: { signal: AbortSignal.timeout(options?.timeoutMs ?? 1e3) }
-    });
-    if (!known && byVariables.size >= SEEN_MAX_PAGES) {
-      byVariables.delete(byVariables.keys().next().value);
+  };
+  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 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))
-        );
+    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;
+  }
+  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;
     }
-    for (const [group, variants] of stored) {
-      if (!next.has(group)) next.set(group, variants);
+    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;
     }
-    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 response = createPreprMiddleware(request, {
+      preview,
+      features: options.features
     });
-  } catch (error) {
-    if (isFrameworkSignal(error)) throw error;
-  }
+    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
 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, options = {}) {
   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;
-    }
-    state.__preprAbSheet.replaceSync(css);
-  } catch {
-    if (!state.__preprAbSheet) {
-      state.__preprAbSheet = document.createElement("style");
-      document.head.appendChild(state.__preprAbSheet);
-    }
-    state.__preprAbSheet.textContent = css;
-  }
-}
-function applyPreprDecisions() {
-  const match = document.cookie.match(/(?:^|; )prepr_decisions=([^;]*)/);
-  let raw;
-  try {
-    raw = match ? decodeURIComponent(match[1]) : "";
-  } catch {
-    raw = "";
+  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("~");
   }
-  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}';
-      }
+  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", "");
+  });
+  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");
   });
-  try {
-    if (!state.__preprDecisionSheet) {
-      const sheet = new CSSStyleSheet();
-      document.adoptedStyleSheets = document.adoptedStyleSheets.concat(sheet);
-      state.__preprDecisionSheet = sheet;
+  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;
+      });
+    }
+    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);
+      });
     }
-    state.__preprDecisionSheet.textContent = css;
+    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
-import { PreprAbSwitch, 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
-  } = 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 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;
+    }
+  }
+  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 ? 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);
     }
-    if (ab) return 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) => 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 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 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)
+      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 }
         })
       );
     })
@@ -1156,33 +1450,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, {
@@ -1193,26 +1513,26 @@ 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;
 }
 export {
-  PREPR_DECISIONS_COOKIE,
+  PREPR_ANY_ITEM_TAG,
   PREPR_DEFAULT_VARIANT,
   PreprError,
   PreprStack,
   createPreprClient2 as createPreprClient,
+  createPreprProxy,
+  decisionsFrom,
   isPersonalizedResponse,
+  loadPreprSchema,
+  preprCacheTags,
+  preprModelTag,
   preprVariantProps,
   resolveVariants,
-  splitStack
+  splitStack,
+  toDecisionQuery,
+  toVariantsQuery
 };