diff --git a/.changeset/lucky-pandas-observe.md b/.changeset/lucky-pandas-observe.md
new file mode 100644
index 00000000000..f1af513ef17
--- /dev/null
+++ b/.changeset/lucky-pandas-observe.md
@@ -0,0 +1,6 @@
+---
+'@clerk/clerk-js': minor
+'@clerk/shared': minor
+---
+
+Internal improvements to Clerk Protect. No action is required, and instances that do not use Protect are unaffected.
diff --git a/packages/clerk-js/bundlewatch.config.json b/packages/clerk-js/bundlewatch.config.json
index 2fb60167bd3..a9b53bd6c93 100644
--- a/packages/clerk-js/bundlewatch.config.json
+++ b/packages/clerk-js/bundlewatch.config.json
@@ -1,10 +1,10 @@
 {
   "files": [
-    { "path": "./dist/clerk.js", "maxSize": "549KB" },
-    { "path": "./dist/clerk.browser.js", "maxSize": "77KB" },
-    { "path": "./dist/clerk.legacy.browser.js", "maxSize": "119KB" },
-    { "path": "./dist/clerk.no-rhc.js", "maxSize": "316KB" },
-    { "path": "./dist/clerk.native.js", "maxSize": "77KB" },
+    { "path": "./dist/clerk.js", "maxSize": "552KB" },
+    { "path": "./dist/clerk.browser.js", "maxSize": "79KB" },
+    { "path": "./dist/clerk.legacy.browser.js", "maxSize": "122KB" },
+    { "path": "./dist/clerk.no-rhc.js", "maxSize": "320KB" },
+    { "path": "./dist/clerk.native.js", "maxSize": "79KB" },
     { "path": "./dist/vendors*.js", "maxSize": "7KB" },
     { "path": "./dist/coinbase*.js", "maxSize": "36KB" },
     { "path": "./dist/base-account-sdk*.js", "maxSize": "207KB" },
diff --git a/packages/clerk-js/src/core/__tests__/clerk.protect-params.test.ts b/packages/clerk-js/src/core/__tests__/clerk.protect-params.test.ts
new file mode 100644
index 00000000000..8344dcf1b66
--- /dev/null
+++ b/packages/clerk-js/src/core/__tests__/clerk.protect-params.test.ts
@@ -0,0 +1,101 @@
+import type { ProtectAssertion } from '@clerk/shared/types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { Clerk } from '../clerk';
+
+/**
+ * Two independent Protect features feed the single `getProtectParams` hook the FAPI client calls:
+ * the application-supplied assertion, and the server-configured session token. They are wired in
+ * the same expression, so collapsing it to either one alone still compiles, still type-checks, and
+ * silently stops sending the other's params — a degradation with nothing to see. These tests pin
+ * the hook to the union.
+ */
+
+const getRequestParams = vi.fn();
+
+vi.mock('../protect', () => ({
+  Protect: class {
+    load = vi.fn();
+    getRequestParams = getRequestParams;
+  },
+}));
+
+const { capturedOptions } = vi.hoisted(() => ({ capturedOptions: { current: undefined as any } }));
+
+vi.mock('../fapiClient', async importOriginal => {
+  const actual = await importOriginal<typeof import('../fapiClient')>();
+  return {
+    ...actual,
+    createFapiClient: (options: any) => {
+      capturedOptions.current = options;
+      return actual.createFapiClient(options);
+    },
+  };
+});
+
+const productionPublishableKey = 'pk_live_Y2xlcmsuYWJjZWYuMTIzNDUucHJvZC5sY2xjbGVyay5jb20k';
+
+const sessionParams = { __clerk_protect_token: 'v1.payload.mac', __clerk_protect_status: 'ok' };
+const assertionParams = { __clerk_protect_assertion: 'token-abc' };
+
+/** The hook a freshly constructed Clerk handed to the FAPI client. */
+const hookFor = (assertion?: ProtectAssertion) => {
+  const clerk = new Clerk(productionPublishableKey);
+  if (assertion !== undefined) {
+    clerk.setProtectAssertion(assertion);
+  }
+  return capturedOptions.current.getProtectParams as () => Promise<Record<string, string | undefined> | undefined>;
+};
+
+describe('Clerk getProtectParams', () => {
+  beforeEach(() => {
+    getRequestParams.mockReset();
+    capturedOptions.current = undefined;
+  });
+
+  it('is wired into the FAPI client', () => {
+    expect(hookFor()).toBeTypeOf('function');
+  });
+
+  it('unions the assertion and the session token', async () => {
+    getRequestParams.mockResolvedValue(sessionParams);
+
+    await expect(hookFor('token-abc')()).resolves.toEqual({ ...assertionParams, ...sessionParams });
+  });
+
+  it('sends the session token when no assertion is configured', async () => {
+    getRequestParams.mockResolvedValue(sessionParams);
+
+    await expect(hookFor()()).resolves.toEqual(sessionParams);
+  });
+
+  it('sends the assertion when the session contributes nothing', async () => {
+    getRequestParams.mockResolvedValue(undefined);
+
+    await expect(hookFor('token-abc')()).resolves.toEqual(assertionParams);
+  });
+
+  // Returning `{}` would make every sign-in body differ from what it was before the feature existed.
+  it('resolves to undefined when neither contributes anything', async () => {
+    getRequestParams.mockResolvedValue(undefined);
+
+    await expect(hookFor()()).resolves.toBeUndefined();
+  });
+
+  // Neither feature may take the other down with it.
+  it('keeps the session token when the assertion resolver throws', async () => {
+    getRequestParams.mockResolvedValue(sessionParams);
+
+    await expect(
+      hookFor(() => {
+        throw new Error('boom');
+      })(),
+    ).resolves.toEqual(sessionParams);
+  });
+
+  it('keeps the assertion when acquiring the session token rejects', async () => {
+    getRequestParams.mockRejectedValue(new DOMException('storage is blocked', 'SecurityError'));
+
+    await expect(hookFor('token-abc')()).resolves.toEqual(assertionParams);
+  });
+});
diff --git a/packages/clerk-js/src/core/__tests__/fapiClient.test.ts b/packages/clerk-js/src/core/__tests__/fapiClient.test.ts
index 865ff7e866d..1c781e5a29f 100644
--- a/packages/clerk-js/src/core/__tests__/fapiClient.test.ts
+++ b/packages/clerk-js/src/core/__tests__/fapiClient.test.ts
@@ -385,67 +385,84 @@ describe('request', () => {
   });
 
   describe('Protect params', () => {
-    const protectParams = { __clerk_protect_assertion: 'token-abc' };
-    const clientWithProtect = createFapiClient({
-      ...baseFapiClientOptions,
-      getProtectParams: () => Promise.resolve(protectParams),
+    // Two independent features feed this one hook — an application-supplied assertion and the
+    // server-configured session token — so the fixture carries params from both.
+    const protectParams = {
+      __clerk_protect_assertion: 'token-abc',
+      __clerk_protect_token: 'v1.payload.mac',
+      __clerk_protect_status: 'ok',
+      __clerk_protect_cid: `1-${'a'.repeat(26)}-${'b'.repeat(26)}`,
+    };
+    const expectedProtectQuery =
+      '__clerk_protect_assertion=token-abc&__clerk_protect_token=v1.payload.mac&__clerk_protect_status=ok' +
+      `&__clerk_protect_cid=${protectParams.__clerk_protect_cid}`;
+
+    let getProtectParams: Mock;
+    let clientWithProtect: ReturnType<typeof createFapiClient>;
+
+    beforeEach(() => {
+      getProtectParams = vi.fn().mockResolvedValue(protectParams);
+      clientWithProtect = createFapiClient({ ...baseFapiClientOptions, getProtectParams });
     });
 
-    it.each([
-      ['/client/sign_ins'],
-      ['/client/sign_ins/sia_123/attempt_first_factor'],
-      ['/client/sign_ups'],
-      ['/client/sign_ups/sua_123/attempt_verification'],
-    ])('attaches them to POST %s', async path => {
-      await clientWithProtect.request({ path, method: 'POST', body: { identifier: 'user@example.com' } as any });
+    const bodyOf = () => (fetch as Mock).mock.calls[0][1].body as string;
 
-      expect(fetch).toHaveBeenCalledWith(
-        expect.any(URL),
-        expect.objectContaining({
-          body: 'identifier=user%40example.com&__clerk_protect_assertion=token-abc',
-        }),
-      );
+    it.each([
+      '/client/sign_ins',
+      '/client/sign_ups',
+      '/client/sign_ins/sia_123/attempt_first_factor',
+      '/client/sign_ups/sua_123/attempt_verification',
+    ])('merges them into the form-encoded body of %s', async path => {
+      await clientWithProtect.request({ path, method: 'POST', body: { identifier: 'nick@clerk.dev' } as any });
+
+      expect(bodyOf()).toBe(`identifier=nick%40clerk.dev&${expectedProtectQuery}`);
+      // A signed credential must never land in the URL, which is logged all along the path.
+      expect((fetch as Mock).mock.calls[0][0].toString()).not.toContain('__clerk_protect');
     });
 
-    it('attaches them when the request has no body of its own', async () => {
-      await clientWithProtect.request({ path: '/client/sign_ins', method: 'POST' });
+    it('adds no request headers', async () => {
+      await clientWithProtect.request({ path: '/client/sign_ins', method: 'POST', body: {} as any });
 
-      expect(fetch).toHaveBeenCalledWith(
-        expect.any(URL),
-        expect.objectContaining({ body: '__clerk_protect_assertion=token-abc' }),
-      );
+      const headers = (fetch as Mock).mock.calls[0][1].headers as Headers;
+      expect([...headers.keys()]).toEqual(['content-type']);
     });
 
-    // All lower-case, so the camel-to-snake body key encoder has nothing to rewrite.
-    it('does not mangle the param name', async () => {
-      await clientWithProtect.request({ path: '/client/sign_ins', method: 'POST' });
+    // Also pins the param names against the camel-to-snake body key encoder: they are all
+    // lower-case, so it has nothing to rewrite.
+    it('populates the body even when the request had none', async () => {
+      await clientWithProtect.request({ path: '/client/sign_ups', method: 'POST' });
 
-      const [, init] = (fetch as Mock).mock.calls.at(-1)!;
-      expect(init.body).toBe('__clerk_protect_assertion=token-abc');
+      expect(bodyOf()).toBe(expectedProtectQuery);
     });
 
-    it.each([
-      ['a GET', 'GET', '/client/sign_ins'],
-      ['an unrelated path', 'POST', '/client/sessions'],
-      ['a path that merely shares a prefix', 'POST', '/client/sign_ins_other'],
-    ])('does not attach them to %s', async (_label, method, path) => {
-      await clientWithProtect.request({ path, method: method as any, body: { a: 'b' } as any });
-
-      const [, init] = (fetch as Mock).mock.calls.at(-1)!;
-      expect(init.body ?? '').not.toContain('__clerk_protect_assertion');
+    it.each(['/client', '/client/sessions', '/environment', '/client/sign_insomething', '/client/sign_ins_other'])(
+      'leaves %s alone',
+      async path => {
+        await clientWithProtect.request({ path, method: 'POST', body: { foo: 'bar' } as any });
+
+        expect(bodyOf()).toBe('foo=bar');
+        expect(getProtectParams).not.toHaveBeenCalled();
+      },
+    );
+
+    it('leaves GET requests alone', async () => {
+      await clientWithProtect.request({ path: '/client/sign_ins', method: 'GET' });
+
+      expect(getProtectParams).not.toHaveBeenCalled();
     });
 
     // Spreading a FormData would discard the caller's payload, so non-plain bodies are left alone.
-    it('leaves a FormData body untouched', async () => {
+    it('leaves a FormData body alone', async () => {
       const formData = new FormData();
-      formData.append('identifier', 'user@example.com');
+      formData.append('identifier', 'nick@clerk.dev');
 
       await clientWithProtect.request({ path: '/client/sign_ins', method: 'POST', body: formData });
 
-      expect(fetch).toHaveBeenCalledWith(expect.any(URL), expect.objectContaining({ body: formData }));
+      expect((fetch as Mock).mock.calls[0][1].body).toBe(formData);
+      expect(getProtectParams).not.toHaveBeenCalled();
     });
 
-    it('leaves a string body untouched', async () => {
+    it('leaves a string body alone', async () => {
       // text/plain keeps the form-urlencoded encoder out of it.
       await clientWithProtect.request({
         path: '/client/sign_ins',
@@ -454,38 +471,44 @@ describe('request', () => {
         headers: { 'content-type': 'text/plain' },
       });
 
-      expect(fetch).toHaveBeenCalledWith(expect.any(URL), expect.objectContaining({ body: 'raw string body' }));
+      expect(bodyOf()).toBe('raw string body');
+      expect(getProtectParams).not.toHaveBeenCalled();
     });
 
-    // Protect may influence a sign-in but must never fail one.
-    it('sends the request unchanged when resolving the params rejects', async () => {
-      const failing = createFapiClient({
-        ...baseFapiClientOptions,
-        getProtectParams: () => Promise.reject(new Error('boom')),
-      });
+    // Merging into any of these would spread away the caller's payload rather than add to it.
+    it.each([
+      ['a Blob', () => new Blob(['payload'])],
+      ['an array', () => [1, 2, 3]],
+      ['a URLSearchParams', () => new URLSearchParams({ identifier: 'nick@clerk.dev' })],
+    ])('leaves %s body alone', async (_label, makeBody) => {
+      await clientWithProtect.request({ path: '/client/sign_ins', method: 'POST', body: makeBody() as any });
+
+      expect(getProtectParams).not.toHaveBeenCalled();
+      expect(String((fetch as Mock).mock.calls[0][1].body)).not.toContain('__clerk_protect');
+    });
 
-      await expect(
-        failing.request({ path: '/client/sign_ins', method: 'POST', body: { identifier: 'a' } as any }),
-      ).resolves.toBeTruthy();
+    it('sends nothing extra when the instance contributes no params', async () => {
+      getProtectParams.mockResolvedValue(undefined);
 
-      expect(fetch).toHaveBeenCalledWith(expect.any(URL), expect.objectContaining({ body: 'identifier=a' }));
-    });
+      await clientWithProtect.request({ path: '/client/sign_ins', method: 'POST', body: { foo: 'bar' } as any });
 
-    it('sends the request unchanged when there are no params', async () => {
-      const none = createFapiClient({
-        ...baseFapiClientOptions,
-        getProtectParams: () => Promise.resolve(undefined),
-      });
+      expect(bodyOf()).toBe('foo=bar');
+    });
 
-      await none.request({ path: '/client/sign_ins', method: 'POST', body: { identifier: 'a' } as any });
+    it('still sends the request when resolving the params rejects', async () => {
+      getProtectParams.mockRejectedValue(new DOMException('storage is blocked', 'SecurityError'));
 
-      expect(fetch).toHaveBeenCalledWith(expect.any(URL), expect.objectContaining({ body: 'identifier=a' }));
+      // Protect can degrade a sign-in but must never fail one before it is even sent.
+      await expect(
+        clientWithProtect.request({ path: '/client/sign_ins', method: 'POST', body: { foo: 'bar' } as any }),
+      ).resolves.toBeDefined();
+      expect(bodyOf()).toBe('foo=bar');
     });
 
     it('is inert when no hook is configured', async () => {
       await fapiClient.request({ path: '/client/sign_ins', method: 'POST', body: { identifier: 'a' } as any });
 
-      expect(fetch).toHaveBeenCalledWith(expect.any(URL), expect.objectContaining({ body: 'identifier=a' }));
+      expect(bodyOf()).toBe('identifier=a');
     });
   });
 
diff --git a/packages/clerk-js/src/core/__tests__/protect.test.ts b/packages/clerk-js/src/core/__tests__/protect.test.ts
new file mode 100644
index 00000000000..683c4420373
--- /dev/null
+++ b/packages/clerk-js/src/core/__tests__/protect.test.ts
@@ -0,0 +1,194 @@
+import type { ProtectLoader } from '@clerk/shared/types';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { Protect } from '../protect';
+import { __internal_resetProtectStorage } from '../protectSession';
+import type { Environment } from '../resources';
+
+const environment = (loaders: unknown[]): Environment => ({ protectConfig: { loaders } }) as unknown as Environment;
+
+/**
+ * No `src`: jsdom fetches real URLs, which fires `error` and races the events we drive here.
+ * `type=module` keeps it on the event-driven path regardless, which is what the served loader is.
+ */
+const loader = (overrides: Partial<ProtectLoader> = {}): ProtectLoader => ({
+  target: 'head',
+  type: 'script',
+  attributes: { 'data-cid': '{cid}', type: 'module' },
+  token_timeout_ms: 200,
+  ...overrides,
+});
+
+const nowSeconds = () => Math.floor(Date.now() / 1_000);
+
+/** The token loader is injected under the acquisition lock, so it appears a few ticks in. */
+const injected = async (selector: string): Promise<Element> => {
+  for (let i = 0; i < 100; i++) {
+    const element = document.head.querySelector(selector);
+    if (element) {
+      return element;
+    }
+    await new Promise(resolve => setTimeout(resolve, 0));
+  }
+  throw new Error(`nothing matched ${selector}`);
+};
+
+const serveInline = (element: Element, overrides: Record<string, unknown> = {}) => {
+  (globalThis as unknown as Record<string, unknown>).__clerk_specter = {
+    v: 3,
+    id: '11111111-2222-3333-4444-555555555555',
+    cid: element.getAttribute('data-cid'),
+    ready: Promise.resolve({ token: 'v1.payload.mac', exp: nowSeconds() + 43_200 }),
+    ...overrides,
+  };
+  element.dispatchEvent(new Event('load'));
+};
+
+beforeEach(() => {
+  localStorage.clear();
+  __internal_resetProtectStorage();
+  document.head.innerHTML = '';
+  document.body.innerHTML = '';
+  delete (globalThis as unknown as Record<string, unknown>).__clerk_specter;
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  localStorage.clear();
+  __internal_resetProtectStorage();
+  delete (globalThis as unknown as Record<string, unknown>).__clerk_specter;
+});
+
+describe('Protect.load', () => {
+  it('does nothing without a protect config', () => {
+    new Protect().load(environment([]));
+    expect(document.head.querySelector('script')).toBeNull();
+    expect(localStorage.getItem('__clerk_protect_pid')).toBeNull();
+  });
+
+  it('applies an untemplated loader unchanged and reports no params', async () => {
+    const protect = new Protect();
+    protect.load(
+      environment([
+        { target: 'head', type: 'script', attributes: { 'data-loader': 'https://loader.example.com/ins_2abc.js' } },
+      ]),
+    );
+
+    expect(document.head.querySelector('script')?.getAttribute('data-loader')).toBe(
+      'https://loader.example.com/ins_2abc.js',
+    );
+    await expect(protect.getRequestParams()).resolves.toBeUndefined();
+    expect(localStorage.getItem('__clerk_protect_pid')).toBeNull();
+  });
+
+  it('substitutes the placeholders it recognises and leaves the rest verbatim', async () => {
+    const protect = new Protect();
+    protect.load(
+      environment([
+        loader({
+          attributes: {
+            // The instance id is baked into the config the server serves, not interpolated here.
+            'data-src': 'https://loader.example.com/ins_2abc/{cid}/loader.js',
+            'data-pid': '{pid}',
+            'data-rid': '{rid}',
+            'data-unknown': '{whatever}',
+            'data-count': 3,
+          },
+        }),
+      ]),
+    );
+
+    const element = await injected('script');
+    const pid = element.getAttribute('data-pid') as string;
+    const rid = element.getAttribute('data-rid') as string;
+
+    expect(pid).toMatch(/^[a-z2-7]{26}$/);
+    expect(rid).toMatch(/^[a-z2-7]{26}$/);
+    expect(element.getAttribute('data-src')).toBe(`https://loader.example.com/ins_2abc/1-${pid}-${rid}/loader.js`);
+    expect(element.getAttribute('data-unknown')).toBe('{whatever}');
+    expect(element.getAttribute('data-count')).toBe('3');
+  });
+
+  it('substitutes placeholders in textContent as well as attributes', async () => {
+    const protect = new Protect();
+    protect.load(environment([loader({ text_content: 'window.__vendor_cid = "{cid}";' })]));
+
+    const element = await injected('script');
+    expect(element.textContent).toBe(`window.__vendor_cid = "${element.getAttribute('data-cid')}";`);
+    expect(element.textContent).not.toContain('{cid}');
+  });
+
+  it('never interpolates {instance_id}', async () => {
+    const protect = new Protect();
+    protect.load(environment([loader({ attributes: { 'data-src': '{instance_id}/{cid}.js' } })]));
+
+    expect((await injected('script')).getAttribute('data-src')).toContain('{instance_id}');
+  });
+
+  it('attaches the token once it has been acquired', async () => {
+    const protect = new Protect();
+    protect.load(environment([loader()]));
+
+    serveInline(await injected('script'));
+
+    await expect(protect.getRequestParams()).resolves.toMatchObject({
+      __clerk_protect_token: 'v1.payload.mac',
+      __clerk_protect_status: 'ok',
+    });
+  });
+
+  it('still applies the other loaders when a token for this browser session is shared', async () => {
+    localStorage.setItem(
+      '__clerk_protect_st',
+      JSON.stringify({ token: 'v1.cached.mac', exp: nowSeconds() + 43_200, rid: 'b'.repeat(26), at: Date.now() }),
+    );
+
+    const protect = new Protect();
+    protect.load(
+      environment([
+        loader({ attributes: { 'data-role': 'detection' } }),
+        loader({ attributes: { 'data-cid': '{cid}', 'data-role': 'token' } }),
+      ]),
+    );
+
+    // Acquisition happens once per browser session, so the token loader is skipped…
+    expect(document.head.querySelector('[data-role="token"]')).toBeNull();
+    // …but the detection loader has its own job and runs on every page load regardless.
+    expect(document.head.querySelector('[data-role="detection"]')).not.toBeNull();
+    await expect(protect.getRequestParams()).resolves.toMatchObject({ __clerk_protect_token: 'v1.cached.mac' });
+  });
+
+  it('does not apply a loader that is outside its rollout', async () => {
+    vi.spyOn(Math, 'random').mockReturnValue(0.9);
+
+    const protect = new Protect();
+    protect.load(environment([loader({ rollout: 0.1 })]));
+
+    expect(document.head.querySelector('script')).toBeNull();
+    // Out of rollout means Protect is off for this browser, so there is nothing to report either.
+    await expect(protect.getRequestParams()).resolves.toBeUndefined();
+  });
+
+  it('reports script_error when the loader element fails to load', async () => {
+    const protect = new Protect();
+    protect.load(environment([loader({ token_timeout_ms: 5_000 })]));
+
+    (await injected('script')).dispatchEvent(new Event('error'));
+
+    await expect(protect.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'script_error' });
+  });
+
+  it('drops a malformed loader entry without failing the rest of the load', async () => {
+    const protect = new Protect();
+
+    // The config is server-controlled and cached; a bad entry must not take Clerk.load() down.
+    expect(() => protect.load(environment([null, loader({ attributes: { 'data-role': 'good' } })]))).not.toThrow();
+
+    expect(document.head.querySelector('[data-role="good"]')).not.toBeNull();
+  });
+
+  it('survives a loader config that is not an array of objects at all', () => {
+    const protect = new Protect();
+    expect(() => protect.load(environment(['nope', 42, undefined]))).not.toThrow();
+  });
+});
diff --git a/packages/clerk-js/src/core/__tests__/protectSession.test.ts b/packages/clerk-js/src/core/__tests__/protectSession.test.ts
new file mode 100644
index 00000000000..bb8056d59e9
--- /dev/null
+++ b/packages/clerk-js/src/core/__tests__/protectSession.test.ts
@@ -0,0 +1,817 @@
+import type { ProtectLoader } from '@clerk/shared/types';
+import { afterEach, beforeEach, describe, expect, it, type Mock, vi } from 'vitest';
+
+import type { ApplyLoader } from '../protectSession';
+import {
+  __internal_resetProtectStorage,
+  buildCid,
+  CID_REGEX,
+  clampTimeout,
+  encodeBase32,
+  interpolatePlaceholders,
+  ProtectSession,
+} from '../protectSession';
+
+const LOADER_SRC = 'https://loader.example.com/ins_2abc/{cid}/loader.js';
+
+/**
+ * No `src` by default: jsdom runs with `resources: 'usable'`, so a real URL is actually fetched
+ * and fires `error` on its own schedule, racing the events these tests need to drive themselves.
+ * `type=module` keeps it on the event-driven path regardless, which is what the served loader is.
+ */
+const loader = (overrides: Partial<ProtectLoader> = {}): ProtectLoader => ({
+  target: 'head',
+  type: 'script',
+  attributes: { 'data-cid': '{cid}', type: 'module' },
+  token_timeout_ms: 200,
+  ...overrides,
+});
+
+const nowSeconds = () => Math.floor(Date.now() / 1_000);
+const tick = () => new Promise(resolve => setTimeout(resolve, 0));
+
+/**
+ * A store entry exactly as `writeStoredToken` would have written it. Tests override only the
+ * field under test, so a rejection is provably about that field and not about a malformed
+ * fixture — every one of these cases is asserting *why* an entry was rejected.
+ */
+const storedEntry = (overrides: Record<string, unknown> = {}) =>
+  JSON.stringify({
+    token: 'v1.cached.mac',
+    exp: nowSeconds() + 43_200,
+    rid: 'b'.repeat(26),
+    at: Date.now(),
+    ...overrides,
+  });
+
+/**
+ * Stands in for `Protect.applyLoader`, handing the test the element the session is waiting on so
+ * it can play the part of the browser and fire `load` or `error`.
+ */
+const harness = () => {
+  const elements: HTMLElement[] = [];
+  const applyLoader: ApplyLoader = (config, placeholders) => {
+    const element = document.createElement(config.type || 'script');
+    for (const [key, value] of Object.entries(config.attributes ?? {})) {
+      element.setAttribute(key, interpolatePlaceholders(String(value), placeholders));
+    }
+    document.head.appendChild(element);
+    elements.push(element);
+    return element;
+  };
+
+  const injected = async (count = 1): Promise<HTMLElement> => {
+    for (let i = 0; i < 100 && elements.length < count; i++) {
+      await tick();
+    }
+    return elements[count - 1];
+  };
+
+  return { applyLoader, elements, injected };
+};
+
+const session = (loaders: ProtectLoader[], tokensInvalidBefore?: number) => {
+  const h = harness();
+  return { session: ProtectSession.create(loaders, h.applyLoader, tokensInvalidBefore), ...h };
+};
+
+/** What the server does: the script body assigns the global, then the element fires `load`. */
+const serveInline = (element: HTMLElement, overrides: Record<string, unknown> = {}) => {
+  (globalThis as unknown as Record<string, unknown>).__clerk_specter = {
+    v: 3,
+    id: '11111111-2222-3333-4444-555555555555',
+    ready: Promise.resolve({ token: 'v1.payload.mac', exp: nowSeconds() + 43_200 }),
+    ...overrides,
+  };
+  element.dispatchEvent(new Event('load'));
+};
+
+/** The shape served to a build that asserts no version: no cid, no `ready`. */
+const serveBaseShape = (element: HTMLElement) => {
+  (globalThis as unknown as Record<string, unknown>).__clerk_specter = {
+    v: 1,
+    id: '11111111-2222-3333-4444-555555555555',
+  };
+  element.dispatchEvent(new Event('load'));
+};
+
+const tokenResponse = (token = 'v1.payload.mac', expInSeconds = nowSeconds() + 43_200) => ({
+  status: 200,
+  json: () => Promise.resolve({ token, exp: expInSeconds }),
+});
+
+const retryResponse = (retryInMs = 10) => ({
+  status: 202,
+  json: () => Promise.resolve({ retry_in_ms: retryInMs }),
+});
+
+const errorResponse = (status: number) => ({
+  status,
+  json: () => Promise.resolve({ status: 'unknown_cid' }),
+});
+
+const originalFetch = global.fetch;
+
+beforeEach(() => {
+  localStorage.clear();
+  __internal_resetProtectStorage();
+  document.head.innerHTML = '';
+  delete (globalThis as unknown as Record<string, unknown>).__clerk_specter;
+  global.fetch = vi.fn(() => Promise.resolve(tokenResponse())) as unknown as typeof fetch;
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  global.fetch = originalFetch;
+  localStorage.clear();
+  __internal_resetProtectStorage();
+  delete (globalThis as unknown as Record<string, unknown>).__clerk_specter;
+});
+
+describe('encodeBase32', () => {
+  it('emits 26 lowercase unpadded base32 chars for 128 bits', () => {
+    expect(encodeBase32(new Uint8Array(16))).toBe('aaaaaaaaaaaaaaaaaaaaaaaaaa');
+    expect(encodeBase32(new Uint8Array(16).fill(0xff))).toBe('77777777777777777777777774');
+  });
+
+  it('matches the RFC 4648 alphabet', () => {
+    // The canonical base32 of 0x00..0x0f is AAAQEAYEAUDAOCAJBIFQYDIOB4======
+    expect(encodeBase32(Uint8Array.from({ length: 16 }, (_, i) => i))).toBe('aaaqeayeaudaocajbifqydiob4');
+  });
+});
+
+describe('interpolatePlaceholders', () => {
+  it('substitutes the closed set', () => {
+    expect(
+      interpolatePlaceholders('{sdkver}/{cid}/{pid}/{rid}', {
+        cid: 'c',
+        pid: 'p',
+        rid: 'r',
+        sdkver: '1.2.3',
+      }),
+    ).toBe('1.2.3/c/p/r');
+  });
+
+  it('leaves an unrecognised placeholder verbatim', () => {
+    // `{instance_id}` is not in the set and must not be: the instance id is the server's to place
+    // into the config it serves, never something the client interpolates.
+    expect(interpolatePlaceholders('{cid}/{nope}/{PID}/{instance_id}', { cid: 'c' })).toBe(
+      'c/{nope}/{PID}/{instance_id}',
+    );
+  });
+
+  it('leaves a recognised placeholder verbatim when there is no value for it', () => {
+    expect(interpolatePlaceholders('{cid}/{sdkver}', { cid: 'c' })).toBe('c/{sdkver}');
+  });
+});
+
+describe('ProtectSession.create', () => {
+  it('returns nothing when no loader references a placeholder', () => {
+    const { session: created } = session([loader({ attributes: { src: 'https://loader.example.com/loader.js' } })]);
+
+    expect(created).toBeUndefined();
+    // An instance not using the correlation id stores nothing in the user's browser.
+    expect(localStorage.getItem('__clerk_protect_pid')).toBeNull();
+  });
+
+  it('mints a 55-char correlation id and persists only the pid', () => {
+    const { session: created } = session([loader()]);
+    const cid = created?.placeholders().cid as string;
+
+    expect(cid).toMatch(CID_REGEX);
+    expect(cid).toHaveLength(55);
+    expect(localStorage.getItem('__clerk_protect_pid')).toBe(created?.placeholders().pid);
+  });
+
+  it('reuses the persisted pid and mints a fresh rid per run', () => {
+    const first = session([loader()]).session?.placeholders();
+    const second = session([loader()]).session?.placeholders();
+
+    expect(second?.pid).toBe(first?.pid);
+    expect(second?.rid).not.toBe(first?.rid);
+    expect(buildCid(second?.pid as string, second?.rid as string)).toBe(second?.cid);
+  });
+
+  it('stores nothing for a loader that only templates the SDK version', async () => {
+    const { session: created, elements } = session([
+      loader({ attributes: { src: 'https://loader.example.com/{sdkver}/loader.js' } }),
+    ]);
+
+    // The SDK version needs no minted identity, so none is planted for it.
+    expect(created?.placeholders().pid).toBeUndefined();
+    expect(localStorage.getItem('__clerk_protect_pid')).toBeNull();
+
+    created?.start();
+    await expect(created?.getRequestParams()).resolves.toBeUndefined();
+    expect(elements).toHaveLength(0);
+  });
+
+  it('reports unsupported when there is no CSPRNG', async () => {
+    const originalGetRandomValues = crypto.getRandomValues;
+    // @ts-expect-error -- deliberately removing the API to exercise the unsupported path
+    crypto.getRandomValues = undefined;
+
+    try {
+      const { session: created, elements } = session([loader()]);
+      created?.start();
+
+      await expect(created?.getRequestParams()).resolves.toEqual({ __clerk_protect_status: 'unsupported' });
+      expect(elements).toHaveLength(0);
+      // Nothing usable to interpolate, so the loader keeps its literal placeholder.
+      expect(created?.placeholders().cid).toBeUndefined();
+    } finally {
+      crypto.getRandomValues = originalGetRandomValues;
+    }
+  });
+});
+
+describe('ProtectSession inline token', () => {
+  it('hands the correlation id to the loader it injects', async () => {
+    const { session: created, injected } = session([loader({ attributes: { src: LOADER_SRC } })]);
+    created?.start();
+
+    expect((await injected()).getAttribute('src')).toBe(
+      `https://loader.example.com/ins_2abc/${created?.placeholders().cid}/loader.js`,
+    );
+  });
+
+  it('takes the token the loader was served with, and shares it through localStorage', async () => {
+    const { session: created, injected } = session([loader()]);
+    created?.start();
+
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toEqual({
+      __clerk_protect_token: 'v1.payload.mac',
+      __clerk_protect_status: 'ok',
+      __clerk_protect_cid: created?.placeholders().cid,
+    });
+    expect(JSON.parse(localStorage.getItem('__clerk_protect_st') as string)).toMatchObject({
+      token: 'v1.payload.mac',
+      rid: created?.placeholders().rid,
+    });
+    // The whole point of inline delivery: no second request.
+    expect(global.fetch).not.toHaveBeenCalled();
+  });
+
+  it('ignores a token minted for someone else’s run', async () => {
+    const { session: created, injected } = session([loader()]);
+    created?.start();
+
+    serveInline(await injected(), { cid: buildCid('z'.repeat(26).replace(/z/g, 'a'), 'b'.repeat(26)) });
+
+    await expect(created?.getRequestParams()).resolves.toEqual({
+      __clerk_protect_status: 'no_token',
+      __clerk_protect_cid: created?.placeholders().cid,
+    });
+  });
+
+  it('takes the token from a classic inline script, which fires no load event', async () => {
+    // A `<script>` with no `src` runs during `appendChild` and reports through neither `load` nor
+    // `error`. Waiting on an event that cannot arrive would burn the whole deadline and then
+    // discard a token the script body had already assigned.
+    const { session: created } = session([loader({ attributes: { 'data-cid': '{cid}' } })]);
+    (globalThis as unknown as Record<string, unknown>).__clerk_specter = {
+      cid: created?.placeholders().cid,
+      ready: Promise.resolve({ token: 'v1.payload.mac', exp: nowSeconds() + 43_200 }),
+    };
+
+    created?.start();
+
+    await expect(created?.getRequestParams()).resolves.toEqual({
+      __clerk_protect_token: 'v1.payload.mac',
+      __clerk_protect_status: 'ok',
+      __clerk_protect_cid: created?.placeholders().cid,
+    });
+  });
+
+  it('waits for load on an inline module, which evaluates asynchronously', async () => {
+    // An inline module does fire `load`, so settling early would read the global before the module
+    // body had written it.
+    const { session: created, injected } = session([loader()]);
+    created?.start();
+
+    const element = await injected();
+    await tick();
+    // Nothing has been served yet; settling now would report no_token.
+    serveInline(element, { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({
+      __clerk_protect_token: 'v1.payload.mac',
+      __clerk_protect_status: 'ok',
+    });
+  });
+
+  it('substitutes the SDK version, which is what earns the current shape', async () => {
+    const { session: created, injected } = session([
+      loader({ attributes: { 'data-cid': '{cid}', 'data-v': '{sdkver}' } }),
+    ]);
+    created?.start();
+
+    expect((await injected()).getAttribute('data-v')).toBe(__PKG_VERSION__);
+  });
+
+  it('reports no_token when the script publishes nothing', async () => {
+    const { session: created, injected } = session([loader()]);
+    created?.start();
+
+    (await injected()).dispatchEvent(new Event('load'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'no_token' });
+  });
+
+  it('reports no_token for the base shape an older server serves', async () => {
+    const { session: created, injected } = session([loader()]);
+    created?.start();
+
+    // Until the server half deploys this is the answer for every load, so it must not read as a
+    // timeout — that would make a normal rollout look like an outage.
+    serveBaseShape(await injected());
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'no_token' });
+  });
+
+  it('reports no_token when ready resolves without one', async () => {
+    const { session: created, injected } = session([loader()]);
+    created?.start();
+
+    serveInline(await injected(), {
+      cid: created?.placeholders().cid,
+      ready: Promise.resolve({ status: 'no_token' }),
+    });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'no_token' });
+  });
+
+  it('reports timeout when ready never settles', async () => {
+    const { session: created, injected } = session([loader({ token_timeout_ms: 60 })]);
+    created?.start();
+
+    serveInline(await injected(), { cid: created?.placeholders().cid, ready: new Promise(() => {}) });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'timeout' });
+  });
+
+  it('survives a ready that rejects, which the contract says it never does', async () => {
+    const rejected = Promise.reject(new Error('loader blew up'));
+    rejected.catch(() => undefined);
+
+    const { session: created, injected } = session([loader()]);
+    created?.start();
+
+    serveInline(await injected(), { cid: created?.placeholders().cid, ready: rejected });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'no_token' });
+  });
+
+  it('reports script_error when the loader element fails to load', async () => {
+    const { session: created, injected } = session([loader({ token_timeout_ms: 5_000 })]);
+    created?.start();
+
+    (await injected()).dispatchEvent(new Event('error'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'script_error' });
+  });
+
+  it('reports timeout when the loader never settles', async () => {
+    const { session: created, injected } = session([loader({ token_timeout_ms: 40 })]);
+    created?.start();
+    await injected();
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'timeout' });
+  });
+
+  it('reuses a fresh token without injecting the loader at all', async () => {
+    localStorage.setItem('__clerk_protect_st', storedEntry());
+
+    const { session: created, elements } = session([loader()]);
+    expect(created?.hasFreshToken()).toBe(true);
+    created?.start();
+
+    await expect(created?.getRequestParams()).resolves.toEqual({
+      __clerk_protect_token: 'v1.cached.mac',
+      __clerk_protect_status: 'ok',
+      // The cid names the run the token was minted for, which is not this tab's run.
+      __clerk_protect_cid: buildCid(created?.placeholders().pid as string, 'b'.repeat(26)),
+    });
+    expect(elements).toHaveLength(0);
+  });
+
+  it('ignores a stored token that has expired', async () => {
+    localStorage.setItem('__clerk_protect_st', storedEntry({ token: 'v1.stale.mac', exp: nowSeconds() - 1 }));
+
+    const { session: created, injected } = session([loader()]);
+    expect(created?.hasFreshToken()).toBe(false);
+
+    created?.start();
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_token: 'v1.payload.mac' });
+  });
+
+  it('ignores a planted token claiming more life than we ever mint', async () => {
+    localStorage.setItem(
+      '__clerk_protect_st',
+      storedEntry({ token: 'v1.planted.mac', exp: nowSeconds() + 10 * 365 * 24 * 60 * 60 }),
+    );
+
+    const { session: created, injected } = session([loader()]);
+    // A page-writable store must not be able to suppress the loader for ever.
+    expect(created?.hasFreshToken()).toBe(false);
+
+    created?.start();
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_token: 'v1.payload.mac' });
+  });
+
+  it('ignores a planted value that could never have been a mint', async () => {
+    localStorage.setItem('__clerk_protect_st', storedEntry({ token: 'not-a-token' }));
+
+    const { session: created, injected } = session([loader()]);
+    // Shape alone proves nothing — only the server can tell a mint from a well-formed forgery —
+    // but a corrupt entry must start a fresh run rather than suppress acquisition until it expires.
+    expect(created?.hasFreshToken()).toBe(false);
+
+    created?.start();
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_token: 'v1.payload.mac' });
+  });
+
+  it('ignores an entry older than any token we would ever be issued', async () => {
+    // `exp` is server truth compared against this browser's clock, so a clock running slow keeps
+    // a lapsed entry alive. Elapsed local time is measured on one clock, so it still catches it.
+    localStorage.setItem(
+      '__clerk_protect_st',
+      storedEntry({ at: Date.now() - 25 * 60 * 60 * 1_000, exp: nowSeconds() + 43_200 }),
+    );
+
+    const { session: created, injected } = session([loader()]);
+    expect(created?.hasFreshToken()).toBe(false);
+
+    created?.start();
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_token: 'v1.payload.mac' });
+  });
+
+  it('ignores an entry stamped in the future, which means the clock moved backwards', () => {
+    localStorage.setItem('__clerk_protect_st', storedEntry({ at: Date.now() + 60 * 60 * 1_000 }));
+
+    const { session: created } = session([loader()]);
+    expect(created?.hasFreshToken()).toBe(false);
+  });
+
+  it('does not send a token that would lapse in flight', async () => {
+    // Inside the send margin: still unexpired, but not worth shipping — it could only fail
+    // verification by the time it arrived.
+    localStorage.setItem('__clerk_protect_st', storedEntry({ exp: nowSeconds() + 2 }));
+
+    const { session: created } = session([loader()]);
+    expect(created?.hasFreshToken()).toBe(false);
+
+    const params = await created?.getRequestParams();
+    expect(params?.__clerk_protect_token).toBeUndefined();
+  });
+
+  it('re-acquires when the configured floor has moved past the stored one', async () => {
+    localStorage.setItem('__clerk_protect_st', storedEntry({ token: 'v1.revoked.mac', floor: 1_000 }));
+
+    // Raising tokens_invalid_before is the recovery lever: a bad mint or a rolled key leaves
+    // browsers holding something the server will not accept, and without this they would keep
+    // sending it for the token's full lifetime.
+    const { session: created, injected } = session([loader()], 2_000);
+    expect(created?.hasFreshToken()).toBe(false);
+
+    created?.start();
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_token: 'v1.payload.mac' });
+  });
+
+  it('keeps a token acquired at or above the configured floor', () => {
+    localStorage.setItem('__clerk_protect_st', storedEntry({ floor: 2_000 }));
+    expect(session([loader()], 2_000).session?.hasFreshToken()).toBe(true);
+  });
+
+  it('keeps cached tokens for an instance that has never set a floor', () => {
+    // An absent floor counts as zero on both sides, so introducing the mechanism must not make
+    // every browser re-acquire at once.
+    localStorage.setItem('__clerk_protect_st', storedEntry());
+    expect(session([loader()]).session?.hasFreshToken()).toBe(true);
+  });
+
+  it('stamps the floor in force onto a token it acquires', async () => {
+    const { session: created, injected } = session([loader()], 2_000);
+    created?.start();
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+    await created?.getRequestParams();
+
+    expect(JSON.parse(localStorage.getItem('__clerk_protect_st') as string)).toMatchObject({ floor: 2_000 });
+  });
+
+  it('reuses a mint whose version this build predates', async () => {
+    localStorage.setItem('__clerk_protect_st', storedEntry({ token: 'v9.cached.mac' }));
+
+    // The shape check must not pin a version. The server may mint ahead of this build, and
+    // rejecting that here would re-run the loader on every page load until the SDK caught up.
+    const { session: created, elements } = session([loader()]);
+    expect(created?.hasFreshToken()).toBe(true);
+    created?.start();
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_token: 'v9.cached.mac' });
+    expect(elements).toHaveLength(0);
+  });
+
+  it('reports nothing at all for a loader that carries no correlation id', async () => {
+    const { session: created, elements } = session([loader({ attributes: { 'data-pid': '{pid}' } })]);
+
+    created?.start();
+    await expect(created?.getRequestParams()).resolves.toBeUndefined();
+    expect(elements).toHaveLength(0);
+  });
+});
+
+describe('ProtectSession upgrade mint', () => {
+  const upgrade = (overrides: Partial<ProtectLoader> = {}) =>
+    loader({ token_url: 'https://loader.example.com/{cid}/token', ...overrides });
+
+  it('fetches the explicitly configured endpoint once the loader has run', async () => {
+    const { session: created, injected } = session([upgrade()]);
+    created?.start();
+
+    (await injected()).dispatchEvent(new Event('load'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'ok' });
+    expect(global.fetch).toHaveBeenCalledWith(
+      `https://loader.example.com/${created?.placeholders().cid}/token`,
+      expect.objectContaining({ credentials: 'omit' }),
+    );
+  });
+
+  it('never derives an endpoint from a loader attribute', async () => {
+    // The cid rides in a data attribute and the src is not a token endpoint; without an explicit
+    // tokenUrl the inline path is the only one, so nothing is fetched.
+    const { session: created, injected } = session([
+      loader({
+        attributes: { 'data-cid': '{cid}', 'data-loader': 'https://cdn.example.com/loader.js', type: 'module' },
+      }),
+    ]);
+    created?.start();
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'ok' });
+    expect(global.fetch).not.toHaveBeenCalled();
+  });
+
+  it('polls through a 202 until the token is minted', async () => {
+    (global.fetch as Mock)
+      .mockImplementationOnce(() => Promise.resolve(retryResponse()))
+      .mockImplementationOnce(() => Promise.resolve(tokenResponse()));
+
+    const { session: created, injected } = session([upgrade({ token_timeout_ms: 1_000 })]);
+    created?.start();
+    (await injected()).dispatchEvent(new Event('load'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'ok' });
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('spends the remaining deadline retrying a transient failure', async () => {
+    (global.fetch as Mock)
+      .mockImplementationOnce(() => Promise.resolve(errorResponse(503)))
+      .mockImplementationOnce(() => Promise.resolve(tokenResponse()));
+
+    const { session: created, injected } = session([upgrade({ token_timeout_ms: 1_000 })]);
+    created?.start();
+    (await injected()).dispatchEvent(new Event('load'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'ok' });
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('reports a non-retryable http status without retrying', async () => {
+    (global.fetch as Mock).mockImplementation(() => Promise.resolve(errorResponse(400)));
+
+    const { session: created, injected } = session([upgrade({ token_timeout_ms: 1_000 })]);
+    created?.start();
+    (await injected()).dispatchEvent(new Event('load'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'http_400' });
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('reports fetch_error when the token endpoint is unreachable', async () => {
+    (global.fetch as Mock).mockImplementation(() => Promise.reject(new TypeError('Failed to fetch')));
+
+    const { session: created, injected } = session([upgrade()]);
+    created?.start();
+    (await injected()).dispatchEvent(new Event('load'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'fetch_error' });
+  });
+
+  it('reports fetch_error when a 200 carries no usable token', async () => {
+    (global.fetch as Mock).mockImplementation(() => Promise.resolve({ status: 200, json: () => Promise.resolve({}) }));
+
+    const { session: created, injected } = session([upgrade()]);
+    created?.start();
+    (await injected()).dispatchEvent(new Event('load'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'fetch_error' });
+  });
+});
+
+describe('ProtectSession storage', () => {
+  it('reads back a token the quota forced into the in-memory fallback', async () => {
+    // Readable but not writable — Safari private browsing, or an exhausted origin quota.
+    vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+      throw new Error('QuotaExceededError');
+    });
+
+    const { session: created, injected } = session([loader()]);
+    created?.start();
+    serveInline(await injected(), { cid: created?.placeholders().cid });
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({
+      __clerk_protect_token: 'v1.payload.mac',
+      __clerk_protect_status: 'ok',
+    });
+  });
+
+  it('falls back to an in-memory pid when localStorage throws outright', async () => {
+    vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
+      throw new Error('storage is blocked');
+    });
+    vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+      throw new Error('storage is blocked');
+    });
+
+    const first = session([loader()]).session;
+    const second = session([loader()]).session;
+
+    expect(first?.placeholders().cid).toMatch(CID_REGEX);
+    // The in-memory fallback still shares the pid across sessions on this page.
+    expect(second?.placeholders().pid).toBe(first?.placeholders().pid);
+  });
+
+  it('keeps one store per origin, not one per instance', async () => {
+    const a = session([loader()]);
+    a.session?.start();
+    serveInline(await a.injected(), { cid: a.session?.placeholders().cid });
+    await expect(a.session?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'ok' });
+
+    // A second session on the same origin reads the same store rather than running its own loader.
+    // The token names the instance that minted it and is verified server-side, so an origin serving
+    // two instances costs a rejected token — never a token honoured for the wrong instance.
+    const b = session([loader()]);
+    expect(b.session?.hasFreshToken()).toBe(true);
+    expect(localStorage.getItem('__clerk_protect_st')).not.toBeNull();
+  });
+});
+
+describe('ProtectSession deadlines', () => {
+  it('honours a deadline that arrived under its wire name', async () => {
+    // The loaders array is assigned straight out of /v1/environment with no case conversion, so a
+    // fixture written as a TS literal agrees with the type by construction and can never catch a
+    // key the server does not send. `token_timeout_ms` was read as `tokenTimeoutMs` and was
+    // therefore always undefined in production while every test passed. Parse the wire shape.
+    const wire = JSON.parse(
+      '{"target":"head","type":"script","attributes":{"data-cid":"{cid}","type":"module"},"token_timeout_ms":50}',
+    ) as ProtectLoader;
+
+    const { session: created } = session([wire]);
+    created?.start();
+
+    const startedAt = Date.now();
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'timeout' });
+    // Misread, this would fall back to the 5s default and be two orders of magnitude out.
+    expect(Date.now() - startedAt).toBeLessThan(1_000);
+  });
+
+  it('holds a sign-in no longer than the deadline, however long acquisition takes', async () => {
+    const { session: created } = session([loader({ token_timeout_ms: 50 })]);
+    created?.start();
+
+    const startedAt = Date.now();
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'timeout' });
+    expect(Date.now() - startedAt).toBeLessThan(1_000);
+  });
+
+  it('starts a fresh run once the cooldown has passed with no token to show for the last one', async () => {
+    const { session: created, injected, elements } = session([loader({ token_timeout_ms: 1_000 })]);
+    created?.start();
+    (await injected()).dispatchEvent(new Event('error'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'script_error' });
+    expect(elements).toHaveLength(1);
+
+    // A tab outlives its token, so a settled failure must not be replayed for the life of the page.
+    const realNow = Date.now();
+    vi.spyOn(Date, 'now').mockImplementation(() => realNow + 31_000);
+
+    const params = created?.getRequestParams();
+    serveInline(await injected(2), { cid: created?.placeholders().cid });
+
+    await expect(params).resolves.toMatchObject({ __clerk_protect_status: 'ok' });
+  });
+
+  it('does not re-run within the cooldown', async () => {
+    const { session: created, injected, elements } = session([loader({ token_timeout_ms: 1_000 })]);
+    created?.start();
+    (await injected()).dispatchEvent(new Event('error'));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'script_error' });
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'script_error' });
+
+    // Repeated sign-in attempts must not turn a failure into a loader-injection loop.
+    expect(elements).toHaveLength(1);
+  });
+
+  it('clamps a server-configured deadline that would stall a sign-in', () => {
+    // `tokenTimeoutMs` is server config with no upper bound of its own, so the ceiling is ours.
+    expect(clampTimeout(120_000)).toBe(10_000);
+    expect(clampTimeout(1_500)).toBe(1_500);
+    expect(clampTimeout(undefined)).toBe(5_000);
+    expect(clampTimeout(0)).toBe(5_000);
+    expect(clampTimeout(-1)).toBe(5_000);
+    expect(clampTimeout('soon')).toBe(5_000);
+    expect(clampTimeout(Number.POSITIVE_INFINITY)).toBe(5_000);
+  });
+});
+
+describe('ProtectSession cross-tab single flight', () => {
+  /**
+   * A serialising Web Locks stand-in. jsdom has no `navigator.locks`, and the `browser-tabs-lock`
+   * fallback is globally mocked to always grant, so without this the double-check inside the lock
+   * would never be exercised.
+   */
+  const installSerialisingLocks = () => {
+    let tail: Promise<unknown> = Promise.resolve();
+    const request = vi.fn((_key: string, _options: unknown, callback: () => Promise<unknown>) => {
+      const result = tail.then(() => callback());
+      tail = result.catch(() => undefined);
+      return result;
+    });
+    Object.defineProperty(navigator, 'locks', { value: { request }, configurable: true });
+    return request;
+  };
+
+  afterEach(() => {
+    delete (navigator as unknown as Record<string, unknown>).locks;
+  });
+
+  it('runs the loader once when several tabs start together', async () => {
+    const request = installSerialisingLocks();
+
+    const a = session([loader({ token_timeout_ms: 1_000 })]);
+    const b = session([loader({ token_timeout_ms: 1_000 })]);
+    a.session?.start();
+    b.session?.start();
+
+    serveInline(await a.injected(), { cid: a.session?.placeholders().cid });
+
+    const results = await Promise.all([a.session?.getRequestParams(), b.session?.getRequestParams()]);
+
+    expect(request).toHaveBeenCalledTimes(2);
+    // The second tab re-read the store inside the lock and reused the leader's token, so it never
+    // injected a loader of its own.
+    expect(b.elements).toHaveLength(0);
+    results.forEach(result => expect(result).toMatchObject({ __clerk_protect_status: 'ok' }));
+  });
+
+  it('uses whatever a leader wrote when the lock is never granted', async () => {
+    Object.defineProperty(navigator, 'locks', {
+      value: {
+        // Mirrors SafeLock's behaviour when its own AbortSignal fires: the callback never runs.
+        request: vi.fn(() => Promise.reject(new DOMException('aborted', 'AbortError'))),
+      },
+      configurable: true,
+    });
+
+    const { session: created } = session([loader()]);
+    created?.start();
+    // Written after the pre-lock read has already missed, so this can only be picked up by the
+    // read that follows a failed lock acquisition.
+    localStorage.setItem('__clerk_protect_st', storedEntry({ token: 'v1.leader.mac', rid: 'c'.repeat(26) }));
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({
+      __clerk_protect_token: 'v1.leader.mac',
+      __clerk_protect_status: 'ok',
+    });
+  });
+
+  it('reports timeout when the lock is never granted and no leader succeeded', async () => {
+    Object.defineProperty(navigator, 'locks', {
+      value: { request: vi.fn(() => Promise.reject(new DOMException('aborted', 'AbortError'))) },
+      configurable: true,
+    });
+
+    const { session: created, elements } = session([loader()]);
+    created?.start();
+
+    await expect(created?.getRequestParams()).resolves.toMatchObject({ __clerk_protect_status: 'timeout' });
+    expect(elements).toHaveLength(0);
+  });
+});
diff --git a/packages/clerk-js/src/core/clerk.ts b/packages/clerk-js/src/core/clerk.ts
index 0622261d9af..9b41d90341f 100644
--- a/packages/clerk-js/src/core/clerk.ts
+++ b/packages/clerk-js/src/core/clerk.ts
@@ -492,6 +492,26 @@ export class Clerk implements ClerkInterface {
     return this.#protectAssertionSet ? this.#protectAssertion : this.#options.protectAssertion;
   }
 
