@preprio/toolkit 0.5.0-rc.1 → 0.6.0-alpha.0

package/dist/nextjs/graphql.js

@@ -0,0 +1,1218 @@
+import {
+  PreprError,
+  getPreprHeaders,
+  getPreprHeadersFromHeaders,
+  isPersonalizedResponse,
+  validatePreprToken
+} from "./chunk-U4HXENF7.js";
+
+// src/core/variants/constants.ts
+var PREPR_CONTEXT_ALIAS = "_preprContext";
+var PREPR_TYPE_ALIAS = "_preprType";
+var PREPR_DEFAULT_VARIANT = "ALL_OTHER_USERS";
+
+// src/core/variants/ast.ts
+import { parse } from "graphql/language/parser.js";
+var name = (value) => ({ kind: "Name", value });
+function selectionSet(selections) {
+  return { kind: "SelectionSet", selections };
+}
+function contextField(withKey) {
+  const fields = ["kind", "group_id", "variant_id"];
+  if (withKey) fields.push("variant_key");
+  return {
+    kind: "Field",
+    alias: name(PREPR_CONTEXT_ALIAS),
+    name: name("_context"),
+    selectionSet: selectionSet(
+      fields.map(
+        (field) => ({ kind: "Field", name: name(field) })
+      )
+    )
+  };
+}
+function typenameField() {
+  return {
+    kind: "Field",
+    alias: name(PREPR_TYPE_ALIAS),
+    name: name("__typename")
+  };
+}
+function inlineFragment(typeName, selections) {
+  return {
+    kind: "InlineFragment",
+    typeCondition: { kind: "NamedType", name: name(typeName) },
+    selectionSet: selectionSet(selections)
+  };
+}
+function contextSelections(typeName, schema, onlyTypes, withType = true) {
+  const fields = () => withType ? [contextField(true), typenameField()] : [contextField(false)];
+  const type = schema.types[typeName];
+  if (!type) return [];
+  if (type.possibleTypes.length > 0) {
+    return type.possibleTypes.filter(
+      (member) => schema.types[member]?.hasContext && (!onlyTypes || onlyTypes.has(member))
+    ).map((member) => inlineFragment(member, fields()));
+  }
+  return type.hasContext ? fields() : [];
+}
+function withoutPersonalizeArg(args = []) {
+  return args.filter((arg) => arg.name.value !== "personalize");
+}
+function documentOf(document2) {
+  if (typeof document2 === "string") return parse(document2);
+  if (document2 instanceof String) return parse(document2.toString());
+  return document2;
+}
+function collectVariables(node, used) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) collectVariables(item, used);
+    return;
+  }
+  const value = node;
+  if (value.kind === "Variable") {
+    used.add(value.name.value);
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    if (key !== "loc") collectVariables(value[key], used);
+  }
+}
+
+// src/core/variants/decision-document.ts
+function decisionSelectionSet(set, typeName, path, ctx) {
+  const selections = [];
+  for (const selection of set.selections) {
+    if (selection.kind === "FragmentSpread") {
+      const fragment = ctx.fragments[selection.name.value];
+      if (!fragment) continue;
+      const pruned = decisionSelectionSet(
+        fragment.selectionSet,
+        fragment.typeCondition.name.value,
+        path,
+        ctx
+      );
+      if (pruned) {
+        selections.push(
+          inlineFragment(fragment.typeCondition.name.value, [
+            ...pruned.selections
+          ])
+        );
+      }
+      continue;
+    }
+    if (selection.kind === "InlineFragment") {
+      const pruned = decisionSelectionSet(
+        selection.selectionSet,
+        selection.typeCondition?.name.value ?? typeName,
+        path,
+        ctx
+      );
+      if (pruned) selections.push({ ...selection, selectionSet: pruned });
+      continue;
+    }
+    if (!selection.selectionSet) continue;
+    const field = ctx.schema.types[typeName]?.fields[selection.name.value];
+    if (!field) continue;
+    const key = selection.alias?.value ?? selection.name.value;
+    const fieldPath = path ? `${path}.${key}` : key;
+    if (ctx.paths && !ctx.paths.prefixes.has(fieldPath)) continue;
+    const child = decisionSelectionSet(
+      selection.selectionSet,
+      field.type,
+      fieldPath,
+      ctx
+    );
+    const groupTypes = ctx.paths?.groups.get(fieldPath);
+    const holdsGroups = field.personalizable && (!ctx.paths || groupTypes !== void 0);
+    if (holdsGroups) {
+      selections.push({
+        ...selection,
+        arguments: withoutPersonalizeArg(selection.arguments),
+        selectionSet: selectionSet([
+          ...ctx.topLevelOnly ? [] : child?.selections ?? [],
+          ...contextSelections(
+            field.type,
+            ctx.schema,
+            groupTypes && !groupTypes.has("*") ? groupTypes : void 0,
+            false
+          )
+        ])
+      });
+    } else if (child) {
+      selections.push({
+        ...selection,
+        arguments: field.personalizable ? withoutPersonalizeArg(selection.arguments) : selection.arguments,
+        selectionSet: child
+      });
+    }
+  }
+  return selections.length > 0 ? selectionSet(selections) : null;
+}
+function toDecisionDocument(document2, schema, groupPaths, options) {
+  const doc = documentOf(document2);
+  const fragments = {};
+  for (const definition of doc.definitions) {
+    if (definition.kind === "FragmentDefinition") {
+      fragments[definition.name.value] = definition;
+    }
+  }
+  const operation = doc.definitions.find(
+    (definition) => definition.kind === "OperationDefinition"
+  );
+  if (!operation) return null;
+  let paths;
+  if (groupPaths) {
+    const prefixes = /* @__PURE__ */ new Set();
+    for (const groupPath of groupPaths.keys()) {
+      const parts = groupPath.split(".");
+      for (let i = 1; i <= parts.length; i++) {
+        prefixes.add(parts.slice(0, i).join("."));
+      }
+    }
+    paths = { groups: groupPaths, prefixes };
+  }
+  const pruned = decisionSelectionSet(
+    operation.selectionSet,
+    schema.queryType,
+    "",
+    { schema, fragments, paths, topLevelOnly: options?.topLevelOnly }
+  );
+  if (!pruned) return null;
+  const used = /* @__PURE__ */ new Set();
+  collectVariables(pruned, used);
+  collectVariables(operation.directives, used);
+  return {
+    kind: "Document",
+    definitions: [
+      {
+        ...operation,
+        name: operation.name && name(`${operation.name.value}Decision`),
+        variableDefinitions: (operation.variableDefinitions ?? []).filter(
+          (definition) => used.has(definition.variable.name.value)
+        ),
+        selectionSet: pruned
+      }
+    ]
+  };
+}
+
+// src/core/variants/probe-document.ts
+function probeSelectionSet(set, fragments) {
+  const selections = [
+    { kind: "Field", name: name("__typename") }
+  ];
+  for (const selection of set.selections) {
+    if (selection.kind === "Field") {
+      if (!selection.selectionSet) continue;
+      selections.push({
+        ...selection,
+        selectionSet: probeSelectionSet(selection.selectionSet, fragments)
+      });
+      continue;
+    }
+    const fragment = selection.kind === "InlineFragment" ? selection : fragments[selection.name.value];
+    if (!fragment) continue;
+    const child = probeSelectionSet(fragment.selectionSet, fragments);
+    if (child.selections.length === 1) continue;
+    selections.push({
+      kind: "InlineFragment",
+      typeCondition: fragment.typeCondition,
+      directives: selection.directives,
+      selectionSet: child
+    });
+  }
+  return selectionSet(selections);
+}
+function toAbProbeDocument(document2) {
+  const doc = documentOf(document2);
+  const fragments = {};
+  for (const definition of doc.definitions) {
+    if (definition.kind === "FragmentDefinition") {
+      fragments[definition.name.value] = definition;
+    }
+  }
+  const operation = doc.definitions.find(
+    (definition) => definition.kind === "OperationDefinition"
+  );
+  if (!operation) return null;
+  const probe = probeSelectionSet(operation.selectionSet, fragments);
+  const used = /* @__PURE__ */ new Set();
+  collectVariables(probe, used);
+  collectVariables(operation.directives, used);
+  return {
+    kind: "Document",
+    definitions: [
+      {
+        ...operation,
+        name: operation.name && name(`${operation.name.value}AbCheck`),
+        variableDefinitions: (operation.variableDefinitions ?? []).filter(
+          (definition) => used.has(definition.variable.name.value)
+        ),
+        selectionSet: probe
+      }
+    ]
+  };
+}
+
+// src/core/variants/resolve.ts
+function personalizationPaths(data) {
+  const paths = /* @__PURE__ */ new Map();
+  const walk = (value, path) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (contextOf(item)?.kind === "PERSONALIZATION") {
+          const record = item;
+          const type = record[PREPR_TYPE_ALIAS] ?? record.__typename;
+          const types = paths.get(path) ?? /* @__PURE__ */ new Set();
+          types.add(typeof type === "string" ? type : "*");
+          paths.set(path, types);
+        }
+        walk(item, path);
+      }
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    for (const [key, child] of Object.entries(value)) {
+      if (key !== PREPR_CONTEXT_ALIAS && key !== PREPR_TYPE_ALIAS)
+        walk(child, path ? `${path}.${key}` : key);
+    }
+  };
+  walk(data, "");
+  return paths;
+}
+function contextOf(item) {
+  if (!item || typeof item !== "object") return null;
+  const context = item[PREPR_CONTEXT_ALIAS];
+  const ctx = context;
+  return ctx?.kind && ctx.group_id ? ctx : null;
+}
+function decisionsFrom(data) {
+  const decisions = /* @__PURE__ */ new Map();
+  const walk = (value) => {
+    if (Array.isArray(value)) return value.forEach(walk);
+    if (!value || typeof value !== "object") return;
+    const ctx = contextOf(value);
+    if (ctx?.group_id && ctx.variant_id) {
+      const ids = decisions.get(ctx.group_id) ?? [];
+      if (!ids.includes(ctx.variant_id)) ids.push(ctx.variant_id);
+      decisions.set(ctx.group_id, ids);
+    }
+    Object.values(value).forEach(walk);
+  };
+  walk(data);
+  return decisions;
+}
+function chosenVariants(ctx, options) {
+  const decided = options.decisions?.get(ctx.group_id);
+  if (ctx.kind === "AB_TEST") {
+    return options.bucket ? [options.bucket] : decided ?? ["A"];
+  }
+  return decided ?? [PREPR_DEFAULT_VARIANT];
+}
+function resolveVariants(data, options = {}) {
+  const resolve = (value) => {
+    if (Array.isArray(value)) {
+      return value.filter((item) => {
+        const ctx = contextOf(item);
+        return !ctx || chosenVariants(ctx, options).includes(ctx.variant_id ?? "");
+      }).map(resolve);
+    }
+    if (!value || typeof value !== "object") return value;
+    const out = {};
+    for (const [key, child] of Object.entries(value)) out[key] = resolve(child);
+    return out;
+  };
+  return resolve(data);
+}
+
+// src/core/variants/schema.ts
+var PREPR_SCHEMA_QUERY = `query PreprPersonalizationSchema {
+  __schema {
+    queryType { name }
+    types {
+      name
+      possibleTypes { name }
+      fields {
+        name
+        args { name }
+        type { name ofType { name ofType { name ofType { name ofType { name } } } } }
+      }
+    }
+  }
+}`;
+function namedType(ref) {
+  let current = ref;
+  while (current && !current.name) current = current.ofType;
+  return current?.name ?? "";
+}
+function toSchemaInfo(introspection) {
+  const types = {};
+  for (const type of introspection.__schema.types) {
+    if (type.name.startsWith("__")) continue;
+    const fields = {};
+    for (const field of type.fields ?? []) {
+      fields[field.name] = {
+        type: namedType(field.type),
+        personalizable: field.args.some((arg) => arg.name === "personalize")
+      };
+    }
+    types[type.name] = {
+      fields,
+      possibleTypes: (type.possibleTypes ?? []).map((t) => t.name),
+      hasContext: "_context" in fields
+    };
+  }
+  return { queryType: introspection.__schema.queryType.name, types };
+}
+
+// src/core/variants/stack.ts
+function containsKind(value, kind) {
+  if (Array.isArray(value))
+    return value.some((item) => containsKind(item, kind));
+  if (!value || typeof value !== "object") return false;
+  if (contextOf(value)?.kind === kind) return true;
+  return Object.values(value).some((child) => containsKind(child, kind));
+}
+function splitStack(items) {
+  const blocks = [];
+  let position = 0;
+  const positionsOf = (block) => block.key.startsWith("group:") ? 1 : block.items.length;
+  items.forEach((item, index) => {
+    const ctx = contextOf(item);
+    const groupKey = ctx ? `group:${ctx.group_id}` : null;
+    const personalized = containsKind(item, "PERSONALIZATION");
+    const abTest = containsKind(item, "AB_TEST");
+    const last = blocks.at(-1);
+    const plain = !groupKey && !personalized && !abTest;
+    if (groupKey && last?.key === groupKey) {
+      last.personalized || (last.personalized = personalized);
+      last.abTest || (last.abTest = abTest);
+      last.items.push(item);
+    } else if (plain && last && !last.personalized && !last.abTest) {
+      last.items.push(item);
+    } else {
+      const last2 = blocks.at(-1);
+      if (last2) position = last2.index + positionsOf(last2);
+      blocks.push({
+        key: groupKey ?? `items:${index}`,
+        items: [item],
+        index: position,
+        personalized,
+        abTest
+      });
+    }
+  });
+  return blocks;
+}
+
+// src/core/variants/tracking.ts
+function preprVariantProps(item) {
+  const key = contextOf(item)?.variant_key;
+  return key ? { "data-prepr-variant-key": key } : {};
+}
+
+// src/core/variants/variants-document.ts
+function variantsSelectionSet(set, typeName, schema) {
+  const selections = set.selections.map((selection) => {
+    if (selection.kind === "InlineFragment") {
+      return {
+        ...selection,
+        selectionSet: variantsSelectionSet(
+          selection.selectionSet,
+          selection.typeCondition?.name.value ?? typeName,
+          schema
+        )
+      };
+    }
+    if (selection.kind !== "Field" || !selection.selectionSet) return selection;
+    const field = schema.types[typeName]?.fields[selection.name.value];
+    if (!field) return selection;
+    const child = variantsSelectionSet(
+      selection.selectionSet,
+      field.type,
+      schema
+    );
+    if (!field.personalizable) return { ...selection, selectionSet: child };
+    return {
+      ...selection,
+      arguments: [
+        ...withoutPersonalizeArg(selection.arguments),
+        {
+          kind: "Argument",
+          name: name("personalize"),
+          value: { kind: "BooleanValue", value: false }
+        }
+      ],
+      selectionSet: selectionSet([
+        ...child.selections,
+        ...contextSelections(field.type, schema)
+      ])
+    };
+  });
+  return { ...set, selections };
+}
+function toVariantsDocument(document2, schema) {
+  const doc = documentOf(document2);
+  return {
+    ...doc,
+    definitions: doc.definitions.map((definition) => {
+      if (definition.kind === "OperationDefinition") {
+        return {
+          ...definition,
+          selectionSet: variantsSelectionSet(
+            definition.selectionSet,
+            schema.queryType,
+            schema
+          )
+        };
+      }
+      if (definition.kind === "FragmentDefinition") {
+        return {
+          ...definition,
+          selectionSet: variantsSelectionSet(
+            definition.selectionSet,
+            definition.typeCondition.name.value,
+            schema
+          )
+        };
+      }
+      return definition;
+    })
+  };
+}
+
+// src/core/graphql/transport.ts
+import { VERCEL_STEGA_REGEX } from "@vercel/stega";
+
+// src/core/stega/clean.ts
+import { vercelStegaClean, vercelStegaDecode } from "@vercel/stega";
+
+// src/core/utils.ts
+var DebugLogger = class {
+  constructor(options) {
+    this.options = {
+      prefix: "[Prepr]",
+      ...options
+    };
+  }
+  // A local `enabled` wins; otherwise defer to the global logger so scoped
+  // loggers created before initDebugLogger() still pick up the setting.
+  isEnabled() {
+    if (this.options.enabled !== void 0) {
+      return this.options.enabled;
+    }
+    return globalDebugLogger?.options?.enabled ?? false;
+  }
+  log(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.log(`${prefix} ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.warn(`${prefix} ${message}`, ...args);
+  }
+  error(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.error(`${prefix} ${message}`, ...args);
+  }
+};
+var globalDebugLogger = null;
+function createScopedLogger(scopeName) {
+  return new DebugLogger({
+    prefix: `[Prepr][${scopeName}]`
+  });
+}
+
+// src/core/stega/clean.ts
+var debug = createScopedLogger("stega:clean");
+function stegaClean(text) {
+  if (!text) return 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(
+  VERCEL_STEGA_REGEX.source,
+  VERCEL_STEGA_REGEX.flags.replace("g", "")
+);
+var STEGA_ESCAPED = /\\u(?:200[bcd]|206[0-3]|feff|d834)/i;
+var URL_KEY = /(url|slug|link|href)$/i;
+var FASTLY_QUERY_MAX = 96 * 1024;
+function base64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary);
+}
+function cacheInit(init, noStore) {
+  const result = { ...init };
+  if (noStore) {
+    result.cache = "no-store";
+    delete result.next;
+  }
+  return result;
+}
+function isFrameworkSignal(error) {
+  return typeof error === "object" && error !== null && typeof error.digest === "string";
+}
+function mergePreprHeaders(base, extra) {
+  const merged = new Headers(base);
+  new Headers(extra).forEach((value, key) => {
+    merged.set(key, value);
+  });
+  return merged;
+}
+function cleanEveryString(_key, value) {
+  return typeof value === "string" ? stegaClean(value) : value;
+}
+function cleanUrlStrings(key, value) {
+  return typeof value === "string" && URL_KEY.test(key) ? stegaClean(value) : value;
+}
+function parseBody(text, stega) {
+  if (stega === "none" || !(STEGA_RAW.test(text) || STEGA_ESCAPED.test(text))) {
+    return JSON.parse(text);
+  }
+  return JSON.parse(text, stega === "all" ? cleanEveryString : cleanUrlStrings);
+}
+function createTransport(options) {
+  const { url, preview = false } = options;
+  const stega = options.stega ?? (preview ? "urls" : "all");
+  const clientHeaders = new Headers(options.headers);
+  return async (document2, variables, queryOptions = {}) => {
+    const query = resolveQuery(document2);
+    const operation = OPERATION_NAME.exec(query)?.[1] ?? "anonymous";
+    const headers = new Headers(clientHeaders);
+    for (const layer of [queryOptions.init?.headers, queryOptions.headers]) {
+      new Headers(layer).forEach((value, key) => {
+        headers.set(key, value);
+      });
+    }
+    headers.set("Content-Type", "application/json");
+    const perRequestHeaders = queryOptions.headers !== void 0 || queryOptions.init?.headers !== void 0;
+    const payload = JSON.stringify({ query, variables });
+    const fastly = options.fastlyQuery ? base64(payload) : null;
+    const viaGet = fastly !== null && fastly.length <= FASTLY_QUERY_MAX;
+    if (viaGet) headers.set("Fastly-Query", fastly);
+    const init = {
+      ...cacheInit(queryOptions.init, preview || perRequestHeaders),
+      method: viaGet ? "GET" : "POST",
+      headers,
+      body: viaGet ? void 0 : payload
+    };
+    const fetchImpl = queryOptions.fetch ?? options.fetch;
+    let response;
+    try {
+      response = await (fetchImpl ? fetchImpl(url, init) : fetch(url, init));
+    } catch (error) {
+      if (isFrameworkSignal(error)) throw error;
+      throw new PreprError(
+        `Prepr GraphQL request failed for ${operation}`,
+        "FETCH_ERROR",
+        operation,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (!response.ok) {
+      throw new PreprError(
+        `Prepr GraphQL HTTP ${response.status} for ${operation}${response.status === 412 ? " (Prepr rejects queries longer than 27,500 characters)" : ""}`,
+        "HTTP_ERROR",
+        operation
+      );
+    }
+    let body;
+    try {
+      body = parseBody(await response.text(), stega);
+    } catch (error) {
+      throw new PreprError(
+        `Prepr GraphQL response for ${operation} is not valid JSON`,
+        "INVALID_RESPONSE",
+        operation,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (typeof body !== "object" || body === null) {
+      throw new PreprError(
+        `Prepr GraphQL response for ${operation} is not an object`,
+        "INVALID_RESPONSE",
+        operation
+      );
+    }
+    const { data, errors } = body;
+    if (Array.isArray(errors) && errors.length > 0) {
+      const messages = errors.map((e) => String(e?.message ?? "Unknown error")).join("; ");
+      throw new PreprError(
+        `Prepr GraphQL errors for ${operation}: ${messages}`,
+        "GRAPHQL_ERROR",
+        operation
+      );
+    }
+    if (data === null || data === void 0) {
+      throw new PreprError(
+        `Prepr GraphQL response for ${operation} has no data`,
+        "INVALID_RESPONSE",
+        operation
+      );
+    }
+    return { data, personalized: isPersonalizedResponse(response) };
+  };
+}
+
+// src/core/graphql/probe.ts
+var AB_TEST_VARY = /\bPrepr-ABTesting/i;
+var SEGMENTS_VARY = /\bPrepr-Segments/i;
+var AB_CHECK_TTL_MS = 6e4;
+var AB_CHECK_MAX_ENTRIES = 1e3;
+function createVaryProbe(run, options) {
+  const abProbes = /* @__PURE__ */ new Map();
+  const abChecks = /* @__PURE__ */ new Map();
+  return (document2, variables) => {
+    const key = JSON.stringify(variables ?? null);
+    let answers = abChecks.get(document2);
+    if (!answers) {
+      answers = /* @__PURE__ */ new Map();
+      abChecks.set(document2, answers);
+    }
+    const cached = answers.get(key);
+    if (cached && Date.now() - cached.at < AB_CHECK_TTL_MS) return cached.value;
+    const value = (async () => {
+      let probe = abProbes.get(document2);
+      if (probe === void 0) {
+        probe = toAbProbeDocument(document2);
+        abProbes.set(document2, probe);
+      }
+      if (!probe) return "";
+      let vary = "";
+      const send = options.fetch ?? fetch;
+      await run(probe, variables, {
+        fetch: async (input, init) => {
+          const response = await send(input, init);
+          vary = response.headers.get("vary") ?? "";
+          return response;
+        }
+      });
+      return vary;
+    })().catch((error) => {
+      if (isFrameworkSignal(error)) throw error;
+      answers.delete(key);
+      return null;
+    });
+    if (answers.size >= AB_CHECK_MAX_ENTRIES) {
+      answers.delete(answers.keys().next().value);
+    }
+    answers.set(key, { value, at: Date.now() });
+    return value;
+  };
+}
+
+// src/core/graphql/client.ts
+function isParseableUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createPreprClient(options) {
+  const { url } = options;
+  validatePreprToken(url);
+  if (!isParseableUrl(url)) {
+    throw new PreprError(
+      "Prepr GraphQL URL is not a valid URL",
+      "INVALID_TOKEN",
+      "createPreprClient"
+    );
+  }
+  const run = createTransport(options);
+  const probeVary = createVaryProbe(run, options);
+  let schema;
+  const loadSchema = () => schema ?? (schema = run(
+    PREPR_SCHEMA_QUERY,
+    void 0,
+    { init: options.schemaInit }
+  ).then(
+    (result) => toSchemaInfo(result.data),
+    (error) => {
+      schema = void 0;
+      throw error;
+    }
+  ));
+  const variantsDocuments = /* @__PURE__ */ new Map();
+  const decisionDocuments = /* @__PURE__ */ new Map();
+  return {
+    async query(document2, variables, queryOptions = {}) {
+      const { variants, ...rest } = queryOptions;
+      if (!variants) return run(document2, variables, rest);
+      let derived = variantsDocuments.get(document2);
+      if (!derived) {
+        derived = toVariantsDocument(document2, await loadSchema());
+        variantsDocuments.set(document2, derived);
+      }
+      return run(derived, variables, rest);
+    },
+    async decide(document2, variables, queryOptions = {}) {
+      const { from, topLevelOnly, ...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" : "*";
+      let byPaths = decisionDocuments.get(document2);
+      if (!byPaths) {
+        byPaths = /* @__PURE__ */ new Map();
+        decisionDocuments.set(document2, byPaths);
+      }
+      let derived = byPaths.get(signature);
+      if (derived === void 0) {
+        derived = toDecisionDocument(document2, await loadSchema(), paths, {
+          topLevelOnly: !paths && topLevelOnly
+        });
+        byPaths.set(signature, derived);
+      }
+      if (!derived) return /* @__PURE__ */ new Map();
+      const { data } = await run(derived, variables, rest);
+      return decisionsFrom(data);
+    },
+    hasAbTests: (document2, variables) => probeVary(document2, variables).then(
+      (vary) => vary === null || AB_TEST_VARY.test(vary)
+    ),
+    hasSegments: (document2, variables) => probeVary(document2, variables).then(
+      (vary) => vary === null || SEGMENTS_VARY.test(vary)
+    )
+  };
+}
+
+// src/nextjs/decisions.ts
+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))
+    );
+  }
+  return out;
+}
+function serializeDecisions(decisions) {
+  return [...decisions].slice(0, DECISIONS_MAX_GROUPS).map(([group, variants]) => `${group}:${variants.join("|")}`).join("~");
+}
+function forwardedHeaders(request, response) {
+  const overridden = response.headers.get("x-middleware-override-headers");
+  if (!overridden) return getPreprHeadersFromHeaders(request.headers);
+  const headers = new Headers();
+  for (const name2 of overridden.split(",")) {
+    const value = response.headers.get(`x-middleware-request-${name2.trim()}`);
+    if (value !== null) headers.set(name2.trim(), value);
+  }
+  return getPreprHeadersFromHeaders(headers);
+}
+async function resolveDecisionsWith(client, seenGroups, request, response, document2, variables, options) {
+  try {
+    if (options?.onlyIf && !await options.onlyIf()) return;
+    if (!await client.hasSegments(document2, variables)) return;
+    const headers = 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 = 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 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);
+    }
+    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
+    });
+  } catch (error) {
+    if (isFrameworkSignal(error)) throw error;
+  }
+}
+
+// src/nextjs/stack.ts
+import {
+  createElement,
+  Fragment,
+  Suspense
+} from "react";
+
+// 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;
+    }
+    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 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}';
+      }
+    });
+  });
+  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;
+  }
+}
+
+// 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";
+var DEFAULT_ATTRIBUTE = "data-prepr-default";
+var GROUP_BASE_CSS = `[${GROUP_ATTRIBUTE}]{display:contents}[${GROUP_ATTRIBUTE}]:not([${DEFAULT_ATTRIBUTE}]){display:none}`;
+function variantKeysOf(items) {
+  return items.flatMap((item) => {
+    const key = preprVariantProps(item)["data-prepr-variant-key"];
+    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
+      );
+    }
+    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));
+}
+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(
+      "div",
+      {
+        key: variant,
+        [GROUP_ATTRIBUTE]: group,
+        [VARIANT_ATTRIBUTE]: variant,
+        ...variant === PREPR_DEFAULT_VARIANT ? { [DEFAULT_ATTRIBUTE]: "" } : {}
+      },
+      renderBuckets(block.items, render, {
+        bucket: options.bucket,
+        decisions: /* @__PURE__ */ new Map([[group, [variant]]]),
+        abTest: false,
+        index: block.index,
+        track: options.track
+      })
+    )
+  );
+}
+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
+}) {
+  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;
+  return createElement(
+    Fragment,
+    null,
+    needsSwitch && createElement(
+      Fragment,
+      { key: "prepr-ab" },
+      createElement("style", {
+        nonce,
+        dangerouslySetInnerHTML: {
+          __html: AB_BASE_CSS + (hasDecided ? GROUP_BASE_CSS : "")
+        }
+      }),
+      createElement("script", {
+        nonce,
+        dangerouslySetInnerHTML: { __html: AB_SWITCH_SCRIPT }
+      }),
+      createElement(PreprAbSwitch)
+    ),
+    ...blocks.map((block) => {
+      if (decidedInProxy(block)) {
+        return createElement(
+          Fragment,
+          { key: block.key },
+          renderAllVariants(block, render, { bucket, track: trackVariants })
+        );
+      }
+      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,
+          bucket,
+          abTest: block.abTest,
+          index: block.index,
+          render,
+          track: trackVariants
+        })
+      );
+    })
+  );
+}
+
+// src/nextjs/graphql.ts
+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.
+    schemaInit: {
+      next: { tags: cacheTags, revalidate: 3600 }
+    },
+    ...coreOptions
+  });
+  const seenGroups = /* @__PURE__ */ new Map();
+  return {
+    async query(document2, variables, queryOptions = {}) {
+      const { personalize = false, ...rest } = queryOptions;
+      const init = rest.init;
+      const tagged = {
+        ...rest,
+        init: {
+          ...init,
+          next: {
+            tags: cacheTags,
+            ...revalidate === void 0 ? {} : { revalidate },
+            ...init?.next
+          }
+        }
+      };
+      if (!personalize) return client.query(document2, variables, tagged);
+      return client.query(document2, variables, {
+        ...tagged,
+        headers: mergePreprHeaders(await getPreprHeaders(), rest.headers)
+      });
+    },
+    async decide(document2, variables, queryOptions = {}) {
+      return client.decide(document2, variables, {
+        ...queryOptions,
+        headers: mergePreprHeaders(
+          await getPreprHeaders(),
+          queryOptions.headers
+        )
+      });
+    },
+    hasAbTests: (document2, variables) => client.hasAbTests(document2, variables),
+    resolveDecisions: (request, response, document2, variables, options2) => resolveDecisionsWith(
+      client,
+      seenGroups,
+      request,
+      response,
+      document2,
+      variables,
+      options2
+    )
+  };
+}
+export {
+  PREPR_DECISIONS_COOKIE,
+  PREPR_DEFAULT_VARIANT,
+  PreprError,
+  PreprStack,
+  createPreprClient2 as createPreprClient,
+  isPersonalizedResponse,
+  preprVariantProps,
+  resolveVariants,
+  splitStack
+};