@thg-agentic/hyper-personalisation-web 3.22.2 → 3.23.0

package/src/onsite/index.js

@@ -0,0 +1,446 @@
+/**
+ * Onsite forms (ADR 0064): sign-up popups, bars, teasers, inline forms and spin-to-win, shown by
+ * the settings' `hp.onsite` index and decided by the server.
+ *
+ *   import { startOnsite } from '@thg-agentic/hyper-personalisation-web/onsite';
+ *   startOnsite(hp); // the client bootstrap resolved to, or pass `onsite: true` to bootstrap
+ *
+ * The browser judges the trigger; the server decides the rest. Each live form's trigger is watched
+ * here, with its pages, devices, dates and caps. When one fires, `POST /v1/decisions` is asked for
+ * that one slot: a held-out visitor, or no decision, shows nothing. One overlay per page view, the
+ * highest priority among those that fire within 50 ms; one that cannot show passes to the next, but
+ * a held-out visitor sees none; with the property's `overlay_gap_minutes`,
+ * none until that long after the last one this session. `?hp_debug=onsite` logs why each form did
+ * or did not show; `hp.onsite.debug()` returns it. The renderer (./render.js, its own chunk) is
+ * fetched only once a trigger fires, alongside the decision request; a page whose forms never fire
+ * never downloads it.
+ */
+
+import { loadAnswers } from './answers-loader.js';
+import { createApi } from './api.js';
+import { createCounters } from './counters.js';
+import { loadRender } from './render-loader.js';
+import {
+	blockers,
+	byPriority,
+	deviceOf,
+	INTERRUPTS,
+	OVERLAY,
+	readCreative,
+	readForm,
+} from './rules.js';
+import { watch } from './triggers.js';
+import { loadWheel } from './wheel-loader.js';
+
+const ACCESS = Symbol.for(
+	'@thg-agentic/hyper-personalisation-web.onsite-access',
+);
+const CONTROLLER = Symbol.for('@thg-agentic/hyper-personalisation-web.onsite');
+const PENDING = Symbol.for(
+	'@thg-agentic/hyper-personalisation-web.onsite.pending',
+);
+const LISTENERS = Symbol.for(
+	'@thg-agentic/hyper-personalisation-web.onsite.listeners',
+);
+const SUPPRESSED = Symbol.for(
+	'@thg-agentic/hyper-personalisation-web.onsite.suppressed',
+);
+
+/** A preview link's counters: a trader's visit counts nothing and is capped by nothing. */
+const INERT = {
+	seen: () => ({ session: 0, lifetime: 0, closedAt: null, submitted: false }),
+	subscribed: () => false,
+	shown() {},
+	closed() {},
+	submitted() {},
+	tab() {},
+	tabOut: () => false,
+	pin: () => null,
+	coveredAt: () => null,
+	covered() {},
+	code: () => null,
+};
+
+/** How long a fired trigger waits for others, so two forms entering together show the higher priority. */
+const FIRE_WINDOW_MS = 50;
+
+const debugParam = () => {
+	try {
+		return new URLSearchParams(location.search).get('hp_debug') === 'onsite';
+	} catch {
+		return false;
+	}
+};
+
+/**
+ * Start onsite forms for `client`, once per page. Returns the controller, or null without a
+ * browser or a client from this SDK.
+ *
+ * @param {object} client The SDK client (bootstrap or createAnalytics).
+ * @param {import('../../types/onsite').OnsiteOptions} [options]
+ */
+export function startOnsite(client, options = {}) {
+	if (typeof window === 'undefined' || typeof document === 'undefined')
+		return null;
+	if (window[CONTROLLER]) return window[CONTROLLER];
+	const access =
+		typeof client?.[ACCESS] === 'function' ? client[ACCESS]() : null;
+	if (!access) {
+		console.warn(
+			'[hp] onsite: startOnsite needs the client bootstrap or createAnalytics made',
+		);
+		return null;
+	}
+	const settings = options.settings ?? access.settings ?? {};
+	const api = createApi(access, {
+		...options,
+		challenge: settings.capture?.challenge,
+	});
+	const counters = access.preview
+		? INERT
+		: createCounters(access.storageKey, access.personalisation);
+	const mounted = new Map();
+	const suppressed = () => window[SUPPRESSED]?.size > 0;
+
+	/** Tell the page's `hp.onsite.on` listeners; a listener that throws never reaches the form. */
+	const emit = (name, detail) => {
+		for (const fn of window[LISTENERS]?.[name] ?? []) {
+			try {
+				fn(detail);
+			} catch (err) {
+				console.warn(`[hp] onsite ${name} listener failed:`, err);
+			}
+		}
+	};
+	const device = deviceOf(window);
+	const logging = access.debug || options.debug === true || debugParam();
+	const trace = new Map();
+	const stops = new Map();
+	const forms = [];
+	for (const raw of Array.isArray(settings.forms) ? settings.forms : []) {
+		const form = readForm(raw);
+		if (form) forms.push(form);
+		else
+			trace.set(String(raw?.slot ?? `form ${trace.size + 1}`), {
+				slot: String(raw?.slot ?? ''),
+				state: 'invalid',
+				reasons: ['not a form this SDK can show'],
+			});
+	}
+	let overlay = null;
+	let fired = [];
+	const gap = Number.isInteger(settings.overlay_gap_minutes)
+		? settings.overlay_gap_minutes
+		: 0;
+	/** Why the property's gap between covering forms still holds this session, or null. */
+	const gapHolds = () => {
+		const at = counters.coveredAt();
+		if (!(gap > 0) || typeof at !== 'number') return null;
+		const ago = Math.max(0, Math.floor((Date.now() - at) / 60_000));
+		return ago < gap
+			? `a popup showed ${ago} min ago; ${gap} min between them`
+			: null;
+	};
+	/** Forms whose trigger fired on an empty basket: they try again when the basket changes. */
+	const awaitingBasket = new Set();
+	/** Covering forms whose trigger fired before the consent banner was answered. */
+	const awaitingConsent = new Set();
+
+	const note = (form, state, reasons = []) => {
+		trace.set(form.slot, {
+			slot: form.slot,
+			format: form.format,
+			trigger: form.trigger.type,
+			priority: form.priority,
+			state,
+			reasons,
+		});
+		if (logging)
+			console.info(
+				`[hp] onsite ${form.slot}: ${state}${reasons.length ? ` (${reasons.join('; ')})` : ''}`,
+			);
+		return state;
+	};
+
+	const sessionAudiences = () => {
+		try {
+			const given = options.audiences?.();
+			return Array.isArray(given) ? given : null;
+		} catch {
+			return null;
+		}
+	};
+
+	const env = (form) => ({
+		path: location.pathname,
+		device,
+		now: Date.now(),
+		seen: counters.seen(form.slot),
+		subscribed: counters.subscribed() || options.subscribed?.() === true,
+		personalisation: access.personalisation(),
+		preview: Boolean(access.preview),
+		audiences: sessionAudiences(),
+	});
+
+	const unwatch = (form) => {
+		stops.get(form.slot)?.();
+		stops.delete(form.slot);
+	};
+
+	/** `kept`: a teaser's tab carried from an earlier page, shown again whatever its caps. */
+	/** Show `form` if its rules allow it; resolves to the state its trace records. */
+	async function show(form, reason, kept = false) {
+		if (suppressed()) {
+			return note(form, 'not shown', [
+				`suppressed: ${[...window[SUPPRESSED]].join(', ')}`,
+			]);
+		}
+		const reasons = blockers(
+			form,
+			kept ? { ...env(form), seen: INERT.seen() } : env(form),
+		);
+		if (reasons.length) {
+			return note(form, 'not eligible', reasons);
+		}
+		// The gap first: it holds for the whole session, so it is the reason worth reading.
+		const interrupts = INTERRUPTS(form.format) && !kept;
+		const wait = interrupts && gapHolds();
+		if (wait) {
+			return note(form, 'not shown', [wait]);
+		}
+		// Never over an unanswered consent banner: the shopper answers it first, whatever the answer.
+		if (interrupts && !access.preview && access.consentAnswered?.() === false) {
+			awaitingConsent.add(form);
+			return note(form, 'not shown', ['waiting for the consent banner']);
+		}
+		const covers = OVERLAY(form.format);
+		if (covers && overlay) {
+			return note(form, 'not shown', [`${overlay} is showing`]);
+		}
+		let container = null;
+		if (!covers) {
+			try {
+				container = document.querySelector(form.trigger.selector ?? '');
+			} catch {
+				container = null;
+			}
+			if (!container) {
+				return note(form, 'not shown', ['no element matches its selector']);
+			}
+		}
+		if (covers) overlay = form.slot;
+		unwatch(form);
+		note(form, 'asking for a decision', [reason]);
+		// The renderer is fetched while the decision is asked, so neither waits on the other.
+		const renderer = loadRender().catch((err) => {
+			console.warn('[hp] onsite renderer not loaded:', err?.message ?? err);
+			return null;
+		});
+		const res = await api.decide(form.slot, counters.pin(form.slot));
+		const decision =
+			res.status === 200
+				? res.body?.decisions?.find((d) => d?.slot === form.slot)
+				: null;
+		// The version this visit was shown in the form's A/B test, kept for the rest of it (ADR 0065).
+		if (decision?.experiment && decision.arm && decision.split)
+			counters.pin(form.slot, [
+				decision.experiment,
+				decision.arm,
+				decision.split,
+			]);
+		const creative =
+			decision && decision.holdout !== true
+				? readCreative(decision.payload)
+				: null;
+		// A reminder needs a code to remind of, and a basket bar a basket: without one, nothing shows.
+		const first = creative?.steps[0].blocks ?? [];
+		const coupon =
+			decision?.offer?.code ?? (access.preview ? 'PREVIEW' : counters.code());
+		const basket = access.basketValue?.() ?? null;
+		const missing =
+			(first.some((b) => b?.t === 'code') &&
+				!coupon &&
+				'no code to remind of') ||
+			(first.some((b) => b?.t === 'progress') &&
+				!(basket > 0) &&
+				'the basket is empty');
+		if (missing) {
+			if (covers) overlay = null;
+			if (missing === 'the basket is empty') awaitingBasket.add(form);
+			return note(form, 'not shown', [missing]);
+		}
+		awaitingBasket.delete(form);
+		if (!creative) {
+			// A held-out visitor whose trigger fired is exposed to the default, as a treated one is.
+			if (decision?.holdout === true && access.analytics())
+				client.recordExposure(res.body);
+			if (covers) overlay = null;
+			return note(
+				form,
+				decision?.holdout === true ? 'held out' : 'no decision',
+				[
+					res.status === 200
+						? 'no creative for this visitor'
+						: `decisions answered ${res.status}`,
+				],
+			);
+		}
+		const render = await renderer;
+		if (!render) {
+			if (covers) overlay = null;
+			return note(form, 'not shown', ['the renderer did not load']);
+		}
+		if (!kept) counters.shown(form.slot);
+		if (interrupts) counters.covered();
+		const tell = (name, detail = {}) =>
+			emit(name, {
+				slot: form.slot,
+				arm: decision.arm ?? null,
+				format: creative.format ?? form.format,
+				...detail,
+			});
+		const handle = render.mountForm({
+			form,
+			creative,
+			decision,
+			access,
+			client,
+			api,
+			counters,
+			loadWheel,
+			loadAnswers,
+			container,
+			coupon,
+			basket: () => access.basketValue?.() ?? null,
+			emit: tell,
+			onClose(why) {
+				mounted.delete(form.slot);
+				if (overlay === form.slot) overlay = null;
+				note(form, 'closed', [why]);
+				tell('closed', { reason: why });
+			},
+		});
+		mounted.set(form.slot, handle);
+		if (access.analytics()) client.recordExposure(res.body);
+		note(form, 'shown', [reason]);
+		tell('shown');
+		return 'shown';
+	}
+
+	/**
+	 * Triggers that fire within FIRE_WINDOW_MS of each other compete: only the highest priority shows.
+	 * One that cannot show passes to the next; a held-out visitor sees none, so the holdout stays clean.
+	 */
+	function fire(form, reason) {
+		if (!OVERLAY(form.format)) return show(form, reason);
+		fired.push([form, reason]);
+		if (fired.length > 1) return;
+		setTimeout(async () => {
+			const queue = fired.sort(([a], [b]) => byPriority(a, b));
+			fired = [];
+			for (const [i, [next, why]] of queue.entries()) {
+				const state = await show(next, why);
+				if (state === 'shown' || state === 'held out') {
+					for (const [f] of queue.slice(i + 1))
+						note(f, 'not shown', [`${next.slot} has a higher priority`]);
+					return;
+				}
+			}
+		}, FIRE_WINDOW_MS);
+	}
+
+	for (const form of forms) {
+		// A teaser's tab still out from an earlier page comes back whatever its caps and trigger.
+		if (form.format === 'teaser' && counters.tabOut(form.slot)) {
+			show(form, 'tab kept from an earlier page', true);
+			continue;
+		}
+		const reasons = blockers(form, env(form));
+		if (reasons.length) {
+			note(form, 'not eligible', reasons);
+			continue;
+		}
+		const type = form.trigger.type;
+		if (type === 'manual') note(form, 'waiting for hp.onsite.open');
+		else if (type === 'inline' || form.format === 'inline')
+			show(form, 'inline');
+		else arm(form);
+	}
+
+	/** Watch a form's trigger; when it fires, the form competes to show. */
+	function arm(form) {
+		// A form armed again (after the consent banner) stops its first watcher, so it fires once.
+		unwatch(form);
+		stops.set(
+			form.slot,
+			watch(
+				form.trigger,
+				(reason) => {
+					unwatch(form);
+					fire(form, reason);
+				},
+				{ device },
+			),
+		);
+		note(form, 'armed', [`${form.trigger.type} on ${device}`]);
+	}
+
+	// Once the banner is answered, a form that waited is armed again, so it opens at its trigger's
+	// next moment (an exit form at the next exit), not at once; a form the site opened is shown.
+	const stopConsent = access.onConsentAnswered?.(() => {
+		const waiting = [...awaitingConsent];
+		awaitingConsent.clear();
+		for (const form of waiting)
+			if (!mounted.has(form.slot))
+				form.trigger.type === 'manual' ? fire(form, 'manual') : arm(form);
+	});
+
+	const stopBasket = access.onBasket?.(() => {
+		if (!((access.basketValue?.() ?? 0) > 0)) return;
+		// Out of the set before the decision is asked, so a second update cannot show them twice;
+		// covering ones compete on priority as any trigger does.
+		const waiting = [...awaitingBasket];
+		awaitingBasket.clear();
+		for (const form of waiting)
+			if (!mounted.has(form.slot)) fire(form, 'the basket changed');
+	});
+
+	const controller = Object.freeze({
+		/** Show the form on `slot` now, whatever its trigger, if its rules allow it. */
+		open(slot) {
+			const form = forms.find((f) => f.slot === slot);
+			// One already on screen (an inline form) is shown, not mounted twice.
+			return form && !mounted.has(slot)
+				? show(form, 'manual').then((state) => state === 'shown')
+				: Promise.resolve(mounted.has(slot));
+		},
+		/** `hp.onsite.suppress`: take every form off the screen, quietly; none shows until unsuppressed. */
+		suppress() {
+			for (const [slot, handle] of mounted) {
+				handle.destroy();
+				mounted.delete(slot);
+				if (overlay === slot) overlay = null;
+				const form = forms.find((f) => f.slot === slot);
+				if (form) note(form, 'closed', ['suppressed']);
+			}
+		},
+		/** Each form's state on this page and why, in settings order. */
+		debug: () =>
+			[...trace.values()].map((t) => ({ ...t, reasons: [...t.reasons] })),
+		/** Stop watching every trigger. A form on screen stays until it is closed. */
+		stop() {
+			for (const stop of stops.values()) stop();
+			stops.clear();
+			stopBasket?.();
+			stopConsent?.();
+			awaitingBasket.clear();
+			awaitingConsent.clear();
+			if (window[CONTROLLER] === controller) delete window[CONTROLLER];
+		},
+	});
+	window[CONTROLLER] = controller;
+	for (const { slot, resolve } of window[PENDING]?.splice(0) ?? [])
+		resolve(controller.open(slot));
+	if (logging) console.table?.(controller.debug());
+	return controller;
+}

