@owlmeans/consent 0.1.18-rc.8 → 0.1.18

package/tests/linker.spec.ts

@@ -1,17 +1,10 @@
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-import {
-  CONSENT_ANALYTICS, CONSENT_ESSENTIAL, CONSENT_FUNCTIONAL, CONSENT_KEY, CONSENT_LANGUAGE_EVENT,
-  CONSENT_LANGUAGE_KEY, CONSENT_MARKETING, CONSENT_PENDING_LANGUAGE, DEFAULT_CONSENT_CATEGORIES,
-} from '../src/consts.js'
-import { consentBootstrapScript } from '../src/gtm.js'
-import {
-  consentLinker, consentLinkerScript, decodeConsentLink, encodeConsentLink, stripConsentLinkParam, writeConsentLanguage,
-  CONSENT_LINK_MAX_AGE, CONSENT_LINK_PARAM,
-} from '../src/linker.js'
-import { adoptConsentLanguage, consentDomains, decorateConsentUrl, registerConsentPlugin } from '../src/plugins.js'
+import { CONSENT_ANALYTICS, CONSENT_ESSENTIAL, CONSENT_KEY, CONSENT_LANGUAGE_KEY, CONSENT_MARKETING, DEFAULT_CONSENT_CATEGORIES, CONSENT_LINK_MAX_AGE, CONSENT_LINK_PARAM } from '../src/consts.js'
+import { consentModeHelper } from '../src/gtobserver.js'
+import { consentLinkHelper } from '../src/linker.js'
+import { consentPluginHelper } from '../src/plugins.js'
 import { makeConsentStore } from '../src/store.js'
