@getquick/content 0.0.0-stage → 0.2.0

package/dist/formatting-wOk2jz6J.js

@@ -0,0 +1,276 @@
+//#region frontend/src/wp-container-layout.ts
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+/** WPGraphQL renders nested blocks independently. Restore the parent's resolved
+* variables on direct container children without replacing their own layout. */
+function containerChildLayoutHtml(html, parentHtml) {
+	const parentTag = parentHtml.match(/^\s*<div\b[^>]*>/i)?.[0] ?? "";
+	if (!/\bgqd-container-layout\b/.test(parentTag)) return html;
+	const declarations = [...(parentTag.match(/\sstyle="([^"]*)"/)?.[1] ?? "").matchAll(/--gqd-layout-([a-z-]+):([^;"']+)/g)].filter(([, , value]) => value === "auto" || layoutValue(value)).map(([, name, value]) => `--gqd-parent-layout-${name}:${value}`).join(";");
+	if (!declarations) return html;
+	return html.replace(/^(\s*<div\b)([^>]*)(>)/i, (_, tag, props, end) => {
+		const style = /\sstyle="([^"]*)"/;
+		props = style.test(props) ? props.replace(style, (_match, old) => ` style="${old};${declarations}"`) : `${props} style="${declarations}"`;
+		return `${tag}${props}${end}`;
+	});
+}
+function layoutValue(value) {
+	if (typeof value !== "string" && typeof value !== "number") return "";
+	const text = String(value);
+	const preset = text.match(/^var:preset\|spacing\|([a-z0-9-]+)$/);
+	if (preset) return `var(--wp--preset--spacing--${preset[1]})`;
+	return /^(?:none|0|[0-9.]+(?:px|rem|em|%|vw|vh|ch)|(?:var|calc|min|max|clamp)\([a-zA-Z0-9_.,%()+*/ -]+\))$/.test(text) ? text : "";
+}
+/** Rendered CMS shells already carry resolved theme defaults. Saved shells need
+* the same opt-in adapter; absent defaults deliberately fall back to no width.
+*/
+function containerLayoutHtml(html, attributes) {
+	if (/\bgqd-container-layout\b/.test(html.match(/^\s*<[^>]+>/)?.[0] ?? "")) return html;
+	const layout = record(attributes.layout);
+	const spacing = record(record(attributes.style).spacing);
+	const gap = spacing.blockGap;
+	if (!Object.keys(layout).length && (gap === void 0 || gap === null || gap === "")) return html;
+	const type = layout.inherit || layout.contentSize ? "constrained" : layout.type ?? "default";
+	if (type !== "default" && type !== "constrained") return html;
+	const content = layoutValue(layout.contentSize);
+	const wide = layoutValue(layout.wideSize);
+	const variables = [
+		`--gqd-layout-content:${content || wide || "var(--wp--style--global--content-size, none)"}`,
+		`--gqd-layout-wide:${wide || content || "var(--wp--style--global--wide-size, none)"}`,
+		`--gqd-layout-gap:${layoutValue(typeof gap === "object" ? record(gap).top : gap) || "var(--wp--style--block-gap, 0)"}`
+	];
+	let classes = "gqd-container-layout";
+	if (type === "constrained") {
+		classes += " gqd-container-layout--constrained";
+		variables.push(`--gqd-layout-left:${layout.justifyContent === "left" ? "0" : "auto"}`, `--gqd-layout-right:${layout.justifyContent === "right" ? "0" : "auto"}`);
+		for (const side of ["left", "right"]) variables.push(`--gqd-layout-padding-${side}:${layoutValue(typeof spacing.padding === "object" ? record(spacing.padding)[side] : spacing.padding) || "0px"}`);
+	}
+	return (html || "<div class=\"wp-block-getquick-design-container\"></div>").replace(/^(\s*<div\b)([^>]*)(>)/i, (_, tag, props, end) => {
+		const add = (name, value, separator) => {
+			const pattern = new RegExp(`(\\s)${name}="([^"]*)"`);
+			props = pattern.test(props) ? props.replace(pattern, (_match, space, old) => `${space}${name}="${old}${separator}${value}"`) : `${props} ${name}="${value}"`;
+		};
+		add("class", classes, " ");
+		add("style", variables.join(";"), ";");
+		return `${tag}${props}${end}`;
+	});
+}
+//#endregion
+//#region frontend/src/wp-block-renderer.ts
+const VIDEO_HERO_BLOCK = "getquick-design/video-hero";
+const YOUTUBE_ID_PATTERN = /^[A-Za-z0-9_-]{11}$/;
+const BLOCKS_WITH_RENDERED_CHILDREN = /* @__PURE__ */ new Set([
+	"core/cover",
+	"core/media-text",
+	"core/navigation",
+	"core/navigation-submenu"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeBlock(value) {
+	if (!isRecord(value) || typeof value.name !== "string") return null;
+	const attributes = isRecord(value.attributes) ? value.attributes : void 0;
+	const innerBlocks = Array.isArray(value.innerBlocks) ? value.innerBlocks.map(normalizeBlock).filter((block) => block !== null) : [];
+	return {
+		name: value.name,
+		attributes,
+		htmlContent: typeof value.htmlContent === "string" ? value.htmlContent : "",
+		dynamicContent: typeof value.dynamicContent === "string" ? value.dynamicContent : void 0,
+		innerBlocks
+	};
+}
+function parseWordPressBlocks(value) {
+	let parsed = value;
+	for (let attempt = 0; attempt < 2 && typeof parsed === "string"; attempt += 1) try {
+		parsed = JSON.parse(parsed);
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(parsed)) return [];
+	return parsed.map(normalizeBlock).filter((block) => block !== null);
+}
+function hasVideoHero(blocks) {
+	return blocks.some((block) => block.name === "getquick-design/video-hero" || hasVideoHero(block.innerBlocks ?? []));
+}
+function escapeAttribute(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function safeMediaUrl(value) {
+	if (typeof value !== "string") return "";
+	const url = value.trim();
+	if (!url || url.startsWith("//")) return "";
+	if (url.startsWith("/")) return url;
+	try {
+		const parsed = new URL(url);
+		return parsed.protocol === "https:" || parsed.protocol === "http:" ? url : "";
+	} catch {
+		return "";
+	}
+}
+function youtubeVideoId(value) {
+	try {
+		const url = new URL(value);
+		if (url.protocol !== "https:" && url.protocol !== "http:") return "";
+		const host = url.hostname.toLowerCase().replace(/^www\./, "");
+		let id = "";
+		if (host === "youtu.be") id = url.pathname.split("/").filter(Boolean)[0] ?? "";
+		else if ([
+			"youtube.com",
+			"m.youtube.com",
+			"youtube-nocookie.com"
+		].includes(host)) {
+			id = url.searchParams.get("v") ?? "";
+			if (!id) id = url.pathname.match(/^\/(?:embed|shorts|live)\/([^/]+)/)?.[1] ?? "";
+		}
+		return YOUTUBE_ID_PATTERN.test(id) ? id : "";
+	} catch {
+		return "";
+	}
+}
+function videoMarkup(attributes) {
+	const posterUrl = safeMediaUrl(attributes.posterUrl);
+	const poster = posterUrl ? `<img class="wp-block-getquick-design-video-hero__poster" src="${escapeAttribute(posterUrl)}" alt="" decoding="async" />` : "";
+	if (attributes.videoType === "youtube") {
+		const videoId = typeof attributes.videoUrl === "string" ? youtubeVideoId(attributes.videoUrl) : "";
+		if (!videoId) return poster;
+		return `${poster}<iframe class="wp-block-getquick-design-video-hero__video wp-block-getquick-design-video-hero__video--youtube" src="https://www.youtube-nocookie.com/embed/${videoId}?${new URLSearchParams({
+			autoplay: "1",
+			mute: "1",
+			controls: "0",
+			loop: "1",
+			playlist: videoId,
+			playsinline: "1",
+			rel: "0"
+		}).toString()}" title="Decorative background video" allow="autoplay; encrypted-media" referrerpolicy="strict-origin-when-cross-origin" tabindex="-1" aria-hidden="true"></iframe>`;
+	}
+	const videoUrl = safeMediaUrl(attributes.videoUrl);
+	if (!videoUrl) return poster;
+	const posterAttribute = posterUrl ? ` poster="${escapeAttribute(posterUrl)}"` : "";
+	return `<video class="wp-block-getquick-design-video-hero__video" src="${escapeAttribute(videoUrl)}"${posterAttribute} autoplay muted loop playsinline preload="metadata" aria-hidden="true"></video>`;
+}
+function rootSectionShell(html) {
+	return html.match(/^\s*(<section\b[^>]*>)/i)?.[1] ?? "<section class=\"wp-block-getquick-design-video-hero\">";
+}
+function renderVideoHero(block, children) {
+	return `${rootSectionShell(block.htmlContent ?? "")}<div class="wp-block-getquick-design-video-hero__media" aria-hidden="true">${videoMarkup(block.attributes ?? {})}</div><div class="wp-block-getquick-design-video-hero__content">${children}</div></section>`;
+}
+function appendChildren(html, children) {
+	if (!children) return html;
+	const closingTag = html.lastIndexOf("</");
+	if (closingTag < 0) return `${html}${children}`;
+	return `${html.slice(0, closingTag)}${children}${html.slice(closingTag)}`;
+}
+function renderBlock(block, parentContainerHtml = "") {
+	const isContainer = block.name === "getquick-design/container";
+	let html = isContainer ? containerLayoutHtml(block.htmlContent ?? "", block.attributes ?? {}) : block.htmlContent ?? "";
+	if (isContainer && parentContainerHtml) html = containerChildLayoutHtml(html, parentContainerHtml);
+	const children = (block.innerBlocks ?? []).map((child) => renderBlock(child, isContainer ? html : "")).join("");
+	if (block.name === "getquick-design/video-hero") return renderVideoHero(block, children);
+	if (!children || BLOCKS_WITH_RENDERED_CHILDREN.has(block.name)) return html;
+	return appendChildren(html, children);
+}
+function renderWordPressBlocks(blocks) {
+	return blocks.map((block) => renderBlock(block)).join("");
+}
+//#endregion
+//#region frontend/src/site-language.ts
+/**
+* The `<html lang>` for a WordPress locale: its language and region as a
+* BCP 47 tag (pt_PT_ao90 → pt-PT). WordPress's variants (ao90, formal) aren't
+* BCP 47 subtags, so they are left out; no locale means English.
+*/
+function htmlLang(locale) {
+	if (!locale) return "en";
+	return locale.split("_").slice(0, 2).join("-");
+}
+/**
+* configuration's languages: wordpress.locale, the default, served at /, then
+* each of wordpress.languages under its slug. A monolingual Site has one.
+*/
+function siteLanguages(wordpress) {
+	const locale = wordpress?.locale ?? "";
+	const language = (locale, slug, isDefault) => ({
+		locale,
+		slug,
+		code: slug.toUpperCase().replaceAll("-", "_"),
+		lang: htmlLang(locale),
+		isDefault,
+		home: isDefault ? "/" : `/${slug}/`
+	});
+	return [language(locale, locale.split("_")[0] || "en", true), ...(wordpress?.languages ?? []).map(({ locale, slug }) => language(locale, slug, false))];
+}
+/**
+* A route's language: the one whose slug is its first segment, else the
+* default language, which has no directory.
+*/
+function routeLanguage(route, among) {
+	const segment = route.split("/")[1];
+	return among.find((language) => !language.isDefault && language.slug === segment) ?? among[0];
+}
+/**
+* How logs and reports name something a language has: "the front page" for
+* the default language's, "the en front page" for another's.
+*/
+function languageSubject(language, what) {
+	return language.isDefault ? `the ${what}` : `the ${language.slug} ${what}`;
+}
+/** Whether a route is a language's home (/, /en/): served as a home, never as an entry. */
+function isLanguageHome(route, among) {
+	return among.some((language) => language.home === route);
+}
+//#endregion
+//#region frontend/src/formatting.ts
+function responseStatus(delivery) {
+	if (delivery.kind === "found") return 200;
+	return delivery.kind === "missing" ? 404 : 503;
+}
+/**
+* WPGraphQL's GMT time ("2026-10-02T09:00:00", without a zone) in ms, or null
+* when it is absent or not a time.
+*/
+function cmsTime(value) {
+	if (!value) return null;
+	const time = Date.parse(/(Z|[+-]\d\d:?\d\d)$/.test(value) ? value : `${value}Z`);
+	return Number.isNaN(time) ? null : time;
+}
+/**
+* An entry's URI as a path. A CMS whose permalinks point at the Frontend gives
+* absolute URIs (`https://acme.example/team/`); only the path is the route.
+* Percent-encoding and the trailing slash are kept as WordPress gives them.
+*/
+function uriPath(uri) {
+	try {
+		return new URL(uri, "https://frontend.invalid").pathname;
+	} catch {
+		return uri;
+	}
+}
+function menuItemHref(url, internalOrigins) {
+	try {
+		const parsed = new URL(url, internalOrigins[0]);
+		if (!internalOrigins.includes(parsed.origin)) return url;
+		return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+	} catch {
+		return url;
+	}
+}
+function stripHtml(value) {
+	return value.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
+}
+function formatDate(value, lang = "en") {
+	return new Intl.DateTimeFormat(lang, {
+		day: "numeric",
+		month: "long",
+		year: "numeric"
+	}).format(new Date(value));
+}
+function routeOf(path) {
+	let route = path;
+	try {
+		route = decodeURI(path);
+	} catch {}
+	if (!route.startsWith("/")) route = `/${route}`;
+	return route.endsWith("/") ? route : `${route}/`;
+}
+//#endregion
+export { youtubeVideoId as _, routeOf as a, htmlLang as c, routeLanguage as d, siteLanguages as f, renderWordPressBlocks as g, parseWordPressBlocks as h, responseStatus as i, isLanguageHome as l, hasVideoHero as m, formatDate as n, stripHtml as o, VIDEO_HERO_BLOCK as p, menuItemHref as r, uriPath as s, cmsTime as t, languageSubject as u, containerChildLayoutHtml as v, containerLayoutHtml as y };

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+import { A as PublishedEntry, B as htmlLang, C as Delivery, D as Found, E as Extended, F as WordPressMenuItem, H as languageSubject, I as WordPressPost, L as WordPressSettings, M as Translation, N as Unavailable, O as HomeContent, P as WordPressImage, R as SiteLanguage, S as CmsFailureReason, T as EntryContent, U as routeLanguage, V as isLanguageHome, W as siteLanguages, _ as NotServed, a as ContentRuntime, b as SqlStatement, c as Alternate, d as EntryPage, f as EntryPublication, g as Moved, h as HomePublication, i as ContentExtension, j as SiteChrome, k as Missing, l as DeliveryFailureReason, m as HomePage, n as ContentConfig, o as ExtensionNode, p as HomeDelivery, r as ContentConsentConfig, t as WordPressClient, u as EntryDelivery, v as ContentBindings, w as DesignPresets, x as CmsFailure, y as SqlDatabase, z as WordPressLanguages } from "./wordpress-CUFb6YZZ.js";
+//#region frontend/src/wp-block-styles.d.ts
+export interface Preset {
+  slug: string;
+}
+export type SpacingPreset = Preset & {
+  size: string;
+};
+export type ColorPreset = Preset & {
+  color: string;
+};
+export interface BlockPresetStyles {
+  vars: Record<string, string>;
+  colorRules: string;
+}
+/**
+ * WordPress preset classes need the CMS palette as well as CSS variables.
+ * `scope` is the content's container (`.prose-wp` by default; another for
+ * content a Site renders itself).
+ */
+export declare function blockPresetStyles(spacingSizes: SpacingPreset[], colors: ColorPreset[], scope?: string): BlockPresetStyles;
+/**
+ * The design presets as WordPress defines them, on `:root`, for styles that
+ * read the palette and spacing from these variables outside the content's
+ * container. Presets with an invalid slug, or a value that could end the
+ * rule, are left out; "" without any.
+ */
+export declare function presetRootStyle(spacingSizes: SpacingPreset[], colors: ColorPreset[]): string;
+//#endregion
+//#region frontend/src/wp-block-renderer.d.ts
+export interface WordPressBlock {
+  name: string;
+  attributes?: Record<string, unknown>;
+  htmlContent?: string;
+  /** Complete server-rendered HTML; htmlContent may be only a container shell. */
+  dynamicContent?: string;
+  innerBlocks?: WordPressBlock[];
+}
+export declare const VIDEO_HERO_BLOCK = "getquick-design/video-hero";
+export declare function parseWordPressBlocks(value: unknown): WordPressBlock[];
+export declare function hasVideoHero(blocks: WordPressBlock[]): boolean;
+export declare function youtubeVideoId(value: string): string;
+export declare function renderWordPressBlocks(blocks: WordPressBlock[]): string;
+//#endregion
+//#region frontend/src/wp-container-layout.d.ts
+export type ContainerAttributes = Record<string, unknown>;
+/** WPGraphQL renders nested blocks independently. Restore the parent's resolved
+ * variables on direct container children without replacing their own layout. */
+export declare function containerChildLayoutHtml(html: string, parentHtml: string): string;
+/** Rendered CMS shells already carry resolved theme defaults. Saved shells need
+ * the same opt-in adapter; absent defaults deliberately fall back to no width.
+ */
+export declare function containerLayoutHtml(html: string, attributes: ContainerAttributes): string;
+//#endregion
+//#region frontend/src/formatting.d.ts
+export declare function responseStatus(delivery: {
+  kind: Delivery<unknown>["kind"];
+}): 200 | 404 | 503;
+/**
+ * WPGraphQL's GMT time ("2026-10-02T09:00:00", without a zone) in ms, or null
+ * when it is absent or not a time.
+ */
+export declare function cmsTime(value: string | null | undefined): number | null;
+/**
+ * An entry's URI as a path. A CMS whose permalinks point at the Frontend gives
+ * absolute URIs (`https://acme.example/team/`); only the path is the route.
+ * Percent-encoding and the trailing slash are kept as WordPress gives them.
+ */
+export declare function uriPath(uri: string): string;
+export declare function menuItemHref(url: string, internalOrigins: string[]): string;
+export declare function stripHtml(value: string): string;
+export declare function formatDate(value: string, lang?: string): string;
+export declare function routeOf(path: string): string;
+//#endregion
+export { Alternate, CmsFailure, CmsFailureReason, ContentBindings, type ContentConfig, type ContentConsentConfig, type ContentExtension, type ContentRuntime, Delivery, DeliveryFailureReason, DesignPresets, EntryContent, EntryDelivery, EntryPage, EntryPublication, Extended, type ExtensionNode, Found, HomeContent, HomeDelivery, HomePage, HomePublication, Missing, Moved, NotServed, PublishedEntry, SiteChrome, SiteLanguage, SqlDatabase, SqlStatement, Translation, Unavailable, type WordPressClient, WordPressImage, WordPressLanguages, WordPressMenuItem, WordPressPost, WordPressSettings, htmlLang, isLanguageHome, languageSubject, routeLanguage, siteLanguages };

package/dist/index.js

@@ -0,0 +1,39 @@
+import { _ as youtubeVideoId, a as routeOf, c as htmlLang, d as routeLanguage, f as siteLanguages, g as renderWordPressBlocks, h as parseWordPressBlocks, i as responseStatus, l as isLanguageHome, m as hasVideoHero, n as formatDate, o as stripHtml, p as VIDEO_HERO_BLOCK, r as menuItemHref, s as uriPath, t as cmsTime, u as languageSubject, v as containerChildLayoutHtml, y as containerLayoutHtml } from "./formatting-wOk2jz6J.js";
+//#region frontend/src/wp-block-styles.ts
+const validSlug = (slug) => /^[a-z0-9][a-z0-9-]*$/.test(slug);
+/** A CSS value safe inside a stylesheet: a color or length, nothing that ends a rule. */
+const safeValue = (value) => /^[#(),.%\w\s-]+$/.test(value);
+/** A selector for the content's container: classes, ids, elements and descendants. */
+const validScope = (scope) => /^[.#]?[A-Za-z][\w-]*(?:[ .#>][A-Za-z][\w-]*)*$/.test(scope);
+/**
+* WordPress preset classes need the CMS palette as well as CSS variables.
+* `scope` is the content's container (`.prose-wp` by default; another for
+* content a Site renders itself).
+*/
+function blockPresetStyles(spacingSizes, colors, scope = ".prose-wp") {
+	if (!validScope(scope)) throw new Error(`${JSON.stringify(scope)} isn't a container selector`);
+	const vars = {};
+	const colorRules = [];
+	for (const { slug, size } of spacingSizes) if (validSlug(slug)) vars[`--wp--preset--spacing--${slug}`] = size;
+	for (const { slug, color } of colors) {
+		if (!validSlug(slug)) continue;
+		vars[`--wp--preset--color--${slug}`] = color;
+		colorRules.push(`${scope} .has-${slug}-color{color:var(--wp--preset--color--${slug})}`, `${scope} .has-${slug}-background-color{background-color:var(--wp--preset--color--${slug})}`, `${scope} .has-${slug}-color.has-link-color a{color:var(--wp--preset--color--${slug})}`);
+	}
+	return {
+		vars,
+		colorRules: colorRules.join("\n")
+	};
+}
+/**
+* The design presets as WordPress defines them, on `:root`, for styles that
+* read the palette and spacing from these variables outside the content's
+* container. Presets with an invalid slug, or a value that could end the
+* rule, are left out; "" without any.
+*/
+function presetRootStyle(spacingSizes, colors) {
+	const declarations = [...spacingSizes.filter(({ slug, size }) => validSlug(slug) && safeValue(size)).map(({ slug, size }) => `--wp--preset--spacing--${slug}:${size}`), ...colors.filter(({ slug, color }) => validSlug(slug) && safeValue(color)).map(({ slug, color }) => `--wp--preset--color--${slug}:${color}`)];
+	return declarations.length ? `:root{${declarations.join(";")}}` : "";
+}
+//#endregion
+export { VIDEO_HERO_BLOCK, blockPresetStyles, cmsTime, containerChildLayoutHtml, containerLayoutHtml, formatDate, hasVideoHero, htmlLang, isLanguageHome, languageSubject, menuItemHref, parseWordPressBlocks, presetRootStyle, renderWordPressBlocks, responseStatus, routeLanguage, routeOf, siteLanguages, stripHtml, uriPath, youtubeVideoId };

package/dist/legal-C5Xiq59W.d.ts

@@ -0,0 +1,48 @@
+//#region frontend/src/consent/legal.d.ts
+/**
+ * LEGAL-1's Legal Contract, as gq-config publishes it (fixed in the consent
+ * execution record): per language, each assigned role's public URL, title and
+ * revision, plus the controller's identity.
+ */
+declare const LEGAL_ROLES: readonly ["privacy_policy", "cookie_policy", "terms_of_use", "legal_notice", "terms_of_sale", "returns_policy", "shipping_policy", "complaints_book", "dispute_resolution"];
+/** The roles every Site needs; commerce and Portuguese-consumer roles come from gq-config's `missingRequired`. */
+declare const REQUIRED_LEGAL_ROLES: readonly ["privacy_policy", "cookie_policy"];
+interface LegalRole {
+  role: string;
+  url: string;
+  title: string | null;
+  revision: string | null;
+  isFallback: boolean;
+}
+interface LegalController {
+  name: string | null;
+  privacyEmail: string | null;
+  dpoContact: string | null;
+}
+/** One language's part of the Contract: what a content Site stores in that language's chrome. */
+interface LegalLanguage {
+  controller: LegalController;
+  roles: LegalRole[];
+  missingRequired: string[];
+}
+interface LegalContract {
+  schemaVersion: 1;
+  controller: LegalController;
+  languages: Record<string, {
+    roles: LegalRole[];
+  }>;
+  missingRequired: string[];
+}
+/**
+ * One language's Contract from untrusted input (GraphQL or the storefront
+ * payload): unknown roles, unsafe URLs and malformed entries are dropped.
+ */
+declare function parseLegalLanguage(value: unknown): LegalLanguage | null;
+/**
+ * The LEGAL-1 revisions in force on a page, recorded with each decision
+ * (CN-R7). A revision the record schema can't hold is left out rather than
+ * making every record invalid.
+ */
+declare function legalRevisions(legal: LegalLanguage | null | undefined): Record<string, string>;
+//#endregion
+export { REQUIRED_LEGAL_ROLES as a, LegalRole as i, LegalContract as n, legalRevisions as o, LegalLanguage as r, parseLegalLanguage as s, LEGAL_ROLES as t };

package/dist/migrations.d.ts

@@ -0,0 +1,4 @@
+//#region frontend/src/migrations.d.ts
+/** Infrastructure only: SQL shipped alongside the installed package. */
+export declare const migrationsDirectory: string;
+//#endregion

package/dist/migrations.js

@@ -0,0 +1,6 @@
+import { fileURLToPath } from "node:url";
+//#region frontend/src/migrations.ts
+/** Infrastructure only: SQL shipped alongside the installed package. */
+const migrationsDirectory = fileURLToPath(new URL("../migrations/", import.meta.url));
+//#endregion
+export { migrationsDirectory };

package/dist/paths-Cmzzof3v.js

@@ -0,0 +1,5 @@
+//#region frontend/src/consent/paths.ts
+/** The same-origin consent endpoint on the Site's Frontend Worker (fixed interface). */
+const CONSENT_PATH = "/gq/consent";
+//#endregion
+export { CONSENT_PATH as t };

package/dist/records-CACA2O0Q.d.ts

@@ -0,0 +1,56 @@
+import { i as ConsentAction, o as ConsentDecisions, s as ConsentState } from "./state-Dzd52F3c.js";
+//#region frontend/src/consent/records.d.ts
+/**
+ * A stored consent record (CN-R7), as the read endpoint returns it. No IP
+ * address, user agent or account link exists in it.
+ */
+interface ConsentRecord {
+  consentId: string;
+  siteId: string;
+  /** Server UTC timestamp (ISO 8601). */
+  recordedAt: string;
+  configVersion: string;
+  /** LEGAL-1 page revisions in force: role → revision. */
+  legalRevisions: Record<string, string>;
+  decisions: ConsentDecisions;
+  action: ConsentAction;
+  /** The banner language (BCP 47). */
+  language: string;
+  uiVersion: string;
+}
+/**
+ * What the browser posts to `POST /gq/consent`. The server adds the Site ID and
+ * its own timestamp. `decidedAt` identifies the decision, so a retried post
+ * appends nothing twice.
+ */
+interface ConsentRecordRequest {
+  consentId: string;
+  decidedAt: string;
+  configVersion: string;
+  legalRevisions: Record<string, string>;
+  decisions: ConsentDecisions;
+  action: ConsentAction;
+  language: string;
+  uiVersion: string;
+}
+/** The largest record body the endpoint accepts (CN-R9). */
+declare const MAX_RECORD_BYTES = 2048;
+declare function consentRecordRequest(state: ConsentState, action: ConsentAction, context: {
+  language: string;
+  uiVersion: string;
+  legalRevisions?: Record<string, string>;
+}): ConsentRecordRequest;
+/** Whether a value can be recorded as a legal role (the record schema's rule). */
+declare const isLegalRoleName: (value: unknown) => value is string;
+/** Whether a value can be recorded as a revision or UI version: a short token. */
+declare const isRecordToken: (value: unknown) => value is string;
+/** A strict parse of a record request: exactly its fields, each bounded. */
+declare function parseConsentRecordRequest(value: unknown): {
+  ok: true;
+  request: ConsentRecordRequest;
+} | {
+  ok: false;
+  error: string;
+};
+//#endregion
+export { isLegalRoleName as a, consentRecordRequest as i, ConsentRecordRequest as n, isRecordToken as o, MAX_RECORD_BYTES as r, parseConsentRecordRequest as s, ConsentRecord as t };

package/dist/records-Dumrz759.js

@@ -0,0 +1,74 @@
+import { l as isConsentId, t as CONSENT_ACTIONS, x as OPTIONAL_CATEGORIES } from "./state-BYWc5TUB.js";
+//#region frontend/src/consent/records.ts
+/** The largest record body the endpoint accepts (CN-R9). */
+const MAX_RECORD_BYTES = 2048;
+function consentRecordRequest(state, action, context) {
+	return {
+		consentId: state.consentId,
+		decidedAt: new Date(state.decidedAt).toISOString(),
+		configVersion: state.version,
+		legalRevisions: context.legalRevisions ?? {},
+		decisions: { ...state.decisions },
+		action,
+		language: context.language,
+		uiVersion: context.uiVersion
+	};
+}
+const KEYS = [
+	"consentId",
+	"decidedAt",
+	"configVersion",
+	"legalRevisions",
+	"decisions",
+	"action",
+	"language",
+	"uiVersion"
+];
+const TOKEN = /^[A-Za-z0-9._:@/+-]{1,64}$/;
+const ROLE = /^[a-z_]{1,32}$/;
+/** Whether a value can be recorded as a legal role (the record schema's rule). */
+const isLegalRoleName = (value) => typeof value === "string" && ROLE.test(value);
+/** Whether a value can be recorded as a revision or UI version: a short token. */
+const isRecordToken = (value) => typeof value === "string" && TOKEN.test(value);
+const LANGUAGE = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,2}$/;
+const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+/** A strict parse of a record request: exactly its fields, each bounded. */
+function parseConsentRecordRequest(value) {
+	const fail = (error) => ({
+		ok: false,
+		error
+	});
+	if (!value || typeof value !== "object" || Array.isArray(value)) return fail("not an object");
+	const body = value;
+	const extra = Object.keys(body).filter((key) => !KEYS.includes(key));
+	if (extra.length) return fail(`unexpected fields: ${extra.join(", ")}`);
+	if (!isConsentId(body.consentId)) return fail("consentId must be a UUID v4");
+	if (typeof body.decidedAt !== "string" || !ISO.test(body.decidedAt)) return fail("decidedAt must be an ISO 8601 UTC time");
+	if (typeof body.configVersion !== "string" || !/^[0-9a-f]{8,64}$/.test(body.configVersion)) return fail("configVersion must be a hex hash");
+	if (typeof body.action !== "string" || !CONSENT_ACTIONS.includes(body.action)) return fail("action is not a consent action");
+	if (typeof body.language !== "string" || !LANGUAGE.test(body.language)) return fail("language must be a BCP 47 tag");
+	if (typeof body.uiVersion !== "string" || !TOKEN.test(body.uiVersion)) return fail("uiVersion must be a short token");
+	const decisions = body.decisions;
+	if (!decisions || typeof decisions !== "object" || Array.isArray(decisions)) return fail("decisions must be an object");
+	if (Object.keys(decisions).length !== OPTIONAL_CATEGORIES.length || !OPTIONAL_CATEGORIES.every((category) => typeof decisions[category] === "boolean")) return fail("decisions must have exactly the four optional categories, as booleans");
+	const revisions = body.legalRevisions;
+	if (!revisions || typeof revisions !== "object" || Array.isArray(revisions)) return fail("legalRevisions must be an object");
+	const roles = Object.entries(revisions);
+	if (roles.length > 16) return fail("too many legal revisions");
+	for (const [role, revision] of roles) if (!isLegalRoleName(role) || !isRecordToken(revision)) return fail("legalRevisions must map roles to short revision tokens");
+	return {
+		ok: true,
+		request: {
+			consentId: body.consentId,
+			decidedAt: body.decidedAt,
+			configVersion: body.configVersion,
+			legalRevisions: Object.fromEntries(roles),
+			decisions: Object.fromEntries(OPTIONAL_CATEGORIES.map((category) => [category, decisions[category]])),
+			action: body.action,
+			language: body.language,
+			uiVersion: body.uiVersion
+		}
+	};
+}
+//#endregion
+export { parseConsentRecordRequest as a, isRecordToken as i, consentRecordRequest as n, isLegalRoleName as r, MAX_RECORD_BYTES as t };

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+import { a as ContentRuntime, i as ContentExtension, n as ContentConfig, o as ExtensionNode, r as ContentConsentConfig, s as createContentRuntime, t as WordPressClient, v as ContentBindings } from "./wordpress-CUFb6YZZ.js";
+export { type ContentBindings, ContentConfig, ContentConsentConfig, ContentExtension, ContentRuntime, ExtensionNode, type WordPressClient, createContentRuntime };