package/src/onsite/pow.js

@@ -0,0 +1,127 @@
+/**
+ * ALTCHA's proof of work (the v1 SHA-256 challenge, MIT), solved headless: find `number` in
+ * [0, maxnumber] with `sha256(salt + number) === challenge`. The answer is the base64 payload
+ * `/v1/capture` takes as `altcha`. Off the main thread in a Worker made from a Blob; where a CSP or
+ * the browser refuses one, on the main thread, yielding to the page between batches.
+ */
+
+const TIMEOUT_MS = 20_000;
+
+/**
+ * Self-contained, so it can be the Worker's body: SubtleCrypto, 256 hashes at a time. `pause`
+ * yields between batches on the main thread; an aborted `signal` stops it there, with null.
+ *
+ * @param {{ challenge: string, salt: string, maxnumber?: number }} c
+ * @param {() => Promise<void>} [pause]
+ * @param {AbortSignal} [signal]
+ */
+export async function solveChallenge(c, pause, signal) {
+	const hex = (buf) =>
+		Array.from(new Uint8Array(buf), (b) =>
+			b.toString(16).padStart(2, '0'),
+		).join('');
+	const encoder = new TextEncoder();
+	const max = c.maxnumber ?? 1e6;
+	for (let start = 0; start <= max; start += 256) {
+		const batch = [];
+		for (let n = start; n < start + 256 && n <= max; n++)
+			batch.push(crypto.subtle.digest('SHA-256', encoder.encode(c.salt + n)));
+		const found = (await Promise.all(batch)).findIndex(
+			(d) => hex(d) === c.challenge,
+		);
+		if (found >= 0) return start + found;
+		if (pause) await pause();
+		if (signal?.aborted) return null;
+	}
+	return null;
+}
+
+/**
+ * A turn for the page between batches: a `user-visible` task, queued behind the page's own, with no
+ * timer's 4 ms clamp (the proof ends 1.4 to 2x sooner than with setTimeout). Not `background`,
+ * which a busy page starves until the proof times out, nor `scheduler.yield`, whose continuation
+ * runs ahead of the page's tasks and held off its timers for the whole proof.
+ */
+const pause = () =>
+	globalThis.scheduler?.postTask?.(() => {}, { priority: 'user-visible' }) ??
+	new Promise((resolve) => setTimeout(resolve, 0));
+
+/** On the main thread, giving the page a turn between batches, until `signal` aborts. */
+export const solveOnMainThread = (c, signal) =>
+	solveChallenge(c, pause, signal);
+
+function solveWithWorker(c, signal) {
+	const source = `onmessage=async(e)=>postMessage(await(${solveChallenge})(e.data))`;
+	const url = URL.createObjectURL(
+		new Blob([source], { type: 'text/javascript' }),
+	);
+	return new Promise((resolve, reject) => {
+		let worker;
+		try {
+			worker = new Worker(url);
+		} catch (err) {
+			URL.revokeObjectURL(url);
+			reject(err);
+			return;
+		}
+		const done = (fn, value) => {
+			worker.terminate();
+			URL.revokeObjectURL(url);
+			fn(value);
+		};
+		signal.addEventListener('abort', () => done(resolve, null), {
+			once: true,
+		});
+		worker.onmessage = (e) => done(resolve, e.data);
+		worker.onerror = (e) => {
+			e.preventDefault?.();
+			done(reject, e);
+		};
+		worker.postMessage({
+			challenge: c.challenge,
+			salt: c.salt,
+			maxnumber: c.maxnumber,
+		});
+	});
+}
+
+const isChallenge = (c) =>
+	c &&
+	c.algorithm === 'SHA-256' &&
+	typeof c.challenge === 'string' &&
+	typeof c.salt === 'string' &&
+	typeof c.signature === 'string';
+
+/** The `altcha` payload for challenge `c`, or null when it cannot be solved in time. */
+export async function solve(c) {
+	// Without SubtleCrypto (not a secure context) there is no proof: the gateway decides.
+	if (!isChallenge(c) || typeof crypto?.subtle?.digest !== 'function')
+		return null;
+	const started = Date.now();
+	// Out of time, the proof stops: the worker is ended, the main thread's batches cease.
+	const stop = new AbortController();
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(null), TIMEOUT_MS);
+	});
+	const work =
+		typeof Worker === 'function' && typeof Blob === 'function'
+			? solveWithWorker(c, stop.signal).catch(() =>
+					solveOnMainThread(c, stop.signal),
+				)
+			: solveOnMainThread(c, stop.signal);
+	const number = await Promise.race([work, timeout]);
+	clearTimeout(timer);
+	stop.abort();
+	if (typeof number !== 'number') return null;
+	return btoa(
+		JSON.stringify({
+			algorithm: c.algorithm,
+			challenge: c.challenge,
+			number,
+			salt: c.salt,
+			signature: c.signature,
+			took: Date.now() - started,
+		}),
+	);
+}

