fontdue-js 3.0.0-alpha9 → 3.0.0

package/dist/preview/index.d.ts

@@ -0,0 +1,53 @@
+import { PREVIEW_TOKEN_COOKIE, PREVIEW_MARKER_COOKIE, PREVIEW_ENDPOINT, DEFAULT_PREVIEW_TTL_MS, PREVIEW_MARKER_GRACE_MS } from './constants.js';
+export { PREVIEW_TOKEN_COOKIE, PREVIEW_MARKER_COOKIE, PREVIEW_ENDPOINT, DEFAULT_PREVIEW_TTL_MS, PREVIEW_MARKER_GRACE_MS, };
+export interface PreviewCookieOptions {
+    /**
+     * Whether to set the cookies' Secure attribute. Defaults to true on https
+     * requests and false otherwise, so cookies work over http in local dev.
+     */
+    secure?: boolean;
+    /** SameSite attribute. Defaults to 'lax' — the toolbar is same-site. */
+    sameSite?: 'lax' | 'strict' | 'none';
+    /** Cookie path. Defaults to '/'. */
+    path?: string;
+}
+/**
+ * Web-standard route handler implementing the portable preview contract. Wire
+ * it into your framework's route at the path the toolbar targets
+ * (`/api/preview` by default):
+ *
+ *   // Astro: src/pages/api/preview.ts
+ *   import { handlePreviewRequest } from 'fontdue-js/preview';
+ *   export const ALL: APIRoute = ({ request }) => handlePreviewRequest(request);
+ *
+ *   // React Router 7: app/routes/api.preview.ts
+ *   import { handlePreviewRequest } from 'fontdue-js/preview';
+ *   export const action = ({ request }: Route.ActionArgs) =>
+ *     handlePreviewRequest(request);
+ *
+ * POST expects a JSON body `{ token: string, expiresAt?: string | number }`;
+ * DELETE takes no body. `expiresAt` (ISO-8601 or epoch-ms) is the token's
+ * expiry; it's stored in the readable marker cookie so the toolbar can warn
+ * when preview has lapsed, and defaults to now + DEFAULT_PREVIEW_TTL_MS when
+ * omitted. The token is opaque here — the Fontdue GraphQL server validates it
+ * on each request, so a forged token simply reveals nothing. Frameworks that
+ * cache HTML should also bypass their shared/CDN cache when
+ * PREVIEW_MARKER_COOKIE is present, so an admin preview is never served to the
+ * public.
+ */
+export declare function handlePreviewRequest(request: Request, options?: PreviewCookieOptions): Promise<Response>;
+/**
+ * Extract the preview token from a Cookie header string, e.g.
+ * `readPreviewToken(request.headers.get('cookie'))`. This is the canonical
+ * reader — it reverses the encoding `handlePreviewRequest` applies, so the
+ * token comes back verbatim. Returns undefined when not in preview.
+ */
+export declare function readPreviewToken(cookieHeader: string | null | undefined): string | undefined;
+/**
+ * Headers to merge into a server-side GraphQL fetch so the request reveals
+ * hidden fonts. Spread the result into your app's fetch headers, into
+ * fontdue-js's per-render `serverConfig.headers`, or into the `headers` option
+ * of a preload helper (loadFontdueProviderQuery, loadTypeTesterQuery, …).
+ * Returns {} when there is no token, so it's safe to spread unconditionally.
+ */
+export declare function previewAuthHeaders(token: string | null | undefined): Record<string, string>;

package/dist/preview/index.js

