@c15t/astro 3.0.0-alpha.0

package/dist-types/mode.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Transport selection for `@c15t/astro`.
+ *
+ * Astro evaluates `astro.config.mjs` at build time, but the browser boot
+ * script is a string the integration injects. A transport factory cannot
+ * cross that boundary, so the integration takes a plain descriptor and both
+ * sides turn it into a {@link ProviderTransportFactory} themselves.
+ */
+import { custom } from '@c15t/core';
+import type { ProviderTransportFactory } from '@c15t/core';
+import type { C15tHostedDescriptor, C15tManifestDescriptor, C15tModeDescriptor, C15tOfflineDescriptor } from './types';
+/**
+ * Talk to a c15t backend over HTTP.
+ *
+ * @param options - Backend URL and request options.
+ * @returns A serializable hosted-mode descriptor.
+ * @example
+ * ```ts
+ * import { c15t, hosted } from '@c15t/astro';
+ *
+ * export default defineConfig({
+ *   integrations: [c15t({ mode: hosted({ url: 'https://consent.example.com' }) })],
+ * });
+ * ```
+ */
+export declare const hostedMode: (options: Omit<C15tHostedDescriptor, "type">) => C15tHostedDescriptor;
+/**
+ * Resolve policies locally with no backend.
+ *
+ * @param options - Explicit policy rules to resolve against.
+ * @returns A serializable offline-mode descriptor.
+ * @example
+ * ```ts
+ * c15t({ mode: offline() })
+ * ```
+ */
+export declare const offlineMode: (options?: Omit<C15tOfflineDescriptor, "type">) => C15tOfflineDescriptor;
+/**
+ * Resolve `/init` from a cached consent manifest.
+ *
+ * The server resolves it in-process; the browser goes through the injected
+ * `/api/c15t/init` route, so no manifest or translation bundle reaches the
+ * client.
+ *
+ * @param options - Manifest URL, inline manifest, or backend URL.
+ * @returns A serializable manifest-mode descriptor.
+ * @example
+ * ```ts
+ * c15t({ mode: manifest({ backendURL: process.env.C15T_BACKEND_URL }) })
+ * ```
+ */
+export declare const manifestMode: (options?: Omit<C15tManifestDescriptor, "type">) => C15tManifestDescriptor;
+/** Where the browser reaches manifest-resolved init data. */
+export interface ManifestClientEndpoints {
+    /** Route that returns a resolved `InitOutput`. */
+    initPath: string;
+    /** Backend base URL used for `POST /subjects`. */
+    backendURL?: string;
+}
+/**
+ * Turn a mode descriptor into the transport factory a kernel needs.
+ *
+ * `manifest` resolves through `endpoints.initPath` so the browser never
+ * downloads a manifest or the full translation catalogue. Server code that
+ * wants in-process manifest resolution uses
+ * `createServerManifestFactory` from `@c15t/astro/server` instead.
+ *
+ * @param descriptor - The serialized mode descriptor.
+ * @param endpoints - Route paths used by `manifest` mode.
+ * @returns A transport factory for `createConsentKernel`.
+ * @throws {Error} When the descriptor carries an unknown `type`.
+ */
+export declare const resolveTransportFactory: (descriptor: C15tModeDescriptor, endpoints?: ManifestClientEndpoints) => ProviderTransportFactory;
+/** Escape hatch for a caller-supplied transport. */
+export { custom };

package/dist-types/server.d.ts

