@kywi-software/core 0.13.0 → 0.15.0

package/dist/audiences/consent-startup.js

@@ -0,0 +1,105 @@
+/**
+ * Startup checks for the cookie-consent gate (kywi-cms#91).
+ *
+ * Two failure modes are invisible at runtime and expensive to discover later:
+ *
+ *   1. The config flag and its edge mirror disagree. `middleware.ts` runs on the
+ *      edge and cannot read `kywi.config.ts`, so `requireConsent` is mirrored as
+ *      `KYWI_REQUIRE_CONSENT`. If the two drift, the middleware and the API
+ *      disagree about whether a visitor may be tracked — one writes
+ *      `kywi_visitor`, the other refuses to read it — and nothing anywhere says
+ *      so. That is a misconfiguration, and it fails the deploy.
+ *
+ *   2. Consent is required and no page offers a way to give it. Every
+ *      personalization cookie is then permanently suppressed: audiences,
+ *      experiments and UTM attribution quietly do nothing, and the site looks
+ *      broken rather than gated. That is a WARNING, not an error — a site may
+ *      legitimately have no personalization at all — but it must be said out
+ *      loud, once, rather than left for someone to debug.
+ */
+import { sql } from 'drizzle-orm';
+/** The env var mirroring `theme.personalization.requireConsent` for edge middleware. */
+export const REQUIRE_CONSENT_ENV = 'KYWI_REQUIRE_CONSENT';
+/** How `middleware.ts` reads the mirror: anything but the literal "false" is true. */
+export function requireConsentFromEnv(env = process.env) {
+    return env[REQUIRE_CONSENT_ENV] !== 'false';
+}
+/**
+ * Fail startup when the config flag and its edge mirror disagree.
+ *
+ * Deliberately a throw and not a warning: the two halves of one setting pointing
+ * opposite ways is never intentional, and the resulting behaviour (cookies
+ * written by the edge that the API then declines to read, or vice versa) is
+ * exactly the kind of bug that survives to production because nothing is
+ * visibly broken.
+ */
+export function assertConsentEnvAgreement(requireConsentFromConfig, env = process.env) {
+    const fromEnv = requireConsentFromEnv(env);
+    if (fromEnv === requireConsentFromConfig)
+        return;
+    const raw = env[REQUIRE_CONSENT_ENV];
+    throw new Error(`Cookie-consent misconfiguration: theme.personalization.requireConsent is ` +
+        `${requireConsentFromConfig} but ${REQUIRE_CONSENT_ENV} is ` +
+        `${raw === undefined ? 'unset (which means true)' : JSON.stringify(raw)}.\n` +
+        `  Next.js edge middleware cannot read kywi.config.ts, so it mirrors that flag ` +
+        `through ${REQUIRE_CONSENT_ENV}. While they disagree, the middleware and the API ` +
+        `disagree about whether a visitor may be tracked.\n` +
+        `  Set both, or neither: ${REQUIRE_CONSENT_ENV}=false alongside ` +
+        `personalization: { requireConsent: false }, or remove both.`);
+}
+const NO_BANNER_WARNING = '[kywi] Cookie consent is required (theme.personalization.requireConsent) but no ' +
+    'page or layout places the `cookieConsent` module, so no visitor can ever grant it. ' +
+    'Every personalization cookie stays suppressed: audiences, A/B bucketing and UTM ' +
+    'attribution will resolve to default content for everyone. Place the module, or set ' +
+    'personalization: { requireConsent: false } if consent is collected by external tooling.';
+/**
+ * Build the once-only "consent required, but nothing asks for it" check.
+ *
+ * Returns a function safe to call on every request: it runs at most once, never
+ * awaits (the first request does not pay for it), and swallows every error. A
+ * warning that could break a page, or add latency to the hot path, would not be
+ * worth having.
+ *
+ * The check is a `::text LIKE` prefilter — the same shape
+ * `checkAudienceDeletionSafety` uses — looking for anything that mentions the
+ * module type at all. Over-matching is fine here: a false negative (staying
+ * quiet) is the safe direction for an advisory warning.
+ *
+ * It reads BOTH places a module can be placed: `kywi_content.layout` and
+ * `kywi_section_templates.definition`. A banner composed from a blueprint is a
+ * banner, and scanning pages alone told a site that builds every page that way
+ * that consent could never be granted — while the banner was on screen.
+ */
+export function createConsentBannerCheck(deps) {
+    const warn = deps.warn ?? ((m) => console.warn(m));
+    let started = false;
+    return () => {
+        if (started || !deps.requireConsent)
+            return;
+        started = true;
+        void (async () => {
+            try {
+                const rows = await deps.db.execute(sql `
+            SELECT 1 AS found
+            FROM kywi_content
+            WHERE layout IS NOT NULL
+              AND layout::text LIKE ${'%"cookieConsent"%'}
+            UNION ALL
+            SELECT 1 AS found
+            FROM kywi_section_templates
+            WHERE definition IS NOT NULL
+              AND definition::text LIKE ${'%"cookieConsent"%'}
+            LIMIT 1
+          `);
+                if (rows.length === 0)
+                    warn(NO_BANNER_WARNING);
+            }
+            catch {
+                // No content table yet (a fresh install mid-migration), a dialect that
+                // cannot cast, a transient connection failure — none of that is worth
+                // failing or logging a request over. Silence is the safe direction.
+            }
+        })();
+    };
+}
+//# sourceMappingURL=consent-startup.js.map

