@10x-media/form-builder 0.1.0-beta.0 → 0.1.0-beta.1

package/dist/index.js

@@ -1,1891 +1,42 @@
-import { _ as IDENTITY_CONTEXT_KEY, a as resolveValidationRules, c as runValidation, d as computeCalcFields, f as evaluateCalc, g as DEFAULT_HONEYPOT_FIELD, h as CAPTCHA_TOKEN_KEY, l as evaluateCondition, m as defaultPresentationDescriptors, n as optionLabelsFor, o as defaultValidationRules, p as DEFAULT_PRESENTATION_NAME, r as valuesFromSearchParams, s as defineValidationRule, t as buildRecallResolver, u as calcExpressionOf, v as noopEventSink, y as interpolate } from "./resolver-OeQyVH2N.js";
-import { t as keys } from "./keys-N5xGiUsh.js";
-import { a as asFieldTranslate, c as labelForKey, i as defineFormField, n as resolveFieldTypes, o as asTranslate, r as defaultFieldDefinitions, s as labelFor } from "./registry-CoCyhtvB.js";
-import { n as defaultConditionType, t as conditionOperators } from "./fieldTypes-CzhhJXjg.js";
-import { t as translations } from "./translations-edMqq_2e.js";
-import { APIError, ValidationError, definePlugin } from "payload";
-import { createHmac } from "node:crypto";
-import { deepMergeSimple, transformWhereQuery } from "payload/shared";
-//#region src/actions/defineAction.ts
-const defineAction = (definition) => definition;
-//#endregion
-//#region src/actions/builtin/confirmation.ts
-const confirmation = defineAction({
-	type: "confirmation",
-	label: keys.actionConfirmation,
-	config: [
-		{
-			name: "toField",
-			type: "text",
-			label: labelFor(keys.actionConfigToField)
-		},
-		{
-			name: "subject",
-			type: "text",
-			label: labelFor(keys.actionConfigSubject)
-		},
-		{
-			name: "body",
-			type: "textarea",
-			label: labelFor(keys.actionConfigBody)
-		}
-	],
-	run: async (args) => {
-		const { config, values, payload } = args;
-		if (!config.toField) return;
-		const entry = values.find((v) => v.field === config.toField);
-		const to = entry == null ? "" : String(entry.value ?? "");
-		if (!to) return;
-		if (typeof payload.sendEmail !== "function") throw new Error("confirmation: no email adapter configured");
-		const resolve = (name) => {
-			const found = values.find((v) => v.field === name);
-			return found == null ? "" : String(found.value ?? "");
-		};
-		const subject = interpolate(config.subject ?? "", resolve);
-		const html = interpolate(config.body ?? "", resolve);
-		await payload.sendEmail({
-			to,
-			subject,
-			html
-		});
-	}
-});
-//#endregion
-//#region src/actions/builtin/emailTeam.ts
-const emailTeam = defineAction({
-	type: "emailTeam",
-	label: keys.actionEmailTeam,
-	config: [
-		{
-			name: "to",
-			type: "text",
-			label: labelFor(keys.actionConfigTo)
-		},
-		{
-			name: "subject",
-			type: "text",
-			label: labelFor(keys.actionConfigSubject)
-		},
-		{
-			name: "body",
-			type: "textarea",
-			label: labelFor(keys.actionConfigBody)
-		}
-	],
-	run: async (args) => {
-		const { config, values, payload } = args;
-		if (!config.to) throw new Error("emailTeam: missing \"to\" address");
-		if (typeof payload.sendEmail !== "function") throw new Error("emailTeam: no email adapter configured");
-		const resolve = (name) => {
-			const entry = values.find((v) => v.field === name);
-			return entry == null ? "" : String(entry.value ?? "");
-		};
-		const subject = interpolate(config.subject ?? "", resolve);
-		const html = interpolate(config.body ?? "", resolve);
-		await payload.sendEmail({
-			to: config.to,
-			subject,
-			html
-		});
-	}
-});
-//#endregion
-//#region src/actions/sign.ts
-const SIGNATURE_HEADER = "X-Form-Signature";
-/** HMAC-SHA256 over `body`, hex-encoded, wrapped in the versioned header value (`v1=<hex>`). */
-const signPayload = (body, secret) => `v1=${createHmac("sha256", secret).update(body).digest("hex")}`;
-//#endregion
-//#region src/actions/builtin/index.ts
-const defaultActionDefinitions = {
-	emailTeam,
-	confirmation,
-	signedWebhook: defineAction({
-		type: "signedWebhook",
-		label: keys.actionSignedWebhook,
-		config: [{
-			name: "url",
-			type: "text",
-			label: labelFor(keys.actionConfigUrl)
-		}, {
-			name: "secret",
-			type: "text",
-			label: labelFor(keys.actionConfigSecret)
-		}],
-		run: async (args) => {
-			const { config, form, submissionId, values } = args;
-			if (!config.url) throw new Error("signedWebhook: missing \"url\"");
-			if (!config.secret) throw new Error("signedWebhook: missing \"secret\"");
-			const body = JSON.stringify({
-				formId: form.id,
-				submissionId,
-				values
-			});
-			const controller = new AbortController();
-			const timer = setTimeout(() => controller.abort(), 1e4);
-			let response;
-			try {
-				response = await fetch(config.url, {
-					method: "POST",
-					headers: {
-						"Content-Type": "application/json",
-						[SIGNATURE_HEADER]: signPayload(body, config.secret)
-					},
-					body,
-					signal: controller.signal
-				});
-			} finally {
-				clearTimeout(timer);
-			}
-			if (!response.ok) throw new Error(`signedWebhook: server responded ${response.status}`);
-		}
-	})
-};
-//#endregion
-//#region src/actions/registry.ts
-/**
-* Resolve the active action registry from built-in defaults and a consumer override map. `false`
-* removes a type, `true` keeps the default (no-op when none exists), a definition adds or replaces.
-* Mirrors the field-type and validation-rule registry convention.
-*/
-const resolveActions = (defaults, config = {}) => {
-	const registry = new Map(Object.entries(defaults));
-	for (const [type, option] of Object.entries(config)) if (option === false) registry.delete(type);
-	else if (option === true) {} else registry.set(type, option);
-	return registry;
-};
-//#endregion
-//#region src/collections/uploads.ts
-const FORM_UPLOADS_SLUG = "form-uploads";
-/**
-* The built-in upload collection backing the `file` field. Anonymous create (public forms upload here),
-* authed read/update/delete (only admins read stored files; submitters cannot enumerate others' uploads).
-* Per-field MIME/size is re-enforced at submit, so the collection stays permissive by default. No
-* `imageSizes`, so it needs no `sharp`. Projects with their own upload collection set `uploads: false` and
-* point the file field's `relationTo` at theirs.
-*/
-const buildUploadsCollection = (config = {}) => ({
-	slug: config.slug ?? "form-uploads",
-	access: config.access ?? {
-		create: () => true,
-		read: ({ req }) => Boolean(req.user),
-		update: ({ req }) => Boolean(req.user),
-		delete: ({ req }) => Boolean(req.user)
-	},
-	admin: { group: "Forms" },
-	upload: config.upload && config.upload !== true ? config.upload : true,
-	fields: [{
-		name: "owner",
-		type: "text",
-		admin: {
-			readOnly: true,
-			hidden: true
-		}
-	}, ...config.fields ?? []]
-});
-/** Resolve the `uploads` plugin option: `false` disables, `true`/object enables the built-in collection. */
-const resolveUploads = (option) => {
-	if (option === false) return {
-		enabled: false,
-		slug: FORM_UPLOADS_SLUG
-	};
-	const collection = buildUploadsCollection(option && option !== true ? option : {});
-	return {
-		enabled: true,
-		slug: collection.slug,
-		collection
-	};
-};
-//#endregion
-//#region src/consent/defineConsentSource.ts
-const defineConsentSource = (source) => source;
-//#endregion
-//#region src/consent/resolvePublishedVersionRef.ts
-/**
-* Returns the latest published version of a doc, or null when versions/drafts are off or nothing
-* is published. Never throws.
-*/
-const resolvePublishedVersionRef = async (payload, args) => {
-	try {
-		const doc = (await payload.findVersions({
-			collection: args.collection,
-			where: { and: [{ parent: { equals: args.id } }, { "version._status": { equals: "published" } }] },
-			sort: "-updatedAt",
-			limit: 1,
-			depth: 0
-		}))?.docs?.[0];
-		if (!doc) return null;
-		return {
-			versionId: String(doc.id),
-			updatedAt: String(doc.updatedAt)
-		};
-	} catch {
-		return null;
-	}
-};
-//#endregion
-//#region src/consent/builtin/pageReference.ts
-const pageReferenceSource = defineConsentSource({
-	type: "pageReference",
-	label: keys.consentSourcePageReference,
-	config: [
-		{
-			name: "relationTo",
-			type: "text",
-			label: labelFor(keys.consentConfigRelationTo)
-		},
-		{
-			name: "docId",
-			type: "text",
-			label: labelFor(keys.consentConfigDocId)
-		},
-		{
-			name: "urlField",
-			type: "text",
-			label: labelFor(keys.consentConfigUrlField),
-			defaultValue: "slug"
-		},
-		{
-			name: "captureVersion",
-			type: "checkbox",
-			label: labelFor(keys.consentConfigCaptureVersion)
-		}
-	],
-	resolve: async ({ config, payload, req, locale }) => {
-		const relationTo = String(config.relationTo ?? "");
-		const docId = String(config.docId ?? "");
-		const urlField = String(config.urlField ?? "slug");
-		const captureVersion = Boolean(config.captureVersion);
-		if (!relationTo || !docId) return { links: [] };
-		const doc = await payload.findByID({
-			collection: relationTo,
-			id: docId,
-			depth: 0,
-			locale,
-			req
-		}).catch(() => null);
-		if (!doc) return { links: [{
-			label: relationTo,
-			url: ""
-		}] };
-		const docRecord = doc;
-		const label = String(docRecord.title ?? docRecord[urlField] ?? relationTo);
-		const url = String(docRecord[urlField] ?? "");
-		if (!captureVersion) return { links: [{
-			label,
-			url
-		}] };
-		const v = await resolvePublishedVersionRef(payload, {
-			collection: relationTo,
-			id: docId
-		});
-		return {
-			links: [{
-				label,
-				url
-			}],
-			...v ? {
-				versionRef: v.versionId,
-				versionLabel: v.updatedAt
-			} : {}
-		};
-	}
-});
-//#endregion
-//#region src/consent/builtin/index.ts
-const defaultConsentSources = {
-	static: defineConsentSource({
-		type: "static",
-		label: keys.consentSourceStatic,
-		config: [
-			{
-				name: "label",
-				type: "text",
-				label: labelFor(keys.consentConfigLabel)
-			},
-			{
-				name: "url",
-				type: "text",
-				label: labelFor(keys.consentConfigUrl)
-			},
-			{
-				name: "version",
-				type: "text",
-				label: labelFor(keys.consentConfigVersion)
-			}
-		],
-		resolve({ config }) {
-			const label = String(config.label ?? "");
-			const url = String(config.url ?? "");
-			const version = config.version ? String(config.version) : void 0;
-			return {
-				links: [{
-					label,
-					url
-				}],
-				...version ? {
-					versionRef: version,
-					versionLabel: version
-				} : {}
-			};
-		}
-	}),
-	pageReference: pageReferenceSource
-};
-//#endregion
-//#region src/consent/registry.ts
-/**
-* Resolve the active consent-source registry from built-in defaults and a consumer override map.
-* `false` removes a type, `true` keeps the default (no-op when none exists), a definition adds or
-* replaces. Mirrors the action and field-type registry convention.
-*/
-const resolveConsentSources = (defaults, config = {}) => {
-	const registry = new Map(Object.entries(defaults));
-	for (const [type, option] of Object.entries(config)) if (option === false) registry.delete(type);
-	else if (option === true) {} else registry.set(type, option);
-	return registry;
-};
-const canQueue = (payload) => typeof payload.jobs?.queue === "function";
-const deadline = (ms) => new Promise((resolve) => {
-	setTimeout(resolve, ms).unref?.();
-});
-/**
-* Dispatch a submission's post-submit actions without throwing and without blocking the response on slow
-* action work. With no actions, returns immediately. When a job runner is present, enqueues the native
-* `form-builder-actions` task and returns (action work happens out of band). Otherwise runs the actions
-* inline but bounded by a deadline so a missing worker still delivers without hanging the request; any
-* error is swallowed (logged via `payload.logger`). Never rejects.
-*/
-const dispatchActions = async (args) => {
-	const { payload, registry, req, formId, submissionId } = args;
-	if ((args.actions ?? []).length === 0) return;
-	if (args.hasRunner && canQueue(payload)) {
-		try {
-			const input = {
-				formId,
-				submissionId
-			};
-			await payload.jobs.queue({
-				task: ACTIONS_TASK_SLUG,
-				input,
-				req
-			});
-		} catch (error) {
-			payload.logger?.error(`@10x-media/form-builder: failed to enqueue actions for submission ${String(submissionId)}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-		return;
-	}
-	const ms = args.deadlineMs ?? 5e3;
-	const work = runActionsForSubmission({
-		input: {
-			formId,
-			submissionId
-		},
-		registry,
-		payload,
-		req
-	}).catch((error) => {
-		payload.logger?.error(`@10x-media/form-builder: inline action dispatch for submission ${String(submissionId)} threw: ${error instanceof Error ? error.message : String(error)}`);
-	});
-	await Promise.race([work, deadline(ms)]);
-};
-//#endregion
-//#region src/events/resolveEventSink.ts
-/** Resolves the configured event sink, falling back to the no-op sink. Consumed by the submission pipeline in a later phase. */
-const resolveEventSink = (sink) => sink ?? noopEventSink;
-//#endregion
-//#region src/spam/reserved.ts
-/**
-* Split reserved entries (honeypot decoy, captcha token) out of the submitted `values`. The honeypot
-* rides a configurable, innocuous field name; the captcha token rides a fixed reserved key. Real field
-* values pass through unchanged. `runSubmission` would already ignore unknown field names, but stripping
-* here keeps them out of storage and out of the validation pass.
-*/
-const extractReservedValues = (values, honeypotField) => {
-	const cleaned = [];
-	const result = { cleaned };
-	for (const entry of values) {
-		if (entry.field === "__fb_captcha") {
-			if (typeof entry.value === "string") result.captchaToken = entry.value;
-			continue;
-		}
-		if (honeypotField !== null && entry.field === honeypotField) {
-			result.honeypot = entry.value;
-			continue;
-		}
-		cleaned.push(entry);
-	}
-	return result;
-};
-/** A honeypot is tripped when the decoy carries any non-empty value (a real user never fills it). */
-const isHoneypotTripped = (value) => value != null && value !== "" && !(Array.isArray(value) && value.length === 0);
-//#endregion
-//#region src/spam/spamGuard.ts
-const firstHop = (req, header) => {
-	const raw = req.headers?.get(header);
-	return raw ? raw.split(",")[0]?.trim() ?? void 0 : void 0;
-};
-/**
-* Submissions spam guard, prepended before `validateSubmission` in `beforeValidate` so it rejects before
-* the form load + field validation. On create it: resolves the request identity once (stashing it on
-* `req.context` for upload-ownership verification downstream); rate-limits per form + identity (429,
-* fail-open when identity is null); strips reserved `values` entries (honeypot, captcha token); rejects a
-* filled honeypot with a generic error; verifies a configured captcha; and writes a server-authoritative
-* `meta` (timestamp + spam signal, with opt-in ip/ua). App-level rate limiting is defense-in-depth that
-* complements edge/CDN/WAF limiting, not a DoS replacement.
-*/
-const buildSpamGuard = (spam) => async ({ data, operation, req }) => {
-	if (operation !== "create" || !data) return data;
-	const t = asTranslate(req.i18n.t);
-	const authenticated = Boolean(req.user);
-	const identity = await spam.identify(req);
-	if (identity != null) req.context[IDENTITY_CONTEXT_KEY] = identity;
-	if (spam.rateLimit !== false && identity != null) {
-		const formKey = data.form != null ? String(data.form) : "unknown";
-		const { ok } = await spam.rateLimit.limiter.check({
-			key: `submissions:${formKey}:${identity}`,
-			max: spam.rateLimit.max,
-			window: spam.rateLimit.window,
-			req
-		});
-		if (!ok) throw new APIError(t(keys.spamRateLimited), 429);
-	}
-	const honeypotField = spam.honeypot === false ? null : spam.honeypot.fieldName;
-	const { cleaned, honeypot, captchaToken } = extractReservedValues(data.values ?? [], honeypotField);
-	data.values = cleaned;
-	if (!authenticated && honeypotField !== null && isHoneypotTripped(honeypot)) throw new APIError(t(keys.spamRejected), 400);
-	const captchaChecked = Boolean(spam.captcha) && !authenticated;
-	if (spam.captcha && !authenticated) {
-		if (!(typeof captchaToken === "string" && captchaToken.length > 0 ? await spam.captcha.verify({
-			token: captchaToken,
-			req
-		}).catch(() => false) : false)) throw new APIError(t(keys.spamCaptchaFailed), 400);
-	}
-	const serverMeta = {
-		at: (/* @__PURE__ */ new Date()).toISOString(),
-		spam: { captcha: captchaChecked ? "passed" : "skipped" }
-	};
-	if (spam.metadata.ip) {
-		const ip = firstHop(req, spam.ipHeader);
-		if (ip) serverMeta.ip = ip;
-	}
-	if (spam.metadata.ua) {
-		const ua = req.headers?.get("user-agent");
-		if (ua) serverMeta.ua = ua;
-	}
-	data.meta = {
-		...authenticated && data.meta != null && typeof data.meta === "object" ? data.meta : {},
-		...serverMeta
-	};
-	return data;
-};
-//#endregion
-//#region src/actions/buildActionBlocks.ts
-/** One authoring block per registered action type: the action's own config fields. */
-const buildActionBlocks = (registry) => {
-	const blocks = [];
-	for (const definition of registry.values()) blocks.push({
-		slug: definition.type,
-		labels: {
-			singular: labelFor(definition.label),
-			plural: labelFor(definition.label)
-		},
-		fields: definition.config ?? []
-	});
-	return blocks;
-};
-//#endregion
-//#region src/aggregation/aggregateRows.ts
-const round1 = (n) => Math.round(n * 10) / 10;
-/** The grouping keys a single answer contributes: [] for empty, one per element for arrays, else one. */
-const valueKeys = (value) => {
-	if (value == null || value === "") return [];
-	if (Array.isArray(value)) return value.filter((entry) => entry != null && entry !== "").map((entry) => String(entry));
-	return [String(value)];
-};
-/** Merge every row's descriptor snapshot for one field into a value -> label map (last write wins). */
-const snapshotLabels = (rows, field) => {
-	const labels = /* @__PURE__ */ new Map();
-	for (const row of rows) for (const descriptor of row.descriptors ?? []) if (descriptor.field === field && descriptor.optionLabels) for (const [value, label] of Object.entries(descriptor.optionLabels)) labels.set(value, label);
-	return labels;
-};
-/** Aggregate one field across rows: respondent-denominated counts + percentages, option-ordered. */
-const aggregateRowForField = (rows, meta, truncated) => {
-	const counts = /* @__PURE__ */ new Map();
-	const order = [];
-	for (const option of meta.options ?? []) {
-		counts.set(option.value, 0);
-		order.push(option.value);
-	}
-	const snapshots = snapshotLabels(rows, meta.field);
-	let total = 0;
-	for (const row of rows) {
-		const keys = valueKeys((row.values ?? []).find((entry) => entry.field === meta.field)?.value);
-		if (keys.length === 0) continue;
-		total += 1;
-		for (const key of keys) {
-			if (!counts.has(key)) {
-				counts.set(key, 0);
-				order.push(key);
-			}
-			counts.set(key, (counts.get(key) ?? 0) + 1);
-		}
-	}
-	const optionValues = new Set((meta.options ?? []).map((option) => option.value));
-	const leftovers = order.filter((value) => !optionValues.has(value)).sort((a, b) => (counts.get(b) ?? 0) - (counts.get(a) ?? 0));
-	const ordered = [...(meta.options ?? []).map((option) => option.value), ...leftovers];
-	const optionLabelByValue = new Map((meta.options ?? []).map((option) => [option.value, option.label]));
-	const buckets = ordered.map((value) => {
-		const count = counts.get(value) ?? 0;
-		return {
-			value,
-			label: optionLabelByValue.get(value) ?? snapshots.get(value) ?? value,
-			count,
-			percentage: total > 0 ? round1(count / total * 100) : 0
-		};
-	});
-	return {
-		field: meta.field,
-		label: meta.label,
-		fieldType: meta.fieldType,
-		total,
-		buckets,
-		truncated
-	};
-};
-/** Aggregate several fields across the same set of rows. */
-const aggregateRowsForFields = (rows, metas, truncated) => metas.map((meta) => aggregateRowForField(rows, meta, truncated));
-//#endregion
-//#region src/aggregation/aggregateResponses.ts
-const optionsOf = (field) => {
-	if (!Array.isArray(field.options)) return;
-	const options = field.options.filter((option) => typeof option?.value === "string").map((option) => ({
-		value: String(option.value),
-		label: option.label ?? String(option.value)
-	}));
-	return options.length > 0 ? options : void 0;
-};
-/** True when a field declares non-empty options (a choice field safe to aggregate publicly). */
-const fieldHasOptions = (field) => optionsOf(field) !== void 0;
-const metaFor = (field) => ({
-	field: field.name,
-	label: field.label ?? field.name,
-	fieldType: field.blockType,
-	options: optionsOf(field)
-});
-/**
-* Aggregate submission responses for a form. Loads the form for current labels + option order, then pages
-* `payload.find` over its submissions (JSON `values` cannot be GROUP BY'd portably across Mongo + Postgres,
-* so we scan + reduce in JS, cross-DB-identically). Bounded by `maxSubmissions`; beyond it the result is
-* `truncated`. Returns one `FieldAggregation` per requested field (or per enumerable field by default).
-*/
-const aggregateFormResponses = async (args) => {
-	const { payload, formId, fields, status = "complete", req, maxSubmissions = 1e4, pageSize = 500 } = args;
-	const form = await payload.findByID({
-		collection: FORMS_SLUG,
-		id: formId,
-		depth: 0,
-		overrideAccess: true,
-		req
-	}).catch(() => null);
-	if (!form || !Array.isArray(form.fields)) return [];
-	const instances = form.fields;
-	const selected = fields ? instances.filter((field) => fields.includes(field.name)) : instances.filter((field) => optionsOf(field) !== void 0);
-	if (selected.length === 0) return [];
-	const metas = selected.map(metaFor);
-	const where = { and: [{ form: { equals: formId } }, ...status === "all" ? [] : [{ status: { equals: status } }]] };
-	const rows = [];
-	let page = 1;
-	let truncated = false;
-	for (;;) {
-		const result = await payload.find({
-			collection: FORM_SUBMISSIONS_SLUG,
-			where,
-			limit: pageSize,
-			page,
-			depth: 0,
-			overrideAccess: true,
-			req,
-			select: {
-				values: true,
-				descriptors: true
-			}
-		});
-		for (const doc of result.docs) {
-			if (rows.length >= maxSubmissions) {
-				truncated = true;
-				break;
-			}
-			rows.push({
-				values: doc.values,
-				descriptors: doc.descriptors
-			});
-		}
-		if (truncated || !result.hasNextPage) break;
-		page += 1;
-	}
-	return aggregateRowsForFields(rows, metas, truncated);
-};
-/** Single-field convenience over `aggregateFormResponses`. Returns the field's aggregation, or null if absent. */
-const aggregateFieldResponses = async (args) => {
-	const { field, ...rest } = args;
-	const [result] = await aggregateFormResponses({
-		...rest,
-		fields: [field]
-	});
-	return result ?? null;
-};
-//#endregion
-//#region src/aggregation/resolveResultsRequest.ts
-const forbidden = {
-	status: 403,
-	body: { errors: [{ message: "Forbidden" }] }
-};
-/**
-* Authorize and resolve a poll/survey results request. Authed callers may aggregate any field (or all
-* enumerable fields). Anonymous callers are allowed only when the form opted in (`showResults`), and then
-* only for the configured `resultsField`, and only if that field is enumerable (has options) so a
-* misconfigured `resultsField` pointing at a free-text or PII field can never be dumped publicly. Returns
-* only aggregate counts, never raw submissions.
-*/
-const resolveFormResultsRequest = async (args) => {
-	const { payload, formId, field, isAuthed, req } = args;
-	if (formId == null) return {
-		status: 400,
-		body: { errors: [{ message: "Missing form id" }] }
-	};
-	const form = await payload.findByID({
-		collection: FORMS_SLUG,
-		id: formId,
-		depth: 0,
-		overrideAccess: true,
-		req
-	}).catch(() => null);
-	if (!form) return {
-		status: 404,
-		body: { errors: [{ message: "Not found" }] }
-	};
-	let fields;
-	if (isAuthed) fields = field ? [field] : void 0;
-	else {
-		if (form.showResults !== true) return forbidden;
-		const publicField = typeof form.resultsField === "string" && form.resultsField.length > 0 ? form.resultsField : void 0;
-		if (!publicField) return forbidden;
-		if (field && field !== publicField) return forbidden;
-		const instance = (Array.isArray(form.fields) ? form.fields : []).find((entry) => entry.name === publicField);
-		if (!instance || !fieldHasOptions(instance)) return forbidden;
-		fields = [publicField];
-	}
-	return {
-		status: 200,
-		body: { results: await aggregateFormResponses({
-			payload,
-			formId,
-			fields,
-			req
-		}) }
-	};
-};
-//#endregion
-//#region src/calc/normalizeCalc.ts
-const MAX_DEPTH = 64;
-const OP_SET = new Set([
-	"+",
-	"-",
-	"*",
-	"/",
-	"%"
-]);
-const FN_SET = new Set([
-	"min",
-	"max",
-	"round",
-	"abs",
-	"ceil",
-	"floor"
-]);
-const isRecord$1 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
-const normalizeNode = (value, depth) => {
-	if (depth > MAX_DEPTH) return void 0;
-	if (!isRecord$1(value)) return void 0;
-	switch (value.type) {
-		case "lit": {
-			const { value: v } = value;
-			if (typeof v !== "number" || !Number.isFinite(v)) return void 0;
-			return {
-				type: "lit",
-				value: v
-			};
-		}
-		case "ref": {
-			const { field } = value;
-			if (typeof field !== "string") return void 0;
-			return {
-				type: "ref",
-				field
-			};
-		}
-		case "op": {
-			const { op, left, right } = value;
-			if (typeof op !== "string" || !OP_SET.has(op)) return void 0;
-			const l = normalizeNode(left, depth + 1);
-			if (!l) return void 0;
-			const r = normalizeNode(right, depth + 1);
-			if (!r) return void 0;
-			return {
-				type: "op",
-				op,
-				left: l,
-				right: r
-			};
-		}
-		case "neg": {
-			const operand = normalizeNode(value.operand, depth + 1);
-			if (!operand) return void 0;
-			return {
-				type: "neg",
-				operand
-			};
-		}
-		case "fn": {
-			const { fn, args } = value;
-			if (typeof fn !== "string" || !FN_SET.has(fn)) return void 0;
-			if (!Array.isArray(args)) return void 0;
-			const normalizedArgs = [];
-			for (const arg of args) {
-				const a = normalizeNode(arg, depth + 1);
-				if (!a) return void 0;
-				normalizedArgs.push(a);
-			}
-			return {
-				type: "fn",
-				fn,
-				args: normalizedArgs
-			};
-		}
-		case "weight": {
-			const { field, weights } = value;
-			if (typeof field !== "string") return void 0;
-			if (!isRecord$1(weights)) return void 0;
-			const normalizedWeights = {};
-			for (const [k, v] of Object.entries(weights)) {
-				if (typeof v !== "number" || !Number.isFinite(v)) return void 0;
-				normalizedWeights[k] = v;
-			}
-			return {
-				type: "weight",
-				field,
-				weights: normalizedWeights
-			};
-		}
-		default: return;
-	}
-};
-/** Structural guard: returns a valid CalcExpression if `value` is structurally sound (depth-guarded at 64), otherwise undefined. Never throws. */
-const normalizeCalc = (value) => normalizeNode(value, 0);
-//#endregion
-//#region src/conditions/conditionType.ts
-/** The condition input a field type uses in the builder: its declared `conditionType` or the value-kind default. */
-const conditionTypeForDefinition = (definition) => definition.conditionType ?? defaultConditionType(definition.value);
-/** A serializable slug -> condition type map for every registered field type, handed to the client builder. */
-const buildConditionTypeMap = (registry) => {
-	const map = {};
-	for (const definition of registry.values()) map[definition.type] = conditionTypeForDefinition(definition);
-	return map;
-};
-//#endregion
-//#region src/conditions/normalizeConditions.ts
-const isValidConstraint = (constraint, operandTypes) => {
-	if (constraint == null || typeof constraint !== "object") return false;
-	const field = Object.keys(constraint)[0];
-	if (!field) return false;
-	const type = operandTypes.get(field);
-	if (!type) return false;
-	const ops = constraint[field];
-	if (ops == null || typeof ops !== "object") return false;
-	const operator = Object.keys(ops)[0];
-	return Boolean(operator && conditionOperators[type].includes(operator));
-};
-const normalizeOne = (raw, operandTypes) => {
-	if (raw == null || typeof raw !== "object" || Object.keys(raw).length === 0) return;
-	const canonical = transformWhereQuery(raw);
-	const groups = (Array.isArray(canonical.or) ? canonical.or : Array.isArray(canonical.and) ? [{ and: canonical.and }] : []).map((group) => {
-		return (Array.isArray(group.and) ? group.and : []).filter((constraint) => isValidConstraint(constraint, operandTypes));
-	}).filter((group) => group.length > 0);
-	return groups.length > 0 ? { or: groups.map((and) => ({ and })) } : void 0;
-};
-/**
-* Normalize every field's `visibleWhen`/`validateWhen` against the form's own field list. Canonicalizes
-* to OR-of-ANDs and strips constraints whose operand field is missing or whose operator is invalid for
-* that field's condition type, so stored conditions always match what `evaluateCondition` can run.
-*/
-const normalizeFormConditions = (fields, conditionTypes) => {
-	const operandTypes = /* @__PURE__ */ new Map();
-	for (const row of fields) {
-		const name = typeof row.name === "string" ? row.name.trim() : "";
-		if (name.length > 0) operandTypes.set(name, conditionTypes[row.blockType] ?? "text");
-	}
-	return fields.map((row) => {
-		const visibleWhen = normalizeOne(row.visibleWhen, operandTypes);
-		const validateWhen = normalizeOne(row.validateWhen, operandTypes);
-		return {
-			...row,
-			visibleWhen,
-			validateWhen
-		};
-	});
-};
-//#endregion
-//#region src/validation/buildRuleBlocks.ts
-/** Each rule block appends its own `message` and `severity` fields, so a rule param of either name would collide and be silently dropped by Payload. */
-const RESERVED_PARAM_NAMES = new Set(["message", "severity"]);
-/** One block per rule applicable to `fieldType` (gated by `appliesTo`): the rule params, then a message override and severity. */
-const buildRuleBlocks = (registry, fieldType) => {
-	const blocks = [];
-	for (const rule of registry.values()) {
-		if (rule.appliesTo && !rule.appliesTo.includes(fieldType)) continue;
-		for (const param of rule.params ?? []) if ("name" in param && RESERVED_PARAM_NAMES.has(param.name)) throw new Error(`form-builder: validation rule "${rule.type}" declares a reserved param name "${param.name}". The names "message" and "severity" are reserved for the constraint-list UI.`);
-		blocks.push({
-			slug: rule.type,
-			labels: {
-				singular: labelFor(rule.label),
-				plural: labelFor(rule.label)
-			},
-			fields: [
-				...rule.params ?? [],
-				{
-					name: "message",
-					type: "text",
-					label: labelFor(keys.validationMessageLabel)
-				},
-				{
-					name: "severity",
-					type: "select",
-					defaultValue: "error",
-					label: labelFor(keys.validationSeverityLabel),
-					options: [{
-						label: labelFor(keys.validationSeverityError),
-						value: "error"
-					}, {
-						label: labelFor(keys.validationSeverityWarning),
-						value: "warning"
-					}]
-				}
-			]
-		});
-	}
-	return blocks;
-};
-//#endregion
-//#region src/fields/sharedConfig.ts
-const CONDITION_FIELD_REF = "@10x-media/form-builder/client#FormConditionField";
-const conditionField = (name, labelKey, conditionTypes) => ({
-	name,
-	type: "json",
-	label: labelFor(labelKey),
-	admin: { components: { Field: {
-		path: CONDITION_FIELD_REF,
-		clientProps: { conditionTypes }
-	} } }
-});
-/**
-* Config every field instance carries regardless of type. `name` is the machine key written into
-* submissions; `width` is stored for the layout grid. `visibleWhen`/`validateWhen` store a
-* canonical Payload `Where`, edited by the native condition builder. Field types add their own `config`
-* after these.
-*/
-const sharedFieldConfig = (conditionTypes) => [
-	{
-		name: "name",
-		type: "text",
-		required: true,
-		label: labelFor(keys.configName)
-	},
-	{
-		name: "label",
-		type: "text",
-		label: labelFor(keys.configLabel)
-	},
-	{
-		name: "required",
-		type: "checkbox",
-		label: labelFor(keys.configRequired)
-	},
-	{
-		name: "width",
-		type: "select",
-		defaultValue: "full",
-		label: labelFor(keys.configWidth),
-		options: [
-			{
-				label: "Full",
-				value: "full"
-			},
-			{
-				label: "Half",
-				value: "half"
-			},
-			{
-				label: "Third",
-				value: "third"
-			},
-			{
-				label: "Two thirds",
-				value: "twoThirds"
-			}
-		]
-	},
-	{
-		name: "placeholder",
-		type: "text",
-		label: labelFor(keys.configPlaceholder)
-	},
-	{
-		name: "description",
-		type: "textarea",
-		label: labelFor(keys.configDescription)
-	},
-	{
-		type: "collapsible",
-		label: labelFor(keys.configAdvanced),
-		admin: { initCollapsed: true },
-		fields: [
-			conditionField("visibleWhen", keys.configVisibleWhen, conditionTypes),
-			conditionField("validateWhen", keys.configValidateWhen, conditionTypes),
-			{
-				name: "hidden",
-				type: "checkbox",
-				label: labelFor(keys.configHidden)
-			}
-		]
-	}
-];
-//#endregion
-//#region src/fields/buildFieldBlocks.ts
-/** One add-field block per registered type: shared config, the type's own config, then its validations. */
-const buildFieldBlocks = (registry, ruleRegistry) => {
-	const conditionTypes = buildConditionTypeMap(registry);
-	const blocks = [];
-	for (const definition of registry.values()) blocks.push({
-		slug: definition.type,
-		labels: {
-			singular: labelFor(definition.label),
-			plural: labelFor(definition.label)
-		},
-		fields: [
-			...sharedFieldConfig(conditionTypes),
-			...definition.config ?? [],
-			{
-				name: "validations",
-				type: "blocks",
-				label: labelFor(keys.validationsLabel),
-				blocks: buildRuleBlocks(ruleRegistry, definition.type)
-			}
-		]
-	});
-	return blocks;
-};
-//#endregion
-//#region src/flow/normalizeFlow.ts
-const isRecord = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
-/**
-* Pure guard that normalizes a raw (possibly untrusted) flow value against the
-* form's current field list. Returns `undefined` when the flow is absent, empty,
-* or resolves to fewer than two steps (a single step is an ordinary form).
-*/
-const normalizeFlow = (raw, fieldNames) => {
-	if (!isRecord(raw) || !Array.isArray(raw.steps)) return;
-	const knownFields = new Set(fieldNames);
-	const rawSteps = raw.steps.filter((s) => isRecord(s) && typeof s.id === "string");
-	const knownIds = new Set(rawSteps.map((s) => s.id));
-	if (knownIds.size < 2) return;
-	return { steps: rawSteps.map((s) => {
-		const id = s.id;
-		const fields = Array.isArray(s.fields) ? s.fields.filter((f) => typeof f === "string" && knownFields.has(f)) : [];
-		const transitions = (Array.isArray(s.transitions) ? s.transitions : []).filter((t) => isRecord(t) && typeof t.to === "string" && knownIds.has(t.to) && isRecord(t.when)).map((t) => ({
-			when: t.when,
-			to: t.to
-		}));
-		const next = typeof s.next === "string" && knownIds.has(s.next) ? s.next : void 0;
-		const step = {
-			id,
-			fields
-		};
-		if (typeof s.title === "string") step.title = s.title;
-		if (transitions.length > 0) step.transitions = transitions;
-		if (next !== void 0) step.next = next;
-		return step;
-	}) };
-};
-//#endregion
-//#region src/collections/forms.ts
-const FORMS_SLUG = "forms";
-const buildFormsCollection = ({ registry, ruleRegistry, presentationRegistry = new Map(Object.entries(defaultPresentationDescriptors)), actionRegistry = /* @__PURE__ */ new Map() }) => {
-	const conditionTypes = buildConditionTypeMap(registry);
-	const beforeValidate = ({ data }) => {
-		if (data && typeof data.defaultPresentation === "string" && !presentationRegistry.has(data.defaultPresentation)) data.defaultPresentation = DEFAULT_PRESENTATION_NAME;
-		if (data && Array.isArray(data.fields)) {
-			const normalized = normalizeFormConditions(data.fields, conditionTypes);
-			for (const field of normalized) if ("expression" in field) field.expression = normalizeCalc(field.expression);
-			data.fields = normalized;
-			const fieldNames = normalized.map((field) => typeof field.name === "string" ? field.name : void 0).filter((name) => name !== void 0);
-			data.flow = normalizeFlow(data.flow, fieldNames);
-		}
-		return data;
-	};
-	return {
-		slug: FORMS_SLUG,
-		labels: {
-			singular: "Form",
-			plural: "Forms"
-		},
-		admin: {
-			group: "Forms",
-			useAsTitle: "title"
-		},
-		access: { read: () => true },
-		hooks: { beforeValidate: [beforeValidate] },
-		fields: [
-			{
-				name: "title",
-				type: "text",
-				required: true,
-				label: labelForKey(keys.fieldTitle)
-			},
-			{
-				name: "fields",
-				type: "blocks",
-				blocks: buildFieldBlocks(registry, ruleRegistry)
-			},
-			{
-				name: "flow",
-				type: "json"
-			},
-			{
-				name: "actions",
-				type: "blocks",
-				blocks: buildActionBlocks(actionRegistry),
-				label: labelForKey(keys.configActions)
-			},
-			{
-				name: "defaultPresentation",
-				type: "select",
-				defaultValue: DEFAULT_PRESENTATION_NAME,
-				options: [...presentationRegistry.values()].map((descriptor) => ({
-					label: labelFor(descriptor.label),
-					value: descriptor.name
-				})),
-				label: labelForKey(keys.configDefaultPresentation),
-				admin: { position: "sidebar" }
-			},
-			{
-				name: "showResults",
-				type: "checkbox",
-				defaultValue: false,
-				label: labelForKey(keys.configShowResults),
-				admin: { position: "sidebar" }
-			},
-			{
-				name: "resultsField",
-				type: "text",
-				label: labelForKey(keys.configResultsField),
-				admin: {
-					position: "sidebar",
-					description: "Field whose aggregate results are public when \"Show results publicly\" is on. Use a choice field, never a free-text or PII field.",
-					condition: (data) => Boolean(data?.showResults)
-				}
-			}
-		],
-		endpoints: [{
-			path: "/:id/results",
-			method: "get",
-			handler: async (req) => {
-				const field = typeof req.query?.field === "string" ? req.query.field : void 0;
-				const { status, body } = await resolveFormResultsRequest({
-					payload: req.payload,
-					formId: req.routeParams?.id,
-					field,
-					isAuthed: Boolean(req.user),
-					req
-				});
-				return Response.json(body, { status });
-			}
-		}]
-	};
-};
-//#endregion
-//#region src/consent/resolveConsentLinks.ts
-const EMPTY = { links: [] };
-/**
-* Resolve a consent field's policy links via its configured source (for display).
-* Unknown/missing source returns empty links. Never throws.
-*/
-const resolveConsentLinks = async (field, ctx) => {
-	const sourceType = typeof field.source === "string" ? field.source : "static";
-	const source = ctx.registry.get(sourceType);
-	if (!source) return EMPTY;
-	const sourceConfig = field.sourceConfig && typeof field.sourceConfig === "object" ? field.sourceConfig : {};
-	try {
-		return await source.resolve({
-			config: sourceConfig,
-			payload: ctx.payload,
-			req: ctx.req,
-			locale: ctx.locale
-		});
-	} catch {
-		return EMPTY;
-	}
-};
-//#endregion
-//#region src/consent/captureConsent.ts
-/**
-* Build the authoritative consent proof at submit time: re-resolve the source server-side
-* (ignores any client ref), capturing a reference url -- never the policy text.
-* `now` is injected by the caller (`new Date().toISOString()`) for testability.
-*/
-const captureConsent = async (args) => {
-	const resolved = await resolveConsentLinks(args.field, {
-		registry: args.registry,
-		payload: args.payload,
-		req: args.req,
-		locale: args.locale
-	});
-	const ref = resolved.links[0]?.url || void 0;
-	return {
-		agreed: args.agreed,
-		...ref ? { ref } : {},
-		...resolved.versionRef ? { versionRef: resolved.versionRef } : {},
-		at: args.now
-	};
-};
-//#endregion
-//#region src/uploads/resolveFileRef.ts
-const mimeAllowed = (mimeType, allow) => {
-	if (!allow || allow.length === 0) return true;
-	return allow.some((pattern) => {
-		if (pattern.endsWith("/*")) return mimeType.startsWith(pattern.slice(0, -1));
-		return mimeType === pattern;
-	});
-};
-/**
-* Pure server trust-boundary check for an uploaded file: given the loaded upload doc (or null) and the
-* field's constraints, either return an authoritative `FileRef` snapshot or a rejection code. Never trusts
-* client metadata; the caller passes the doc it loaded from the upload collection.
-*/
-const resolveFileRef = (doc, config) => {
-	if (doc == null || doc.id == null) return {
-		ok: false,
-		code: "missing"
-	};
-	const mimeType = typeof doc.mimeType === "string" ? doc.mimeType : "";
-	const filesize = typeof doc.filesize === "number" ? doc.filesize : 0;
-	if (!mimeAllowed(mimeType, config.mimeTypes)) return {
-		ok: false,
-		code: "mimeType"
-	};
-	if (typeof config.maxSize === "number" && filesize > config.maxSize) return {
-		ok: false,
-		code: "tooLarge"
-	};
-	const ref = {
-		id: doc.id,
-		filename: typeof doc.filename === "string" ? doc.filename : "",
-		mimeType,
-		filesize
-	};
-	if (typeof doc.url === "string" && doc.url.length > 0) ref.url = doc.url;
-	return {
-		ok: true,
-		ref
-	};
-};
-//#endregion
-//#region src/uploads/captureFileRef.ts
-/**
-* Load the referenced upload doc and run the pure trust-boundary check. The client sends only the id; the
-* filename/mimeType/filesize are read authoritatively from the stored doc, never from the client. When the
-* upload carries an `owner` stamp AND the submitter is identifiable, the two must match, so an anonymous
-* submitter cannot capture another identity's upload; a mismatch collapses to `missing`, indistinguishable
-* from a deleted upload. When the submitter cannot be identified (no `expectedOwner`), ownership is not
-* enforced (fail-open, consistent with rate-limiting): a proxy-configured deployment identifies every
-* request, so this only relaxes scoping where it could not be applied fairly anyway. Unstamped uploads
-* (no identity at upload time, or a BYO collection without the field) pass unchanged.
-*/
-const captureFileRef = async (args) => {
-	const { payload, collectionSlug, uploadId, config, req, expectedOwner } = args;
-	const doc = await payload.findByID({
-		collection: collectionSlug,
-		id: uploadId,
-		depth: 0,
-		overrideAccess: true,
-		req
-	}).catch(() => null);
-	if (doc && expectedOwner != null) {
-		const owner = doc.owner;
-		if (typeof owner === "string" && owner.length > 0 && owner !== expectedOwner) return {
-			ok: false,
-			code: "missing"
-		};
-	}
-	return resolveFileRef(doc, config);
-};
-//#endregion
-//#region src/submissions/runSubmission.ts
-const errorKeyFor = (code) => {
-	if (code === "mimeType") return keys.validationFileMimeType;
-	if (code === "tooLarge") return keys.validationFileTooLarge;
-	return keys.validationFileMissing;
-};
-/** Normalize the authored `mimeTypes` (a `hasMany` text field) to a `string[]`. */
-const mimeTypesOf = (raw) => {
-	if (!Array.isArray(raw)) return;
-	const out = raw.filter((entry) => typeof entry === "string");
-	return out.length > 0 ? out : void 0;
-};
-const fileFieldConfigOf = (instance) => ({
-	relationTo: typeof instance.relationTo === "string" ? instance.relationTo : void 0,
-	mimeTypes: mimeTypesOf(instance.mimeTypes),
-	maxSize: typeof instance.maxSize === "number" ? instance.maxSize : void 0
-});
-const isEmpty = (value) => value == null || value === "" || Array.isArray(value) && value.length === 0;
-const coerce = (kind, value) => {
-	if (value == null) return value;
-	if (kind === "number") {
-		const next = typeof value === "number" ? value : Number(value);
-		return Number.isNaN(next) ? value : next;
-	}
-	if (kind === "boolean") {
-		if (typeof value === "string") {
-			const normalized = value.trim().toLowerCase();
-			return !(normalized === "" || normalized === "false" || normalized === "0" || normalized === "off" || normalized === "no");
-		}
-		return Boolean(value);
-	}
-	if (kind === "text") return typeof value === "string" ? value : String(value);
-	return value;
-};
-const optionLabelsFor$1 = (instance) => {
-	const options = instance.options;
-	if (!Array.isArray(options)) return;
-	const map = {};
-	for (const option of options) if (typeof option?.value === "string") map[option.value] = option.label ?? option.value;
-	return Object.keys(map).length > 0 ? map : void 0;
-};
-/**
-* Pure submission core, two-pass: first coerce every answered field to its typed kind (so cross-field
-* rules see coerced siblings), then validate each field through `runValidation` (required, intrinsic
-* facet, declarative rules), snapshotting a localized descriptor per answered field. Calc fields are
-* the trust boundary: their client-sent values are never seeded, their values are derived from their
-* expressions over the coerced answers, and those derived values are authoritative everywhere downstream
-* (conditions, validation, storage). Conditions gate the second pass against these effective answers: a
-* field whose `visibleWhen` is false is skipped entirely (never validated, never stored, so a client-sent
-* value for it is ignored), and a visible field whose `validateWhen` is false stores its value but skips
-* validation. A visible calc field stores its derived value and is never validated. Only `error` severity
-* blocks; warnings are computed but not surfaced server-side (the renderer surfaces them).
-*/
-const runSubmission = async (input) => {
-	const { fields, values, registry, ruleRegistry, consentRegistry, locale, t, operation, req, payload, formId, uploadSlug, expectedOwner } = input;
-	const incoming = new Map(values.map((entry) => [entry.field, entry.value]));
-	const coercedAnswers = {};
-	const coercedByName = /* @__PURE__ */ new Map();
-	for (const instance of fields) {
-		const definition = registry.get(instance.blockType);
-		const raw = incoming.get(instance.name);
-		if (!definition || calcExpressionOf(instance)) continue;
-		const effectiveRaw = instance.blockType === "consent" && isEmpty(raw) ? false : raw;
-		if (isEmpty(effectiveRaw)) continue;
-		const value = coerce(definition.value, effectiveRaw);
-		coercedAnswers[instance.name] = value;
-		coercedByName.set(instance.name, value);
-	}
-	const effective = computeCalcFields(fields, coercedAnswers);
-	const errors = [];
-	const outValues = [];
-	const descriptors = [];
-	const consentProofs = [];
-	const now = (/* @__PURE__ */ new Date()).toISOString();
-	for (const instance of fields) {
-		const definition = registry.get(instance.blockType);
-		if (!definition) continue;
-		const raw = incoming.get(instance.name);
-		const value = coercedByName.has(instance.name) ? coercedByName.get(instance.name) : raw;
-		if (!evaluateCondition(instance.visibleWhen, effective)) continue;
-		if (calcExpressionOf(instance)) {
-			outValues.push({
-				field: instance.name,
-				value: effective[instance.name]
-			});
-			descriptors.push({
-				field: instance.name,
-				label: instance.label ?? instance.name,
-				fieldType: instance.blockType
-			});
-			continue;
-		}
-		if (evaluateCondition(instance.validateWhen, effective)) {
-			const { errors: issues } = await runValidation({
-				field: instance,
-				fieldDefinition: definition,
-				value,
-				fieldType: instance.blockType,
-				ruleRegistry,
-				answers: effective,
-				locale,
-				t,
-				operation,
-				event: "submit",
-				mode: "server",
-				req,
-				payload,
-				formId
-			});
-			const blocking = issues.filter((issue) => issue.severity === "error");
-			if (blocking.length > 0) {
-				for (const issue of blocking) errors.push({
-					path: instance.name,
-					message: issue.message
-				});
-				continue;
-			}
-		}
-		if (instance.blockType === "file") {
-			if (isEmpty(value)) continue;
-			if (payload) {
-				const fileConfig = fileFieldConfigOf(instance);
-				const captured = await captureFileRef({
-					payload,
-					collectionSlug: fileConfig.relationTo ?? uploadSlug ?? "form-uploads",
-					uploadId: value,
-					config: fileConfig,
-					req,
-					expectedOwner
-				});
-				if (!captured.ok) {
-					errors.push({
-						path: instance.name,
-						message: t(errorKeyFor(captured.code))
-					});
-					continue;
-				}
-				outValues.push({
-					field: instance.name,
-					value: captured.ref
-				});
-				descriptors.push({
-					field: instance.name,
-					label: instance.label ?? instance.name,
-					fieldType: instance.blockType
-				});
-				continue;
-			}
-			outValues.push({
-				field: instance.name,
-				value
-			});
-			descriptors.push({
-				field: instance.name,
-				label: instance.label ?? instance.name,
-				fieldType: instance.blockType
-			});
-			continue;
-		}
-		if (instance.blockType === "consent" && payload) {
-			const proof = await captureConsent({
-				field: instance,
-				agreed: value === true,
-				registry: consentRegistry,
-				payload,
-				req,
-				locale,
-				now
-			});
-			consentProofs.push({
-				field: instance.name,
-				...proof
-			});
-			continue;
-		}
-		if (isEmpty(raw)) continue;
-		outValues.push({
-			field: instance.name,
-			value
-		});
-		const optionLabels = optionLabelsFor$1(instance);
-		descriptors.push({
-			field: instance.name,
-			label: instance.label ?? instance.name,
-			fieldType: instance.blockType,
-			...optionLabels ? { optionLabels } : {}
-		});
-	}
-	return {
-		errors,
-		values: outValues,
-		descriptors,
-		consent: consentProofs
-	};
-};
-//#endregion
-//#region src/submissions/validateSubmission.ts
-/**
-* Server-authoritative submission validation. On create it loads the referenced form, re-runs every
-* field's required check, intrinsic validator, and declarative rules through `runSubmission`, threading
-* `req`/`payload` so server-only async rules can hit the DB, and throws a Payload `ValidationError` with
-* per-field paths on any error-severity failure. The client is never trusted.
-* Consent fields are captured into `result.consent` (array of proofs, one per visible consent field).
-*/
-const validateSubmission = ({ registry, ruleRegistry, consentRegistry, uploadSlug }) => async ({ data, operation, req }) => {
-	if (operation !== "create" || !data) return data;
-	const formId = data.form;
-	if (formId == null) return data;
-	const fields = (await req.payload.findByID({
-		collection: "forms",
-		id: formId,
-		depth: 0,
-		locale: req.locale,
-		req
-	})).fields ?? [];
-	const incoming = data.values ?? [];
-	const locale = req.locale ?? "en";
-	const t = asFieldTranslate(req.i18n.t);
-	const expectedOwner = typeof req.context?.["formBuilderSpamIdentity"] === "string" ? req.context[IDENTITY_CONTEXT_KEY] : void 0;
-	const result = await runSubmission({
-		fields,
-		values: incoming,
-		registry,
-		ruleRegistry,
-		consentRegistry,
-		locale,
-		t,
-		operation: "create",
-		req,
-		payload: req.payload,
-		formId,
-		uploadSlug,
-		expectedOwner
-	});
-	if (result.errors.length > 0) throw new ValidationError({
-		collection: FORM_SUBMISSIONS_SLUG,
-		errors: result.errors
-	}, req.t);
-	data.values = result.values;
-	data.descriptors = result.descriptors;
-	data.consent = result.consent.length > 0 ? result.consent : void 0;
-	data.locale = locale;
-	return data;
-};
-//#endregion
-//#region src/collections/formSubmissions.ts
-const FORM_SUBMISSIONS_SLUG = "form-submissions";
-const formIdOf = (form) => {
-	if (typeof form === "number" || typeof form === "string") return form;
-	if (form && typeof form === "object" && "id" in form) {
-		const id = form.id;
-		if (typeof id === "number" || typeof id === "string") return id;
-	}
-};
-/**
-* On a completed submission create, dispatch the form's post-submit actions and emit `submission.created`.
-* Both are side effects on an already-written row, so the whole body is wrapped: nothing it does can throw
-* past the hook (a failed action or sink must never fail the submission write). Dispatch is itself bounded
-* and non-throwing; the inline fallback is awaited so the bound caps the added latency, while the queued
-* path returns immediately. The form's `actions` are null-guarded for legacy rows created before the field
-* existed.
-*/
-const makeAfterChange = (args) => async ({ doc, operation, req }) => {
-	if (operation !== "create" || doc.status != null && doc.status !== "complete") return doc;
-	const { payload } = req;
-	try {
-		const formId = formIdOf(doc.form);
-		if (formId == null) return doc;
-		await dispatchActions({
-			actions: (await payload.findByID({
-				collection: "forms",
-				id: formId,
-				depth: 0,
-				overrideAccess: true,
-				req
-			}).catch(() => null))?.actions ?? null,
-			formId,
-			submissionId: doc.id,
-			registry: args.actionRegistry,
-			payload,
-			req,
-			hasRunner: args.hasRunner
-		});
-		try {
-			await resolveEventSink(args.events).emit({
-				type: "submission.created",
-				formId: String(formId),
-				submissionId: String(doc.id),
-				at: (/* @__PURE__ */ new Date()).toISOString()
-			});
-		} catch (error) {
-			payload.logger?.error(`@10x-media/form-builder: submission.created sink threw: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	} catch (error) {
-		payload.logger?.error(`@10x-media/form-builder: afterChange dispatch failed for submission ${String(doc.id)}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	return doc;
-};
-const buildSubmissionsCollection = ({ registry, ruleRegistry, consentRegistry, actionRegistry = /* @__PURE__ */ new Map(), events, hasRunner = false, uploadSlug, spam }) => ({
-	slug: FORM_SUBMISSIONS_SLUG,
-	labels: {
-		singular: "Submission",
-		plural: "Submissions"
-	},
-	admin: { group: "Forms" },
-	access: {
-		create: () => true,
-		read: ({ req }) => Boolean(req.user),
-		update: () => false
-	},
-	hooks: {
-		beforeValidate: [...spam ? [buildSpamGuard(spam)] : [], validateSubmission({
-			registry,
-			ruleRegistry,
-			consentRegistry,
-			uploadSlug
-		})],
-		afterChange: [makeAfterChange({
-			actionRegistry,
-			events,
-			hasRunner
-		})]
-	},
-	fields: [
-		{
-			name: "form",
-			type: "relationship",
-			relationTo: FORMS_SLUG,
-			required: true
-		},
-		{
-			name: "status",
-			type: "select",
-			defaultValue: "complete",
-			options: [{
-				label: "Complete",
-				value: "complete"
-			}, {
-				label: "Partial",
-				value: "partial"
-			}]
-		},
-		{
-			name: "locale",
-			type: "text"
-		},
-		{
-			name: "values",
-			type: "json"
-		},
-		{
-			name: "descriptors",
-			type: "json"
-		},
-		{
-			name: "consent",
-			type: "json"
-		},
-		{
-			name: "meta",
-			type: "json"
-		},
-		{
-			name: "answers",
-			type: "ui",
-			admin: { components: { Field: "@10x-media/form-builder/rsc#SubmissionAnswers" } }
-		}
-	]
-});
-//#endregion
-//#region src/actions/runActions.ts
-/**
-* Run each configured action, isolating failures: a throwing action is captured as a failed result
-* and never breaks the others or the caller.
-*/
-const runActions = async (args) => {
-	const { actions, registry, ...ctx } = args;
-	const results = [];
-	for (const instance of actions) {
-		const definition = registry.get(instance.blockType);
-		if (!definition) continue;
-		try {
-			await definition.run({
-				...ctx,
-				config: instance
-			});
-			results.push({
-				type: instance.blockType,
-				ok: true
-			});
-		} catch (error) {
-			results.push({
-				type: instance.blockType,
-				ok: false,
-				error: error instanceof Error ? error.message : String(error)
-			});
-		}
-	}
-	return results;
-};
-//#endregion
-//#region src/actions/task.ts
-const ACTIONS_TASK_SLUG = "form-builder-actions";
-const asActions = (value) => Array.isArray(value) ? value : [];
-const asValues = (value) => Array.isArray(value) ? value : [];
-const asDescriptors = (value) => Array.isArray(value) ? value : [];
-/**
-* Load the form and submission by id and run the form's actions through the shared, failure-isolating
-* `runActions`. Tolerates a missing form or submission (the row may have been deleted between enqueue and
-* run) by returning early. Used by both the queued task handler and the inline fallback.
-*/
-const runActionsForSubmission = async (args) => {
-	const { input, registry, payload, req } = args;
-	const form = await payload.findByID({
-		collection: FORMS_SLUG,
-		id: input.formId,
-		depth: 0,
-		overrideAccess: true,
-		req
-	}).catch(() => null);
-	if (!form) return;
-	const submission = await payload.findByID({
-		collection: FORM_SUBMISSIONS_SLUG,
-		id: input.submissionId,
-		depth: 0,
-		overrideAccess: true,
-		req
-	}).catch(() => null);
-	if (!submission) return;
-	const locale = typeof submission.locale === "string" ? submission.locale : req?.locale ?? "en";
-	const t = asFieldTranslate(req?.i18n?.t ?? ((key) => key));
-	await runActions({
-		actions: asActions(form.actions),
-		registry,
-		form: {
-			id: form.id,
-			title: typeof form.title === "string" ? form.title : void 0
-		},
-		submissionId: submission.id,
-		values: asValues(submission.values),
-		descriptors: asDescriptors(submission.descriptors),
-		payload,
-		req,
-		locale,
-		t
-	});
-};
-/** Native Payload jobs task that runs a submission's post-submit actions out of band. */
-const buildActionsTask = (registry) => ({
-	slug: ACTIONS_TASK_SLUG,
-	inputSchema: [{
-		name: "formId",
-		type: "text",
-		required: true
-	}, {
-		name: "submissionId",
-		type: "text",
-		required: true
-	}],
-	handler: async ({ input, req }) => {
-		await runActionsForSubmission({
-			input,
-			registry,
-			payload: req.payload,
-			req
-		});
-		return { output: {} };
-	}
-});
-/** Register the actions task on `config.jobs.tasks`, creating the jobs config if absent. */
-const registerActionsTask = (config, registry) => {
-	config.jobs ??= {};
-	config.jobs.tasks ??= [];
-	config.jobs.tasks.push(buildActionsTask(registry));
-};
-//#endregion
-//#region src/spam/uploadHooks.ts
-/**
-* Stamp the resolved request identity onto a new upload's `owner`. `captureFileRef` later requires the
-* referencing submission's identity to match, so an anonymous submitter cannot capture another identity's
-* upload. No identity (no user, no trusted IP header) means no stamp, so the upload stays unscoped (a
-* deliberate fail-open; identity granularity is IP-level, so same-network clients share scope -- documented).
-*/
-const buildUploadOwnerStamp = (spam) => async ({ data, operation, req }) => {
-	if (operation !== "create" || !data) return data;
-	const identity = await spam.identify(req);
-	if (identity != null && data.owner == null) data.owner = identity;
-	return data;
-};
-/** Reject upload floods per identity before the file is written to `staticDir`. Fail-open without identity. */
-const buildUploadRateLimit = (spam) => async ({ operation, req }) => {
-	if (operation !== "create" || spam.uploadRateLimit === false) return;
-	const identity = await spam.identify(req);
-	if (identity == null) return;
-	const { ok } = await spam.uploadRateLimit.limiter.check({
-		key: `uploads:${identity}`,
-		max: spam.uploadRateLimit.max,
-		window: spam.uploadRateLimit.window,
-		req
-	});
-	if (!ok) throw new APIError(asTranslate(req.i18n.t)(keys.spamRateLimited), 429);
-};
-//#endregion
-//#region src/plugin/registerCollections.ts
-const registerCollections = ({ config, registry, ruleRegistry, consentRegistry, presentationRegistry, actionRegistry, hasJobsPlugin, events, uploads, spam }) => {
-	registerActionsTask(config, actionRegistry);
-	const hasRunner = Boolean(config.jobs?.autoRun) || hasJobsPlugin;
-	if (spam && uploads.enabled && uploads.collection) {
-		const collection = uploads.collection;
-		collection.hooks = collection.hooks ?? {};
-		collection.hooks.beforeOperation = [...collection.hooks.beforeOperation ?? [], buildUploadRateLimit(spam)];
-		collection.hooks.beforeValidate = [...collection.hooks.beforeValidate ?? [], buildUploadOwnerStamp(spam)];
-	}
-	config.collections = [
-		...config.collections ?? [],
-		...uploads.enabled && uploads.collection ? [uploads.collection] : [],
-		buildFormsCollection({
-			registry,
-			ruleRegistry,
-			presentationRegistry,
-			actionRegistry
-		}),
-		buildSubmissionsCollection({
-			registry,
-			ruleRegistry,
-			consentRegistry,
-			actionRegistry,
-			events,
-			hasRunner,
-			uploadSlug: uploads.slug,
-			spam
-		})
-	];
-};
-//#endregion
-//#region src/plugin/registerTranslations.ts
-/**
-* Merge this plugin's translations into the host config. A host value wins on
-* conflict (`deepMergeSimple` lets the second argument override), so projects can
-* override any string.
-*/
-const registerTranslations = (config) => {
-	config.i18n ??= {};
-	config.i18n.translations = deepMergeSimple(translations, config.i18n.translations ?? {});
-};
-//#endregion
-//#region src/presentations/registry.ts
-/**
-* Resolve the active presentation descriptors from the defaults and a consumer override map.
-* Mirrors the field-type, validation-rule, and renderer registry convention.
-*/
-const resolvePresentationDescriptors = (defaults, config = {}) => {
-	const registry = new Map(Object.entries(defaults));
-	for (const [name, option] of Object.entries(config)) if (option === false) registry.delete(name);
-	else if (option === true) {} else registry.set(name, option);
-	return registry;
-};
-//#endregion
-//#region src/spam/identify.ts
-/**
-* Default identity resolution for rate-limiting + upload ownership. Prefers an authenticated user id
-* (trustworthy); else the first hop of the configured trusted IP header (best-effort, proxy-dependent);
-* else null, in which case the caller fails open (cannot fairly rate-limit an unidentifiable client).
-*/
-const defaultIdentify = (ipHeader) => (req) => {
-	const userId = req.user?.id;
-	if (userId != null) return `user:${String(userId)}`;
-	const header = req.headers?.get(ipHeader);
-	if (header) {
-		const first = header.split(",")[0]?.trim();
-		if (first) return `ip:${first}`;
-	}
-	return null;
-};
-//#endregion
-//#region src/spam/rateLimiter.ts
-/**
-* The default rate limiter: a read-modify-write window counter over Payload's `payload.kv`
-* (always present; default `DatabaseKVAdapter`, durable + cross-instance). Because the KV interface
-* has no atomic increment, the get-then-set is NON-ATOMIC, so a concurrent burst can slightly undercount.
-* This is a SOFT limit, acceptable for spam basics and complemented by edge/WAF limiting. The window
-* expires lazily on read; stale keys for one-time identities linger (minor; the count self-resets).
-* `now` is injectable for tests.
-*/
-const createKvRateLimiter = (options = {}) => {
-	const now = options.now ?? (() => Date.now());
-	const prefix = options.namespace ?? "fb:rl:";
-	return { async check({ key, max, window, req }) {
-		const kv = req.payload.kv;
-		const storeKey = `${prefix}${key}`;
-		const current = now();
-		const existing = await kv.get(storeKey).catch(() => null);
-		let count;
-		let windowStart;
-		if (!existing || current - existing.windowStart >= window) {
-			count = 1;
-			windowStart = current;
-		} else {
-			count = existing.count + 1;
-			windowStart = existing.windowStart;
-		}
-		await kv.set(storeKey, {
-			count,
-			windowStart
-		}).catch(() => void 0);
-		return {
-			ok: count <= max,
-			remaining: Math.max(0, max - count),
-			resetAt: windowStart + window
-		};
-	} };
-};
-//#endregion
-//#region src/spam/resolveSpam.ts
-const DEFAULT_WINDOW = 6e4;
-const DEFAULT_SUBMISSION_MAX = 5;
-const DEFAULT_UPLOAD_MAX = 20;
-const resolveRateLimit = (option, defaultMax) => {
-	if (option === false) return false;
-	const cfg = option ?? {};
-	return {
-		window: cfg.window ?? DEFAULT_WINDOW,
-		max: cfg.max ?? defaultMax,
-		limiter: cfg.limiter ?? createKvRateLimiter()
-	};
-};
-/**
-* Resolve the `spam` plugin option into a concrete config. `false` disables the whole subsystem.
-* Otherwise honeypot + both rate limits default on, captcha + metadata capture default off, and the
-* identity seam defaults to user id / trusted IP header.
-*/
-const resolveSpamConfig = (option) => {
-	if (option === false) return false;
-	const cfg = option ?? {};
-	const ipHeader = cfg.ipHeader ?? "x-forwarded-for";
-	return {
-		honeypot: cfg.honeypot === false ? false : { fieldName: cfg.honeypot?.fieldName ?? "confirm_email" },
-		rateLimit: resolveRateLimit(cfg.rateLimit, DEFAULT_SUBMISSION_MAX),
-		uploadRateLimit: resolveRateLimit(cfg.uploadRateLimit, DEFAULT_UPLOAD_MAX),
-		captcha: cfg.captcha,
-		identify: cfg.identify ?? defaultIdentify(ipHeader),
-		ipHeader,
-		metadata: {
-			ip: cfg.metadata?.ip ?? false,
-			ua: cfg.metadata?.ua ?? false
-		}
-	};
-};
-//#endregion
-//#region src/spam/captcha.ts
-/**
-* Identity helper for authoring a captcha provider (mirrors `defineAction`/`defineConsentSource`).
-* v1 ships no built-in provider; a project supplies one (Turnstile/reCAPTCHA/hCaptcha) and the submit
-* path verifies a token carried on the submission. Prebuilt providers are a v1.x addition.
-*/
-const defineCaptchaProvider = (provider) => provider;
-//#endregion
+import { interpolate } from "./recall/interpolate.js";
+import { defineAction } from "./actions/defineAction.js";
+import { SIGNATURE_HEADER, signPayload } from "./actions/sign.js";
+import { defaultActionDefinitions } from "./actions/builtin/index.js";
+import { resolveActions } from "./actions/registry.js";
+import { FORM_UPLOADS_SLUG, buildUploadsCollection, resolveUploads } from "./collections/uploads.js";
+import { defineConsentSource } from "./consent/defineConsentSource.js";
+import { resolvePublishedVersionRef } from "./consent/resolvePublishedVersionRef.js";
+import { defaultConsentSources } from "./consent/builtin/index.js";
+import { resolveConsentSources } from "./consent/registry.js";
+import { defineFormField } from "./fields/defineFormField.js";
+import { defaultFieldDefinitions } from "./fields/builtin/index.js";
+import { resolveFieldTypes } from "./fields/registry.js";
+import { CAPTCHA_TOKEN_KEY, DEFAULT_HONEYPOT_FIELD } from "./spam/constants.js";
+import { aggregateRowForField, aggregateRowsForFields } from "./aggregation/aggregateRows.js";
+import { aggregateFieldResponses, aggregateFormResponses, fieldHasOptions } from "./aggregation/aggregateResponses.js";
+import { resolveFormResultsRequest } from "./aggregation/resolveResultsRequest.js";
+import { normalizeCalc } from "./calc/normalizeCalc.js";
+import { DEFAULT_PRESENTATION_NAME, defaultPresentationDescriptors } from "./presentations/defaults.js";
+import { evaluateCalc } from "./calc/evaluate.js";
+import { calcExpressionOf, computeCalcFields } from "./calc/computeCalcFields.js";
+import { evaluateCondition } from "./conditions/evaluate.js";
+import { resolveConsentLinks } from "./consent/resolveConsentLinks.js";
+import { captureConsent } from "./consent/captureConsent.js";
+import { resolveFileRef } from "./uploads/resolveFileRef.js";
+import { captureFileRef } from "./uploads/captureFileRef.js";
+import { registerCollections } from "./plugin/registerCollections.js";
+import { registerTranslations } from "./plugin/registerTranslations.js";
+import { resolvePresentationDescriptors } from "./presentations/registry.js";
+import { defaultIdentify } from "./spam/identify.js";
+import { createKvRateLimiter } from "./spam/rateLimiter.js";
+import { resolveSpamConfig } from "./spam/resolveSpam.js";
+import { defineValidationRule } from "./validation/defineValidationRule.js";
+import { defaultValidationRules } from "./validation/builtin/index.js";
+import { resolveValidationRules } from "./validation/registry.js";
+import { valuesFromSearchParams } from "./prefill/valuesFromSearchParams.js";
+import { buildRecallResolver, optionLabelsFor } from "./recall/resolver.js";
+import { defineCaptchaProvider } from "./spam/captcha.js";
+import { definePlugin } from "payload";
 //#region src/index.ts
 const formBuilder = definePlugin({
 	slug: "@10x-media/form-builder",
@@ -1899,7 +50,7 @@ const formBuilder = definePlugin({
 		const actionRegistry = resolveActions(defaultActionDefinitions, options.actions);
 		const uploads = resolveUploads(options.uploads);
 		const spam = resolveSpamConfig(options.spam);
-		registerTranslations(config);
+		registerTranslations(config, options.translations);
 		registerCollections({
 			config,
 			registry,