@preprio/toolkit 0.1.0-beta.1 → 0.1.0-beta.4

package/dist/nuxt/index.cjs

@@ -0,0 +1,399 @@
+"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/nuxt/index.ts
+var nuxt_exports = {};
+__export(nuxt_exports, {
+  PREPR_CONTEXT_KEY: () => PREPR_CONTEXT_KEY,
+  PreprError: () => PreprError,
+  extractAccessToken: () => extractAccessToken,
+  getActiveSegment: () => getActiveSegment,
+  getActiveVariant: () => getActiveVariant,
+  getPreprHeaders: () => getPreprHeaders,
+  getPreprHeadersFromEvent: () => getPreprHeadersFromEvent,
+  getPreprUUID: () => getPreprUUID,
+  getToolbarProps: () => getToolbarProps,
+  handlePreprRequest: () => handlePreprRequest,
+  validatePreprToken: () => validatePreprToken
+});
+module.exports = __toCommonJS(nuxt_exports);
+
+// src/version.ts
+var VERSION = "0.1.0-beta.4";
+
+// 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 serializeCookie(cookie) {
+  const parts = [
+    `${cookie.name}=${encodeURIComponent(cookie.value)}`,
+    `Max-Age=${cookie.maxAge}`,
+    `Path=${cookie.path}`
+  ];
+  if (cookie.sameSite) {
+    parts.push(`SameSite=${cookie.sameSite}`);
+  }
+  if (cookie.secure) {
+    parts.push("Secure");
+  }
+  return parts.join("; ");
+}
+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 url = new URL(request.url);
+  const searchParams = url.searchParams;
+  const forwardedProto = request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
+  const isSecure = forwardedProto ? forwardedProto === "https" : url.protocol === "https:";
+  const crossSite = isSecure ? { sameSite: "None", secure: true } : {};
+  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 && !requestCookies.has(COOKIE_PREVIEW_MODE)) {
+    responseCookies.push({
+      name: COOKIE_PREVIEW_MODE,
+      value: "true",
+      maxAge: ONE_YEAR_SECONDS,
+      path: "/",
+      ...crossSite
+    });
+  }
+  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: "/",
+        ...crossSite
+      });
+    }
+  }
+  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: "/",
+        ...crossSite
+      });
+    }
+  }
+  return { requestHeaders, responseCookies };
+}
+
+// src/nuxt/middleware.ts
+var PREPR_CONTEXT_KEY = "prepr";
+function handlePreprRequest(event, options) {
+  const req = event.node.req;
+  const host = typeof req.headers.host === "string" ? req.headers.host : "localhost";
+  const request = new Request(`http://${host}${req.url ?? "/"}`);
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (typeof value === "string") {
+      request.headers.set(key, value);
+    } else if (Array.isArray(value)) {
+      request.headers.set(key, value.join(", "));
+    }
+  }
+  const { requestHeaders, responseCookies } = processPreprRequest(request, options);
+  requestHeaders.forEach((value, key) => {
+    req.headers[key.toLowerCase()] = value;
+  });
+  event.context[PREPR_CONTEXT_KEY] = requestHeaders;
+  for (const cookie of responseCookies) {
+    event.node.res.appendHeader("Set-Cookie", serializeCookie(cookie));
+  }
+}
+function getPreprHeadersFromEvent(event) {
+  const headers = event.context[PREPR_CONTEXT_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/nuxt/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_CONTEXT_KEY,
+  PreprError,
+  extractAccessToken,
+  getActiveSegment,
+  getActiveVariant,
+  getPreprHeaders,
+  getPreprHeadersFromEvent,
+  getPreprUUID,
+  getToolbarProps,
+  handlePreprRequest,
+  validatePreprToken
+});

package/dist/nuxt/index.d.cts

