@preprio/toolkit 0.1.0-beta.1

package/dist/pixel-DVSJQC0K.d.ts

@@ -0,0 +1,94 @@
+type Dictionary = Record<string, unknown>;
+declare const dictionaries: {
+    en: Dictionary;
+    nl: Dictionary;
+};
+type Locale = keyof typeof dictionaries;
+
+interface PreprSegment {
+    readonly _id: string;
+    readonly name: string;
+}
+interface PreprToolbarOptions {
+    debug?: boolean;
+    locale?: Locale;
+}
+interface PreprToolbarProps {
+    readonly activeSegment: string | null;
+    readonly activeVariant: string | null;
+    /** Available segments to personalize on. */
+    readonly segments?: readonly PreprSegment[];
+    /** @deprecated Alias for `segments`. */
+    readonly data?: readonly PreprSegment[];
+}
+type PreprHeaderName = 'prepr-customer-id' | 'Prepr-Segments' | 'Prepr-ABtesting' | 'Prepr-User-Agent';
+type PreprVariant = 'A' | 'B';
+type PreprEnvironment = 'preview' | 'production';
+type PreprEventType = 'segment_changed' | 'variant_changed' | 'edit_mode_toggled' | 'preview_mode_toggled' | 'getScrollPosition' | 'loaded' | 'field_edit_requested';
+interface PreprHeaders {
+    readonly 'prepr-customer-id'?: string;
+    readonly 'Prepr-Segments'?: string;
+    readonly 'Prepr-ABtesting'?: PreprVariant;
+    readonly 'Prepr-Preview-Bar'?: 'true';
+    readonly 'Prepr-Context-utm_source'?: string;
+    readonly 'Prepr-Context-utm_medium'?: string;
+    readonly 'Prepr-Context-utm_term'?: string;
+    readonly 'Prepr-Context-utm_content'?: string;
+    readonly 'Prepr-Context-utm_campaign'?: string;
+    readonly 'Prepr-Context-initial_referral'?: string;
+    readonly 'Prepr-Visitor-IP'?: string;
+    readonly 'Prepr-Hubspot-Id'?: string;
+    readonly 'Prepr-Customer-Id-Created'?: 'true';
+    readonly 'Prepr-User-Agent'?: string;
+}
+type PreprErrorCode = 'INVALID_TOKEN' | 'MISSING_TOKEN' | 'HTTP_ERROR' | 'FETCH_ERROR' | 'INVALID_RESPONSE' | 'CONTEXT_ERROR';
+
+/**
+ * Loader + typed facade for Prepr's CDN tracking pixel, so consumers don't have
+ * to paste a `<script>` tag. The pixel itself lives on the CDN; this only sets
+ * up the handoff.
+ *
+ * The CDN script expects a queue stub to already exist when it loads, so the
+ * contract must be reproduced exactly:
+ *   - `window.prepr` pushes `arguments` onto `.queue` until the real script
+ *     lands and replaces `.process`.
+ *   - `.t` must be a `Date.now()` timestamp.
+ *   - The tag is inserted async, `src` cache-busted every 24h via
+ *     `Math.ceil(Date.now() / cacheTime) * cacheTime`.
+ */
+/** Config accepted by the CDN pixel. */
+interface PreprPixelConfig {
+    destinations?: {
+        googleTagManager?: boolean;
+    };
+    variantImpressionThreshold?: number;
+}
+type PreprQueueArgs = unknown[];
+interface PreprQueueFn {
+    (...args: PreprQueueArgs): void;
+    queue: PreprQueueArgs[];
+    t: number;
+    process?: (...args: PreprQueueArgs) => void;
+}
+declare global {
+    interface Window {
+        prepr?: PreprQueueFn;
+    }
+}
+/**
+ * Install the queue stub, inject the pixel script, then queue
+ * `('init', trackingId, config?)` and `('event', 'pageload')` in that order.
+ *
+ * Idempotent, and a no-op outside a browser.
+ */
+declare function loadTrackingPixel(trackingId: string, config?: PreprPixelConfig): void;
+/**
+ * Send a tracking event through `window.prepr`. Only depends on `window.prepr`
+ * existing, never on how it got installed. Warns once and returns quietly when
+ * no pixel is present.
+ */
+declare function trackEvent(name: string, data?: string | Record<string, unknown>): void;
+/** Loader-independent like `trackEvent`; warns once if no pixel is installed. */
+declare function setTrackingParam(key: string, value: string): void;
+
+export { type Locale as L, type PreprSegment as P, type PreprVariant as a, type PreprToolbarProps as b, type PreprToolbarOptions as c, type PreprErrorCode as d, type PreprHeaders as e, type PreprEnvironment as f, type PreprEventType as g, type PreprHeaderName as h, type PreprPixelConfig as i, loadTrackingPixel as l, setTrackingParam as s, trackEvent as t };