package/dist/audiences/consent-startup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-startup.js","sourceRoot":"","sources":["../../src/audiences/consent-startup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAGjC,wFAAwF;AACxF,MAAM,CAAC,MAAM,mBAAmB,GAAG,sBAAsB,CAAA;AAEzD,sFAAsF;AACtF,MAAM,UAAU,qBAAqB,CAAC,MAA0C,OAAO,CAAC,GAAG;IACzF,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,OAAO,CAAA;AAC7C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,yBAAyB,CACvC,wBAAiC,EACjC,MAA0C,OAAO,CAAC,GAAG;IAErD,MAAM,OAAO,GAAG,qBAAqB,CAAC,GAAG,CAAC,CAAA;IAC1C,IAAI,OAAO,KAAK,wBAAwB;QAAE,OAAM;IAChD,MAAM,GAAG,GAAG,GAAG,CAAC,mBAAmB,CAAC,CAAA;IACpC,MAAM,IAAI,KAAK,CACb,2EAA2E;QACzE,GAAG,wBAAwB,QAAQ,mBAAmB,MAAM;QAC5D,GAAG,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK;QAC5E,gFAAgF;QAChF,WAAW,mBAAmB,oDAAoD;QAClF,oDAAoD;QACpD,2BAA2B,mBAAmB,mBAAmB;QACjE,6DAA6D,CAChE,CAAA;AACH,CAAC;AAED,MAAM,iBAAiB,GACrB,kFAAkF;IAClF,qFAAqF;IACrF,kFAAkF;IAClF,qFAAqF;IACrF,yFAAyF,CAAA;AAE3F;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAIxC;IACC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;IAC1D,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,OAAO,GAAG,EAAE;QACV,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,cAAc;YAAE,OAAM;QAC3C,OAAO,GAAG,IAAI,CAAA;QACd,KAAK,CAAC,KAAK,IAAI,EAAE;YACf,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,OAAO,CAChC,GAAG,CAAA;;;;sCAIyB,mBAAmB;;;;;0CAKf,mBAAmB;;WAElD,CACF,CAAA;gBACD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;oBAAE,IAAI,CAAC,iBAAiB,CAAC,CAAA;YAChD,CAAC;YAAC,MAAM,CAAC;gBACP,uEAAuE;gBACvE,sEAAsE;gBACtE,oEAAoE;YACtE,CAAC;QACH,CAAC,CAAC,EAAE,CAAA;IACN,CAAC,CAAA;AACH,CAAC"}