@@ -0,0 +1,120 @@
+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 h3's `H3Event`, so this package needs no build-time
+ * dependency on `h3`/`nuxt`. Only the fields `handlePreprRequest` uses.
+ *
+ * `node` ties this to Nitro's Node.js preset (the Nuxt default). Edge presets
+ * expose no raw Node request/response to fold headers back onto.
+ */
+interface H3EventLike {
+    node: {
+        req: {
+            url?: string;
+            headers: Record<string, string | string[] | undefined>;
+        };
+        res: {
+            /** Node's `ServerResponse.appendHeader` (Node >= 18.3). */
+            appendHeader(name: string, value: string): unknown;
+        };
+    };
+    /** Request-scoped bag shared with route handlers and Vue via `useRequestEvent`. */
+    context: Record<string, unknown>;
+}
+/** Key under which `handlePreprRequest` mirrors the forwarded Prepr `Headers`. */
+declare const PREPR_CONTEXT_KEY = "prepr";
+/**
+ * Nuxt server middleware entry point — call it inside `defineEventHandler` in
+ * `server/middleware/prepr.ts`:
+ *
+ * ```ts
+ * export default defineEventHandler(event => {
+ *   handlePreprRequest(event, { preview: import.meta.dev });
+ * });
+ * ```
+ *
+ * The computed Prepr headers are folded back onto the raw Node request
+ * (lowercased, as Node stores them), which is what `useRequestHeaders()` and
+ * downstream handlers read. The same `Headers` are mirrored onto
+ * `event.context.prepr` for callers who prefer an explicit read
+ * (`getPreprHeadersFromEvent`). Cookies are appended to the response.
+ */
+declare function handlePreprRequest(event: H3EventLike, options?: PreprMiddlewareOptions): void;
+/**
+ * Personalization headers to forward to your GraphQL fetch, from the h3 event.
+ * Empty `Headers` if `handlePreprRequest` did not run, so the result is always
+ * safe to spread.
+ */
+declare function getPreprHeadersFromEvent(event: Pick<H3EventLike, 'context'>): 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 the request headers. */
+declare function getPreprUUID(headers: Headers): string | null;
+/** Returns the active segment from the request headers. */
+declare function getActiveSegment(headers: Headers): string | null;
+/** Returns the active A/B testing variant from the request headers. */
+declare function getActiveVariant(headers: Headers): string | null;
+/** Returns all Prepr headers from the request headers. */
+declare function getPreprHeaders(headers: Headers): PreprHeaders;
+/**
+ * Props needed to mount `PreprToolbar.vue`, from the request headers plus a
+ * Prepr GraphQL token. Ungated — gate on preview mode yourself (e.g.
+ * `import.meta.dev`).
+ */
+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 H3EventLike, PREPR_CONTEXT_KEY, PreprError, type PreprMiddlewareOptions, extractAccessToken, getActiveSegment, getActiveVariant, getPreprHeaders, getPreprHeadersFromEvent, getPreprUUID, getToolbarProps, handlePreprRequest, validatePreprToken };

package/dist/nuxt/index.d.ts

@@ -0,0 +1,120 @@
+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 h3's `H3Event`, so this package needs no build-time
+ * dependency on `h3`/`nuxt`. Only the fields `handlePreprRequest` uses.
+ *
+ * `node` ties this to Nitro's Node.js preset (the Nuxt default). Edge presets
+ * expose no raw Node request/response to fold headers back onto.
+ */
+interface H3EventLike {
+    node: {
+        req: {
+            url?: string;
+            headers: Record<string, string | string[] | undefined>;
+        };
+        res: {
+            /** Node's `ServerResponse.appendHeader` (Node >= 18.3). */
+            appendHeader(name: string, value: string): unknown;
+        };
+    };
+    /** Request-scoped bag shared with route handlers and Vue via `useRequestEvent`. */
+    context: Record<string, unknown>;
+}
+/** Key under which `handlePreprRequest` mirrors the forwarded Prepr `Headers`. */
+declare const PREPR_CONTEXT_KEY = "prepr";
+/**
+ * Nuxt server middleware entry point — call it inside `defineEventHandler` in
+ * `server/middleware/prepr.ts`:
+ *
+ * ```ts
+ * export default defineEventHandler(event => {
+ *   handlePreprRequest(event, { preview: import.meta.dev });
+ * });
+ * ```
+ *
+ * The computed Prepr headers are folded back onto the raw Node request
+ * (lowercased, as Node stores them), which is what `useRequestHeaders()` and
+ * downstream handlers read. The same `Headers` are mirrored onto
+ * `event.context.prepr` for callers who prefer an explicit read
+ * (`getPreprHeadersFromEvent`). Cookies are appended to the response.
+ */
+declare function handlePreprRequest(event: H3EventLike, options?: PreprMiddlewareOptions): void;
+/**
+ * Personalization headers to forward to your GraphQL fetch, from the h3 event.
+ * Empty `Headers` if `handlePreprRequest` did not run, so the result is always
+ * safe to spread.
+ */
+declare function getPreprHeadersFromEvent(event: Pick<H3EventLike, 'context'>): 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 the request headers. */
+declare function getPreprUUID(headers: Headers): string | null;
+/** Returns the active segment from the request headers. */
+declare function getActiveSegment(headers: Headers): string | null;
+/** Returns the active A/B testing variant from the request headers. */
+declare function getActiveVariant(headers: Headers): string | null;
+/** Returns all Prepr headers from the request headers. */
+declare function getPreprHeaders(headers: Headers): PreprHeaders;
+/**
+ * Props needed to mount `PreprToolbar.vue`, from the request headers plus a
+ * Prepr GraphQL token. Ungated — gate on preview mode yourself (e.g.
+ * `import.meta.dev`).
+ */
+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 H3EventLike, PREPR_CONTEXT_KEY, PreprError, type PreprMiddlewareOptions, extractAccessToken, getActiveSegment, getActiveVariant, getPreprHeaders, getPreprHeadersFromEvent, getPreprUUID, getToolbarProps, handlePreprRequest, validatePreprToken };