@getquick/content 0.3.1 → 0.4.0

package/dist/forms-server.js

@@ -0,0 +1,294 @@
+import { c as formDiagnostics, t as FORMS_PATH } from "./descriptor-x8kHFQ79.js";
+import { n as readBoundedBody, t as isSameOrigin } from "./request-guards-BUPr_vA4.js";
+import { n as honeypotFilled, r as validateSubmission } from "./validate-wRgYUNxN.js";
+import { c as formStateLocation, n as formsCopyLanguage, o as formStateCookie, t as FORMS_COPY } from "./copy-DLto_bWj.js";
+//#region frontend/src/forms/server.ts
+/** The largest form body accepted (bytes); larger posts are refused unread. */
+const MAX_FORM_BYTES = 65536;
+/** Cloudflare's server-side Turnstile verification. */
+const TURNSTILE_SITEVERIFY_URL = "https://challenges.cloudflare.com/turnstile/v0/siteverify";
+/** The field Turnstile's widget posts its token in. */
+const TURNSTILE_RESPONSE_FIELD = "cf-turnstile-response";
+const SOURCE = /^\/(?!\/)[^\s\\]*$/;
+/** HTML as text: tags dropped, paragraphs and breaks as new lines, entities decoded. */
+function htmlText(html) {
+	return html.replace(/<(script|style)\b[\s\S]*?<\/\1>/gi, "").replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div|li|h[1-6])>/gi, "\n\n").replace(/<[^>]*>/g, "").replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code))).replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16))).replace(/&nbsp;/g, " ").replace(/&quot;/g, "\"").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim().slice(0, 2e3);
+}
+/**
+* The form endpoint. `handle` answers `POST /gq/forms/<id>` and null for any
+* other path; `check` says what is configured, for readiness, never values.
+*/
+function createFormsServer(config) {
+	const cms = new URL(config.cmsOrigin);
+	if (cms.protocol !== "https:" && cms.protocol !== "http:") throw new Error("cmsOrigin must be the CMS's http(s) origin");
+	const restRoot = (config.restRoot ?? `${cms.origin}/wp-json`).replace(/\/+$/, "");
+	if (new URL(restRoot).origin !== cms.origin) throw new Error("restRoot must be on the CMS's origin");
+	const origins = new Set((config.siteOrigins ?? []).map((origin) => new URL(origin).origin));
+	const timeoutMs = config.timeoutMs ?? 15e3;
+	const fetcher = config.fetch ?? globalThis.fetch.bind(globalThis);
+	const copy = FORMS_COPY[formsCopyLanguage(config.language)];
+	const turnstileRequired = config.spam?.turnstile === true;
+	const wantsJson = (request) => {
+		const accept = request.headers.get("Accept") ?? "";
+		return /\bapplication\/json\b/i.test(accept) && !/\btext\/html\b/i.test(accept);
+	};
+	const json = (status, body, headers = {}) => Response.json(body, {
+		status,
+		headers: {
+			"Cache-Control": "no-store",
+			...headers
+		}
+	});
+	/** The Access pair, if both are set; "partial" is a misconfiguration and fails closed. */
+	function accessHeaders(bindings) {
+		const id = bindings.GQ_FORMS_ACCESS_CLIENT_ID?.trim() ?? "";
+		const secret = bindings.GQ_FORMS_ACCESS_CLIENT_SECRET?.trim() ?? "";
+		if (!id && !secret) return {};
+		if (!id || !secret) return "partial";
+		return {
+			"CF-Access-Client-Id": id,
+			"CF-Access-Client-Secret": secret
+		};
+	}
+	/** The answer to a post: JSON for a script that asks for it, else a redirect back. */
+	function outcome(request, state, source) {
+		const full = {
+			values: {},
+			messages: {},
+			errors: {},
+			...state
+		};
+		if (wantsJson(request)) return json({
+			sent: 200,
+			invalid: 422,
+			verification: 422,
+			"too-many": 429,
+			failed: 502
+		}[full.status], {
+			status: full.status,
+			errors: Object.fromEntries(Object.entries(full.errors).map(([id, code]) => [id, full.messages[Number(id)] ?? copy.errors[code]])),
+			...full.confirmation ? { confirmation: full.confirmation } : {}
+		});
+		return new Response(null, {
+			status: 303,
+			headers: {
+				Location: formStateLocation(source, full.formId),
+				"Set-Cookie": formStateCookie(full, { secure: new URL(request.url).protocol === "https:" }),
+				"Cache-Control": "no-store"
+			}
+		});
+	}
+	async function verifyTurnstile(secret, token, ip) {
+		const body = new URLSearchParams({
+			secret,
+			response: token
+		});
+		if (ip) body.set("remoteip", ip);
+		try {
+			const response = await fetcher(TURNSTILE_SITEVERIFY_URL, {
+				method: "POST",
+				body,
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+			if (!response.ok) return false;
+			return (await response.json()).success === true;
+		} catch (error) {
+			console.error(`Forms: Turnstile couldn't be verified: ${error.name}`);
+			return false;
+		}
+	}
+	/** Gravity Forms' field messages, by field id. */
+	function fieldMessages(value) {
+		if (!value || typeof value !== "object") return {};
+		return Object.fromEntries(Object.entries(value).flatMap(([id, message]) => /^\d+$/.test(id) && typeof message === "string" && message ? [[Number(id), htmlText(message)]] : []));
+	}
+	async function submit(request, formId, source, params) {
+		const bindings = await config.bindings();
+		let descriptor;
+		try {
+			descriptor = await config.descriptor({
+				formId,
+				source
+			});
+		} catch (error) {
+			console.error(`Forms: form ${formId}'s descriptor couldn't be read: ${error.message}`);
+			descriptor = null;
+		}
+		if (!descriptor || descriptor.id !== formId || !descriptor.available) return outcome(request, {
+			formId,
+			status: "failed"
+		}, source);
+		const diagnostics = formDiagnostics(descriptor);
+		if (diagnostics.length) {
+			console.error(`Forms: form ${formId} isn't submitted: ${diagnostics.map((each) => each.code).join(", ")}`);
+			return outcome(request, {
+				formId,
+				status: "failed"
+			}, source);
+		}
+		const sent = {
+			formId,
+			status: "sent",
+			...descriptor.confirmation.type === "message" && descriptor.confirmation.message ? { confirmation: descriptor.confirmation.message } : {}
+		};
+		if (honeypotFilled(descriptor, params)) return outcome(request, sent, source);
+		const checked = validateSubmission(descriptor, params);
+		if (Object.keys(checked.errors).length) return outcome(request, {
+			formId,
+			status: "invalid",
+			errors: checked.errors,
+			values: checked.values
+		}, source);
+		if (turnstileRequired) {
+			const secret = bindings.TURNSTILE_SECRET_KEY?.trim();
+			if (!secret) {
+				console.error("Forms: Turnstile is required but TURNSTILE_SECRET_KEY isn't bound");
+				return outcome(request, {
+					formId,
+					status: "failed",
+					values: checked.values
+				}, source);
+			}
+			const token = params.get("cf-turnstile-response") ?? "";
+			if (!token || token.length > 2048 || !await verifyTurnstile(secret, token, request.headers.get("CF-Connecting-IP"))) return outcome(request, {
+				formId,
+				status: "verification",
+				values: checked.values
+			}, source);
+		}
+		const access = accessHeaders(bindings);
+		if (access === "partial") {
+			console.error("Forms: set both GQ_FORMS_ACCESS_CLIENT_ID and GQ_FORMS_ACCESS_CLIENT_SECRET, or neither");
+			return outcome(request, {
+				formId,
+				status: "failed",
+				values: checked.values
+			}, source);
+		}
+		let response;
+		try {
+			response = await fetcher(`${restRoot}/gf/v2/forms/${formId}/submissions`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Accept: "application/json",
+					...access
+				},
+				body: JSON.stringify(checked.input),
+				redirect: "manual",
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+		} catch (error) {
+			console.error(`Forms: form ${formId} couldn't reach the CMS: ${error.name}`);
+			return outcome(request, {
+				formId,
+				status: "failed",
+				values: checked.values
+			}, source);
+		}
+		let result = null;
+		try {
+			result = await response.json();
+		} catch {
+			result = null;
+		}
+		if (response.status === 200 && result?.is_valid === true) {
+			if (result.confirmation_type === "redirect" && typeof result.confirmation_redirect === "string") {
+				let target = null;
+				try {
+					target = new URL(result.confirmation_redirect);
+				} catch {
+					target = null;
+				}
+				if (target && target.origin === cms.origin) target = new URL(`${target.pathname}${target.search}${target.hash}`, request.url);
+				if (target && (target.protocol === "https:" || target.protocol === "http:")) {
+					const location = target.origin === new URL(request.url).origin ? `${target.pathname}${target.search}${target.hash}` : target.href;
+					if (wantsJson(request)) return json(200, {
+						status: "sent",
+						redirect: location
+					});
+					return new Response(null, {
+						status: 303,
+						headers: {
+							Location: location,
+							"Cache-Control": "no-store"
+						}
+					});
+				}
+			}
+			const message = typeof result.confirmation_message === "string" ? htmlText(result.confirmation_message) : "";
+			return outcome(request, {
+				formId,
+				status: "sent",
+				...message ? { confirmation: message } : sent
+			}, source);
+		}
+		if (response.status === 400 && result?.is_valid === false) {
+			const messages = fieldMessages(result.validation_messages);
+			return outcome(request, {
+				formId,
+				status: "invalid",
+				errors: Object.fromEntries(Object.keys(messages).map((id) => [Number(id), "required"])),
+				messages,
+				values: checked.values
+			}, source);
+		}
+		console.error(`Forms: Gravity Forms refused form ${formId} (HTTP ${response.status})`);
+		return outcome(request, {
+			formId,
+			status: "failed",
+			values: checked.values
+		}, source);
+	}
+	/** `POST /gq/forms/<id>`. */
+	async function handlePost(request, formId) {
+		if (request.method !== "POST") return json(405, { error: "Send forms with POST." }, { Allow: "POST" });
+		if (!isSameOrigin(request, origins)) return json(403, { error: "Forms are accepted from this Site only." });
+		if (!/^application\/x-www-form-urlencoded\b/i.test(request.headers.get("Content-Type") ?? "")) return json(415, { error: "Send the form as application/x-www-form-urlencoded." });
+		const bindings = await config.bindings();
+		const text = await readBoundedBody(request, MAX_FORM_BYTES);
+		if (text === null) return json(413, { error: "The form is too large." });
+		const params = new URLSearchParams(text);
+		const source = params.get("gq_source") ?? "";
+		if (!SOURCE.test(source) || source.length > 2048) return json(400, { error: "The form's page (gq_source) isn't a path on this Site." });
+		const limiter = bindings.FORMS_RATE_LIMITER;
+		if (limiter) {
+			const { success } = await limiter.limit({ key: `${formId}:${request.headers.get("CF-Connecting-IP") ?? "unknown"}` });
+			if (!success) return outcome(request, {
+				formId,
+				status: "too-many"
+			}, source);
+		}
+		return submit(request, formId, source, params);
+	}
+	/** Routes a form post; null when the path isn't a form endpoint. */
+	async function handle(request) {
+		const path = new URL(request.url).pathname.replace(/\/+$/, "");
+		if (!path.startsWith(`/gq/forms/`)) return null;
+		const id = path.slice(FORMS_PATH.length + 1);
+		if (!/^[1-9]\d{0,8}$/.test(id)) return null;
+		return handlePost(request, Number(id));
+	}
+	/** What is configured, for readiness: never values. */
+	async function check() {
+		const bindings = await config.bindings();
+		const access = accessHeaders(bindings);
+		return {
+			cmsOrigin: cms.origin,
+			spam: {
+				honeypot: true,
+				turnstile: turnstileRequired
+			},
+			turnstileSecret: Boolean(bindings.TURNSTILE_SECRET_KEY?.trim()),
+			access: access === "partial" ? "partial" : Object.keys(access).length ? "configured" : "none",
+			rateLimit: Boolean(bindings.FORMS_RATE_LIMITER),
+			ready: (!turnstileRequired || Boolean(bindings.TURNSTILE_SECRET_KEY?.trim())) && access !== "partial"
+		};
+	}
+	return {
+		handle,
+		check
+	};
+}
+//#endregion
+export { FORMS_PATH, MAX_FORM_BYTES, TURNSTILE_RESPONSE_FIELD, TURNSTILE_SITEVERIFY_URL, createFormsServer, htmlText };

package/dist/forms-testing.d.ts

@@ -0,0 +1,66 @@
+import { o as FormDescriptor } from "./descriptor-B-e7gHi1.js";
+//#region frontend/src/forms/testing.d.ts
+/** A contact form like Nomia's form 1: name, email, subject, message and privacy consent. */
+export declare const CONTACT_FORM: FormDescriptor;
+/** A form readiness must fail: Gravity Forms' CAPTCHA, a file upload, a payment field and a page break. */
+export declare const UNSUPPORTED_FORM: FormDescriptor;
+/** A referenced form that is missing, inactive or trashed. */
+export declare const UNAVAILABLE_FORM: FormDescriptor;
+/** Keys that must never appear anywhere in a delivered descriptor. */
+export declare const PRIVATE_FORM_KEYS: readonly ["notifications", "notification", "confirmations", "entries", "entry", "entry_id", "feeds", "feed", "settings", "personalData", "routing", "to", "bcc", "from", "fromName", "replyTo", "save", "limitEntries", "scheduleForm", "requireLogin", "consumer_key", "consumer_secret"];
+/**
+ * Throws unless a delivered descriptor is public: it parses, and nothing in it
+ * is a notification, entry, feed or admin setting (by key, at any depth).
+ */
+export declare function assertPublicDescriptor(value: unknown): FormDescriptor;
+/**
+ * Throws unless rendered form HTML is accessible: every visible control has a
+ * label (`for`) or is in a labelled fieldset, every `aria-describedby` id
+ * exists, invalid controls are described by their error, an error summary is
+ * an alert and a confirmation is a status.
+ */
+export declare function assertAccessibleForm(html: string): void;
+/** A request Gravity Forms' stand-in received. */
+export interface RecordedRequest {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  body: Record<string, string> | null;
+}
+export interface StoredEntry {
+  formId: number;
+  values: Record<string, string>;
+  spam: boolean;
+}
+/**
+ * A stand-in for Gravity Forms' REST API on a CMS: `POST
+ * /wp-json/gf/v2/forms/<id>/submissions` as Gravity Forms 3.2 answers it,
+ * validating required fields and storing entries for the given descriptors.
+ * A filled honeypot is stored as spam, Gravity Forms' default honeypot
+ * action. Anything else is a 404. `requests` records every request.
+ */
+export declare function gravityFormsStub(forms: readonly FormDescriptor[]): {
+  entries: StoredEntry[];
+  requests: RecordedRequest[];
+  handle: (request: Request) => Promise<Response>;
+  /** A `fetch` that answers the CMS's requests at `origin` and refuses any other. */
+  fetchFor(origin: string): typeof globalThis.fetch;
+};
+/** Throws if any request asked for entries, or carried a Gravity Forms credential. */
+export declare function assertNoEntryReadsOrCredentials(requests: readonly RecordedRequest[]): void;
+/** Throws if a module exports anything that reads entries (by name; these assertions aside). */
+export declare function assertNoEntryExports(module: Record<string, unknown>): void;
+/** A form body as a browser posts it (application/x-www-form-urlencoded). */
+export declare function formBody(values: Record<string, string>): string;
+/** A filled-in, valid submission of CONTACT_FORM from `source`. */
+export declare function contactSubmission(source?: string): Record<string, string>;
+/** Cloudflare's Turnstile test keys: always pass, always fail. */
+export declare const TURNSTILE_TEST_KEYS: {
+  readonly passingSiteKey: "1x00000000000000000000AA";
+  readonly failingSiteKey: "2x00000000000000000000AB";
+  readonly passingSecretKey: "1x0000000000000000000000000000000AA";
+  readonly failingSecretKey: "2x0000000000000000000000000000000AA";
+  /** The token the test site keys produce. */
+  readonly dummyToken: "XXXX.DUMMY.TOKEN.XXXX";
+};
+//#endregion

package/dist/forms-testing.js

@@ -0,0 +1,334 @@
+import { u as parseFormDescriptor } from "./descriptor-x8kHFQ79.js";
+//#region frontend/src/forms/testing.ts
+/** A contact form like Nomia's form 1: name, email, subject, message and privacy consent. */
+const CONTACT_FORM = {
+	schema: 1,
+	id: 1,
+	available: true,
+	title: "Contactos",
+	description: "Envie-nos uma mensagem.",
+	submitLabel: "Enviar",
+	fields: [
+		{
+			id: 1,
+			type: "name",
+			label: "Nome",
+			description: "",
+			required: true,
+			visibility: "visible",
+			inputs: [{
+				id: "1.3",
+				name: "input_1_3",
+				label: "Nome próprio",
+				autocomplete: "given-name"
+			}, {
+				id: "1.6",
+				name: "input_1_6",
+				label: "Apelido",
+				autocomplete: "family-name"
+			}]
+		},
+		{
+			id: 2,
+			type: "email",
+			label: "Email",
+			description: "",
+			required: true,
+			visibility: "visible",
+			inputs: [{
+				id: "2",
+				name: "input_2",
+				label: "Email"
+			}]
+		},
+		{
+			id: 3,
+			type: "text",
+			label: "Assunto",
+			description: "",
+			required: false,
+			visibility: "visible",
+			maxLength: 120,
+			inputs: [{
+				id: "3",
+				name: "input_3",
+				label: "Assunto"
+			}]
+		},
+		{
+			id: 4,
+			type: "textarea",
+			label: "Mensagem",
+			description: "",
+			required: true,
+			visibility: "visible",
+			inputs: [{
+				id: "4",
+				name: "input_4",
+				label: "Mensagem"
+			}]
+		},
+		{
+			id: 5,
+			type: "consent",
+			label: "Privacidade",
+			description: "",
+			required: true,
+			visibility: "visible",
+			inputs: [
+				{
+					id: "5.1",
+					name: "input_5_1",
+					label: "Consentimento"
+				},
+				{
+					id: "5.2",
+					name: "input_5_2",
+					label: "Texto"
+				},
+				{
+					id: "5.3",
+					name: "input_5_3",
+					label: "Descrição"
+				}
+			],
+			consent: {
+				checkboxLabel: "Aceito o tratamento dos meus dados para responder a este contacto.",
+				description: "Os dados são usados apenas para responder à sua mensagem.",
+				revisionId: "7"
+			}
+		}
+	],
+	honeypot: { name: "input_6" },
+	confirmation: {
+		type: "message",
+		message: "Obrigado pelo seu contacto."
+	},
+	diagnostics: []
+};
+/** A form readiness must fail: Gravity Forms' CAPTCHA, a file upload, a payment field and a page break. */
+const UNSUPPORTED_FORM = {
+	...CONTACT_FORM,
+	id: 2,
+	title: "Candidatura",
+	fields: CONTACT_FORM.fields.slice(0, 2),
+	diagnostics: [
+		{
+			code: "unsupported-captcha",
+			fieldId: 10,
+			type: "captcha",
+			message: "CAPTCHA"
+		},
+		{
+			code: "unsupported-file-upload",
+			fieldId: 11,
+			type: "fileupload",
+			message: "File upload"
+		},
+		{
+			code: "unsupported-payment",
+			fieldId: 12,
+			type: "product",
+			message: "Payment"
+		},
+		{
+			code: "unsupported-multi-page",
+			fieldId: 13,
+			type: "page",
+			message: "Multi-page"
+		}
+	]
+};
+/** A referenced form that is missing, inactive or trashed. */
+const UNAVAILABLE_FORM = {
+	...CONTACT_FORM,
+	id: 3,
+	available: false,
+	fields: [],
+	honeypot: null,
+	diagnostics: [{
+		code: "unavailable",
+		message: "Form 3 is inactive."
+	}]
+};
+/** Keys that must never appear anywhere in a delivered descriptor. */
+const PRIVATE_FORM_KEYS = [
+	"notifications",
+	"notification",
+	"confirmations",
+	"entries",
+	"entry",
+	"entry_id",
+	"feeds",
+	"feed",
+	"settings",
+	"personalData",
+	"routing",
+	"to",
+	"bcc",
+	"from",
+	"fromName",
+	"replyTo",
+	"save",
+	"limitEntries",
+	"scheduleForm",
+	"requireLogin",
+	"consumer_key",
+	"consumer_secret"
+];
+function keysOf(value, path = "", found = []) {
+	if (Array.isArray(value)) value.forEach((each, index) => keysOf(each, `${path}[${index}]`, found));
+	else if (typeof value === "object" && value !== null) for (const [key, each] of Object.entries(value)) {
+		found.push(`${path}.${key}`);
+		keysOf(each, `${path}.${key}`, found);
+	}
+	return found;
+}
+/**
+* Throws unless a delivered descriptor is public: it parses, and nothing in it
+* is a notification, entry, feed or admin setting (by key, at any depth).
+*/
+function assertPublicDescriptor(value) {
+	const descriptor = parseFormDescriptor(value);
+	if (!descriptor) throw new Error("Not a form descriptor");
+	const forbidden = keysOf(value).filter((path) => PRIVATE_FORM_KEYS.includes(path.slice(path.lastIndexOf(".") + 1)));
+	if (forbidden.length) throw new Error(`The descriptor carries private form data: ${forbidden.join(", ")}`);
+	return descriptor;
+}
+/**
+* Throws unless rendered form HTML is accessible: every visible control has a
+* label (`for`) or is in a labelled fieldset, every `aria-describedby` id
+* exists, invalid controls are described by their error, an error summary is
+* an alert and a confirmation is a status.
+*/
+function assertAccessibleForm(html) {
+	const ids = new Set([...html.matchAll(/\sid="([^"]+)"/g)].map((match) => match[1]));
+	const labelled = new Set([...html.matchAll(/<label[^>]*\sfor="([^"]+)"/g)].map((m) => m[1]));
+	const problems = [];
+	for (const match of html.matchAll(/<(input|select|textarea)\b([^>]*)>/g)) {
+		const attributes = match[2];
+		if (/\stype="hidden"/.test(attributes)) continue;
+		const id = /\sid="([^"]+)"/.exec(attributes)?.[1];
+		if (!id || !labelled.has(id)) problems.push(`a ${match[1]} without a label (${id ?? "no id"})`);
+		const describedBy = /\saria-describedby="([^"]+)"/.exec(attributes)?.[1];
+		for (const reference of describedBy?.split(/\s+/) ?? []) if (!ids.has(reference)) problems.push(`${id} is described by a missing #${reference}`);
+		if (/\saria-invalid="true"/.test(attributes) && !/-error\b/.test(describedBy ?? "")) problems.push(`${id} is invalid without its error in aria-describedby`);
+	}
+	if (/gq-form__errors/.test(html) && !/class="gq-form__errors" role="alert"/.test(html)) problems.push("the error summary isn't an alert");
+	if (/gq-form__status--sent/.test(html) && !/gq-form__status--sent" role="status"/.test(html)) problems.push("the confirmation isn't a status message");
+	if (/<form\b/.test(html) && !/<button type="submit"/.test(html)) problems.push("the form has no submit button");
+	if (problems.length) throw new Error(`Inaccessible form: ${problems.join("; ")}`);
+}
+/**
+* A stand-in for Gravity Forms' REST API on a CMS: `POST
+* /wp-json/gf/v2/forms/<id>/submissions` as Gravity Forms 3.2 answers it,
+* validating required fields and storing entries for the given descriptors.
+* A filled honeypot is stored as spam, Gravity Forms' default honeypot
+* action. Anything else is a 404. `requests` records every request.
+*/
+function gravityFormsStub(forms) {
+	const entries = [];
+	const requests = [];
+	async function handle(request) {
+		const url = new URL(request.url);
+		let body = null;
+		try {
+			body = request.method === "POST" ? await request.json() : null;
+		} catch {
+			body = null;
+		}
+		requests.push({
+			method: request.method,
+			url: url.pathname + url.search,
+			headers: Object.fromEntries(request.headers),
+			body
+		});
+		const match = /^\/wp-json\/gf\/v2\/forms\/(\d+)\/submissions$/.exec(url.pathname);
+		const form = match && forms.find((each) => each.id === Number(match[1]));
+		if (!match || request.method !== "POST") return Response.json({ code: "rest_no_route" }, { status: 404 });
+		if (!form || !form.available) return Response.json({
+			code: "form_not_found",
+			message: "Your form could not be found"
+		}, { status: 400 });
+		const values = body ?? {};
+		const messages = {};
+		for (const field of form.fields) {
+			if (!field.required) continue;
+			if ((field.type === "consent" ? [field.inputs[0].name] : field.inputs.map((input) => input.name)).every((name) => !values[name])) messages[field.id] = "This field is required.";
+		}
+		if (Object.keys(messages).length) return Response.json({
+			is_valid: false,
+			validation_messages: messages,
+			page_number: 1,
+			source_page_number: 1
+		}, { status: 400 });
+		const spam = Boolean(form.honeypot && values[form.honeypot.name]);
+		entries.push({
+			formId: form.id,
+			values,
+			spam
+		});
+		return Response.json({
+			is_valid: true,
+			page_number: 0,
+			source_page_number: 1,
+			confirmation_type: "message",
+			confirmation_message: `<div id='gform_confirmation_wrapper_${form.id}' class='gform_confirmation_wrapper '><div id='gform_confirmation_message_${form.id}' class='gform_confirmation_message_${form.id} gform_confirmation_message'>${form.confirmation.type === "message" ? form.confirmation.message : ""}</div></div>`,
+			is_spam: spam
+		});
+	}
+	return {
+		entries,
+		requests,
+		handle,
+		/** A `fetch` that answers the CMS's requests at `origin` and refuses any other. */
+		fetchFor(origin) {
+			return async (input, init) => {
+				const request = new Request(input, init);
+				if (new URL(request.url).origin !== origin) throw new TypeError(`Unexpected request to ${new URL(request.url).origin}`);
+				return handle(request);
+			};
+		}
+	};
+}
+/** Throws if any request asked for entries, or carried a Gravity Forms credential. */
+function assertNoEntryReadsOrCredentials(requests) {
+	for (const request of requests) {
+		if (/\/entries\b/.test(request.url)) throw new Error(`An entry read reached the CMS: ${request.method} ${request.url}`);
+		if (request.headers.authorization) throw new Error(`A credential reached the CMS: ${request.method} ${request.url}`);
+		if (/consumer_(key|secret)|oauth_/i.test(request.url)) throw new Error(`A consumer key reached the CMS: ${request.method} ${request.url}`);
+	}
+}
+/** Throws if a module exports anything that reads entries (by name; these assertions aside). */
+function assertNoEntryExports(module) {
+	const names = Object.keys(module).filter((name) => /entr(y|ies)/i.test(name) && !name.startsWith("assertNo"));
+	if (names.length) throw new Error(`Exports that read entries: ${names.join(", ")}`);
+}
+/** A form body as a browser posts it (application/x-www-form-urlencoded). */
+function formBody(values) {
+	return new URLSearchParams(values).toString();
+}
+/** A filled-in, valid submission of CONTACT_FORM from `source`. */
+function contactSubmission(source = "/contactos/") {
+	return {
+		gq_source: source,
+		input_1_3: "Ana",
+		input_1_6: "Silva",
+		input_2: "ana@example.com",
+		input_3: "Pergunta",
+		input_4: "Olá, gostava de saber mais.",
+		input_5_1: "1",
+		input_6: ""
+	};
+}
+/** Cloudflare's Turnstile test keys: always pass, always fail. */
+const TURNSTILE_TEST_KEYS = {
+	passingSiteKey: "1x00000000000000000000AA",
+	failingSiteKey: "2x00000000000000000000AB",
+	passingSecretKey: "1x0000000000000000000000000000000AA",
+	failingSecretKey: "2x0000000000000000000000000000000AA",
+	/** The token the test site keys produce. */
+	dummyToken: "XXXX.DUMMY.TOKEN.XXXX"
+};
+//#endregion
+export { CONTACT_FORM, PRIVATE_FORM_KEYS, TURNSTILE_TEST_KEYS, UNAVAILABLE_FORM, UNSUPPORTED_FORM, assertAccessibleForm, assertNoEntryExports, assertNoEntryReadsOrCredentials, assertPublicDescriptor, contactSubmission, formBody, gravityFormsStub };