@unitninety/site-kit 1.6.5 → 1.7.0

package/src/features/client/ConsentRuntime.tsx

@@ -1,95 +0,0 @@
-'use client'
-import {
-  Suspense,
-  useCallback,
-  useLayoutEffect,
-  useMemo,
-  useRef,
-  useState,
-  type ReactNode,
-} from 'react'
-import type { PublicFeatureBase } from '../contracts'
-import { deniedConsentState } from '../contracts/consent'
-import type { CustomConsentRegistration } from '../consent/custom'
-import { consentRegistry } from '../consent/registry'
-import { ConsentContext } from './useConsent'
-import { PageReporter } from './PageReporter'
-const ignoreTitle = () => {}
-/** Commit-only ownership: rendering never installs listeners, scripts, or authority. */
-export function ConsentRuntime({
-  endpoint,
-  config,
-  customConsent,
-  children,
-}: {
-  endpoint: string
-  config: PublicFeatureBase | null
-  customConsent?: CustomConsentRegistration
-  children: ReactNode
-}) {
-  const owner = useRef({})
-  const registry = useRef<ReturnType<typeof consentRegistry> | null>(null)
-  const [snapshot, setSnapshot] = useState(() => ({
-    state: deniedConsentState(),
-    ready: false,
-    error: null as string | null,
-    reloadRequired: false,
-  }))
-  useLayoutEffect(() => {
-    const current = consentRegistry(window)
-    registry.current = current
-    const off = current.subscribe(() => setSnapshot(current.read()))
-    const currentOwner = owner.current
-    current.attach(currentOwner)
-    return () => {
-      off()
-      current.detach(currentOwner)
-      registry.current = null
-    }
-  }, [])
-  useLayoutEffect(() => {
-    registry.current!.commit(
-      owner.current,
-      endpoint,
-      config?.enabled.consent ?? false,
-      config?.consent,
-      customConsent,
-    )
-    setSnapshot(registry.current!.read())
-  }, [endpoint, config, customConsent, customConsent?.adapter, customConsent?.openPreferences])
-  const openPreferences = useCallback(() => registry.current?.openPreferences(), [])
-  const page = useCallback((path: string) => registry.current?.page(path), [])
-  const value = useMemo(
-    () => ({
-      state: snapshot.state,
-      ready: snapshot.ready,
-      error: snapshot.error,
-      openPreferences,
-    }),
-    [snapshot, openPreferences],
-  )
-  return (
-    <ConsentContext.Provider value={value}>
-      {children}
-      <Suspense fallback={null}>
-        <PageReporter report={page} titleChanged={ignoreTitle} />
-      </Suspense>
-      {snapshot.error && (
-        <div className="u90-features u90-consent-status">
-          <p role="status" aria-live="polite">
-            {snapshot.error}
-          </p>
-          {snapshot.reloadRequired ? (
-            <button type="button" data-u90-consent-reload onClick={() => window.location.reload()}>
-              Reload to apply consent changes
-            </button>
-          ) : (
-            <button type="button" onClick={() => registry.current?.retry()}>
-              Retry consent setup
-            </button>
-          )}
-        </div>
-      )}
-    </ConsentContext.Provider>
-  )
-}

package/src/features/client/useConsent.ts

@@ -1,15 +0,0 @@
-'use client'
-import { createContext, useContext } from 'react'
-import type { ConsentState } from '../contracts/consent'
-export type ConsentController = {
-  state: ConsentState
-  ready: boolean
-  error: string | null
-  openPreferences(): void
-}
-export const ConsentContext = createContext<ConsentController | null>(null)
-export function useConsent(): ConsentController {
-  const value = useContext(ConsentContext)
-  if (!value) throw new Error('Consent hooks require a SiteFeatures root.')
-  return value
-}

package/src/features/consent/README.md

