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

package/dist/astro/graphql.js

@@ -0,0 +1,936 @@
+import {
+  PreprError,
+  getPreprHeadersFromHeaders,
+  isPersonalizedResponse,
+  validatePreprToken
+} from "./chunk-O7N6GPAH.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/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";
+
+// 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/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 assertPreprUrl(url, source) {
+  validatePreprToken(url);
+  if (!isParseableUrl(url)) {
+    throw new PreprError(
+      "Prepr GraphQL URL is not a valid URL",
+      "INVALID_TOKEN",
+      source
+    );
+  }
+}
+function createPreprClient(options) {
+  assertPreprUrl(options.url, "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/core/graphql/event-client.ts
+function createEventClient(options, adapter) {
+  const client = createPreprClient(options);
+  return {
+    async query(document2, variables, queryOptions = {}) {
+      const { personalize, event, ...rest } = queryOptions;
+      if (personalize && event === void 0) {
+        throw new PreprError(
+          "personalize: true requires the request event",
+          "CONTEXT_ERROR",
+          "createPreprClient"
+        );
+      }
+      const fetchImpl = rest.fetch ?? (event === void 0 ? void 0 : adapter.fetch?.(event));
+      const headers = personalize ? mergePreprHeaders(
+        getPreprHeadersFromHeaders(adapter.headers(event)),
+        rest.headers
+      ) : rest.headers;
+      return client.query(document2, variables, {
+        ...rest,
+        headers,
+        fetch: fetchImpl
+      });
+    },
+    async decide(document2, variables, queryOptions) {
+      const { event, ...rest } = queryOptions;
+      if (event === void 0) {
+        throw new PreprError(
+          "decide requires the request event",
+          "CONTEXT_ERROR",
+          "createPreprClient"
+        );
+      }
+      return client.decide(document2, variables, {
+        ...rest,
+        headers: mergePreprHeaders(
+          getPreprHeadersFromHeaders(adapter.headers(event)),
+          rest.headers
+        ),
+        fetch: rest.fetch ?? adapter.fetch?.(event)
+      });
+    }
+  };
+}
+
+// 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/astro/graphql.ts
+function createPreprClient2(options) {
+  return createEventClient(options, {
+    headers: (event) => event.request.headers
+  });
+}
+export {
+  PREPR_DEFAULT_VARIANT,
+  PreprError,
+  createPreprClient2 as createPreprClient,
+  decisionsFrom,
+  isPersonalizedResponse,
+  loadPreprSchema,
+  preprVariantProps,
+  resolveVariants,
+  splitStack,
+  toDecisionQuery,
+  toVariantsQuery
+};