@@ -0,0 +1,130 @@
+import type { ConsentSnapshot, KernelConfig, KernelTranslations } from '@c15t/core';
+import type { ConsentRequestHeaderInputs } from '@c15t/schema/types';
+import type { C15tColorScheme, C15tLocals, C15tResolvedOptions } from './types';
+/** Input for {@link resolveConsentContext}. */
+export interface ResolveConsentContextOptions {
+    /** The incoming request headers. */
+    headers: Headers;
+    /**
+     * The absolute request URL. Used to resolve a relative `backendURL` or
+     * `manifestURL` against this request's own origin and protocol; without
+     * it the shared resolver assumes `https`.
+     */
+    url?: string;
+    /** The integration options, already normalized. */
+    options: C15tResolvedOptions;
+    /** Override fetch, mainly for tests. */
+    fetch?: typeof globalThis.fetch;
+    /**
+     * Skip the server-side init roundtrip and return cookie + geo only.
+     * Useful for static output where every request shares one render.
+     */
+    skipPrefetch?: boolean;
+    /**
+     * Receives the promise of a background manifest revalidation started by
+     * this render, so the host can keep it alive past the response on
+     * runtimes that stop detached work once a response is sent. The
+     * middleware passes the adapter's `waitUntil` from `locals.runtime.ctx`
+     * when there is one. The promise never rejects.
+     */
+    onBackgroundRevalidate?: (revalidation: Promise<void>) => void;
+}
+/**
+ * Resolve the language the surfaces should render in.
+ *
+ * @param options - Integration options.
+ * @param inputs - Request inputs from the geo/language headers.
+ * @returns The kernel translations for this request.
+ */
+export declare const resolveTranslations: (options: C15tResolvedOptions, inputs: ConsentRequestHeaderInputs) => KernelTranslations;
+/**
+ * Read cookies and geo headers into a baseline `KernelConfig`.
+ *
+ * Does no network work and sets no cookies, so it is safe on every runtime
+ * including static prerenders.
+ *
+ * @param headers - The incoming request headers.
+ * @param options - The integration options.
+ * @returns A config seeded with stored consent and request overrides.
+ */
+export declare const readInitialConsentConfig: (headers: Headers, options: C15tResolvedOptions) => {
+    config: KernelConfig;
+    inputs: ConsentRequestHeaderInputs;
+};
+/**
+ * Derive the kernel snapshot the server would hand a freshly booted page.
+ *
+ * Kernel construction is pure — no DOM, no network, no storage — so this is
+ * safe to run per request.
+ *
+ * @param config - The resolved kernel configuration.
+ * @returns The snapshot, including derived `activeUI` and policy UI hints.
+ */
+export declare const snapshotFromConfig: (config: KernelConfig) => ConsentSnapshot;
+/**
+ * Resolve everything the page needs about consent for one request.
+ *
+ * Reads the consent cookie and the geo/GPC headers, prefetches the policy
+ * decision through the configured mode, and derives whether the banner
+ * should render server-side.
+ *
+ * @param input - Request headers and integration options.
+ * @returns The value the middleware stores on `Astro.locals.c15t`.
+ * @example
+ * ```ts
+ * const c15t = await resolveConsentContext({ headers: request.headers, options });
+ * ```
+ */
+export declare const resolveConsentContext: (input: ResolveConsentContextOptions) => Promise<C15tLocals>;
+/**
+ * Build the inline `<script>` body that hands the browser its boot payload.
+ *
+ * The payload is the already-resolved `KernelConfig`, not a fetch: the
+ * browser starts with the same decision the server rendered, so there is no
+ * network init per page and no banner flicker.
+ *
+ * @param config - The resolved kernel configuration.
+ * @returns JavaScript safe for inline `<script>` injection.
+ */
+export declare const buildConfigScript: (config: KernelConfig) => string;
+/**
+ * Build the first-paint colour-scheme script.
+ *
+ * Dark mode is the `c15t-dark` class on `<html>`, and the client boot sets
+ * it — but that runs after the stylesheet has already painted the
+ * server-rendered banner in the light palette. This runs in `<head>`,
+ * before the browser has anything to paint, so a system-dark visitor never
+ * sees the flash. It is deliberately framework-free and unbundled: a
+ * module script would be deferred and lose the race.
+ *
+ * `'light'` emits nothing. Light is the absence of the class, so there is
+ * nothing to do before paint.
+ *
+ * @param colorScheme - The resolved colour scheme.
+ * @returns Script source, or an empty string when none is needed.
+ * @example
+ * ```astro
+ * <script is:inline set:html={buildColorSchemeScript('system')} />
+ * ```
+ */
+export declare const buildColorSchemeScript: (colorScheme: C15tColorScheme) => string;
+export { buildPrefetchScript } from '@c15t/core';
+export type { KernelConfig } from '@c15t/core';
+/**
+ * The per-request identity the emission guard keys off — in practice
+ * `Astro.locals`, which Astro creates fresh for every request.
+ */
+export interface ConfigEmissionScope {
+    c15t?: C15tLocals;
+}
+/**
+ * Claim the one-per-request emission of the inline config script.
+ *
+ * `<ConsentScript />` and `<ConsentBanner />` both want to inline the boot
+ * payload, and a page may well contain both. The first caller for a given
+ * request wins; every later caller renders nothing.
+ *
+ * @param locals - The current `Astro.locals`, used as the request identity.
+ * @returns `true` for the first caller of this request.
+ */
+export declare const markConfigEmitted: (locals: ConfigEmissionScope) => boolean;

