@c15t/react 3.0.0-alpha.2 → 3.0.0-alpha.3

package/dist-types/draft.d.ts

@@ -1,4 +1,4 @@
-import type { AllConsentNames, ConsentState, SaveResult, SaveInput } from '@c15t/core';
+import type { AllConsentNames, ConsentKernel, ConsentState, SaveResult, SaveInput } from '@c15t/core';
 import type { ReactNode } from 'react';
 /** A local, unmasked selection, committed only by an explicit save. */
 export interface ConsentDraftHandle {
@@ -27,6 +27,28 @@ export interface ConsentDraftHandle {
     save: () => Promise<SaveResult>;
     reset: () => void;
 }
+interface DraftSnapshot {
+    values: ConsentState;
+    displayedCategories: readonly AllConsentNames[];
+    vendors: Record<string, boolean>;
+    isDirty: boolean;
+    isStale: boolean;
+}
+declare const createDraftStore: (kernel: ConsentKernel, defaults?: Partial<ConsentState>) => {
+    acceptAll(): void;
+    connect(): import("@c15t/core").Unsubscribe;
+    getSnapshot: () => DraftSnapshot;
+    /** The kernel this draft reads from and saves into. */
+    kernel: ConsentKernel;
+    rejectAll(): void;
+    reset: () => void;
+    save(input?: SaveInput, categories?: readonly AllConsentNames[], onSuccess?: () => void): Promise<SaveResult>;
+    set(category: AllConsentNames, value: boolean): void;
+    setVendor(vendorId: string, granted: boolean): void;
+    subscribe(listener: () => void): () => void;
+    update: (patch: Partial<ConsentState>) => void;
+};
+type DraftStore = ReturnType<typeof createDraftStore>;
 export interface ConsentDraftProviderProps {
     children: ReactNode;
     /** Defaults apply only to categories without an explicit receipt. */
@@ -35,11 +57,25 @@ export interface ConsentDraftProviderProps {
 export declare const ConsentDraftProvider: ({ children, initial, }: ConsentDraftProviderProps) => import("react").JSX.Element;
 /** Internal UI save path shared by stock controls and headless actions. */
 export declare const useConsentSaveAction: () => (input?: SaveInput) => Promise<SaveResult>;
-/** Keep the compatibility manager selection and its save on the same draft. */
-export declare const useConsentManagerDraft: () => {
-    draft: ConsentDraftHandle;
-    save: (input?: SaveInput) => Promise<SaveResult>;
-};
+/**
+ * The nearest consent draft store, for the stock preference rows. Pair with
+ * {@link useConsentDraftSlice} so a row re-renders only when its own slice
+ * changes, not on every staged edit elsewhere in the draft.
+ *
+ * @returns The shared draft store, or a local one outside a provider.
+ * @internal
+ */
+export declare const useConsentDraftStore: () => DraftStore;
+/**
+ * Subscribes to one slice of a consent draft store.
+ *
+ * @param store - Store from {@link useConsentDraftStore}.
+ * @param selector - Picks the slice. Return a primitive or a reference the
+ * draft already holds.
+ * @returns The selected slice.
+ * @internal
+ */
+export declare const useConsentDraftSlice: <SliceType>(store: DraftStore, selector: (draft: DraftSnapshot) => SliceType) => SliceType;
 /** Read and edit displayed choices without replacing masked effective permissions. */
 export declare const useConsentDraft: () => ConsentDraftHandle;
 /** The vendor slice of the consent draft, for a custom vendor control. */
@@ -81,3 +117,4 @@ export interface VendorDraftHandle {
  * @public
  */
 export declare const useVendorDraft: () => VendorDraftHandle;
+export {};

package/dist-types/headless.d.ts

@@ -6,7 +6,6 @@
  */
 export { defaultTranslationConfig, detectBrowserLanguage, mergeTranslationConfigs, prepareTranslationConfig, } from '@c15t/core';
 export { type ConsentDialogTriggerVisibility, type UseConsentDialogTriggerOptions, type UseConsentDialogTriggerResult, useConsentDialogTrigger, } from './component-hooks/use-panel-trigger.js';
-export { useConsentManager } from './component-hooks/use-manager.js';
 export { type HeadlessConsentBannerAction, type HeadlessConsentBannerState, type HeadlessConsentDialogAction, type HeadlessConsentDialogState, type HeadlessConsentSurface, type HeadlessConsentSurfaceAction, type HeadlessConsentSurfaceState, type HeadlessConsentWriteAction, useHeadlessConsentUI, } from './component-hooks/use-headless-consent-ui.js';
 export { useTranslations } from './component-hooks/use-translations.js';
 export { useColorScheme } from './hooks/use-color-scheme.js';

package/dist-types/hooks/use-committed-ref.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A ref that holds `value` from the render React most recently committed.
+ *
+ * Consent guards use it to answer "is this still the kernel, draft or IAB
+ * selection this component renders?" when a kept callback runs, including
+ * from a descendant's layout effect in the very commit that switched
+ * runtimes.
+ *
+ * Why an insertion effect: React runs insertion effects while it applies a
+ * commit, before any layout effect of that commit, and never for a render it
+ * discards. Assigning the ref during render would publish values from
+ * renders React throws away (an interrupted concurrent render, StrictMode's
+ * second render). A layout effect is too late, because descendants' layout
+ * effects run before their ancestors'. A passive effect is later still.
+ * Assigning the committed value is idempotent, so StrictMode's replayed
+ * effects cannot leave a stale value behind.
+ *
+ * @param value - The value this render uses.
+ * @returns A ref whose `current` is the last committed `value`.
+ * @internal
+ */
+export declare const useCommittedRef: <Value>(value: Value) => {
+    readonly current: Value;
+};

package/dist-types/hooks.d.ts

@@ -65,6 +65,8 @@ export declare const useHasConsentPolicy: () => boolean;
  * {@link useHasConsentPolicy}.
  */
 export declare const useHasConsentUI: () => boolean;
+/** Whether c15t or an external CMP offers a preferences control. */
+export declare const useHasConsentPreferences: () => boolean;
 /**
  * Derived consent model (opt-in / opt-out / iab), or `null` while no policy
  * rule is resolved. The kernel keeps a safe fallback rule internally; this

package/dist-types/index.d.ts

@@ -48,13 +48,14 @@ export type { ConsentGateProps, FrameProps } from './components/consent-gate/ind
 export { ConsentGate, Frame } from './components/consent-gate/index.js';
 export type { ConsentDraftHandle, ConsentDraftProviderProps, VendorDraftHandle, } from './draft.js';
 export { ConsentDraftProvider, useConsentDraft, useVendorDraft } from './draft.js';
-export { useConsentManager } from './component-hooks/use-manager.js';
 export { useTranslations } from './component-hooks/use-translations.js';
-export { useActiveUI, useBranding, useConsent, useConsents, useHasConsentPolicy, useHasConsentUI, useIABEnabled, useIABSnapshot, useIdentify, useInit, useLocation, useModel, useOverrides, usePromptPresentation, usePolicyCategories, usePreferencesPresentation, usePolicyScopeMode, usePurposeConsent, useSaveConsents, useSetActiveUI, useSetLanguage, useSetOverrides, useSnapshot, useSpecialFeatureOptIn, useTCString, useUser, useDeclaredVendors, useVendorAllowed, useVendorChoice, useVendorConsent, } from './hooks.js';
+export { useActiveUI, useBranding, useConsent, useConsents, useHasConsentPolicy, useHasConsentPreferences, useHasConsentUI, useIABEnabled, useIABSnapshot, useIdentify, useInit, useLocation, useModel, useOverrides, usePromptPresentation, usePolicyCategories, usePreferencesPresentation, usePolicyScopeMode, usePurposeConsent, useRegisterConsentCategories, useSaveConsents, useSetActiveUI, useSetLanguage, useSetOverrides, useSnapshot, useSpecialFeatureOptIn, useSubscribeToConsentChanges, useTCString, useUser, useDeclaredVendors, useVendorAllowed, useVendorChoice, useVendorConsent, } from './hooks.js';
 export type { UseIframeBlockerOptions, UseNetworkBlockerOptions, UsePersistenceOptions, UseScriptLoaderOptions, } from './module-hooks.js';
 export { useIframeBlocker, useNetworkBlocker, usePersistence, useScriptLoader, } from './module-hooks.js';
 export type { ConsentProviderOptions, ConsentProviderCallbacks, ConsentProviderPrefetch, ConsentProviderProps, ExternalRuntimeProviderOptions, ExternalRuntimeProviderProps, OwnedRuntimeProviderProps, } from './provider.js';
 export { ConsentProvider } from './provider.js';
+export { ConsentTheme } from './consent-theme.js';
+export type { ConsentThemeProps } from './consent-theme.js';
 export type { ReactUIOptions } from './types/manager.js';
 export { defineTheme, type Theme } from './types/theme/index.js';
 export { useExplicitChoice, useEffectivePermissions, usePromptRequirement, useNoticeDismissal, usePrivacySignals, useOptOutDirectives, usePolicyResolution, usePolicyRule, useRestrictions, useDismissNotice, } from './hooks.js';

package/dist-types/kernel-selector.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Kernel access for the hooks and the stock components. The component
+ * selectors below each read a single derived value, so a component
+ * re-renders only when that value changes. Not exported from any package
+ * entry.
+ *
+ * @packageDocumentation
+ * @internal
+ */
+import type { AllConsentNames, ConsentKernel, ConsentSnapshot } from '@c15t/core';
+/**
+ * Reads the kernel from the nearest provider.
+ *
+ * @returns The provider's kernel.
+ * @throws {Error} When called outside a `ConsentProvider`.
+ * @internal
+ */
+export declare const useKernel: () => ConsentKernel;
+/**
+ * Subscribes to one slice of the kernel snapshot. React re-renders the
+ * caller only when the selected value `Object.is`-differs, so a selector
+ * must return a primitive or a reference the snapshot already holds.
+ *
+ * @param selector - Picks the slice from a snapshot.
+ * @returns The selected slice.
+ * @internal
+ */
+export declare const useKernelSelector: <SliceType>(selector: (snap: ConsentSnapshot) => SliceType) => SliceType;
+/**
+ * Like `useKernelSelector`, for selectors that evaluate a gate at a point in
+ * time. The server render and hydration evaluate at the snapshot's own
+ * `evaluatedAt`, so they never read the clock: a Next.js `cacheComponents`
+ * prerender rejects `Date.now()` in a Client Component. In the browser the
+ * gate is evaluated at `Date.now()`, so an expiry the kernel's deadline
+ * timer has not processed yet still denies.
+ *
+ * @param selector - Picks the slice from a snapshot at the given time.
+ * @returns The selected slice.
+ * @internal
+ */
+export declare const useGateSelector: <SliceType>(selector: (snap: ConsentSnapshot, now: number) => SliceType) => SliceType;
+/**
+ * Whether content gated on one category may render, with the kernel's gate
+ * semantics. Server rendering and hydration read no clock; see
+ * `useGateSelector`.
+ *
+ * @param category - Category the content needs.
+ * @returns `true` while the category is permitted.
+ * @internal
+ */
+export declare const useCategoryAllowed: (category: AllConsentNames) => boolean;
+/**
+ * Language of the active translation bundle.
+ *
+ * @returns The bundle's language, or the default language before one loads.
+ * @internal
+ */
+export declare const useTranslationLanguage: () => string;
+/**
+ * Categories the preference surface lists: `necessary` plus the recorded
+ * choice scope, or the policy scope when no choice scope applies.
+ *
+ * @returns A list whose identity changes only when the scope does.
+ * @internal
+ */
+export declare const useDisplayedCategories: () => readonly AllConsentNames[];

package/dist-types/module-hooks/iframe-blocker.d.ts

@@ -1,6 +1,33 @@
+import type { ConsentKernel } from '@c15t/core';
 import type { IframeBlockerHandle } from '@c15t/core/modules/iframe-blocker';
 export interface UseIframeBlockerOptions {
     disableAutomaticBlocking?: boolean;
 }
 export declare const useIframeBlocker: (options?: UseIframeBlockerOptions) => IframeBlockerHandle;
+/**
+ * Call `onFound` when a gated iframe is on the page: at once when one is
+ * there already, and again for each batch of gated frames that arrives.
+ *
+ * Until the returned stop function runs, a gated frame that arrives with a
+ * `src` the snapshot does not clearly allow is paused (`src` moved to
+ * `data-src`), as the loaded blocker would pause it. Frames on the page at
+ * the first call are left to the blocker, which is what happens when it
+ * loads with the provider.
+ *
+ * @param kernel - The kernel whose snapshot decides what is clearly allowed.
+ * @param onFound - Called for every sighting; the caller dedupes.
+ * @returns Stops watching.
+ * @internal
+ */
+export declare const watchGatedIframes: (kernel: ConsentKernel, onFound: () => void) => () => void;
+/**
+ * The provider's default iframe blocker. Loads the blocker module when the
+ * first gated iframe (`data-category` or `data-vendor`) is on the page
+ * instead of on every mount, so pages without one never download it.
+ *
+ * @param options - Blocker options. With `disableAutomaticBlocking` the
+ * module loads at once, as it did before.
+ * @internal
+ */
+export declare const useIframeBlockerOnDemand: (options?: UseIframeBlockerOptions) => void;
 export type { IframeBlockerHandle };

package/dist-types/module-hooks/network-blocker.d.ts

@@ -5,5 +5,28 @@ export interface UseNetworkBlockerOptions {
     logBlockedRequests?: boolean;
     onRequestBlocked?: (info: BlockedRequestInfo) => void;
 }
+/**
+ * Block `fetch` and XHR requests that match `rules` until the visitor's
+ * consent allows them.
+ *
+ * Blocking starts during the first render in the browser: matching requests
+ * wait from then on, including ones sent from this component's children's
+ * mount effects and from effects that run before this component's. The
+ * blocker loads after mount and decides each waiting request. On the
+ * server the hook does nothing.
+ *
+ * Rendering has a side effect: the first render patches `fetch` and
+ * `XMLHttpRequest` to hold matching requests. If React discards that
+ * render and never commits it, the hold ends after 10 seconds. Nothing
+ * checked consent for the requests it held, so they fail as blocked: a 451
+ * response for `fetch`, a failed XHR.
+ *
+ * Prefer the provider's `networkBlocker` option. It starts blocking when
+ * the provider renders, so it also covers components rendered before this
+ * one.
+ *
+ * @param options - Rules and logging options.
+ * @returns A handle to update rules or toggle blocking.
+ */
 export declare const useNetworkBlocker: (options: UseNetworkBlockerOptions) => NetworkBlockerHandle;
 export type { BlockedRequestInfo, NetworkBlockerHandle, NetworkBlockerRule };

package/dist-types/module-hooks/network-hold.d.ts

@@ -0,0 +1,47 @@
+import type { NetworkBlockerRule } from '@c15t/core/modules/network-blocker';
+import type { NetworkHold } from '@c15t/core/modules/network-hold';
+/**
+ * How long a hold started during render waits for its component to commit.
+ * A render React throws away never commits, so nothing else would end its
+ * hold. When this runs out the hold ends, and since nothing checked consent
+ * for the requests it held, they get the blocker's answer for a blocked
+ * request instead of being sent.
+ * @internal
+ */
+export declare const UNCOMMITTED_HOLD_MS = 10000;
+/**
+ * The render-time hold behind one network blocker mount.
+ * @internal
+ */
+export interface EarlyNetworkHold {
+    /**
+     * Call from the mount effect, before loading the blocker. Keeps the hold
+     * from expiring, starts a new one if it already ended (a StrictMode or
+     * kernel re-run after the blocker took over, or a commit that came after
+     * the expiry), and returns it for `createNetworkBlocker({ hold })`. A
+     * disabled blocker gets a hold that holds nothing, so it cannot end
+     * another caller's hold.
+     */
+    claim: (rules: readonly NetworkBlockerRule[], enabled: boolean | undefined) => NetworkHold;
+    /**
+     * Call from the mount effect's cleanup. Ends a hold no blocker took
+     * over, unless the effect runs again first (StrictMode, a kernel change).
+     * Nothing checked consent for what that hold held, so those requests get
+     * the blocker's answer for a blocked request instead of being sent.
+     */
+    unmount: () => void;
+}
+/**
+ * Hold requests matching `rules` from this component's first render in the
+ * browser, before any child renders or runs an effect. The network blocker
+ * loads after mount and takes the hold over.
+ *
+ * Rendering is not side-effect free: the first render patches `fetch` and
+ * `XMLHttpRequest`. That is safe because the hold only delays matching
+ * requests, a render React discards ends its hold after
+ * {@link UNCOMMITTED_HOLD_MS} (failing what it held as blocked), and on the
+ * server it does nothing.
+ *
+ * @internal
+ */
+export declare const useEarlyNetworkHold: (rules: readonly NetworkBlockerRule[], enabled: boolean | undefined) => EarlyNetworkHold;

package/dist-types/panel.d.ts

@@ -1 +1,13 @@
-export * from './components/panel/index.js';
+/**
+ * `@c15t/react/consent-dialog`: the deferred `ConsentDialog`, the same
+ * component the `@c15t/react` entry exports. Its implementation and styles
+ * load when the dialog first opens, or earlier when something preloads it,
+ * so importing this entry adds nothing heavy to the first load.
+ *
+ * The eager dialog and its individual parts (`Card`, `Header`, `Overlay`,
+ * ...) are in `@c15t/react/components/consent-dialog`.
+ *
+ * @packageDocumentation
+ */
+export { ConsentDialog } from './aggregate-components.js';
+export type { ConsentDialogCompoundComponent, ConsentDialogProps, } from './components/panel/index.js';

package/dist-types/preferences.d.ts

@@ -1 +1,12 @@
-export * from './components/preferences/index.js';
+/**
+ * `@c15t/react/consent-widget`: the deferred `ConsentWidget`, the same
+ * component the `@c15t/react` entry exports. Its implementation and styles
+ * load when the widget first renders.
+ *
+ * The eager widget and its individual parts (`Accordion`, `Switch`, `Footer`,
+ * ...) are in `@c15t/react/components/consent-widget`.
+ *
+ * @packageDocumentation
+ */
+export { ConsentWidget } from './aggregate-components.js';
+export type { ConsentWidgetCompoundComponent, ConsentWidgetProps, } from './components/preferences/index.js';

package/dist-types/provider.d.ts

@@ -1,16 +1,17 @@
 import type { AllConsentNames, ClearOnRevocationConfig, ConsentPresentation, Callbacks, I18nConfig, KernelConfig, KernelOverrides, KernelUser, LegalLinks, ProviderTransportFactory, StorageConfig, User, Vendor } from '@c15t/core';
 import type { Script } from '@c15t/core/modules/script-loader';
-import type { ConsentRuntime } from '@c15t/core/runtime';
+import type { ConsentControlOptions, ConsentRuntime } from '@c15t/core/runtime';
 import type { ReactNode } from 'react';
+import type { DialogPreload } from './chunk-warming.js';
 import type { UseNetworkBlockerOptions, UsePersistenceOptions, UseScriptLoaderOptions } from './module-hooks.js';
 import type { UseIframeBlockerOptions } from './module-hooks/iframe-blocker.js';
 import type { ReactUIOptions } from './types/manager.js';
 import type { ReactComponentSlots } from './types/slots.js';
 /** Events emitted by the mounted provider without snapshot-derived consent aliases. */
-export type ConsentProviderCallbacks = Pick<Callbacks, 'onChoiceRecorded' | 'onPermissionsChanged' | 'onError'>;
+export type ConsentProviderCallbacks = Pick<Callbacks, 'onChoiceRecorded' | 'onPermissionsChanged' | 'onError' | 'onBeforeConsentRevocationReload'>;
 /** Prepared policy and records; legacy consent projections are not provider inputs. */
 export type ConsentProviderPrefetch = Omit<KernelConfig, 'initialDraft' | 'transport'>;
-export interface ConsentProviderOptions extends Pick<ReactUIOptions, 'colorScheme' | 'disableAnimation' | 'noStyle' | 'scrollLock' | 'theme' | 'trapFocus'> {
+export interface ConsentProviderOptions extends ConsentControlOptions, Pick<ReactUIOptions, 'colorScheme' | 'disableAnimation' | 'noStyle' | 'scrollLock' | 'theme' | 'trapFocus'> {
     enabled?: boolean;
     presentation?: ConsentPresentation;
     /**
@@ -18,9 +19,10 @@ export interface ConsentProviderOptions extends Pick<ReactUIOptions, 'colorSchem
      *
      * @remarks
      * Set this when your CSP uses a nonce-based policy instead of
-     * `'unsafe-inline'`. The provider forwards it to the injected theme
-     * `<style>` element and to every `<script>` element created by the
-     * script loader. A per-script `nonce` still takes precedence.
+     * `'unsafe-inline'`. The provider forwards it to every `<script>`
+     * element created by the script loader. A per-script `nonce` still takes
+     * precedence. Pass the same nonce to `ConsentTheme`, which renders the
+     * theme `<style>` element.
      */
     nonce?: string;
     /**
@@ -83,6 +85,15 @@ export interface ConsentProviderOptions extends Pick<ReactUIOptions, 'colorSchem
      * Initial-only: remount the provider to replace its cleanup configuration.
      */
     clearOnRevocation?: ClearOnRevocationConfig;
+    /**
+     * Reload the page after an accept, reject or save turns off a category or
+     * vendor that was granted, or after a `consentSource` withdraws one.
+     * Removing a script cannot stop code that already ran, so the reload
+     * starts a document with only permitted code. Waits for the save request.
+     * Set `false` to handle revocation yourself.
+     * @default true
+     */
+    reloadOnConsentRevoked?: boolean;
     scripts?: Script[];
     /**
      * Vendors offered for vendor-level consent outside IAB. Each sits inside a
@@ -94,7 +105,12 @@ export interface ConsentProviderOptions extends Pick<ReactUIOptions, 'colorSchem
     vendors?: Vendor[];
     scriptLoader?: UseScriptLoaderOptions;
     networkBlocker?: UseNetworkBlockerOptions | false;
-    /** Discover and gate DOM iframes with data-category. Enabled by default. */
+    /**
+     * Discover and gate DOM iframes with data-category. Enabled by default.
+     * The blocker loads when the first gated iframe is on the page; until it
+     * runs, a gated iframe that arrives with a `src` consent does not allow
+     * is paused.
+     */
     iframeBlocker?: UseIframeBlockerOptions | false;
     persistence?: boolean | UsePersistenceOptions;
     i18n?: Partial<I18nConfig>;
@@ -103,6 +119,21 @@ export interface ConsentProviderOptions extends Pick<ReactUIOptions, 'colorSchem
     /** Per-component slot attribute overrides (shared contract with @c15t/vue). */
     components?: ReactComponentSlots;
     legalLinks?: LegalLinks;
+    /**
+     * When the deferred `<ConsentDialog />` starts loading before it opens.
+     *
+     * - `'idle'` (default): after the page's load event, in browser idle time,
+     *   while the banner is shown or a button that opens the dialog is
+     *   mounted, and on hover or focus of such a button. Skipped when the
+     *   visitor has Save-Data on or a 2G-class connection.
+     * - `'intent'`: only on hover or focus of a button that opens the dialog.
+     *
+     * Neither loads the dialog on a visit that shows no banner and has no
+     * dialog trigger.
+     *
+     * @default 'idle'
+     */
+    preloadDialog?: DialogPreload;
     /**
      * Adapter package name reported by `window.c15t`.
      * @internal
@@ -149,7 +180,9 @@ export type ConsentProviderProps = OwnedRuntimeProviderProps | ExternalRuntimePr
  * Pass `runtime` to render a runtime someone else created. The provider
  * then borrows its kernel and mounts none of the side-effecting modules —
  * no second `init()`, no second persistence handle, no second `window.c15t`
- * — and does not dispose it on unmount.
+ * — and does not dispose it on unmount. Handing it a different runtime
+ * switches the tree to that runtime's kernel; switching between a borrowed
+ * runtime and a provider-built kernel still needs a remount.
  *
  * @example
  * ```tsx

package/dist-types/ui-config-context.d.ts

@@ -1,9 +1,11 @@
 import type { LegalLinks, ConsentPresentation } from '@c15t/core';
+import type { DialogPreload } from './chunk-warming.js';
 import type { ReactComponentSlots } from './types/slots.js';
 export interface V3UIConfigValue {
     components?: ReactComponentSlots;
     presentation?: ConsentPresentation;
     legalLinks?: LegalLinks;
+    preloadDialog?: DialogPreload;
 }
 export declare const V3UIConfigContext: import("react").Context<V3UIConfigValue>;
 export declare const useUIConfig: () => V3UIConfigValue;

package/dist-types/ui-save.d.ts

@@ -1,5 +1,25 @@
 import type { ConsentKernel, SaveResult } from '@c15t/core';
 /** Explicit navigation supersedes a pending UI action, even to the same dialog. */
 export declare const invalidateConsentUIAction: (kernel: ConsentKernel) => void;
-/** Keep an open preferences dialog available until its own save succeeds. */
+/**
+ * Close the preferences dialog as soon as its choice is recorded locally.
+ *
+ * The kernel commits the receipt and updates permissions synchronously, so
+ * the dialog closes in the task that handled the click. Storage is written
+ * one task later, still ahead of the request, and the request runs after:
+ * its outcome never reopens the dialog, and a failed request stays queued
+ * for replay by the kernel. A save that recorded nothing (an unchanged
+ * selection) closes when it resolves successfully, unless explicit
+ * navigation or a newer action came first.
+ */
 export declare const saveConsentUI: (kernel: ConsentKernel, save: () => Promise<SaveResult>, canClose: () => boolean) => Promise<SaveResult>;
+/**
+ * Close an IAB surface in the task that handled the click.
+ *
+ * An IAB choice commits once its TC string is encoded, which can wait on the
+ * TCF library chunk but never on the backend. The surface closes first and
+ * comes back only when that local step recorded nothing (the vendor list
+ * failed to load, or the policy changed underneath), so the visitor can try
+ * again. A failed backend request never reopens it.
+ */
+export declare const saveIABConsentUI: (kernel: ConsentKernel, save: () => Promise<void> | void) => Promise<void>;

package/dist-types/utils/deferred-module.d.ts

@@ -1,7 +1,9 @@
 import type { ComponentType } from 'react';
 /**
- * Share an on-demand module across exports and intent preloading. Ready client
+ * Share an on-demand module across exports and preloading. Ready client
  * retries run synchronously; Suspense retains server rendering and hydration.
+ * A failed import is cached for rendered exports only, so a failed preload
+ * does not stop a later open from retrying.
  *
  * @internal
  */

package/dist-types/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.0.0-alpha.2";
+export declare const version = "3.0.0-alpha.3";

package/docs/README.md

@@ -32,8 +32,9 @@ These docs describe v3. Start with Inth hosted setup, identify the framework, ro
 - [Consent categories](./frameworks/react/concepts/consent-categories.md): Assign optional features to categories and understand how policy scope affects permission.
 - [Policy presets](./frameworks/react/concepts/policy-presets.md): Understand how policy rules affect React prompts, permissions and persistent privacy controls.
 - [Headless](./frameworks/react/headless.md): Build a custom consent banner in React with the c15t/react/headless hooks inside your ConsentProvider.
-- [Hooks](./frameworks/react/hooks/use-consent-manager/overview.md): Gate features and save consent choices in React components with the focused hooks exported from c15t/react.
+- [Hooks](./frameworks/react/hooks/overview.md): Gate features and save consent choices in React components with the focused hooks exported from c15t/react.
 - [IAB TCF](./frameworks/react/iab/overview.md): Mount the IAB TCF banner and dialog inside a React ConsentProvider and configure the CMP ID, policy and vendor data.
+- [Block network requests](./frameworks/react/network-blocker.md): Block fetch and XHR calls to third-party domains in a React app until the visitor grants their consent category.
 - [Quickstart](./frameworks/react/quickstart.md): Connect a React application to Inth and add consent UI, persistence and a preferences link.
 - [Load scripts with consent](./frameworks/react/script-loader.md): Register vendor scripts once and let effective permissions control loading.
 - [Styling](./frameworks/react/styling/overview.md): Import the React stylesheet and theme c15t components with tokens, slots, and class names on ConsentProvider.
@@ -44,6 +45,7 @@ These docs describe v3. Start with Inth hosted setup, identify the framework, ro
 - [Understand consent state](./guides/consent-state.md): Distinguish policy resolution, effective permissions, explicit choices, notices and privacy signals.
 - [Data fetching and transports](./guides/data-fetching.md): Choose cached manifests, backend init or offline policy resolution, and understand where consent records are saved.
 - [Choose a deployment mode](./guides/deployment-modes.md): Choose who runs your consent backend, then select manifest, init or offline resolution for your deployment.
+- [Share consent controls across frameworks](./guides/shared-consent-controls.md): Use the same c15t script lifecycle, external consent source, and event controls in every framework.
 - [Troubleshoot consent](./guides/troubleshooting.md): Diagnose missing banners, early vendor requests, lost choices and hydration differences.
 - [Verify consent before shipping](./guides/verify-consent.md): Test requests, policy resolution, persistence, navigation and preference changes in a production build.
 
@@ -68,6 +70,7 @@ These docs describe v3. Start with Inth hosted setup, identify the framework, ro
 - [Crisp](./integrations/crisp.md): Configure Crisp with c15t v3, understand functionality permission and verify loading and revocation.
 - [Databuddy](./integrations/databuddy.md): Configure Databuddy's initial and updated consent state with c15t v3.
 - [Fathom Analytics](./integrations/fathom-analytics.md): Configure Fathom Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [Front Chat](./integrations/front-chat.md): Load the Front Chat widget with functionality permission, forward CSP nonces and clear the session on revocation.
 - [Google Maps](./integrations/google-maps.md): Prevent a map iframe from mounting before the required permission.
 - [Google Tag](./integrations/google-tag.md): Configure gtag with c15t Consent Mode signals and understand its loading behavior.
 - [Google Tag Manager](./integrations/google-tag-manager.md): Load GTM with c15t consent signals and verify the tags inside your container.
@@ -83,8 +86,10 @@ These docs describe v3. Start with Inth hosted setup, identify the framework, ro
 - [Microsoft Clarity](./integrations/microsoft-clarity.md): Configure Microsoft Clarity with c15t v3, understand measurement permission and verify loading and revocation.
 - [Microsoft UET](./integrations/microsoft-uet.md): Configure Microsoft UET with c15t v3, understand marketing permission and verify loading and revocation.
 - [Mixpanel](./integrations/mixpanel-analytics.md): Configure Mixpanel with c15t v3, understand measurement permission and verify loading and revocation.
+- [OneDollarStats](./integrations/one-dollar-stats.md): Load the OneDollarStats tracker with measurement permission, forward its settings and verify loading and revocation.
 - [OpenAI Pixel](./integrations/openai-pixel.md): Configure the OpenAI Measurement Pixel for ChatGPT Ads with c15t v3, manage marketing permission and verify conversion delivery.
 - [Overview](./integrations/overview.md): Find all c15t integrations for analytics, tag managers, advertising, chat and embedded content.
+- [Pinterest Tag](./integrations/pinterest-tag.md): Configure the Pinterest Tag with c15t v3, track typed events and verify marketing permission, revocation and reload.
 - [Pirsch](./integrations/pirsch.md): Configure Pirsch with c15t v3, understand measurement permission and verify loading and revocation.
 - [Plausible Analytics](./integrations/plausible-analytics.md): Configure Plausible Analytics with c15t v3, understand measurement permission and verify loading and revocation.
 - [PostHog](./integrations/posthog.md): Choose PostHog loading and cookieless behavior, configure the region, and synchronize v3 permissions.

package/docs/customization/overview.md

@@ -34,10 +34,11 @@ layout can be restored by the policy renderer.
 ## Use the adapter's configuration shape
 
 React and Next.js accept provider `theme`, `presentation` and `components`
-options. Vue and Nuxt expose their own shared configuration, including CSS
+options, and render theme tokens with `ConsentTheme` on the server. Vue and Nuxt expose their own shared configuration, including CSS
 `tokens` and component slots. Svelte accepts its provider options and theme
-contract. Astro serializes integration options and uses the selected adapter for
-dialogs. Do not move a configuration object between frameworks without checking
+slots; SvelteKit renders the token CSS from a server `load`. Astro serializes
+integration options, renders the theme tokens on the server and uses the
+selected adapter for dialogs. Do not move a configuration object between frameworks without checking
 the target types.
 
 Read [tokens and CSS](./tokens.md),

package/docs/customization/recipes.md

@@ -26,8 +26,10 @@ export const brandTheme = defineTheme({
 
 ```
 
-Install `@c15t/ui` to use `defineTheme` directly. Pass `brandTheme` as `theme` in
-your existing React or Next.js provider options. Keep your Inth mode and script
+Install `@c15t/ui` to use `defineTheme` directly. Render
+`<ConsentTheme theme={brandTheme} />` on the server for the tokens, and pass
+`brandTheme` as `theme` in your existing React or Next.js provider options for
+the action styles. Keep your Inth mode and script
 configuration. The theme source above is also imported by the runnable example,
 so the rendered result and the documentation use the same values.