fontdue-js 3.0.0-alpha11 → 3.0.0-alpha13

package/dist/__tests__/nextAdapter.test.js

@@ -8,6 +8,11 @@ import path from 'node:path';
 async function importTenant() {
   return await import("../next/tenant.js");
 }
+// Importing this module registers the single-tenant ambient resolver as a side
+// effect, the same way the FontdueProvider react-server entrypoint does.
+async function importRegister() {
+  return await import("../next/registerSingleTenantResolver.js");
+}
 async function importConfig() {
   return await import("../next/config.js");
 }
@@ -20,17 +25,56 @@ vi.mock('next/cache', () => ({
 }));
 
 // Next's notFound() throws a sentinel the framework catches; the mock does
-// the same so tests can assert on it.
+// the same so tests can assert on it. unstable_rethrow re-throws Next's
+// internal control-flow errors (dynamic bailout, notFound, redirect) and is a
+// no-op for anything else — the mock keys off the `digest` convention Next
+// uses to tag those errors.
 vi.mock('next/navigation', () => ({
   notFound: () => {
     throw new Error('NEXT_NOT_FOUND');
+  },
+  unstable_rethrow: error => {
+    const digest = error === null || error === void 0 ? void 0 : error.digest;
+    if (typeof digest === 'string' && (digest.startsWith('DYNAMIC_SERVER_USAGE') || digest.startsWith('NEXT_') || digest.startsWith('BAILOUT_TO_CLIENT_SIDE_RENDERING'))) {
+      throw error;
+    }
+  }
+}));
+
+// Draft mode + the preview token cookie, controllable per test. Default: not
+// previewing, so __prepareFontdueRender takes the public (cached) path. Set
+// cookiesError to make cookies() throw (e.g. simulate Next's dynamic bailout
+// during a prerender pass).
+const draft = vi.hoisted(() => ({
+  enabled: false,
+  token: undefined,
+  cookiesError: undefined
+}));
+vi.mock('next/headers', () => ({
+  draftMode: async () => ({
+    isEnabled: draft.enabled
+  }),
+  cookies: async () => {
+    if (draft.cookiesError) throw draft.cookiesError;
+    return {
+      get: name => name === 'fontdue_preview_token' && draft.token ? {
+        value: draft.token
+      } : undefined
+    };
   }
 }));
 beforeEach(() => {
   vi.resetModules();
+  // The server-config store (incl. the ambient resolver) is anchored on
+  // globalThis, so it survives resetModules; clear it so a resolver registered
+  // by one test can't leak into the next.
+  delete globalThis.__fontdueServerConfigStore__;
   revalidateTag.mockClear();
   vi.unstubAllEnvs();
   vi.restoreAllMocks();
+  draft.enabled = false;
+  draft.token = undefined;
+  draft.cookiesError = undefined;
 });
 function stubSingleTenant() {
   let url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'https://acme.fontdue.com';
@@ -64,13 +108,13 @@ describe('isValidDomain', () => {
     expect(isValidDomain('a'.repeat(254) + '.example')).toBe(false);
   });
 });