package/dist-types/types.d.ts

@@ -0,0 +1,305 @@
+/**
+ * Public option and locals types for `@c15t/astro`.
+ *
+ * Everything the integration accepts must survive `JSON.stringify`: the
+ * options are serialized once at build time into a virtual module that the
+ * middleware, the `.astro` components and the injected client boot script
+ * all import. Callbacks and other live values belong in the module named
+ * by {@link C15tAstroOptions.clientEntrypoint}.
+ */
+import type { AllConsentNames, ConsentSnapshot, ConsentPresentation, KernelConfig, LegalLinks, Script, StorageConfig } from '@c15t/core';
+import type { PolicyRule, PolicyResolution, ConsentManifest, GlobalVendorList } from '@c15t/schema/types';
+import type { Theme } from '@c15t/ui/theme';
+/** Transport selection, in a form that survives serialization. */
+export type C15tModeDescriptor = C15tHostedDescriptor | C15tOfflineDescriptor | C15tManifestDescriptor;
+/** Talk to a c15t backend over HTTP. */
+export interface C15tHostedDescriptor {
+    type: 'hosted';
+    /** Backend base URL. Absolute, or same-origin like `/api/c15t`. */
+    url: string;
+    /** Domain recorded when consent is saved. */
+    domain?: string;
+    /** Extra headers forwarded to the backend. */
+    headers?: Record<string, string>;
+}
+/** Resolve policies locally with no backend at all. */
+export interface C15tOfflineDescriptor {
+    type: 'offline';
+    /** Policy packs resolved locally. */
+    policyRules?: PolicyRule[];
+}
+/**
+ * Resolve `/init` from a cached consent manifest.
+ *
+ * The server resolves the manifest per request; the browser talks to the
+ * injected `/api/c15t/init` route, which is manifest-backed and cached.
+ */
+export interface C15tManifestDescriptor {
+    type: 'manifest';
+    /** `GET /manifest` URL. Defaults to `${backendURL}/manifest`. */
+    manifestURL?: string;
+    /** Backend base URL used for `POST /subjects`. */
+    backendURL?: string;
+    /** Inline manifest. Takes precedence over `manifestURL`. */
+    manifest?: ConsentManifest;
+}
+/**
+ * Which framework renders the on-demand dialog islands.
+ *
+ * Svelte is the default because it is the smallest: its runtime costs
+ * roughly 14 KB gzipped against React's ~45 KB. A site already shipping
+ * React or Vue should say so and reuse what it has instead of downloading
+ * a second framework for one dialog. The choice is never inferred — a
+ * silent change to what a page downloads is worse than an explicit one.
+ */
+export type C15tUIAdapterName = 'svelte' | 'react' | 'vue';
+/**
+ * How the consent surfaces pick light or dark.
+ *
+ * Dark mode is the `c15t-dark` class on `<html>`, not a
+ * `prefers-color-scheme` block, so something has to set it. `'system'`
+ * follows `prefers-color-scheme` and keeps following it; `'light'` and
+ * `'dark'` pin it.
+ */
+export type C15tColorScheme = 'light' | 'dark' | 'system';
+/** Route paths the integration can inject. */
+export interface C15tEndpointOptions {
+    /**
+     * Inject `GET /api/c15t/init` and `GET /api/c15t/manifest`.
+     *
+     * Required for `mode: manifest()` unless you write the routes yourself.
+     *
+     * @default true when `mode.type === 'manifest'`, otherwise false
+     */
+    enabled?: boolean;
+    /** @default '/api/c15t/init' */
+    initPath?: string;
+    /** @default '/api/c15t/manifest' */
+    manifestPath?: string;
+}
+/** How the integration registers its `pre`-order middleware. */
+export interface C15tMiddlewareOptions {
+    /**
+     * Register `@c15t/astro/middleware` at all.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Extra path prefixes the middleware leaves alone.
+     *
+     * The integration's own init and manifest routes are always skipped, so
+     * this is only for routes of your own that must not resolve consent —
+     * health checks, webhooks, anything that would otherwise pay for a
+     * decision it never renders. A path matches when it is the pathname
+     * exactly or a parent segment of it, so `'/api'` covers `/api/health`.
+     *
+     * `Astro.locals.c15t` is left unset on a skipped route.
+     *
+     * @example ['/api/webhooks', '/healthz']
+     */
+    skip?: string[];
+}
+/** Options accepted by the `c15t()` Astro integration. */
+export interface C15tAstroOptions {
+    /** Host layout and styling constrained by the active policy. */
+    presentation?: ConsentPresentation;
+    /**
+     * Transport selection. Build it with `hosted()`, `offline()` or
+     * `manifest()` so the descriptor stays well-formed.
+     */
+    mode: C15tModeDescriptor;
+    /** Categories offered in the banner and preference centre. */
+    consentCategories?: AllConsentNames[];
+    /** Consent-gated scripts handed to the core script loader. */
+    scripts?: Script[];
+    /**
+     * IAB TCF configuration. `false` disables it.
+     *
+     * Only the serializable fields are accepted here; a live GVL fetcher
+     * belongs in {@link C15tAstroOptions.clientEntrypoint}.
+     */
+    iab?: C15tIABOptions | false;
+    /** Cookie/localStorage configuration for persisted consent. */
+    storageConfig?: StorageConfig;
+    /** Locale and message overrides. */
+    i18n?: C15tI18nOptions;
+    /** Theme tokens applied to the banner and dialog surfaces. */
+    theme?: Theme;
+    /**
+     * Light or dark for the banner and dialogs.
+     *
+     * `'system'` follows `prefers-color-scheme` and keeps following it as
+     * the visitor changes it. `<ConsentScript />` writes the class from a
+     * tiny inline script in `<head>`, so the server-rendered banner is
+     * already dark on its first paint rather than flashing light.
+     *
+     * @default 'system'
+     */
+    colorScheme?: C15tColorScheme;
+    /** Legal links rendered inline in the banner and dialog. */
+    legalLinks?: LegalLinks;
+    /**
+     * Framework used to render the on-demand dialog islands.
+     *
+     * `'svelte'` ships the least JavaScript and is the default. Pick
+     * `'react'` or `'vue'` when the site already loads that runtime, so the
+     * dialog reuses it instead of adding a second framework. Whichever you
+     * pick, install the matching Astro integration — `@astrojs/svelte`,
+     * `@astrojs/react` or `@astrojs/vue` — and list it before `c15t()`.
+     *
+     * @default 'svelte'
+     */
+    ui?: C15tUIAdapterName;
+    /** Injected API routes. */
+    endpoints?: C15tEndpointOptions | boolean;
+    /**
+     * Module specifier whose default export is a
+     * {@link C15tClientOptionsExtension}. Use it for anything that cannot be
+     * serialized — callbacks, a custom GVL fetcher, scripts with lifecycle
+     * hooks.
+     *
+     * @example './src/c15t.client.ts'
+     */
+    clientEntrypoint?: string;
+    /**
+     * Register the `pre`-order middleware that populates `Astro.locals.c15t`.
+     *
+     * `false` is the same as `{ enabled: false }`. The middleware already
+     * skips the integration's own init and manifest routes, so a site that
+     * serves its own manifest does not have to hand-roll one to break the
+     * cycle; use `skip` to add routes of your own.
+     *
+     * @default true
+     */
+    middleware?: boolean | C15tMiddlewareOptions;
+    /**
+     * Fail the build when the Astro integration for {@link C15tAstroOptions.ui}
+     * is missing. Set to `false` for banner-only sites, which render no
+     * island at all.
+     *
+     * @default true
+     */
+    requireUIIntegration?: boolean;
+}
+/**
+ * IAB TCF options accepted by the integration.
+ *
+ * The serializable subset of the runtime's `RuntimeIABOptions`: a custom
+ * fetcher cannot survive the trip into the injected boot script, so that
+ * belongs in {@link C15tAstroOptions.clientEntrypoint} instead. A vendor
+ * list itself is plain JSON and does travel — see {@link C15tIABOptions.gvl}.
+ */
+export interface C15tIABOptions {
+    /** Set `false` to keep IAB configured but inert. */
+    enabled?: boolean;
+    /**
+     * A vendor list to use as-is, instead of fetching one.
+     *
+     * The server needs a GVL to render `<IABConsentBanner />` at all — the
+     * banner names the purposes and counts the vendors — so hosted and
+     * manifest mode get theirs from `/init`. Offline mode has no backend to
+     * ask, which is what this is for: a pinned list, or a fixture in a
+     * demo. It is inlined into the page's boot payload, so keep it trimmed
+     * to the vendors the site actually works with.
+     */
+    gvl?: GlobalVendorList;
+    /** IAB-registered CMP ID. A hosted backend can supply it through `/init`. */
+    cmpId?: number;
+    /** CMP version reported through `__tcfapi`. */
+    cmpVersion?: number;
+    /** Restricts the vendor list to these vendor IDs. */
+    vendors?: number[];
+    /** Publisher country code used in the TC string. */
+    publisherCountryCode?: string;
+    /** Whether the CMP is service-specific rather than global. */
+    isServiceSpecific?: boolean;
+    /**
+     * Fetch the vendor list from this URL on the server.
+     *
+     * Goes through the shared in-process cache in `@c15t/core/server`, so
+     * concurrent renders collapse onto one download. Ignored when
+     * {@link C15tIABOptions.gvl} is set.
+     */
+    gvlURL?: string;
+}
+/** Locale configuration accepted by the integration. */
+export interface C15tI18nOptions {
+    /** Force a locale instead of negotiating `Accept-Language`. */
+    locale?: string;
+    /** Per-language message overrides, deep-merged over the defaults. */
+    messages?: Record<string, unknown>;
+    /**
+     * Negotiate the locale from the request's `Accept-Language` header.
+     *
+     * @default true
+     */
+    detectLanguage?: boolean;
+}
+/**
+ * Non-serializable additions merged over the integration options in the
+ * browser. Default-export this from
+ * {@link C15tAstroOptions.clientEntrypoint}.
+ */
+export interface C15tClientOptionsExtension {
+    scripts?: Script[];
+    callbacks?: Record<string, unknown>;
+    /** Merged over the serialized theme. */
+    theme?: Theme;
+}
+/**
+ * The serialized options shape shared by the middleware, the components and
+ * the client boot script.
+ *
+ * @internal
+ */
+export interface C15tResolvedOptions extends Omit<C15tAstroOptions, 'endpoints' | 'middleware' | 'requireUIIntegration'> {
+    ui: C15tUIAdapterName;
+    colorScheme: C15tColorScheme;
+    endpoints: Required<Omit<C15tEndpointOptions, 'enabled'>> & {
+        enabled: boolean;
+    };
+    middleware: Required<C15tMiddlewareOptions>;
+}
+/** Consent context the middleware attaches to every request. */
+export interface C15tLocals {
+    /**
+     * Server-resolved kernel configuration. Inline it into the page with
+     * `<ConsentBanner />` or `buildConfigScript()` so the browser boots with
+     * no `/init` roundtrip.
+     */
+    config: KernelConfig;
+    /**
+     * The kernel snapshot derived from {@link C15tLocals.config}. Components
+     * read translations, policy UI hints and consent state from here so the
+     * server and the browser agree on first paint.
+     */
+    snapshot: ConsentSnapshot;
+    /** Whether the server decided this request should see the banner. */
+    shouldShowBanner: boolean;
+    /**
+     * Whether a policy rule is resolved for this request. Every c15t consent
+     * surface renders nothing until one is: an unconfigured, failed, or
+     * unmatched resolution leaves nothing to consent to, and the browser shows
+     * the surfaces on its own once a later init supplies a rule.
+     */
+    hasPolicy: boolean;
+    /**
+     * Whether the resolved rule owes any consent UI. A prompt owes a banner
+     * and a preference center; rights owe a way back to preferences. A `none`
+     * rule with no rights owes neither, so no surface renders while the
+     * permissions it grants apply. `false` until a rule is resolved.
+     */
+    hasConsentUi: boolean;
+    /** Resolved policy decision, when the transport produced one. */
+    decision: PolicyResolution;
+    /** Normalized request inputs (geo, language, GPC). */
+    inputs: {
+        country?: string;
+        region?: string;
+        language?: string;
+        gpc?: boolean;
+    };
+    /** The integration options, as the browser will receive them. */
+    options: C15tResolvedOptions;
+}

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

