@jini-ai/cms 0.5.5 → 0.5.6

package/dist/consent/express/index.d.ts

@@ -0,0 +1,53 @@
+import { type Express, type Request, type Response } from 'express';
+import { type ConsentConfig, type ConsentRecordPort } from '../types.js';
+import type { ConsentGateOptions } from '../html/gate.js';
+/** All host effects are explicit. Region defaults to unknown; no geo service is required. */
+export interface ConsentHttpPorts {
+    config: {
+        get(required: Record<string, never>, optional?: Record<string, never>): Promise<ConsentConfig>;
+    };
+    records: ConsentRecordPort;
+    clock: {
+        nowMs(): number;
+        nowIso(): string;
+    };
+    ids: {
+        newId(): string;
+    };
+    readReceiptId(required: {
+        cookieHeader: string;
+    }, optional?: Record<string, never>): string | null;
+    origin(required: {
+        request: Request;
+    }, optional?: Record<string, never>): string;
+    region(required: {
+        request: Request;
+    }, optional?: Record<string, never>): string | null;
+    allowWrite(required: {
+        request: Request;
+    }, optional?: Record<string, never>): Promise<boolean>;
+    reportError(required: {
+        operation: 'read' | 'save';
+        error: unknown;
+    }, optional?: Record<string, never>): void;
+}
+/** Mount before public renderers, outside admin/API HTML. Durable proof precedes cookie issuance.
+ * This is a basic Consent Mode implementation: no Google script or denied cookieless ping loads.
+ * Errors are reported through the injected port, and never silently grant optional categories.
+ * @complexity Per page O(HTML bytes), one config/receipt read; per choice O(1), one durable write.
+ */
+export declare function registerConsentHttp({ app, ports }: {
+    app: Express;
+    ports: ConsentHttpPorts;
+}, { endpoint, cookieName, nonce, necessaryScripts, resourceOrigins, delivery }?: {
+    endpoint?: string;
+    cookieName?: string;
+    nonce?: string | ((required: {
+        request: Request;
+        response: Response;
+    }) => string | undefined);
+    necessaryScripts?: ConsentGateOptions['necessaryScripts'];
+    resourceOrigins?: ConsentGateOptions['resourceOrigins'];
+    delivery?: 'live' | 'static';
+}): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/consent/express/index.js