@@ -1,70 +0,0 @@
-# Consent setup and lifecycle
-
-Install the existing same-origin feature gateway. Mount this standard setup once in the consuming server root layout, independently of whether Consent is currently enabled:
-
-```tsx
-import { SiteFeatures } from '@unitninety/site-kit/features'
-import { ConsentDefaults } from '@unitninety/site-kit/features/server'
-import '@unitninety/site-kit/features/styles.css'
-
-export default function RootLayout({ children }: { children: React.ReactNode }) {
-  return <html lang="en"><body>
-    <ConsentDefaults />
-    <SiteFeatures>{children}</SiteFeatures>
-  </body></html>
-}
-```
-
-Keep the root around children from their first render, including while choosing custom presentations. Remote accepted configuration controls activation, provider/source, Google mode and integrations. No installation, grant or mode prop is supported. Later administration does not require layout edits. Reuse the native gateway handlers; never add a competing catch-all.
-
-`ConsentDefaults` is exported only through the server entry. It renders a stable-ID denied-only `next/script` with `beforeInteractive`, without provider IDs, tag sources, configuration fetches or pageviews. Installed Next 16.3.4 queues App Router scripts before hydration; this does not promise native parser-time execution or control unmanaged async scripts. Remove old CMP, GA and other raw optional installers. The browser driver defensively runs the same initializer before its own first managed Google insertion if its marker is absent; conflicting unmanaged Google ownership aborts insertion. The marker is bookkeeping, never consent authority, and defaults never replay on refresh/navigation/regrant.
-
-`useConsent()` exposes exactly `{ state, ready, error, openPreferences }`. A real preferences button calls `openPreferences`; unavailable or throwing providers produce a handled error. The root supplies an accessible status/retry control and a visitor-controlled **Reload to apply consent changes** button when needed. It never reloads automatically on Close or assumes any event confirms a saved choice. Existing preferences controls remain usable during disable/withdrawal where the provider is still available.
-
-## Banner embed URL
-
-The Cookies workspace accepts an HTTPS script URL from any banner provider. With an active
-`custom` installation and no `customConsent` registration, Site Kit inserts that script once per
-document. No adapter or consent event is required just to display the provider's banner. The URL
-must point to its external JavaScript, not a provider dashboard, iframe page or pasted HTML. Providers
-that need inline initialization, extra attributes or synchronous parser execution may still need
-website code. The website Content Security Policy must allow the provider’s script origin and
-any additional resources it needs; saving a URL does not relax that policy. Custom script changes retain the existing `code.write` permission requirement.
-
-Embedding does not grant U90 consent: `useConsent().ready` stays false, all U90-managed optional
-integrations remain denied, and the provider's own controls handle preferences. Unregistered
-`u90:consent` events are ignored. Successful loading alone is not a consent signal. A missing optional
-registration is not an installation error; actual network failures/timeouts still surface normally.
-Already executed scripts cannot be undone by disabling the feature; reload the document to apply
-URL removal/replacement. Remove duplicate legacy installers before enabling the embed.
-
-Recognized direct CookieScript URLs retain their built-in category connection automatically. Other
-URLs use the same provider-independent embed path. Existing saved installations remain compatible.
-
-## Optional custom consent connection
-
-The optional `SiteFeatures` prop `customConsent?: CustomConsentRegistration` selects exactly one code-owned registration, only when the accepted remote provider is `custom`:
-
-```ts
-// Stable module identity, or useMemo with stable callback/adapter dependencies.
-const customConsent = { adapter: myConsentAdapter }
-// Alternatively: const customConsent = { openPreferences: reopenMyCMP }
-```
-
-The adapter supplies `read`, `subscribe` (returning cleanup) and `openPreferences`. The event bridge supplies only the reopen callback and publishes a fresh complete validated `ConsentState` in `window` event `u90:consent` during its active subscription. An event before registration cannot qualify. Missing/conflicting registration, invalid/unready snapshots and missing reopening deny optional code. An absent registration still permits the banner embed described above; an explicitly invalid registration remains an error. There is no arbitrary-window-global fallback. Factories are side-effect free; committed ownership subscribes before provider insertion and immediately reads current state.
-
-Keep actual adapter identity stable. For a bridge keep both its registration object and reopen callback stable. Replacement after activation requires a document reload and cannot transfer old events/grants. Render-only/suspended updates do not install listeners or replace authority.
-
-## Runtime guarantees and limits
-
-A document-owned registry retains execution records across navigation, React replay, root remount, integration removal and endpoint replacement. Equivalent settings revisions do not reinstall scripts or resubscribe. Last accepted config remains authoritative during failed/rejected refresh; real provider failures, committed disable and endpoint/provider replacement still deny immediately. Session/Feedback errors never decide consent. Disabled Consent does not grant categories.
-
-The fixed `createConsentLoader(driver)` API exposes `apply(state, integrations): Promise<void>` and `dispose(): void`. `IntegrationDriver` remains `start(integration): Promise<void>` and `stop(id): Promise<'stopped' | 'reload-required'>`. Starts deduplicate; withdrawal invokes stop immediately even during an unresolved start, and late initialization is stopped again. Built-in vetoes are synchronous. Drivers supplied by code must honor that same emission-veto obligation. Ten-second load/stop bounds surface failure and uncertainty. A network load error is retryable; possibly executing timed-out code requires reload.
-
-Basic Google mode makes no managed Google tag request before consent. Explicit advanced mode permits only classified Google requests while denied and may produce vendor consent-mode traffic; generic rows remain category-gated. Google defaults/update, `ga-disable`, `send_page_view:false` and current-permission checks guard Site Kit-owned SPA pageviews. Denied queued navigation is discarded; regrant emits only the current page.
-
-The shared closed classifier determines new GA4/ContentSquare drivers and approved executable attributes. An already executed GA source retains its proven teardown on category-policy changes, but its events require **both current row-category permission and analytics consent**. That historical capability never changes classification, code.write authorization or advanced eligibility for the edited row. New recategorized rows are generic.
-
-ContentSquare uses documented `optout` and requires reload; no web optin or cookie-clearing workaround is supplied. Its persisted opt-out may still affect regrant after reload. Attempted generic/Maps code requires reload regardless of a requested `stop` policy. Removing a script node is not teardown. Any reload requirement blocks every optional restart, including renamed/readded rows, until a real document reload. Previously executed third-party code cannot be rolled back.
-
-Tests use deterministic local DOM/provider doubles only. Task3 supplies actual production Next browser tag/beacon proof, both public projections, settings authorization/UI, the standard starter mount and exact KAW fixture transforms. No live-vendor account, regional/legal compliance, ContentSquare delivery/regrant or production rollout is certified.