@@ -0,0 +1,122 @@
+/**
+ * The dialog surface seam.
+ *
+ * The banner is server-rendered `.astro` with no framework at all, but the
+ * preference centre and the IAB dialog need real component state. Rather
+ * than hard-wiring one framework through the whole package, dialogs go
+ * through this adapter: `svelte`, `react` and `vue` each implement it, and
+ * a site downloads exactly the one its `ui` option names.
+ *
+ * Nothing framework-specific is named here, and the registry starts empty
+ * on purpose. A built-in entry pointing at the React adapter would make
+ * every build resolve `@c15t/react` and `react-dom`, which a Svelte-only
+ * site does not install. The integration knows `ui` at config time, so it
+ * registers the one adapter and the one surface into the page boot script;
+ * that is the only place a framework specifier appears.
+ */
+import type { ConsentRuntime } from '@c15t/core/runtime';
+import type { C15tResolvedOptions, C15tUIAdapterName } from '../types';
+/** Which dialog a caller asked for. */
+export type ConsentDialogKind = 'preferences' | 'iab';
+/** Context handed to an adapter when a dialog opens. */
+export interface ConsentDialogContext {
+    /** The page-level runtime that owns the kernel. */
+    runtime: ConsentRuntime;
+    /** The resolved integration options. */
+    options: C15tResolvedOptions;
+    /** The element the surface mounts into. */
+    target: HTMLElement;
+    /** Which dialog to show. */
+    kind: ConsentDialogKind;
+    /**
+     * Which IAB preference-centre tab to open on. Ignored by the
+     * preferences dialog, which has no tabs.
+     */
+    tab?: 'purposes' | 'vendors';
+}
+/**
+ * Loads the component a dialog adapter mounts.
+ *
+ * The loader is registered by the `.astro` dialog component rather than
+ * imported here, so the specifier is resolved by the consuming app's build
+ * — which is the only build that knows how to compile a `.svelte` file —
+ * and the chunk stays out of the page until someone opens a dialog.
+ */
+export type ConsentDialogSurfaceLoader = () => Promise<{
+    default: unknown;
+}>;
+/**
+ * Register the component a dialog adapter should mount.
+ *
+ * @param name - The adapter the surface belongs to.
+ * @param load - Loader returning the surface module.
+ * @example
+ * ```ts
+ * registerDialogSurface('svelte', () =>
+ *   import('@c15t/astro/islands/panel-surface.svelte')
+ * );
+ * ```
+ */
+export declare const registerDialogSurface: (name: C15tUIAdapterName, load: ConsentDialogSurfaceLoader) => void;
+/**
+ * The registered surface loader for an adapter.
+ *
+ * @param name - The adapter name.
+ * @returns The loader.
+ * @throws {Error} When no surface has been registered for that adapter.
+ */
+export declare const requireDialogSurface: (name: C15tUIAdapterName) => ConsentDialogSurfaceLoader;
+/** A mounted dialog surface. */
+export interface ConsentDialogHandle {
+    /** Hide the dialog without destroying the surface. */
+    close: () => void;
+    /** Unmount and release everything. */
+    destroy: () => Promise<void> | void;
+}
+/** A dialog surface implementation. */
+export interface ConsentDialogAdapter {
+    /** Adapter name, matching the `ui` integration option. */
+    readonly name: C15tUIAdapterName;
+    /**
+     * Mount the surface. Called on the first open only; later opens reuse
+     * the returned handle.
+     *
+     * @param context - Runtime, options and mount target.
+     * @returns A handle controlling the mounted surface.
+     */
+    mount: (context: ConsentDialogContext) => Promise<ConsentDialogHandle>;
+    /**
+     * Warm the surface's chunks without mounting anything, so the first
+     * open does not wait on a download.
+     */
+    preload?: () => Promise<void>;
+}
+/**
+ * Register a dialog surface implementation.
+ *
+ * @param name - The adapter name, matched against the `ui` option.
+ * @param load - Loader returning the adapter. Called at most once.
+ */
+export declare const registerDialogAdapter: (name: C15tUIAdapterName, load: () => Promise<ConsentDialogAdapter>) => void;
+/**
+ * Empties both registries.
+ *
+ * The registries are module state, so a test that registers an adapter
+ * would otherwise decide what the next one sees.
+ *
+ * Tests only.
+ *
+ * @internal
+ */
+export declare const resetDialogRegistriesForTest: () => void;
+/**
+ * Load the adapter named by the `ui` option.
+ *
+ * The import is dynamic so a page that never opens a dialog never
+ * downloads the framework behind it.
+ *
+ * @param name - The adapter name.
+ * @returns The adapter.
+ * @throws {Error} When no adapter is registered under that name.
+ */
+export declare const loadDialogAdapter: (name: C15tUIAdapterName) => Promise<ConsentDialogAdapter>;