@@ -0,0 +1,159 @@
+import { randomUUID } from 'node:crypto';
+import express, {} from 'express';
+import { createConsentRecord, googleConsentSignals, readConsentRecord, resolveConsentRegion } from '../policy.js';
+import { CONSENT_MAX_AGE_MS } from '../types.js';
+import { gateConsentHtml } from '../html/index.js';
+import { blockConsentResponse, captureConsentHtml } from './response.js';
+function isPublicPage(request) {
+    return ['GET', 'HEAD'].includes(request.method) && !/^\/(?:admin|api|theme-assets|assets|\.well-known)(?:\/|$)/.test(request.path);
+}
+/** Missing/malformed IDs never reach storage. Changed policy versions require another choice.
+ * @complexity O(1) and at most one bounded record read. */
+async function currentRecord({ request, ports, config }) {
+    try {
+        const id = ports.readReceiptId({ cookieHeader: request.get('cookie') ?? '' });
+        if (!id || !/^[a-zA-Z0-9_-]{16,128}$/.test(id))
+            return { record: null, failed: false };
+        const value = await ports.records.read({ id });
+        const record = readConsentRecord({ value, policyVersion: config.policyVersion, nowMs: ports.clock.nowMs() });
+        if (value !== null && record === null) {
+            ports.reportError({ operation: 'read', error: new Error('Invalid consent receipt.') });
+            return { record: null, failed: true };
+        }
+        return { record, failed: false };
+    }
+    catch (error) {
+        // Corrupt, oversized or unreadable proof is absence, never a visitor-wide outage.
+        ports.reportError({ operation: 'read', error });
+        return { record: null, failed: true };
+    }
+}
+/** Browsers supply Origin on normal POST; Referer supports progressively enhanced no-JS forms.
+ * Refuse a request with neither, and ignore caller-selected redirect destinations.
+ * @complexity O(header length), bounded by the HTTP server. */
+function sameOrigin(request, origin) {
+    const source = request.get('origin') ?? request.get('referer');
+    if (!source)
+        return false;
+    try {
+        return new URL(source).origin === new URL(origin).origin;
+    }
+    catch {
+        return false;
+    }
+}
+function respondError(response, status, error) {
+    response.status(status).json({ error });
+}
+/** Mount before public renderers, outside admin/API HTML. Durable proof precedes cookie issuance.
+ * This is a basic Consent Mode implementation: no Google script or denied cookieless ping loads.
+ * Errors are reported through the injected port, and never silently grant optional categories.
+ * @complexity Per page O(HTML bytes), one config/receipt read; per choice O(1), one durable write.
+ */
+export function registerConsentHttp({ app, ports }, { endpoint = '/api/site-consent', cookieName = 'jini_consent', nonce, necessaryScripts, resourceOrigins, delivery = 'live' } = {}) {
+    let lastGood;
+    app.get(`${endpoint}/status`, async (_request, response) => {
+        response.set('Cache-Control', 'no-store').json({ ready: true });
+    });
+    app.post(endpoint, express.urlencoded({ extended: false, limit: '2kb', parameterLimit: 12 }), async (request, response) => {
+        response.set('Cache-Control', 'no-store');
+        try {
+            const origin = ports.origin({ request });
+            if (!sameOrigin(request, origin)) {
+                respondError(response, 403, 'Cookie preferences must be saved from this site.');
+                return;
+            }
+            if (!await ports.allowWrite({ request })) {
+                respondError(response, 429, 'Too many cookie preference changes. Please try again later.');
+                return;
+            }
+            const config = await ports.config.get({});
+            if (!config.enabled) {
+                respondError(response, 409, 'Cookie consent is disabled on this site.');
+                return;
+            }
+            const gpc = request.get('sec-gpc') === '1' || request.body?.gpc === '1';
+            let record;
+            try {
+                record = createConsentRecord({ fields: request.body ?? {}, config, id: ports.ids.newId(), timestamp: ports.clock.nowIso(), regionMode: resolveConsentRegion({ configuredMode: config.regionMode, region: ports.region({ request }) }), gpc });
+            }
+            catch (error) {
+                respondError(response, 400, error instanceof Error ? error.message : 'Invalid cookie preferences.');
+                return;
+            }
+            await ports.records.save({ record });
+            response.cookie(cookieName, record.id, { httpOnly: true, sameSite: 'lax', secure: new URL(origin).protocol === 'https:', path: '/', maxAge: CONSENT_MAX_AGE_MS });
+            if (request.get('accept')?.includes('application/json')) {
+                response.json({ record, signals: googleConsentSignals({ choices: record.choices }) });
+                return;
+            }
+            const referer = request.get('referer');
+            let destination = '/';
+            if (referer && sameOrigin(request, origin)) {
+                const url = new URL(referer, origin);
+                // A root path beginning // would become a cross-origin Location header.
+                if (url.origin === new URL(origin).origin && !url.pathname.startsWith('//'))
+                    destination = url.pathname + url.search;
+            }
+            response.redirect(303, destination);
+        }
+        catch (error) {
+            ports.reportError({ operation: 'save', error });
+            respondError(response, 500, 'Cookie preferences could not be saved. Optional scripts remain paused. Please try again.');
+        }
+    });
+    app.use((request, response, next) => {
+        if (!isPublicPage(request)) {
+            next();
+            return;
+        }
+        captureConsentHtml({ response, transform: ({ body }) => deliver({ body }) }, { reportError: ({ error }) => ports.reportError({ operation: 'read', error }) });
+        async function deliver({ body }, _options = {}) {
+            let config;
+            let failed = false;
+            try {
+                config = await ports.config.get({});
+                lastGood = config;
+            }
+            catch (error) {
+                ports.reportError({ operation: 'read', error });
+                if (lastGood?.enabled === false)
+                    return body;
+                // A failed policy/proof read cannot safely decide that consent is off.
+                config = lastGood ?? { enabled: true, regionMode: 'opt-in', policyVersion: 'unavailable', privacyPolicyUrl: '', title: 'Cookie preferences', message: 'Optional content is paused while preferences are unavailable.', acceptLabel: 'Accept all', rejectLabel: 'Reject non-essential', preferencesLabel: 'Cookie preferences' };
+                failed = true;
+            }
+            if (!config.enabled)
+                return body;
+            response.set('Cache-Control', 'private, no-store');
+            response.vary('Cookie');
+            response.vary('Sec-GPC');
+            response.removeHeader('Content-Length');
+            response.removeHeader('ETag');
+            if (delivery === 'static') {
+                // Exported pages cannot POST a receipt. Refuse the export instead of publishing a broken theme.
+                response.removeHeader('Content-Encoding');
+                response.status(409).type('text/plain');
+                return Buffer.from('Static export requires cookie consent to be disabled. Review optional scripts before exporting.');
+            }
+            try {
+                if (response.getHeader('Content-Encoding') && response.getHeader('Content-Encoding') !== 'identity')
+                    throw new Error('Consent requires uncompressed HTML.');
+                const receipt = failed ? { record: null, failed: false } : await currentRecord({ request, ports, config });
+                const record = receipt.record;
+                const regionMode = failed || receipt.failed ? 'opt-in' : resolveConsentRegion({ configuredMode: config.regionMode, region: ports.region({ request }) });
+                const requestNonce = typeof nonce === 'function' ? nonce({ request, response }) : nonce;
+                const html = gateConsentHtml({ html: body.toString('utf8'), config, record, regionMode, gpc: request.get('sec-gpc') === '1', endpoint }, { runtimeToken: randomUUID(), ...(requestNonce === undefined ? {} : { nonce: requestNonce }), ...(necessaryScripts === undefined ? {} : { necessaryScripts }), ...(resourceOrigins === undefined ? {} : { resourceOrigins }) });
+                return Buffer.from(html);
+            }
+            catch (error) {
+                ports.reportError({ operation: 'read', error });
+                // Last-resort browser enforcement keeps the original page available when HTML processing fails.
+                blockConsentResponse({ response });
+                return body;
+            }
+        }
+        next();
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/consent/express/response.d.ts

@@ -0,0 +1,21 @@
+import type { Response } from 'express';
+/** Last-resort browser enforcement keeps original HTML available after a transform failure.
+ * Existing CSP remains enforced alongside this policy. @complexity O(existing header length). */
+export declare function blockConsentResponse({ response }: {
+    response: Response;
+}, _options?: {}): void;
+/** Intercept actual HTML at the common write/end boundary, including sendFile and pipes.
+ * Non-HTML output uses native methods without invoking policy/storage. HTML must be complete
+ * before parsing; callbacks acknowledge buffered writes and final completion remains native.
+ * @complexity O(n) time/space for n response bytes, plus the injected transformation. */
+export declare function captureConsentHtml({ response, transform }: {
+    response: Response;
+    transform: (required: {
+        body: Buffer;
+    }) => Promise<Buffer>;
+}, { reportError }?: {
+    reportError?: (required: {
+        error: unknown;
+    }) => void;
+}): void;
+//# sourceMappingURL=response.d.ts.map

package/dist/consent/express/response.js

@@ -0,0 +1,89 @@
+/** Last-resort browser enforcement keeps original HTML available after a transform failure.
+ * Existing CSP remains enforced alongside this policy. @complexity O(existing header length). */
+export function blockConsentResponse({ response }, _options = {}) {
+    const policy = "default-src 'self'; script-src 'none'; frame-src 'none'; object-src 'none'; connect-src 'none'; img-src 'self' data:; media-src 'self'; font-src 'self'; style-src 'self' 'unsafe-inline'; base-uri 'self'";
+    const existing = response.getHeader('Content-Security-Policy');
+    response.setHeader('Content-Security-Policy', existing ? [...(Array.isArray(existing) ? existing.map(String) : [String(existing)]), policy] : policy);
+    response.setHeader('Cache-Control', 'private, no-store');
+    response.removeHeader('Content-Length');
+    response.removeHeader('ETag');
+}
+/** Intercept actual HTML at the common write/end boundary, including sendFile and pipes.
+ * Non-HTML output uses native methods without invoking policy/storage. HTML must be complete
+ * before parsing; callbacks acknowledge buffered writes and final completion remains native.
+ * @complexity O(n) time/space for n response bytes, plus the injected transformation. */
+export function captureConsentHtml({ response, transform }, { reportError = () => console.error("Consent HTML transform failed; optional content is blocked.") } = {}) {
+    const write = response.write, end = response.end, writeHead = response.writeHead, flushHeaders = response.flushHeaders;
+    const chunks = [];
+    let bytes = 0, buffering = false;
+    const isHtml = (_chunk) => !response.getHeader('content-type') || String(response.getHeader('content-type')).toLowerCase().includes('text/html');
+    const restore = () => { response.write = write; response.end = end; response.writeHead = writeHead; response.flushHeaders = flushHeaders; };
+    // Explicit header flushes must wait for the HTML transform, including sendFile/stream output.
+    response.writeHead = function (status, reasonOrHeaders, headers) {
+        response.statusCode = status;
+        if (typeof reasonOrHeaders === 'string')
+            response.statusMessage = reasonOrHeaders;
+        const values = typeof reasonOrHeaders === 'string' ? headers : reasonOrHeaders;
+        if (Array.isArray(values))
+            for (let i = 0; i < values.length; i += 2)
+                response.setHeader(String(values[i]), values[i + 1]);
+        else if (values && typeof values === 'object')
+            for (const [name, value] of Object.entries(values))
+                if (value !== undefined)
+                    response.setHeader(name, value);
+        return this;
+    };
+    response.flushHeaders = function () { if (!isHtml('')) {
+        restore();
+        flushHeaders.call(this);
+    } };
+    response.write = function (chunk, encoding, callback) {
+        if (!buffering && !isHtml(chunk)) {
+            restore();
+            return Reflect.apply(write, this, [chunk, encoding, callback]);
+        }
+        buffering = true;
+        const value = Buffer.isBuffer(chunk) ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk) : Buffer.from(String(chunk), typeof encoding === 'string' ? encoding : 'utf8');
+        chunks.push(value);
+        bytes += value.length;
+        const done = typeof encoding === 'function' ? encoding : callback;
+        if (typeof done === 'function')
+            queueMicrotask(() => done());
+        return true;
+    };
+    response.end = function (chunk, encoding, callback) {
+        if (!buffering && !isHtml(chunk)) {
+            restore();
+            return Reflect.apply(end, this, [chunk, encoding, callback]);
+        }
+        if (chunk !== undefined && chunk !== null && typeof chunk !== 'function') {
+            const value = Buffer.isBuffer(chunk) ? chunk : chunk instanceof Uint8Array ? Buffer.from(chunk) : Buffer.from(String(chunk), typeof encoding === 'string' ? encoding : 'utf8');
+            chunks.push(value);
+            bytes += value.length;
+        }
+        const done = typeof chunk === 'function' ? chunk : typeof encoding === 'function' ? encoding : callback;
+        const collected = Buffer.concat(chunks, bytes);
+        // Headerless streams may split their opening tag across chunks; inspect the complete body.
+        const type = response.getHeader('content-type');
+        const html = String(type).toLowerCase().includes('text/html') || (!type && /^\s*<[a-z!]/i.test(collected.toString('utf8')));
+        void Promise.resolve().then(() => html ? transform({ body: collected }) : collected).catch(error => {
+            if (!response.destroyed)
+                blockConsentResponse({ response });
+            // An observability outage must never hold page completion or grant optional requests.
+            try {
+                reportError({ error });
+            }
+            catch {
+                console.error('Consent error reporter failed; optional content is blocked.');
+            }
+            return collected;
+        }).then(body => {
+            if (response.destroyed)
+                return;
+            restore();
+            Reflect.apply(end, response, [body, typeof done === 'function' ? done : undefined]);
+        });
+        return this;
+    };
+}
+//# sourceMappingURL=response.js.map

package/dist/consent/html/client.d.ts

@@ -0,0 +1,6 @@
+/** Vanilla enhancement: forms remain ordinary POST forms without this script.
+ * Signals are queued before any released tag. A changed choice reloads to stop already-running
+ * scripts; a new grant is released only after the server durably saved its receipt.
+ * Script release is ordered and each template is consumed once. O(s + l) for s deferred elements and l late listeners. */
+export declare const CONSENT_CLIENT: string;
+//# sourceMappingURL=client.d.ts.map

package/dist/consent/html/client.js

@@ -0,0 +1,135 @@
+/** Vanilla enhancement: forms remain ordinary POST forms without this script.
+ * Signals are queued before any released tag. A changed choice reloads to stop already-running
+ * scripts; a new grant is released only after the server durably saved its receipt.
+ * Script release is ordered and each template is consumed once. O(s + l) for s deferred elements and l late listeners. */
+export const CONSENT_CLIENT = String.raw `(function () {
+  'use strict';
+  var node = document.getElementById('jini-consent-config');
+  if (!node) return;
+  var state = JSON.parse(node.textContent);
+  var gpc = state.gpc || navigator.globalPrivacyControl === true;
+  var choices = gpc ? state.gpcChoices : state.choices;
+  if (gpc && choices.marketing !== true) {
+    // navigator GPC may be absent from the request headers; enforce resource denial before parsing site styles.
+    var policy = document.createElement('meta');
+    policy.httpEquiv = 'Content-Security-Policy';
+    policy.content = state.resourcePolicy;
+    document.head.appendChild(policy);
+  }
+  window.dataLayer = window.dataLayer || [];
+  function signal(command, signals) {
+    // Google consumes gtag-style Arguments entries, not arbitrary arrays/objects.
+    (function () { window.dataLayer.push(arguments); })('consent', command, signals);
+  }
+  signal('default', state.deniedSignals);
+  if (state.hasRecord || state.optOut) signal('update', gpc ? state.gpcSignals : state.signals);
+  async function release() {
+    // Released theme scripts may register DCL listeners after the native event has fired.
+    // Replay only listeners added during release, so already-running necessary scripts do not run twice.
+    var late = [];
+    var byCapture = [new Map(), new Map()];
+    var add = document.addEventListener;
+    var remove = document.removeEventListener;
+    document.addEventListener = function (type, listener, options) {
+      var capture = typeof options === 'boolean' ? options : Boolean(options && options.capture);
+      var tracked = byCapture[Number(capture)];
+      if (type === 'DOMContentLoaded' && listener && !tracked.has(listener)) {
+        var entry = { listener: listener, options: options, removed: false };
+        late.push(entry); tracked.set(listener, entry);
+      }
+      return add.call(this, type, listener, options);
+    };
+    document.removeEventListener = function (type, listener, options) {
+      var capture = typeof options === 'boolean' ? options : Boolean(options && options.capture);
+      var tracked = byCapture[Number(capture)];
+      if (type === 'DOMContentLoaded' && tracked.has(listener)) { tracked.get(listener).removed = true; tracked.delete(listener); }
+      return remove.call(this, type, listener, options);
+    };
+    try {
+      var scripts = Array.from(document.querySelectorAll('template[data-jini-consent-script],template[data-jini-consent-resource]'));
+      for (var template of scripts) {
+        if (!['functional', 'analytics', 'marketing'].includes(template.dataset.category) || choices[template.dataset.category] !== true) continue;
+        if (template.hasAttribute('data-jini-consent-resource')) { template.replaceWith(template.content); continue; }
+        var original = template.content.querySelector('script');
+        if (!original) continue;
+        var script = document.createElement('script');
+        for (var attribute of original.attributes) script.setAttribute(attribute.name, attribute.value);
+        if (original.nonce) script.nonce = original.nonce;
+        script.textContent = original.textContent;
+        script.async = false;
+        var completion = Promise.resolve();
+        if (script.src || script.type === 'module') {
+          completion = new Promise(function (resolve) {
+            var timer;
+            function finish() { clearTimeout(timer); resolve(); }
+            script.addEventListener('load', finish, { once: true });
+            script.addEventListener('error', finish, { once: true });
+            // A broken external tag must not hold unrelated later tags indefinitely.
+            timer = setTimeout(finish, 15000);
+          });
+        }
+        template.replaceWith(script);
+        await completion;
+      }
+      document.querySelectorAll('[data-jini-consent-attributes]').forEach(function (element) {
+        if (!['functional', 'analytics', 'marketing'].includes(element.dataset.jiniConsentCategory) || choices[element.dataset.jiniConsentCategory] !== true) return;
+        var attributes = JSON.parse(element.dataset.jiniConsentAttributes);
+        Object.keys(attributes).forEach(function (name) { element.setAttribute(name, attributes[name]); });
+        element.removeAttribute('data-jini-consent-attributes');
+      });
+    } finally { document.addEventListener = add; document.removeEventListener = remove; }
+    var event = new Event('DOMContentLoaded');
+    late.forEach(function (entry) {
+      if (entry.removed || (entry.options && entry.options.signal && entry.options.signal.aborted)) return;
+      if (entry.options && entry.options.once) remove.call(document, 'DOMContentLoaded', entry.listener, entry.options);
+      try {
+        if (typeof entry.listener === 'function') entry.listener.call(document, event);
+        else entry.listener.handleEvent(event);
+      } catch (failure) {
+        // Native dispatch isolates listener errors; keep later theme initializers running too.
+        setTimeout(function () { throw failure; }, 0);
+      }
+    });
+  }
+  document.addEventListener('DOMContentLoaded', function () {
+    var banner = document.getElementById('jini-consent');
+    if (gpc) {
+      banner.querySelector('[data-jini-gpc-note]').hidden = false;
+      banner.querySelector('[name=gpc]').value = '1';
+      ['analytics', 'marketing'].forEach(function (category) {
+        var input = banner.querySelector('[name=' + category + ']');
+        input.checked = false; input.disabled = true;
+      });
+    }
+    var preferences = document.getElementById('jini-consent-preferences');
+    banner.querySelector('[data-jini-do-not-sell]').addEventListener('click', function () {
+      preferences.open = true;
+      banner.querySelector('[data-jini-do-not-sell-button]').focus();
+    });
+    banner.querySelector('form').addEventListener('submit', async function (event) {
+      if (!event.submitter) return;
+      event.preventDefault();
+      var form = event.currentTarget;
+      var data = new URLSearchParams(new FormData(form));
+      data.set('action', event.submitter.value);
+      var buttons = Array.from(form.querySelectorAll('button'));
+      buttons.forEach(function (button) { button.disabled = true; });
+      var error = banner.querySelector('[data-jini-consent-error]');
+      error.hidden = true;
+      try {
+        var response = await fetch(form.action, { method: 'POST', credentials: 'same-origin',
+          headers: { 'Accept': 'application/json' }, body: data });
+        var result = await response.json();
+        if (!response.ok) throw new Error(result.error || 'Cookie preferences could not be saved.');
+        signal('update', result.signals);
+        window.location.reload();
+      } catch (failure) {
+        error.textContent = failure.message || 'Cookie preferences could not be saved. Please try again.';
+        error.hidden = false;
+        buttons.forEach(function (button) { button.disabled = false; });
+      }
+    });
+    release();
+  }, { once: true });
+})();`;
+//# sourceMappingURL=client.js.map

package/dist/consent/html/gate.d.ts

@@ -0,0 +1,29 @@
+import { type ConsentConfig, type ConsentRecord, type ConsentRegionMode } from '../types.js';
+/** Exact host manifest entries, never declarations taken from page HTML. */
+export interface ConsentGateOptions {
+    nonce?: string;
+    runtimeToken?: string;
+    /** Host-reviewed theme origins allowed by the pre-consent resource policy. */
+    resourceOrigins?: readonly string[];
+    necessaryScripts?: readonly ({
+        src: string;
+        content?: never;
+    } | {
+        content: string;
+        src?: never;
+    })[];
+}
+/** Gate delivered HTML using the existing parser, including no-JS and non-script requests.
+ * Only host allowlisted scripts are necessary. JSON/JSON-LD and authored templates stay inert.
+ * Resource hints are removed so browsers cannot fetch before consent. Source offsets preserve
+ * unrelated markup byte-for-byte; wrapping a parent consumes its subtree without overlapping edits.
+ * @complexity O(n + s log s + a*k) time/O(n) space: n bytes, s edits, a scripts, k manifest entries. */
+export declare function gateConsentHtml({ html, config, record, regionMode, gpc, endpoint }: {
+    html: string;
+    config: ConsentConfig;
+    record: ConsentRecord | null;
+    regionMode: ConsentRegionMode;
+    gpc: boolean;
+    endpoint: string;
+}, options?: ConsentGateOptions): string;
+//# sourceMappingURL=gate.d.ts.map

package/dist/consent/html/gate.js

@@ -0,0 +1,104 @@
+import { parse, serializeOuter } from 'parse5';
+import { escapeHtml } from '@jini-ai/core/text';
+import {} from '../types.js';
+import { renderConsentHead, renderConsentUi } from './render.js';
+import { CONSENT_CLIENT } from './client.js';
+/** Relative resources belong to the host. A base element is removed before delivery.
+ * @complexity O(URL length). Unknown schemes and protocol-relative URLs are external. */
+function external({ url }, _options = {}) {
+    // Browsers normalize backslashes and embedded ASCII URL whitespace before fetching.
+    const normalized = url.trim().replace(/[\t\r\n]/g, '').replace(/\\/g, '/');
+    return !/^(?:[?#]|\/(?!\/)|\.?\.?\/|[a-zA-Z0-9_-]+(?:[./?#]|$))/.test(normalized) || /^[a-z][a-z0-9+.-]*:|^\/\//i.test(normalized);
+}
+/** Gate delivered HTML using the existing parser, including no-JS and non-script requests.
+ * Only host allowlisted scripts are necessary. JSON/JSON-LD and authored templates stay inert.
+ * Resource hints are removed so browsers cannot fetch before consent. Source offsets preserve
+ * unrelated markup byte-for-byte; wrapping a parent consumes its subtree without overlapping edits.
+ * @complexity O(n + s log s + a*k) time/O(n) space: n bytes, s edits, a scripts, k manifest entries. */
+export function gateConsentHtml({ html, config, record, regionMode, gpc, endpoint }, options = {}) {
+    if (!config.enabled)
+        return html;
+    const document = parse(html, { sourceCodeLocationInfo: true, scriptingEnabled: false });
+    const stack = [...document.childNodes];
+    const edits = [];
+    let headStart, htmlStart, bodyStart;
+    let doctypeEnd = 0;
+    while (stack.length) {
+        const node = stack.pop();
+        if (node.nodeName === '#documentType')
+            doctypeEnd = node.sourceCodeLocation?.endOffset ?? 0;
+        if (!('tagName' in node))
+            continue;
+        const location = node.sourceCodeLocation;
+        const attrs = new Map(node.attrs.map(attr => [attr.name, attr.value]));
+        if (node.tagName === 'html' && location?.startTag)
+            htmlStart = location.startTag.endOffset;
+        if (node.tagName === 'head' && location?.startTag)
+            headStart = location.startTag.endOffset;
+        if (node.tagName === 'body' && location?.startTag)
+            bodyStart = location.startTag.endOffset;
+        const text = node.childNodes.filter(child => child.nodeName === '#text').map(child => 'value' in child ? child.value : '').join('');
+        // A marker exempts only our exact runtime in this response, never the surrounding page.
+        const runtime = node.tagName === 'script' && options.runtimeToken !== undefined && attrs.get('data-jini-consent-runtime') === options.runtimeToken && text === CONSENT_CLIENT;
+        const necessary = node.tagName === 'script' && (runtime || options.necessaryScripts?.some(entry => entry.src !== undefined ? attrs.get('src') === entry.src : !attrs.has('src') && text === entry.content));
+        const reserved = runtime ? [] : node.attrs.filter(attr => attr.name.startsWith('data-jini-consent-') || (attr.name === 'id' && ['jini-consent', 'jini-consent-config', 'jini-consent-preferences'].includes(attr.value)));
+        // Authored markers cannot become another release owner or shadow our UI/state IDs.
+        node.attrs = node.attrs.filter(attr => !reserved.includes(attr));
+        const rel = (attrs.get('rel') ?? '').toLowerCase().split(/\s+/);
+        if (location && (node.tagName === 'base' || (node.tagName === 'meta' && attrs.get('http-equiv')?.toLowerCase() === 'refresh') || (node.tagName === 'link' && rel.some(value => ['preload', 'modulepreload', 'prefetch', 'prerender', 'preconnect', 'dns-prefetch'].includes(value))))) {
+            // An as=fetch preload can fetch the same optional script URL, so remove all resource hints.
+            edits.push({ start: location.startOffset, end: location.endOffset, text: '' });
+            continue;
+        }
+        const type = (attrs.get('type') ?? '').trim().toLowerCase();
+        // Default deny includes legacy JavaScript MIME types, import maps and speculation rules.
+        const dataScript = node.tagName === 'script' && ['application/json', 'application/ld+json', 'text/plain', 'text/template', 'text/x-template'].includes(type);
+        const remote = (attrs.has('srcset') && /(?:^|[,\s])(?:https?:|\/\/)/i.test(attrs.get('srcset'))) || ['src', 'href', 'poster', 'data', 'srcset', 'background'].some(key => attrs.has(key) && external({ url: attrs.get(key) }));
+        const cssRequests = (node.tagName === 'style' && /url\s*\(|(?:-webkit-)?image-set\s*\(|@import|\\/i.test(text));
+        const resource = ['iframe', 'frame', 'object', 'embed', 'video', 'audio', 'source', 'track', 'noscript'].includes(node.tagName)
+            || (['img', 'image', 'input'].includes(node.tagName) && (remote || attrs.has('data-consent-category') || attrs.get('width') === '1' || attrs.get('height') === '1'))
+            || (remote && !['a', 'area', 'form', 'html', 'head', 'body', 'script'].includes(node.tagName)) || cssRequests
+            || (attrs.has('data-consent-category') && !['html', 'head', 'body', 'script'].includes(node.tagName));
+        const declared = attrs.get('data-consent-category');
+        // Page labels may select optional categories; they can never grant necessity.
+        const category = declared === undefined || declared === 'necessary' ? (remote || resource ? 'marketing' : 'functional') : ['functional', 'analytics', 'marketing'].includes(declared) ? declared : 'blocked';
+        if (location && ((node.tagName === 'script' && !dataScript && !necessary) || resource)) {
+            // Normalize ignored/misnested end tags so they cannot escape the new template boundary.
+            const source = serializeOuter(node, { scriptingEnabled: false });
+            // A template in SVG/MathML is not an inert HTML template. Remove foreign scripts/resources.
+            const marker = node.tagName === 'script' ? 'data-jini-consent-script' : 'data-jini-consent-resource';
+            edits.push({ start: location.startOffset, end: location.endOffset, text: node.namespaceURI === 'http://www.w3.org/1999/xhtml' ? `<template ${marker} data-category="${category}">${source}</template>` : '' });
+            continue;
+        }
+        if (location?.startTag) {
+            for (const attr of reserved) {
+                const attrLocation = location.attrs?.[attr.name];
+                if (attrLocation)
+                    edits.push({ start: attrLocation.startOffset, end: attrLocation.endOffset, text: '' });
+            }
+            const deferred = {};
+            for (const attr of node.attrs) {
+                const attrLocation = location.attrs?.[attr.name];
+                if (!attrLocation)
+                    continue;
+                if ((attr.name === 'background' && external({ url: attr.value })) || /^on/i.test(attr.name) || (['href', 'action', 'formaction'].includes(attr.name) && /^[\s\x00-\x20]*javascript:/i.test(attr.value)) || (attr.name === 'style' && /url\s*\(|(?:-webkit-)?image-set\s*\(|@import|\\/i.test(attr.value))) {
+                    deferred[attr.name] = attr.value;
+                    edits.push({ start: attrLocation.startOffset, end: attrLocation.endOffset, text: '' });
+                }
+            }
+            if (Object.keys(deferred).length)
+                edits.push({ start: location.startTag.endOffset - 1, end: location.startTag.endOffset - 1, text: ` data-jini-consent-attributes="${escapeHtml({ text: JSON.stringify(deferred) })}" data-jini-consent-category="${category}"` });
+        }
+        // Authored template contents are already inert; traversing them would release never-mounted code.
+        if (node.tagName !== 'template')
+            stack.push(...node.childNodes);
+    }
+    const bootstrapOffset = headStart ?? htmlStart ?? doctypeEnd;
+    edits.push({ start: bootstrapOffset, end: bootstrapOffset, text: renderConsentHead({ record, gpc, regionMode }, options) });
+    edits.push({ start: bodyStart ?? bootstrapOffset, end: bodyStart ?? bootstrapOffset, text: renderConsentUi({ config, record, regionMode, gpc, endpoint }) });
+    edits.sort((a, b) => b.start - a.start);
+    for (const edit of edits)
+        html = html.slice(0, edit.start) + edit.text + html.slice(edit.end);
+    return html;
+}
+//# sourceMappingURL=gate.js.map

package/dist/consent/html/index.d.ts

@@ -0,0 +1,4 @@
+export { gateConsentHtml } from './gate.js';
+export { renderConsentUi, renderConsentHead, consentPolicyHref } from './render.js';
+export type { ConsentGateOptions } from './gate.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/consent/html/index.js

@@ -0,0 +1,3 @@
+export { gateConsentHtml } from './gate.js';
+export { renderConsentUi, renderConsentHead, consentPolicyHref } from './render.js';
+//# sourceMappingURL=index.js.map

package/dist/consent/html/render.d.ts

@@ -0,0 +1,27 @@
+import { type ConsentConfig, type ConsentRecord, type ConsentRegionMode } from '../types.js';
+/** Refuse executable/data/protocol-relative privacy links; local pages are the common case.
+ * @complexity O(url length). */
+export declare function consentPolicyHref({ url }: {
+    url: string;
+}, _options?: {}): string | null;
+/** Render one accessible progressive form. Config text is always text, never trusted HTML.
+ * Necessary cookies/default rejection work without JS. @complexity O(config text length). */
+export declare function renderConsentUi({ config, record, regionMode, gpc, endpoint }: {
+    config: ConsentConfig;
+    record: ConsentRecord | null;
+    regionMode: ConsentRegionMode;
+    gpc: boolean;
+    endpoint: string;
+}, _options?: {}): string;
+/** Bootstrap must be inserted before every site script; JSON cannot terminate its script element.
+ * @complexity O(config text length). */
+export declare function renderConsentHead({ record, gpc, regionMode }: {
+    record: ConsentRecord | null;
+    gpc: boolean;
+    regionMode?: ConsentRegionMode;
+}, { nonce, runtimeToken, resourceOrigins }?: {
+    nonce?: string;
+    runtimeToken?: string;
+    resourceOrigins?: readonly string[];
+}): string;
+//# sourceMappingURL=render.d.ts.map