package/src/features/consent/cookieScript.ts

@@ -1,53 +0,0 @@
-import { deniedConsentState, type ConsentAdapter, type ConsentState } from '../contracts/consent'
-
-/** Provider state is authoritative; neither event names nor an action alone grant categories. */
-export function normalizeCookieScript(input: unknown): ConsentState {
-  if (!input || typeof input !== 'object') return deniedConsentState()
-  const state = input as { action?: unknown; categories?: unknown }
-  if ((state.action !== 'accept' && state.action !== 'reject') || !Array.isArray(state.categories) ||
-    !state.categories.every((category) => typeof category === 'string')) return deniedConsentState()
-  const accepted = state.action === 'accept' ? state.categories : []
-  return {
-    version: 1, necessary: true, ready: true,
-    preferences: accepted.includes('functionality'), analytics: accepted.includes('performance'),
-    marketing: accepted.includes('targeting'),
-  }
-}
-
-type CookieScriptWindow = Window & { CookieScript?: { instance?: { currentState?: () => unknown; show?: () => void } } }
-const EVENTS = ['CookieScriptLoaded', 'CookieScriptAccept', 'CookieScriptAcceptAll', 'CookieScriptReject', 'CookieScriptClose'] as const
-
-/** Construct without side effects; the root subscribes before installing its owned CMP. */
-export function cookieScriptAdapter(window: Window): ConsentAdapter {
-  const target = window as CookieScriptWindow
-  const listeners = new Set<(state: ConsentState) => void>()
-  let reopenFailed = false
-  const read = (): ConsentState => {
-    try {
-      const instance = target.CookieScript?.instance
-      if (reopenFailed || typeof instance?.currentState !== 'function' || typeof instance.show !== 'function') return deniedConsentState()
-      return normalizeCookieScript(instance.currentState())
-    } catch { return deniedConsentState() }
-  }
-  const publish = () => { const state = read(); for (const listener of listeners) listener({ ...state }) }
-  const change = () => { reopenFailed = false; publish() }
-  return {
-    read,
-    subscribe(listener) {
-      if (listeners.size === 0) for (const event of EVENTS) window.addEventListener(event, change)
-      listeners.add(listener)
-      let subscribed = true
-      return () => {
-        if (!subscribed) return
-        subscribed = false
-        listeners.delete(listener)
-        if (listeners.size === 0) for (const event of EVENTS) window.removeEventListener(event, change)
-      }
-    },
-    openPreferences() {
-      if (!read().ready) { publish(); return }
-      try { target.CookieScript!.instance!.show!() }
-      catch { reopenFailed = true; publish() }
-    },
-  }
-}

package/src/features/consent/custom.ts

