fontdue-js 3.0.0-alpha9 → 3.0.0

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', () => {
@@ -130,11 +174,8 @@ describe('configureFontdueRender', () => {
     const {
       configureFontdueRender
     } = await importTenant();
-    const {
-      getFontdueServerConfig
-    } = await import("../relay/serverConfig.js");
+    // Invalid domain returns null before any setFontdueServerConfig call.
     expect(configureFontdueRender('not a domain')).toBeNull();
-    expect(getFontdueServerConfig()).toBeUndefined();
   });
   it('sets the per-render server config and returns the endpoint', async () => {
     stubMultiTenant({
@@ -144,9 +185,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
@@ -161,12 +199,11 @@ describe('configureFontdueRender', () => {
         'x-forwarded-host': 'acme.fontdue.com',
         'x-fontdue-proxy-secret': 's3cret'
       },
-      cacheTags: ['graphql:acme.fontdue.com'],
-      domain: 'acme.fontdue.com'
+      cacheTags: ['graphql:acme.fontdue.com']
     });
   });
 });
-describe('prepareFontdueRender', () => {
+describe('__prepareFontdueRender', () => {
   const props = params => ({
     params: Promise.resolve(params)
   });
@@ -175,9 +212,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,62 +224,140 @@ 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');
   });
-});
-describe('currentFontdueEndpoint', () => {
-  it('multi-tenant: throws when no render config was set', async () => {
+
+  // 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('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 per-render setup 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 {
-      currentFontdueEndpoint
-    } = await importTenant();
-    expect(() => currentFontdueEndpoint()).toThrow(/prepareFontdueRender/);
+      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('single-tenant: derives the endpoint from NEXT_PUBLIC_FONTDUE_URL', async () => {
+  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 {
-      currentFontdueEndpoint
-    } = await importTenant();
-    expect(currentFontdueEndpoint()).toEqual({
-      domain: 'acme.fontdue.com',
-      origin: 'https://acme.fontdue.com',
-      headers: {},
-      tags: ['graphql', 'graphql:acme.fontdue.com']
-    });
+      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('uses the render-configured domain when set', async () => {
+  it('multi-tenant: resolver stays out of the way so the slot drives config', async () => {
     stubMultiTenant({
       origin: 'http://app:4000'
     });
-    vi.doMock('../relay/serverConfig', async importActual => ({
-      ...(await importActual()),
-      getFontdueServerConfig: () => ({
-        domain: 'acme.fontdue.com'
-      })
-    }));
+    await importRegister();
     const {
-      currentFontdueEndpoint
-    } = await importTenant();
-    expect(currentFontdueEndpoint().headers['x-forwarded-host']).toBe('acme.fontdue.com');
-    vi.doUnmock('../relay/serverConfig');
+      resolveFontdueServerConfig
+    } = await import("../relay/serverConfig.js");
+    expect(await resolveFontdueServerConfig()).toBeUndefined();
   });
-});
-describe('generateStaticParams', () => {
-  it('returns no build-time params (everything renders on demand)', async () => {
-    stubMultiTenant();
+
+  // 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 {
-      generateStaticParams
-    } = await importTenant();
-    await expect(generateStaticParams()).resolves.toEqual([]);
+      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();
   });
 });
 

package/dist/__tests__/preview.test.js

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { handlePreviewRequest, readPreviewToken, previewAuthHeaders, PREVIEW_TOKEN_COOKIE, PREVIEW_MARKER_COOKIE } from '../preview/index.js';
+import { setPreviewMarkerCookie, hasPreviewMarkerCookie, getPreviewExpiry } from '../preview/constants.js';
+function postPreview(token) {
+  let url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'https://site.test/api/preview';
+  return handlePreviewRequest(new Request(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({
+      token
+    })
+  }));
+}
+describe('handlePreviewRequest', () => {
+  it('enters preview: sets an httpOnly token cookie + a readable marker', async () => {
+    const before = Date.now();
+    const res = await postPreview('admin.tok.123');
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.ok).toBe(true);
+    expect(body.preview).toBe(true);
+    // No expiresAt in the body → defaults to now + the 1h TTL.
+    expect(body.expiresAt).toBeGreaterThanOrEqual(before + 60 * 60 * 1000 - 5_000);
+    const cookies = res.headers.getSetCookie();
+    const tokenCookie = cookies.find(c => c.startsWith(`${PREVIEW_TOKEN_COOKIE}=`));
+    const markerCookie = cookies.find(c => c.startsWith(`${PREVIEW_MARKER_COOKIE}=`));
+    expect(tokenCookie).toContain(`${PREVIEW_TOKEN_COOKIE}=admin.tok.123`);
+    expect(tokenCookie).toContain('HttpOnly');
+    expect(tokenCookie).toContain('SameSite=Lax');
+    expect(tokenCookie).toContain('Path=/');
+
+    // The marker now carries the token's expiry (epoch-ms), and outlives the
+    // token via a grace window so the toolbar can reach the "expired" warning.
+    expect(markerCookie).toContain(`${PREVIEW_MARKER_COOKIE}=${body.expiresAt}`);
+    expect(markerCookie).toMatch(/Max-Age=\d+/);
+    // The marker must be readable by the client toolbar.
+    expect(markerCookie).not.toContain('HttpOnly');
+  });
+  it('threads an explicit expiresAt (ISO + epoch-ms) into the marker + body', async () => {
+    const iso = '2030-01-01T00:00:00.000Z';
+    const epoch = Date.parse(iso);
+    const fromIso = await handlePreviewRequest(new Request('https://site.test/api/preview', {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify({
+        token: 't',
+        expiresAt: iso
+      })
+    }));
+    expect((await fromIso.json()).expiresAt).toBe(epoch);
+    const fromEpoch = await handlePreviewRequest(new Request('https://site.test/api/preview', {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: JSON.stringify({
+        token: 't',
+        expiresAt: epoch
+      })
+    }));
+    expect((await fromEpoch.json()).expiresAt).toBe(epoch);
+    const marker = fromEpoch.headers.getSetCookie().find(c => c.startsWith(`${PREVIEW_MARKER_COOKIE}=`));
+    expect(marker).toContain(`${PREVIEW_MARKER_COOKIE}=${epoch}`);
+  });
+  it('marks cookies Secure on https and not on http (local dev)', async () => {
+    const httpsCookies = (await postPreview('t')).headers.getSetCookie();
+    expect(httpsCookies.every(c => c.includes('Secure'))).toBe(true);
+    const httpCookies = (await postPreview('t', 'http://localhost:4321/api/preview')).headers.getSetCookie();
+    expect(httpCookies.some(c => c.includes('Secure'))).toBe(false);
+  });
+  it('rejects a POST with no token', async () => {
+    const res = await postPreview('');
+    expect(res.status).toBe(400);
+    expect(res.headers.getSetCookie()).toHaveLength(0);
+  });
+  it('exits preview: clears both cookies', async () => {
+    const res = await handlePreviewRequest(new Request('https://site.test/api/preview', {
+      method: 'DELETE'
+    }));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      ok: true,
+      preview: false
+    });
+    const cookies = res.headers.getSetCookie();
+    expect(cookies).toHaveLength(2);
+    // Expiry via Max-Age=0 clears the cookie.
+    expect(cookies.every(c => c.includes('Max-Age=0'))).toBe(true);
+  });
+  it('rejects unsupported methods', async () => {
+    const res = await handlePreviewRequest(new Request('https://site.test/api/preview', {
+      method: 'GET'
+    }));
+    expect(res.status).toBe(405);
+  });
+  it('round-trips a token with cookie-unsafe characters', async () => {
+    const token = 'tok+en/with=specials';
+    const res = await postPreview(token);
+    const setCookie = res.headers.getSetCookie().find(c => c.startsWith(`${PREVIEW_TOKEN_COOKIE}=`));
+    // Reconstruct the Cookie header the browser would send back (name=value).
+    const cookieHeader = setCookie.split(';')[0];
+    expect(readPreviewToken(cookieHeader)).toBe(token);
+  });
+});
+describe('readPreviewToken', () => {
+  it('extracts the token from a multi-cookie header', () => {
+    expect(readPreviewToken(`a=1; ${PREVIEW_TOKEN_COOKIE}=abc; ${PREVIEW_MARKER_COOKIE}=1`)).toBe('abc');
+  });
+  it('returns undefined when there is no token cookie', () => {
+    expect(readPreviewToken('a=1; b=2')).toBeUndefined();
+    expect(readPreviewToken('')).toBeUndefined();
+    expect(readPreviewToken(null)).toBeUndefined();
+    expect(readPreviewToken(undefined)).toBeUndefined();
+  });
+});
+describe('setPreviewMarkerCookie (client-only embeds)', () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  // Captures the last `document.cookie = ...` write through a setter, the way
+  // the browser would receive it.
+  function stubBrowser(protocol) {
+    const state = {
+      written: ''
+    };
+    vi.stubGlobal('document', {
+      set cookie(value) {
+        state.written = value;
+      },
+      get cookie() {
+        return state.written;
+      }
+    });
+    vi.stubGlobal('location', {
+      protocol
+    });
+    return state;
+  }
+  it('is a no-op during server rendering (no document)', () => {
+    // The node test env has no `document`, so this must stay inert, not throw.
+    expect(() => setPreviewMarkerCookie(true)).not.toThrow();
+  });
+  it('sets a JS-readable marker carrying the expiry, Secure on https', () => {
+    const state = stubBrowser('https:');
+    const expiresAt = Date.now() + 60 * 60 * 1000;
+    setPreviewMarkerCookie(expiresAt);
+    expect(state.written).toContain(`${PREVIEW_MARKER_COOKIE}=${expiresAt}`);
+    expect(state.written).toContain('Path=/');
+    expect(state.written).toContain('SameSite=Lax');
+    expect(state.written).toContain('Secure');
+    // A positive Max-Age (not a clear) that outlives the token.
+    expect(state.written).toMatch(/Max-Age=\d+/);
+    expect(state.written).not.toContain('Max-Age=0');
+  });
+  it('defaults to the 1h TTL when passed a bare true', () => {
+    const state = stubBrowser('https:');
+    const before = Date.now();
+    setPreviewMarkerCookie(true);
+    const match = state.written.match(new RegExp(`${PREVIEW_MARKER_COOKIE}=(\\d+)`));
+    expect(match).not.toBeNull();
+    expect(Number(match[1])).toBeGreaterThanOrEqual(before + 60 * 60 * 1000 - 5_000);
+  });
+  it('omits Secure on http so it persists in local dev', () => {
+    const state = stubBrowser('http:');
+    setPreviewMarkerCookie(Date.now() + 60 * 60 * 1000);
+    expect(state.written).not.toContain('Secure');
+  });
+  it('clears the marker with Max-Age=0 on exit', () => {
+    const state = stubBrowser('https:');
+    setPreviewMarkerCookie(false);
+    expect(state.written).toContain(`${PREVIEW_MARKER_COOKIE}=`);
+    expect(state.written).toContain('Max-Age=0');
+  });
+});
+describe('previewAuthHeaders', () => {
+  it('builds a Bearer header when a token is present', () => {
+    expect(previewAuthHeaders('abc')).toEqual({
+      authorization: 'Bearer abc'
+    });
+  });
+  it('returns an empty object when there is no token (safe to spread)', () => {
+    expect(previewAuthHeaders(undefined)).toEqual({});
+    expect(previewAuthHeaders(null)).toEqual({});
+    expect(previewAuthHeaders('')).toEqual({});
+  });
+});
+describe('marker cookie readers (hasPreviewMarkerCookie / getPreviewExpiry)', () => {
+  afterEach(() => vi.unstubAllGlobals());
+  function stubCookies(cookie) {
+    vi.stubGlobal('document', {
+      cookie
+    });
+  }
+  it('reads presence + expiry from an expiry-encoded marker', () => {
+    stubCookies(`a=1; ${PREVIEW_MARKER_COOKIE}=1781700000000; b=2`);
+    expect(hasPreviewMarkerCookie()).toBe(true);
+    expect(getPreviewExpiry()).toBe(1781700000000);
+  });
+  it('treats a legacy `=1` marker as present, expiry 1ms (always expired)', () => {
+    stubCookies(`${PREVIEW_MARKER_COOKIE}=1`);
+    expect(hasPreviewMarkerCookie()).toBe(true);
+    expect(getPreviewExpiry()).toBe(1);
+  });
+  it('reports absent when the marker cookie is missing', () => {
+    stubCookies('a=1; b=2');
+    expect(hasPreviewMarkerCookie()).toBe(false);
+    expect(getPreviewExpiry()).toBeUndefined();
+  });
+  it('returns undefined expiry for a non-numeric marker value', () => {
+    stubCookies(`${PREVIEW_MARKER_COOKIE}=bogus`);
+    expect(hasPreviewMarkerCookie()).toBe(true);
+    expect(getPreviewExpiry()).toBeUndefined();
+  });
+});