@@ -0,0 +1,190 @@
+// Portable admin-preview contract, shared by every framework adapter.
+//
+// The admin toolbar (FontdueAdminToolbar, auto-mounted by FontdueProvider)
+// detects a logged-in admin session, brokers a short-lived admin token, and
+// POSTs it to a small preview route on the storefront's own origin to "enter
+// preview"; a DELETE exits. In Next.js that route additionally toggles draft
+// mode, but the underlying contract is framework-agnostic:
+//
+//   - Enter (POST { token }): set an httpOnly token cookie + a readable marker
+//     cookie, so server renders forward the token and the client toolbar can
+//     tell preview is on.
+//   - Exit (DELETE): clear both cookies.
+//   - Server fetch: when the token cookie is present, forward it as
+//     `Authorization: Bearer <token>` so GraphQL reveals hidden (unpublished)
+//     fonts. The public never has these cookies, so their renders stay
+//     sessionless and cacheable.
+//
+// Astro, React Router 7 and TanStack Start all speak the Web Fetch API, so
+// `handlePreviewRequest` is a drop-in route handler for all of them. Next keeps
+// its own route because it layers Next draft mode on top of the same cookies.
+//
+// Why not route this through fontdue-js's per-render `setFontdueServerConfig`
+// store? That store is React.cache-backed and only isolates per request inside
+// an RSC render (Next). Outside RSC — Astro frontmatter, RR7 loaders — writes
+// are no-ops (see relay/serverConfig.ts). Two portable ways to get the token to
+// server fetches instead:
+//
+//   - Ambient (recommended): wrap requests in `runWithPreview` from
+//     fontdue-js/preview/server, which holds the token in AsyncLocalStorage for
+//     the request so every fontdue-js fetch/preload forwards it with no
+//     per-call plumbing — and forces preview responses out of shared caches.
+//   - Explicit: read the cookie per request and pass `previewAuthHeaders(token)`
+//     via the `headers` option on the app's own GraphQL fetch and on each
+//     preload helper (loadFontdueProviderQuery, loadTypeTesterQuery, …). This
+//     mirrors how headless-CMS previews (e.g. Sanity's loadQuery) pass
+//     per-request state explicitly, and is the fallback where ambient context
+//     can't propagate.
+
+import { PREVIEW_TOKEN_COOKIE, PREVIEW_MARKER_COOKIE, PREVIEW_ENDPOINT, DEFAULT_PREVIEW_TTL_MS, PREVIEW_MARKER_GRACE_MS } from './constants.js';
+export { PREVIEW_TOKEN_COOKIE, PREVIEW_MARKER_COOKIE, PREVIEW_ENDPOINT, DEFAULT_PREVIEW_TTL_MS, PREVIEW_MARKER_GRACE_MS };
+function serializeCookie(name, value, opts) {
+  const sameSite = opts.sameSite === 'strict' ? 'Strict' : opts.sameSite === 'none' ? 'None' : 'Lax';
+  const parts = [`${name}=${encodeURIComponent(value)}`, `Path=${opts.path ?? '/'}`, `SameSite=${sameSite}`];
+  if (opts.httpOnly) parts.push('HttpOnly');
+  if (opts.secure) parts.push('Secure');
+  if (opts.maxAge != null) parts.push(`Max-Age=${opts.maxAge}`);
+  return parts.join('; ');
+}
+
+// Coerce an `expiresAt` from the POST body — an ISO-8601 string, an epoch-ms
+// number, or a numeric string — into epoch-ms. Falls back to
+// now + DEFAULT_PREVIEW_TTL_MS when absent or unparseable, since the canonical
+// 1h TTL lives in the backend token and the field may not be present yet (the
+// backend half ships separately). Never throws.
+function resolveExpiresAt(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string' && value !== '') {
+    const asNumber = Number(value);
+    if (Number.isFinite(asNumber)) return asNumber;
+    const asDate = Date.parse(value);
+    if (!Number.isNaN(asDate)) return asDate;
+  }
+  return Date.now() + DEFAULT_PREVIEW_TTL_MS;
+}
+function isSecureRequest(request) {
+  try {
+    return new URL(request.url).protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+function jsonResponse(body, status) {
+  let setCookies = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  const headers = new Headers({
+    'content-type': 'application/json'
+  });
+  for (const cookie of setCookies) headers.append('Set-Cookie', cookie);
+  return new Response(JSON.stringify(body), {
+    status,
+    headers
+  });
+}
+
+/**
+ * Web-standard route handler implementing the portable preview contract. Wire
+ * it into your framework's route at the path the toolbar targets
+ * (`/api/preview` by default):
+ *
+ *   // Astro: src/pages/api/preview.ts
+ *   import { handlePreviewRequest } from 'fontdue-js/preview';
+ *   export const ALL: APIRoute = ({ request }) => handlePreviewRequest(request);
+ *
+ *   // React Router 7: app/routes/api.preview.ts
+ *   import { handlePreviewRequest } from 'fontdue-js/preview';
+ *   export const action = ({ request }: Route.ActionArgs) =>
+ *     handlePreviewRequest(request);
+ *
+ * POST expects a JSON body `{ token: string, expiresAt?: string | number }`;
+ * DELETE takes no body. `expiresAt` (ISO-8601 or epoch-ms) is the token's
+ * expiry; it's stored in the readable marker cookie so the toolbar can warn
+ * when preview has lapsed, and defaults to now + DEFAULT_PREVIEW_TTL_MS when
+ * omitted. The token is opaque here — the Fontdue GraphQL server validates it
+ * on each request, so a forged token simply reveals nothing. Frameworks that
+ * cache HTML should also bypass their shared/CDN cache when
+ * PREVIEW_MARKER_COOKIE is present, so an admin preview is never served to the
+ * public.
+ */
+export async function handlePreviewRequest(request) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const base = {
+    secure: options.secure ?? isSecureRequest(request),
+    sameSite: options.sameSite ?? 'lax',
+    path: options.path ?? '/'
+  };
+  if (request.method === 'DELETE') {
+    return jsonResponse({
+      ok: true,
+      preview: false
+    }, 200, [serializeCookie(PREVIEW_TOKEN_COOKIE, '', {
+      ...base,
+      httpOnly: true,
+      maxAge: 0
+    }), serializeCookie(PREVIEW_MARKER_COOKIE, '', {
+      ...base,
+      httpOnly: false,
+      maxAge: 0
+    })]);
+  }
+  if (request.method === 'POST') {
+    const body = await request.json().catch(() => ({}));
+    const token = body.token;
+    if (typeof token !== 'string' || token === '') {
+      return jsonResponse({
+        ok: false,
+        error: 'Missing preview token'
+      }, 400);
+    }
+    const expiresAt = resolveExpiresAt(body.expiresAt);
+    // Marker outlives the token by a grace window so the toolbar can reach the
+    // "expired" warning state instead of the cookie silently vanishing.
+    const markerMaxAge = Math.max(0, Math.ceil((expiresAt - Date.now() + PREVIEW_MARKER_GRACE_MS) / 1000));
+    return jsonResponse({
+      ok: true,
+      preview: true,
+      expiresAt
+    }, 200, [serializeCookie(PREVIEW_TOKEN_COOKIE, token, {
+      ...base,
+      httpOnly: true
+    }), serializeCookie(PREVIEW_MARKER_COOKIE, String(expiresAt), {
+      ...base,
+      httpOnly: false,
+      maxAge: markerMaxAge
+    })]);
+  }
+  return jsonResponse({
+    ok: false,
+    error: 'Method not allowed'
+  }, 405);
+}
+
+/**
+ * Extract the preview token from a Cookie header string, e.g.
+ * `readPreviewToken(request.headers.get('cookie'))`. This is the canonical
+ * reader — it reverses the encoding `handlePreviewRequest` applies, so the
+ * token comes back verbatim. Returns undefined when not in preview.
+ */
+export function readPreviewToken(cookieHeader) {
+  if (!cookieHeader) return undefined;
+  for (const part of cookieHeader.split(';')) {
+    const idx = part.indexOf('=');
+    if (idx === -1) continue;
+    if (part.slice(0, idx).trim() !== PREVIEW_TOKEN_COOKIE) continue;
+    const value = part.slice(idx + 1).trim();
+    return value === '' ? undefined : decodeURIComponent(value);
+  }
+  return undefined;
+}
+
+/**
+ * Headers to merge into a server-side GraphQL fetch so the request reveals
+ * hidden fonts. Spread the result into your app's fetch headers, into
+ * fontdue-js's per-render `serverConfig.headers`, or into the `headers` option
+ * of a preload helper (loadFontdueProviderQuery, loadTypeTesterQuery, …).
+ * Returns {} when there is no token, so it's safe to spread unconditionally.
+ */
+export function previewAuthHeaders(token) {
+  return token ? {
+    authorization: `Bearer ${token}`
+  } : {};
+}

package/dist/preview/server.d.ts

@@ -0,0 +1,20 @@
+/** Whether the current async context is an admin preview. */
+export declare function isPreviewing(): boolean;
+/**
+ * Preview auth headers for the current async context, or {} when not previewing.
+ * Spread into a hand-rolled fetch you make inside `runWithPreview`; the
+ * fontdue-js fetch/preload helpers pick these up automatically and don't need
+ * it.
+ */
+export declare function ambientPreviewHeaders(): Record<string, string>;
+/**
+ * Run `next` (your framework's render/loader chain) with the request's preview
+ * token in ambient context, then return its Response. When the request is
+ * previewing, the response's cache headers are rewritten so it is never stored
+ * in a shared/CDN cache. Public (no-token) requests pass through untouched and
+ * stay fully cacheable.
+ *
+ * `next` is your middleware's continuation — `next` in Astro, `next` in a React
+ * Router 7 middleware. It must return (a promise of) the Response.
+ */
+export declare function runWithPreview(request: Request, next: () => Response | Promise<Response>): Promise<Response>;

package/dist/preview/server.js

@@ -0,0 +1,89 @@
+// Ambient (request-scoped) preview for non-RSC server frameworks.
+//
+// fontdue-js/preview gives you the cookie contract and an explicit option:
+// read the token per request and thread `previewAuthHeaders(token)` into every
+// GraphQL fetch and preload helper. That's portable but easy to get wrong — miss
+// one preload and that island silently renders the public view.
+//
+// This module removes the threading. `runWithPreview` establishes an
+// AsyncLocalStorage context for the duration of a request; while it's active,
+// every fontdue-js server fetch (createFontdueFetch and all the preload helpers)
+// automatically forwards the admin preview token, with no per-call plumbing —
+// the same ergonomics RSC gets from React.cache, and the same mechanism Next's
+// own headers()/draftMode() use under the hood. Install it once in your
+// framework's middleware:
+//
+//   // Astro: src/middleware.ts
+//   export const onRequest = (ctx, next) => runWithPreview(ctx.request, next);
+//
+//   // React Router 7 (root route, with future.v8_middleware):
+//   export const middleware = [({ request }, next) => runWithPreview(request, next)];
+//
+// runWithPreview also binds the cache guarantee to the same call: when a request
+// is previewing, the response is forced out of any shared/CDN cache. Because the
+// context and the no-cache rule are set in one place, you can't be ambiently
+// previewing without the response being uncacheable — so an admin render is never
+// served to the public.
+//
+// Requirements & fallback: AsyncLocalStorage must propagate from the install
+// point into the render. That holds for in-process middleware — Node (Netlify
+// Functions, the default SSR target), Deno (Netlify Edge), Bun. It does NOT hold
+// when middleware runs in a separate runtime from the render (e.g. Astro with
+// `edgeMiddleware: true`, where locals cross the boundary as a serialized
+// header). In that case fall back to the explicit path: read the token in
+// middleware and thread `previewAuthHeaders(token)` via the `headers` option on
+// fetches/preloads. The explicit `headers` option always overrides the ambient
+// context, so the two compose.
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { readPreviewToken, previewAuthHeaders } from './index.js';
+import { registerAmbientConfigResolver } from '../relay/serverConfig.js';
+const previewStore = new AsyncLocalStorage();
+
+// Feed the ambient token into fontdue-js's server config resolution. Returns
+// undefined outside a preview context, so non-preview requests are untouched.
+registerAmbientConfigResolver(() => {
+  const store = previewStore.getStore();
+  return store ? {
+    headers: store.headers
+  } : undefined;
+});
+
+/** Whether the current async context is an admin preview. */
+export function isPreviewing() {
+  return previewStore.getStore() != null;
+}
+
+/**
+ * Preview auth headers for the current async context, or {} when not previewing.
+ * Spread into a hand-rolled fetch you make inside `runWithPreview`; the
+ * fontdue-js fetch/preload helpers pick these up automatically and don't need
+ * it.
+ */
+export function ambientPreviewHeaders() {
+  var _previewStore$getStor;
+  return ((_previewStore$getStor = previewStore.getStore()) === null || _previewStore$getStor === void 0 ? void 0 : _previewStore$getStor.headers) ?? {};
+}
+const NO_STORE = 'private, no-store';
+
+/**
+ * Run `next` (your framework's render/loader chain) with the request's preview
+ * token in ambient context, then return its Response. When the request is
+ * previewing, the response's cache headers are rewritten so it is never stored
+ * in a shared/CDN cache. Public (no-token) requests pass through untouched and
+ * stay fully cacheable.
+ *
+ * `next` is your middleware's continuation — `next` in Astro, `next` in a React
+ * Router 7 middleware. It must return (a promise of) the Response.
+ */
+export async function runWithPreview(request, next) {
+  const token = readPreviewToken(request.headers.get('cookie'));
+  if (!token) return next();
+  const response = await previewStore.run({
+    headers: previewAuthHeaders(token)
+  }, next);
+  response.headers.set('Cache-Control', NO_STORE);
+  response.headers.delete('Netlify-CDN-Cache-Control');
+  response.headers.delete('CDN-Cache-Control');
+  return response;
+}

package/dist/relay/environment.d.ts

@@ -1,9 +1,17 @@
 import { Environment, RequestParameters, QueryResponseCache, Variables, GraphQLResponse } from 'relay-runtime';
+export declare const version: string;
+export declare function fontdueBaseUrl(): string | undefined;
 export declare function createNetworkFetch(options?: CreateRelayEnvironmentOptions): (request: RequestParameters, variables: Variables) => Promise<GraphQLResponse>;
 export declare const networkFetch: (request: RequestParameters, variables: Variables) => Promise<GraphQLResponse>;
 export declare const responseCache: QueryResponseCache | null;
 interface CreateRelayEnvironmentOptions {
     url?: string;
+    /**
+     * Extra headers for this fetch (server-side). Used to forward a per-request
+     * preview `Authorization: Bearer <token>` in non-RSC frameworks, where the
+     * render-scoped serverConfig store is a no-op. See ../preview.
+     */
+    headers?: Record<string, string>;
     stripeIntegration?: 'card-element' | 'dynamic';
 }
 export declare function createEnvironment(options: CreateRelayEnvironmentOptions): Environment;

package/dist/relay/environment.js

@@ -1,12 +1,24 @@
 import { Environment, Network, RecordSource, Store, QueryResponseCache } from 'relay-runtime';
 import { handlePossibleCorsError } from '../corsError.js';
-import { getFontdueServerConfig } from './serverConfig.js';
+import { resolveFontdueServerConfig } from './serverConfig.js';
+import { PREVIEW_HEADER, hasPreviewMarkerCookie } from '../preview/constants.js';
 
 // `__FONTDUE_JS_VERSION__` is replaced by an inline babel plugin
 // (defineVersionPlugin in .babelrc.cjs) with the literal package.json#version.
-const version = "3.0.0-alpha9";
+// Exported so UI (the admin toolbar) can surface it without re-reading the
+// build-time global in a 'use client' module.
+export const version = "3.0.0";
 const IS_SERVER = typeof window === typeof undefined;
 
+// Opt server fetches into Next's data cache only in production; dev stays
+// uncached so storefront content is always fresh (see the init.cache note
+// below). Read per call (not memoized) so the literal `process.env.NODE_ENV` is
+// inlined at build time and tests can stub it; `typeof process` guards non-Node
+// bundles from throwing.
+function cacheInProduction() {
+  return typeof process !== 'undefined' && process.env.NODE_ENV === 'production';
+}
+
 // Read env from either process.env (Node/Next.js) or import.meta.env (Vite/Astro).
 // Prefer the framework-agnostic FONTDUE_URL name; fall back to NEXT_PUBLIC_FONTDUE_URL
 // for backwards compatibility with existing Next.js integrations.
@@ -36,48 +48,82 @@ const FONTDUE_URL = readEnv('FONTDUE_URL') ?? readEnv('NEXT_PUBLIC_FONTDUE_URL')
 const STRIPE_INTEGRATION = readEnv('FONTDUE_STRIPE_INTEGRATION') ?? readEnv('NEXT_PUBLIC_FONTDUE_STRIPE_INTEGRATION') ?? NEXT_PUBLIC_STRIPE;
 const CACHE_TTL = 10 * 1000; // 10 seconds, to resolve preloaded results
 
+// The configured Fontdue base URL resolved for the current runtime, or
+// undefined when it can't be determined (e.g. multi-tenant, where fetches go to
+// the page's own origin). The admin toolbar uses it to show where the admin is
+// signed in and to link back to the Fontdue admin.
+export function fontdueBaseUrl() {
+  return FONTDUE_URL || undefined;
+}
 export function createNetworkFetch(options) {
   return async function networkFetch(request, variables) {
-    // Per-render server config (set via setFontdueServerConfig or the
-    // FontdueProvider server entrypoint). Resolved per call, not per
-    // createNetworkFetch, because module-level fetchers outlive renders.
-    const serverConfig = IS_SERVER ? getFontdueServerConfig() : undefined;
+    // Per-render server config (the RSC slot set via setFontdueServerConfig /
+    // the FontdueProvider server entrypoint, the runWithPreview AsyncLocalStorage
+    // store, or the Next single-tenant ambient resolver). Awaited per call, not
+    // per createNetworkFetch, because module-level fetchers outlive renders — so
+    // an embedded component's own preload reveals hidden fonts in preview even
+    // on a page that never calls the app's GraphQL fetcher.
+    const serverConfig = IS_SERVER ? await resolveFontdueServerConfig() : undefined;
     const base = (options === null || options === void 0 ? void 0 : options.url) ?? (serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.url) ?? FONTDUE_URL;
     if (IS_SERVER && (base == null || base === '')) {
       throw new Error('fontdue-js: no Fontdue URL configured for server-side fetch. ' + 'Set FONTDUE_URL / PUBLIC_FONTDUE_URL / VITE_FONTDUE_URL in your environment, ' + 'pass `url` to loadSerializableQuery, or call setFontdueServerConfig ' + '(or render <FontdueProvider url=…>) earlier in the server render.');
     }
     const url = `${base ?? ''}/graphql`;
+    const headers = {
+      ...(serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.headers),
+      // Per-call headers (e.g. a preview Authorization: Bearer token passed to
+      // a preload helper) override the render-store headers.
+      ...(options === null || options === void 0 ? void 0 : options.headers),
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      'fontdue-stripe-integration': (options === null || options === void 0 ? void 0 : options.stripeIntegration) ?? STRIPE_INTEGRATION ?? 'dynamic',
+      'fontdue-client-version': version
+    };
+
+    // Whether this request is an admin *preview*. On the server that's a
+    // forwarded admin token; in the browser it's the readable preview marker
+    // cookie — NOT a bare admin session cookie that happens to ride the fetch
+    // (that conflation was the leak: a logged-in admin browsing normally would
+    // see hidden fonts). It's sent explicitly as the `fontdue-preview` header so
+    // the GraphQL server reveals hidden (unpublished) fonts only in preview:
+    // "false" forces the public view even for a logged-in admin, and an absent
+    // header (older clients) keeps the legacy "any admin sees hidden" behavior.
+    const previewing = IS_SERVER ? headers.authorization != null || headers.Authorization != null : hasPreviewMarkerCookie();
+    headers[PREVIEW_HEADER] = previewing ? 'true' : 'false';
+
+    // Public server fetches are all site content (per-session data is fetched
+    // client-side only), so opt them into Next's data cache — without this,
+    // Next 15 treats them as no-store and silently makes every page fully
+    // dynamic. The tags let the revalidate handler purge them. A preview render,
+    // though, carries an admin Authorization token: those fetches must stay live
+    // and never be written to or served from the shared data cache (a public
+    // request could otherwise be handed the hidden-fonts response), so opt them
+    // out with no-store. Both hints are inert outside Next.
+    //
+    // In local dev (`next dev`) we also skip the cache: the data cache plus
+    // on-demand `revalidateTag` don't reliably refresh, and the storefront proxy
+    // strips the browser's `no-cache`, so a stale entry can't be busted — leave
+    // dev fetches uncached so every render is fresh. See CACHE_IN_PRODUCTION.
+    const init = {
+      method: 'POST',
+      credentials: 'include',
+      headers,
+      body: JSON.stringify({
+        query: request.text,
+        variables
+      })
+    };
+    if (IS_SERVER && (previewing || !cacheInProduction())) {
+      init.cache = 'no-store';
+    } else if (IS_SERVER) {
+      init.cache = 'force-cache';
+      init.next = {
+        tags: ['graphql', ...((serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.cacheTags) ?? []), `operation:${request.name}`]
+      };
+    }
     for (let attempt = 0; attempt <= 2; attempt++) {
       try {
-        const resp = await fetch(url + `?queryName=${request.name}`, {
-          method: 'POST',
-          credentials: 'include',
-          headers: {
-            ...(serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.headers),
-            Accept: 'application/json',
-            'Content-Type': 'application/json',
-            'fontdue-stripe-integration': (options === null || options === void 0 ? void 0 : options.stripeIntegration) ?? STRIPE_INTEGRATION ?? 'dynamic',
-            'fontdue-client-version': version
-          },
-          body: JSON.stringify({
-            query: request.text,
-            variables
-          }),
-          // Server-side fetches are all site content (per-session data is
-          // fetched client-side only), so opt them into Next's data cache —
-          // without this, Next 15 treats them as no-store and silently makes
-          // every page fully dynamic. The tags below let the revalidate
-          // handler purge them when content changes. Inert outside Next:
-          // Node's fetch accepts and ignores this cache mode, and the
-          // browser path doesn't set it.
-          ...(IS_SERVER ? {
-            cache: 'force-cache'
-          } : {}),
-          // @ts-ignore
-          next: {
-            tags: ['graphql', ...((serverConfig === null || serverConfig === void 0 ? void 0 : serverConfig.cacheTags) ?? []), `operation:${request.name}`]
-          }
-        });
+        const resp = await fetch(url + `?queryName=${request.name}`, init);
         const json = await resp.json();
 
         // GraphQL returns exceptions (for example, a missing required variable) in the "errors"

package/dist/relay/loadSerializableQuery.d.ts

@@ -4,6 +4,18 @@ export interface SerializablePreloadedQuery<TQuery extends OperationType> {
     variables: VariablesOf<TQuery>;
     response: GraphQLResponse;
 }
+/** Per-call options shared by every preload helper. */
+export interface LoadQueryOptions {
+    /** Override the GraphQL base URL for this fetch. */
+    url?: string;
+    /**
+     * Extra headers for this server-side fetch. Pass
+     * `previewAuthHeaders(token)` (from fontdue-js/preview) to reveal hidden
+     * fonts in preview when the render-scoped serverConfig store can't carry the
+     * token (Astro frontmatter, RR7 loaders — anything that isn't an RSC render).
+     */
+    headers?: Record<string, string>;
+}
 /**
  * RELAY CACHE KEY NORMALIZATION
  *
@@ -43,7 +55,5 @@ export interface SerializablePreloadedQuery<TQuery extends OperationType> {
 type RequireAllWithNull<T> = {
     [K in keyof T]-?: T[K] | null;
 };
-export default function loadSerializableQuery<TQuery extends OperationType>(query: GraphQLTaggedNode, variables: RequireAllWithNull<VariablesOf<TQuery>>, options?: {
-    url?: string;
-}): Promise<SerializablePreloadedQuery<TQuery>>;
+export default function loadSerializableQuery<TQuery extends OperationType>(query: GraphQLTaggedNode, variables: RequireAllWithNull<VariablesOf<TQuery>>, options?: LoadQueryOptions): Promise<SerializablePreloadedQuery<TQuery>>;
 export {};

package/dist/relay/loadSerializableQuery.js

@@ -1,5 +1,7 @@
 import { createNetworkFetch } from './environment.js';
 
+/** Per-call options shared by every preload helper. */
+
 /**
  * RELAY CACHE KEY NORMALIZATION
  *

package/dist/relay/serverConfig.d.ts

@@ -5,12 +5,10 @@ export interface FontdueServerConfig {
     headers?: Record<string, string>;
     /** Extra Next.js fetch cache tags applied to every server-side GraphQL fetch. */
     cacheTags?: string[];
-    /**
-     * The site domain this render is for, when known. Set by
-     * fontdue-js/next's prepareFontdueRender so render-scoped helpers
-     * (currentFontdueEndpoint) can recover it.
-     */
-    domain?: string;
 }
+type MaybePromise<T> = T | Promise<T>;
+type AmbientConfigResolver = () => MaybePromise<FontdueServerConfig | undefined>;
 export declare function setFontdueServerConfig(config: FontdueServerConfig): void;
-export declare function getFontdueServerConfig(): FontdueServerConfig | undefined;
+export declare function registerAmbientConfigResolver(resolver: AmbientConfigResolver): void;
+export declare function resolveFontdueServerConfig(): Promise<FontdueServerConfig | undefined>;
+export {};