package/src/onsite/preview.js

@@ -0,0 +1,97 @@
+/**
+ * `./onsite/preview`: the console's preview of a creative, drawn by the shoppers' own renderer
+ * inside the console's box instead of over the page. It makes no request, sends no event and counts
+ * nothing: its buttons only move between steps, and closing does nothing. A popup, sheet, bar or
+ * teaser sits inside `host` as it would in the viewport (the host contains its fixed layers), and
+ * `device` picks the small-screen layout whatever the console's own width.
+ */
+
+import { answerFields, answerOf } from './answers.js';
+import { mountForm } from './render.js';
+import { readCreative } from './rules.js';
+import { mountWheel } from './wheel.js';
+
+export { CALLING_CODES } from './rules.js';
+
+const SAMPLE_CONSENT = 'Your consent text appears here.';
+const SAMPLE_SMS_CONSENT = 'Your SMS consent text appears here.';
+const noop = () => {};
+const silent = { analytics: () => false };
+const inert = {
+	submitted: noop,
+	closed: noop,
+	shown: noop,
+	tab: noop,
+	code: noop,
+};
+/** A basket to show a progress block against, when the console gives none. */
+const SAMPLE_BASKET = 32;
+
+/**
+ * Render `creative` into `host`.
+ *
+ * @param {HTMLElement} host The console's element; the preview fills it.
+ * @param {unknown} creative The arm's payload.
+ * @param {{ step?: string, device?: 'desktop'|'mobile', consentText?: string, smsConsentText?: string, locale?: string,
+ *   questions?: Array<{ key: string, type?: 'one'|'many'|'date'|'number', label?: string, options?: Array<{ value: string, label?: string }>, format?: object }>,
+ *   prizes?: Array<{ key: string, label: string }>, basketValue?: number }} [options]
+ * @returns {{ update(creative: unknown, options?: object): void, destroy(): void, step(): string|null }}
+ */
+export function mountPreview(host, creative, options = {}) {
+	let mounted = null;
+	let last = options;
+
+	const render = (doc, opts) => {
+		const read = readCreative(doc);
+		mounted?.destroy();
+		mounted = null;
+		if (!read) return;
+		const format = read.format ?? 'popup';
+		mounted = mountForm({
+			form: {
+				slot: 'preview',
+				format,
+				// The settings' `locale`, so the preview orders a birthday and picks a phone's
+				// country as shoppers see them, not by the console's own language.
+				...(opts.locale ? { locale: opts.locale } : {}),
+				consent_text: { text: opts.consentText ?? SAMPLE_CONSENT },
+				sms_consent_text: { text: opts.smsConsentText ?? SAMPLE_SMS_CONSENT },
+				questions: Array.isArray(opts.questions) ? opts.questions : [],
+				prizes: Array.isArray(opts.prizes) ? opts.prizes : [],
+			},
+			creative: read,
+			decision: { slot: 'preview' },
+			access: silent,
+			client: null,
+			api: null,
+			counters: inert,
+			loadWheel: () => Promise.resolve({ mountWheel }),
+			loadAnswers: () => Promise.resolve({ answerFields, answerOf }),
+			basket: () =>
+				Number.isFinite(opts.basketValue) ? opts.basketValue : SAMPLE_BASKET,
+			container: host,
+			preview: {
+				device: opts.device === 'mobile' ? 'mobile' : 'desktop',
+				step: opts.step,
+			},
+		});
+	};
+
+	render(creative, options);
+	return {
+		/** Re-render, on the step shown unless `options.step` names another. */
+		update(next, opts = {}) {
+			last = {
+				...last,
+				...opts,
+				step: opts.step ?? mounted?.step() ?? undefined,
+			};
+			render(next, last);
+		},
+		destroy() {
+			mounted?.destroy();
+			mounted = null;
+		},
+		step: () => mounted?.step() ?? null,
+	};
+}

package/src/onsite/render-loader.js

@@ -0,0 +1,5 @@
+/**
+ * The renderer, only once a form is to show: a bundler splits this import out of ./onsite, and the
+ * CDN build swaps this module for cdn/render-loader.js, which loads dist/onsite-render.min.js.
+ */
+export const loadRender = () => import('./render.js');