@c15t/react 3.0.0-alpha.8 → 3.0.0

package/dist-types/components/consent-gate/frame.d.ts

@@ -0,0 +1,19 @@
+import * as atoms from './atoms.js';
+import type { ConsentGateCompoundComponent, ConsentGateProps } from './types.js';
+/** @deprecated Renamed to `ConsentGateRoot`. */
+declare const FrameRoot: typeof atoms.ConsentGateRoot;
+/** @deprecated Renamed to `ConsentGateTitle`. */
+declare const FrameTitle: typeof atoms.ConsentGateTitle;
+/** @deprecated Renamed to `ConsentGateButton`. */
+declare const FrameButton: typeof atoms.ConsentGateButton;
+/**
+ * @deprecated Renamed to `ConsentGate`. `Frame` will be removed in a
+ * future major release.
+ */
+declare const Frame: ConsentGateCompoundComponent;
+/** @deprecated Renamed to `ConsentGateProps`. */
+type FrameProps = ConsentGateProps;
+/** @deprecated Renamed to `ConsentGateCompoundComponent`. */
+type FrameCompoundComponent = ConsentGateCompoundComponent;
+export type { FrameCompoundComponent, FrameProps };
+export { Frame, FrameButton, FrameRoot, FrameTitle };

package/dist-types/components/consent-gate/index.d.ts

@@ -1,5 +1,4 @@
-import * as atoms from './atoms.js';
-import type { ConsentGateCompoundComponent, ConsentGateProps } from './types.js';
+import type { ConsentGateCompoundComponent } from './types.js';
 /**
  * Renders its children only while a consent category is allowed
  *
@@ -19,23 +18,8 @@ import type { ConsentGateCompoundComponent, ConsentGateProps } from './types.js'
  * @see {@link AllConsentNames} for consent categories
  */
 declare const ConsentGate: ConsentGateCompoundComponent;
-/**
- * @deprecated Renamed to {@link ConsentGate}. `Frame` will be removed in a
- * future major release.
- */
-declare const Frame: ConsentGateCompoundComponent;
-/** @deprecated Renamed to {@link ConsentGateProps}. */
-type FrameProps = ConsentGateProps;
-/** @deprecated Renamed to {@link ConsentGateCompoundComponent}. */
-type FrameCompoundComponent = ConsentGateCompoundComponent;
-/** @deprecated Renamed to `ConsentGateRoot`. */
-declare const FrameRoot: typeof atoms.ConsentGateRoot;
-/** @deprecated Renamed to `ConsentGateTitle`. */
-declare const FrameTitle: typeof atoms.ConsentGateTitle;
-/** @deprecated Renamed to `ConsentGateButton`. */
-declare const FrameButton: typeof atoms.ConsentGateButton;
 export { ConsentGateButton, ConsentGateRoot, ConsentGateTitle } from './atoms.js';
 export type { ConsentGateCompoundComponent, ConsentGateProps } from './types.js';
 export { ConsentGate };
-export type { FrameCompoundComponent, FrameProps };
-export { Frame, FrameButton, FrameRoot, FrameTitle };
+export type { FrameCompoundComponent, FrameProps } from './frame.js';
+export { Frame, FrameButton, FrameRoot, FrameTitle } from './frame.js';

package/dist-types/components/iab-prompt/iab-prompt.d.ts

