fontdue-js 3.0.0-alpha6 → 3.0.0-alpha8

package/dist/__generated__/orderTrackingUpdateOrderTrackingMutation.graphql.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @generated SignedSource<<017a8a724b3a0fd0918153ce04d07f68>>
+ * @lightSyntaxTransform
+ * @nogrep
+ */
+import { ConcreteRequest } from 'relay-runtime';
+export type UpdateOrderTrackingInput = {
+    analyticsConsent?: boolean | null;
+    anonymousId?: string | null;
+    fbc?: string | null;
+    fbp?: string | null;
+    url?: string | null;
+};
+export type orderTrackingUpdateOrderTrackingMutation$variables = {
+    input: UpdateOrderTrackingInput;
+};
+export type orderTrackingUpdateOrderTrackingMutation$data = {
+    readonly updateOrderTracking: {
+        readonly success: boolean | null;
+    } | null;
+};
+export type orderTrackingUpdateOrderTrackingMutation = {
+    response: orderTrackingUpdateOrderTrackingMutation$data;
+    variables: orderTrackingUpdateOrderTrackingMutation$variables;
+};
+declare const node: ConcreteRequest;
+export default node;

package/dist/__generated__/orderTrackingUpdateOrderTrackingMutation.graphql.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * @generated SignedSource<<017a8a724b3a0fd0918153ce04d07f68>>
+ * @lightSyntaxTransform
+ * @nogrep
+ */
+
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+
+const node = function () {
+  var v0 = [{
+      "defaultValue": null,
+      "kind": "LocalArgument",
+      "name": "input"
+    }],
+    v1 = [{
+      "alias": null,
+      "args": [{
+        "kind": "Variable",
+        "name": "input",
+        "variableName": "input"
+      }],
+      "concreteType": "UpdateOrderTrackingPayload",
+      "kind": "LinkedField",
+      "name": "updateOrderTracking",
+      "plural": false,
+      "selections": [{
+        "alias": null,
+        "args": null,
+        "kind": "ScalarField",
+        "name": "success",
+        "storageKey": null
+      }],
+      "storageKey": null
+    }];
+  return {
+    "fragment": {
+      "argumentDefinitions": v0 /*: any*/,
+      "kind": "Fragment",
+      "metadata": null,
+      "name": "orderTrackingUpdateOrderTrackingMutation",
+      "selections": v1 /*: any*/,
+      "type": "RootMutationType",
+      "abstractKey": null
+    },
+    "kind": "Request",
+    "operation": {
+      "argumentDefinitions": v0 /*: any*/,
+      "kind": "Operation",
+      "name": "orderTrackingUpdateOrderTrackingMutation",
+      "selections": v1 /*: any*/
+    },
+    "params": {
+      "cacheID": "c6d6059215c6ed30315c881dff80e9a7",
+      "id": null,
+      "metadata": {},
+      "name": "orderTrackingUpdateOrderTrackingMutation",
+      "operationKind": "mutation",
+      "text": "mutation orderTrackingUpdateOrderTrackingMutation(\n  $input: UpdateOrderTrackingInput!\n) {\n  updateOrderTracking(input: $input) {\n    success\n  }\n}\n"
+    }
+  };
+}();
+node.hash = "d59a127a7f140424f507ae549731bac7";
+var _default = node;
+exports.default = _default;

package/dist/__tests__/nextAdapter.test.js