@@ -1,89 +0,0 @@
-import { ConsentStateSchema, deniedConsentState, type ConsentAdapter, type ConsentState } from '../contracts/consent'
-
-/** Code-owned registration: choose one stable adapter or one normalized-event bridge. */
-export type CustomConsentRegistration =
-  | { adapter: ConsentAdapter; openPreferences?: never }
-  | { adapter?: never; openPreferences: () => void }
-
-export function customConsentAdapter(window: Window, registration?: CustomConsentRegistration): ConsentAdapter {
-  const listeners = new Set<(state: ConsentState) => void>()
-  const adapter = registration?.adapter
-  const registered = adapter && registration.openPreferences === undefined &&
-    typeof adapter.read === 'function' && typeof adapter.subscribe === 'function' && typeof adapter.openPreferences === 'function'
-  const reopen = registration?.openPreferences
-  const bridge = adapter === undefined && typeof registration?.openPreferences === 'function'
-  let state = deniedConsentState()
-  let failed = false
-  let subscription = 0
-  const hasReopen = () => registered
-    ? registration?.adapter === adapter && registration.openPreferences === undefined && typeof adapter.openPreferences === 'function'
-    : bridge && registration?.adapter === undefined && typeof reopen === 'function' && registration?.openPreferences === reopen
-  let cleanup: (() => void) | undefined
-  const normalize = (input: unknown): ConsentState => {
-    try {
-      const result = ConsentStateSchema.safeParse(input)
-      return result.success ? result.data : deniedConsentState()
-    } catch { return deniedConsentState() }
-  }
-  const publish = (input: unknown) => {
-    state = normalize(input)
-    for (const listener of listeners) listener({ ...state })
-  }
-  const change = (event: Event) => { failed = false; publish(hasReopen() ? (event as CustomEvent<unknown>).detail : deniedConsentState()) }
-  const read = (): ConsentState => {
-    if (failed || !hasReopen()) return deniedConsentState()
-    if (registered) {
-      try { state = normalize(adapter.read()); return { ...state } }
-      catch { state = deniedConsentState(); return { ...state } }
-    }
-    return bridge && listeners.size > 0 ? { ...state } : deniedConsentState()
-  }
-  return {
-    read,
-    subscribe(listener) {
-      listeners.add(listener)
-      if (listeners.size === 1) {
-        const current = ++subscription
-        state = deniedConsentState()
-        failed = false
-        if (registered) {
-          try {
-            let active = false
-            const off = adapter.subscribe((next) => {
-              if (!active || current !== subscription || !listeners.size) return
-              failed = false
-              publish(hasReopen() ? next : deniedConsentState())
-            })
-            if (typeof off !== 'function') throw new Error('Custom subscription must supply cleanup.')
-            active = true
-            cleanup = off
-            publish(read())
-          } catch { ++subscription; failed = true; publish(deniedConsentState()) }
-        } else if (bridge) {
-          window.addEventListener('u90:consent', change)
-          cleanup = () => window.removeEventListener('u90:consent', change)
-        }
-      }
-      let subscribed = true
-      return () => {
-        if (!subscribed) return
-        subscribed = false
-        listeners.delete(listener)
-        if (listeners.size === 0) {
-          ++subscription
-          try { cleanup?.() } catch { /* Detached listeners cannot restore this authority. */ }
-          cleanup = undefined
-          state = deniedConsentState()
-          failed = true
-        }
-      }
-    },
-    openPreferences() {
-      if (!read().ready) { publish(deniedConsentState()); return }
-      try {
-        if (registered) adapter.openPreferences()
-        else if (bridge) reopen!()
-      } catch { failed = true; publish(deniedConsentState()) }
-    },
-  }
-}

package/src/features/consent/defaults.ts

@@ -1,40 +0,0 @@
-/** Shared server/bootstrap and defensive driver initializer. No tenant/category authority. */
-export type GoogleConsentWindow = Window & {
-  __u90ConsentDefaultsV1?: true
-  dataLayer?: unknown[]
-  gtag?: (...args: unknown[]) => void
-}
-export function initializeConsentDefaults(window: Window): void {
-  const target = window as GoogleConsentWindow
-  if (target.__u90ConsentDefaultsV1 === true) {
-    if (!Array.isArray(target.dataLayer) || typeof target.gtag !== 'function')
-      throw new Error('Consent defaults are unavailable.')
-    return
-  }
-  if (
-    target.gtag !== undefined ||
-    (target.dataLayer !== undefined &&
-      (!Array.isArray(target.dataLayer) || target.dataLayer.length > 0))
-  )
-    throw new Error(
-      'Consent defaults ownership conflicts with unmanaged Google code. Reload after correcting setup.',
-    )
-  target.dataLayer = target.dataLayer || []
-  target.gtag = function () {
-    // Preserve Google's documented gtag queue payload shape.
-    // eslint-disable-next-line prefer-rest-params
-    target.dataLayer!.push(arguments)
-  }
-  target.gtag('consent', 'default', {
-    analytics_storage: 'denied',
-    ad_storage: 'denied',
-    ad_user_data: 'denied',
-    ad_personalization: 'denied',
-    functionality_storage: 'denied',
-    personalization_storage: 'denied',
-    security_storage: 'granted',
-  })
-  target.__u90ConsentDefaultsV1 = true
-}
-export const CONSENT_DEFAULTS_ID = 'u90-consent-defaults-v1'
-export const CONSENT_DEFAULTS_SCRIPT = `(${initializeConsentDefaults.toString()})(window);`

