@c15t/astro 3.0.0-alpha.0

package/AGENTS.md

@@ -0,0 +1,86 @@
+# @c15t/astro
+
+> Astro v3 static and server integration, dialog adapters and runtime ownership.
+
+These docs ship inside the package so coding agents can read them offline. Open the topic file you need from the list below — paths are relative to this file.
+
+## Using these docs
+
+These docs describe v3. Start with Inth hosted setup, identify the framework, router and deployment, then read its quickstart. Static sites can use Inth directly. Use page Markdown and package-bundled docs for targeted context. Verify scripts, rejection, reload and preferences; banner visibility alone is insufficient.
+
+## Start here
+
+- [Astro quickstart](./docs/frameworks/astro/quickstart.md)
+- [Customize your consent interface](./docs/customization/overview.md): Choose presentation, theme tokens, slots or custom markup for the change you need.
+- [Verify consent before shipping](./docs/guides/verify-consent.md): Test requests, policy resolution, persistence, navigation and preference changes in a production build.
+- [Upgrade to v3 policies](./docs/upgrade-v3.md): Migrate policy configuration, consent records, callbacks, and custom transports to the v3 policy system.
+
+## More documentation
+
+[Documentation index](https://c15t.com/docs/llms.txt) · [Full Markdown context](https://c15t.com/llms-full.txt). Prefer the index and individual pages for focused tasks.
+
+## Frameworks
+
+- [Quickstart](./docs/frameworks/astro/quickstart.md): Add c15t to static or server-rendered Astro pages and choose the framework used by preference dialogs.
+
+## Guides
+
+- [Understand consent state](./docs/guides/consent-state.md): Distinguish policy resolution, effective permissions, explicit choices, notices and privacy signals.
+- [Data fetching and transports](./docs/guides/data-fetching.md): Choose cached manifests, backend init or offline policy resolution, and understand where consent records are saved.
+- [Choose a deployment mode](./docs/guides/deployment-modes.md): Choose who runs your consent backend, then select manifest, init or offline resolution for your deployment.
+- [Troubleshoot consent](./docs/guides/troubleshooting.md): Diagnose missing banners, early vendor requests, lost choices and hydration differences.
+- [Verify consent before shipping](./docs/guides/verify-consent.md): Test requests, policy resolution, persistence, navigation and preference changes in a production build.
+
+## Customization
+
+- [Customize your consent interface](./docs/customization/overview.md): Choose presentation, theme tokens, slots or custom markup for the change you need.
+- [Banner styling recipes](./docs/customization/recipes.md): See real v3 components and reuse the exact theme configuration behind the examples.
+- [Style component slots](./docs/customization/slots.md): Target a specific c15t component part without replacing its markup or behavior.
+- [Theme tokens and CSS](./docs/customization/tokens.md): Style c15t with semantic tokens and use the stylesheet that matches your CSS tooling.
+- [Copy and translations](./docs/customization/translations.md): Change consent wording through i18n and test the complete prompt and preferences flow.
+
+## Integrations
+
+- [Adobe Analytics](./docs/integrations/adobe-analytics.md): Configure Adobe Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [Ahrefs Analytics](./docs/integrations/ahrefs-analytics.md): Configure Ahrefs Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [Amplitude](./docs/integrations/amplitude.md): Configure Amplitude with c15t v3, understand measurement permission and verify loading and revocation.
+- [Custom integrations](./docs/integrations/building-integrations.md): Define loading, initialization and consent-change behavior for a vendor without a helper.
+- [Clearbit](./docs/integrations/clearbit.md): Configure Clearbit with c15t v3, understand marketing permission and verify loading and revocation.
+- [Cloudflare Web Analytics](./docs/integrations/cloudflare-web-analytics.md): Configure Cloudflare Web Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [Crisp](./docs/integrations/crisp.md): Configure Crisp with c15t v3, understand functionality permission and verify loading and revocation.
+- [Databuddy](./docs/integrations/databuddy.md): Configure Databuddy's initial and updated consent state with c15t v3.
+- [Fathom Analytics](./docs/integrations/fathom-analytics.md): Configure Fathom Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [Google Maps](./docs/integrations/google-maps.md): Prevent a map iframe from mounting before the required permission.
+- [Google Tag](./docs/integrations/google-tag.md): Configure gtag with c15t Consent Mode signals and understand its loading behavior.
+- [Google Tag Manager](./docs/integrations/google-tag-manager.md): Load GTM with c15t consent signals and verify the tags inside your container.
+- [Heap](./docs/integrations/heap.md): Configure Heap with c15t v3, understand measurement permission and verify loading and revocation.
+- [Hightouch](./docs/integrations/hightouch.md): Configure Hightouch with c15t v3, understand measurement permission and verify loading and revocation.
+- [Hotjar](./docs/integrations/hotjar.md): Configure Hotjar with c15t v3, understand measurement permission and verify loading and revocation.
+- [Intercom](./docs/integrations/intercom.md): Load the Intercom messenger with functionality permission and configure its region.
+- [LinkedIn Insight Tag](./docs/integrations/linkedin-insights.md): Configure LinkedIn Insight Tag with c15t v3, understand marketing permission and verify loading and revocation.
+- [LogRocket](./docs/integrations/logrocket.md): Configure LogRocket with c15t v3, understand measurement permission and verify loading and revocation.
+- [Matomo Analytics](./docs/integrations/matomo-analytics.md): Choose gated loading or Matomo consent signaling and configure the correct tracker endpoints.
+- [Meta Pixel](./docs/integrations/meta-pixel.md): Register the Meta Pixel under marketing permission and verify event calls after revocation.
+- [Microsoft Clarity](./docs/integrations/microsoft-clarity.md): Configure Microsoft Clarity with c15t v3, understand measurement permission and verify loading and revocation.
+- [Microsoft UET](./docs/integrations/microsoft-uet.md): Configure Microsoft UET with c15t v3, understand marketing permission and verify loading and revocation.
+- [Mixpanel](./docs/integrations/mixpanel-analytics.md): Configure Mixpanel with c15t v3, understand measurement permission and verify loading and revocation.
+- [OpenAI Pixel](./docs/integrations/openai-pixel.md): Configure the OpenAI Measurement Pixel for ChatGPT Ads with c15t v3, manage marketing permission and verify conversion delivery.
+- [Overview](./docs/integrations/overview.md): Find all c15t integrations for analytics, tag managers, advertising, chat and embedded content.
+- [Pirsch](./docs/integrations/pirsch.md): Configure Pirsch with c15t v3, understand measurement permission and verify loading and revocation.
+- [Plausible Analytics](./docs/integrations/plausible-analytics.md): Configure Plausible Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [PostHog](./docs/integrations/posthog.md): Choose PostHog loading and cookieless behavior, configure the region, and synchronize v3 permissions.
+- [Promptwatch](./docs/integrations/promptwatch.md): Configure Promptwatch with c15t v3, understand measurement permission and verify loading and revocation.
+- [Reddit Pixel](./docs/integrations/reddit-pixel.md): Configure Reddit Pixel with c15t v3, understand marketing permission and verify loading and revocation.
+- [RudderStack](./docs/integrations/rudderstack.md): Gate the RudderStack browser SDK or map c15t categories to destination consent IDs.
+- [Rybbit Analytics](./docs/integrations/rybbit-analytics.md): Configure Rybbit Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [Segment](./docs/integrations/segment.md): Configure Segment with c15t v3, understand measurement permission and verify loading and revocation.
+- [Snapchat Pixel](./docs/integrations/snapchat-pixel.md): Configure Snapchat Pixel with c15t v3, understand marketing permission and verify loading and revocation.
+- [TikTok Pixel](./docs/integrations/tiktok-pixel.md): Configure TikTok Pixel with c15t v3, understand marketing permission and verify loading and revocation.
+- [Umami Analytics](./docs/integrations/umami-analytics.md): Configure Umami Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [Vercel Analytics](./docs/integrations/vercel-analytics.md): Configure Vercel Analytics with c15t v3, understand measurement permission and verify loading and revocation.
+- [X Pixel](./docs/integrations/x-pixel.md): Configure X Pixel with c15t v3, understand marketing permission and verify loading and revocation.
+- [YouTube](./docs/integrations/youtube.md): Gate YouTube embeds with c15t v3 in Next.js, TanStack Start, React, Nuxt, Vue, Astro, Svelte, SvelteKit or JavaScript.
+
+## Reference
+
+- [Upgrade to v3 policies](./docs/upgrade-v3.md): Migrate policy configuration, consent records, callbacks, and custom transports to the v3 policy system.

package/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: c15t-astro-docs
+description: Read and search the @c15t/astro documentation. Use when working with @c15t/astro — its setup, configuration, API, and behavior.
+metadata:
+  source: leadtype
+---
+# @c15t/astro documentation
+
+Astro v3 static and server integration, dialog adapters and runtime ownership.
+
+To work with @c15t/astro, read its bundled docs — they ship with the package and are version-matched to the installed code:
+
+- Start with `./AGENTS.md`; it links every per-topic Markdown file under `./docs/`.
+- Prefer these local files over fetching anything over the network.

package/dist/api/handlers.js

@@ -0,0 +1,91 @@
+import { serveGvlReference } from "@c15t/core";
+import { MANIFEST_PASSTHROUGH_HEADERS, fetchCachedGvl, fetchCachedManifest, getManifestAge } from "@c15t/core/server";
+import { extractConsentRequestInputs } from "@c15t/schema/types";
+import { loadConsentManifest, resolveManifestInit, resolveManifestSourceFrom } from "./manifest-init.js";
+const INIT_CACHE_CONTROL = 'private, no-store';
+const MANIFEST_ROUTE_SUFFIX = '/manifest';
+const handlers_waitUntilFromLocals = function(revalidation, locals) {
+    const ctx = locals?.runtime?.ctx;
+    if (ctx && 'function' == typeof ctx.waitUntil) ctx.waitUntil.call(ctx, revalidation);
+};
+const handlers_bindBackgroundRevalidate = function(handlerOptions, lifetime) {
+    if (handlerOptions.onBackgroundRevalidate) return handlerOptions.onBackgroundRevalidate;
+    if (!lifetime) return;
+    return (revalidation)=>handlers_waitUntilFromLocals(revalidation, lifetime.locals);
+};
+const handlers_resolveManifestSourceURL = function(request, options) {
+    return resolveManifestSourceFrom({
+        headers: request.headers,
+        url: request.url
+    }, options);
+};
+const handlers_createConsentRouteHandlers = function(handlerOptions) {
+    const init = async function(request, lifetime) {
+        const manifest = await loadConsentManifest({
+            fetch: handlerOptions.fetch,
+            onBackgroundRevalidate: handlers_bindBackgroundRevalidate(handlerOptions, lifetime),
+            options: handlerOptions.options,
+            source: {
+                headers: request.headers,
+                url: request.url
+            }
+        });
+        const listResponse = await serveGvlReference(request, (language)=>!manifest.iab?.gvl || handlerOptions.fetch || handlerOptions.fetchGvl ? Promise.resolve(null) : fetchCachedGvl({
+                language,
+                url: manifest.iab.gvl.url
+            }));
+        if (listResponse) return listResponse;
+        const payload = await resolveManifestInit({
+            fetch: handlerOptions.fetch,
+            fetchGvl: handlerOptions.fetchGvl,
+            gvlRoute: new URL(request.url).pathname,
+            inputs: extractConsentRequestInputs(request.headers, {
+                language: handlerOptions.options.i18n?.locale
+            }),
+            manifest
+        });
+        return Response.json(payload, {
+            headers: {
+                'cache-control': INIT_CACHE_CONTROL
+            }
+        });
+    };
+    const manifest = async function(request, lifetime) {
+        const manifestURL = handlers_resolveManifestSourceURL(request, handlerOptions.options);
+        const query = new URL(request.url).searchParams.toString();
+        const result = await fetchCachedManifest({
+            config: {
+                manifestURL
+            },
+            fetch: handlerOptions.fetch,
+            onBackgroundRevalidate: handlers_bindBackgroundRevalidate(handlerOptions, lifetime),
+            query
+        });
+        const headers = new Headers({
+            'content-type': 'application/json'
+        });
+        for (const name of MANIFEST_PASSTHROUGH_HEADERS){
+            const value = result.headers[name];
+            if (value) headers.set(name, value);
+        }
+        headers.set('age', String(getManifestAge(result)));
+        const { etag } = result.headers;
+        if (etag && request.headers.get('if-none-match') === etag) return new Response(null, {
+            headers,
+            status: 304
+        });
+        return new Response(JSON.stringify(result.manifest), {
+            headers,
+            status: 200
+        });
+    };
+    const GET = function(request) {
+        return new URL(request.url).pathname.endsWith(MANIFEST_ROUTE_SUFFIX) ? manifest(request) : init(request);
+    };
+    return {
+        GET,
+        init,
+        manifest
+    };
+};
+export { handlers_createConsentRouteHandlers as createConsentRouteHandlers, handlers_resolveManifestSourceURL as resolveManifestSourceURL, handlers_waitUntilFromLocals as waitUntilFromLocals };

package/dist/api/index.js

@@ -0,0 +1,3 @@
+export { createConsentRouteHandlers, resolveManifestSourceURL, waitUntilFromLocals } from "./handlers.js";
+export { loadConsentManifest, resolveManifestInit, resolveManifestSourceFrom } from "./manifest-init.js";
+export { MANIFEST_DEDUPE_TTL_SECONDS, MANIFEST_PASSTHROUGH_HEADERS, clearManifestCache, createManifestRequestURL, fetchCachedManifest, getManifestSMaxAge, getManifestStaleWhileRevalidate } from "@c15t/core/server";

package/dist/api/init.js

@@ -0,0 +1,10 @@
+import options from "virtual:c15t/options";
+import { createConsentRouteHandlers } from "./handlers.js";
+const handlers = createConsentRouteHandlers({
+    options: options
+});
+const GET = ({ locals, request })=>handlers.init(request, {
+        locals
+    });
+const prerender = false;
+export { GET, prerender };

package/dist/api/manifest-init.js

@@ -0,0 +1,103 @@
+import { deferInitGvlToRoute } from "@c15t/core";
+import { fetchCachedManifest } from "@c15t/core/server";
+import { consentInputsToOverrides, resolveBackendURL, resolveInitFromManifest } from "@c15t/schema/types";
+import { baseTranslations } from "@c15t/translations/all";
+const MANIFEST_ROUTE_SUFFIX = '/manifest';
+const manifest_init_getEnv = function(name) {
+    if ("u" < typeof process) return;
+    return process.env?.[name];
+};
+const manifest_init_trimSlash = function(value) {
+    return value.endsWith('/') ? value.slice(0, -1) : value;
+};
+const manifest_init_resolveAgainstRequest = function(url, source) {
+    if (source.url) {
+        const requestURL = new URL(source.url);
+        return resolveBackendURL(url, {
+            host: requestURL.host,
+            'x-forwarded-proto': requestURL.protocol.replace(':', '')
+        });
+    }
+    const hostHeader = source.headers.get('host');
+    return hostHeader ? resolveBackendURL(url, {
+        host: hostHeader
+    }) : null;
+};
+const manifest_init_resolveManifestSourceFrom = function(source, options) {
+    const { mode } = options;
+    const manifestURL = ('manifest' === mode.type ? mode.manifestURL : void 0) ?? manifest_init_getEnv('C15T_MANIFEST_URL');
+    if (manifestURL) {
+        const resolved = manifest_init_resolveAgainstRequest(manifestURL, source);
+        if (!resolved) throw new Error('@c15t/astro: invalid manifest URL.');
+        return resolved;
+    }
+    const backendURL = ('manifest' === mode.type ? mode.backendURL : void 0) ?? ('hosted' === mode.type ? mode.url : void 0) ?? manifest_init_getEnv('C15T_BACKEND_URL') ?? manifest_init_getEnv('PUBLIC_C15T_BACKEND_URL');
+    if (!backendURL) throw new Error('@c15t/astro: manifest mode requires `backendURL` or `manifestURL` (or the C15T_BACKEND_URL environment variable).');
+    const resolved = manifest_init_resolveAgainstRequest(backendURL, source);
+    if (!resolved) throw new Error('@c15t/astro: invalid backend URL.');
+    return `${manifest_init_trimSlash(resolved)}${MANIFEST_ROUTE_SUFFIX}`;
+};
+const manifest_init_loadConsentManifest = async function(input) {
+    const { mode } = input.options;
+    if ('manifest' === mode.type && mode.manifest) return mode.manifest;
+    const manifestURL = manifest_init_resolveManifestSourceFrom(input.source, input.options);
+    const { manifest } = await fetchCachedManifest({
+        config: {
+            manifestURL
+        },
+        fetch: input.fetch,
+        onBackgroundRevalidate: input.onBackgroundRevalidate,
+        query: input.query
+    });
+    return manifest;
+};
+const manifest_init_shouldFetchGvl = function(manifest, payload) {
+    return manifest.iab?.enabled === true && void 0 !== manifest.iab.gvl && payload.policyResolution?.status === 'matched' && 'iab' === payload.policyResolution.policy.model;
+};
+const GVL_FETCH_TIMEOUT_MS = 5000;
+const manifest_init_defaultFetchGvl = async function(input) {
+    const response = await input.fetch(input.reference.url, {
+        headers: {
+            'accept-language': input.language
+        },
+        method: 'GET',
+        signal: AbortSignal.timeout(GVL_FETCH_TIMEOUT_MS)
+    });
+    if (204 === response.status) return null;
+    if (!response.ok) throw new Error(`@c15t/astro: GVL responded ${response.status} ${response.statusText}`);
+    return await response.json();
+};
+const manifest_init_resolveManifestInit = async function(input) {
+    const { inputs, manifest } = input;
+    const payload = resolveInitFromManifest(manifest, {
+        country: inputs.country,
+        gpc: inputs.gpc,
+        language: inputs.language ?? 'en',
+        region: inputs.region
+    }, {
+        baseTranslations: baseTranslations
+    });
+    const fetchImpl = input.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (manifest_init_shouldFetchGvl(manifest, payload) && manifest.iab?.gvl && fetchImpl) {
+        const language = payload.translations.language.split('-')[0] || 'en';
+        try {
+            payload.gvl = await (input.fetchGvl ?? manifest_init_defaultFetchGvl)({
+                fetch: fetchImpl,
+                language,
+                reference: manifest.iab.gvl
+            });
+        } catch  {
+            payload.gvl = null;
+        }
+    }
+    payload.resolvedOverrides = consentInputsToOverrides({
+        country: inputs.country,
+        language: inputs.language,
+        region: inputs.region
+    });
+    payload.resolvedPrivacySignals = {
+        gpc: inputs.gpc
+    };
+    return !input.gvlRoute || input.fetch || input.fetchGvl ? payload : deferInitGvlToRoute(payload, input.gvlRoute);
+};
+export { manifest_init_defaultFetchGvl as defaultFetchGvl, manifest_init_loadConsentManifest as loadConsentManifest, manifest_init_resolveManifestInit as resolveManifestInit, manifest_init_resolveManifestSourceFrom as resolveManifestSourceFrom };

package/dist/api/manifest.js

@@ -0,0 +1,10 @@
+import options from "virtual:c15t/options";
+import { createConsentRouteHandlers } from "./handlers.js";
+const handlers = createConsentRouteHandlers({
+    options: options
+});
+const GET = ({ locals, request })=>handlers.manifest(request, {
+        locals
+    });
+const prerender = false;
+export { GET, prerender };

package/dist/browser/iab.js

@@ -0,0 +1,5 @@
+import { createLazyIABFactory } from "@c15t/core/runtime";
+const defaultFactory = createLazyIABFactory(()=>import("@c15t/iab"));
+const lazyCreateIAB = defaultFactory.create;
+const whenIABReady = defaultFactory.whenReady;
+export { lazyCreateIAB, whenIABReady };

package/dist/browser/inline-scripts.js

@@ -0,0 +1,47 @@
+import { allConsentNames, has } from "@c15t/core";
+const CATEGORY_ATTRIBUTE = 'data-c15t-category';
+const ACTIVATED_ATTRIBUTE = 'data-c15t-activated';
+const COPIED_ATTRIBUTES = [
+    'src',
+    'async',
+    'defer',
+    'crossorigin',
+    'integrity',
+    'referrerpolicy',
+    'nonce',
+    'id'
+];
+const inline_scripts_activate = function(element) {
+    const replacement = document.createElement("script");
+    for (const name of COPIED_ATTRIBUTES){
+        const value = element.getAttribute(name);
+        if (null !== value) replacement.setAttribute(name, value);
+    }
+    for (const attribute of Array.from(element.attributes))if (attribute.name.startsWith('data-') && attribute.name !== ACTIVATED_ATTRIBUTE) replacement.setAttribute(attribute.name, attribute.value);
+    replacement.setAttribute(ACTIVATED_ATTRIBUTE, 'true');
+    if (!element.hasAttribute('src')) replacement.textContent = element.textContent;
+    element.setAttribute(ACTIVATED_ATTRIBUTE, 'true');
+    element.parentNode?.insertBefore(replacement, element.nextSibling);
+    element.remove();
+};
+const inline_scripts_activateGatedScripts = function(snapshot, root = document) {
+    const selector = `script[${CATEGORY_ATTRIBUTE}]:not([${ACTIVATED_ATTRIBUTE}])`;
+    const elements = Array.from(root.querySelectorAll(selector));
+    let activated = 0;
+    for (const element of elements){
+        const category = element.getAttribute(CATEGORY_ATTRIBUTE);
+        if (!category) continue;
+        if (!allConsentNames.includes(category)) {
+            console.warn(`@c15t/astro: unknown ${CATEGORY_ATTRIBUTE} "${category}". Expected one of ${allConsentNames.join(', ')}.`);
+            element.setAttribute(ACTIVATED_ATTRIBUTE, 'invalid');
+            continue;
+        }
+        const allowed = has(category, snapshot.effectivePermissions);
+        if (allowed) {
+            inline_scripts_activate(element);
+            activated += 1;
+        }
+    }
+    return activated;
+};
+export { ACTIVATED_ATTRIBUTE, CATEGORY_ATTRIBUTE, inline_scripts_activateGatedScripts as activateGatedScripts };

package/dist/client.js

@@ -0,0 +1,276 @@
+import { createConsentRuntime } from "@c15t/core/runtime";
+import { setupColorScheme, setupFocusTrap, setupScrollLock } from "@c15t/ui/utils/dom";
+import { lazyCreateIAB, whenIABReady } from "./browser/iab.js";
+import { activateGatedScripts } from "./browser/inline-scripts.js";
+import { resolveTransportFactory } from "./mode.js";
+import { loadDialogAdapter, registerDialogAdapter, registerDialogSurface } from "./ui/adapter.js";
+const GLOBAL_KEY = '__c15tAstro';
+const NO_PAGE_SWAP_LISTENERS = ()=>{};
+let detachPageSwapListeners = NO_PAGE_SWAP_LISTENERS;
+const COLOR_SCHEME_KEY = '__c15tAstroColorScheme';
+const CONFIG_KEY = '__c15tAstroConfig';
+const DIALOG_HOST_ID = 'c15t-dialog-host';
+const ACTION_ATTRIBUTE = 'data-c15t-action';
+const DIALOG_ATTRIBUTE = 'data-c15t-dialog';
+const DIALOG_TAB_ATTRIBUTE = 'data-c15t-tab';
+const client_getWindow = function() {
+    return "u" < typeof window ? void 0 : window;
+};
+const client_readInlinedConfig = function() {
+    return client_getWindow()?.[CONFIG_KEY] ?? {};
+};
+const client_applyColorScheme = function(colorScheme) {
+    const browserWindow = client_getWindow();
+    if (!browserWindow) return;
+    browserWindow[COLOR_SCHEME_KEY]?.();
+    browserWindow[COLOR_SCHEME_KEY] = void 0;
+    if ('function' != typeof browserWindow.matchMedia) return void document.documentElement.classList.toggle('c15t-dark', 'dark' === colorScheme);
+    browserWindow[COLOR_SCHEME_KEY] = setupColorScheme(colorScheme);
+};
+const client_ensureDialogHost = function() {
+    const existing = document.getElementById(DIALOG_HOST_ID);
+    if (existing) return existing;
+    const host = document.createElement('div');
+    host.id = DIALOG_HOST_ID;
+    document.body.appendChild(host);
+    return host;
+};
+let releaseBlocking = null;
+const client_hasConsentPolicy = function(snapshot) {
+    return 'matched' === snapshot.resolution.status;
+};
+const client_hasConsentUi = function(snapshot) {
+    return client_hasConsentPolicy(snapshot) && ('none' !== snapshot.policyRule.prompt || snapshot.policyRule.rights.length > 0);
+};
+const client_whenPolicySettled = function(kernel) {
+    if (!kernel.getSnapshot().policyPending) return Promise.resolve();
+    return new Promise((resolve)=>{
+        const unsubscribe = kernel.subscribe((snapshot)=>{
+            if (!snapshot.policyPending) {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+};
+const client_syncSurfaceVisibility = function(snapshot) {
+    const owesUi = client_hasConsentUi(snapshot);
+    for (const control of document.querySelectorAll('[data-c15t-surface="trigger"]'))control.hidden = !owesUi;
+};
+const client_syncBannerVisibility = function(snapshot) {
+    const banner = document.querySelector('[data-testid="consent-banner-root"], [data-testid="iab-consent-banner-root"]');
+    if (!banner) return void releaseBlocking?.();
+    const shouldShow = 'banner' === snapshot.activeUI;
+    banner.hidden = !shouldShow;
+    banner.setAttribute('data-c15t-visible', shouldShow ? 'true' : 'false');
+    const blocking = shouldShow && 'true' === banner.dataset.blocking;
+    for (const overlay of document.querySelectorAll('[data-testid="consent-banner-overlay"], [data-testid="iab-consent-banner-overlay"]'))overlay.hidden = !blocking;
+    if (!blocking) return void releaseBlocking?.();
+    if (releaseBlocking) return;
+    const card = banner.querySelector('[data-testid="consent-banner-card"], [data-testid="iab-consent-banner-card"]') ?? banner;
+    const unlockScroll = setupScrollLock();
+    const releaseFocus = setupFocusTrap(card);
+    releaseBlocking = ()=>{
+        releaseFocus();
+        unlockScroll();
+        releaseBlocking = null;
+    };
+};
+const client_resolveAction = function(target) {
+    if (!(target instanceof Element)) return null;
+    const element = target.closest(`[${ACTION_ATTRIBUTE}]`);
+    const action = element?.getAttribute(ACTION_ATTRIBUTE);
+    if ('accept' !== action && 'reject' !== action && 'customize' !== action && 'dismiss' !== action && 'close' !== action) return null;
+    const dialog = element?.getAttribute(DIALOG_ATTRIBUTE);
+    const tab = element?.getAttribute(DIALOG_TAB_ATTRIBUTE);
+    return {
+        action,
+        dialog: 'iab' === dialog ? 'iab' : 'preferences',
+        tab: 'vendors' === tab || 'purposes' === tab ? tab : void 0
+    };
+};
+const client_createClient = function(options, extension = {}) {
+    const config = client_readInlinedConfig();
+    const scripts = [
+        ...options.scripts ?? [],
+        ...extension.scripts ?? []
+    ];
+    const runtime = createConsentRuntime({
+        consentCategories: options.consentCategories,
+        createIAB: lazyCreateIAB,
+        i18n: options.i18n,
+        iab: false === options.iab ? false : options.iab,
+        mode: resolveTransportFactory(options.mode, {
+            backendURL: 'manifest' === options.mode.type ? options.mode.backendURL : void 0,
+            initPath: options.endpoints.initPath
+        }),
+        pkg: '@c15t/astro',
+        policyRules: 'offline' === options.mode.type ? options.mode.policyRules : void 0,
+        prefetch: config,
+        scripts,
+        storageConfig: options.storageConfig
+    });
+    let dialog = null;
+    let dialogKind = null;
+    let dialogTab;
+    let opening = null;
+    let disposed = false;
+    const client = {
+        async acceptAll () {
+            await runtime.kernel.commands.save('all');
+        },
+        closeDialog () {
+            runtime.kernel.set.activeUI('none');
+            dialog?.close();
+        },
+        dispose () {
+            if (disposed) return;
+            disposed = true;
+            detachPageSwapListeners();
+            releaseBlocking?.();
+            dialog?.destroy();
+            dialog = null;
+            dialogKind = null;
+            runtime.dispose();
+            const browserWindow = client_getWindow();
+            if (browserWindow) {
+                browserWindow[COLOR_SCHEME_KEY]?.();
+                browserWindow[COLOR_SCHEME_KEY] = void 0;
+                browserWindow[GLOBAL_KEY] = void 0;
+            }
+        },
+        getConsent () {
+            return runtime.kernel.getSnapshot();
+        },
+        async identify (user) {
+            await runtime.identify(user);
+        },
+        async openDialog (kind = 'preferences', tab) {
+            if (disposed) return;
+            await client_whenPolicySettled(runtime.kernel);
+            if (disposed || !client_hasConsentUi(runtime.kernel.getSnapshot())) return;
+            if (opening) await opening;
+            if (disposed) return;
+            if (dialog && (dialogKind !== kind || void 0 !== tab && tab !== dialogTab)) {
+                await dialog.destroy();
+                dialog = null;
+            }
+            if (!dialog) {
+                opening = (async ()=>{
+                    const adapter = await loadDialogAdapter(options.ui);
+                    if (disposed) return;
+                    if ('iab' === kind) {
+                        await whenIABReady();
+                        if (disposed) return;
+                    }
+                    const handle = await adapter.mount({
+                        kind,
+                        options,
+                        runtime,
+                        tab,
+                        target: client_ensureDialogHost()
+                    });
+                    if (disposed) return void await handle.destroy();
+                    dialog = handle;
+                    dialogKind = kind;
+                    dialogTab = tab;
+                })();
+                try {
+                    await opening;
+                } finally{
+                    opening = null;
+                }
+            }
+            if (disposed) return;
+            runtime.kernel.set.activeUI('dialog');
+        },
+        options,
+        async rejectAll () {
+            await runtime.kernel.commands.save('none');
+        },
+        runtime,
+        async save (consents) {
+            await runtime.kernel.commands.save(consents);
+        },
+        subscribe (listener) {
+            return runtime.kernel.subscribe(listener);
+        }
+    };
+    return client;
+};
+const client_attach = function(client) {
+    const snapshot = client.getConsent();
+    client_syncBannerVisibility(snapshot);
+    client_syncSurfaceVisibility(snapshot);
+    activateGatedScripts(snapshot);
+};
+const client_getConsentClient = function() {
+    return client_getWindow()?.[GLOBAL_KEY] ?? null;
+};
+const client_attachBannerActions = function() {
+    const browserWindow = client_getWindow();
+    if (!browserWindow || browserWindow.__c15tAstroActions) return;
+    browserWindow.__c15tAstroActions = true;
+    document.addEventListener('click', (event)=>{
+        const resolved = client_resolveAction(event.target);
+        if (!resolved) return;
+        const client = client_getConsentClient();
+        if (!client) return;
+        event.preventDefault();
+        if ('dismiss' === resolved.action) return void client.runtime.kernel.commands.dismissNotice();
+        if ('accept' === resolved.action) return void client.acceptAll();
+        if ('reject' === resolved.action) return void client.rejectAll();
+        if ('customize' === resolved.action) return void client.openDialog(resolved.dialog, resolved.tab);
+        client.closeDialog();
+    });
+};
+const client_boot = function(options, extension = {}) {
+    const browserWindow = client_getWindow();
+    if (!browserWindow) throw new Error('@c15t/astro: boot() requires a browser environment.');
+    const existing = browserWindow[GLOBAL_KEY];
+    if (existing) return existing;
+    const client = client_createClient(options, extension);
+    browserWindow[GLOBAL_KEY] = client;
+    client.runtime.start();
+    client_applyColorScheme(options.colorScheme);
+    client_attachBannerActions();
+    client.subscribe((snapshot)=>{
+        client_syncBannerVisibility(snapshot);
+        client_syncSurfaceVisibility(snapshot);
+        activateGatedScripts(snapshot);
+    });
+    const onAfterSwap = function() {
+        client_applyColorScheme(options.colorScheme);
+        client_attach(client);
+    };
+    const onPageLoad = function() {
+        client_attach(client);
+    };
+    document.addEventListener('astro:after-swap', onAfterSwap);
+    document.addEventListener('astro:page-load', onPageLoad);
+    detachPageSwapListeners = ()=>{
+        document.removeEventListener('astro:after-swap', onAfterSwap);
+        document.removeEventListener('astro:page-load', onPageLoad);
+        detachPageSwapListeners = NO_PAGE_SWAP_LISTENERS;
+    };
+    client_attach(client);
+    return client;
+};
+const client_getConsent = function() {
+    return client_getConsentClient()?.getConsent() ?? null;
+};
+const client_subscribe = function(listener) {
+    const client = client_getConsentClient();
+    if (!client) return ()=>{};
+    return client.subscribe(listener);
+};
+const client_openDialog = async function(kind = 'preferences', tab) {
+    await client_getConsentClient()?.openDialog(kind, tab);
+};
+const client_preloadDialog = async function() {
+    const client = client_getConsentClient();
+    if (!client) return;
+    const adapter = await loadDialogAdapter(client.options.ui);
+    await adapter.preload?.();
+};
+export { ACTION_ATTRIBUTE, DIALOG_ATTRIBUTE, DIALOG_TAB_ATTRIBUTE, activateGatedScripts, client_attachBannerActions as attachBannerActions, client_boot as boot, client_getConsent as getConsent, client_getConsentClient as getConsentClient, client_openDialog as openDialog, client_preloadDialog as preloadDialog, client_subscribe as subscribe, client_syncBannerVisibility as syncBannerVisibility, client_syncSurfaceVisibility as syncSurfaceVisibility, registerDialogAdapter, registerDialogSurface };

package/dist/index.js

@@ -0,0 +1,5 @@
+export { c15t, c15t as default, resolveOptions } from "./integration.js";
+export { createConsentMiddleware } from "./middleware-handler.js";
+export { custom, hostedMode as hosted, manifestMode as manifest, offlineMode as offline, resolveTransportFactory } from "./mode.js";
+export { registerDialogAdapter, registerDialogSurface } from "./ui/adapter.js";
+export { policyRulePresets } from "@c15t/core";