@@ -57,7 +57,7 @@ export interface IABConsentBannerProps {
  * ```tsx
  * <ConsentProvider
  *   options={{
- *     mode: hosted({ url: '/api/c15t' }),
+ *     mode: hosted({ backendURL: '/api/c15t' }),
  *     iab: { cmpId: 123, vendors: [1, 2, 10] },
  *   }}
  * >

package/dist-types/components/panel/index.d.ts

@@ -57,7 +57,7 @@ export interface ConsentDialogCompoundComponent extends FC<ConsentDialogProps> {
  * ```tsx
  * <ConsentProvider
  *   options={{
- *     mode: hosted({ url: '/api/c15t' }),
+ *     mode: hosted({ backendURL: '/api/c15t' }),
  *     components: {
  *       dialog: {
  *         card: { className: 'rounded-3xl shadow-xl' },

package/dist-types/components/panel-trigger/toolbar-loader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Loads the trigger toolbar on demand. The single-button trigger becomes a
+ * toolbar only while `<ConsentDevTools>` is mounted, so apps without
+ * DevTools never download it. The DevTools entry registers the toolbar when
+ * it loads, so the swap to a toolbar never waits on a request.
+ *
+ * @internal
+ * @packageDocumentation
+ */
+import type { TriggerToolbar } from './atoms/toolbar.js';
+/** The toolbar view the trigger renders while DevTools is mounted. */
+export type TriggerToolbarComponent = typeof TriggerToolbar;
+/**
+ * Make the toolbar available synchronously.
+ *
+ * @param component - The toolbar view.
+ * @internal
+ */
+export declare const registerTriggerToolbar: (component: TriggerToolbarComponent) => void;
+/**
+ * The toolbar view when it has loaded or been registered.
+ *
+ * @returns The toolbar view, or `undefined` while it is not loaded.
+ * @internal
+ */
+export declare const getTriggerToolbar: () => TriggerToolbarComponent | undefined;
+/**
+ * Load the toolbar view. A failed load is not cached, so a later call
+ * retries.
+ *
+ * @returns The toolbar view.
+ * @internal
+ */
+export declare const loadTriggerToolbar: () => Promise<TriggerToolbarComponent>;

package/dist-types/components/preferences/index.d.ts

@@ -67,7 +67,7 @@ export interface ConsentWidgetCompoundComponent extends FC<ConsentWidgetProps> {
  * ```tsx
  * <ConsentProvider
  *   options={{
- *     mode: hosted({ url: '/api/c15t' }),
+ *     mode: hosted({ backendURL: '/api/c15t' }),
  *     components: {
  *       accordion: {
  *         root: { className: 'rounded-3xl border border-black/10' },

package/dist-types/components/prompt/atoms/early-tap-script.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Keeps a banner tap made before hydration.
+ *
+ * A server-rendered banner shows long before React attaches its handlers.
+ * The inline script records an accept, reject, dismiss or customize tap in
+ * that gap and hides the banner. Once this component mounts, the banner's
+ * own handlers work: it stops the script and records the tap when the
+ * runtime has started. See `@c15t/core/surface-actions`.
+ *
+ * The script is in the server HTML. A banner that hydrates keeps it, inert
+ * once claimed, so hydration changes nothing in the markup. A banner React
+ * renders in the browser has its handlers at once, and a script it inserts
+ * would never run, so there it renders nothing.
+ *
+ * @internal
+ */
+export declare const EarlyTapScript: () => import("react").JSX.Element | null;

package/dist-types/components/prompt/index.d.ts

@@ -62,7 +62,7 @@ export interface ConsentBannerCompoundComponent extends FC<ConsentBannerProps> {
  * ```tsx
  * <ConsentProvider
  *   options={{
- *     mode: hosted({ url: '/api/c15t' }),
+ *     mode: hosted({ backendURL: '/api/c15t' }),
  *     i18n: {
  *       locale: 'en',
  *       messages: {

package/dist-types/components/shared/dialog-sheets.d.ts

@@ -0,0 +1,9 @@
+import type { SurfaceStyleSheet } from './surface-styles.js';
+/**
+ * What the dialog and the preference widget render: the first-paint sheet,
+ * then the dialog and widget rules. Only their lazy chunks import this, so
+ * the dialog rules load with the dialog's code.
+ *
+ * @internal
+ */
+export declare const DIALOG_SHEETS: readonly SurfaceStyleSheet[];

package/dist-types/components/shared/first-paint-sheets.d.ts

@@ -0,0 +1,8 @@
+import type { SurfaceStyleSheet } from './surface-styles.js';
+/**
+ * What the banner, trigger and ConsentGate render: tokens, every c15t
+ * variable and the first-paint rules of `styles.css`.
+ *
+ * @internal
+ */
+export declare const FIRST_PAINT_SHEETS: readonly SurfaceStyleSheet[];

package/dist-types/components/shared/iab-dialog-sheets.d.ts

@@ -0,0 +1,3 @@
+import type { SurfaceStyleSheet } from './surface-styles.js';
+/** Styles for a standalone IAB dialog, loaded with its code. @internal */
+export declare const IAB_DIALOG_SHEETS: readonly SurfaceStyleSheet[];

package/dist-types/components/shared/iab-first-paint-sheets.d.ts

@@ -0,0 +1,3 @@
+import type { SurfaceStyleSheet } from './surface-styles.js';
+/** The shared tokens and IAB banner rules. @internal */
+export declare const IAB_FIRST_PAINT_SHEETS: readonly SurfaceStyleSheet[];

package/dist-types/components/shared/surface-styles.d.ts

@@ -0,0 +1,60 @@
+/** A stylesheet from `@c15t/ui/styles/sheets/*`. */
+export interface SurfaceStyleSheet {
+    /** Dedupes the stylesheet: a page renders each `id` once. */
+    id: string;
+    /** The stylesheet text. Empty for a deferred sheet. */
+    css: string;
+    /**
+     * Loads the text of a deferred sheet. A browser bundle gets one in place
+     * of `css` when the framework already put the sheet in the server HTML,
+     * as the Next.js adapter does, so the text ships once.
+     */
+    load?: () => Promise<string>;
+}
+/**
+ * Starts loading the deferred sheets the page does not hold yet. Safe to
+ * call often: each sheet loads once, and the next call retries a failed
+ * load.
+ *
+ * @internal
+ */
+export declare const preloadSurfaceSheets: (sheets: readonly SurfaceStyleSheet[]) => Promise<void>;
+/**
+ * Whether a surface can show: its deferred sheets are in the page or
+ * loaded. Starts loading the missing ones after mount, so a surface that
+ * renders later, like a banner waiting on the browser's consent fetch,
+ * finds them ready. Hydration reads `true`: the server rendered the sheets
+ * it rendered the surface with.
+ *
+ * @internal
+ */
+export declare const useSurfaceSheetsReady: (sheets: readonly SurfaceStyleSheet[], noStyle?: boolean) => boolean;
+/**
+ * Renders the stylesheets a stock surface needs as `<style>` elements.
+ *
+ * The banner, trigger, ConsentGate, dialog and widget each render the
+ * sheets they use, so an app that imports no c15t stylesheet still gets
+ * styled surfaces, and no stylesheet `<link>` holds back the first paint.
+ * A server-rendered surface puts its rules in the HTML. A surface that
+ * renders in the browser, like the dialog, inserts them with its own code.
+ *
+ * In React 19 the elements move to `<head>` and each `id` renders once per
+ * page; later sheets follow earlier ones, which keeps the cascade order of
+ * `styles.css`. React 18 renders them in place, next to the surface, and
+ * so does React 19 when the provider sets a `nonce`: React drops the nonce
+ * from a style it moves to `<head>` unless the app passed the same nonce to
+ * React's server renderer, and a style without it would break a
+ * nonce-based policy.
+ *
+ * Renders nothing when the provider sets `styles: false` (the app imports
+ * `styles.css` itself) or `noStyle`.
+ *
+ * @param props.sheets - The stylesheets, in cascade order.
+ * @param props.noStyle - The surface's own `noStyle` prop.
+ * @returns The `<style>` elements, or `null`.
+ * @internal
+ */
+export declare const SurfaceStyles: ({ sheets, noStyle, }: {
+    sheets: readonly SurfaceStyleSheet[];
+    noStyle?: boolean;
+}) => (import("react").JSX.Element | null)[] | null;

package/dist-types/consent-gate.d.ts

@@ -1 +1 @@
-export * from './components/consent-gate/index.js';
+export { ConsentGate, ConsentGateButton, type ConsentGateCompoundComponent, type ConsentGateProps, ConsentGateRoot, ConsentGateTitle, Frame, FrameButton, type FrameCompoundComponent, type FrameProps, FrameRoot, FrameTitle, } from './components/consent-gate/index.js';

package/dist-types/context/index.d.ts

@@ -1,3 +1,3 @@
-export * from '../context.js';
-export * from './consent-tracking-context.js';
-export * from './theme-context.js';
+export { HydrationSnapshotContext, KernelContext, type ProviderServices, ProviderServicesContext, StreamedPrefetchContext, } from '../context.js';
+export { ConsentTrackingContext, type ConsentTrackingValue, toSaveUISource, useConsentTracking, } from './consent-tracking-context.js';
+export { GlobalThemeContext, LocalThemeContext, type ThemeContextValue, } from './theme-context.js';

package/dist-types/context.d.ts

@@ -14,6 +14,8 @@ export interface ProviderServices {
     clearRecords: () => void;
     getPresentation: () => ConsentPresentation | undefined;
     getConsentCategories: () => readonly AllConsentNames[];
+    /** Whether the runtime has started: records hydrated, prefetch adopted. */
+    isStarted: () => boolean;
     /**
      * Store a language override and load its copy: init runs again on the
      * provider's own kernel while it is enabled, and a borrowed runtime

package/dist-types/gpp.d.ts

@@ -18,7 +18,7 @@ export type ConsentGPPProps = RuntimeGPPOptions;
  * ```tsx
  * import { ConsentGPP } from '@c15t/react/gpp';
  *
- * <ConsentProvider options={{ mode: hosted({ url }) }}>
+ * <ConsentProvider options={{ mode: hosted({ backendURL }) }}>
  *   <ConsentGPP usFallback="none" />
  *   <App />
  * </ConsentProvider>

package/dist-types/hooks/use-iab-policy-guard.d.ts

@@ -0,0 +1,35 @@
+import { IABUnavailableError } from '@c15t/core';
+/**
+ * Record that `IABProvider` is part of the app. `@c15t/react/iab` calls
+ * this when it loads.
+ *
+ * @internal
+ */
+export declare const markIABProviderLoaded: () => void;
+/**
+ * The error the standard surfaces throw for an `iab` policy without
+ * `<IABProvider>`.
+ *
+ * @returns A fresh {@link IABUnavailableError}.
+ * @internal
+ */
+export declare const missingIABProviderError: () => IABUnavailableError;
+/**
+ * Throw while rendering when the visitor's policy needs a CMP and the app
+ * has none.
+ *
+ * The standard banner and dialog do not answer for the IAB model, so
+ * without `<IABProvider>` a visitor under an `iab` policy would see no
+ * consent UI at all. Throwing during render reaches error boundaries and
+ * framework error overlays, on the server render and in the browser alike,
+ * since both read the same snapshot.
+ *
+ * `<IABProvider>` usually sits beside the standard surfaces rather than
+ * around them, so a missing IAB context alone does not prove the app has
+ * none. The check also passes once `@c15t/react/iab` has loaded.
+ *
+ * @throws {IABUnavailableError} When the policy needs IAB and neither an
+ * IAB context nor `@c15t/react/iab` is present.
+ * @internal
+ */
+export declare const useIABPolicyGuard: () => void;

package/dist-types/iab-dialog-deferred.d.ts

@@ -0,0 +1,36 @@
+import type { IABConsentDialogCompoundComponent } from './components/iab-panel/index.js';
+/**
+ * The IAB TCF preference centre: purposes, stacks, special features and
+ * per-vendor consent and legitimate-interest controls.
+ *
+ * @remarks
+ * The component code loads on demand. It downloads in the browser's first
+ * idle period after the page's `load` event while the IAB banner is shown,
+ * on hover or focus of the banner's Customize button or partners link, or
+ * when the dialog opens, whichever comes first. `preloadDialog: 'intent'` in
+ * the provider options skips the idle load. `open={true}` or `showTrigger`
+ * loads it on mount under a model `models` lists; under another model,
+ * `showTrigger` loads only the trigger.
+ *
+ * The compound parts (`IABConsentDialog.Root`, `.Card`, `.Header`, `.Tabs`,
+ * `.TabButton`, `.Content`, `.Footer`, `.Overlay`, `.FeatureItem`,
+ * `.PurposeItem`, `.StackItem`, `.VendorList`) load the same module when
+ * they render.
+ *
+ * @example
+ * ```tsx
+ * <IABProvider cmpId={28}>
+ *   <IABConsentBanner />
+ *   <IABConsentDialog />
+ * </IABProvider>
+ * ```
+ *
+ * @public
+ */
+export declare const IABConsentDialog: IABConsentDialogCompoundComponent;
+/**
+ * Reset the warming state shared by mounted dialogs between tests.
+ *
+ * @internal
+ */
+export declare const resetIABDialogWarmingForTests: () => void;

package/dist-types/iab.d.ts

@@ -12,7 +12,7 @@
  * import { IABProvider, IABConsentBanner, IABConsentDialog } from '@c15t/react/iab';
  *
  * <ConsentProvider
- *   options={{ mode: hosted({ url: '/api/c15t' }) }}
+ *   options={{ mode: hosted({ backendURL: '/api/c15t' }) }}
  * >
  *   <IABProvider cmpId={28}>
  *     <IABConsentBanner />
@@ -24,7 +24,8 @@
  * @packageDocumentation
  */
 export { IABConsentBanner, type IABConsentBannerProps, } from './components/iab-prompt/index.js';
-export { IABConsentDialog, type IABConsentDialogProps, } from './components/iab-panel/index.js';
+export type { IABConsentDialogProps } from './components/iab-panel/index.js';
+export { IABConsentDialog } from './iab-dialog-deferred.js';
 export { type HeadlessIABBannerAction, type HeadlessIABBannerState, type HeadlessIABDialogAction, type HeadlessIABDialogState, type HeadlessIABPreferenceTab, type UseHeadlessIABConsentUIResult, useHeadlessIABConsentUI, } from './hooks/use-headless-iab-consent-ui.js';
 export { IABProvider } from './iab-context.js';
 export type { IABProviderProps } from './iab-context.js';

package/dist-types/index-parts/consent-gate.d.ts

@@ -4,4 +4,4 @@
  * (esbuild) does not treat every module the index names as part of an app
  * that imports one hook: only the groups it uses are live.
  */
-export { ConsentGate, Frame } from '../components/consent-gate/index.js';
+export { ConsentGate } from '../components/consent-gate/index.js';

package/dist-types/index-parts/core.d.ts

@@ -4,5 +4,4 @@
  * (esbuild) does not treat every module the index names as part of an app
  * that imports one hook: only the groups it uses are live.
  */
-export { createConsentKernel, custom, hosted, policyRulePresets, } from '@c15t/core';
-export { offline } from '../transports/offline.js';
+export { createConsentKernel, custom } from '@c15t/core';

package/dist-types/index-parts/frame.d.ts

@@ -0,0 +1,7 @@
+/**
+ * One group of `@c15t/react`'s public exports. The package index re-exports
+ * each group with `export *`, so a bundler that splits code by reachability
+ * (esbuild) does not treat every module the index names as part of an app
+ * that imports one hook: only the groups it uses are live.
+ */
+export { Frame } from '../components/consent-gate/frame.js';

package/dist-types/index-parts/hosted.d.ts

@@ -0,0 +1,7 @@
+/**
+ * One group of `@c15t/react`'s public exports. The package index re-exports
+ * each group with `export *`, so a bundler that splits code by reachability
+ * (esbuild) does not treat every module the index names as part of an app
+ * that imports one hook: only the groups it uses are live.
+ */
+export { hosted } from '@c15t/core';

package/dist-types/index-parts/offline.d.ts

@@ -0,0 +1,7 @@
+/**
+ * One group of `@c15t/react`'s public exports. The package index re-exports
+ * each group with `export *`, so a bundler that splits code by reachability
+ * (esbuild) does not treat every module the index names as part of an app
+ * that imports one hook: only the groups it uses are live.
+ */
+export { offline } from '../transports/offline.js';

package/dist-types/index-parts/presets.d.ts

@@ -0,0 +1,7 @@
+/**
+ * One group of `@c15t/react`'s public exports. The package index re-exports
+ * each group with `export *`, so a bundler that splits code by reachability
+ * (esbuild) does not treat every module the index names as part of an app
+ * that imports one hook: only the groups it uses are live.
+ */
+export { policyRulePresets } from '@c15t/core';

package/dist-types/index.d.ts

@@ -11,7 +11,7 @@
  *
  *   function App({ children }) {
  *     return (
- *       <ConsentProvider options={{ mode: hosted({ url: '/api/c15t' }) }}>
+ *       <ConsentProvider options={{ mode: hosted({ backendURL: '/api/c15t' }) }}>
  *         {children}
  *       </ConsentProvider>
  *     );
@@ -48,11 +48,15 @@ export type { ConsentBannerCompoundComponent } from './components/prompt/index.j
 export type { ReactUIOptions } from './types/manager.js';
 export type { ConsentPresentation, PromptPresentation, PreferencesPresentation, PresentationAction, PromptPosition, PromptVariant, ResolvedConsentPresentation, } from '@c15t/core';
 export * from './index-parts/core.js';
+export * from './index-parts/hosted.js';
+export * from './index-parts/offline.js';
+export * from './index-parts/presets.js';
 export * from './index-parts/consent-dialog.js';
 export * from './index-parts/consent-banner.js';
 export * from './index-parts/consent-dialog-link.js';
 export * from './index-parts/consent-dialog-trigger.js';
 export * from './index-parts/consent-gate.js';
+export * from './index-parts/frame.js';
 export * from './index-parts/draft.js';
 export * from './index-parts/translations.js';
 export * from './index-parts/module-hooks.js';

package/dist-types/modes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `@c15t/react/modes` — the single-page app modes, defaulting to what the
+ * build integration downloaded.
+ *
+ * `manifest()` and `hosted()` here read `@c15t/core/generated`, which
+ * `consentManifest()` from `c15t/build` fills with the policy snapshot and
+ * the backend URL. `c15t/react` exports these in place of the plain
+ * `hosted()` from `@c15t/react`.
+ *
+ * The package index does not import this module. Server-framework packages
+ * re-export the index, and their browser bundles must not import
+ * `@c15t/core/generated`: Next.js fails the build when they do.
+ *
+ * @example
+ * ```tsx
+ * import { ConsentProvider, manifest } from 'c15t/react';
+ *
+ * <ConsentProvider options={{ mode: manifest() }}>{children}</ConsentProvider>;
+ * ```
+ */
+export { hosted } from './transports/hosted.js';
+export type { HostedOptions } from './transports/hosted.js';
+export { manifest } from './transports/manifest.js';
+export type { BrowserManifestModeFactory, ManifestModeOptions, } from './transports/manifest.js';
+export { offline } from './transports/offline.js';
+export type { OfflineModeOptions } from './transports/offline.js';

package/dist-types/panel-link.d.ts

@@ -1 +1 @@
-export * from './components/panel-link/index.js';
+export { ConsentDialogLink, type ConsentDialogLinkProps, } from './components/panel-link/index.js';

package/dist-types/panel-trigger.d.ts

@@ -1 +1 @@
-export * from './components/panel-trigger/index.js';
+export { ConsentDialogTrigger, type ConsentDialogTriggerCompound, type ConsentDialogTriggerProps, ConsentDialogTriggerToolbar, type ConsentDialogTriggerToolbarAction, type ConsentDialogTriggerToolbarPreferences, type ConsentDialogTriggerToolbarProps, type CornerPosition, TriggerButton, type TriggerButtonProps, TriggerIcon, type TriggerIconProps, type TriggerIconType, type TriggerOrientation, TriggerRoot, type TriggerRootProps, type TriggerSize, TriggerText, type TriggerTextProps, type TriggerVisibility, type UseDraggableOptions, type UseDraggableReturn, useDraggable, useTriggerContext, } from './components/panel-trigger/index.js';

package/dist-types/provider.d.ts

@@ -40,11 +40,29 @@ export interface ConsentProviderOptions extends ConsentControlOptions, Pick<Reac
      * @remarks
      * Set this when your CSP uses a nonce-based policy instead of
      * `'unsafe-inline'`. The provider forwards it to every `<script>`
-     * element created by the script loader. A per-script `nonce` still takes
+     * element created by the script loader, and to the `<style>` elements
+     * the stock surfaces render. A per-script `nonce` still takes
      * precedence. Pass the same nonce to `ConsentTheme`, which renders the
      * theme `<style>` element.
      */
     nonce?: string;
+    /**
+     * Whether the stock surfaces render their own stylesheets.
+     *
+     * @remarks
+     * The banner, dialog trigger, ConsentGate, dialog and preference widget
+     * each render the c15t rules they use as a `<style>` element: in the
+     * server-rendered HTML, or with the surface's own code in the browser.
+     * No c15t stylesheet `<link>` then holds back the page's first paint.
+     * React 19 moves them into `<head>` and renders each once. They carry
+     * {@link ConsentProviderOptions.nonce}.
+     *
+     * Set `false` when the app imports `styles.css` itself, for example to
+     * run it through Tailwind CSS 3 or to put it in a named cascade layer.
+     *
+     * @default true
+     */
+    styles?: boolean;
     /**
      * Transport factory the provider builds its kernel with. Required.
      *
@@ -57,7 +75,7 @@ export interface ConsentProviderOptions extends ConsentControlOptions, Pick<Reac
      * ```tsx
      * import { ConsentProvider, hosted, offline } from '@c15t/react';
      *
-     * <ConsentProvider options={{ mode: hosted({ url: '/api/c15t' }) }}>
+     * <ConsentProvider options={{ mode: hosted({ backendURL: '/api/c15t' }) }}>
      *   {children}
      * </ConsentProvider>
      *
@@ -101,7 +119,7 @@ export interface ConsentProviderOptions extends ConsentControlOptions, Pick<Reac
      * // app/layout.tsx — stays synchronous, so the shell prerenders.
      * const config = resolveConsent({ backendURL });
      * return (
-     *   <ConsentProvider options={{ mode: hosted({ url }), prefetch: config }}>
+     *   <ConsentProvider options={{ mode: hosted({ backendURL }), prefetch: config }}>
      *     {children}
      *   </ConsentProvider>
      * );
@@ -261,7 +279,7 @@ export type ConsentProviderProps = OwnedRuntimeProviderProps | ExternalRuntimePr
  * ```tsx
  * import { createConsentRuntime } from '@c15t/core/runtime';
  *
- * const runtime = createConsentRuntime({ mode: hosted({ url: '/api/c15t' }) });
+ * const runtime = createConsentRuntime({ mode: hosted({ backendURL: '/api/c15t' }) });
  * runtime.start();
  *
  * <ConsentProvider runtime={runtime} options={{ theme }}>

package/dist-types/transports/hosted.d.ts

@@ -0,0 +1,36 @@
+import type { HostedModeFactory, HostedModeOptions } from '@c15t/core';
+/** Options for {@link hosted}. `backendURL` defaults to the build's. */
+export type HostedOptions = Omit<HostedModeOptions, 'backendURL'> & {
+    /**
+     * Backend URL, relative (`/api/c15t`) or absolute. Defaults to the URL
+     * `consentManifest()` from `c15t/build` read from
+     * `VITE_C15T_BACKEND_URL` or `VITE_INTH_PROJECT_URL`.
+     */
+    backendURL?: string;
+};
+/**
+ * Build a hosted factory, taking the backend URL from the build when the
+ * options name none.
+ *
+ * @param options - The page's options.
+ * @param buildBackendURL - The backend URL the build read, if any.
+ * @returns A hosted transport factory.
+ * @throws {Error} When neither names a backend URL.
+ * @internal
+ */
+export declare const hostedWithBuild: (options: HostedOptions, buildBackendURL: string | undefined) => HostedModeFactory;
+/**
+ * Ask the backend's `/init` for every visitor's policy.
+ *
+ * @param options - Backend URL, init headers and request overrides.
+ * @returns A transport factory for the provider's `mode`, carrying its
+ * options.
+ * @throws {Error} When no backend URL is passed and the build set none.
+ * @example
+ * ```tsx
+ * import { ConsentProvider, hosted } from 'c15t/react';
+ *
+ * <ConsentProvider options={{ mode: hosted() }}>{children}</ConsentProvider>;
+ * ```
+ */
+export declare const hosted: (options?: HostedOptions) => HostedModeFactory;

package/dist-types/transports/manifest.d.ts

@@ -0,0 +1,48 @@
+import type { BrowserManifestModeFactory, BrowserManifestOptions } from '@c15t/core/transports/manifest-browser';
+/**
+ * Manifest mode for the React provider: core's browser resolver, with the
+ * policy and backend URL the build integration downloaded as defaults.
+ */
+import type { ConsentManifest } from '@c15t/schema/types';
+/** What a build integration downloaded, as `@c15t/core/generated` exports it. */
+export interface BuildOutput {
+    backendURL?: string;
+    snapshot?: ConsentManifest;
+}
+/**
+ * Fill the options the page left out from the build: the backend URL that
+ * saves go to, and the snapshot unless the page passed one, a
+ * `manifestURL`, or `source: 'runtime'`.
+ *
+ * @param options - The page's options.
+ * @param build - What the build downloaded.
+ * @returns The options `manifest()` resolves with.
+ * @internal
+ */
+export declare const withBuildDefaults: (options: BrowserManifestOptions, build: BuildOutput) => BrowserManifestOptions;
+/**
+ * Resolve the policy in the browser from the backend's consent manifest.
+ *
+ * Without options it uses what `consentManifest()` from `c15t/build`
+ * downloaded: the snapshot and the backend URL from
+ * `VITE_C15T_BACKEND_URL` or `VITE_INTH_PROJECT_URL`, both served as
+ * `c15t/generated`. Without a
+ * snapshot, such as in dev after a failed fetch, it fetches
+ * `${backendURL}/manifest` at runtime. Saves go to the backend either way.
+ * With `manifestURL` or `source: 'runtime'`, also pass `source: 'runtime'`
+ * to `consentManifest()`, so the build downloads no snapshot.
+ *
+ * @param options - Overrides: your own `snapshot`, `source: 'runtime'`, a
+ * `manifestURL`, a `backendURL`, or the visitor's location as `inputs`.
+ * @returns A transport factory for the provider's `mode`, carrying its
+ * options.
+ * @throws {Error} When no snapshot, manifest URL or backend URL is known.
+ * @example
+ * ```tsx
+ * import { ConsentProvider, manifest } from 'c15t/react';
+ *
+ * <ConsentProvider options={{ mode: manifest() }}>{children}</ConsentProvider>;
+ * ```
+ */
+export declare const manifest: (options?: BrowserManifestOptions) => BrowserManifestModeFactory;
+export type { BrowserManifestModeFactory, BrowserManifestOptions as ManifestModeOptions, } from '@c15t/core/transports/manifest-browser';

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

@@ -12,6 +12,10 @@ export interface V3UIConfigValue {
     theme?: Theme;
     legalLinks?: LegalLinks;
     preloadDialog?: DialogPreload;
+    /** CSP nonce for the `<style>` elements the surfaces render. */
+    nonce?: string;
+    /** `false` when the app loads `styles.css` itself. */
+    styles?: boolean;
 }
 export declare const V3UIConfigContext: import("react").Context<V3UIConfigValue>;
 export declare const useUIConfig: () => V3UIConfigValue;

package/dist-types/version.d.ts

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