package/src/features/consent/drivers.ts

@@ -1,233 +0,0 @@
-import {
-  classifyManagedIntegration,
-  deniedConsentState,
-  ManagedIntegrationSchema,
-  type ConsentState,
-  type IntegrationDriver,
-  type ManagedIntegration,
-} from '../contracts/consent'
-import { ConsentReloadRequiredError, executableFingerprint } from './loader'
-import { initializeConsentDefaults, type GoogleConsentWindow } from './defaults'
-
-type BrowserWindow = GoogleConsentWindow & {
-  _uxa?: unknown[][]
-  [key: `ga-disable-${string}`]: boolean
-}
-type Execution = {
-  integration: ManagedIntegration
-  kind: ReturnType<typeof classifyManagedIntegration>
-  attempted: boolean
-  loaded: boolean
-  running: boolean
-  allowed: boolean
-  configured: boolean
-  uncertain: boolean
-  element?: HTMLScriptElement
-  loading?: Promise<void>
-  lastPage?: string
-}
-export const CONSENT_LOAD_TIMEOUT_MS = 10000
-/** Private built-in driver. Its synchronous veto is independent of async loader completion. */
-export function createBrowserConsentDriver(window: Window): IntegrationDriver & {
-  configure(integrations: ManagedIntegration[]): void
-  setPermission(state: ConsentState, mode: 'basic' | 'advanced'): void
-  suspend(value: boolean): void
-  page(path: string): void
-  attempted(): boolean
-  googleAttempted(): boolean
-} {
-  const target = window as BrowserWindow
-  const records = new Map<string, Execution>()
-  let state = deniedConsentState()
-  let mode: 'basic' | 'advanced' = 'basic'
-  let suspended = false
-  let path = window.location.pathname
-  const permitted = (record: Execution) =>
-    !suspended &&
-    state.ready &&
-    state[record.integration.category] &&
-    record.allowed &&
-    (record.kind.kind !== 'ga4' || state.analytics)
-  const signal = () => {
-    if (target.__u90ConsentDefaultsV1 !== true) return
-    target.gtag?.('consent', 'update', {
-      analytics_storage: state.ready && state.analytics ? 'granted' : 'denied',
-      ad_storage: state.ready && state.marketing ? 'granted' : 'denied',
-      ad_user_data: state.ready && state.marketing ? 'granted' : 'denied',
-      ad_personalization: state.ready && state.marketing ? 'granted' : 'denied',
-      functionality_storage: state.ready && state.preferences ? 'granted' : 'denied',
-      personalization_storage: state.ready && state.preferences ? 'granted' : 'denied',
-      security_storage: 'granted',
-    })
-  }
-  const veto = (record: Execution) => {
-    if (record.kind.kind === 'ga4')
-      target[`ga-disable-${record.kind.measurementId}`] = !permitted(record)
-  }
-  const pageview = (record: Execution) => {
-    if (
-      record.kind.kind !== 'ga4' ||
-      !record.loaded ||
-      !permitted(record) ||
-      record.lastPage === path
-    )
-      return
-    record.lastPage = path
-    target.gtag!('event', 'page_view', {
-      send_to: record.kind.measurementId,
-      page_path: path,
-      page_location: new URL(path, window.location.origin).href,
-      page_title: window.document.title,
-    })
-  }
-  const optout = () => {
-    target._uxa = target._uxa || []
-    target._uxa.push(['optout'])
-  }
-  const driver = {
-    // Preserve proven teardown for executed code; policy edits never promote catalogue authority.
-    configure(integrations: ManagedIntegration[]) {
-      for (const record of records.values()) {
-        const next = integrations.find((row) => row.id === record.integration.id)
-        if (next && executableFingerprint(next) === executableFingerprint(record.integration))
-          record.integration = next
-        else {
-          record.running = false
-          record.allowed = false
-        }
-        veto(record)
-      }
-    },
-    setPermission(next: ConsentState, nextMode: 'basic' | 'advanced') {
-      const changed = JSON.stringify(state) !== JSON.stringify(next)
-      state = { ...next }
-      mode = nextMode
-      for (const record of records.values()) {
-        record.allowed = record.running && state.ready && state[record.integration.category]
-        if (!permitted(record)) record.lastPage = undefined
-        veto(record)
-      }
-      if (changed) signal()
-      for (const record of records.values()) pageview(record)
-    },
-    suspend(value: boolean) {
-      suspended = value
-      for (const record of records.values()) veto(record)
-    },
-    page(next: string) {
-      path = next
-      for (const record of records.values()) pageview(record)
-    },
-    attempted: () => [...records.values()].some((record) => record.attempted),
-    googleAttempted: () =>
-      [...records.values()].some((record) => record.attempted && record.kind.kind === 'ga4'),
-    async start(input: ManagedIntegration) {
-      const integration = ManagedIntegrationSchema.parse(input)
-      let record = records.get(integration.id)
-      if (!record) {
-        record = {
-          integration,
-          kind: classifyManagedIntegration(integration),
-          attempted: false,
-          loaded: false,
-          running: false,
-          allowed: false,
-          configured: false,
-          uncertain: false,
-        }
-        records.set(integration.id, record)
-      }
-      if (record.uncertain)
-        throw new ConsentReloadRequiredError(
-          'Reload required after uncertain integration initialization.',
-        )
-      const current = record
-      current.running = true
-      current.integration = integration
-      current.allowed = !suspended && state.ready && state[integration.category]
-      if (
-        !current.allowed &&
-        !(current.kind.kind === 'ga4' && mode === 'advanced' && state.ready && !suspended)
-      )
-        return
-      if (current.kind.kind === 'ga4') {
-        initializeConsentDefaults(window)
-        signal()
-        veto(current)
-        if (!current.configured) {
-          target.gtag!('js', new Date())
-          target.gtag!('config', current.kind.measurementId, { send_page_view: false })
-          current.configured = true
-        }
-      }
-      if (current.loaded) {
-        veto(current)
-        pageview(current)
-        return
-      }
-      if (!current.loading) {
-        current.loading = new Promise<void>((resolve, reject) => {
-          const script = window.document.createElement('script')
-          script.async = true
-          for (const [key, value] of Object.entries(integration.attributes ?? {}))
-            script.setAttribute(key, value)
-          if (script.id && window.document.getElementById(script.id)) {
-            reject(Error('Integration element ID is already owned.'))
-            return
-          }
-          script.src = integration.src
-          script.dataset.u90Integration = integration.id
-          current.element = script
-          const finish = () => {
-            window.clearTimeout(timer)
-            script.onload = null
-            script.onerror = null
-          }
-          const timer = window.setTimeout(() => {
-            finish()
-            current.uncertain = true
-            reject(new ConsentReloadRequiredError('Integration load timed out; reload required.'))
-          }, CONSENT_LOAD_TIMEOUT_MS)
-          script.onload = () => {
-            finish()
-            current.loaded = true
-            resolve()
-          }
-          script.onerror = () => {
-            finish()
-            script.remove()
-            current.element = undefined
-            reject(Error('Integration failed to load. Retry consent setup.'))
-          }
-          current.attempted = true
-          window.document.head.appendChild(script)
-        }).finally(() => {
-          current.loading = undefined
-        })
-      }
-      await current.loading
-      veto(current)
-      if (current.kind.kind === 'contentsquare' && !permitted(current)) optout()
-      pageview(current)
-    },
-    async stop(id: string): Promise<'stopped' | 'reload-required'> {
-      const record = records.get(id)
-      if (!record) return 'stopped'
-      record.running = false
-      record.allowed = false
-      record.lastPage = undefined
-      veto(record)
-      if (!record.attempted) return 'stopped'
-      if (record.kind.kind === 'contentsquare') optout()
-      if (
-        record.kind.kind === 'ga4' &&
-        !record.uncertain &&
-        record.integration.revocation === 'stop'
-      )
-        return 'stopped'
-      // Removing a node cannot undo downloaded or executing third-party code.
-      return 'reload-required'
-    },
-  }
-  return driver
-}