package/dist-types/ui/provider-props.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Props for the Svelte dialog island.
+ *
+ * The page runtime owns the kernel and every side-effecting module, so the
+ * provider is handed it through `runtime` and neither starts nor disposes
+ * it. Everything else it gets here is presentation: categories, legal links
+ * and theme tokens the banner and dialog both read.
+ */
+import type { ConsentRuntime } from '@c15t/core/runtime';
+import type { C15tResolvedOptions } from '../types';
+/**
+ * The slice of the integration options a dialog island renders with.
+ *
+ * Named so every framework surface can state the same shape instead of
+ * widening to `Record<string, unknown>` and casting it back.
+ */
+export interface DialogPresentationOptions {
+    consentCategories?: C15tResolvedOptions['consentCategories'];
+    legalLinks?: C15tResolvedOptions['legalLinks'];
+    presentation?: C15tResolvedOptions['presentation'];
+    theme?: C15tResolvedOptions['theme'];
+}
+/** Props handed to `ConsentManagerProvider` by the Svelte dialog surface. */
+export interface DialogProviderProps {
+    /** The page-level runtime. The provider borrows it, it does not own it. */
+    runtime: ConsentRuntime;
+    /** Presentation options forwarded to the provider. */
+    options: DialogPresentationOptions;
+}
+/**
+ * Build the provider props for a dialog island.
+ *
+ * @param runtime - The page runtime that owns the kernel.
+ * @param options - The resolved integration options.
+ * @returns Props for `ConsentManagerProvider`.
+ */
+export declare const buildProviderProps: (runtime: ConsentRuntime, options: C15tResolvedOptions) => DialogProviderProps;

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

@@ -0,0 +1,19 @@
+/**
+ * The React dialog surface.
+ *
+ * For a site that already ships React, mounting the preference centre in
+ * React costs nothing new: the runtime is on the page already, and the
+ * dialog reuses it instead of pulling a second framework alongside it. A
+ * site that does not ship React should stay on the Svelte default, which
+ * is roughly a third of the runtime weight.
+ *
+ * Mounting happens on the first open through `mount()`, so the island's
+ * chunks are paid for only by visitors who click "Customize".
+ *
+ * The island itself is registered by the integration rather than imported
+ * here: a `.tsx` file can only be compiled by the consuming app's build,
+ * and only that build knows whether `@astrojs/react` is present.
+ */
+import type { ConsentDialogAdapter } from './adapter';
+/** The React 18/19 dialog surface implementation. */
+export declare const reactDialogAdapter: ConsentDialogAdapter;