package/dist/audiences/consent.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Cookie consent — the category map, and the gate every optional cookie write
+ * passes through (kywi-cms#91).
+ *
+ * Before this module the `cookieConsent` layout module and the `kywi_consent`
+ * cookie were two halves of a feature that never met: the banner's buttons had
+ * no handlers, and no cookie-writing code path ever asked whether the visitor
+ * had consented. This file is the join. It owns three things:
+ *
+ *   1. `COOKIE_CONSENT_CATEGORY` — the SINGLE SOURCE OF TRUTH mapping every
+ *      cookie the engine writes to the consent category it needs. Nothing else
+ *      in the codebase may decide a cookie's category.
+ *   2. `cookieAllowed()` / `consentAllows()` — the gate. Every optional cookie
+ *      write calls one of these first.
+ *   3. The browser-side read/write of the `kywi_consent` cookie itself, used by
+ *      the `cookieConsent` layout module's buttons.
+ *
+ * ── Category decisions (owner-set) ──────────────────────────────────────────
+ *
+ *   necessary / `essential` — always allowed, never gated:
+ *     `kywi_consent`      the consent record itself
+ *     `kywi_optout`       the personalization opt-out flag: a *suppression*
+ *                         preference. Blocking a visitor from recording "stop
+ *                         personalizing me" until they consent to cookies would
+ *                         be perverse, so this is necessary by construction.
+ *     `kywi_preview_init` admin preview hand-off, not visitor tracking.
+ *
+ *   `personalization` — gated:
+ *     `kywi_visitor`   visitor id, incl. experiment bucketing / exposure
+ *     `kywi_signals`   the signed server-resolved audience signals
+ *     `kywi_utm`       campaign attribution carried across navigation
+ *     `kywi_audience`  the audience the RUNTIME resolved and remembered. A pin
+ *                      the visitor chose by hand in the transparency panel is
+ *                      `essential` instead — see the `source` discussion in
+ *                      `api/audience-runtime-routes.ts`
+ *     `kywi_known`     adapter-pushed known-identity flag
+ *
+ *   Auth/session cookies (the admin's access + refresh cookies, CSRF) are
+ *   `essential` by definition and deliberately never routed through this gate —
+ *   they carry no tracking and the admin cannot function without them.
+ *
+ * ── Undecided means not consented ───────────────────────────────────────────
+ *
+ * A visitor who has not answered the banner has a null `ConsentState`, and
+ * `consentAllows(null, 'personalization')` is FALSE. This matches `hasConsent()`
+ * in `@kywi-software/js` and is the compliance-correct default. The consequence
+ * is deliberate: until a visitor accepts, personalization cookies are not
+ * written and pages degrade to their default (unpersonalized) content. Nothing
+ * fails — the request still resolves, the visitor id is still minted for the
+ * duration of that request, it just is not persisted.
+ *
+ * An unmapped cookie name is denied rather than allowed, so adding a new cookie
+ * without classifying it here fails closed. A core test asserts every name in
+ * `COOKIE_NAMES` appears in the map, so that failure surfaces at test time.
+ *
+ * ── The escape hatch: personalization.requireConsent ────────────────────────
+ *
+ * `theme.personalization.requireConsent` (kywi.config.ts) DEFAULTS TO TRUE — the
+ * compliant behaviour above. Setting it to `false` turns this gate off entirely:
+ * every category reads as allowed, decided or not, and the cookie writes behave
+ * as they did before kywi-cms#91. That is for a site whose consent is collected
+ * by external tooling (a third-party CMP) which suppresses cookies its own way;
+ * the site takes responsibility for compliance, and Kywi stops second-guessing
+ * it. It is NOT a way to opt out of consent — turning it off on a site with no
+ * other consent mechanism is the non-compliant configuration this issue existed
+ * to fix.
+ *
+ * Every gate function takes the flag through a `ConsentGateOptions` bag rather
+ * than reading config itself, because this module must stay dependency-free
+ * (see below). `personalizationRequiresConsent()` in `./consent-config.ts`
+ * resolves it from a `KywiConfig`; the edge middleware, which cannot import an
+ * app's config at all, mirrors it with `KYWI_REQUIRE_CONSENT=false`.
+ *
+ * EDGE-SAFE LEAF MODULE: this file imports nothing, so it can be pulled into
+ * Next.js edge middleware (where core's DB-backed code cannot run) and into
+ * `audiences/utm-persistence.ts`, which has the same constraint. It is
+ * published as its own export entry (`@kywi-software/core/audiences/consent`).
+ * Keep it dependency-free. The browser-only helpers guard on `document`, so
+ * importing this on the server or the edge is safe.
+ */
+/** The cookie the visitor's consent decision is stored in. */
+export declare const CONSENT_COOKIE = "kywi_consent";
+/** 1 year, in seconds — how long a consent decision is remembered. */
+export declare const CONSENT_MAX_AGE: number;
+/** The cookie an audience pin lives in. */
+export declare const AUDIENCE_PIN_COOKIE = "kywi_audience";
+/**
+ * The `kywi_audience` value prefix marking a pin the visitor chose BY HAND in
+ * the transparency panel, as opposed to one the runtime remembered on its own.
+ *
+ * Owned here, in the zero-import leaf, because both halves of the feature need
+ * it and neither can import the other: `collectors/pinned-audience.ts` encodes
+ * and decodes with it, and `clearDeniedCookies` below must recognise it to avoid
+ * sweeping away a preference it is supposed to honour.
+ */
+export declare const SWITCHER_PIN_PREFIX = "switcher:";
+export type ConsentCategory = 'essential' | 'analytics' | 'marketing' | 'personalization';
+/** Shared tail argument of every gate function. */
+export interface ConsentGateOptions {
+    /**
+     * `theme.personalization.requireConsent`. Defaults to true. When explicitly
+     * `false` the gate is off and every category reads as allowed — the
+     * external-CMP escape hatch described in the file header.
+     */
+    requireConsent?: boolean;
+}
+export interface ConsentState {
+    essential: boolean;
+    analytics: boolean;
+    marketing: boolean;
+    personalization: boolean;
+}
+/**
+ * Every cookie the engine writes → the consent category it requires.
+ * The single source of truth; see the file header for the reasoning behind
+ * each classification.
+ */
+export declare const COOKIE_CONSENT_CATEGORY: {
+    readonly kywi_consent: "essential";
+    readonly kywi_optout: "essential";
+    readonly kywi_preview_init: "essential";
+    readonly kywi_signals: "personalization";
+    readonly kywi_visitor: "personalization";
+    readonly kywi_utm: "personalization";
+    readonly kywi_audience: "personalization";
+    readonly kywi_known: "personalization";
+};
+/**
+ * The consent category `cookieName` requires, or `null` when the name is not
+ * classified. An unclassified cookie is denied by `cookieAllowed`.
+ */
+export declare function consentCategoryFor(cookieName: string): ConsentCategory | null;
+/** Parse a raw `kywi_consent` cookie value. Returns null when absent/malformed. */
+export declare function parseConsentValue(raw: string | null | undefined): ConsentState | null;
+/**
+ * Read the consent decision out of a request's `Cookie` header.
+ * Returns null when the header is absent or carries no usable decision.
+ *
+ * A header can legitimately carry the same cookie name twice — most often a
+ * `Path=/` cookie shadowed by a narrower one from an earlier deploy. Taking the
+ * first match and giving up if it will not parse would throw away a perfectly
+ * good decision sitting right behind a corrupt one, so keep looking.
+ */
+export declare function readConsentFromCookieHeader(header: string | null | undefined): ConsentState | null;
+/**
+ * Is `category` granted by `state`? `essential` is always granted — necessary
+ * cookies need no consent. Every other category requires an explicit `true`,
+ * so an undecided visitor (null state) grants nothing.
+ */
+export declare function consentAllows(state: ConsentState | null, category: ConsentCategory, options?: ConsentGateOptions): boolean;
+/**
+ * The gate: may `cookieName` be written given `state`? Unclassified cookie
+ * names fail closed — unless the gate itself is off.
+ */
+export declare function cookieAllowed(cookieName: string, state: ConsentState | null, options?: ConsentGateOptions): boolean;
+/** Convenience for request handlers: gate `cookieName` against a `Cookie` header. */
+export declare function cookieAllowedByHeader(cookieName: string, header: string | null | undefined, options?: ConsentGateOptions): boolean;
+/** Every cookie name classified into `category`. */
+export declare function cookiesInCategory(category: ConsentCategory): string[];
+/**
+ * Delete every cookie whose category `state` does not grant, and return the
+ * names deleted.
+ *
+ * Refusing to WRITE new cookies is only half of "Reject All" — a visitor who
+ * accepted last month and rejects today is still carrying a `kywi_visitor` id,
+ * and a gate that only blocks writes would keep reading it forever. So a
+ * decision revokes as well as denies (kywi-cms#91).
+ *
+ * `kywi_signals` is HttpOnly and cannot be removed from script; the attempt is
+ * harmless and the server stops writing it, after which it expires on its own
+ * 60-second horizon. The server-side read paths ALSO ignore personalization
+ * cookies whenever the gate denies, so a cookie script cannot clear is inert
+ * either way.
+ *
+ * No-op off the browser.
+ */
+export declare function clearDeniedCookies(state: ConsentState | null): string[];
+/** Read the visitor's consent decision from `document.cookie`, or null. */
+export declare function getConsentState(): ConsentState | null;
+/**
+ * Record a consent decision. `essential` is always forced true — the visitor
+ * cannot decline necessary cookies, and the banner renders that checkbox
+ * checked and disabled to say so. Returns the state written.
+ *
+ * Any category the decision denies is REVOKED at the same time: see
+ * `clearDeniedCookies`. Rejecting is not just "stop writing", it is "and delete
+ * what you already wrote".
+ */
+export declare function setConsent(prefs: Partial<Omit<ConsentState, 'essential'>>): ConsentState;
+/** Has the visitor granted `category`? See `consentAllows` for the semantics. */
+export declare function hasConsent(category: ConsentCategory, options?: ConsentGateOptions): boolean;
+//# sourceMappingURL=consent.d.ts.map

package/dist/audiences/consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent.d.ts","sourceRoot":"","sources":["../../src/audiences/consent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AAEH,8DAA8D;AAC9D,eAAO,MAAM,cAAc,iBAAiB,CAAA;AAE5C,sEAAsE;AACtE,eAAO,MAAM,eAAe,QAAkB,CAAA;AAE9C,2CAA2C;AAC3C,eAAO,MAAM,mBAAmB,kBAAkB,CAAA;AAElD;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,cAAc,CAAA;AAE9C,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,iBAAiB,CAAA;AAEzF,mDAAmD;AACnD,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,eAAe,EAAE,OAAO,CAAA;CACzB;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;CASgB,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAE7E;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,GAAG,IAAI,CAsBrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,GAAG,IAAI,CAWlG;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,YAAY,GAAG,IAAI,EAC1B,QAAQ,EAAE,eAAe,EACzB,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAKT;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,YAAY,GAAG,IAAI,EAC1B,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAOT;AAED,qFAAqF;AACrF,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,OAAO,GAAE,kBAAuB,GAC/B,OAAO,CAET;AAED,oDAAoD;AACpD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,EAAE,CAIrE;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,GAAG,MAAM,EAAE,CAUvE;AAsCD,2EAA2E;AAC3E,wBAAgB,eAAe,IAAI,YAAY,GAAG,IAAI,CAGrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC,GAAG,YAAY,CAiBxF;AAED,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAE/F"}

package/dist/audiences/consent.js

@@ -0,0 +1,322 @@
+/**
+ * Cookie consent — the category map, and the gate every optional cookie write
+ * passes through (kywi-cms#91).
+ *
+ * Before this module the `cookieConsent` layout module and the `kywi_consent`
+ * cookie were two halves of a feature that never met: the banner's buttons had
+ * no handlers, and no cookie-writing code path ever asked whether the visitor
+ * had consented. This file is the join. It owns three things:
+ *
+ *   1. `COOKIE_CONSENT_CATEGORY` — the SINGLE SOURCE OF TRUTH mapping every
+ *      cookie the engine writes to the consent category it needs. Nothing else
+ *      in the codebase may decide a cookie's category.
+ *   2. `cookieAllowed()` / `consentAllows()` — the gate. Every optional cookie
+ *      write calls one of these first.
+ *   3. The browser-side read/write of the `kywi_consent` cookie itself, used by
+ *      the `cookieConsent` layout module's buttons.
+ *
+ * ── Category decisions (owner-set) ──────────────────────────────────────────
+ *
+ *   necessary / `essential` — always allowed, never gated:
+ *     `kywi_consent`      the consent record itself
+ *     `kywi_optout`       the personalization opt-out flag: a *suppression*
+ *                         preference. Blocking a visitor from recording "stop
+ *                         personalizing me" until they consent to cookies would
+ *                         be perverse, so this is necessary by construction.
+ *     `kywi_preview_init` admin preview hand-off, not visitor tracking.
+ *
+ *   `personalization` — gated:
+ *     `kywi_visitor`   visitor id, incl. experiment bucketing / exposure
+ *     `kywi_signals`   the signed server-resolved audience signals
+ *     `kywi_utm`       campaign attribution carried across navigation
+ *     `kywi_audience`  the audience the RUNTIME resolved and remembered. A pin
+ *                      the visitor chose by hand in the transparency panel is
+ *                      `essential` instead — see the `source` discussion in
+ *                      `api/audience-runtime-routes.ts`
+ *     `kywi_known`     adapter-pushed known-identity flag
+ *
+ *   Auth/session cookies (the admin's access + refresh cookies, CSRF) are
+ *   `essential` by definition and deliberately never routed through this gate —
+ *   they carry no tracking and the admin cannot function without them.
+ *
+ * ── Undecided means not consented ───────────────────────────────────────────
+ *
+ * A visitor who has not answered the banner has a null `ConsentState`, and
+ * `consentAllows(null, 'personalization')` is FALSE. This matches `hasConsent()`
+ * in `@kywi-software/js` and is the compliance-correct default. The consequence
+ * is deliberate: until a visitor accepts, personalization cookies are not
+ * written and pages degrade to their default (unpersonalized) content. Nothing
+ * fails — the request still resolves, the visitor id is still minted for the
+ * duration of that request, it just is not persisted.
+ *
+ * An unmapped cookie name is denied rather than allowed, so adding a new cookie
+ * without classifying it here fails closed. A core test asserts every name in
+ * `COOKIE_NAMES` appears in the map, so that failure surfaces at test time.
+ *
+ * ── The escape hatch: personalization.requireConsent ────────────────────────
+ *
+ * `theme.personalization.requireConsent` (kywi.config.ts) DEFAULTS TO TRUE — the
+ * compliant behaviour above. Setting it to `false` turns this gate off entirely:
+ * every category reads as allowed, decided or not, and the cookie writes behave
+ * as they did before kywi-cms#91. That is for a site whose consent is collected
+ * by external tooling (a third-party CMP) which suppresses cookies its own way;
+ * the site takes responsibility for compliance, and Kywi stops second-guessing
+ * it. It is NOT a way to opt out of consent — turning it off on a site with no
+ * other consent mechanism is the non-compliant configuration this issue existed
+ * to fix.
+ *
+ * Every gate function takes the flag through a `ConsentGateOptions` bag rather
+ * than reading config itself, because this module must stay dependency-free
+ * (see below). `personalizationRequiresConsent()` in `./consent-config.ts`
+ * resolves it from a `KywiConfig`; the edge middleware, which cannot import an
+ * app's config at all, mirrors it with `KYWI_REQUIRE_CONSENT=false`.
+ *
+ * EDGE-SAFE LEAF MODULE: this file imports nothing, so it can be pulled into
+ * Next.js edge middleware (where core's DB-backed code cannot run) and into
+ * `audiences/utm-persistence.ts`, which has the same constraint. It is
+ * published as its own export entry (`@kywi-software/core/audiences/consent`).
+ * Keep it dependency-free. The browser-only helpers guard on `document`, so
+ * importing this on the server or the edge is safe.
+ */
+/** The cookie the visitor's consent decision is stored in. */
+export const CONSENT_COOKIE = 'kywi_consent';
+/** 1 year, in seconds — how long a consent decision is remembered. */
+export const CONSENT_MAX_AGE = 365 * 24 * 3600;
+/** The cookie an audience pin lives in. */
+export const AUDIENCE_PIN_COOKIE = 'kywi_audience';
+/**
+ * The `kywi_audience` value prefix marking a pin the visitor chose BY HAND in
+ * the transparency panel, as opposed to one the runtime remembered on its own.
+ *
+ * Owned here, in the zero-import leaf, because both halves of the feature need
+ * it and neither can import the other: `collectors/pinned-audience.ts` encodes
+ * and decodes with it, and `clearDeniedCookies` below must recognise it to avoid
+ * sweeping away a preference it is supposed to honour.
+ */
+export const SWITCHER_PIN_PREFIX = 'switcher:';
+/**
+ * Every cookie the engine writes → the consent category it requires.
+ * The single source of truth; see the file header for the reasoning behind
+ * each classification.
+ */
+export const COOKIE_CONSENT_CATEGORY = {
+    kywi_consent: 'essential',
+    kywi_optout: 'essential',
+    kywi_preview_init: 'essential',
+    kywi_signals: 'personalization',
+    kywi_visitor: 'personalization',
+    kywi_utm: 'personalization',
+    kywi_audience: 'personalization',
+    kywi_known: 'personalization',
+};
+/**
+ * The consent category `cookieName` requires, or `null` when the name is not
+ * classified. An unclassified cookie is denied by `cookieAllowed`.
+ */
+export function consentCategoryFor(cookieName) {
+    return COOKIE_CONSENT_CATEGORY[cookieName] ?? null;
+}
+/** Parse a raw `kywi_consent` cookie value. Returns null when absent/malformed. */
+export function parseConsentValue(raw) {
+    if (!raw)
+        return null;
+    let text = raw;
+    try {
+        text = decodeURIComponent(raw);
+    }
+    catch {
+        /* malformed escape — fall through with the raw value */
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const obj = parsed;
+    return {
+        essential: true,
+        analytics: obj.analytics === true,
+        marketing: obj.marketing === true,
+        personalization: obj.personalization === true,
+    };
+}
+/**
+ * Read the consent decision out of a request's `Cookie` header.
+ * Returns null when the header is absent or carries no usable decision.
+ *
+ * A header can legitimately carry the same cookie name twice — most often a
+ * `Path=/` cookie shadowed by a narrower one from an earlier deploy. Taking the
+ * first match and giving up if it will not parse would throw away a perfectly
+ * good decision sitting right behind a corrupt one, so keep looking.
+ */
+export function readConsentFromCookieHeader(header) {
+    if (!header)
+        return null;
+    for (const pair of header.split(';')) {
+        const trimmed = pair.trim();
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx < 0)
+            continue;
+        if (trimmed.slice(0, eqIdx) !== CONSENT_COOKIE)
+            continue;
+        const state = parseConsentValue(trimmed.slice(eqIdx + 1));
+        if (state)
+            return state;
+    }
+    return null;
+}
+/**
+ * Is `category` granted by `state`? `essential` is always granted — necessary
+ * cookies need no consent. Every other category requires an explicit `true`,
+ * so an undecided visitor (null state) grants nothing.
+ */
+export function consentAllows(state, category, options = {}) {
+    if (options.requireConsent === false)
+        return true;
+    if (category === 'essential')
+        return true;
+    if (!state)
+        return false;
+    return state[category] === true;
+}
+/**
+ * The gate: may `cookieName` be written given `state`? Unclassified cookie
+ * names fail closed — unless the gate itself is off.
+ */
+export function cookieAllowed(cookieName, state, options = {}) {
+    // With the gate off there is nothing to classify against — the site's own
+    // tooling decides, including for a cookie this map has never heard of.
+    if (options.requireConsent === false)
+        return true;
+    const category = consentCategoryFor(cookieName);
+    if (category === null)
+        return false;
+    return consentAllows(state, category);
+}
+/** Convenience for request handlers: gate `cookieName` against a `Cookie` header. */
+export function cookieAllowedByHeader(cookieName, header, options = {}) {
+    return cookieAllowed(cookieName, readConsentFromCookieHeader(header), options);
+}
+/** Every cookie name classified into `category`. */
+export function cookiesInCategory(category) {
+    return Object.entries(COOKIE_CONSENT_CATEGORY)
+        .filter(([, c]) => c === category)
+        .map(([name]) => name);
+}
+/* ── browser side: the cookieConsent module's read/write ─────────────────── */
+/**
+ * Delete every cookie whose category `state` does not grant, and return the
+ * names deleted.
+ *
+ * Refusing to WRITE new cookies is only half of "Reject All" — a visitor who
+ * accepted last month and rejects today is still carrying a `kywi_visitor` id,
+ * and a gate that only blocks writes would keep reading it forever. So a
+ * decision revokes as well as denies (kywi-cms#91).
+ *
+ * `kywi_signals` is HttpOnly and cannot be removed from script; the attempt is
+ * harmless and the server stops writing it, after which it expires on its own
+ * 60-second horizon. The server-side read paths ALSO ignore personalization
+ * cookies whenever the gate denies, so a cookie script cannot clear is inert
+ * either way.
+ *
+ * No-op off the browser.
+ */
+export function clearDeniedCookies(state) {
+    if (typeof document === 'undefined')
+        return [];
+    const deleted = [];
+    for (const [name, category] of Object.entries(COOKIE_CONSENT_CATEGORY)) {
+        if (consentAllows(state, category))
+            continue;
+        if (isDeliberatePreference(name, rawCookie(name)))
+            continue;
+        document.cookie = `${name}=; Path=/; Max-Age=0`;
+        deleted.push(name);
+    }
+    return deleted;
+}
+/** The raw (decoded) value of one cookie, or undefined. Browser-only. */
+function rawCookie(name) {
+    if (typeof document === 'undefined')
+        return undefined;
+    for (const pair of document.cookie.split(';')) {
+        const trimmed = pair.trim();
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx < 0 || trimmed.slice(0, eqIdx) !== name)
+            continue;
+        const raw = trimmed.slice(eqIdx + 1);
+        if (raw === '')
+            return undefined;
+        try {
+            return decodeURIComponent(raw);
+        }
+        catch {
+            return raw;
+        }
+    }
+    return undefined;
+}
+/**
+ * Does this cookie's CURRENT VALUE mark it as an explicit visitor preference
+ * that outranks its category?
+ *
+ * `kywi_audience` is the one cookie whose category depends on how it was
+ * written: automatic ("remember what I resolved") is `personalization`, but an
+ * audience the visitor picked by hand in the transparency panel is `essential`,
+ * on the same argument as `kywi_optout`. The category map is static and cannot
+ * express that, so the sweep asks the value.
+ *
+ * Without this, rejecting personalization would delete a choice the visitor made
+ * deliberately and which the server is under orders to keep honouring — the
+ * revocation would quietly undo the exemption.
+ */
+function isDeliberatePreference(name, value) {
+    if (name !== AUDIENCE_PIN_COOKIE || value === undefined)
+        return false;
+    // The prefix alone is not a pin — `switcher:` with no id decodes to nothing
+    // (parseAudiencePin rejects it), so exempting it would strand a cookie nobody
+    // will ever honour.
+    return value.startsWith(SWITCHER_PIN_PREFIX) && value.length > SWITCHER_PIN_PREFIX.length;
+}
+/** Read the visitor's consent decision from `document.cookie`, or null. */
+export function getConsentState() {
+    if (typeof document === 'undefined')
+        return null;
+    return readConsentFromCookieHeader(document.cookie);
+}
+/**
+ * Record a consent decision. `essential` is always forced true — the visitor
+ * cannot decline necessary cookies, and the banner renders that checkbox
+ * checked and disabled to say so. Returns the state written.
+ *
+ * Any category the decision denies is REVOKED at the same time: see
+ * `clearDeniedCookies`. Rejecting is not just "stop writing", it is "and delete
+ * what you already wrote".
+ */
+export function setConsent(prefs) {
+    const state = {
+        essential: true,
+        analytics: prefs.analytics === true,
+        marketing: prefs.marketing === true,
+        personalization: prefs.personalization === true,
+    };
+    if (typeof document !== 'undefined') {
+        document.cookie =
+            `${CONSENT_COOKIE}=${encodeURIComponent(JSON.stringify(state))}` +
+                `; Path=/; Max-Age=${CONSENT_MAX_AGE}; SameSite=Lax`;
+        // A decision REVOKES as well as denies: cookies from an earlier, more
+        // permissive answer are removed here rather than lingering until they
+        // expire. Written first so the consent record survives its own sweep.
+        clearDeniedCookies(state);
+    }
+    return state;
+}
+/** Has the visitor granted `category`? See `consentAllows` for the semantics. */
+export function hasConsent(category, options = {}) {
+    return consentAllows(getConsentState(), category, options);
+}
+//# sourceMappingURL=consent.js.map

package/dist/audiences/consent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent.js","sourceRoot":"","sources":["../../src/audiences/consent.ts"],"names":[],"mappings":"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"}

package/dist/audiences/engine.d.ts

@@ -1,6 +1,13 @@
 import type { VisitorContext, AudienceResult, Audience } from './types.js';
 export interface AudienceEngineConfig {
     audiences: Audience[];
+    /**
+     * `theme.personalization.requireConsent` (kywi-cms#91). Defaults to true —
+     * personalization cookies are neither written nor READ for a visitor who has
+     * not consented, so a stale id from an earlier "accept" cannot keep resolving
+     * them after they reject.
+     */
+    requireConsent?: boolean;
 }
 export interface AudienceEngine {
     evaluate(context: VisitorContext): Promise<AudienceResult>;

package/dist/audiences/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/audiences/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,cAAc,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAM1F,MAAM,WAAW,oBAAoB;IAAG,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE;AAC/D,MAAM,WAAW,cAAc;IAAG,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;CAAE;AAe9F,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CA4BjF"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/audiences/engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,cAAc,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAM1F,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,QAAQ,EAAE,CAAA;IACrB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AACD,MAAM,WAAW,cAAc;IAAG,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;CAAE;AAe9F,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAiCjF"}