-describe('fontdueEndpoint', () => {
+describe('endpointForDomain', () => {
   it('single-tenant: targets NEXT_PUBLIC_FONTDUE_URL with no headers', async () => {
     stubSingleTenant('https://acme.fontdue.com');
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(fontdueEndpoint('acme.fontdue.com')).toEqual({
+    expect(endpointForDomain('acme.fontdue.com')).toEqual({
       domain: 'acme.fontdue.com',
       origin: 'https://acme.fontdue.com',
       headers: {},
@@ -81,9 +125,9 @@ describe('fontdueEndpoint', () => {
     vi.stubEnv('NEXT_PUBLIC_FONTDUE_URL', '');
     vi.stubEnv('FONTDUE_MULTI_TENANT', '');
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(() => fontdueEndpoint('acme.fontdue.com')).toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
+    expect(() => endpointForDomain('acme.fontdue.com')).toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
   });
   it('multi-tenant: forwards the host to FONTDUE_ORIGIN with the proxy secret', async () => {
     stubMultiTenant({
@@ -91,9 +135,9 @@ describe('fontdueEndpoint', () => {
       secret: 's3cret'
     });
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(fontdueEndpoint('acme.fontdue.com')).toEqual({
+    expect(endpointForDomain('acme.fontdue.com')).toEqual({
       domain: 'acme.fontdue.com',
       origin: 'http://app:4000',
       headers: {
@@ -108,18 +152,18 @@ describe('fontdueEndpoint', () => {
       origin: 'http://app:4000'
     });
     const {
-      fontdueEndpoint
+      endpointForDomain
     } = await importTenant();
-    expect(fontdueEndpoint('acme.fontdue.com').headers).toEqual({
+    expect(endpointForDomain('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
+      endpointForDomain
     } = await importTenant();
-    expect(fontdueEndpoint('acme.fontdue.com').origin).toBe('https://acme.fontdue.com');
+    expect(endpointForDomain('acme.fontdue.com').origin).toBe('https://acme.fontdue.com');
   });
 });
 describe('configureFontdueRender', () => {
@@ -131,10 +175,10 @@ describe('configureFontdueRender', () => {
       configureFontdueRender
     } = await importTenant();
     const {
-      getFontdueServerConfig
+      getFontdueSlotConfig
     } = await import("../relay/serverConfig.js");
     expect(configureFontdueRender('not a domain')).toBeNull();
-    expect(getFontdueServerConfig()).toBeUndefined();
+    expect(getFontdueSlotConfig()).toBeUndefined();
   });
   it('sets the per-render server config and returns the endpoint', async () => {
     stubMultiTenant({
@@ -144,9 +188,6 @@ describe('configureFontdueRender', () => {
     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
@@ -166,7 +207,7 @@ describe('configureFontdueRender', () => {
     });
   });
 });
-describe('prepareFontdueRender', () => {
+describe('__prepareFontdueRender', () => {
   const props = params => ({
     params: Promise.resolve(params)
   });
@@ -175,9 +216,9 @@ describe('prepareFontdueRender', () => {
       origin: 'http://app:4000'
     });
     const {
-      prepareFontdueRender
+      __prepareFontdueRender
     } = await importTenant();
-    const endpoint = await prepareFontdueRender(props({
+    const endpoint = await __prepareFontdueRender(props({
       domain: 'acme.fontdue.com',
       slug: 'sans'
     }));
@@ -187,32 +228,209 @@ describe('prepareFontdueRender', () => {
   it('404s invalid or missing domains', async () => {
     stubMultiTenant();
     const {
-      prepareFontdueRender
+      __prepareFontdueRender
     } = await importTenant();
-    await expect(prepareFontdueRender(props({
+    await expect(__prepareFontdueRender(props({
       domain: 'not a domain'
     }))).rejects.toThrow('NEXT_NOT_FOUND');
-    await expect(prepareFontdueRender(props({
+    await expect(__prepareFontdueRender(props({
       slug: 'sans'
     }))).rejects.toThrow('NEXT_NOT_FOUND');
   });
+
+  // React.cache doesn't memoize outside an RSC render (see configureFontdueRender
+  // above), so the slot write is a no-op here — capture what __prepareFontdueRender
+  // passes to setFontdueServerConfig instead.
+  async function captureRenderConfig(params) {
+    let captured;
+    vi.doMock('../relay/serverConfig', async importActual => ({
+      ...(await importActual()),
+      setFontdueServerConfig: c => {
+        captured = c;
+      }
+    }));
+    const {
+      __prepareFontdueRender
+    } = await importTenant();
+    await __prepareFontdueRender(props(params));
+    vi.doUnmock('../relay/serverConfig');
+    return captured;
+  }
+  it('public render: sets the tenant config with cache tags and no token', async () => {
+    var _config$headers;
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    const config = await captureRenderConfig({
+      domain: 'acme.fontdue.com'
+    });
+    expect(config.cacheTags).toEqual(['graphql:acme.fontdue.com']);
+    expect((_config$headers = config.headers) === null || _config$headers === void 0 ? void 0 : _config$headers.authorization).toBeUndefined();
+  });
+  it('preview render: folds the token into headers and drops cache tags', async () => {
+    var _config$headers2;
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    const config = await captureRenderConfig({
+      domain: 'acme.fontdue.com'
+    });
+    // Embeds (createNetworkFetch) and the app's fetch (createFontdueFetch) both
+    // read this, so both reveal hidden fonts; no tags keeps the render live.
+    expect((_config$headers2 = config.headers) === null || _config$headers2 === void 0 ? void 0 : _config$headers2.authorization).toBe('Bearer admin-tok');
+    expect(config.cacheTags).toBeUndefined();
+  });
 });
-describe('currentFontdueEndpoint', () => {
+describe('configureFontduePreview (single-tenant)', () => {
+  async function captureConfig() {
+    let captured;
+    vi.doMock('../relay/serverConfig', async importActual => ({
+      ...(await importActual()),
+      setFontdueServerConfig: c => {
+        captured = c;
+      }
+    }));
+    const {
+      configureFontduePreview
+    } = await importTenant();
+    const endpoint = await configureFontduePreview();
+    vi.doUnmock('../relay/serverConfig');
+    return {
+      captured,
+      endpoint
+    };
+  }
+  it('public render: configures the NEXT_PUBLIC_FONTDUE_URL site with cache tags', async () => {
+    var _captured$headers;
+    stubSingleTenant('https://acme.fontdue.com');
+    const {
+      captured,
+      endpoint
+    } = await captureConfig();
+    expect(endpoint.origin).toBe('https://acme.fontdue.com');
+    expect(captured.url).toBe('https://acme.fontdue.com');
+    expect(captured.cacheTags).toEqual(['graphql:acme.fontdue.com']);
+    expect((_captured$headers = captured.headers) === null || _captured$headers === void 0 ? void 0 : _captured$headers.authorization).toBeUndefined();
+  });
+  it('preview render: forwards the token and drops cache tags', async () => {
+    var _captured$headers2;
+    stubSingleTenant('https://acme.fontdue.com');
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    const {
+      captured
+    } = await captureConfig();
+    expect((_captured$headers2 = captured.headers) === null || _captured$headers2 === void 0 ? void 0 : _captured$headers2.authorization).toBe('Bearer admin-tok');
+    expect(captured.cacheTags).toBeUndefined();
+  });
+  it('throws a helpful error when NEXT_PUBLIC_FONTDUE_URL is unset', async () => {
+    stubMultiTenant();
+    const {
+      configureFontduePreview
+    } = await importTenant();
+    await expect(configureFontduePreview()).rejects.toThrow(/NEXT_PUBLIC_FONTDUE_URL/);
+  });
+});
+describe('single-tenant ambient resolver (no per-render call)', () => {
+  // Importing registerSingleTenantResolver registers the resolver as a module
+  // side effect — the FontdueProvider RSC entrypoint does this import, so
+  // merely mounting the provider wires it up. No
+  // configureFontduePreview()/__prepareFontdueRender() call is made in any of
+  // these tests; the config is pulled at fetch time.
+  it('public render: feeds the env URL + cache tags, no token', async () => {
+    var _config$headers3;
+    stubSingleTenant('https://acme.fontdue.com');
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    const config = await resolveFontdueServerConfig();
+    expect(config === null || config === void 0 ? void 0 : config.url).toBe('https://acme.fontdue.com');
+    expect(config === null || config === void 0 ? void 0 : config.cacheTags).toEqual(['graphql:acme.fontdue.com']);
+    expect(config === null || config === void 0 ? void 0 : (_config$headers3 = config.headers) === null || _config$headers3 === void 0 ? void 0 : _config$headers3.authorization).toBeUndefined();
+  });
+  it('preview render: folds in the admin token and drops cache tags', async () => {
+    var _config$headers4;
+    stubSingleTenant('https://acme.fontdue.com');
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    const config = await resolveFontdueServerConfig();
+    // This is what reveals hidden fonts in an embedded component's own preload
+    // on a page that never calls the app's GraphQL fetcher.
+    expect(config === null || config === void 0 ? void 0 : (_config$headers4 = config.headers) === null || _config$headers4 === void 0 ? void 0 : _config$headers4.authorization).toBe('Bearer admin-tok');
+    expect(config === null || config === void 0 ? void 0 : config.cacheTags).toBeUndefined();
+  });
+  it('multi-tenant: resolver stays out of the way so the slot drives config', async () => {
+    stubMultiTenant({
+      origin: 'http://app:4000'
+    });
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    expect(await resolveFontdueServerConfig()).toBeUndefined();
+  });
+
+  // Regression for FD-712: a preview render that begins as a static/prerender
+  // pass must NOT swallow Next's dynamic bailout — re-throwing it is what takes
+  // the route off the full-route cache so the embeds' preloads re-run with the
+  // token. If this were swallowed, every server fetch (including a <BuyButton>
+  // node(id) @required(THROW) preload) would silently get the public view.
+  it('preview render: propagates Next’s dynamic bailout instead of dropping the token', async () => {
+    stubSingleTenant('https://acme.fontdue.com');
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    draft.cookiesError = Object.assign(new Error('Dynamic server usage'), {
+      digest: 'DYNAMIC_SERVER_USAGE'
+    });
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    await expect(resolveFontdueServerConfig()).rejects.toBe(draft.cookiesError);
+  });
+
+  // A non-control-flow throw (e.g. no request scope at all) is not a bailout,
+  // so it's swallowed and the render degrades to the public (token-less) config
+  // rather than crashing.
+  it('preview render: swallows a non-control-flow throw and falls back to public', async () => {
+    var _config$headers5;
+    stubSingleTenant('https://acme.fontdue.com');
+    draft.enabled = true;
+    draft.token = 'admin-tok';
+    draft.cookiesError = new Error('no request scope');
+    await importRegister();
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    const config = await resolveFontdueServerConfig();
+    expect(config === null || config === void 0 ? void 0 : config.url).toBe('https://acme.fontdue.com');
+    expect(config === null || config === void 0 ? void 0 : config.cacheTags).toEqual(['graphql:acme.fontdue.com']);
+    expect(config === null || config === void 0 ? void 0 : (_config$headers5 = config.headers) === null || _config$headers5 === void 0 ? void 0 : _config$headers5.authorization).toBeUndefined();
+  });
+});
+describe('fontdueEndpoint', () => {
   it('multi-tenant: throws when no render config was set', async () => {
     stubMultiTenant({
       origin: 'http://app:4000'
     });
     const {
-      currentFontdueEndpoint
+      fontdueEndpoint
     } = await importTenant();
-    expect(() => currentFontdueEndpoint()).toThrow(/prepareFontdueRender/);
+    expect(() => fontdueEndpoint()).toThrow(/__prepareFontdueRender/);
   });
   it('single-tenant: derives the endpoint from NEXT_PUBLIC_FONTDUE_URL', async () => {
     stubSingleTenant('https://acme.fontdue.com');
     const {
-      currentFontdueEndpoint
+      fontdueEndpoint
     } = await importTenant();
-    expect(currentFontdueEndpoint()).toEqual({
+    expect(fontdueEndpoint()).toEqual({
       domain: 'acme.fontdue.com',
       origin: 'https://acme.fontdue.com',
       headers: {},
@@ -225,26 +443,17 @@ describe('currentFontdueEndpoint', () => {
     });
     vi.doMock('../relay/serverConfig', async importActual => ({
       ...(await importActual()),
-      getFontdueServerConfig: () => ({
+      getFontdueSlotConfig: () => ({
         domain: 'acme.fontdue.com'
       })
     }));
     const {
-      currentFontdueEndpoint
+      fontdueEndpoint
     } = await importTenant();
-    expect(currentFontdueEndpoint().headers['x-forwarded-host']).toBe('acme.fontdue.com');
+    expect(fontdueEndpoint().headers['x-forwarded-host']).toBe('acme.fontdue.com');
     vi.doUnmock('../relay/serverConfig');
   });
 });
-describe('generateStaticParams', () => {
-  it('returns no build-time params (everything renders on demand)', async () => {
-    stubMultiTenant();
-    const {
-      generateStaticParams
-    } = await importTenant();
-    await expect(generateStaticParams()).resolves.toEqual([]);
-  });
-});
 
 // withFontdue detects the route-tree shape from the working directory; give
 // it one with or without src/app/[domain].

package/dist/__tests__/serverConfig.test.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+// The render-scoped slot and the ambient resolver are anchored on globalThis so
+// they survive this module being bundled into more than one Next.js server
+// chunk (the app/provider chunk vs. a per-embed chunk), which would otherwise
+// give each chunk its own copy of the module-level state. Re-importing the
+// module after vi.resetModules() faithfully simulates that second chunk: a
+// fresh module instance with its own scope but the same globalThis.
+const STORE_KEY = '__fontdueServerConfigStore__';
+function clearStore() {
+  delete globalThis[STORE_KEY];
+}
+beforeEach(() => {
+  vi.resetModules();
+  clearStore();
+});
+afterEach(clearStore);
+describe('serverConfig store (chunk-duplication safety, FD-712)', () => {
+  it('shares the ambient resolver across module instances', async () => {
+    var _await$a$resolveFontd, _await$a$resolveFontd2, _await$b$resolveFontd, _await$b$resolveFontd2;
+    // First "chunk": register a resolver (what fontdue-js/next does when
+    // <FontdueProvider> mounts in single-tenant mode).
+    const a = await import("../relay/serverConfig.js");
+    a.registerAmbientConfigResolver(async () => ({
+      url: 'https://acme.fontdue.com',
+      headers: {
+        authorization: 'Bearer admin-tok'
+      }
+    }));
+    expect((_await$a$resolveFontd = await a.resolveFontdueServerConfig()) === null || _await$a$resolveFontd === void 0 ? void 0 : (_await$a$resolveFontd2 = _await$a$resolveFontd.headers) === null || _await$a$resolveFontd2 === void 0 ? void 0 : _await$a$resolveFontd2.authorization).toBe('Bearer admin-tok');
+
+    // Second "chunk": a fresh module instance. Before the fix its module-level
+    // `ambientResolver` was undefined here, so an embed preloading from this
+    // chunk fetched without the preview token and a hidden-font reveal failed.
+    vi.resetModules();
+    const b = await import("../relay/serverConfig.js");
+    expect(b).not.toBe(a); // genuinely a re-evaluated module
+    expect((_await$b$resolveFontd = await b.resolveFontdueServerConfig()) === null || _await$b$resolveFontd === void 0 ? void 0 : (_await$b$resolveFontd2 = _await$b$resolveFontd.headers) === null || _await$b$resolveFontd2 === void 0 ? void 0 : _await$b$resolveFontd2.authorization).toBe('Bearer admin-tok');
+  });
+  it('reuses one shared store object across re-imports', async () => {
+    const a = await import("../relay/serverConfig.js");
+    // The store is created lazily on first use, not on import.
+    a.registerAmbientConfigResolver(() => undefined);
+    const first = globalThis[STORE_KEY];
+    expect(first).toBeDefined();
+    vi.resetModules();
+    const b = await import("../relay/serverConfig.js");
+    await b.resolveFontdueServerConfig();
+    const second = globalThis[STORE_KEY];
+
+    // Same store (slot factory + resolver), not a per-instance copy — so the
+    // React.cache-backed slot multi-tenant uses (setFontdueServerConfig via
+    // __prepareFontdueRender) is one shared cell every chunk reads/writes.
+    expect(second).toBe(first);
+  });
+  it('starts with no resolver (resolution unchanged until something registers)', async () => {
+    const {
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    expect(await resolveFontdueServerConfig()).toBeUndefined();
+  });
+});

package/dist/components/ConfigContext.d.ts

@@ -25,6 +25,7 @@ interface TrackingConfig {
 }
 interface PreviewConfig {
     endpoint?: string;
+    revalidateEndpoint?: string;
 }
 export interface Config {
     form?: FormConfig;
@@ -108,6 +109,7 @@ export declare const makeConfig: (config?: Config) => {
     };
     preview: {
         endpoint: string;
+        revalidateEndpoint: string | undefined;
     };
     corsErrorModal: boolean;
 };
@@ -183,6 +185,7 @@ declare const _default: React.Context<{
     };
     preview: {
         endpoint: string;
+        revalidateEndpoint: string | undefined;
     };
     corsErrorModal: boolean;
 }>;

package/dist/components/ConfigContext.js

@@ -80,7 +80,7 @@ export const mergeConfig = (base, override) => {
   return deepMerge(base, override);
 };
 export const makeConfig = config => {
-  var _config$form, _config$storeModal, _config$storeModal2, _config$storeModal3, _config$storeModal4, _config$stripe, _config$tracking, _config$tracking2, _config$tracking3, _config$tracking4, _config$preview;
+  var _config$form, _config$storeModal, _config$storeModal2, _config$storeModal3, _config$storeModal4, _config$stripe, _config$tracking, _config$tracking2, _config$tracking3, _config$tracking4, _config$preview, _config$preview2;
   return {
     typeTester: makeTypeTesterConfig(config === null || config === void 0 ? void 0 : config.typeTester),
     form: {
@@ -103,7 +103,10 @@ export const makeConfig = config => {
       segment: config === null || config === void 0 ? void 0 : (_config$tracking4 = config.tracking) === null || _config$tracking4 === void 0 ? void 0 : _config$tracking4.segment
     },
     preview: {
-      endpoint: (config === null || config === void 0 ? void 0 : (_config$preview = config.preview) === null || _config$preview === void 0 ? void 0 : _config$preview.endpoint) ?? PREVIEW_ENDPOINT
+      endpoint: (config === null || config === void 0 ? void 0 : (_config$preview = config.preview) === null || _config$preview === void 0 ? void 0 : _config$preview.endpoint) ?? PREVIEW_ENDPOINT,
+      // No default: an unset revalidate endpoint hides the toolbar's refresh
+      // button (frameworks without a client-callable purge leave it unset).
+      revalidateEndpoint: config === null || config === void 0 ? void 0 : (_config$preview2 = config.preview) === null || _config$preview2 === void 0 ? void 0 : _config$preview2.revalidateEndpoint
     },
     corsErrorModal: (config === null || config === void 0 ? void 0 : config.corsErrorModal) ?? true
   };

package/dist/components/FontdueAdminToolbar/index.js

@@ -5,7 +5,8 @@ import _FontdueAdminToolbarQuery from "../../__generated__/FontdueAdminToolbarQu
 import React, { useContext, useEffect, useState } from 'react';
 import { commitMutation, fetchQuery, graphql, useRelayEnvironment } from 'react-relay';
 import ConfigContext from '../ConfigContext.js';
-import { PREVIEW_ENDPOINT, PREVIEW_MARKER_COOKIE } from '../../preview/constants.js';
+import { PREVIEW_ENDPOINT, hasPreviewMarkerCookie } from '../../preview/constants.js';
+import { fontdueBaseUrl, version } from '../../relay/environment.js';
 // Admin-only affordance for logged-in foundry admins: reveal unpublished
 // ("hidden") fonts across the whole storefront. Storefront pages are
 // server-rendered sessionless and cached, and the provider's own query is
@@ -22,28 +23,31 @@ const adminQuery = (_FontdueAdminToolbarQuery.hash && _FontdueAdminToolbarQuery.
 // createAdminToken mints a short-lived, stateless admin token from the admin
 // session; it's handed to the preview route to enter draft mode.
 const tokenMutation = (_FontdueAdminToolbarTokenMutation.hash && _FontdueAdminToolbarTokenMutation.hash !== "2b82f195747c86d50fd5884d76f3b709" && console.error("The definition of 'FontdueAdminToolbarTokenMutation' appears to have changed. Run `relay-compiler` to update the generated files to receive the expected data."), _FontdueAdminToolbarTokenMutation);
-
-// The preview entry/exit route and the readable marker cookie are part of the
-// portable preview contract — see fontdue-js/preview. The route path defaults
-// to '/api/preview' but is configurable via FontdueConfig.preview.endpoint so
-// non-Next apps can mount it wherever their router expects (the Next adapter's
-// draft-mode route, an Astro APIRoute, an RR7 action — all honor the same
-// POST-token-to-enter / DELETE-to-exit contract).
-function hasPreviewCookie() {
-  return typeof document !== 'undefined' && document.cookie.split('; ').some(c => c === `${PREVIEW_MARKER_COOKIE}=1`);
-}
 export default function FontdueAdminToolbar() {
-  var _useContext$preview;
   const environment = useRelayEnvironment();
-  const previewEndpoint = ((_useContext$preview = useContext(ConfigContext).preview) === null || _useContext$preview === void 0 ? void 0 : _useContext$preview.endpoint) ?? PREVIEW_ENDPOINT;
+  const previewConfig = useContext(ConfigContext).preview;
+  // The preview entry/exit route is part of the portable preview contract (see
+  // fontdue-js/preview); it defaults to '/api/preview' but is configurable so
+  // non-Next apps can mount it where their router expects. The revalidate route
+  // is opt-in (no default) — see config.preview.revalidateEndpoint.
+  const previewEndpoint = (previewConfig === null || previewConfig === void 0 ? void 0 : previewConfig.endpoint) ?? PREVIEW_ENDPOINT;
+  const revalidateEndpoint = previewConfig === null || previewConfig === void 0 ? void 0 : previewConfig.revalidateEndpoint;
+
+  // Where the admin is signed in: the configured Fontdue origin. Used for the
+  // "signed in at" line and the deep link back to the admin. Undefined (e.g.
+  // multi-tenant) just drops both gracefully.
+  const fontdueUrl = fontdueBaseUrl();
+  const fontdueHost = fontdueUrl ? safeHost(fontdueUrl) : null;
+  const adminUrl = fontdueUrl ? `${fontdueUrl.replace(/\/+$/, '')}/admin` : null;
   const [adminName, setAdminName] = useState(null);
   const [ready, setReady] = useState(false);
   const [open, setOpen] = useState(false);
   const [previewing, setPreviewing] = useState(false);
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState(null);
+  const [notice, setNotice] = useState(null);
   useEffect(() => {
-    setPreviewing(hasPreviewCookie());
+    setPreviewing(hasPreviewMarkerCookie());
     // network-only: the provider's preloaded query already wrote a sessionless
     // `viewer` to the store, so we must go to the network (with the session)
     // rather than read that cached, admin-blind copy.
@@ -83,6 +87,7 @@ export default function FontdueAdminToolbar() {
   function enterPreview() {
     setBusy(true);
     setError(null);
+    setNotice(null);
     commitMutation(environment, {
       mutation: tokenMutation,
       variables: {},
@@ -105,11 +110,32 @@ export default function FontdueAdminToolbar() {
   async function exitPreview() {
     setBusy(true);
     setError(null);
+    setNotice(null);
     await fetch(previewEndpoint, {
       method: 'DELETE'
     });
     window.location.reload();
   }
+
+  // Purge the cached storefront so public visitors see freshly published (or
+  // newly hidden) content. Targets the configured revalidate route as-is.
+  async function refreshCache() {
+    if (!revalidateEndpoint) return;
+    setBusy(true);
+    setError(null);
+    setNotice(null);
+    try {
+      const res = await fetch(revalidateEndpoint, {
+        method: 'POST'
+      });
+      if (!res.ok) throw new Error(`status ${res.status}`);
+      setNotice('Public cache refreshed.');
+    } catch {
+      setError('Could not refresh the cache.');
+    } finally {
+      setBusy(false);
+    }
+  }
   return /*#__PURE__*/React.createElement("div", {
     className: "fontdue-admin-toolbar",
     "data-previewing": previewing,
@@ -132,9 +158,29 @@ export default function FontdueAdminToolbar() {
     "data-testid": "preview-toggle"
   }), /*#__PURE__*/React.createElement("span", null, "Preview hidden fonts")), /*#__PURE__*/React.createElement("p", {
     className: "fontdue-admin-toolbar__hint"
-  }, previewing ? 'Unpublished fonts are visible across the site — only to you.' : 'Reveal unpublished fonts everywhere, only for you.'), error && /*#__PURE__*/React.createElement("p", {
+  }, previewing ? 'Unpublished fonts are visible across the site — only to you.' : 'Reveal unpublished fonts everywhere, only for you.'), (revalidateEndpoint || adminUrl) && /*#__PURE__*/React.createElement("div", {
+    className: "fontdue-admin-toolbar__actions"
+  }, revalidateEndpoint && /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: "fontdue-admin-toolbar__action",
+    onClick: refreshCache,
+    disabled: busy,
+    "data-testid": "revalidate-button"
+  }, "Refresh public cache"), adminUrl && /*#__PURE__*/React.createElement("a", {
+    className: "fontdue-admin-toolbar__action",
+    href: adminUrl,
+    target: "_blank",
+    rel: "noreferrer",
+    "data-testid": "open-admin-link"
+  }, "Open Fontdue admin \u2197")), notice && /*#__PURE__*/React.createElement("p", {
+    className: "fontdue-admin-toolbar__notice"
+  }, notice), error && /*#__PURE__*/React.createElement("p", {
     className: "fontdue-admin-toolbar__error"
-  }, error)), /*#__PURE__*/React.createElement("button", {
+  }, error), /*#__PURE__*/React.createElement("p", {
+    className: "fontdue-admin-toolbar__meta"
+  }, fontdueHost ? `Shown because you’re signed in to Fontdue at ${fontdueHost}.` : 'Shown because you’re signed in to Fontdue.', /*#__PURE__*/React.createElement("span", {
+    className: "fontdue-admin-toolbar__version"
+  }, "fontdue-js ", version))), /*#__PURE__*/React.createElement("button", {
     type: "button",
     className: "fontdue-admin-toolbar__button",
     onClick: () => setOpen(v => !v),
@@ -144,4 +190,14 @@ export default function FontdueAdminToolbar() {
     className: "fontdue-admin-toolbar__dot",
     "aria-hidden": "true"
   }), "Fontdue", previewing ? ' · previewing' : ''));
+}
+
+// Hostname of a base URL, or the raw value if it can't be parsed (so a
+// misconfigured URL still shows something rather than throwing).
+function safeHost(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
 }