+  /**
+   * The Protect params for one sign-in or sign-up body. The application-supplied assertion and the
+   * server-configured session token are independent features that write disjoint params, so both
+   * contribute and neither can suppress the other: they are resolved concurrently, and a failure on
+   * one side costs only that side's params. Resolves to `undefined` when neither produces anything,
+   * so a request from an instance using no Protect feature is byte-for-byte what it was before.
+   */
+  async #protectParams(): Promise<Record<string, string | undefined> | undefined> {
+    const [assertion, session] = await Promise.all([
+      protectAssertionParams(this.#currentProtectAssertion()).catch(() => undefined),
+      this.#protect?.getRequestParams().catch(() => undefined),
+    ]);
+
+    if (!assertion && !session) {
+      return undefined;
+    }
+
+    return { ...assertion, ...session };
+  }
+
   get isSignedIn(): boolean {
     const hasPendingSession = this?.session?.status === 'pending';
     if (hasPendingSession) {
@@ -529,7 +549,7 @@ export class Clerk implements ClerkInterface {
       getSessionId: () => {
         return this.session?.id;
       },
-      getProtectParams: () => protectAssertionParams(this.#currentProtectAssertion()),
+      getProtectParams: () => this.#protectParams(),
       proxyUrl: this.proxyUrl,
     });
     this.#publicEventBus.emit(clerkEvents.Status, 'loading');
diff --git a/packages/clerk-js/src/core/fapiClient.ts b/packages/clerk-js/src/core/fapiClient.ts
index 526eaf4f0ca..b09406ee985 100644
--- a/packages/clerk-js/src/core/fapiClient.ts
+++ b/packages/clerk-js/src/core/fapiClient.ts
@@ -74,6 +74,11 @@ type FapiClientOptions = {
   proxyUrl?: string;
   instanceType: InstanceType;
   getSessionId: () => string | undefined;
+  /**
+   * Resolves the Protect params to merge into the body of a sign-in or sign-up POST, or `undefined`
+   * when this instance contributes none. Resolves to `undefined` before the environment has loaded,
+   * so early requests carry nothing.
+   */
   getProtectParams?: () => Promise<Record<string, string | undefined> | undefined>;
   isSatellite?: boolean;
 };
@@ -93,6 +98,8 @@ function isMergeableBody(body: unknown): body is Record<string, unknown> | undef
   if (typeof body !== 'object' || body === null) {
     return false;
   }
+  // Spreading anything else — a Blob, a typed array, a stream — would discard the caller's payload
+  // rather than add to it.
   const prototype = Object.getPrototypeOf(body);
   return prototype === Object.prototype || prototype === null;
 }
@@ -221,11 +228,14 @@ export function createFapiClient(options: FapiClientOptions): FapiClient {
     const { method = 'GET' } = requestInit;
     let { body } = requestInit;
 
-    // Protect params must merge before the body is stringified below (onBeforeRequest callbacks run
-    // after stringification), and ride the body rather than a header to avoid the same
-    // CORS preflight `_method` avoids.
+    // Protect params ride in the form-encoded body of sign-in and sign-up POSTs. They have to be
+    // merged here, before the body is stringified below — the onBeforeRequest callbacks run after
+    // stringification, so they cannot add a body param. A body param also keeps the request
+    // CORS-simple; a custom header would trigger the preflight that breaks cookie dropping in
+    // Safari, the same reason `_method` is a query param.
     if (options.getProtectParams && isProtectGatedRequest(method, requestInit.path) && isMergeableBody(body)) {
-      // A rejection costs the params, never the request.
+      // Protect can degrade a sign-in but must never fail one, so a rejection here costs the
+      // params and nothing else.
       const protectParams = await options.getProtectParams().catch(() => undefined);
       if (protectParams) {
         body = { ...((body ?? {}) as Record<string, unknown>), ...protectParams } as unknown as BodyInit;
diff --git a/packages/clerk-js/src/core/protect.ts b/packages/clerk-js/src/core/protect.ts
index 569ec4e7969..259de41ee36 100644
--- a/packages/clerk-js/src/core/protect.ts
+++ b/packages/clerk-js/src/core/protect.ts
@@ -2,9 +2,12 @@ import { inBrowser } from '@clerk/shared/browser';
 import { logger } from '@clerk/shared/logger';
 import type { ProtectLoader } from '@clerk/shared/types';
 
+import type { ApplyLoader, ProtectPlaceholders, ProtectRequestParams } from './protectSession';
+import { interpolatePlaceholders, ProtectSession } from './protectSession';
 import type { Environment } from './resources';
 export class Protect {
   #initialized: boolean = false;
+  #session?: ProtectSession;
 
   load(env: Environment): void {
     const config = env?.protectConfig;
@@ -23,31 +26,57 @@ export class Protect {
     // here rather than at end to mark as initialized even if load fails.
     this.#initialized = true;
 
-    for (const loader of config.loaders) {
+    // The config is server-controlled and cached, so nothing it can contain may take `Clerk.load()`
+    // down with it.
+    try {
+      this.#apply(config.loaders, config.tokens_invalid_before);
+    } catch (error) {
+      logger.warnOnce(`[protect] failed to load: ${error}`);
+    }
+  }
+
+  #apply(configured: ProtectLoader[], tokensInvalidBefore?: number): void {
+    // Rollout is decided before anything else, because the session is only meaningful for the
+    // loaders we are actually going to apply.
+    const loaders = configured.filter(loader => isLoader(loader) && inRollout(loader));
+
+    // Only an instance whose loaders reference the correlation id gets a session, so an instance
+    // not using it is unaffected and stores nothing in the browser.
+    const applyLoader: ApplyLoader = (loader, placeholders) => this.applyLoader(loader, placeholders);
+    this.#session = ProtectSession.create(loaders, applyLoader, tokensInvalidBefore);
+
+    for (const loader of loaders) {
+      // The session injects this one itself, under the acquisition lock, so exactly one tab per
+      // browser session runs it. Every other loader runs on every page load regardless.
+      if (this.#session?.isTokenLoader(loader)) {
+        continue;
+      }
       try {
-        this.applyLoader(loader);
+        this.applyLoader(loader, this.#session?.placeholders());
       } catch (error) {
         logger.warnOnce(`[protect] failed to apply loader: ${error}`);
       }
     }
+
+    // Acquisition is prefetched here rather than at sign-in, so a sign-in normally finds the token
+    // long since cached and acquisition stays off the latency-critical path.
+    this.#session?.start();
   }
 
-  // apply individual loader
-  applyLoader(loader: ProtectLoader) {
-    // we use rollout for percentage based rollouts (as the environment file is cached)
-    if (loader.rollout !== undefined) {
-      const rollout = loader.rollout;
-      if (typeof rollout !== 'number' || rollout < 0) {
-        // invalid rollout percentage - do nothing
-        logger.warnOnce(`[protect] loader rollout value is invalid: ${rollout}`);
-        return;
-      }
-      if (rollout === 0 || Math.random() > rollout) {
-        // not in rollout percentage - do nothing
-        return;
-      }
+  /**
+   * The Protect params to attach to a sign-in or sign-up request, or `undefined` when this instance
+   * does not participate. Never rejects, and never blocks past the acquisition deadline.
+   */
+  getRequestParams(): Promise<ProtectRequestParams | undefined> {
+    try {
+      return (this.#session?.getRequestParams() ?? Promise.resolve(undefined)).catch(() => undefined);
+    } catch {
+      return Promise.resolve(undefined);
     }
+  }
 
+  // apply individual loader
+  applyLoader(loader: ProtectLoader, placeholders?: ProtectPlaceholders): HTMLElement | undefined {
     const type = loader.type || 'script';
     const target = loader.target || 'body';
 
@@ -57,6 +86,8 @@ export class Protect {
       for (const [key, value] of Object.entries(loader.attributes)) {
         switch (typeof value) {
           case 'string':
+            element.setAttribute(key, placeholders ? interpolatePlaceholders(value, placeholders) : value);
+            break;
           case 'number':
           case 'boolean':
             element.setAttribute(key, String(value));
@@ -69,29 +100,57 @@ export class Protect {
       }
     }
 
-    if (loader.textContent && typeof loader.textContent === 'string') {
-      element.textContent = loader.textContent;
+    if (loader.text_content && typeof loader.text_content === 'string') {
+      element.textContent = placeholders
+        ? interpolatePlaceholders(loader.text_content, placeholders)
+        : loader.text_content;
     }
 
     switch (target) {
       case 'head':
         document.head.appendChild(element);
-        break;
+        return element;
       case 'body':
         document.body.appendChild(element);
-        break;
+        return element;
       default:
         if (target?.startsWith('#')) {
           const targetElement = document.getElementById(target.substring(1));
           if (!targetElement) {
             logger.warnOnce(`[protect] loader target element not found: ${target}`);
-            return;
+            return undefined;
           }
           targetElement.appendChild(element);
-          return;
+          return element;
         }
         logger.warnOnce(`[protect] loader target is invalid: ${target}`);
-        break;
+        return undefined;
     }
   }
 }
+
+// A malformed entry is dropped on its own, the way a failed injection always has been — it must
+// not cost the instance its other loaders.
+function isLoader(loader: unknown): loader is ProtectLoader {
+  if (!loader || typeof loader !== 'object') {
+    logger.warnOnce(`[protect] loader entry is not an object: ${loader}`);
+    return false;
+  }
+  return true;
+}
+
+// we use rollout for percentage based rollouts (as the environment file is cached)
+function inRollout(loader: ProtectLoader): boolean {
+  if (loader.rollout === undefined) {
+    return true;
+  }
+
+  const rollout = loader.rollout;
+  if (typeof rollout !== 'number' || rollout < 0) {
+    // invalid rollout percentage - do nothing
+    logger.warnOnce(`[protect] loader rollout value is invalid: ${rollout}`);
+    return false;
+  }
+
+  return rollout !== 0 && Math.random() <= rollout;
+}
diff --git a/packages/clerk-js/src/core/protectSession.ts b/packages/clerk-js/src/core/protectSession.ts
new file mode 100644
index 00000000000..ee36a82b0e9
--- /dev/null
+++ b/packages/clerk-js/src/core/protectSession.ts
@@ -0,0 +1,853 @@
+import type { ProtectLoader } from '@clerk/shared/types';
+
+import { SafeLock } from './auth/safeLock';
+
+/**
+ * Correlation id and Protect session token acquisition.
+ *
+ * The browser mints an opaque correlation id (`cid`) and hands it to the loader through the
+ * element's attributes, which are per-instance server config. The server mints a signed session
+ * token while serving that loader and returns it inline on the script's own global, so the gate
+ * costs no extra round trip. We acquire it exactly once per browser session across all tabs and
+ * attach it to sign-in and sign-up requests.
+ *
+ * An instance that configures `tokenUrl` gets the upgrade mint instead: a `GET` for a token that
+ * attests to work happening after the script runs. Only that path can report `fetch_error` or
+ * `http_<n>`.
+ *
+ * Acquisition failure is never fatal: a structured status travels in the token's place so that
+ * a blocked or failed acquisition becomes a reportable fact rather than silence.
+ */
+
+/** Persistent, per-app-origin client id. Opaque and random — nothing about the device. */
+const PID_STORAGE_KEY = '__clerk_protect_pid';
+/** The shared `{ token, exp, rid }` store every tab reads before it considers acquiring. */
+const TOKEN_STORAGE_KEY = '__clerk_protect_st';
+const ACQUISITION_LOCK_KEY = 'clerk.lock.protectSessionToken';
+
+/** Where the loader script leaves the token it was served with. */
+const INLINE_TOKEN_GLOBAL = '__clerk_specter';
+
+/** A token this close to expiry is treated as absent, so a fresh run starts before it lapses. */
+const TOKEN_REFRESH_MARGIN_MS = 60 * 1_000;
+/** Acquisition deadline when the instance does not configure one. */
+const DEFAULT_TOKEN_TIMEOUT_MS = 5 * 1_000;
+/** Ceiling on the instance-configured deadline, so no server value can stall a sign-in. */
+const MAX_TOKEN_TIMEOUT_MS = 10 * 1_000;
+/** A stored token claiming more remaining life than this was not minted by us. */
+const MAX_TOKEN_LIFETIME_MS = 24 * 60 * 60 * 1_000;
+/** Longest token we will hand back, so a planted store entry cannot bloat a sign-in body. */
+const MAX_TOKEN_LENGTH = 4_096;
+/**
+ * The shape of a mint: `v<n>.<payload>.<mac>`, base64url. Version-agnostic on purpose — the server
+ * may mint a version this build predates, and only the server can judge a token either way.
+ */
+const TOKEN_SHAPE = /^v\d+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+/** How long a settled, tokenless acquisition is reused before a fresh run is allowed. */
+const REACQUIRE_COOLDOWN_MS = 30 * 1_000;
+/**
+ * Ceiling on the backoff between tokenless attempts. The cooldown doubles per consecutive failure
+ * so a Specter outage costs a bounded number of deadlines instead of one every cooldown window,
+ * and this stops it growing past the point where a recovered Specter would go unnoticed.
+ */
+const MAX_REACQUIRE_COOLDOWN_MS = 15 * 60 * 1_000;
+/** A token this close to expiry is not worth sending — it would lapse before it was verified. */
+const TOKEN_SEND_MARGIN_MS = 5 * 1_000;
+/** Bounds we hold the server-supplied `retry_in_ms` to. */
+const MIN_RETRY_DELAY_MS = 50;
+const MAX_RETRY_DELAY_MS = 1_000;
+
+/** Lowercase RFC 4648 base32 — a `cid` has to survive case-insensitive, alphanumeric-only contexts. */
+const BASE32_ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+/** 128 bits of base32, unpadded. */
+const BASE32_128_REGEX = /^[a-z2-7]{26}$/;
+/** The full correlation id, identical to the regex FAPI validates against. */
+export const CID_REGEX = /^1-[a-z2-7]{26}-[a-z2-7]{26}$/;
+
+/** The closed set of placeholders `applyLoader` substitutes. Anything else is left verbatim. */
+const PLACEHOLDER_REGEX = /\{(cid|pid|rid|sdkver)\}/g;
+/** Non-global twin of the above, so `test` does not carry `lastIndex` between calls. */
+const HAS_PLACEHOLDER_REGEX = /\{(?:cid|pid|rid|sdkver)\}/;
+/** The placeholders that need a minted, persisted client id to substitute. */
+const HAS_CLIENT_ID_REGEX = /\{(?:cid|pid|rid)\}/;
+/** Only the correlation id binds a loader to an acquisition run, so only it names the token loader. */
+const HAS_CID_REGEX = /\{cid\}/;
+
+/**
+ * Closed set — FAPI validates these by exact match and drops anything else, so a new value here
+ * is a wire change. `fetch_error` and `http_<n>` are reachable only through the upgrade mint.
+ */
+export type ProtectStatus =
+  | 'ok'
+  | 'no_token'
+  | 'timeout'
+  | 'script_error'
+  | 'fetch_error'
+  | 'unsupported'
+  | `http_${number}`;
+
+export type ProtectPlaceholders = {
+  cid?: string;
+  pid?: string;
+  rid?: string;
+  sdkver?: string;
+};
+
+/** The params attached to the form-encoded body of sign-in and sign-up POSTs. */
+export type ProtectRequestParams = {
+  __clerk_protect_token?: string;
+  __clerk_protect_status: ProtectStatus;
+  __clerk_protect_cid?: string;
+};
+
+/** Appends a loader element to the document and returns it, or `undefined` when it cannot. */
+export type ApplyLoader = (loader: ProtectLoader, placeholders: ProtectPlaceholders) => HTMLElement | undefined;
+
+type StoredToken = {
+  token: string;
+  /** Unix seconds, as served by the token endpoint. */
+  exp: number;
+  rid: string;
+  /**
+   * Local milliseconds at the moment we stored it. `exp` compares server truth against this
+   * browser's clock, so a skewed clock either ships lapsed tokens or discards good ones; this
+   * bounds both by elapsed local time, which is measured entirely on the one clock.
+   */
+  at: number;
+  /**
+   * The `tokens_invalid_before` in force when this was acquired. Raising the configured value
+   * strands every entry stamped with an older one, so a bad mint or a key roll is recovered from
+   * in minutes rather than over the token's full lifetime.
+   */
+  floor: number;
+};
+
+/**
+ * A token as it arrives from a mint, before it is stored. `at` and `floor` are stamped by the
+ * write rather than carried from here, so the two states are different types and a producer
+ * cannot forget either.
+ */
+type MintedToken = Omit<StoredToken, 'at' | 'floor'>;
+
+type LoaderOutcome = 'loaded' | 'error' | 'timeout';
+
+/**
+ * Substitutes the closed placeholder set. A recognised placeholder with no value available, and
+ * any unrecognised `{…}`, is left verbatim — the server treats an unsubstituted placeholder as
+ * "no id" and serves normally, which is what keeps older SDK builds working against a templated
+ * loader config.
+ */
+export function interpolatePlaceholders(value: string, placeholders: ProtectPlaceholders): string {
+  return value.replace(PLACEHOLDER_REGEX, (match, name: keyof ProtectPlaceholders) => placeholders[name] ?? match);
+}
+
+/** Lowercase RFC 4648 base32, unpadded. 16 bytes in, 26 chars out. */
+export function encodeBase32(bytes: Uint8Array): string {
+  let out = '';
+  let value = 0;
+  let bits = 0;
+
+  for (let i = 0; i < bytes.length; i++) {
+    value = (value << 8) | bytes[i];
+    bits += 8;
+    while (bits >= 5) {
+      out += BASE32_ALPHABET[(value >>> (bits - 5)) & 31];
+      bits -= 5;
+    }
+  }
+
+  if (bits > 0) {
+    out += BASE32_ALPHABET[(value << (5 - bits)) & 31];
+  }
+
+  return out;
+}
+
+/** 128 random bits as base32, or `null` when the platform has no CSPRNG. */
+function random128(): string | null {
+  const webCrypto = typeof crypto !== 'undefined' ? crypto : undefined;
+  if (typeof webCrypto?.getRandomValues !== 'function') {
+    return null;
+  }
+
+  try {
+    return encodeBase32(webCrypto.getRandomValues(new Uint8Array(16)));
+  } catch {
+    return null;
+  }
+}
+
+export function buildCid(pid: string, rid: string): string {
+  return `1-${pid}-${rid}`;
+}
+
+/**
+ * `localStorage` with an in-memory fallback. A sandboxed iframe, blocked storage or a full quota
+ * costs us cross-tab sharing, never a sign-in, so nothing in here throws.
+ */
+const memoryStore = new Map<string, string>();
+
+/** Test-only: the fallback outlives any single session, so a suite has to be able to clear it. */
+export function __internal_resetProtectStorage(): void {
+  memoryStore.clear();
+}
+
+function localStorageOrNull(): Storage | null {
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function readStored(key: string): string | null {
+  try {
+    const value = localStorageOrNull()?.getItem(key);
+    if (typeof value === 'string') {
+      return value;
+    }
+  } catch {
+    // blocked — the in-memory fallback below is the only copy there is
+  }
+  // Reached when storage is absent, blocked, or readable but not writable: a write that hit the
+  // quota landed in memory instead, and this is the only place it can be read back from.
+  return memoryStore.get(key) ?? null;
+}
+
+function writeStored(key: string, value: string): void {
+  try {
+    const storage = localStorageOrNull();
+    if (storage) {
+      storage.setItem(key, value);
+      memoryStore.delete(key);
+      return;
+    }
+  } catch {
+    // blocked or over quota — fall through
+  }
+  // In-memory only, for the lifetime of this page. We lose cross-tab sharing, not the sign-in.
+  memoryStore.set(key, value);
+}
+
+function readOrMintPid(): string | null {
+  const existing = readStored(PID_STORAGE_KEY);
+  if (existing && BASE32_128_REGEX.test(existing)) {
+    return existing;
+  }
+
+  const minted = random128();
+  if (minted) {
+    writeStored(PID_STORAGE_KEY, minted);
+  }
+  return minted;
+}
+
+/**
+ * Reads the shared token store. `marginMs` is how much remaining life a token needs to count as
+ * present: the acquisition path demands a margin so a run starts before the token lapses, while
+ * the request path takes anything not yet expired. `floor` is the instance's currently configured
+ * `tokens_invalid_before`; an entry acquired under an older one is stranded.
+ */
+function readStoredToken(key: string, marginMs: number, floor: number): StoredToken | null {
+  const raw = readStored(key);
+  if (!raw) {
+    return null;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+
+  if (!parsed || typeof parsed !== 'object') {
+    return null;
+  }
+
+  const { token, exp, rid, at, floor: storedFloor } = parsed as Record<string, unknown>;
+  if (typeof rid !== 'string' || !BASE32_128_REGEX.test(rid)) {
+    return null;
+  }
+  if (!freshByLocalClock(at)) {
+    return null;
+  }
+  // An entry with no floor predates the mechanism and counts as zero, so an instance that has
+  // never set one keeps its cached tokens rather than re-acquiring on every browser at once.
+  if (normalizeFloor(storedFloor) < floor) {
+    return null;
+  }
+
+  const validated = validateToken(token, exp, marginMs);
+  return validated ? { ...validated, rid, at: at as number, floor: normalizeFloor(storedFloor) } : null;
+}
+
+/** A floor is unix seconds; anything else configured or stored is treated as no floor at all. */
+function normalizeFloor(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
+/**
+ * The clock-skew bound. `exp` is server truth compared against this browser's clock, so a clock
+ * running slow keeps an entry alive long past its real expiry and a clock running fast throws
+ * good ones away. Elapsed time since we stored it is measured on one clock, so a constant offset
+ * cancels: an entry older than any token we would ever be issued is stale whatever `exp` claims,
+ * and one stamped in the future means the clock moved backwards under us.
+ *
+ * This bounds the damage rather than removing it — a fully skew-proof check needs the server to
+ * send a relative lifetime instead of an absolute `exp`, which is a wire change.
+ */
+function freshByLocalClock(at: unknown): boolean {
+  if (typeof at !== 'number' || !Number.isFinite(at)) {
+    return false;
+  }
+  const elapsed = Date.now() - at;
+  return elapsed >= 0 && elapsed < MAX_TOKEN_LIFETIME_MS;
+}
+
+/**
+ * The store is writable by anything running on the origin, so a value that could not have come
+ * from a mint of ours is discarded rather than trusted to suppress the loaders.
+ *
+ * The shape check is hygiene, not a security boundary: only the server can tell a real token from a
+ * well-formed forgery, and anything that can write the store can send the same values to the API
+ * directly. What it buys is that a corrupt or truncated entry starts a fresh run immediately
+ * instead of suppressing acquisition until it expires.
+ */
+function validateToken(token: unknown, exp: unknown, marginMs: number): { token: string; exp: number } | null {
+  if (typeof token !== 'string' || token.length > MAX_TOKEN_LENGTH || !TOKEN_SHAPE.test(token)) {
+    return null;
+  }
+  if (typeof exp !== 'number' || !Number.isFinite(exp)) {
+    return null;
+  }
+  const expMs = exp * 1_000;
+  if (expMs - marginMs <= Date.now() || expMs > Date.now() + MAX_TOKEN_LIFETIME_MS) {
+    return null;
+  }
+  return { token, exp };
+}
+
+/** `at` and `floor` are the writer's business, not the caller's — both stamped here, at the write. */
+function writeStoredToken(key: string, value: MintedToken, floor: number): void {
+  writeStored(key, JSON.stringify({ ...value, at: Date.now(), floor }));
+}
+
+/** Sentinel for "the deadline won", distinguishable from anything `ready` could resolve to. */
+const DEADLINE = Symbol('deadline');
+
+function isThenable(value: unknown): value is PromiseLike<unknown> {
+  return (
+    !!value &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    typeof (value as PromiseLike<unknown>).then === 'function'
+  );
+}
+
+/** `ready` never rejects by contract; a rejection is still treated as nothing served. */
+function settleWithin(ready: PromiseLike<unknown>, deadline: number): Promise<unknown> {
+  return new Promise(resolve => {
+    const timer = setTimeout(() => resolve(DEADLINE), Math.max(0, deadline - Date.now()));
+    const settle = (value: unknown) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+    ready.then(settle, () => settle(null));
+  });
+}
+
+/**
+ * The token the loader script was served with, or the status that stands in for it.
+ *
+ * The current shape carries `ready`, a promise resolving to `{ token, exp }` or to
+ * `{ status: 'no_token' }`. It is the loader's completion signal and the seam where page-side
+ * work will later live, so the token is awaited rather than read. The base shape carries neither
+ * `cid` nor `ready` and lands on `no_token` — which is why that status exists separately from
+ * `timeout`: until the server half deploys it is the correct answer for every load, and calling
+ * that a timeout would make a normal rollout look like an outage.
+ */
+async function readInlineToken(cid: string, rid: string, deadline: number): Promise<MintedToken | ProtectStatus> {
+  const inline = (globalThis as unknown as Record<string, unknown>)[INLINE_TOKEN_GLOBAL];
+  if (!inline || typeof inline !== 'object') {
+    return 'no_token';
+  }
+
+  const { cid: mintedFor, ready } = inline as Record<string, unknown>;
+  // The global is page-visible and outlives a navigation, so a token minted for anyone else's run
+  // is not ours to send. The base shape, which carries no cid at all, lands here too.
+  if (mintedFor !== cid || !isThenable(ready)) {
+    return 'no_token';
+  }
+
+  const resolved = await settleWithin(ready, deadline);
+  if (resolved === DEADLINE) {
+    return 'timeout';
+  }
+  if (!resolved || typeof resolved !== 'object') {
+    return 'no_token';
+  }
+
+  const { token, exp } = resolved as Record<string, unknown>;
+  const validated = validateToken(token, exp, 0);
+  // `{ status: 'no_token' }` has no token to validate and lands here, as does a malformed one.
+  return validated ? { ...validated, rid } : 'no_token';
+}
+
+function httpStatus(status: number): ProtectStatus {
+  // The status enum only admits `http_1xx`-`http_5xx`; anything else would be dropped by FAPI.
+  return status >= 100 && status <= 599 ? (`http_${status}` as ProtectStatus) : 'fetch_error';
+}
+
+/** Worth spending the rest of the deadline on rather than reporting as the outcome. */
+function isRetryableStatus(status: number): boolean {
+  return status === 408 || status === 429 || status >= 500;
+}
+
+function sleep(ms: number, signal: AbortSignal): Promise<void> {
+  return new Promise(resolve => {
+    const timer = setTimeout(resolve, ms);
+    signal.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true },
+    );
+  });
+}
+
+/** Resolves to `timeout` rather than waiting past `ms`, and never rejects. */
+function withDeadline(promise: Promise<ProtectStatus>, ms: number): Promise<ProtectStatus> {
+  return new Promise(resolve => {
+    const timer = setTimeout(() => resolve('timeout'), ms);
+    const settle = (status: ProtectStatus) => {
+      clearTimeout(timer);
+      resolve(status);
+    };
+    promise.then(settle, () => settle('timeout'));
+  });
+}
+
+/** Every string a loader can carry a placeholder in. */
+function templatedValues(loader: ProtectLoader): string[] {
+  const values: string[] = [];
+  if (typeof loader.token_url === 'string') {
+    values.push(loader.token_url);
+  }
+  if (typeof loader.text_content === 'string') {
+    values.push(loader.text_content);
+  }
+  for (const value of Object.values(loader.attributes ?? {})) {
+    if (typeof value === 'string') {
+      values.push(value);
+    }
+  }
+  return values;
+}
+
+/** Does this loader reference anything we would substitute? */
+function isTemplated(loader: ProtectLoader): boolean {
+  return templatedValues(loader).some(value => HAS_PLACEHOLDER_REGEX.test(value));
+}
+
+/** Does this loader need the persisted client id, as opposed to only the instance id? */
+function needsClientId(loader: ProtectLoader): boolean {
+  return templatedValues(loader).some(value => HAS_CLIENT_ID_REGEX.test(value));
+}
+
+function isCorrelated(loader: ProtectLoader): boolean {
+  return templatedValues(loader).some(value => HAS_CID_REGEX.test(value));
+}
+
+/**
+ * Will this element fetch, and so eventually fire `load` or `error`? A classic inline script will
+ * not — it runs during `appendChild` and reports through neither event. An inline module will: it
+ * evaluates off a module graph the browser still has to fetch.
+ */
+function isFetching(element: HTMLElement): boolean {
+  if (element.getAttribute('src') || element.getAttribute('href')) {
+    return true;
+  }
+  return element.tagName === 'SCRIPT' && element.getAttribute('type')?.toLowerCase() === 'module';
+}
+
+export class ProtectSession {
+  /** `null` when no loader needs it, or when the platform has no CSPRNG. */
+  readonly #pid: string | null;
+  readonly #rid: string | null;
+  readonly #cid: string | null;
+  readonly #placeholders: ProtectPlaceholders;
+  /** The loader carrying the correlation id; absent when the instance has not configured the gate. */
+  readonly #tokenLoader?: ProtectLoader;
+  /** Set only by an instance opting into the upgrade mint. */
+  readonly #tokenUrl?: string;
+  readonly #timeoutMs: number;
+  readonly #applyLoader: ApplyLoader;
+  /**
+   * One store per origin. The token is scoped to the instance that minted it and is verified
+   * server-side, so an origin serving two instances costs a rejected token, never a wrong grant.
+   */
+  /** Currently configured `tokens_invalid_before`; 0 when the instance has never set one. */
+  readonly #floor: number = 0;
+  readonly #tokenStorageKey: string;
+  readonly #lock: ReturnType<typeof SafeLock>;
+
+  /** One attempt at a time; re-armed once it has settled without leaving a usable token. */
+  #acquisition?: Promise<ProtectStatus>;
+  #acquisitionSettled = false;
+  #lastAttemptAt = 0;
+  /** Consecutive attempts that settled without a usable token. Drives the re-acquire backoff. */
+  #consecutiveFailures = 0;
+
+  /**
+   * Returns a session only when at least one loader references a placeholder — an instance using
+   * none of them is unaffected.
+   */
+  static create(
+    loaders: ProtectLoader[],
+    applyLoader: ApplyLoader,
+    tokensInvalidBefore?: number,
+  ): ProtectSession | undefined {
+    const templated = loaders.filter(isTemplated);
+    if (templated.length === 0) {
+      return undefined;
+    }
+    return new ProtectSession(templated, applyLoader, tokensInvalidBefore);
+  }
+
+  private constructor(templatedLoaders: ProtectLoader[], applyLoader: ApplyLoader, tokensInvalidBefore?: number) {
+    this.#applyLoader = applyLoader;
+    this.#floor = normalizeFloor(tokensInvalidBefore);
+
+    // Nothing is persisted for a loader that only templates the SDK version: that needs no minted
+    // identity, so minting one would plant a durable id nobody asked for.
+    const clientIdNeeded = templatedLoaders.some(needsClientId);
+    this.#pid = clientIdNeeded ? readOrMintPid() : null;
+    this.#rid = this.#pid ? random128() : null;
+    this.#cid = this.#pid && this.#rid ? buildCid(this.#pid, this.#rid) : null;
+
+    this.#placeholders = {
+      ...(this.#cid ? { cid: this.#cid } : {}),
+      ...(this.#pid ? { pid: this.#pid } : {}),
+      ...(this.#rid ? { rid: this.#rid } : {}),
+      // Sending a version is what tells the server this build interpolates placeholders at all,
+      // and so can be served the current shape. A build that leaves it verbatim gets the base one.
+      sdkver: __PKG_VERSION__,
+    };
+
+    const tokenLoader = templatedLoaders.find(isCorrelated);
+    this.#tokenLoader = tokenLoader;
+    this.#tokenUrl = tokenLoader ? resolveTokenUrl(tokenLoader, this.#placeholders) : undefined;
+    this.#timeoutMs = clampTimeout(tokenLoader?.token_timeout_ms);
+
+    this.#tokenStorageKey = TOKEN_STORAGE_KEY;
+    this.#lock = SafeLock(ACQUISITION_LOCK_KEY);
+  }
+
+  placeholders(): ProtectPlaceholders {
+    return this.#placeholders;
+  }
+
+  /** The session owns this loader's injection, so `Protect` must not apply it as well. */
+  isTokenLoader(loader: ProtectLoader): boolean {
+    return this.#tokenLoader === loader;
+  }
+
+  /** Fire-and-forget; started at `Clerk.load()` so a sign-in normally finds the token cached. */
+  start(): void {
+    if (!this.#tokenLoader || this.#acquisition) {
+      return;
+    }
+    this.#startAcquisition();
+  }
+
+  async getRequestParams(): Promise<ProtectRequestParams | undefined> {
+    if (!this.#tokenLoader) {
+      // The instance interpolates an id into its loader but has not configured the gate, so there
+      // is nothing to report.
+      return undefined;
+    }
+
+    if (!this.#cid || !this.#pid) {
+      return { __clerk_protect_status: 'unsupported' };
+    }
+
+    this.#rearmIfStale();
+    const status = this.#acquisition ? await withDeadline(this.#acquisition, this.#timeoutMs) : 'timeout';
+
+    // Re-read: another tab may have completed a run after ours gave up. The send margin is what
+    // stops us shipping a token with a second of life left, which could only fail verification.
+    const stored = readStoredToken(this.#tokenStorageKey, TOKEN_SEND_MARGIN_MS, this.#floor);
+    if (stored) {
+      return {
+        __clerk_protect_token: stored.token,
+        __clerk_protect_status: 'ok',
+        // The cid has to name the run the token was minted for, not necessarily ours.
+        __clerk_protect_cid: buildCid(this.#pid, stored.rid),
+      };
+    }
+
+    return {
+      // `ok` without a token would contradict itself; the token lapsed between the run and now.
+      __clerk_protect_status: status === 'ok' ? 'timeout' : status,
+      __clerk_protect_cid: this.#cid,
+    };
+  }
+
+  /**
+   * True when a token from this browser session is already shared with us. Only the token loader
+   * is skipped on the strength of it — every other loader still runs on every page load.
+   */
+  hasFreshToken(): boolean {
+    return this.#tokenLoader ? this.#freshStoredToken() !== null : false;
+  }
+
+  #freshStoredToken(): StoredToken | null {
+    return readStoredToken(this.#tokenStorageKey, TOKEN_REFRESH_MARGIN_MS, this.#floor);
+  }
+
+  /**
+   * A page outlives its token. Once an attempt has settled without leaving one usable, the next
+   * sign-in starts a fresh run instead of replaying a stale result for the life of the tab.
+   */
+  #rearmIfStale(): void {
+    if (!this.#acquisition) {
+      this.#startAcquisition();
+      return;
+    }
+    if (!this.#acquisitionSettled) {
+      return;
+    }
+    if (readStoredToken(this.#tokenStorageKey, TOKEN_SEND_MARGIN_MS, this.#floor)) {
+      return;
+    }
+    if (Date.now() - this.#lastAttemptAt < this.#backoffMs()) {
+      return;
+    }
+    this.#startAcquisition();
+  }
+
+  /**
+   * How long to wait before another attempt, doubling per consecutive tokenless one. A flat
+   * cooldown means a Specter outage adds the full deadline to a sign-in every cooldown window,
+   * for as long as the outage lasts — which is the auth-critical-path cost landing exactly when
+   * things are already worst. The ceiling keeps a long-lived tab noticing a recovery.
+   */
+  #backoffMs(): number {
+    if (this.#consecutiveFailures <= 1) {
+      return REACQUIRE_COOLDOWN_MS;
+    }
+    // 2 ** n overflows to Infinity long before it matters; Math.min still yields the ceiling.
+    return Math.min(REACQUIRE_COOLDOWN_MS * 2 ** (this.#consecutiveFailures - 1), MAX_REACQUIRE_COOLDOWN_MS);
+  }
+
+  #startAcquisition(): void {
+    this.#lastAttemptAt = Date.now();
+    this.#acquisitionSettled = false;
+    const settled = (status: ProtectStatus): ProtectStatus => {
+      this.#acquisitionSettled = true;
+      // Judged on whether a token landed, not on the status: another tab may have won the lock
+      // and written one while this attempt reported `timeout`, and that is not a failure.
+      this.#consecutiveFailures = readStoredToken(this.#tokenStorageKey, TOKEN_SEND_MARGIN_MS, this.#floor)
+        ? 0
+        : this.#consecutiveFailures + 1;
+      return status;
+    };
+    this.#acquisition = this.#acquire().then(settled, () => settled('timeout'));
+  }
+
+  async #acquire(): Promise<ProtectStatus> {
+    if (!this.#cid) {
+      return 'unsupported';
+    }
+    if (this.#freshStoredToken()) {
+      // Step 1: valid and not near expiry. No lock, no loader, no network.
+      return 'ok';
+    }
+
+    const result = await this.#lock.acquireLockAndRun(async () => {
+      // Double-checked inside the lock. Without this re-read every tab runs the loader in turn,
+      // which is the exact failure this design exists to prevent.
+      if (this.#freshStoredToken()) {
+        return 'ok' satisfies ProtectStatus;
+      }
+      return await this.#mint();
+    });
+
+    if (typeof result === 'string') {
+      return result as ProtectStatus;
+    }
+
+    // The lock was never held — `SafeLock` gives up waiting after ~5s so a wedged leader delays
+    // nobody. Whatever a leader did manage to write is still ours to use.
+    return this.#freshStoredToken() ? 'ok' : 'timeout';
+  }
+
+  /** Runs the loader and takes the token it was served with. Never rejects. */
+  async #mint(): Promise<ProtectStatus> {
+    const deadline = Date.now() + this.#timeoutMs;
+
+    const outcome = await this.#runTokenLoader(deadline);
+    if (outcome === 'error') {
+      return 'script_error';
+    }
+    if (outcome === 'timeout') {
+      return 'timeout';
+    }
+
+    if (this.#tokenUrl) {
+      return await this.#poll(deadline);
+    }
+
+    const inline = await readInlineToken(this.#cid as string, this.#rid as string, deadline);
+    if (typeof inline === 'string') {
+      return inline;
+    }
+
+    writeStoredToken(this.#tokenStorageKey, inline, this.#floor);
+    return 'ok';
+  }
+
+  /**
+   * Injects the token loader and settles on whichever of `load`, `error` or the deadline comes
+   * first, or immediately when the element has nothing to fetch.
+   */
+  #runTokenLoader(deadline: number): Promise<LoaderOutcome> {
+    const loader = this.#tokenLoader;
+    if (!loader) {
+      return Promise.resolve('error');
+    }
+
+    let element: HTMLElement | undefined;
+    try {
+      element = this.#applyLoader(loader, this.#placeholders);
+    } catch {
+      return Promise.resolve('error');
+    }
+    if (!element) {
+      return Promise.resolve('error');
+    }
+
+    // An element that fetches nothing fires neither `load` nor `error`, and a classic inline script
+    // has already executed by the time it was appended. Waiting for an event that cannot arrive
+    // would spend the whole deadline and then discard the token the script body had assigned before
+    // we ever looked. An inline module is the exception: it evaluates off a fetched graph, so its
+    // `load` does arrive and settling early would read the global before it is written.
+    if (!isFetching(element)) {
+      return Promise.resolve('loaded');
+    }
+
+    return new Promise<LoaderOutcome>(resolve => {
+      const timer = setTimeout(() => resolve('timeout'), Math.max(0, deadline - Date.now()));
+      const settle = (outcome: LoaderOutcome) => () => {
+        clearTimeout(timer);
+        resolve(outcome);
+      };
+      element.addEventListener('load', settle('loaded'), { once: true });
+      element.addEventListener('error', settle('error'), { once: true });
+    });
+  }
+
+  /** The upgrade mint: polls the token endpoint until the deadline. Never rejects. */
+  async #poll(deadline: number): Promise<ProtectStatus> {
+    const url = this.#tokenUrl as string;
+    const controller = new AbortController();
+    const deadlineTimer = setTimeout(() => controller.abort(), Math.max(0, deadline - Date.now()));
+
+    try {
+      for (;;) {
+        if (Date.now() >= deadline) {
+          return 'timeout';
+        }
+
+        let response: Response;
+        try {
+          // No custom headers, no credentials: a CORS-simple GET needs no preflight.
+          response = await fetch(url, { credentials: 'omit', signal: controller.signal });
+        } catch {
+          return controller.signal.aborted ? 'timeout' : 'fetch_error';
+        }
+
+        if (response.status === 200) {
+          const token = await readTokenPayload(response, this.#rid as string);
+          if (!token) {
+            return 'fetch_error';
+          }
+          writeStoredToken(this.#tokenStorageKey, token, this.#floor);
+          return 'ok';
+        }
+
+        const pending = response.status === 202;
+        if (!pending && !isRetryableStatus(response.status)) {
+          return httpStatus(response.status);
+        }
+
+        // Still pending, or transiently unavailable. Spending the remaining deadline on a retry
+        // beats reporting a blip as the outcome for the whole page.
+        const delay = pending ? await readRetryDelay(response) : MIN_RETRY_DELAY_MS * 4;
+        if (Date.now() + delay >= deadline) {
+          return pending ? 'timeout' : httpStatus(response.status);
+        }
+        await sleep(delay, controller.signal);
+      }
+    } finally {
+      clearTimeout(deadlineTimer);
+    }
+  }
+}
+
+export function clampTimeout(configured: unknown): number {
+  if (typeof configured !== 'number' || !Number.isFinite(configured) || configured <= 0) {
+    return DEFAULT_TOKEN_TIMEOUT_MS;
+  }
+  return Math.min(configured, MAX_TOKEN_TIMEOUT_MS);
+}
+
+/**
+ * The upgrade mint's endpoint, for an instance that has opted into it. It is instance config like
+ * every other part of the loader, so a new placement ships without an SDK release. Absent it, the
+ * token arrives inline with the loader and there is no endpoint to resolve.
+ */
+function resolveTokenUrl(loader: ProtectLoader, placeholders: ProtectPlaceholders): string | undefined {
+  if (typeof loader.token_url !== 'string' || !loader.token_url) {
+    return undefined;
+  }
+
+  const base = typeof document !== 'undefined' ? document.baseURI : undefined;
+  try {
+    return new URL(interpolatePlaceholders(loader.token_url, placeholders), base).href;
+  } catch {
+    return undefined;
+  }
+}
+
+async function readTokenPayload(response: Response, rid: string): Promise<MintedToken | null> {
+  let json: unknown;
+  try {
+    json = await response.json();
+  } catch {
+    return null;
+  }
+
+  if (!json || typeof json !== 'object') {
+    return null;
+  }
+
+  const { token, exp } = json as Record<string, unknown>;
+  const validated = validateToken(token, exp, 0);
+  return validated ? { ...validated, rid } : null;
+}
+
+async function readRetryDelay(response: Response): Promise<number> {
+  try {
+    const json = (await response.json()) as Record<string, unknown> | null;
+    const retryInMs = json?.retry_in_ms;
+    if (typeof retryInMs === 'number' && Number.isFinite(retryInMs)) {
+      return Math.min(Math.max(retryInMs, MIN_RETRY_DELAY_MS), MAX_RETRY_DELAY_MS);
+    }
+  } catch {
+    // fall through to the default backoff
+  }
+  return MIN_RETRY_DELAY_MS * 2;
+}
diff --git a/packages/clerk-js/src/core/resources/ProtectConfig.ts b/packages/clerk-js/src/core/resources/ProtectConfig.ts
index 93e46083c9e..2a5b1a7cfb7 100644
--- a/packages/clerk-js/src/core/resources/ProtectConfig.ts
+++ b/packages/clerk-js/src/core/resources/ProtectConfig.ts
@@ -10,6 +10,7 @@ import { BaseResource } from './internal';
 export class ProtectConfig extends BaseResource implements ProtectConfigResource {
   id: string = '';
   loaders?: ProtectLoader[];
+  tokens_invalid_before?: number;
   rollout?: number;
 
   public constructor(data: ProtectConfigJSON | ProtectConfigJSONSnapshot | null = null) {
@@ -25,6 +26,7 @@ export class ProtectConfig extends BaseResource implements ProtectConfigResource
 
     this.id = this.withDefault(data.id, this.id);
     this.loaders = this.withDefault(data.loaders, this.loaders);
+    this.tokens_invalid_before = this.withDefault(data.tokens_invalid_before, this.tokens_invalid_before);
 
     return this;
   }
@@ -34,6 +36,7 @@ export class ProtectConfig extends BaseResource implements ProtectConfigResource
       object: 'protect_config',
       id: this.id,
       loaders: this.loaders,
+      tokens_invalid_before: this.tokens_invalid_before,
     };
   }
 }
diff --git a/packages/shared/src/types/protectConfig.ts b/packages/shared/src/types/protectConfig.ts
index 7f469757a41..d1fdb5e8714 100644
--- a/packages/shared/src/types/protectConfig.ts
+++ b/packages/shared/src/types/protectConfig.ts
@@ -1,23 +1,66 @@
 import type { ClerkResource } from './resource';
 import type { ProtectConfigJSONSnapshot } from './snapshots';
 
+/**
+ * One loader, exactly as the server serves it.
+ *
+ * **Field names are the wire's, not TypeScript's.** The array is assigned straight out of
+ * `/v1/environment` with no case conversion, so a camelCase name here reads a field the server
+ * does not send and is silently `undefined` forever. `token_timeout_ms` shipped that way and the
+ * per-instance deadline it configures did nothing. Match the Go tag on
+ * `antifraud/config.JSLoaderConfig`, and if a field has no tag there yet, name it as that tag
+ * would be.
+ */
 export interface ProtectLoader {
   rollout?: number;
   target: 'head' | 'body' | `#${string}`;
   type: string;
+  /**
+   * Attribute values may contain the placeholders `{cid}`, `{pid}`, `{rid}` and `{sdkver}`, which
+   * are substituted before the element is appended. An unrecognised `{…}` is left verbatim.
+   * `{sdkver}` is how the server tells a build that interpolates from one that does not, so a
+   * loader wanting the current response shape has to carry it.
+   */
   attributes?: Record<string, string | number | boolean>;
-  textContent?: string;
+  /** Substituted in the same way as `attributes`. No server field emits this yet. */
+  text_content?: string;
+  /**
+   * Opts this loader into the upgrade mint: the Protect session token is fetched from here instead
+   * of being taken from the one served inline with the loader itself. Placeholders are substituted
+   * as they are in `attributes`. Only this path can report `fetch_error` or an HTTP status.
+   *
+   * No server field emits this yet, so no instance can currently be configured to use it.
+   */
+  token_url?: string;
+  /**
+   * How long to wait for the token before giving up and reporting a status instead. Defaults to
+   * 5000 and is capped at 10000 by the SDK, so this cannot stall a sign-in.
+   */
+  token_timeout_ms?: number;
 }
 
 export interface ProtectConfigJSON {
   object: 'protect_config';
   id: string;
   loaders?: ProtectLoader[];
+  /**
+   * Unix seconds. A session token acquired while an older value was configured is discarded and
+   * re-acquired, so raising this makes every browser fetch a fresh one as its environment
+   * refreshes — the recovery half of a bad mint or a key roll.
+   *
+   * It is **not** revocation: an outstanding token stays cryptographically valid until it expires
+   * or its signing key is dropped. What this buys is that the fleet heals in minutes rather than
+   * spending the token's full lifetime sending something the server will not accept.
+   */
+  tokens_invalid_before?: number;
 }
 
 export interface ProtectConfigResource extends ClerkResource {
-  id: string;
+  /** Not sent by every instance, and read by nothing in the SDK. */
+  id?: string;
   loaders?: ProtectLoader[];
+  /** See {@link ProtectConfigJSON.tokens_invalid_before}. */
+  tokens_invalid_before?: number;
   __internal_toSnapshot: () => ProtectConfigJSONSnapshot;
 }