package/dist/sveltekit/index.cjs

@@ -0,0 +1,371 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sveltekit/index.ts
+var sveltekit_exports = {};
+__export(sveltekit_exports, {
+  PREPR_LOCALS_KEY: () => PREPR_LOCALS_KEY,
+  PreprError: () => PreprError,
+  extractAccessToken: () => extractAccessToken,
+  getActiveSegment: () => getActiveSegment,
+  getActiveVariant: () => getActiveVariant,
+  getPreprHeaders: () => getPreprHeaders,
+  getPreprHeadersFromLocals: () => getPreprHeadersFromLocals,
+  getPreprUUID: () => getPreprUUID,
+  getToolbarProps: () => getToolbarProps,
+  preprHandle: () => preprHandle,
+  validatePreprToken: () => validatePreprToken
+});
+module.exports = __toCommonJS(sveltekit_exports);
+
+// src/version.ts
+var VERSION = "0.1.0-beta.1";
+
+// src/core/constants.ts
+var COOKIE_PREVIEW_MODE = "Prepr-Preview-Mode";
+var COOKIE_SEGMENT = "Prepr-Segments";
+var COOKIE_VARIANT = "Prepr-ABtesting";
+var COOKIE_UID = "__prepr_uid";
+var COOKIE_HUBSPOT = "hubspotutk";
+var PARAM_SEGMENT = "prepr_preview_segment";
+var PARAM_VARIANT = "prepr_preview_ab";
+var PARAM_HIDE_BAR = "prepr_hide_bar";
+var ONE_YEAR_SECONDS = 60 * 60 * 24 * 365;
+
+// src/core/middleware.ts
+var UTM_PARAMS = [
+  "utm_source",
+  "utm_medium",
+  "utm_term",
+  "utm_content",
+  "utm_campaign"
+];
+function parseCookies(request) {
+  const cookies = /* @__PURE__ */ new Map();
+  const header = request.headers.get("cookie");
+  if (!header) return cookies;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const name = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (!name) continue;
+    cookies.set(name, decodeURIComponent(value));
+  }
+  return cookies;
+}
+function processPreprRequest(request, opts) {
+  const requestHeaders = new Headers(request.headers);
+  const responseCookies = [];
+  const requestCookies = parseCookies(request);
+  const searchParams = new URL(request.url).searchParams;
+  for (const key of UTM_PARAMS) {
+    const value = searchParams.get(key);
+    if (value !== null) {
+      requestHeaders.set(`Prepr-Context-${key}`, value);
+    }
+  }
+  const referer = request.headers.get("referer");
+  if (referer) {
+    requestHeaders.set("Prepr-Context-initial_referral", referer);
+  }
+  const userAgent = request.headers.get("user-agent");
+  if (userAgent) {
+    requestHeaders.set("Prepr-User-Agent", userAgent);
+  }
+  requestHeaders.set("Prepr-Package", `@preprio/toolkit@${opts?.version ?? VERSION}`);
+  const ip = request.headers.get("Cf-Connecting-Ip") ?? request.headers.get("x-real-ip");
+  if (ip) {
+    requestHeaders.set("Prepr-Visitor-IP", ip);
+  }
+  const hutkCookie = requestCookies.get(COOKIE_HUBSPOT);
+  if (hutkCookie) {
+    requestHeaders.set("Prepr-Hubspot-Id", hutkCookie);
+  }
+  let uid = requestCookies.get(COOKIE_UID);
+  if (!uid) {
+    uid = crypto.randomUUID();
+    responseCookies.push({
+      name: COOKIE_UID,
+      value: uid,
+      maxAge: ONE_YEAR_SECONDS,
+      path: "/"
+    });
+    requestHeaders.set("Prepr-Customer-Id-Created", "true");
+  }
+  requestHeaders.set("Prepr-Customer-Id", uid);
+  if (!opts?.preview) {
+    return { requestHeaders, responseCookies };
+  }
+  const hasPreviewParams = searchParams.has(PARAM_SEGMENT) || searchParams.has(PARAM_VARIANT);
+  if (!hasPreviewParams) {
+    const previewModeCookie = requestCookies.get(COOKIE_PREVIEW_MODE);
+    const previewModeEnabled = previewModeCookie !== "false";
+    if (!previewModeEnabled) {
+      return { requestHeaders, responseCookies };
+    }
+  }
+  requestHeaders.set("Prepr-Preview-Bar", "true");
+  const isLivePreview = searchParams.get(PARAM_HIDE_BAR) === "true";
+  if (!isLivePreview) {
+    const segmentCookie = requestCookies.get(COOKIE_SEGMENT);
+    if (segmentCookie) {
+      requestHeaders.set("Prepr-Segments", segmentCookie);
+    }
+    const abCookie = requestCookies.get(COOKIE_VARIANT);
+    if (abCookie) {
+      requestHeaders.set("Prepr-ABtesting", abCookie);
+    }
+  }
+  const previewAb = searchParams.get(PARAM_VARIANT);
+  if (previewAb !== null) {
+    requestHeaders.set("Prepr-ABtesting", previewAb);
+    if (!isLivePreview) {
+      responseCookies.push({
+        name: COOKIE_VARIANT,
+        value: previewAb,
+        maxAge: ONE_YEAR_SECONDS,
+        path: "/"
+      });
+    }
+  }
+  const previewSegment = searchParams.get(PARAM_SEGMENT);
+  if (previewSegment !== null) {
+    requestHeaders.set("Prepr-Segments", previewSegment);
+    if (!isLivePreview) {
+      responseCookies.push({
+        name: COOKIE_SEGMENT,
+        value: previewSegment,
+        maxAge: ONE_YEAR_SECONDS,
+        path: "/"
+      });
+    }
+  }
+  return { requestHeaders, responseCookies };
+}
+
+// src/sveltekit/hooks.ts
+var PREPR_LOCALS_KEY = "prepr";
+function preprHandle(options) {
+  return async ({ event, resolve }) => {
+    const { requestHeaders, responseCookies } = processPreprRequest(event.request, options);
+    requestHeaders.forEach((value, key) => {
+      event.request.headers.set(key, value);
+    });
+    if (event.locals) {
+      event.locals[PREPR_LOCALS_KEY] = requestHeaders;
+    }
+    const response = await resolve(event);
+    for (const cookie of responseCookies) {
+      const parts = [
+        `${cookie.name}=${encodeURIComponent(cookie.value)}`,
+        `Max-Age=${cookie.maxAge}`,
+        `Path=${cookie.path}`
+      ];
+      response.headers.append("Set-Cookie", parts.join("; "));
+    }
+    return response;
+  };
+}
+function getPreprHeadersFromLocals(locals) {
+  const headers = locals[PREPR_LOCALS_KEY];
+  return headers instanceof Headers ? headers : new Headers();
+}
+
+// src/core/server.ts
+var PreprError = class extends Error {
+  constructor(message, code, context, originalError) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.originalError = originalError;
+    this.name = "PreprError";
+  }
+};
+function getPreprUUIDFromHeaders(headers) {
+  return headers.get("prepr-customer-id");
+}
+function getActiveSegmentFromHeaders(headers) {
+  return headers.get("Prepr-Segments");
+}
+function getActiveVariantFromHeaders(headers) {
+  return headers.get("Prepr-ABtesting");
+}
+var PREPR_HEADER_KEYS = [
+  "prepr-customer-id",
+  "Prepr-Segments",
+  "Prepr-ABtesting",
+  "Prepr-Preview-Bar",
+  "Prepr-Context-utm_source",
+  "Prepr-Context-utm_medium",
+  "Prepr-Context-utm_term",
+  "Prepr-Context-utm_content",
+  "Prepr-Context-utm_campaign",
+  "Prepr-Context-initial_referral",
+  "Prepr-Visitor-IP",
+  "Prepr-Hubspot-Id",
+  "Prepr-Customer-Id-Created",
+  "Prepr-User-Agent"
+];
+function getPreprHeadersFromHeaders(headers) {
+  const preprHeaders = {};
+  const copy = (key) => {
+    const value = headers.get(key);
+    if (value !== null) {
+      preprHeaders[key] = value;
+    }
+  };
+  for (const key of PREPR_HEADER_KEYS) {
+    copy(key);
+  }
+  return preprHeaders;
+}
+function validatePreprToken(token) {
+  if (!token) {
+    throw new PreprError("Token is required", "MISSING_TOKEN", "validatePreprToken");
+  }
+  if (!token.startsWith("https://")) {
+    throw new PreprError(
+      "Token must be a valid HTTPS URL",
+      "INVALID_TOKEN",
+      "validatePreprToken"
+    );
+  }
+}
+function extractAccessToken(graphqlUrl) {
+  let url;
+  try {
+    url = new URL(graphqlUrl);
+  } catch (error) {
+    throw new PreprError(
+      "Token must be a valid URL",
+      "INVALID_TOKEN",
+      "extractAccessToken",
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+  if (url.hostname !== "graphql.prepr.io") {
+    throw new PreprError(
+      "Token must be a graphql.prepr.io URL",
+      "INVALID_TOKEN",
+      "extractAccessToken"
+    );
+  }
+  const pathParts = url.pathname.split("/");
+  const token = pathParts[pathParts.length - 1];
+  if (!token) {
+    throw new PreprError(
+      "Token URL is missing an access token segment",
+      "INVALID_TOKEN",
+      "extractAccessToken"
+    );
+  }
+  return token;
+}
+async function getPreprEnvironmentSegments(token) {
+  validatePreprToken(token);
+  try {
+    const response = await fetch(token, {
+      headers: {
+        "User-Agent": `Prepr-Preview-Bar/${VERSION}`,
+        "Content-Type": "application/json"
+      },
+      method: "POST",
+      body: JSON.stringify({
+        query: `{
+                _Segments {
+                    _id
+                    name
+                }
+            }`
+      })
+    });
+    if (!response.ok) {
+      throw new PreprError(
+        `HTTP ${response.status}: ${response.statusText}`,
+        "HTTP_ERROR",
+        "getPreprEnvironmentSegments"
+      );
+    }
+    const json = await response.json();
+    if (!json || !json.data || !json.data._Segments) {
+      throw new PreprError(
+        "Invalid response format from Prepr API",
+        "INVALID_RESPONSE",
+        "getPreprEnvironmentSegments"
+      );
+    }
+    return json.data._Segments;
+  } catch (error) {
+    if (error instanceof PreprError) {
+      throw error;
+    }
+    throw new PreprError(
+      "Failed to fetch segments from Prepr API",
+      "FETCH_ERROR",
+      "getPreprEnvironmentSegments",
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+}
+async function getToolbarPropsFromHeaders(headers, token) {
+  let segments = [];
+  try {
+    segments = await getPreprEnvironmentSegments(token);
+  } catch {
+    segments = [];
+  }
+  return {
+    activeSegment: getActiveSegmentFromHeaders(headers),
+    activeVariant: getActiveVariantFromHeaders(headers),
+    segments,
+    data: segments
+  };
+}
+
+// src/sveltekit/server.ts
+function getPreprUUID(headers) {
+  return getPreprUUIDFromHeaders(headers);
+}
+function getActiveSegment(headers) {
+  return getActiveSegmentFromHeaders(headers);
+}
+function getActiveVariant(headers) {
+  return getActiveVariantFromHeaders(headers);
+}
+function getPreprHeaders(headers) {
+  return getPreprHeadersFromHeaders(headers);
+}
+async function getToolbarProps(headers, token) {
+  return getToolbarPropsFromHeaders(headers, token);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PREPR_LOCALS_KEY,
+  PreprError,
+  extractAccessToken,
+  getActiveSegment,
+  getActiveVariant,
+  getPreprHeaders,
+  getPreprHeadersFromLocals,
+  getPreprUUID,
+  getToolbarProps,
+  preprHandle,
+  validatePreprToken
+});

package/dist/sveltekit/index.d.cts

@@ -0,0 +1,117 @@
+interface PreprMiddlewareOptions {
+    /** Enable preview-mode headers (segment/AB overrides, preview bar). */
+    preview?: boolean;
+    /** Override the version reported in Prepr-Package (mainly for tests). */
+    version?: string;
+}
+
+/**
+ * Structural stand-in for SvelteKit's `RequestEvent`, so this package needs no
+ * build-time dependency on `@sveltejs/kit`. Only the fields `preprHandle` uses.
+ */
+interface SvelteKitRequestEvent {
+    request: Request;
+    /**
+     * Request-scoped bag shared across `handle` → `load`. `preprHandle` mirrors
+     * the computed Prepr headers here for load functions that prefer an explicit
+     * read over `request.headers` (see `getPreprHeadersFromLocals`). Optional —
+     * hand-built events (tests, non-page endpoints) may omit it.
+     */
+    locals?: Record<string, unknown>;
+}
+/** Key under which `preprHandle` mirrors the forwarded Prepr `Headers`. */
+declare const PREPR_LOCALS_KEY = "prepr";
+/** SvelteKit's `resolve(event)` — produces the downstream `Response`. */
+type SvelteKitResolve = (event: SvelteKitRequestEvent) => Promise<Response>;
+/** Structural match for SvelteKit's `Handle`. */
+type Handle = (input: {
+    event: SvelteKitRequestEvent;
+    resolve: SvelteKitResolve;
+}) => Promise<Response>;
+/**
+ * Builds the SvelteKit `Handle` for `src/hooks.server.ts`.
+ *
+ * The computed Prepr headers are set on `event.request.headers` in place, which
+ * load functions do see: SvelteKit shallow-spreads the event before `handle`
+ * (`respond.js`) and again before `load` (`load_data.js`), so `request` is
+ * carried by reference and never reconstructed — same mechanism as the Astro
+ * wrapper's `onPreprRequest`. Verified against @sveltejs/kit 2.70.1. The same
+ * `Headers` are mirrored onto `event.locals` for callers who prefer reading
+ * them explicitly (`getPreprHeadersFromLocals`). Cookies are appended to the
+ * resolved response.
+ */
+declare function preprHandle(options?: PreprMiddlewareOptions): Handle;
+/**
+ * Personalization headers to forward to your GraphQL fetch, for use in load
+ * functions. Equivalent to reading `event.request.headers` — `preprHandle`
+ * writes both. Empty `Headers` if `preprHandle` did not run, so the result is
+ * always safe to spread.
+ */
+declare function getPreprHeadersFromLocals(locals: Record<string, unknown>): Headers;
+
+interface PreprSegment {
+    readonly _id: string;
+    readonly name: string;
+}
+interface PreprToolbarProps {
+    readonly activeSegment: string | null;
+    readonly activeVariant: string | null;
+    /** Available segments to personalize on. */
+    readonly segments?: readonly PreprSegment[];
+    /** @deprecated Alias for `segments`. */
+    readonly data?: readonly PreprSegment[];
+}
+type PreprVariant = 'A' | 'B';
+interface PreprHeaders {
+    readonly 'prepr-customer-id'?: string;
+    readonly 'Prepr-Segments'?: string;
+    readonly 'Prepr-ABtesting'?: PreprVariant;
+    readonly 'Prepr-Preview-Bar'?: 'true';
+    readonly 'Prepr-Context-utm_source'?: string;
+    readonly 'Prepr-Context-utm_medium'?: string;
+    readonly 'Prepr-Context-utm_term'?: string;
+    readonly 'Prepr-Context-utm_content'?: string;
+    readonly 'Prepr-Context-utm_campaign'?: string;
+    readonly 'Prepr-Context-initial_referral'?: string;
+    readonly 'Prepr-Visitor-IP'?: string;
+    readonly 'Prepr-Hubspot-Id'?: string;
+    readonly 'Prepr-Customer-Id-Created'?: 'true';
+    readonly 'Prepr-User-Agent'?: string;
+}
+type PreprErrorCode = 'INVALID_TOKEN' | 'MISSING_TOKEN' | 'HTTP_ERROR' | 'FETCH_ERROR' | 'INVALID_RESPONSE' | 'CONTEXT_ERROR';
+
+/** Returns the Prepr Customer ID from `event.request.headers`. */
+declare function getPreprUUID(headers: Headers): string | null;
+/** Returns the active segment from `event.request.headers`. */
+declare function getActiveSegment(headers: Headers): string | null;
+/** Returns the active A/B testing variant from `event.request.headers`. */
+declare function getActiveVariant(headers: Headers): string | null;
+/** Returns all Prepr headers from `event.request.headers`. */
+declare function getPreprHeaders(headers: Headers): PreprHeaders;
+/**
+ * Props needed to mount `PreprToolbar.svelte`, from `event.request.headers`
+ * plus a Prepr GraphQL token. Ungated — gate on preview mode yourself in
+ * `+layout.server.ts`.
+ */
+declare function getToolbarProps(headers: Headers, token: string): Promise<PreprToolbarProps>;
+
+/** Error thrown by the token helpers and the segments fetch. */
+declare class PreprError extends Error {
+    readonly code: PreprErrorCode;
+    readonly context?: string | undefined;
+    readonly originalError?: Error | undefined;
+    constructor(message: string, code: PreprErrorCode, context?: string | undefined, originalError?: Error | undefined);
+}
+/**
+ * Asserts `token` is the full `https://graphql.prepr.io/<token>` URL.
+ * @throws PreprError if the token is missing or not an HTTPS URL.
+ */
+declare function validatePreprToken(token: string): void;
+/**
+ * Pulls the access token out of a GraphQL URL: `https://graphql.prepr.io/abc123`
+ * -> `abc123`.
+ * @throws PreprError if the URL is not a valid `graphql.prepr.io` URL.
+ */
+declare function extractAccessToken(graphqlUrl: string): string;
+
+export { type Handle, PREPR_LOCALS_KEY, PreprError, type PreprMiddlewareOptions, type SvelteKitRequestEvent, type SvelteKitResolve, extractAccessToken, getActiveSegment, getActiveVariant, getPreprHeaders, getPreprHeadersFromLocals, getPreprUUID, getToolbarProps, preprHandle, validatePreprToken };

package/dist/sveltekit/index.d.ts

@@ -0,0 +1,117 @@
+interface PreprMiddlewareOptions {
+    /** Enable preview-mode headers (segment/AB overrides, preview bar). */
+    preview?: boolean;
+    /** Override the version reported in Prepr-Package (mainly for tests). */
+    version?: string;
+}
+
+/**
+ * Structural stand-in for SvelteKit's `RequestEvent`, so this package needs no
+ * build-time dependency on `@sveltejs/kit`. Only the fields `preprHandle` uses.
+ */
+interface SvelteKitRequestEvent {
+    request: Request;
+    /**
+     * Request-scoped bag shared across `handle` → `load`. `preprHandle` mirrors
+     * the computed Prepr headers here for load functions that prefer an explicit
+     * read over `request.headers` (see `getPreprHeadersFromLocals`). Optional —
+     * hand-built events (tests, non-page endpoints) may omit it.
+     */
+    locals?: Record<string, unknown>;
+}
+/** Key under which `preprHandle` mirrors the forwarded Prepr `Headers`. */
+declare const PREPR_LOCALS_KEY = "prepr";
+/** SvelteKit's `resolve(event)` — produces the downstream `Response`. */
+type SvelteKitResolve = (event: SvelteKitRequestEvent) => Promise<Response>;
+/** Structural match for SvelteKit's `Handle`. */
+type Handle = (input: {
+    event: SvelteKitRequestEvent;
+    resolve: SvelteKitResolve;
+}) => Promise<Response>;
+/**
+ * Builds the SvelteKit `Handle` for `src/hooks.server.ts`.
+ *
+ * The computed Prepr headers are set on `event.request.headers` in place, which
+ * load functions do see: SvelteKit shallow-spreads the event before `handle`
+ * (`respond.js`) and again before `load` (`load_data.js`), so `request` is
+ * carried by reference and never reconstructed — same mechanism as the Astro
+ * wrapper's `onPreprRequest`. Verified against @sveltejs/kit 2.70.1. The same
+ * `Headers` are mirrored onto `event.locals` for callers who prefer reading
+ * them explicitly (`getPreprHeadersFromLocals`). Cookies are appended to the
+ * resolved response.
+ */
+declare function preprHandle(options?: PreprMiddlewareOptions): Handle;
+/**
+ * Personalization headers to forward to your GraphQL fetch, for use in load
+ * functions. Equivalent to reading `event.request.headers` — `preprHandle`
+ * writes both. Empty `Headers` if `preprHandle` did not run, so the result is
+ * always safe to spread.
+ */
+declare function getPreprHeadersFromLocals(locals: Record<string, unknown>): Headers;
+
+interface PreprSegment {
+    readonly _id: string;
+    readonly name: string;
+}
+interface PreprToolbarProps {
+    readonly activeSegment: string | null;
+    readonly activeVariant: string | null;
+    /** Available segments to personalize on. */
+    readonly segments?: readonly PreprSegment[];
+    /** @deprecated Alias for `segments`. */
+    readonly data?: readonly PreprSegment[];
+}
+type PreprVariant = 'A' | 'B';
+interface PreprHeaders {
+    readonly 'prepr-customer-id'?: string;
+    readonly 'Prepr-Segments'?: string;
+    readonly 'Prepr-ABtesting'?: PreprVariant;
+    readonly 'Prepr-Preview-Bar'?: 'true';
+    readonly 'Prepr-Context-utm_source'?: string;
+    readonly 'Prepr-Context-utm_medium'?: string;
+    readonly 'Prepr-Context-utm_term'?: string;
+    readonly 'Prepr-Context-utm_content'?: string;
+    readonly 'Prepr-Context-utm_campaign'?: string;
+    readonly 'Prepr-Context-initial_referral'?: string;
+    readonly 'Prepr-Visitor-IP'?: string;
+    readonly 'Prepr-Hubspot-Id'?: string;
+    readonly 'Prepr-Customer-Id-Created'?: 'true';
+    readonly 'Prepr-User-Agent'?: string;
+}
+type PreprErrorCode = 'INVALID_TOKEN' | 'MISSING_TOKEN' | 'HTTP_ERROR' | 'FETCH_ERROR' | 'INVALID_RESPONSE' | 'CONTEXT_ERROR';
+
+/** Returns the Prepr Customer ID from `event.request.headers`. */
+declare function getPreprUUID(headers: Headers): string | null;
+/** Returns the active segment from `event.request.headers`. */
+declare function getActiveSegment(headers: Headers): string | null;
+/** Returns the active A/B testing variant from `event.request.headers`. */
+declare function getActiveVariant(headers: Headers): string | null;
+/** Returns all Prepr headers from `event.request.headers`. */
+declare function getPreprHeaders(headers: Headers): PreprHeaders;
+/**
+ * Props needed to mount `PreprToolbar.svelte`, from `event.request.headers`
+ * plus a Prepr GraphQL token. Ungated — gate on preview mode yourself in
+ * `+layout.server.ts`.
+ */
+declare function getToolbarProps(headers: Headers, token: string): Promise<PreprToolbarProps>;
+
+/** Error thrown by the token helpers and the segments fetch. */
+declare class PreprError extends Error {
+    readonly code: PreprErrorCode;
+    readonly context?: string | undefined;
+    readonly originalError?: Error | undefined;
+    constructor(message: string, code: PreprErrorCode, context?: string | undefined, originalError?: Error | undefined);
+}
+/**
+ * Asserts `token` is the full `https://graphql.prepr.io/<token>` URL.
+ * @throws PreprError if the token is missing or not an HTTPS URL.
+ */
+declare function validatePreprToken(token: string): void;
+/**
+ * Pulls the access token out of a GraphQL URL: `https://graphql.prepr.io/abc123`
+ * -> `abc123`.
+ * @throws PreprError if the URL is not a valid `graphql.prepr.io` URL.
+ */
+declare function extractAccessToken(graphqlUrl: string): string;
+
+export { type Handle, PREPR_LOCALS_KEY, PreprError, type PreprMiddlewareOptions, type SvelteKitRequestEvent, type SvelteKitResolve, extractAccessToken, getActiveSegment, getActiveVariant, getPreprHeaders, getPreprHeadersFromLocals, getPreprUUID, getToolbarProps, preprHandle, validatePreprToken };