@@ -0,0 +1,307 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+// The next adapter modules read process.env at module load, so each test
+// group stubs the env and re-imports them fresh.
+async function importTenant() {
+  return await import("../next/tenant.js");
+}
+async function importConfig() {
+  return await import("../next/config.js");
+}
+async function importRevalidate() {
+  return await import("../next/revalidate.js");
+}
+const revalidateTag = vi.fn();
+vi.mock('next/cache', () => ({
+  revalidateTag: tag => revalidateTag(tag)
+}));
+beforeEach(() => {
+  vi.resetModules();
+  revalidateTag.mockClear();
+  vi.unstubAllEnvs();
+});
+function stubSingleTenant() {
+  let url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'https://acme.fontdue.com';
+  vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', url);
+  vi.stubEnv('FONTDUE_MULTI_TENANT', '');
+  vi.stubEnv('FONTDUE_ORIGIN', '');
+  vi.stubEnv('FONTDUE_PROXY_SECRET', '');
+}
+function stubMultiTenant() {
+  let {
+    origin = '',
+    secret = ''
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
+  vi.stubEnv('FONTDUE_MULTI_TENANT', '1');
+  vi.stubEnv('FONTDUE_ORIGIN', origin);
+  vi.stubEnv('FONTDUE_PROXY_SECRET', secret);
+}
+describe('isValidDomain', () => {
+  it('accepts plain dotted hostnames and rejects everything else', async () => {
+    stubMultiTenant();
+    const {
+      isValidDomain
+    } = await importTenant();
+    expect(isValidDomain('acme.fontdue.com')).toBe(true);
+    expect(isValidDomain('a-b.example')).toBe(true);
+    expect(isValidDomain('localhost')).toBe(false); // no dot
+    expect(isValidDomain('acme.fontdue.com:3000')).toBe(false); // port
+    expect(isValidDomain('acme.fontdue.com/x')).toBe(false); // path
+    expect(isValidDomain('-bad.example')).toBe(false);
+    expect(isValidDomain('a'.repeat(254) + '.example')).toBe(false);
+  });
+});
+describe('fontdueEndpoint', () => {
+  it('single-tenant: targets NEXT_PUBLIC_FONTDUE_URL with no headers', async () => {
+    stubSingleTenant('https://acme.fontdue.com');
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(fontdueEndpoint('acme.fontdue.com')).toEqual({
+      origin: 'https://acme.fontdue.com',
+      headers: {},
+      tags: ['graphql', 'graphql:acme.fontdue.com']
+    });
+  });
+  it('single-tenant: throws when NEXT_PUBLIC_FONTDUE_URL is missing', async () => {
+    vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
+    vi.stubEnv('FONTDUE_MULTI_TENANT', '');
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(() => fontdueEndpoint('acme.fontdue.com')).toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
+  });
+  it('multi-tenant: forwards the host to FONTDUE_ORIGIN with the proxy secret', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000',
+      secret: 's3cret'
+    });
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(fontdueEndpoint('acme.fontdue.com')).toEqual({
+      origin: 'http://app:4000',
+      headers: {
+        'x-forwarded-host': 'acme.fontdue.com',
+        'x-fontdue-proxy-secret': 's3cret'
+      },
+      tags: ['graphql', 'graphql:acme.fontdue.com']
+    });
+  });
+  it('multi-tenant: omits the secret header when unset', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(fontdueEndpoint('acme.fontdue.com').headers).toEqual({
+      'x-forwarded-host': 'acme.fontdue.com'
+    });
+  });
+  it('multi-tenant: falls back to the tenant public URL without FONTDUE_ORIGIN', async () => {
+    stubMultiTenant();
+    const {
+      fontdueEndpoint
+    } = await importTenant();
+    expect(fontdueEndpoint('acme.fontdue.com').origin).toBe('https://acme.fontdue.com');
+  });
+});
+describe('configureFontdueRender', () => {
+  it('rejects invalid domains with null and sets no config', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const {
+      configureFontdueRender
+    } = await importTenant();
+    const {
+      getFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    expect(configureFontdueRender('not a domain')).toBeNull();
+    expect(getFontdueServerConfig()).toBeUndefined();
+  });
+  it('sets the per-render server config and returns the endpoint', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000',
+      secret: 's3cret'
+    });
+    const {
+      configureFontdueRender
+    } = await importTenant();
+    const {
+      getFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    const endpoint = configureFontdueRender('acme.fontdue.com');
+    expect(endpoint === null || endpoint === void 0 ? void 0 : endpoint.origin).toBe('http://app:4000');
+    // Outside an RSC render React.cache doesn't memoize, so the write is a
+    // no-op here — but the config passed must still be shaped correctly, so
+    // assert via fontdueServerConfig instead.
+    const {
+      fontdueServerConfig
+    } = await importTenant();
+    expect(fontdueServerConfig('acme.fontdue.com')).toEqual({
+      url: 'http://app:4000',
+      headers: {
+        'x-forwarded-host': 'acme.fontdue.com',
+        'x-fontdue-proxy-secret': 's3cret'
+      },
+      cacheTags: ['graphql:acme.fontdue.com']
+    });
+  });
+});
+describe('withFontdue', () => {
+  it('throws when neither mode is configured', async () => {
+    vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
+    vi.stubEnv('FONTDUE_MULTI_TENANT', '');
+    const {
+      withFontdue
+    } = await importConfig();
+    expect(() => withFontdue({})).toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
+  });
+  it('single-tenant: rewrites every path under the constant domain', async () => {
+    stubSingleTenant('https://acme.fontdue.com');
+    const {
+      withFontdue
+    } = await importConfig();
+    const rewrites = await withFontdue({}).rewrites();
+    expect(rewrites.afterFiles).toEqual([]);
+    expect(rewrites.fallback).toEqual([]);
+    const destinations = rewrites.beforeFiles.map(r => r.destination);
+    expect(destinations).toEqual(['/acme.fontdue.com', '/acme.fontdue.com/robots.txt', '/acme.fontdue.com/sitemap.xml', '/acme.fontdue.com/:path']);
+  });
+  it('multi-tenant: emits forwarded-host rules before host rules, mutually exclusive', async () => {
+    stubMultiTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const rewrites = await withFontdue({}).rewrites();
+    expect(rewrites.beforeFiles).toHaveLength(8);
+    const [forwarded, hostBased] = [rewrites.beforeFiles.slice(0, 4), rewrites.beforeFiles.slice(4)];
+    for (const rule of forwarded) {
+      var _rule$has;
+      expect((_rule$has = rule.has) === null || _rule$has === void 0 ? void 0 : _rule$has[0]).toMatchObject({
+        type: 'header',
+        key: 'x-forwarded-host'
+      });
+      expect(rule.missing).toBeUndefined();
+    }
+    for (const rule of hostBased) {
+      var _rule$has2, _rule$missing;
+      expect((_rule$has2 = rule.has) === null || _rule$has2 === void 0 ? void 0 : _rule$has2[0]).toMatchObject({
+        type: 'host'
+      });
+      expect((_rule$missing = rule.missing) === null || _rule$missing === void 0 ? void 0 : _rule$missing[0]).toMatchObject({
+        type: 'header',
+        key: 'x-forwarded-host'
+      });
+    }
+  });
+  it("chains the app's beforeFiles rules ahead of the tenant rules", async () => {
+    stubSingleTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const userRule = {
+      source: '/old',
+      destination: '/new'
+    };
+    const config = withFontdue({
+      rewrites: async () => ({
+        beforeFiles: [userRule]
+      })
+    });
+    const rewrites = await config.rewrites();
+    expect(rewrites.beforeFiles[0]).toEqual(userRule);
+    expect(rewrites.beforeFiles).toHaveLength(5);
+  });
+  it("treats a plain-array rewrites() result as afterFiles, per Next's contract", async () => {
+    stubSingleTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const userRule = {
+      source: '/old',
+      destination: '/new'
+    };
+    const rewrites = await withFontdue({
+      rewrites: async () => [userRule]
+    }).rewrites();
+    expect(rewrites.afterFiles).toEqual([userRule]);
+    expect(rewrites.beforeFiles).toHaveLength(4);
+  });
+  it('merges image settings, keeping app remotePatterns and overrides', async () => {
+    stubMultiTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const config = withFontdue({
+      images: {
+        dangerouslyAllowSVG: false,
+        remotePatterns: [{
+          protocol: 'https',
+          hostname: 'cdn.example'
+        }]
+      }
+    });
+    expect(config.images.dangerouslyAllowSVG).toBe(false);
+    // NODE_ENV is 'test' here, i.e. not production → dev workaround active.
+    expect(config.images.unoptimized).toBe(true);
+    const hostnames = config.images.remotePatterns.map(p => p.hostname);
+    expect(hostnames).toContain('cdn.example');
+    expect(hostnames).toContain('*.fontdue.com');
+    expect(hostnames).toContain('**');
+  });
+  it('passes unrelated config through and defaults htmlLimitedBots', async () => {
+    stubSingleTenant();
+    const {
+      withFontdue
+    } = await importConfig();
+    const config = withFontdue({
+      reactStrictMode: true
+    });
+    expect(config.reactStrictMode).toBe(true);
+    expect(config.htmlLimitedBots).toEqual(/.*/);
+    expect(withFontdue({
+      htmlLimitedBots: /Googlebot/
+    }).htmlLimitedBots).toEqual(/Googlebot/);
+  });
+});
+describe('revalidate POST', () => {
+  it('multi-tenant: purges only the tenant tag', async () => {
+    stubMultiTenant();
+    const {
+      POST
+    } = await importRevalidate();
+    const response = await POST(new Request('http://internal/api/revalidate?domain=Acme.Fontdue.com', {
+      method: 'POST'
+    }));
+    expect(response.status).toBe(200);
+    expect(revalidateTag).toHaveBeenCalledExactlyOnceWith('graphql:acme.fontdue.com');
+  });
+  it('multi-tenant: 400s on a missing or invalid domain', async () => {
+    stubMultiTenant();
+    const {
+      POST
+    } = await importRevalidate();
+    for (const url of ['http://internal/api/revalidate', 'http://internal/api/revalidate?domain=not%20a%20domain']) {
+      const response = await POST(new Request(url, {
+        method: 'POST'
+      }));
+      expect(response.status).toBe(400);
+    }
+    expect(revalidateTag).not.toHaveBeenCalled();
+  });
+  it('single-tenant: purges the global graphql tag', async () => {
+    stubSingleTenant();
+    const {
+      POST
+    } = await importRevalidate();
+    const response = await POST(new Request('http://internal/api/revalidate', {
+      method: 'POST'
+    }));
+    expect(response.status).toBe(200);
+    expect(revalidateTag).toHaveBeenCalledExactlyOnceWith('graphql');
+  });
+});