-import { consentAllowsScript, functionalGranted, functionalKeysOf, writeFunctionalPreference } from '../src/functional.js'
-import { readConsent, writeConsent } from '../src/storage.js'
+import { consentStorageHelper } from '../src/storage.js'
 import type { ConsentRecord } from '../src/types.js'
 
 /** A minimal browser: storage, a settable referrer, and a `location`/`history` pair that actually
@@ -74,41 +67,40 @@ beforeEach(() => {
   env.goto('https://platform.test/dispatcher')
   delete (globalThis as any).dataLayer
   delete (globalThis as any).cookieConsentSetup
-  delete (globalThis as any)[CONSENT_PENDING_LANGUAGE]
 })
 
 describe('encodeConsentLink / decodeConsentLink', () => {
   test('round-trips a record through the optional categories only', () => {
     const record: ConsentRecord = { [CONSENT_ESSENTIAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
-    const encoded = encodeConsentLink(record)
-    const decoded = decodeConsentLink(encoded)
+    const encoded = consentLinkHelper.encodeConsentLink(record)
+    const decoded = consentLinkHelper.decodeConsentLink(encoded)
 
     expect(decoded?.v).toBe(2)
-    expect(decoded?.c).toEqual({ [CONSENT_FUNCTIONAL]: 0, [CONSENT_ANALYTICS]: 1, [CONSENT_MARKETING]: 0 })
+    expect(decoded?.c).toEqual({ [CONSENT_ANALYTICS]: 1, [CONSENT_MARKETING]: 0 })
     expect(decoded?.t).toBeGreaterThan(0)
   })
 
   test('rejects garbage rather than throwing', () => {
-    expect(decodeConsentLink('not-base64url-json')).toBeNull()
-    expect(decodeConsentLink('')).toBeNull()
+    expect(consentLinkHelper.decodeConsentLink('not-base64url-json')).toBeNull()
+    expect(consentLinkHelper.decodeConsentLink('')).toBeNull()
   })
 
   test('rejects a payload of the wrong version', () => {
     const bad = Buffer.from(JSON.stringify({ v: 1, c: {}, t: nowSeconds() })).toString('base64url')
 
-    expect(decodeConsentLink(bad)).toBeNull()
+    expect(consentLinkHelper.decodeConsentLink(bad)).toBeNull()
   })
 })
 
 describe('consentLinker().decorate', () => {
-  const plugin = consentLinker()
+  const plugin = consentLinkHelper.consentLinker()
   const record: ConsentRecord = { [CONSENT_ESSENTIAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
 
   test('decorates a listed, foreign host', () => {
     const decorated = plugin.decorate!(new URL('https://site.test/legal/cookies'), record, linkerOpts)
 
     expect(decorated).not.toBeNull()
-    const payload = decodeConsentLink(decorated!.searchParams.get(CONSENT_LINK_PARAM)!)
+    const payload = consentLinkHelper.decodeConsentLink(decorated!.searchParams.get(CONSENT_LINK_PARAM)!)
     expect(payload?.c[CONSENT_ANALYTICS]).toBe(1)
   })
 
@@ -134,8 +126,8 @@ describe('consentLinker().decorate', () => {
 })
 
 describe('consentLinker().adopt — every trust rule', () => {
-  const plugin = consentLinker()
-  const valid = () => encodeConsentLink({ [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false })
+  const plugin = consentLinkHelper.consentLinker()
+  const valid = () => consentLinkHelper.encodeConsentLink({ [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false })
 
   test('adopts a fresh, referred, fully-covered decision', () => {
     env.goto(`https://platform.test/dispatcher?owlcc=${valid()}`, 'https://site.test/')
@@ -201,21 +193,21 @@ describe('consentLinker().adopt — every trust rule', () => {
 describe('stripConsentLinkParam', () => {
   test('removes only the parameter, keeping the rest and the hash', () => {
     env.goto('https://platform.test/dispatcher?owlcc=abc&next=%2Fhome&ref=site#panel')
-    stripConsentLinkParam(linkerOpts)
+    consentLinkHelper.stripConsentLinkParam(linkerOpts)
 
     expect(env.href()).toBe('https://platform.test/dispatcher?next=%2Fhome&ref=site#panel')
   })
 
   test('is a no-op with no parameter present', () => {
     env.goto('https://platform.test/dispatcher?next=%2Fhome')
-    stripConsentLinkParam(linkerOpts)
+    consentLinkHelper.stripConsentLinkParam(linkerOpts)
 
     expect(env.href()).toBe('https://platform.test/dispatcher?next=%2Fhome')
   })
 
   test('is a no-op with no linker configured', () => {
     env.goto('https://platform.test/dispatcher?owlcc=abc')
-    stripConsentLinkParam({})
+    consentLinkHelper.stripConsentLinkParam({})
 
     expect(env.href()).toBe('https://platform.test/dispatcher?owlcc=abc')
   })
@@ -223,8 +215,8 @@ describe('stripConsentLinkParam', () => {
 
 describe('consentDomains / decorateConsentUrl (registry level)', () => {
   test('discloses the current host plus every plugin-named domain, deduplicated', () => {
-    registerConsentPlugin(consentLinker())
-    const domains = consentDomains(linkerOpts)
+    consentPluginHelper.registerConsentPlugin(consentLinkHelper.consentLinker())
+    const domains = consentPluginHelper.consentDomains(linkerOpts)
 
     expect(domains).toContain('platform.test')
     expect(domains).toContain('site.test')
@@ -232,18 +224,18 @@ describe('consentDomains / decorateConsentUrl (registry level)', () => {
   })
 
   test('decorateConsentUrl applies the registered plugin to a plain URL', () => {
-    registerConsentPlugin(consentLinker())
+    consentPluginHelper.registerConsentPlugin(consentLinkHelper.consentLinker())
     const record: ConsentRecord = { [CONSENT_ESSENTIAL]: true, [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false }
-    const decorated = decorateConsentUrl('https://site.test/legal/cookies', record, linkerOpts)
+    const decorated = consentPluginHelper.decorateConsentUrl('https://site.test/legal/cookies', record, linkerOpts)
 
     expect(decorated.searchParams.has(CONSENT_LINK_PARAM)).toBe(true)
   })
 
   test('registering the same alias twice replaces rather than duplicates', () => {
-    registerConsentPlugin(consentLinker())
-    registerConsentPlugin(consentLinker())
+    consentPluginHelper.registerConsentPlugin(consentLinkHelper.consentLinker())
+    consentPluginHelper.registerConsentPlugin(consentLinkHelper.consentLinker())
     const record: ConsentRecord = { [CONSENT_ESSENTIAL]: true }
-    const decorated = decorateConsentUrl('https://site.test/', record, linkerOpts)
+    const decorated = consentPluginHelper.decorateConsentUrl('https://site.test/', record, linkerOpts)
 
     // A duplicate `decorate` implementation would still be idempotent (same value both times), so
     // what this actually guards is that the registry never grows unbounded per alias.
@@ -254,7 +246,7 @@ describe('consentDomains / decorateConsentUrl (registry level)', () => {
 describe('the store, with a linker configured', () => {
   test('adopts on init when nothing is stored yet, and applies it', () => {
     const record = { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
-    env.goto(`https://platform.test/dispatcher?owlcc=${encodeConsentLink(record)}`, 'https://site.test/')
+    env.goto(`https://platform.test/dispatcher?owlcc=${consentLinkHelper.encodeConsentLink(record)}`, 'https://site.test/')
 
     const store = makeConsentStore()
     store.init({ silent: true, linker: { domains: DOMAINS } })
@@ -263,7 +255,7 @@ describe('the store, with a linker configured', () => {
     expect(store.get().record?.[CONSENT_ANALYTICS]).toBe(true)
     expect(store.granted(CONSENT_ESSENTIAL)).toBe(true)
     // Written through, not just held in memory — a second page load must see it too.
-    expect(readConsent()?.[CONSENT_ANALYTICS]).toBe(true)
+    expect(consentStorageHelper.readConsent()?.[CONSENT_ANALYTICS]).toBe(true)
   })
 
   test('strips the parameter from the URL either way', () => {
@@ -276,9 +268,9 @@ describe('the store, with a linker configured', () => {
   })
 
   test('never overwrites a decision this document already made', () => {
-    writeConsent({ [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false })
+    consentStorageHelper.writeConsent({ [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false })
     const incoming = { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: true }
-    env.goto(`https://platform.test/dispatcher?owlcc=${encodeConsentLink(incoming)}`, 'https://site.test/')
+    env.goto(`https://platform.test/dispatcher?owlcc=${consentLinkHelper.encodeConsentLink(incoming)}`, 'https://site.test/')
 
     const store = makeConsentStore()
     store.init({ silent: true, linker: { domains: DOMAINS } })
@@ -299,7 +291,7 @@ describe('the store, with a linker configured', () => {
 
 describe('consentBootstrapScript with a linker: order and shape', () => {
   test('the linker fragment sits after the default push and before the storage read', () => {
-    const script = consentBootstrapScript({ linker: { domains: DOMAINS } })
+    const script = consentModeHelper.consentBootstrapScript({ linker: { domains: DOMAINS } })
     const defaultAt = script.indexOf("'consent','default'")
     const linkerAt = script.indexOf('URLSearchParams')
     const storageAt = script.indexOf('w.localStorage.getItem')
@@ -310,11 +302,11 @@ describe('consentBootstrapScript with a linker: order and shape', () => {
   })
 
   test('emits nothing extra with no linker configured', () => {
-    expect(consentBootstrapScript()).not.toContain('URLSearchParams')
+    expect(consentModeHelper.consentBootstrapScript()).not.toContain('URLSearchParams')
   })
 
   test('escapes "<" inside embedded strings', () => {
-    const script = consentLinkerScript({ linker: { domains: ['<script>evil.test'] } })
+    const script = consentLinkHelper.consentLinkerScript({ linker: { domains: ['<script>evil.test'] } })
 
     expect(script).not.toContain('<script>evil.test')
     expect(script).toContain('\\u003cscript>evil.test')
@@ -324,31 +316,31 @@ describe('consentBootstrapScript with a linker: order and shape', () => {
 describe('consentLinkerScript, executed', () => {
   test('adopts a valid link and strips the parameter, via new Function', () => {
     const record = { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
-    env.goto(`https://platform.test/dispatcher?owlcc=${encodeConsentLink(record)}`, 'https://site.test/')
+    env.goto(`https://platform.test/dispatcher?owlcc=${consentLinkHelper.encodeConsentLink(record)}`, 'https://site.test/')
 
-    const script = consentLinkerScript({ linker: { domains: DOMAINS } })
+    const script = consentLinkHelper.consentLinkerScript({ linker: { domains: DOMAINS } })
     // eslint-disable-next-line no-new-func
     new Function(script)()
 
     expect(env.href()).toBe('https://platform.test/dispatcher')
-    expect(readConsent()?.[CONSENT_ANALYTICS]).toBe(true)
+    expect(consentStorageHelper.readConsent()?.[CONSENT_ANALYTICS]).toBe(true)
   })
 
   test('never overwrites an existing record, and still strips', () => {
-    writeConsent({ [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false })
+    consentStorageHelper.writeConsent({ [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false })
     const incoming = { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: true }
-    env.goto(`https://platform.test/dispatcher?owlcc=${encodeConsentLink(incoming)}`, 'https://site.test/')
+    env.goto(`https://platform.test/dispatcher?owlcc=${consentLinkHelper.encodeConsentLink(incoming)}`, 'https://site.test/')
 
-    const script = consentLinkerScript({ linker: { domains: DOMAINS } })
+    const script = consentLinkHelper.consentLinkerScript({ linker: { domains: DOMAINS } })
     // eslint-disable-next-line no-new-func
     new Function(script)()
 
     expect(env.href()).toBe('https://platform.test/dispatcher')
-    expect(readConsent()?.[CONSENT_ANALYTICS]).toBe(false)
+    expect(consentStorageHelper.readConsent()?.[CONSENT_ANALYTICS]).toBe(false)
   })
 
   test('is an empty string with no linker configured', () => {
-    expect(consentLinkerScript({})).toBe('')
+    expect(consentLinkHelper.consentLinkerScript({})).toBe('')
   })
 })
 
@@ -359,12 +351,11 @@ describe('every category the built-in bundle carries', () => {
     expect(DEFAULT_CONSENT_CATEGORIES.filter(c => c.required === true).map(c => c.key)).toEqual([CONSENT_ESSENTIAL])
   })
 
-  test('functional is an optional category that drives no Consent Mode signal', () => {
-    const functional = DEFAULT_CONSENT_CATEGORIES.find(c => c.key === CONSENT_FUNCTIONAL)
-
-    expect(functional).toBeDefined()
-    expect(functional?.required).not.toBe(true)
-    expect(functional?.signals ?? []).toEqual([])
+  test('the optional categories are analytics and marketing — nothing asks about the language', () => {
+    // The interface language is strictly necessary storage: no category governs it, so the default
+    // set has no "functional" row that would offer a choice which changes nothing.
+    expect(DEFAULT_CONSENT_CATEGORIES.filter(c => c.required !== true).map(c => c.key))
+      .toEqual([CONSENT_ANALYTICS, CONSENT_MARKETING])
   })
 })
 
@@ -373,29 +364,29 @@ describe('language: the link parameter', () => {
 
   test('carries the page language as `l`, lower-cased, when the sender turned it on', () => {
     env.lang('PL')
-    const decoded = decodeConsentLink(encodeConsentLink({ [CONSENT_ANALYTICS]: true }, withLanguage))
+    const decoded = consentLinkHelper.decodeConsentLink(consentLinkHelper.encodeConsentLink({ [CONSENT_ANALYTICS]: true }, withLanguage))
 
     expect(decoded?.l).toBe('pl')
-    expect(decoded?.c).toEqual({ [CONSENT_FUNCTIONAL]: 0, [CONSENT_ANALYTICS]: 1, [CONSENT_MARKETING]: 0 })
+    expect(decoded?.c).toEqual({ [CONSENT_ANALYTICS]: 1, [CONSENT_MARKETING]: 0 })
   })
 
   test('carries no `l` when the sender did not turn it on, whatever the page says', () => {
     env.lang('pl')
 
-    expect(decodeConsentLink(encodeConsentLink({ [CONSENT_ANALYTICS]: true }, linkerOpts))?.l).toBeUndefined()
+    expect(consentLinkHelper.decodeConsentLink(consentLinkHelper.encodeConsentLink({ [CONSENT_ANALYTICS]: true }, linkerOpts))?.l).toBeUndefined()
   })
 
   test('carries no `l` for a page with no usable language', () => {
     for (const lang of ['', 'not a language!', '12']) {
       env.lang(lang)
 
-      expect(decodeConsentLink(encodeConsentLink(null, withLanguage))?.l).toBeUndefined()
+      expect(consentLinkHelper.decodeConsentLink(consentLinkHelper.encodeConsentLink(null, withLanguage))?.l).toBeUndefined()
     }
   })
 
   test('encodes no decision at all as an empty `c`', () => {
     env.lang('de')
-    const decoded = decodeConsentLink(encodeConsentLink(null, withLanguage))
+    const decoded = consentLinkHelper.decodeConsentLink(consentLinkHelper.encodeConsentLink(null, withLanguage))
 
     expect(decoded?.c).toEqual({})
     expect(decoded?.l).toBe('de')
@@ -405,7 +396,7 @@ describe('language: the link parameter', () => {
     const raw = Buffer.from(JSON.stringify({
       v: 2, c: { [CONSENT_ANALYTICS]: 1 }, t: nowSeconds(), l: '../../etc',
     })).toString('base64url')
-    const decoded = decodeConsentLink(raw)
+    const decoded = consentLinkHelper.decodeConsentLink(raw)
 
     expect(decoded).not.toBeNull()
     expect(decoded?.l).toBeUndefined()
@@ -414,7 +405,7 @@ describe('language: the link parameter', () => {
 })
 
 describe('language: consentLinker().decorate', () => {
-  const plugin = consentLinker()
+  const plugin = consentLinkHelper.consentLinker()
   const withLanguage = { linker: { domains: DOMAINS, language: {} } }
   const record: ConsentRecord = { [CONSENT_ESSENTIAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
 
@@ -423,14 +414,14 @@ describe('language: consentLinker().decorate', () => {
     const decorated = plugin.decorate!(new URL('https://site.test/start'), null, withLanguage)
 
     expect(decorated).not.toBeNull()
-    const payload = decodeConsentLink(decorated!.searchParams.get(CONSENT_LINK_PARAM)!)
+    const payload = consentLinkHelper.decodeConsentLink(decorated!.searchParams.get(CONSENT_LINK_PARAM)!)
     expect(payload?.l).toBe('uk')
     expect(payload?.c).toEqual({})
   })
 
   test('carries the decision and the language together', () => {
     env.lang('pl')
-    const payload = decodeConsentLink(
+    const payload = consentLinkHelper.decodeConsentLink(
       plugin.decorate!(new URL('https://site.test/start'), record, withLanguage)!.searchParams.get(CONSENT_LINK_PARAM)!
     )
 
@@ -458,12 +449,12 @@ describe('language: consentLinker().decorate', () => {
 })
 
 describe('language: consentLinker().adoptLanguage', () => {
-  const plugin = consentLinker()
+  const plugin = consentLinkHelper.consentLinker()
   const receiving = { linker: { domains: DOMAINS, language: { supported: ['en', 'pl', 'de', 'fr'] } } }
   const carried = (lang: string, record: ConsentRecord | null = null): string => {
     env.lang(lang)
 
-    return encodeConsentLink(record, { linker: { domains: DOMAINS, language: {} } })
+    return consentLinkHelper.encodeConsentLink(record, { linker: { domains: DOMAINS, language: {} } })
   }
   const arrive = (owlcc: string, referrer = 'https://site.test/') => {
     env.goto(`https://platform.test/dispatcher?owlcc=${owlcc}`, referrer)
@@ -529,115 +520,64 @@ describe('language: consentLinker().adoptLanguage', () => {
   })
 
   test('registry: adoptConsentLanguage asks the registered plugin', () => {
-    registerConsentPlugin(consentLinker())
+    consentPluginHelper.registerConsentPlugin(consentLinkHelper.consentLinker())
     arrive(carried('pl'))
 
-    expect(adoptConsentLanguage(receiving)).toBe('pl')
-    expect(adoptConsentLanguage(linkerOpts)).toBeNull()
+    expect(consentPluginHelper.adoptConsentLanguage(receiving)).toBe('pl')
+    expect(consentPluginHelper.adoptConsentLanguage(linkerOpts)).toBeNull()
   })
 })
 
-describe('language: only while functional storage is granted', () => {
+describe('language: strictly necessary, stored whatever the cookie decision is', () => {
   const receiving = { silent: true, linker: { domains: DOMAINS, language: { supported: ['en', 'pl', 'de'] } } }
   const arrive = (lang: string, record: ConsentRecord | null = null, referrer = 'https://site.test/') => {
     env.lang(lang)
-    const owlcc = encodeConsentLink(record, { linker: { domains: DOMAINS, language: {} } })
+    const owlcc = consentLinkHelper.encodeConsentLink(record, { linker: { domains: DOMAINS, language: {} } })
     env.goto(`https://platform.test/dispatcher?owlcc=${owlcc}`, referrer)
     env.lang('en')
   }
-  /** A decision that allows remembering a preference, and one that refuses everything optional. */
-  const granted: ConsentRecord = { [CONSENT_FUNCTIONAL]: true, [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false }
-  const refused: ConsentRecord = { [CONSENT_FUNCTIONAL]: false, [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false }
-  const legacy: ConsentRecord = { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
-
-  test('writeConsentLanguage writes only on a functional grant, and says so', () => {
-    expect(writeConsentLanguage('pl', receiving)).toBe(false)
-
-    writeConsent(refused)
-    expect(writeConsentLanguage('pl', receiving)).toBe(false)
-
-    writeConsent(legacy)
-    expect(writeConsentLanguage('pl', receiving)).toBe(false)
-    expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-
-    writeConsent(granted)
-    expect(writeConsentLanguage('pl', receiving)).toBe(true)
-    expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
-  })
-
-  test('a grant that survives only in the cookie counts; a corrupt record does not', () => {
-    env.store.set(CONSENT_KEY, '{not json')
-    expect(writeConsentLanguage('pl', receiving)).toBe(false)
+  const accepted: ConsentRecord = { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: true }
+  const refused: ConsentRecord = { [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false }
+  /** Saved before the `functional` category was retired: an extra key nobody reads any more. */
+  const withRetiredKey: ConsentRecord = { functional: false, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
 
-    env.reset()
-    ;(globalThis as any).document.cookie = `${CONSENT_KEY}=${JSON.stringify({ v: 2, essential: true, ...granted })}`
-    expect(writeConsentLanguage('pl', receiving)).toBe(true)
-    expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
+  test('writeConsentLanguage writes with no decision, a refusal, an acceptance or an old record', () => {
+    for (const record of [null, refused, accepted, withRetiredKey]) {
+      env.reset()
+      if (record != null) {
+        consentStorageHelper.writeConsent(record)
+      }
+      expect(consentLinkHelper.writeConsentLanguage('pl', receiving)).toBe(true)
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
+    }
   })
 
-  test('functionalGranted, writeFunctionalPreference and functionalKeysOf agree with the record', () => {
-    expect(functionalGranted()).toBe(false)
-    expect(writeFunctionalPreference('theme-choice', 'dark')).toBe(false)
-
-    writeConsent(granted)
-    expect(functionalGranted()).toBe(true)
-    expect(writeFunctionalPreference('theme-choice', 'dark')).toBe(true)
-    expect(env.store.get('theme-choice')).toBe('dark')
-
-    expect(functionalKeysOf()).toEqual([CONSENT_LANGUAGE_KEY])
-    expect(functionalKeysOf({ functionalKeys: ['a', 'b'], linker: { domains: DOMAINS, language: { storageKey: 'a' } } }))
-      .toEqual(['a', 'b'])
+  test('storage that refuses the write is not an error', () => {
+    const storage = (globalThis as any).localStorage
+    const setItem = storage.setItem
+    storage.setItem = () => { throw new Error('blocked') }
+    try {
+      expect(consentLinkHelper.writeConsentLanguage('pl', receiving)).toBe(false)
+    } finally {
+      // The mock storage is shared by every test in the file.
+      storage.setItem = setItem
+    }
   })
 
   describe('the store', () => {
-    test('with no decision the language is NOT stored — it is held in memory, the dialog asks, the parameter is stripped', () => {
+    test('with no decision the language is stored at once, the dialog asks, the parameter is stripped', () => {
       arrive('pl')
 
       const store = makeConsentStore()
       store.init(receiving)
 
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect(store.pendingLanguage()).toBe('pl')
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
       expect(store.get().open).toBe(true)
       expect(env.href()).toBe('https://platform.test/dispatcher')
     })
 
-    test('answering the dialog AFTER arrival stores the waiting language on a grant, and tells the app', () => {
-      arrive('pl')
-      const store = makeConsentStore()
-      store.init(receiving)
-      const heard: string[] = []
-      // Process-wide globals: put them back, whatever the assertions do (bun shares them across files).
-      const saved = { dispatch: (globalThis as any).dispatchEvent, custom: (globalThis as any).CustomEvent }
-      ;(globalThis as any).dispatchEvent = (e: any) => { if (e.type === CONSENT_LANGUAGE_EVENT) heard.push(e.detail.language) }
-      ;(globalThis as any).CustomEvent = class { constructor(public type: string, public init: any) {} get detail() { return this.init.detail } }
-      try {
-        store.save(granted)
-      } finally {
-        (globalThis as any).dispatchEvent = saved.dispatch
-        ;(globalThis as any).CustomEvent = saved.custom
-      }
-
-      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
-      expect(store.pendingLanguage()).toBeNull()
-      expect(heard).toEqual(['pl'])
-    })
-
-    test('answering with a refusal stores nothing, and the language keeps waiting for a later grant', () => {
-      arrive('pl')
-      const store = makeConsentStore()
-      store.init(receiving)
-
-      store.save(refused)
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect(store.pendingLanguage()).toBe('pl')
-
-      store.save(granted)
-      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
-    })
-
-    test('a decision carried by the link that grants functional stores decision and language together', () => {
-      arrive('de', { [CONSENT_FUNCTIONAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false })
+    test('a decision carried by the link is stored together with the language', () => {
+      arrive('de', { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false })
 
       const store = makeConsentStore()
       store.init(receiving)
@@ -647,80 +587,62 @@ describe('language: only while functional storage is granted', () => {
       expect(store.get().record?.[CONSENT_ANALYTICS]).toBe(true)
     })
 
-    test('a carried "reject all" stores the decision but NOT the language', () => {
+    test('a carried "reject all" stores the decision AND the language', () => {
       arrive('de', refused)
 
       const store = makeConsentStore()
       store.init(receiving)
 
       expect(store.get().open).toBe(false)
-      expect(store.get().record?.[CONSENT_FUNCTIONAL]).toBe(false)
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect(store.pendingLanguage()).toBe('de')
+      expect(store.get().record?.[CONSENT_ANALYTICS]).toBe(false)
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('de')
     })
 
-    test('a functional grant stored here is enough for a link that carries only the language', () => {
-      writeConsent(granted)
-      arrive('pl')
+    test('a stored decision of any kind lets the link\'s language through, and still wins over its decision', () => {
+      for (const stored of [refused, accepted, withRetiredKey]) {
+        env.reset()
+        consentStorageHelper.writeConsent(stored)
+        arrive('pl', { [CONSENT_ANALYTICS]: !stored[CONSENT_ANALYTICS], [CONSENT_MARKETING]: true })
 
-      makeConsentStore().init(receiving)
+        const store = makeConsentStore()
+        store.init(receiving)
 
-      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
+        expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
+        expect(store.get().record?.[CONSENT_ANALYTICS]).toBe(stored[CONSENT_ANALYTICS])
+      }
     })
 
-    test('the carried language outranks one chosen here earlier, while a stored decision still wins', () => {
-      writeConsent(granted)
+    test('the carried language outranks one chosen here earlier', () => {
       env.store.set(CONSENT_LANGUAGE_KEY, 'de')
-      arrive('pl', { [CONSENT_FUNCTIONAL]: false, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: true })
+      arrive('pl')
 
-      const store = makeConsentStore()
-      store.init(receiving)
+      makeConsentStore().init(receiving)
 
       expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
-      expect(store.get().record?.[CONSENT_ANALYTICS]).toBe(false)
     })
 
-    test('no functional grant removes a language stored earlier — on init, and on a refusal', () => {
-      env.store.set(CONSENT_LANGUAGE_KEY, 'de')
+    test('answering the dialog never touches the language, in either direction', () => {
+      arrive('pl')
       const store = makeConsentStore()
       store.init(receiving)
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
 
-      store.save(granted)
-      env.store.set(CONSENT_LANGUAGE_KEY, 'de')
       store.save(refused)
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-    })
-
-    test('a grant keeps what is stored, and every functional key is purged when it is withdrawn', () => {
-      writeConsent(granted)
-      env.store.set(CONSENT_LANGUAGE_KEY, 'de')
-      env.store.set('locale_chosen', '1')
-      const opts = { ...receiving, functionalKeys: [CONSENT_LANGUAGE_KEY, 'locale_chosen'] }
-      const store = makeConsentStore()
-      store.init(opts)
-      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('de')
-      expect(env.store.get('locale_chosen')).toBe('1')
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
 
-      store.save(refused)
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect(env.store.has('locale_chosen')).toBe(false)
+      store.save(accepted)
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
     })
 
-    test('a record saved before the category existed is not a grant', () => {
-      writeConsent(legacy)
+    test('a language stored earlier survives every decision', () => {
       env.store.set(CONSENT_LANGUAGE_KEY, 'de')
-      arrive('pl')
-
       const store = makeConsentStore()
       store.init(receiving)
+      store.save(refused)
 
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect(store.pendingLanguage()).toBe('pl')
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('de')
     })
 
     test('honours a custom storage key', () => {
-      writeConsent(granted)
       arrive('pl')
 
       makeConsentStore().init({ ...receiving, linker: { ...receiving.linker, language: { supported: ['pl'], storageKey: 'app-lng' } } })
@@ -729,110 +651,72 @@ describe('language: only while functional storage is granted', () => {
       expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
     })
 
-    test('writes nothing for an unsupported language or an untrusted referrer, grant or not', () => {
-      writeConsent(granted)
+    test('writes nothing for an unsupported language or an untrusted referrer', () => {
       arrive('ja')
       makeConsentStore().init(receiving)
       expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
 
       arrive('pl', null, 'https://evil.test/')
-      const store = makeConsentStore()
-      store.init(receiving)
+      makeConsentStore().init(receiving)
       expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect(store.pendingLanguage()).toBeNull()
-    })
-
-    test('picks up what the inline fragment left on window, and clears it', () => {
-      ;(globalThis as any)[CONSENT_PENDING_LANGUAGE] = 'pl'
-      env.goto('https://platform.test/dispatcher')
-
-      const store = makeConsentStore()
-      store.init(receiving)
-
-      expect(store.pendingLanguage()).toBe('pl')
-      expect((globalThis as any)[CONSENT_PENDING_LANGUAGE]).toBeUndefined()
-
-      store.save(granted)
-      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
     })
   })
 
   describe('the inline fragment', () => {
-    const run = (opts: Parameters<typeof consentLinkerScript>[0] = receiving) => {
+    const run = (opts: Parameters<typeof consentLinkHelper.consentLinkerScript>[0] = receiving) => {
       // eslint-disable-next-line no-new-func
-      new Function(consentLinkerScript(opts))()
+      new Function(consentLinkHelper.consentLinkerScript(opts))()
     }
     const all = { linker: { domains: DOMAINS, language: { supported: ['en', 'pl', 'de', 'fr'] } } }
 
-    test('with no decision anywhere it writes NO language, leaves it on window, adopts nothing, and still strips', () => {
+    test('with no decision anywhere it stores the language, adopts nothing, and still strips', () => {
       arrive('pl')
       run()
 
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect((globalThis as any)[CONSENT_PENDING_LANGUAGE]).toBe('pl')
-      expect(readConsent()).toBeNull()
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
+      expect(consentStorageHelper.readConsent()).toBeNull()
       expect(env.href()).toBe('https://platform.test/dispatcher')
     })
 
-    test('a link that grants functional writes decision and language together', () => {
-      arrive('fr', { [CONSENT_FUNCTIONAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false })
+    test('a link that carries a decision writes decision and language together', () => {
+      arrive('fr', { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false })
       run(all)
 
       expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('fr')
-      expect(readConsent()?.[CONSENT_ANALYTICS]).toBe(true)
-      expect((globalThis as any)[CONSENT_PENDING_LANGUAGE]).toBeUndefined()
+      expect(consentStorageHelper.readConsent()?.[CONSENT_ANALYTICS]).toBe(true)
     })
 
-    test('a link that carries "reject all" adopts the decision but keeps the language in memory only', () => {
+    test('a link that carries "reject all" adopts the decision and stores the language', () => {
       arrive('fr', refused)
       run(all)
 
-      expect(readConsent()?.[CONSENT_FUNCTIONAL]).toBe(false)
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect((globalThis as any)[CONSENT_PENDING_LANGUAGE]).toBe('fr')
-    })
-
-    test('a functional grant stored here is enough, and the link\'s own decision never overwrites it', () => {
-      writeConsent({ ...granted, [CONSENT_ANALYTICS]: false })
-      arrive('de', { [CONSENT_FUNCTIONAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: true })
-      run()
-
-      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('de')
-      expect(readConsent()?.[CONSENT_ANALYTICS]).toBe(false)
-    })
-
-    test('a functional grant stored here is enough for a link that carries only the language', () => {
-      writeConsent(granted)
-      arrive('pl')
-      run()
-
-      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
+      expect(consentStorageHelper.readConsent()?.[CONSENT_ANALYTICS]).toBe(false)
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('fr')
     })
 
-    test('a stored refusal or a legacy record is not a grant: nothing written, language kept in memory', () => {
-      for (const record of [refused, legacy]) {
+    test('a stored record of any kind lets the language through, and the link\'s decision never overwrites it', () => {
+      for (const stored of [refused, accepted, withRetiredKey]) {
         env.reset()
-        delete (globalThis as any)[CONSENT_PENDING_LANGUAGE]
-        writeConsent(record)
-        arrive('pl')
+        consentStorageHelper.writeConsent(stored)
+        arrive('de', { [CONSENT_ANALYTICS]: !stored[CONSENT_ANALYTICS], [CONSENT_MARKETING]: true })
         run()
 
-        expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-        expect((globalThis as any)[CONSENT_PENDING_LANGUAGE]).toBe('pl')
+        expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('de')
+        expect(consentStorageHelper.readConsent()?.[CONSENT_ANALYTICS]).toBe(stored[CONSENT_ANALYTICS])
       }
     })
 
-    test('an unparseable stored record is no grant: nothing is written, and nothing is adopted over it', () => {
+    test('an unparseable stored record still lets the language through, and nothing is adopted over it', () => {
       env.store.set(CONSENT_KEY, '{not json')
-      arrive('pl', { [CONSENT_FUNCTIONAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: true })
+      arrive('pl', { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: true })
       run()
 
-      expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
+      expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('pl')
       expect(env.store.get(CONSENT_KEY)).toBe('{not json')
     })
 
     test('matches by base tag and by the receiver\'s spelling, like the TypeScript path', () => {
-      const grant = { [CONSENT_FUNCTIONAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
+      const grant = { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false }
       arrive('de-CH', grant)
       run()
       expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('de')
@@ -843,97 +727,48 @@ describe('language: only while functional storage is granted', () => {
       expect(env.store.get(CONSENT_LANGUAGE_KEY)).toBe('PL')
     })
 
-    test('agrees with the TypeScript path on what it refuses, grant or not', () => {
-      writeConsent(granted)
+    test('agrees with the TypeScript path on what it refuses', () => {
       arrive('ja')
       run()
       expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
 
-      delete (globalThis as any)[CONSENT_PENDING_LANGUAGE]
       arrive('pl', null, 'https://evil.test/')
       run()
       expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect((globalThis as any)[CONSENT_PENDING_LANGUAGE]).toBeUndefined()
 
       arrive('pl', null, '')
       run()
       expect(env.store.has(CONSENT_LANGUAGE_KEY)).toBe(false)
-      expect((globalThis as any)[CONSENT_PENDING_LANGUAGE]).toBeUndefined()
     })
 
     test('honours a custom storage key', () => {
-      arrive('pl', { [CONSENT_FUNCTIONAL]: true, [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false })
+      arrive('pl', { [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: false })
       run({ linker: { domains: DOMAINS, language: { supported: ['pl'], storageKey: 'app-lng' } } })
 
       expect(env.store.get('app-lng')).toBe('pl')
     })
 
     test('a page that only sends carries no language code at all', () => {
-      const script = consentLinkerScript({ linker: { domains: DOMAINS, language: {} } })
+      const script = consentLinkHelper.consentLinkerScript({ linker: { domains: DOMAINS, language: {} } })
 
       expect(script).not.toContain(CONSENT_LANGUAGE_KEY)
-      expect(script).not.toContain(CONSENT_PENDING_LANGUAGE)
-      expect(consentLinkerScript(linkerOpts)).toBe(script)
+      expect(consentLinkHelper.consentLinkerScript(linkerOpts)).toBe(script)
     })
 
-    test('the bootstrap embeds it, after the decision is settled and before its own storage read', () => {
-      const script = consentBootstrapScript(receiving)
+    test('the bootstrap embeds it, after the defaults and before its own storage read', () => {
+      const script = consentModeHelper.consentBootstrapScript(receiving)
 
       expect(script.indexOf(CONSENT_LANGUAGE_KEY)).toBeGreaterThan(script.indexOf("'consent','default'"))
-      // The fragment reads storage itself (to know what is granted) before it writes the language;
-      // the bootstrap's own read is the LAST one, after the whole fragment.
+      // The fragment reads storage itself (to know whether a decision exists) before it writes the
+      // language; the bootstrap's own read is the LAST one, after the whole fragment.
       expect(script.indexOf(CONSENT_LANGUAGE_KEY)).toBeLessThan(script.lastIndexOf('w.localStorage.getItem'))
     })
 
     test('escapes "<" in a configured language too', () => {
-      const script = consentLinkerScript({ linker: { domains: DOMAINS, language: { supported: ['<b>'], storageKey: '<k>' } } })
+      const script = consentLinkHelper.consentLinkerScript({ linker: { domains: DOMAINS, language: { supported: ['<b>'], storageKey: '<k>' } } })
 
       expect(script).not.toContain('<b>')
       expect(script).not.toContain('<k>')
     })
   })
 })
-
-describe('consentAllowsScript, executed', () => {
-  const run = (opts?: Parameters<typeof consentAllowsScript>[0]) => {
-    // eslint-disable-next-line no-new-func
-    new Function(consentAllowsScript(opts))()
-
-    return (globalThis as any).owlConsentAllows as (category: string) => boolean
-  }
-  afterEach(() => { delete (globalThis as any).owlConsentAllows })
-
-  test('answers from the stored record, category by category', () => {
-    writeConsent({ [CONSENT_FUNCTIONAL]: true, [CONSENT_ANALYTICS]: false, [CONSENT_MARKETING]: false })
-    const allows = run()
-
-    expect(allows(CONSENT_FUNCTIONAL)).toBe(true)
-    expect(allows(CONSENT_ANALYTICS)).toBe(false)
-    expect(allows('unknown')).toBe(false)
-  })
-
-  test('no record, a legacy record and a corrupt one are all a no', () => {
-    const allows = run()
-    expect(allows(CONSENT_FUNCTIONAL)).toBe(false)
-
-    writeConsent({ [CONSENT_ANALYTICS]: true, [CONSENT_MARKETING]: true })
-    expect(allows(CONSENT_FUNCTIONAL)).toBe(false)
-
-    env.store.set(CONSENT_KEY, '{not json')
-    expect(allows(CONSENT_FUNCTIONAL)).toBe(false)
-  })
-
-  test('reads the cookie when localStorage has nothing, and honours a custom key', () => {
-    ;(globalThis as any).document.cookie = `${CONSENT_KEY}=${JSON.stringify({ v: 2, functional: true })}`
-    expect(run()(CONSENT_FUNCTIONAL)).toBe(true)
-
-    env.reset()
-    env.store.set('my_consent', JSON.stringify({ v: 2, functional: true }))
-    expect(run({ storageKey: 'my_consent' })(CONSENT_FUNCTIONAL)).toBe(true)
-    expect(run()(CONSENT_FUNCTIONAL)).toBe(false)
-  })
-
-  test('escapes "<" in the key', () => {
-    expect(consentAllowsScript({ storageKey: '<k>' })).not.toContain('<k>')
-  })
-})