package/dist/components/BuyButton/index.js

@@ -85,7 +85,10 @@ export function BuyButtonPreloadedIDQueryRenderer(_ref3) {
     preloadedQuery,
     ...rest
   } = _ref3;
-  const queryRef = useSerializablePreloadedQuery(preloadedQuery);
+  // The query node lets the hook commit the payload into the store, so
+  // usePreloadedQuery resolves synchronously during SSR instead of
+  // refetching (the response cache only exists in the browser).
+  const queryRef = useSerializablePreloadedQuery(preloadedQuery, 'store-or-network', idQuery);
   const data = usePreloadedQuery(idQuery, queryRef);
   return /*#__PURE__*/React.createElement(BuyButtonComponent, _extends({}, rest, data));
 }
@@ -108,7 +111,10 @@ export function BuyButtonPreloadedSlugQueryRenderer(_ref5) {
     preloadedQuery,
     ...rest
   } = _ref5;
-  const queryRef = useSerializablePreloadedQuery(preloadedQuery);
+  // The query node lets the hook commit the payload into the store, so
+  // usePreloadedQuery resolves synchronously during SSR instead of
+  // refetching (the response cache only exists in the browser).
+  const queryRef = useSerializablePreloadedQuery(preloadedQuery, 'store-or-network', slugQuery);
   const data = usePreloadedQuery(slugQuery, queryRef);
   return /*#__PURE__*/React.createElement(BuyButtonComponent, _extends({}, rest, {
     collection: ((_data$viewer2 = data.viewer) === null || _data$viewer2 === void 0 ? void 0 : (_data$viewer2$slug = _data$viewer2.slug) === null || _data$viewer2$slug === void 0 ? void 0 : _data$viewer2$slug.collection) ?? null

package/dist/components/Cart/orderTracking.d.ts

@@ -0,0 +1,10 @@
+import { Environment } from 'relay-runtime';
+/**
+ * Stores the buyer's analytics context (cookie consent, Meta browser IDs,
+ * checkout page URL) on the current order. The server emits the purchase
+ * event from a Stripe webhook — outside the browser — so this is how that
+ * event respects the consent banner and carries attribution.
+ *
+ * Fire-and-forget: tracking must never break checkout.
+ */
+export declare function sendOrderTracking(environment: Environment): void;

package/dist/components/Cart/orderTracking.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sendOrderTracking = sendOrderTracking;
+var _orderTrackingUpdateOrderTrackingMutation2 = _interopRequireDefault(require("../../__generated__/orderTrackingUpdateOrderTrackingMutation.graphql"));
+var _reactRelay = require("react-relay");
+var _consent = require("../ConsentBanner/consent");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function readCookie(name) {
+  const match = document.cookie.match(new RegExp('(?:^|;\\s*)' + name + '=([^;]*)'));
+  return match ? decodeURIComponent(match[1]) : undefined;
+}
+
+/**
+ * Stores the buyer's analytics context (cookie consent, Meta browser IDs,
+ * checkout page URL) on the current order. The server emits the purchase
+ * event from a Stripe webhook — outside the browser — so this is how that
+ * event respects the consent banner and carries attribution.
+ *
+ * Fire-and-forget: tracking must never break checkout.
+ */
+function sendOrderTracking(environment) {
+  try {
+    (0, _reactRelay.commitMutation)(environment, {
+      mutation: (_orderTrackingUpdateOrderTrackingMutation2.default.hash && _orderTrackingUpdateOrderTrackingMutation2.default.hash !== "d59a127a7f140424f507ae549731bac7" && console.error("The definition of 'orderTrackingUpdateOrderTrackingMutation' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _orderTrackingUpdateOrderTrackingMutation2.default),
+      variables: {
+        input: {
+          analyticsConsent: (0, _consent.hasConsent)('analytics'),
+          anonymousId: (0, _consent.getClientAnonymousId)(),
+          fbp: readCookie('_fbp'),
+          fbc: readCookie('_fbc'),
+          url: window.location.href
+        }
+      },
+      onCompleted: () => undefined,
+      onError: () => undefined
+    });
+  } catch {
+    // Ignore — see above.
+  }
+}

package/dist/components/CartButton/index.js

@@ -3,7 +3,7 @@
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
 import _CartButtonQuery from "../../__generated__/CartButtonQuery.graphql.js";
 import _CartButton_order from "../../__generated__/CartButton_order.graphql.js";
-import React, { useEffect, useCallback, useContext, useState } from 'react';
+import React, { Suspense, useEffect, useCallback, useContext, useState } from 'react';
 import { useDispatch } from 'react-redux';
 import { graphql, useFragment, useLazyLoadQuery } from 'react-relay';
 import ComponentsContext from '../ComponentsContext.js';
@@ -101,14 +101,26 @@ function CartButtonLazyQueryRenderer(props) {
 }
 // Cart contents are per-customer-session, so a server-side preload from a
 // CDN-cached SSG/prerender environment (no session cookies) just caches an
-// empty cart and delays the real one. CartButton always lazy-fetches on
-// hydration — same pattern as StoreModal.
+// empty cart and delays the real one. CartButton lazy-fetches on hydration —
+// and only after mount: useLazyLoadQuery would otherwise also run during the
+// SSR pass, where the fetch is sessionless (and in multi-tenant setups may
+// have no resolvable GraphQL URL at all). Until mount it renders the empty
+// cart state, which is also the Suspense fallback while the real fetch runs,
+// so server HTML and first client render agree.
 export default function CartButton(_ref2) {
   let {
     config,
     ...props
   } = _ref2;
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => setMounted(true), []);
   return /*#__PURE__*/React.createElement(EnsureFontdueContext, {
     config: config
-  }, /*#__PURE__*/React.createElement(CartButtonLazyQueryRenderer, props));
+  }, mounted ? /*#__PURE__*/React.createElement(Suspense, {
+    fallback: /*#__PURE__*/React.createElement(CartButtonComponent, _extends({}, props, {
+      order: null
+    }))
+  }, /*#__PURE__*/React.createElement(CartButtonLazyQueryRenderer, props)) : /*#__PURE__*/React.createElement(CartButtonComponent, _extends({}, props, {
+    order: null
+  })));
 }

package/dist/components/CharacterViewer/index.js

@@ -446,7 +446,10 @@ export function CharacterViewerPreloadedIDQueryRenderer(_ref8) {
     preloadedQuery,
     ...rest
   } = _ref8;
-  const queryRef = useSerializablePreloadedQuery(preloadedQuery);
+  // The query node lets the hook commit the payload into the store, so
+  // usePreloadedQuery resolves synchronously during SSR instead of
+  // refetching (the response cache only exists in the browser).
+  const queryRef = useSerializablePreloadedQuery(preloadedQuery, 'store-or-network', idQuery);
   const data = usePreloadedQuery(idQuery, queryRef);
   if (!data.node) return null;
   return /*#__PURE__*/React.createElement(CharacterViewerComponent, _extends({}, rest, {
@@ -473,7 +476,10 @@ export function CharacterViewerPreloadedSlugQueryRenderer(_ref10) {
     preloadedQuery,
     ...rest
   } = _ref10;
-  const queryRef = useSerializablePreloadedQuery(preloadedQuery);
+  // The query node lets the hook commit the payload into the store, so
+  // usePreloadedQuery resolves synchronously during SSR instead of
+  // refetching (the response cache only exists in the browser).
+  const queryRef = useSerializablePreloadedQuery(preloadedQuery, 'store-or-network', slugQuery);
   const data = usePreloadedQuery(slugQuery, queryRef);
   const collection = data === null || data === void 0 ? void 0 : (_data$viewer2 = data.viewer) === null || _data$viewer2 === void 0 ? void 0 : (_data$viewer2$slug = _data$viewer2.slug) === null || _data$viewer2$slug === void 0 ? void 0 : _data$viewer2$slug.fontCollection;
   if (!collection) return null;

package/dist/components/CustomerLoginForm/index.js

@@ -9,7 +9,6 @@ const loginMutation = (_CustomerLoginFormLoginMutation.hash && _CustomerLoginFor
 const query = (_CustomerLoginFormQuery.hash && _CustomerLoginFormQuery.hash !== "f32c7b0b485a2b2a02ddf2cbc5b87a3c" && console.error("The definition of 'CustomerLoginFormQuery' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _CustomerLoginFormQuery);
 const DEFAULT_SUBMITTED_LABEL = '<p>Submitted!</p><p>Please check your email inbox for a link to log in.</p><p>If you don\u2019t receive an email, please contact us to retrieve your order information.</p>';
 const CustomerLoginForm = _ref => {
-  var _data$viewer, _data$viewer$settings;
   let {
     submitLabel = 'Submit'
   } = _ref;
@@ -18,8 +17,6 @@ const CustomerLoginForm = _ref => {
   const [submitting, setSubmitting] = useState(false);
   const [submitted, setSubmitted] = useState(false);
   const environment = useRelayEnvironment();
-  const data = useLazyLoadQuery(query, {});
-  const submittedLabel = ((_data$viewer = data.viewer) === null || _data$viewer === void 0 ? void 0 : (_data$viewer$settings = _data$viewer.settings) === null || _data$viewer$settings === void 0 ? void 0 : _data$viewer$settings.customerLoginSubmittedLabel) || DEFAULT_SUBMITTED_LABEL;
   const handleSubmit = e => {
     e.preventDefault();
     setSubmitting(true);
@@ -54,12 +51,7 @@ const CustomerLoginForm = _ref => {
     className: "login-form"
   }, error && /*#__PURE__*/React.createElement("div", {
     className: "login-form__errors"
-  }, error), submitted ? /*#__PURE__*/React.createElement("div", {
-    className: "login-form__submitted",
-    dangerouslySetInnerHTML: {
-      __html: submittedLabel
-    }
-  }) : /*#__PURE__*/React.createElement("form", {
+  }, error), submitted ? /*#__PURE__*/React.createElement(SubmittedMessage, null) : /*#__PURE__*/React.createElement("form", {
     className: "login-form__form",
     onSubmit: handleSubmit
   }, /*#__PURE__*/React.createElement("div", {
@@ -79,4 +71,20 @@ const CustomerLoginForm = _ref => {
     className: "submit-button__arrow"
   }, " \u2192")))));
 };
+
+// The settings label is only shown after a submit, which can only happen in
+// the browser — fetching it here (not in the form component) keeps the lazy
+// query out of the SSR pass, where it has no session and, in multi-tenant
+// setups, possibly no resolvable GraphQL URL.
+function SubmittedMessage() {
+  var _data$viewer, _data$viewer$settings;
+  const data = useLazyLoadQuery(query, {});
+  const submittedLabel = ((_data$viewer = data.viewer) === null || _data$viewer === void 0 ? void 0 : (_data$viewer$settings = _data$viewer.settings) === null || _data$viewer$settings === void 0 ? void 0 : _data$viewer$settings.customerLoginSubmittedLabel) || DEFAULT_SUBMITTED_LABEL;
+  return /*#__PURE__*/React.createElement("div", {
+    className: "login-form__submitted",
+    dangerouslySetInnerHTML: {
+      __html: submittedLabel
+    }
+  });
+}
 export default CustomerLoginForm;

package/dist/components/FontdueProvider/index.d.ts

@@ -2,11 +2,20 @@ import React from 'react';
 export { default as loadFontdueProviderQuery } from '../../loadFontdueProviderQuery.js';
 import type { FontdueContextProvider_props } from '../FontdueContextProvider/index.js';
 import { SerializablePreloadedQuery } from '../../relay/loadSerializableQuery.js';
+import type { FontdueServerConfig } from '../../relay/serverConfig.js';
 import { FontdueProviderQuery } from '../../__generated__/FontdueProviderQuery.graphql.js';
 export declare const fontdueProviderQuery: import("react-relay").GraphQLTaggedNode;
 export type FontdueProviderPreloadedQuery = SerializablePreloadedQuery<FontdueProviderQuery>;
 export interface FontdueProvider_props extends FontdueContextProvider_props {
     preloadedQuery?: FontdueProviderPreloadedQuery;
+    /**
+     * Per-render config for server-side fetches (url, headers, cacheTags).
+     * Only honoured by the React Server Components entrypoint, which writes it
+     * to the render-scoped config store and strips it before this client
+     * component — it may carry internal headers that must never reach the
+     * browser. Ignored when the client provider is used directly.
+     */
+    serverConfig?: FontdueServerConfig;
 }
-declare const FontdueProvider: ({ children, preloadedQuery, ...rest }: FontdueProvider_props) => React.JSX.Element;
+declare const FontdueProvider: ({ children, preloadedQuery, serverConfig: _serverConfig, ...rest }: FontdueProvider_props) => React.JSX.Element;
 export default FontdueProvider;

package/dist/components/FontdueProvider/index.js

@@ -22,6 +22,7 @@ const FontdueProvider = _ref => {
   let {
     children,
     preloadedQuery,
+    serverConfig: _serverConfig,
     ...rest
   } = _ref;
   return /*#__PURE__*/React.createElement(FontdueContextProvider, rest, /*#__PURE__*/React.createElement(ErrorBoundary, {

package/dist/components/FontdueProvider/index.server.d.ts

@@ -2,5 +2,6 @@ import React from 'react';
 import type { FontdueProvider_props } from './index.js';
 export type { FontdueProvider_props } from './index.js';
 export type { FontdueProviderPreloadedQuery } from '../../loadFontdueProviderQuery.js';
+export type { FontdueServerConfig } from '../../relay/serverConfig.js';
 export declare function loadFontdueProviderQuery(): never;
-export default function FontdueProviderServer({ preloadedQuery, ...rest }: FontdueProvider_props): Promise<React.JSX.Element>;
+export default function FontdueProviderServer({ preloadedQuery, serverConfig, ...rest }: FontdueProvider_props): Promise<React.JSX.Element>;