@nextlyhq/plugin-form-builder 0.0.2-alpha.73 → 0.0.2-alpha.75

package/dist/{field-references-CtzGg51W.js → field-references-oCuFEwkr.js}

@@ -1,3 +1,65 @@
+import { z } from "zod";
+
+// src/form-pages.ts
+/**
+* The form editor's pages, read by the plugin's declaration (which gives each
+* page its address) and by the editor (which draws a tab for each). One list,
+* so a tab cannot lead to an address nobody declared, nor an address go
+* without its tab.
+*
+* No React and no admin imports here: the server reads this module too.
+*
+* @module form-pages
+*/
+/**
+* The form editor, the forms collection's own edit view. The admin draws it at
+* the form's edit address and at each page's address below, so it stays
+* mounted, unsaved work and all, while a person moves between the tabs.
+*/
+const FORM_EDITOR_VIEW = "@nextlyhq/plugin-form-builder/admin#FormBuilderView";
+/** Every page, in the order the tabs show them. */
+const FORM_PAGES = [
+	{
+		label: "Builder",
+		path: void 0
+	},
+	{
+		label: "Preview",
+		path: "preview"
+	},
+	{
+		label: "Settings",
+		path: "settings"
+	},
+	{
+		label: "Notifications",
+		path: "notifications"
+	},
+	{
+		label: "Submissions",
+		path: "submissions"
+	}
+];
+/** A page's id. */
+function formPageId(page) {
+	return page.path ?? "builder";
+}
+/**
+* The page an address segment names: Builder for none, or for a segment that
+* is not one of the editor's pages.
+*/
+function formPageOf(view) {
+	const page = FORM_PAGES.find((each) => each.path !== void 0 && each.path === view);
+	return page === void 0 ? "builder" : formPageId(page);
+}
+/** The pages with an address of their own, for the plugin's declaration. */
+function addressedFormPages() {
+	return FORM_PAGES.flatMap((page) => page.path === void 0 ? [] : [{
+		path: page.path,
+		label: page.label
+	}]);
+}
+
 // src/utils/redirect-reference.ts
 /**
 * The reference a `redirectPage` value holds, in any shape a read produces.
@@ -389,122 +451,560 @@ function instantOf(value) {
 	return Number.isNaN(at.getTime()) ? void 0 : at.toISOString();
 }
 
-// src/types.ts
-/** Every built-in form field type, as a value list (the single source shared
-* by the field-type guard and the config validator). */
-const BUILT_IN_FORM_FIELD_TYPES = [
-	"text",
-	"email",
-	"number",
-	"phone",
-	"url",
-	"textarea",
-	"select",
-	"checkbox",
-	"radio",
-	"file",
-	"date",
-	"time",
-	"hidden"
-];
-const BUILT_IN_FORM_FIELD_TYPES_SET = new Set(BUILT_IN_FORM_FIELD_TYPES);
+// src/utils/evaluate-conditions.ts
 /**
-* Narrow an `AnyFormField` to the closed built-in `FormField` union. Returns
-* `false` for a plugin-contributed field, so callers handle it generically
-* before switching on the built-in discriminant.
+* Checks if a value is considered "empty".
+* Empty values: undefined, null, empty string, empty array.
 */
-function isKnownFormField(field) {
-	return BUILT_IN_FORM_FIELD_TYPES_SET.has(field.type);
+function isEmptyValue(value) {
+	if (value === void 0 || value === null) return true;
+	if (typeof value === "string" && value.trim() === "") return true;
+	if (Array.isArray(value) && value.length === 0) return true;
+	return false;
 }
 /**
-* Check if a value is a FormField.
+* Converts a value to a number for numeric comparisons.
+* Returns NaN if conversion is not possible.
 */
-function isFormField(value) {
-	return typeof value === "object" && value !== null && "type" in value && "name" in value && "label" in value;
+function toNumber(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed === "") return NaN;
+		return Number(trimmed);
+	}
+	return NaN;
 }
 /**
-* Check if a FormField is a specific type.
+* Converts a value to a string for string comparisons.
 */
-function isFormFieldType(field, type) {
-	return field.type === type;
+function toString(value) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.join(", ");
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
 }
 /**
-* Type guard for text field.
+* Compares two values using the specified operator.
+*
+* @param operator - The comparison operator to use
+* @param fieldValue - The actual value from the form data
+* @param conditionValue - The expected value from the condition
+* @returns Whether the comparison is true
 */
-function isTextFormField(field) {
-	return field.type === "text";
+function compareValues(operator, fieldValue, conditionValue) {
+	switch (operator) {
+		case "equals":
+			if (Array.isArray(fieldValue)) {
+				if (Array.isArray(conditionValue)) {
+					if (fieldValue.length !== conditionValue.length) return false;
+					return fieldValue.every((v, i) => v === conditionValue[i]);
+				}
+				return fieldValue.includes(conditionValue);
+			}
+			return toString(fieldValue) === toString(conditionValue);
+		case "notEquals":
+			if (Array.isArray(fieldValue)) {
+				if (Array.isArray(conditionValue)) {
+					if (fieldValue.length !== conditionValue.length) return true;
+					return !fieldValue.every((v, i) => v === conditionValue[i]);
+				}
+				return !fieldValue.includes(conditionValue);
+			}
+			return toString(fieldValue) !== toString(conditionValue);
+		case "contains": {
+			const fieldStr = toString(fieldValue).toLowerCase();
+			const conditionStr = toString(conditionValue).toLowerCase();
+			if (Array.isArray(fieldValue)) return fieldValue.some((v) => toString(v).toLowerCase().includes(conditionStr));
+			return fieldStr.includes(conditionStr);
+		}
+		case "isEmpty": return isEmptyValue(fieldValue);
+		case "isNotEmpty": return !isEmptyValue(fieldValue);
+		case "greaterThan": {
+			const fieldNum = toNumber(fieldValue);
+			const conditionNum = toNumber(conditionValue);
+			if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) return fieldNum > conditionNum;
+			return toString(fieldValue) > toString(conditionValue);
+		}
+		case "lessThan": {
+			const fieldNum = toNumber(fieldValue);
+			const conditionNum = toNumber(conditionValue);
+			if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) return fieldNum < conditionNum;
+			return toString(fieldValue) < toString(conditionValue);
+		}
+		default:
+			console.warn(`[evaluateConditions] Unknown comparison operator: ${String(operator)}`);
+			return false;
+	}
 }
 /**
-* Type guard for email field.
+* Evaluates a single condition against the form data.
+*
+* Exported for consumers that gate on one condition rather than a full
+* conditional-logic block — notification send-conditions use exactly this.
+*
+* @param condition - The condition to evaluate
+* @param formData - The current form data
+* @returns Whether the condition is met
 */
-function isEmailFormField(field) {
-	return field.type === "email";
+function evaluateSingleCondition(condition, formData) {
+	const { field, comparison, value: conditionValue } = condition;
+	return compareValues(comparison, getNestedValue(formData, field), conditionValue);
 }
 /**
-* Type guard for select field.
+* Gets a nested value from an object using dot notation.
+*
+* @param obj - The object to get the value from
+* @param path - The path to the value (e.g., "address.city")
+* @returns The value at the path, or undefined if not found
 */
-function isSelectFormField(field) {
-	return field.type === "select";
+function getNestedValue(obj, path) {
+	if (!path) return;
+	if (!path.includes(".")) return obj[path];
+	const parts = path.split(".");
+	let current = obj;
+	for (const part of parts) {
+		if (current === void 0 || current === null) return;
+		if (typeof current !== "object") return;
+		current = current[part];
+	}
+	return current;
 }
 /**
-* Type guard for checkbox field.
+* Evaluates conditional logic to determine field visibility.
+*
+* This is the main entry point for conditional logic evaluation.
+* It evaluates all conditions according to the logical operator (AND/OR)
+* and returns whether the field should be visible based on the action
+* (show/hide).
+*
+* @param logic - The conditional logic configuration
+* @param formData - The current form data (field values)
+* @returns Whether the field should be visible
+*
+* @example
+* ```typescript
+* // Show field when country is US AND age is over 18
+* const logic: ConditionalLogic = {
+*   enabled: true,
+*   action: 'show',
+*   operator: 'AND',
+*   conditions: [
+*     { field: 'country', comparison: 'equals', value: 'US' },
+*     { field: 'age', comparison: 'greaterThan', value: 18 },
+*   ],
+* };
+*
+* evaluateConditions(logic, { country: 'US', age: 25 }); // true
+* evaluateConditions(logic, { country: 'US', age: 15 }); // false
+* evaluateConditions(logic, { country: 'CA', age: 25 }); // false
+*
+* // Hide field when status is "completed"
+* const hideLogic: ConditionalLogic = {
+*   enabled: true,
+*   action: 'hide',
+*   operator: 'AND',
+*   conditions: [
+*     { field: 'status', comparison: 'equals', value: 'completed' },
+*   ],
+* };
+*
+* evaluateConditions(hideLogic, { status: 'completed' }); // false (hidden)
+* evaluateConditions(hideLogic, { status: 'pending' });   // true (visible)
+* ```
+*
+* @example
+* ```typescript
+* // Show field when either condition is met (OR)
+* const orLogic: ConditionalLogic = {
+*   enabled: true,
+*   action: 'show',
+*   operator: 'OR',
+*   conditions: [
+*     { field: 'role', comparison: 'equals', value: 'admin' },
+*     { field: 'role', comparison: 'equals', value: 'editor' },
+*   ],
+* };
+*
+* evaluateConditions(orLogic, { role: 'admin' });  // true
+* evaluateConditions(orLogic, { role: 'editor' }); // true
+* evaluateConditions(orLogic, { role: 'viewer' }); // false
+* ```
 */
-function isCheckboxFormField(field) {
-	return field.type === "checkbox";
+function evaluateConditions(logic, formData) {
+	if (!logic || !logic.enabled) return true;
+	const { action, operator, conditions } = logic;
+	if (!conditions || conditions.length === 0) return true;
+	const results = conditions.map((condition) => evaluateSingleCondition(condition, formData));
+	let conditionsMet;
+	if (operator === "OR") conditionsMet = results.some((result) => result);
+	else conditionsMet = results.every((result) => result);
+	if (action === "hide") return !conditionsMet;
+	return conditionsMet;
 }
 /**
-* Type guard for file field.
+* Checks if a comparison operator is valid.
+*
+* @param operator - The operator to check
+* @returns Whether the operator is valid
 */
-function isFileFormField(field) {
-	return field.type === "file";
+function isValidComparisonOperator(operator) {
+	return [
+		"equals",
+		"notEquals",
+		"contains",
+		"isEmpty",
+		"isNotEmpty",
+		"greaterThan",
+		"lessThan"
+	].includes(operator);
 }
-
-// src/utils/enforced-validation.ts
 /**
-* `message` appears on every row because it is honoured everywhere: each
-* generator passes `validation.errorMessage` to `applyRequired`, so even a type
-* with no bounds of its own uses it for the required failure.
+* Gets the list of supported comparison operators.
 *
-* Typed as a total `Record` rather than a partial one, so adding a field type
-* without deciding what it enforces is a compile error instead of a type that
-* silently offers nothing.
+* @returns Array of supported operator names
 */
-const ENFORCED_VALIDATION_RULES = {
-	text: [
-		"minLength",
-		"maxLength",
-		"pattern",
-		"message"
-	],
-	email: ["pattern", "message"],
-	number: [
-		"min",
-		"max",
-		"message"
-	],
-	phone: ["pattern", "message"],
-	url: ["pattern", "message"],
-	textarea: [
-		"minLength",
-		"maxLength",
-		"message"
-	],
-	select: ["message"],
-	checkbox: ["message"],
-	radio: ["message"],
-	file: ["message"],
-	date: ["message"],
-	time: ["message"],
-	hidden: ["message"]
-};
+function getSupportedComparisonOperators() {
+	return [
+		"equals",
+		"notEquals",
+		"contains",
+		"isEmpty",
+		"isNotEmpty",
+		"greaterThan",
+		"lessThan"
+	];
+}
+
+// src/utils/export-formats.ts
+/** UTF-8 BOM character sequence */
+const UTF8_BOM = "";
 /**
-* The rules a field of this type both accepts and has enforced.
+* Stringify a value safely, falling back to JSON for plain objects so we
+* never emit the default `[object Object]` representation.
+*/
+function safeString(value) {
+	if (typeof value === "object" && value !== null) return JSON.stringify(value);
+	return String(value);
+}
+/**
+* Format a field value for export based on field type.
 *
-* A plugin-contributed type has no row, and correctly gets nothing: this
-* runtime's generator has no clause for it, so every rule would be inert.
+* @param value - The raw value from submission data
+* @param field - The field definition (optional, for type-specific formatting)
+* @returns Formatted string representation of the value
+*
+* @example
+* ```typescript
+* formatExportValue(true, { type: 'checkbox' }); // "Yes"
+* formatExportValue(['a', 'b'], { type: 'select' }); // "a, b"
+* formatExportValue(new Date(), { type: 'date' }); // "2024-01-15"
+* ```
 */
-function enforcedValidationRules(type) {
-	return ENFORCED_VALIDATION_RULES[type] ?? [];
+function formatExportValue(value, field) {
+	if (value === null || value === void 0) return "";
+	if (field) switch (field.type) {
+		case "checkbox": return value ? "Yes" : "No";
+		case "select":
+			if (Array.isArray(value)) return value.join(", ");
+			return safeString(value);
+		case "file":
+			if (Array.isArray(value)) return value.map((v) => safeString(v)).join(", ");
+			return safeString(value);
+		case "date":
+			if (value instanceof Date) return value.toISOString().split("T")[0];
+			if (typeof value === "string") {
+				const parsed = new Date(value);
+				if (!isNaN(parsed.getTime())) return parsed.toISOString().split("T")[0];
+			}
+			return safeString(value);
+		case "time": return safeString(value);
+		case "hidden": return safeString(value);
+	}
+	if (Array.isArray(value)) return value.join(", ");
+	if (typeof value === "boolean") return value ? "Yes" : "No";
+	if (value instanceof Date) return value.toISOString();
+	return safeString(value);
+}
+/**
+* Format a date for export.
+*
+* @param date - Date value (Date object or string)
+* @param format - Output format ("iso" or "locale")
+* @returns Formatted date string
+*/
+function formatDate(date, format = "iso") {
+	if (!date) return "";
+	const d = typeof date === "string" ? new Date(date) : date;
+	if (isNaN(d.getTime())) return "";
+	return format === "iso" ? d.toISOString() : d.toLocaleString();
+}
+/**
+* Escape a value for CSV format (RFC 4180 compliant).
+*
+* Rules:
+* - Fields containing comma, double-quote, or newline must be quoted
+* - Double-quotes within fields must be escaped with another double-quote
+*
+* @param value - The value to escape
+* @param delimiter - The delimiter being used
+* @returns Properly escaped CSV value
+*/
+function escapeCSVValue(value, delimiter = ",") {
+	const escapedFormula = /^[=+\-@\t\r]/.test(value) && !/^-?\d+(\.\d+)?$/.test(value) ? `'${value}` : value;
+	if (!(escapedFormula.includes(delimiter) || escapedFormula.includes("\"") || escapedFormula.includes("\n") || escapedFormula.includes("\r"))) return escapedFormula;
+	return `"${escapedFormula.replace(/"/g, "\"\"")}"`;
+}
+/**
+* Export submissions to CSV format.
+*
+* Generates an RFC 4180 compliant CSV string with:
+* - Form field values as columns (in form definition order)
+* - Optional metadata columns at the end (_id, _status, _submittedAt, etc.)
+* - Proper escaping of special characters
+* - Optional UTF-8 BOM for Excel compatibility
+*
+* @param submissions - Array of submission documents to export
+* @param form - Form document containing field definitions
+* @param options - Export options
+* @returns CSV formatted string
+*
+* @example
+* ```typescript
+* const csv = exportToCSV(submissions, form, {
+*   includeMetadata: true,
+*   includeBOM: true,
+* });
+*
+* // Download in browser
+* downloadFile(csv, 'submissions.csv', 'text/csv;charset=utf-8');
+* ```
+*/
+function exportToCSV(submissions, form, options = {}) {
+	const { includeMetadata = true, delimiter = ",", includeBOM = true, dateFormat = "iso" } = options;
+	const exportableFields = form.fields;
+	const headers = [];
+	for (const field of exportableFields) headers.push(field.label);
+	if (includeMetadata) headers.push("ID", "Status", "Submitted At", "IP Address", "User Agent");
+	const rows = [];
+	for (const submission of submissions) {
+		const row = [];
+		const data = submission.data;
+		for (const field of exportableFields) {
+			const value = data[field.name];
+			const formatted = formatExportValue(value, field);
+			row.push(escapeCSVValue(formatted, delimiter));
+		}
+		if (includeMetadata) {
+			row.push(escapeCSVValue(submission.id, delimiter));
+			row.push(escapeCSVValue(submission.status, delimiter));
+			row.push(escapeCSVValue(formatDate(submission.submittedAt, dateFormat), delimiter));
+			row.push(escapeCSVValue(submission.ipAddress || "", delimiter));
+			row.push(escapeCSVValue(submission.userAgent || "", delimiter));
+		}
+		rows.push(row);
+	}
+	const csvContent = [headers.map((h) => escapeCSVValue(h, delimiter)).join(delimiter), ...rows.map((row) => row.join(delimiter))].join("\r\n");
+	return includeBOM ? UTF8_BOM + csvContent : csvContent;
+}
+/**
+* Export submissions to JSON format.
+*
+* Generates a structured JSON export with:
+* - Export metadata (timestamp)
+* - Optional form definition
+* - Array of submissions with field values
+* - Optional submission metadata (_id, _status, etc.)
+*
+* @param submissions - Array of submission documents to export
+* @param form - Form document containing field definitions
+* @param options - Export options
+* @returns JSON formatted string
+*
+* @example
+* ```typescript
+* const json = exportToJSON(submissions, form, {
+*   includeMetadata: true,
+*   includeFormDefinition: true,
+*   indent: 2,
+* });
+*
+* // Download in browser
+* downloadFile(json, 'submissions.json', 'application/json');
+* ```
+*/
+function exportToJSON(submissions, form, options = {}) {
+	const { includeMetadata = true, includeFormDefinition = true, indent = 2 } = options;
+	const exportableFields = form.fields;
+	const formDefinition = includeFormDefinition ? {
+		id: form.id,
+		name: form.name,
+		slug: form.slug,
+		fields: exportableFields.map((f) => ({
+			name: f.name,
+			label: f.label,
+			type: f.type
+		}))
+	} : void 0;
+	const exportedSubmissions = submissions.map((submission) => {
+		const data = submission.data;
+		const fieldData = {};
+		for (const field of exportableFields) {
+			const value = data[field.name];
+			fieldData[field.name] = value;
+		}
+		if (includeMetadata) return {
+			...fieldData,
+			_metadata: {
+				id: submission.id,
+				status: submission.status,
+				submittedAt: submission.submittedAt,
+				ipAddress: submission.ipAddress || null,
+				userAgent: submission.userAgent || null,
+				createdAt: submission.createdAt,
+				updatedAt: submission.updatedAt
+			}
+		};
+		return fieldData;
+	});
+	const exportData = {
+		exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		totalSubmissions: submissions.length,
+		submissions: exportedSubmissions
+	};
+	if (formDefinition) exportData.form = formDefinition;
+	return JSON.stringify(exportData, null, indent);
+}
+/**
+* Trigger a file download in the browser.
+*
+* Creates a Blob from the content and triggers a download using a temporary
+* anchor element. This function is browser-only and will throw in Node.js.
+*
+* @param content - File content as string
+* @param filename - Name for the downloaded file
+* @param mimeType - MIME type of the file
+*
+* @example
+* ```typescript
+* const csv = exportToCSV(submissions, form);
+* downloadFile(csv, 'contact-form-submissions.csv', 'text/csv;charset=utf-8');
+*
+* const json = exportToJSON(submissions, form);
+* downloadFile(json, 'submissions.json', 'application/json');
+* ```
+*/
+function downloadFile(content, filename, mimeType) {
+	if (typeof window === "undefined" || typeof document === "undefined") throw new Error("downloadFile is only available in browser environments");
+	const blob = new Blob([content], { type: mimeType });
+	const url = URL.createObjectURL(blob);
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = filename;
+	document.body.appendChild(link);
+	link.click();
+	document.body.removeChild(link);
+	URL.revokeObjectURL(url);
+}
+/**
+* Generate a filename for export.
+*
+* Creates a filename with form slug and current timestamp.
+*
+* @param formSlug - The form's slug
+* @param format - Export format ('csv' or 'json')
+* @returns Generated filename
+*
+* @example
+* ```typescript
+* generateExportFilename('contact-form', 'csv');
+* // Returns: "contact-form-submissions-2024-01-15.csv"
+* ```
+*/
+function generateExportFilename(formSlug, format) {
+	return `${formSlug.toLowerCase().replace(/[^a-z0-9_-]+/g, "-") || "form"}-submissions-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${format}`;
+}
+/**
+* Export submissions and trigger browser download.
+*
+* Convenience function that combines export and download in one call.
+* Browser-only.
+*
+* @param submissions - Array of submission documents
+* @param form - Form document
+* @param format - Export format ('csv' or 'json')
+* @param options - Format-specific options
+*
+* @example
+* ```typescript
+* // In a React component
+* const handleExport = (format: 'csv' | 'json') => {
+*   exportAndDownload(submissions, form, format);
+* };
+* ```
+*/
+function exportAndDownload(submissions, form, format, options) {
+	const filename = generateExportFilename(form.slug, format);
+	if (format === "csv") downloadFile(exportToCSV(submissions, form, options), filename, "text/csv;charset=utf-8");
+	else downloadFile(exportToJSON(submissions, form, options), filename, "application/json");
+}
+
+// src/emails/starter-messages.ts
+/** The team's email: every answer, so the inbox has the whole submission. */
+const FORM_SUBMISSION_TEMPLATE = "forms-submission";
+/** The visitor's email: confirms the submission arrived, with a copy. */
+const FORM_CONFIRMATION_TEMPLATE = "forms-confirmation";
+/** The answers as a two-column table, label then value, one row each. */
+const ANSWERS_TABLE = "<table role=\"presentation\" cellpadding=\"0\" cellspacing=\"0\" style=\"width: 100%; border-collapse: collapse;\">{% for answer in _submission.answers %}<tr><td style=\"width: 40%; padding: 8px 16px 8px 0; vertical-align: top; font-weight: 600; overflow-wrap: anywhere;\">{{ answer.label }}</td><td style=\"padding: 8px 0; vertical-align: top; overflow-wrap: anywhere;\">{{ answer.value }}</td></tr>{% endfor %}</table>";
+/**
+* Shown where the table would be when no answer list was sent: the Email hub's
+* preview and Send test, whose sample data has a placeholder string for each
+* variable. A real send always carries a list, even an empty one, which
+* Liquid treats as present, so a sent email never shows this line.
+*/
+const PREVIEW_NOTE = `{% unless _submission.answers %}<p><em>Each answer appears here, its question then what was answered.</em></p>{% endunless %}`;
+/** The answers as plain text, one per line, for mail clients that show text. */
+const ANSWERS_TEXT = `{% for answer in _submission.answers %}{{ answer.label }}: {{ answer.value }}\n{% endfor %}`;
+/** The variables both messages are sent with, as the Email hub lists them. */
+const VARIABLES = [{
+	name: "formName",
+	description: "The form's name",
+	required: true
+}, {
+	name: "_submission",
+	description: "The submission: `_submission.answers` holds each answer as `label` and `value`, in the form's order, leaving out questions left blank or hidden by a condition; `_submission.id` is its id. It starts with an underscore, which no form field's name may, so it never meets a submitted field of the same name",
+	required: true
+}];
+/** The messages the plugin contributes to Settings › Email. */
+function formsEmailTemplates() {
+	return [{
+		slug: FORM_SUBMISSION_TEMPLATE,
+		name: "Form submission",
+		description: "Sent to your team when someone submits a form, with every answer.",
+		subject: "New submission: {{ formName }}",
+		htmlContent: `<p>Someone submitted <strong>{{ formName }}</strong>.</p>${ANSWERS_TABLE}${PREVIEW_NOTE}`,
+		plainTextContent: `Someone submitted {{ formName }}.\n\n${ANSWERS_TEXT}`,
+		variables: VARIABLES,
+		engine: "liquid"
+	}, {
+		slug: FORM_CONFIRMATION_TEMPLATE,
+		name: "Form confirmation",
+		description: "Sent to the person who submitted a form, confirming it arrived, with a copy of their answers.",
+		subject: "We received your submission",
+		htmlContent: `<p>Thank you. We received your answers to <strong>{{ formName }}</strong> and will be in touch if we need anything else.</p><p>Here is a copy of what you sent:</p>${ANSWERS_TABLE}${PREVIEW_NOTE}`,
+		plainTextContent: `Thank you. We received your answers to {{ formName }} and will be in touch if we need anything else.\n\nHere is a copy of what you sent:\n\n${ANSWERS_TEXT}`,
+		variables: VARIABLES,
+		engine: "liquid"
+	}];
+}
+/**
+* The starter message for a notification's kind: the confirmation when it goes
+* to the visitor (the address in one of the form's fields), the team's email
+* otherwise.
+*/
+function starterTemplateFor(recipientType) {
+	return recipientType === "field" ? FORM_CONFIRMATION_TEMPLATE : FORM_SUBMISSION_TEMPLATE;
 }
 
 // src/config/removed-options.ts
@@ -533,7 +1033,11 @@ const DEFAULT_FORM_SETTINGS = {
 	submitButtonText: "Submit",
 	confirmationType: "message",
 	successMessage: "Thank you for your submission!",
-	allowMultipleSubmissions: true
+	allowMultipleSubmissions: true,
+	oneResponse: "off",
+	oneResponseVersion: 0,
+	botCheck: "default",
+	storeIpAndBrowser: true
 };
 /**
 * Default notification settings.
@@ -628,15 +1132,11 @@ function applyFormDefaults(config) {
 			plural: config.labels?.plural || pluralize(singularLabel)
 		},
 		settings: {
+			...config.settings,
 			submitButtonText: config.settings?.submitButtonText || DEFAULT_FORM_SETTINGS.submitButtonText,
 			confirmationType: config.settings?.confirmationType || DEFAULT_FORM_SETTINGS.confirmationType,
 			successMessage: config.settings?.successMessage || DEFAULT_FORM_SETTINGS.successMessage,
-			allowMultipleSubmissions: config.settings?.allowMultipleSubmissions ?? DEFAULT_FORM_SETTINGS.allowMultipleSubmissions,
-			redirectUrl: config.settings?.redirectUrl,
-			redirectRelation: config.settings?.redirectRelation,
-			honeypotEnabled: config.settings?.honeypotEnabled,
-			captchaEnabled: config.settings?.captchaEnabled,
-			captchaSiteKey: config.settings?.captchaSiteKey
+			allowMultipleSubmissions: config.settings?.allowMultipleSubmissions ?? DEFAULT_FORM_SETTINGS.allowMultipleSubmissions
 		},
 		notifications: config.notifications ? {
 			enabled: config.notifications.enabled ?? DEFAULT_NOTIFICATION_SETTINGS.enabled,
@@ -721,17 +1221,63 @@ function asOptionalBoolean(value) {
 function asOptionalString(value) {
 	return typeof value === "string" && value !== "" ? value : void 0;
 }
+/** A whole number of zero or more, or `undefined`. */
+function asWholeNumber(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+/** A whole number above zero, or `undefined`. */
+function asPositiveWholeNumber(value) {
+	const whole = asWholeNumber(value);
+	return whole === void 0 || whole === 0 ? void 0 : whole;
+}
+const ONE_RESPONSE_MODES = [
+	"off",
+	"email",
+	"browser",
+	"ip"
+];
+const BOT_CHECK_MODES = [
+	"default",
+	"off",
+	"recaptcha",
+	"turnstile"
+];
+/**
+* The form's one-response mode: as stored, or read from the setting it
+* replaced, so no form's behaviour changes. Several responses allowed reads
+* as `"off"`; one per network address as `"ip"`, the only check it had.
+*/
+function oneResponseOf(source) {
+	const stored = ONE_RESPONSE_MODES.find((mode) => mode === source.oneResponse);
+	if (stored !== void 0) return stored;
+	if (asOptionalBoolean(source.allowMultipleSubmissions) === false) return "ip";
+	return DEFAULT_FORM_SETTINGS.oneResponse;
+}
+/**
+* The form's bot check: as stored, or read from the per-form reCAPTCHA
+* switch it replaced: unset follows the plugin, on is reCAPTCHA, off is off,
+* so no form's protection changes.
+*/
+function botCheckOf(source, captchaEnabled) {
+	const stored = BOT_CHECK_MODES.find((mode) => mode === source.botCheck);
+	if (stored !== void 0) return stored;
+	if (captchaEnabled === true) return "recaptcha";
+	if (captchaEnabled === false) return "off";
+	return DEFAULT_FORM_SETTINGS.botCheck;
+}
 /**
 * Normalize a stored settings value into the canonical {@link FormSettings}.
 *
 * Legacy keys are migrated on read (no data is lost, nothing is rewritten
 * until the form is next saved):
 * - `confirmationMessage` → `successMessage` + `confirmationType: "message"`
-* - nested `captcha: { enabled, siteKey }` → flat `captchaEnabled`/`captchaSiteKey`
+* - nested `captcha: { enabled, siteKey }` → flat `captchaSiteKey`, and its
+*   `enabled` read as `botCheck`
+* - `allowMultipleSubmissions` → `oneResponse`; `captchaEnabled` → `botCheck`
 *
 * Keys with no consumer (`showResetButton`, `resetButtonText`,
-* `storeSubmissions`, `submissionLimit`) are dropped: a setting that does
-* nothing must not survive into the UI.
+* `storeSubmissions`) are dropped: a setting that does nothing must not
+* survive into the UI.
 */
 function normalizeFormSettings(raw) {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { ...DEFAULT_FORM_SETTINGS };
@@ -746,510 +1292,633 @@ function normalizeFormSettings(raw) {
 		redirectUrl: asOptionalString(source.redirectUrl),
 		redirectPage: source.redirectPage ?? void 0,
 		redirectRelation: source.redirectRelation && typeof source.redirectRelation === "object" ? source.redirectRelation : void 0,
-		allowMultipleSubmissions: asOptionalBoolean(source.allowMultipleSubmissions) ?? DEFAULT_FORM_SETTINGS.allowMultipleSubmissions,
+		oneResponse: oneResponseOf(source),
+		oneResponseField: asOptionalString(source.oneResponseField),
+		oneResponseVersion: asWholeNumber(source.oneResponseVersion) ?? DEFAULT_FORM_SETTINGS.oneResponseVersion,
+		oneResponseKeyedVersion: asWholeNumber(source.oneResponseKeyedVersion),
 		honeypotEnabled: asOptionalBoolean(source.honeypotEnabled),
-		captchaEnabled: asOptionalBoolean(source.captchaEnabled) ?? asOptionalBoolean(legacyCaptcha?.enabled),
+		botCheck: botCheckOf(source, asOptionalBoolean(source.captchaEnabled) ?? asOptionalBoolean(legacyCaptcha?.enabled)),
+		closesAt: asOptionalString(source.closesAt),
+		submissionLimit: asPositiveWholeNumber(source.submissionLimit),
+		storeIpAndBrowser: asOptionalBoolean(source.storeIpAndBrowser) ?? DEFAULT_FORM_SETTINGS.storeIpAndBrowser,
+		keepDays: asPositiveWholeNumber(source.keepDays),
+		internalNote: asOptionalString(source.internalNote),
 		captchaSiteKey: asOptionalString(source.captchaSiteKey) ?? asOptionalString(legacyCaptcha?.siteKey)
 	};
 }
 
-// src/utils/evaluate-conditions.ts
-/**
-* Checks if a value is considered "empty".
-* Empty values: undefined, null, empty string, empty array.
-*/
-function isEmptyValue(value) {
-	if (value === void 0 || value === null) return true;
-	if (typeof value === "string" && value.trim() === "") return true;
-	if (Array.isArray(value) && value.length === 0) return true;
-	return false;
+// src/utils/condition-visibility.ts
+/** The names a field's enabled condition reads; none when it has none. */
+function namesRead(field) {
+	const logic = field.conditionalLogic;
+	return logic?.enabled === true ? logic.conditions.map((condition) => condition.field) : [];
 }
 /**
-* Converts a value to a number for numeric comparisons.
-* Returns NaN if conversion is not possible.
+* Which of a form's fields its conditions hide, for a given set of answers.
+*
+* A condition reads the answers of fields that are themselves shown, so a
+* hidden field's leftover answer never decides another field, and it may read
+* a field before or after its own. Fields are decided in the order their
+* conditions depend on each other, whatever their order on the form.
+*
+* Conditions can read each other in a loop (A shown when B is answered, B
+* shown when A is), and no order settles a loop. The rule for one: fields in
+* the same loop read each other's answers as given, and only the loop's
+* fields decide it, so an unrelated field elsewhere on the form never changes
+* the outcome.
+*
+* A field of type `hidden` is not one of them: it is sent with every
+* submission, unseen.
 */
-function toNumber(value) {
-	if (typeof value === "number") return value;
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		if (trimmed === "") return NaN;
-		return Number(trimmed);
-	}
-	return NaN;
+function fieldsHiddenByCondition(fields, answers) {
+	const byName = new Map(fields.map((field) => [field.name, field]));
+	const reach = /* @__PURE__ */ new Map();
+	/** Every field `name`'s condition depends on, directly or through others. */
+	const dependsOn = (name) => {
+		const known = reach.get(name);
+		if (known) return known;
+		const found = /* @__PURE__ */ new Set();
+		reach.set(name, found);
+		const pending = [name];
+		for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+			const field = byName.get(next);
+			for (const read of field ? namesRead(field) : []) if (!found.has(read)) {
+				found.add(read);
+				pending.push(read);
+			}
+		}
+		return found;
+	};
+	const shown = /* @__PURE__ */ new Map();
+	/** Whether field `name` is on the page, deciding what it reads first. */
+	const isShown = (name) => {
+		const decided = shown.get(name);
+		if (decided !== void 0) return decided;
+		const field = byName.get(name);
+		const logic = field?.conditionalLogic;
+		if (!field || logic?.enabled !== true) return true;
+		const read = Object.fromEntries(Object.entries(answers).filter(([other]) => !byName.has(other) || !namesRead(field).includes(other) || dependsOn(other).has(name) || isShown(other)));
+		const result = evaluateConditions(logic, read);
+		shown.set(name, result);
+		return result;
+	};
+	return new Set(fields.filter((field) => !isShown(field.name)).map((field) => field.name));
 }
+
+// src/types.ts
+/** Every built-in form field type, as a value list (the single source shared
+* by the field-type guard and the config validator). */
+const BUILT_IN_FORM_FIELD_TYPES = [
+	"text",
+	"email",
+	"number",
+	"phone",
+	"url",
+	"textarea",
+	"select",
+	"checkbox",
+	"radio",
+	"file",
+	"date",
+	"time",
+	"hidden"
+];
+const BUILT_IN_FORM_FIELD_TYPES_SET = new Set(BUILT_IN_FORM_FIELD_TYPES);
 /**
-* Converts a value to a string for string comparisons.
+* Narrow an `AnyFormField` to the closed built-in `FormField` union. Returns
+* `false` for a plugin-contributed field, so callers handle it generically
+* before switching on the built-in discriminant.
 */
-function toString(value) {
-	if (value === void 0 || value === null) return "";
-	if (typeof value === "string") return value;
-	if (Array.isArray(value)) return value.join(", ");
-	if (typeof value === "object") return JSON.stringify(value);
-	return String(value);
+function isKnownFormField(field) {
+	return BUILT_IN_FORM_FIELD_TYPES_SET.has(field.type);
 }
 /**
-* Compares two values using the specified operator.
-*
-* @param operator - The comparison operator to use
-* @param fieldValue - The actual value from the form data
-* @param conditionValue - The expected value from the condition
-* @returns Whether the comparison is true
+* Check if a value is a FormField.
 */
-function compareValues(operator, fieldValue, conditionValue) {
-	switch (operator) {
-		case "equals":
-			if (Array.isArray(fieldValue)) {
-				if (Array.isArray(conditionValue)) {
-					if (fieldValue.length !== conditionValue.length) return false;
-					return fieldValue.every((v, i) => v === conditionValue[i]);
-				}
-				return fieldValue.includes(conditionValue);
-			}
-			return toString(fieldValue) === toString(conditionValue);
-		case "notEquals":
-			if (Array.isArray(fieldValue)) {
-				if (Array.isArray(conditionValue)) {
-					if (fieldValue.length !== conditionValue.length) return true;
-					return !fieldValue.every((v, i) => v === conditionValue[i]);
-				}
-				return !fieldValue.includes(conditionValue);
-			}
-			return toString(fieldValue) !== toString(conditionValue);
-		case "contains": {
-			const fieldStr = toString(fieldValue).toLowerCase();
-			const conditionStr = toString(conditionValue).toLowerCase();
-			if (Array.isArray(fieldValue)) return fieldValue.some((v) => toString(v).toLowerCase().includes(conditionStr));
-			return fieldStr.includes(conditionStr);
-		}
-		case "isEmpty": return isEmptyValue(fieldValue);
-		case "isNotEmpty": return !isEmptyValue(fieldValue);
-		case "greaterThan": {
-			const fieldNum = toNumber(fieldValue);
-			const conditionNum = toNumber(conditionValue);
-			if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) return fieldNum > conditionNum;
-			return toString(fieldValue) > toString(conditionValue);
-		}
-		case "lessThan": {
-			const fieldNum = toNumber(fieldValue);
-			const conditionNum = toNumber(conditionValue);
-			if (!Number.isNaN(fieldNum) && !Number.isNaN(conditionNum)) return fieldNum < conditionNum;
-			return toString(fieldValue) < toString(conditionValue);
-		}
-		default:
-			console.warn(`[evaluateConditions] Unknown comparison operator: ${String(operator)}`);
-			return false;
-	}
+function isFormField(value) {
+	return typeof value === "object" && value !== null && "type" in value && "name" in value && "label" in value;
 }
 /**
-* Evaluates a single condition against the form data.
-*
-* Exported for consumers that gate on one condition rather than a full
-* conditional-logic block — notification send-conditions use exactly this.
-*
-* @param condition - The condition to evaluate
-* @param formData - The current form data
-* @returns Whether the condition is met
+* Check if a FormField is a specific type.
 */
-function evaluateSingleCondition(condition, formData) {
-	const { field, comparison, value: conditionValue } = condition;
-	return compareValues(comparison, getNestedValue(formData, field), conditionValue);
+function isFormFieldType(field, type) {
+	return field.type === type;
 }
 /**
-* Gets a nested value from an object using dot notation.
-*
-* @param obj - The object to get the value from
-* @param path - The path to the value (e.g., "address.city")
-* @returns The value at the path, or undefined if not found
+* Type guard for text field.
 */
-function getNestedValue(obj, path) {
-	if (!path) return;
-	if (!path.includes(".")) return obj[path];
-	const parts = path.split(".");
-	let current = obj;
-	for (const part of parts) {
-		if (current === void 0 || current === null) return;
-		if (typeof current !== "object") return;
-		current = current[part];
-	}
-	return current;
+function isTextFormField(field) {
+	return field.type === "text";
 }
 /**
-* Evaluates conditional logic to determine field visibility.
-*
-* This is the main entry point for conditional logic evaluation.
-* It evaluates all conditions according to the logical operator (AND/OR)
-* and returns whether the field should be visible based on the action
-* (show/hide).
-*
-* @param logic - The conditional logic configuration
-* @param formData - The current form data (field values)
-* @returns Whether the field should be visible
+* Type guard for email field.
+*/
+function isEmailFormField(field) {
+	return field.type === "email";
+}
+/**
+* Type guard for select field.
+*/
+function isSelectFormField(field) {
+	return field.type === "select";
+}
+/**
+* Type guard for checkbox field.
+*/
+function isCheckboxFormField(field) {
+	return field.type === "checkbox";
+}
+/**
+* Type guard for file field.
+*/
+function isFileFormField(field) {
+	return field.type === "file";
+}
+
+// src/utils/enforced-validation.ts
+/**
+* `message` appears on every row because it is honoured everywhere: each
+* generator passes `validation.errorMessage` to `applyRequired`, so even a type
+* with no bounds of its own uses it for the required failure.
 *
-* @example
-* ```typescript
-* // Show field when country is US AND age is over 18
-* const logic: ConditionalLogic = {
-*   enabled: true,
-*   action: 'show',
-*   operator: 'AND',
-*   conditions: [
-*     { field: 'country', comparison: 'equals', value: 'US' },
-*     { field: 'age', comparison: 'greaterThan', value: 18 },
-*   ],
-* };
+* Typed as a total `Record` rather than a partial one, so adding a field type
+* without deciding what it enforces is a compile error instead of a type that
+* silently offers nothing.
+*/
+const ENFORCED_VALIDATION_RULES = {
+	text: [
+		"minLength",
+		"maxLength",
+		"pattern",
+		"message"
+	],
+	email: ["pattern", "message"],
+	number: [
+		"min",
+		"max",
+		"message"
+	],
+	phone: ["pattern", "message"],
+	url: ["pattern", "message"],
+	textarea: [
+		"minLength",
+		"maxLength",
+		"message"
+	],
+	select: ["message"],
+	checkbox: ["message"],
+	radio: ["message"],
+	file: ["message"],
+	date: ["message"],
+	time: ["message"],
+	hidden: ["message"]
+};
+/**
+* The rules a field of this type both accepts and has enforced.
 *
-* evaluateConditions(logic, { country: 'US', age: 25 }); // true
-* evaluateConditions(logic, { country: 'US', age: 15 }); // false
-* evaluateConditions(logic, { country: 'CA', age: 25 }); // false
+* A plugin-contributed type has no row, and correctly gets nothing: this
+* runtime's generator has no clause for it, so every rule would be inert.
+*/
+function enforcedValidationRules(type) {
+	return ENFORCED_VALIDATION_RULES[type] ?? [];
+}
+
+// src/utils/generate-schema.ts
+/**
+* Generate a Zod validation schema from form field configuration.
 *
-* // Hide field when status is "completed"
-* const hideLogic: ConditionalLogic = {
-*   enabled: true,
-*   action: 'hide',
-*   operator: 'AND',
-*   conditions: [
-*     { field: 'status', comparison: 'equals', value: 'completed' },
-*   ],
-* };
+* Creates a dynamic Zod schema based on the form fields array,
+* applying appropriate validation rules for each field type.
 *
-* evaluateConditions(hideLogic, { status: 'completed' }); // false (hidden)
-* evaluateConditions(hideLogic, { status: 'pending' });   // true (visible)
-* ```
+* @param fields - Array of form field configurations
+* @returns Zod object schema for validating submission data
 *
 * @example
 * ```typescript
-* // Show field when either condition is met (OR)
-* const orLogic: ConditionalLogic = {
-*   enabled: true,
-*   action: 'show',
-*   operator: 'OR',
-*   conditions: [
-*     { field: 'role', comparison: 'equals', value: 'admin' },
-*     { field: 'role', comparison: 'equals', value: 'editor' },
-*   ],
-* };
+* const fields: FormField[] = [
+*   { type: 'text', name: 'firstName', label: 'First Name', required: true },
+*   { type: 'email', name: 'email', label: 'Email', required: true },
+*   { type: 'number', name: 'age', label: 'Age', validation: { min: 18, max: 120 } },
+* ];
 *
-* evaluateConditions(orLogic, { role: 'admin' });  // true
-* evaluateConditions(orLogic, { role: 'editor' }); // true
-* evaluateConditions(orLogic, { role: 'viewer' }); // false
+* const schema = generateZodSchema(fields);
+* const result = schema.safeParse({ firstName: 'John', email: 'john@example.com', age: 25 });
 * ```
 */
-function evaluateConditions(logic, formData) {
-	if (!logic || !logic.enabled) return true;
-	const { action, operator, conditions } = logic;
-	if (!conditions || conditions.length === 0) return true;
-	const results = conditions.map((condition) => evaluateSingleCondition(condition, formData));
-	let conditionsMet;
-	if (operator === "OR") conditionsMet = results.some((result) => result);
-	else conditionsMet = results.every((result) => result);
-	if (action === "hide") return !conditionsMet;
-	return conditionsMet;
+function generateZodSchema(fields) {
+	const schemaShape = {};
+	for (const field of fields) {
+		if (!isKnownFormField(field)) {
+			schemaShape[field.name] = field.required ? z.unknown().refine((value) => value !== void 0 && value !== null && value !== "", { message: `${field.label || field.name} is required` }) : z.unknown();
+			continue;
+		}
+		if (field.type === "hidden" && !field.required) {
+			schemaShape[field.name] = z.string().optional();
+			continue;
+		}
+		const fieldSchema = generateFieldSchema(field);
+		if (fieldSchema) schemaShape[field.name] = fieldSchema;
+	}
+	return z.object(schemaShape);
 }
 /**
-* Checks if a comparison operator is valid.
-*
-* @param operator - The operator to check
-* @returns Whether the operator is valid
+* Generate a Zod schema for a single field.
 */
-function isValidComparisonOperator(operator) {
-	return [
-		"equals",
-		"notEquals",
-		"contains",
-		"isEmpty",
-		"isNotEmpty",
-		"greaterThan",
-		"lessThan"
-	].includes(operator);
+function generateFieldSchema(field) {
+	switch (field.type) {
+		case "text": return generateTextSchema(field);
+		case "email": return generateEmailSchema(field);
+		case "number": return generateNumberSchema(field);
+		case "phone": return generatePhoneSchema(field);
+		case "url": return generateUrlSchema(field);
+		case "textarea": return generateTextareaSchema(field);
+		case "select": return generateSelectSchema(field);
+		case "checkbox": return generateCheckboxSchema(field);
+		case "radio": return generateRadioSchema(field);
+		case "file": return generateFileSchema(field);
+		case "date": return generateDateSchema(field);
+		case "time": return generateTimeSchema(field);
+		case "hidden": return generateHiddenSchema(field);
+		default: return z.unknown();
+	}
 }
 /**
-* Gets the list of supported comparison operators.
+* Generate schema for text field.
+*/
+/**
+* The author's own wording for a failure, or `undefined` when this field's type
+* does not enforce `message`.
+*
+* Asked of the row rather than read off `validation` directly, for the reason
+* the table exists at all: the editor decides whether to OFFER the control from
+* that row, so a generator honouring a stored message regardless would enforce
+* a value the author was never shown a box for — and, worse, the table would
+* describe a rule it did not govern.
+*
+* `message` was the one rule that stayed outside this. It agreed with the table
+* only because every row happens to list it, which is agreement by coincidence:
+* drop `message` from a row and the control disappears while the wording went
+* on being applied.
+*/
+function customMessage(field) {
+	if (!(ENFORCED_VALIDATION_RULES[field.type] ?? []).includes("message")) return void 0;
+	return field.validation?.errorMessage;
+}
+/**
+* A field's stored bounds, with the custom message already resolved by the row.
 *
-* @returns Array of supported operator names
+* Handed to the appliers so they cannot read an ungated message: they take a
+* validation object, and giving them one whose `errorMessage` has been through
+* {@link customMessage} makes the rule hold for every applier without each of
+* them having to remember it.
 */
-function getSupportedComparisonOperators() {
-	return [
-		"equals",
-		"notEquals",
-		"contains",
-		"isEmpty",
-		"isNotEmpty",
-		"greaterThan",
-		"lessThan"
-	];
+function enforcedValidation(field) {
+	return {
+		...field.validation ?? {},
+		errorMessage: customMessage(field)
+	};
 }
-
-// src/utils/export-formats.ts
-/** UTF-8 BOM character sequence */
-const UTF8_BOM = "";
 /**
-* Stringify a value safely, falling back to JSON for plain objects so we
-* never emit the default `[object Object]` representation.
+* Which rules a type's schema applies, and how each one constrains a string.
+*
+* The WHICH comes from {@link ENFORCED_VALIDATION_RULES}, which the field
+* editor also reads to decide what to offer. One definition answers both
+* questions, so a rule cannot be offered by the editor and ignored here, or
+* honoured here and hidden there — the two used to state the same thing
+* separately and could only agree by being edited together.
+*
+* The HOW stays here, because it is about zod and the table is deliberately
+* free of it: the editor imports the table, and pulling the schema builder in
+* behind it would ship this file and its validation library to every admin
+* client before anyone opened a field.
 */
-function safeString(value) {
-	if (typeof value === "object" && value !== null) return JSON.stringify(value);
-	return String(value);
+const STRING_RULE_APPLIERS = {
+	minLength: (schema, validation) => validation.minLength === void 0 ? schema : schema.min(validation.minLength, validation.errorMessage || `Minimum ${validation.minLength} characters required`),
+	maxLength: (schema, validation) => validation.maxLength === void 0 ? schema : schema.max(validation.maxLength, validation.errorMessage || `Maximum ${validation.maxLength} characters allowed`),
+	pattern: (schema, validation, fallback) => validation.pattern ? schema.regex(new RegExp(validation.pattern), validation.errorMessage || fallback) : schema
+};
+/** The same, for the bounds a number carries. */
+const NUMBER_RULE_APPLIERS = {
+	min: (schema, validation) => validation.min === void 0 ? schema : schema.min(validation.min, validation.errorMessage || `Minimum value is ${validation.min}`),
+	max: (schema, validation) => validation.max === void 0 ? schema : schema.max(validation.max, validation.errorMessage || `Maximum value is ${validation.max}`)
+};
+/**
+* Whether an author-supplied pattern actually replaces a type's intrinsic one.
+*
+* Two conditions, and both are load-bearing: a pattern must be stored, AND the
+* type's row must enforce `pattern`. A type that keeps its own shape check —
+* a phone, a URL — stands it down only for an override that will really be
+* applied, because standing down for one that will not leaves nothing behind.
+*/
+function overridesPattern(field) {
+	if (!(ENFORCED_VALIDATION_RULES[field.type] ?? []).includes("pattern")) return false;
+	const validation = field.validation ?? {};
+	return Boolean(validation.pattern);
 }
 /**
-* Format a field value for export based on field type.
+* Constrain a string schema by the rules this field's TYPE enforces.
 *
-* @param value - The raw value from submission data
-* @param field - The field definition (optional, for type-specific formatting)
-* @returns Formatted string representation of the value
+* A rule the type does not list is not applied even when the field carries a
+* value for it, which is the point: a `pattern` stored on a textarea is a bound
+* the editor never offered, and honouring it here would enforce a restriction
+* its author could not see.
 *
-* @example
-* ```typescript
-* formatExportValue(true, { type: 'checkbox' }); // "Yes"
-* formatExportValue(['a', 'b'], { type: 'select' }); // "a, b"
-* formatExportValue(new Date(), { type: 'date' }); // "2024-01-15"
-* ```
+* `patternMessage` is the type's own wording for a failed pattern — "Invalid
+* URL format" reads differently from "Invalid format" — so the rule set decides
+* WHICH constraints apply while each type keeps its own voice.
 */
-function formatExportValue(value, field) {
-	if (value === null || value === void 0) return "";
-	if (field) switch (field.type) {
-		case "checkbox": return value ? "Yes" : "No";
-		case "select":
-			if (Array.isArray(value)) return value.join(", ");
-			return safeString(value);
-		case "file":
-			if (Array.isArray(value)) return value.map((v) => safeString(v)).join(", ");
-			return safeString(value);
-		case "date":
-			if (value instanceof Date) return value.toISOString().split("T")[0];
-			if (typeof value === "string") {
-				const parsed = new Date(value);
-				if (!isNaN(parsed.getTime())) return parsed.toISOString().split("T")[0];
-			}
-			return safeString(value);
-		case "time": return safeString(value);
-		case "hidden": return safeString(value);
+function applyStringRules(schema, field, patternMessage) {
+	const validation = enforcedValidation(field);
+	let constrained = schema;
+	for (const rule of ENFORCED_VALIDATION_RULES[field.type] ?? []) {
+		const apply = STRING_RULE_APPLIERS[rule];
+		if (apply) constrained = apply(constrained, validation, patternMessage);
+	}
+	return constrained;
+}
+function generateTextSchema(field) {
+	return applyRequired(applyStringRules(z.string(), field, "Invalid format"), field.required, customMessage(field));
+}
+/**
+* Generate schema for email field.
+*/
+function generateEmailSchema(field) {
+	return applyRequired(applyStringRules(z.string().email(customMessage(field) || "Invalid email address"), field, "Invalid email format"), field.required, customMessage(field));
+}
+/**
+* Generate schema for number field.
+*/
+function generateNumberSchema(field) {
+	let schema = z.number({ error: (issue) => issue.input === void 0 ? customMessage(field) || "This field is required" : "Must be a number" });
+	const validation = enforcedValidation(field);
+	for (const rule of ENFORCED_VALIDATION_RULES[field.type] ?? []) {
+		const apply = NUMBER_RULE_APPLIERS[rule];
+		if (apply) schema = apply(schema, validation);
+	}
+	if (field.required) return schema;
+	return schema.optional().nullable();
+}
+/**
+* Generate schema for phone field.
+*/
+function generatePhoneSchema(field) {
+	return applyRequired(applyStringRules(overridesPattern(field) ? z.string() : z.string().regex(/^[\d\s\-+()]+$/, customMessage(field) || "Invalid phone number"), field, "Invalid phone number format"), field.required, customMessage(field));
+}
+/**
+* Generate schema for URL field.
+*/
+function generateUrlSchema(field) {
+	return applyRequired(applyStringRules(z.string().url(customMessage(field) || "Invalid URL"), field, "Invalid URL format"), field.required, customMessage(field));
+}
+/**
+* Generate schema for textarea field.
+*/
+function generateTextareaSchema(field) {
+	return applyRequired(applyStringRules(z.string(), field, "Invalid format"), field.required, customMessage(field));
+}
+/**
+* Generate schema for select field.
+*/
+function generateSelectSchema(field) {
+	const validValues = field.options.map((opt) => opt.value);
+	if (field.allowMultiple) {
+		const schema = z.array(z.enum(validValues));
+		if (field.required) return schema.min(1, customMessage(field) || "Please select at least one option");
+		return schema.optional();
 	}
-	if (Array.isArray(value)) return value.join(", ");
-	if (typeof value === "boolean") return value ? "Yes" : "No";
-	if (value instanceof Date) return value.toISOString();
-	return safeString(value);
+	const schema = z.enum(validValues, { error: () => customMessage(field) || "Please select a valid option" });
+	if (field.required) return schema;
+	return schema.optional();
 }
 /**
-* Format a date for export.
-*
-* @param date - Date value (Date object or string)
-* @param format - Output format ("iso" or "locale")
-* @returns Formatted date string
+* Generate schema for checkbox field.
 */
-function formatDate(date, format = "iso") {
-	if (!date) return "";
-	const d = typeof date === "string" ? new Date(date) : date;
-	if (isNaN(d.getTime())) return "";
-	return format === "iso" ? d.toISOString() : d.toLocaleString();
+function generateCheckboxSchema(field) {
+	const schema = z.boolean();
+	if (field.required) return schema.refine((val) => val === true, { message: customMessage(field) || "This field is required" });
+	return schema.optional();
 }
 /**
-* Escape a value for CSV format (RFC 4180 compliant).
-*
-* Rules:
-* - Fields containing comma, double-quote, or newline must be quoted
-* - Double-quotes within fields must be escaped with another double-quote
-*
-* @param value - The value to escape
-* @param delimiter - The delimiter being used
-* @returns Properly escaped CSV value
+* Generate schema for radio field.
 */
-function escapeCSVValue(value, delimiter = ",") {
-	const escapedFormula = /^[=+\-@\t\r]/.test(value) && !/^-?\d+(\.\d+)?$/.test(value) ? `'${value}` : value;
-	if (!(escapedFormula.includes(delimiter) || escapedFormula.includes("\"") || escapedFormula.includes("\n") || escapedFormula.includes("\r"))) return escapedFormula;
-	return `"${escapedFormula.replace(/"/g, "\"\"")}"`;
+function generateRadioSchema(field) {
+	const validValues = field.options.map((opt) => opt.value);
+	const schema = z.enum(validValues, { error: () => customMessage(field) || "Please select an option" });
+	if (field.required) return schema;
+	return schema.optional();
 }
 /**
-* Export submissions to CSV format.
-*
-* Generates an RFC 4180 compliant CSV string with:
-* - Form field values as columns (in form definition order)
-* - Optional metadata columns at the end (_id, _status, _submittedAt, etc.)
-* - Proper escaping of special characters
-* - Optional UTF-8 BOM for Excel compatibility
-*
-* @param submissions - Array of submission documents to export
-* @param form - Form document containing field definitions
-* @param options - Export options
-* @returns CSV formatted string
-*
-* @example
-* ```typescript
-* const csv = exportToCSV(submissions, form, {
-*   includeMetadata: true,
-*   includeBOM: true,
-* });
+* Generate schema for file field.
 *
-* // Download in browser
-* downloadFile(csv, 'submissions.csv', 'text/csv;charset=utf-8');
-* ```
+* Note: File validation is typically handled server-side.
+* This schema validates file references (IDs or URLs).
 */
-function exportToCSV(submissions, form, options = {}) {
-	const { includeMetadata = true, delimiter = ",", includeBOM = true, dateFormat = "iso" } = options;
-	const exportableFields = form.fields;
-	const headers = [];
-	for (const field of exportableFields) headers.push(field.label);
-	if (includeMetadata) headers.push("ID", "Status", "Submitted At", "IP Address", "User Agent");
-	const rows = [];
-	for (const submission of submissions) {
-		const row = [];
-		const data = submission.data;
-		for (const field of exportableFields) {
-			const value = data[field.name];
-			const formatted = formatExportValue(value, field);
-			row.push(escapeCSVValue(formatted, delimiter));
-		}
-		if (includeMetadata) {
-			row.push(escapeCSVValue(submission.id, delimiter));
-			row.push(escapeCSVValue(submission.status, delimiter));
-			row.push(escapeCSVValue(formatDate(submission.submittedAt, dateFormat), delimiter));
-			row.push(escapeCSVValue(submission.ipAddress || "", delimiter));
-			row.push(escapeCSVValue(submission.userAgent || "", delimiter));
-		}
-		rows.push(row);
+function generateFileSchema(field) {
+	if (field.multiple) {
+		const schema = z.array(z.string());
+		if (field.required) return schema.min(1, customMessage(field) || "Please upload at least one file");
+		return schema.optional();
 	}
-	const csvContent = [headers.map((h) => escapeCSVValue(h, delimiter)).join(delimiter), ...rows.map((row) => row.join(delimiter))].join("\r\n");
-	return includeBOM ? UTF8_BOM + csvContent : csvContent;
+	return applyRequired(z.string(), field.required, customMessage(field));
 }
 /**
-* Export submissions to JSON format.
-*
-* Generates a structured JSON export with:
-* - Export metadata (timestamp)
-* - Optional form definition
-* - Array of submissions with field values
-* - Optional submission metadata (_id, _status, etc.)
-*
-* @param submissions - Array of submission documents to export
-* @param form - Form document containing field definitions
-* @param options - Export options
-* @returns JSON formatted string
+* Generate schema for date field.
+*/
+function generateDateSchema(field) {
+	let schema = z.string();
+	schema = schema.refine((val) => {
+		if (!val) return true;
+		const date = new Date(val);
+		return !isNaN(date.getTime());
+	}, { message: customMessage(field) || "Invalid date" });
+	if (field.min || field.max) schema = schema.refine((val) => {
+		if (!val) return true;
+		const date = new Date(val);
+		if (field.min && date < new Date(field.min)) return false;
+		if (field.max && date > new Date(field.max)) return false;
+		return true;
+	}, { message: customMessage(field) || `Date must be between ${field.min || "any"} and ${field.max || "any"}` });
+	if (field.required) return schema.refine((val) => val !== void 0 && val !== null && val !== "", { message: customMessage(field) || "This field is required" });
+	return schema.optional().or(z.literal(""));
+}
+/**
+* Generate schema for time field.
+*/
+function generateTimeSchema(field) {
+	return applyRequired(z.string().regex(/^([0-1]?[0-9]|2[0-3]):[0-5][0-9]$/, customMessage(field) || "Invalid time format (HH:mm)"), field.required, customMessage(field));
+}
+/**
+* Generate schema for hidden field.
+*/
+function generateHiddenSchema(field) {
+	return applyRequired(z.string(), field.required, customMessage(field));
+}
+/**
+* Apply required/optional to a schema.
+*/
+function applyRequired(schema, required, errorMessage) {
+	if (required) return schema.min(1, errorMessage || "This field is required");
+	return schema.optional().or(z.literal(""));
+}
+/**
+* Transform form data before validation.
 *
-* @example
-* ```typescript
-* const json = exportToJSON(submissions, form, {
-*   includeMetadata: true,
-*   includeFormDefinition: true,
-*   indent: 2,
-* });
+* Handles type coercion and normalization:
+* - Converts string numbers to actual numbers
+* - Converts string booleans to actual booleans
+* - Trims string values
+* - Handles empty strings
 *
-* // Download in browser
-* downloadFile(json, 'submissions.json', 'application/json');
-* ```
+* @param data - Raw form data
+* @param fields - Form field configurations
+* @returns Transformed data ready for validation
 */
-function exportToJSON(submissions, form, options = {}) {
-	const { includeMetadata = true, includeFormDefinition = true, indent = 2 } = options;
-	const exportableFields = form.fields;
-	const formDefinition = includeFormDefinition ? {
-		id: form.id,
-		name: form.name,
-		slug: form.slug,
-		fields: exportableFields.map((f) => ({
-			name: f.name,
-			label: f.label,
-			type: f.type
-		}))
-	} : void 0;
-	const exportedSubmissions = submissions.map((submission) => {
-		const data = submission.data;
-		const fieldData = {};
-		for (const field of exportableFields) {
-			const value = data[field.name];
-			fieldData[field.name] = value;
-		}
-		if (includeMetadata) return {
-			...fieldData,
-			_metadata: {
-				id: submission.id,
-				status: submission.status,
-				submittedAt: submission.submittedAt,
-				ipAddress: submission.ipAddress || null,
-				userAgent: submission.userAgent || null,
-				createdAt: submission.createdAt,
-				updatedAt: submission.updatedAt
+function transformFormData(data, fields) {
+	const transformed = {};
+	for (const field of fields) {
+		const value = data[field.name];
+		if (value === void 0) continue;
+		transformed[field.name] = isKnownFormField(field) ? transformFieldValue(value, field) : value;
+	}
+	return transformed;
+}
+/**
+* Transform a single field value based on its type.
+*/
+function transformFieldValue(value, field) {
+	if (value === null || value === void 0) return value;
+	switch (field.type) {
+		case "number":
+			if (typeof value === "string") {
+				const num = parseFloat(value);
+				return isNaN(num) ? value : num;
 			}
-		};
-		return fieldData;
-	});
-	const exportData = {
-		exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		totalSubmissions: submissions.length,
-		submissions: exportedSubmissions
-	};
-	if (formDefinition) exportData.form = formDefinition;
-	return JSON.stringify(exportData, null, indent);
+			return value;
+		case "checkbox":
+			if (typeof value === "string") return value === "true" || value === "1" || value === "on";
+			return Boolean(value);
+		case "text":
+		case "email":
+		case "phone":
+		case "url":
+		case "textarea":
+		case "hidden":
+			if (typeof value === "string") return value.trim();
+			return value;
+		case "select":
+			if (field.allowMultiple) {
+				if (!Array.isArray(value)) return value ? [value] : [];
+			}
+			return value;
+		default: return value;
+	}
 }
 /**
-* Trigger a file download in the browser.
+* Validate form data against a form's field configuration.
 *
-* Creates a Blob from the content and triggers a download using a temporary
-* anchor element. This function is browser-only and will throw in Node.js.
+* Combines transformation and validation in one step.
 *
-* @param content - File content as string
-* @param filename - Name for the downloaded file
-* @param mimeType - MIME type of the file
+* @param data - Raw form data
+* @param fields - Form field configurations
+* @returns Zod safe parse result
 *
 * @example
 * ```typescript
-* const csv = exportToCSV(submissions, form);
-* downloadFile(csv, 'contact-form-submissions.csv', 'text/csv;charset=utf-8');
+* const result = validateFormData({ name: 'John', email: 'john@example.com' }, fields);
 *
-* const json = exportToJSON(submissions, form);
-* downloadFile(json, 'submissions.json', 'application/json');
+* if (result.success) {
+*   console.log('Valid data:', result.data);
+* } else {
+*   console.log('Validation errors:', result.error.flatten());
+* }
 * ```
 */
-function downloadFile(content, filename, mimeType) {
-	if (typeof window === "undefined" || typeof document === "undefined") throw new Error("downloadFile is only available in browser environments");
-	const blob = new Blob([content], { type: mimeType });
-	const url = URL.createObjectURL(blob);
-	const link = document.createElement("a");
-	link.href = url;
-	link.download = filename;
-	document.body.appendChild(link);
-	link.click();
-	document.body.removeChild(link);
-	URL.revokeObjectURL(url);
+function validateFormData(data, fields) {
+	const transformed = transformFormData(data, fields);
+	return generateZodSchema(fields).safeParse(transformed);
 }
 /**
-* Generate a filename for export.
-*
-* Creates a filename with form slug and current timestamp.
+* Whether the visitor supplied nothing at this field.
 *
-* @param formSlug - The form's slug
-* @param format - Export format ('csv' or 'json')
-* @returns Generated filename
-*
-* @example
-* ```typescript
-* generateExportFilename('contact-form', 'csv');
-* // Returns: "contact-form-submissions-2024-01-15.csv"
-* ```
+* The same four shapes the endpoint has always counted as blank. A `false`
+* checkbox and a `0` are answers, so neither is absent.
 */
-function generateExportFilename(formSlug, format) {
-	return `${formSlug.toLowerCase().replace(/[^a-z0-9_-]+/g, "-") || "form"}-submissions-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${format}`;
+function isBlank(value) {
+	return value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
 }
 /**
-* Export submissions and trigger browser download.
-*
-* Convenience function that combines export and download in one call.
-* Browser-only.
-*
-* @param submissions - Array of submission documents
-* @param form - Form document
-* @param format - Export format ('csv' or 'json')
-* @param options - Format-specific options
+* The failures with their codes, first one per field.
+*
+* A code as well as a sentence, because the public submission error has always
+* carried one and a client uses it to tell "you left this blank" from "this is
+* not an email" without parsing English. Flattening every failure to `INVALID`
+* silently stopped required-field detection working for those clients.
+*
+* The code is decided by looking at the SUBMITTED VALUE, not at the Zod issue.
+* Zod's codes do not divide the same way: `too_small` covers a blank answer and
+* a four-character password under a minimum of eight, and `invalid_type` covers
+* an absent key and a string sent to a number field. Reading the code alone
+* told a visitor to fill in a field they had already filled in.
+*/
+function getValidationIssues(result, submitted = {}) {
+	if (result.success) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const issues = [];
+	for (const issue of result.error.issues) {
+		const path = issue.path.join(".");
+		if (seen.has(path)) continue;
+		seen.add(path);
+		issues.push({
+			path,
+			code: isBlank(submitted[path]) ? "REQUIRED" : "INVALID",
+			message: issue.message
+		});
+	}
+	return issues;
+}
+/**
+* The same failures as a field-to-message map.
 *
-* @example
-* ```typescript
-* // In a React component
-* const handleExport = (format: 'csv' | 'json') => {
-*   exportAndDownload(submissions, form, format);
-* };
-* ```
+* Derived from {@link getValidationIssues} rather than walking the issues a
+* second time, so the two cannot disagree about which message belongs to a
+* field or which failure won when one field had several.
 */
-function exportAndDownload(submissions, form, format, options) {
-	const filename = generateExportFilename(form.slug, format);
-	if (format === "csv") downloadFile(exportToCSV(submissions, form, options), filename, "text/csv;charset=utf-8");
-	else downloadFile(exportToJSON(submissions, form, options), filename, "application/json");
+function getValidationErrors(result) {
+	return Object.fromEntries(getValidationIssues(result).map((issue) => [issue.path, issue.message]));
+}
+
+// src/utils/one-response-field.ts
+/** Why the chosen field cannot be made optional, conditional, or deleted. */
+const ONE_RESPONSE_FIELD_REASON = "This field is used for one response per person, so it stays required and always shown. Choose another Email field in Settings first.";
+/** Whether `field` can be the Email field one response per email compares. */
+function comparesByEmail(field) {
+	return field.type === "email" && field.required === true && field.conditionalLogic?.enabled !== true;
+}
+/** The fields one response per email may compare, in the form's order. */
+function emailFieldsToCompare(fields) {
+	return fields.filter(comparesByEmail);
+}
+/**
+* Why a form's one response per email cannot stand as saved, or undefined
+* when it can (or the form does not compare by email).
+*/
+function oneResponseFieldProblem(settings, fields) {
+	if (settings.oneResponse !== "email") return void 0;
+	const name = settings.oneResponseField;
+	if (!name) return "One response per email address needs an Email field to compare. Choose one in Settings.";
+	const field = fields.find((each) => each.name === name);
+	if (!field || field.type !== "email") return `One response per email address compares "${name}", which is not an Email field of this form.`;
+	return comparesByEmail(field) ? void 0 : `The Email field one response per person compares, "${field.label || name}", must be required and not hidden by a condition.`;
+}
+/**
+* Why an edit of `before` into `after` is refused, or undefined: the field
+* one response per email compares may be renamed but not made optional,
+* conditional or another type.
+*/
+function oneResponseEditProblem(before, after, settings) {
+	if (settings.oneResponse !== "email") return void 0;
+	if (settings.oneResponseField !== before.name) return void 0;
+	return comparesByEmail(after) ? void 0 : ONE_RESPONSE_FIELD_REASON;
 }
 
 // src/utils/field-references.ts
@@ -1273,12 +1942,31 @@ function parseFieldRef(value) {
 * Match `{{ fieldName }}` interpolations (whitespace-tolerant), the syntax the
 * notification send path resolves recipients and reply-to values with.
 */
+function templatePattern(fieldName, flags) {
+	return new RegExp(`\\{\\{\\s*${fieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\}\\}`, flags);
+}
 function referencesInTemplate(template, fieldName) {
-	return new RegExp(`\\{\\{\\s*${fieldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*\\}\\}`).test(template);
+	return templatePattern(fieldName).test(template);
+}
+/** The label a setting that refers to a field is named by. */
+const ONE_RESPONSE_SETTING = "One response per person";
+/**
+* The field one response per email compares, when the form takes one
+* response per email address; none otherwise.
+*/
+function oneResponseEmailField(settings) {
+	return settings?.oneResponse === "email" ? settings.oneResponseField : void 0;
 }
-/** All references to `fieldName` across the form's fields and notifications. */
-function findFieldReferences(fieldName, fields, notifications) {
+/**
+* All references to `fieldName` across the form's fields, notifications and
+* settings (the Email field one response per person compares).
+*/
+function findFieldReferences(fieldName, fields, notifications, settings) {
 	const references = [];
+	if (oneResponseEmailField(settings) === fieldName) references.push({
+		kind: "setting",
+		label: ONE_RESPONSE_SETTING
+	});
 	for (const field of fields) {
 		if (field.name === fieldName) continue;
 		if (!field.conditionalLogic?.enabled) continue;
@@ -1308,11 +1996,55 @@ function findFieldReferences(fieldName, fields, notifications) {
 * per-card lookup is O(1) instead of re-walking fields and notifications for
 * each card on every render.
 */
-function buildFieldReferenceMap(fields, notifications) {
+function buildFieldReferenceMap(fields, notifications, settings) {
 	const map = /* @__PURE__ */ new Map();
-	for (const field of fields) map.set(field.name, findFieldReferences(field.name, fields, notifications));
+	for (const field of fields) map.set(field.name, findFieldReferences(field.name, fields, notifications, settings));
 	return map;
 }
+/**
+* The fields with every condition on `from` naming `to` instead: the
+* conditions `findFieldReferences` reads, disabled ones too, so a rename never
+* leaves one pointing at a field that no longer has that name.
+*/
+function renameInFieldConditions(fields, from, to) {
+	return fields.map((field) => {
+		const logic = field.conditionalLogic;
+		if (!logic?.conditions?.some((condition) => condition.field === from)) return field;
+		return {
+			...field,
+			conditionalLogic: {
+				...logic,
+				conditions: logic.conditions.map((condition) => condition.field === from ? {
+					...condition,
+					field: to
+				} : condition)
+			}
+		};
+	});
+}
+/**
+* The notifications with every reference to `from` naming `to` instead: the
+* addresses (`{{ from }}`) and the condition `findFieldReferences` reads.
+*/
+function renameInNotifications(notifications, from, to) {
+	const pattern = templatePattern(from, "g");
+	const rename = (template) => template.replace(pattern, `{{${to}}}`);
+	return notifications.map((notification) => {
+		const { cc, bcc } = notification;
+		const next = {
+			...notification,
+			to: rename(notification.to)
+		};
+		if (cc) next.cc = cc.map(rename);
+		if (bcc) next.bcc = bcc.map(rename);
+		if (notification.replyTo !== void 0) next.replyTo = rename(notification.replyTo);
+		if (notification.condition?.field === from) next.condition = {
+			...notification.condition,
+			field: to
+		};
+		return next;
+	});
+}
 
-export { isKnownFormField as A, enforcedValidationRules as C, isFileFormField as D, isEmailFormField as E, SCHEMA_ONLY_CONTEXT as F, SCHEMA_ONLY_READ as I, documentReachability as L, isTextFormField as M, NEW_SUBMISSIONS_WIDGET_ID as N, isFormField as O, readNewSubmissions as P, parseRedirectReference as R, ENFORCED_VALIDATION_RULES as S, isCheckboxFormField as T, applyFormDefaults as _, exportToCSV as a, toTitleCase as b, generateExportFilename as c, getSupportedComparisonOperators as d, isValidComparisonOperator as f, applyFieldDefaults as g, DEFAULT_NOTIFICATION_SETTINGS as h, exportAndDownload as i, isSelectFormField as j, isFormFieldType as k, evaluateConditions as l, DEFAULT_FORM_SETTINGS as m, parseFieldRef as n, exportToJSON as o, normalizeFormSettings as p, downloadFile as r, formatExportValue as s, buildFieldReferenceMap as t, evaluateSingleCondition as u, createFormConfig as v, BUILT_IN_FORM_FIELD_TYPES as w, warnIfWebhooksConfigured as x, pluralize as y, pickedDocumentField as z };
-//# sourceMappingURL=field-references-CtzGg51W.js.map
+export { SCHEMA_ONLY_READ as $, applyFieldDefaults as A, downloadFile as B, isKnownFormField as C, normalizeFormSettings as D, fieldsHiddenByCondition as E, warnIfWebhooksConfigured as F, generateExportFilename as G, exportToCSV as H, FORM_CONFIRMATION_TEMPLATE as I, getSupportedComparisonOperators as J, evaluateConditions as K, FORM_SUBMISSION_TEMPLATE as L, createFormConfig as M, pluralize as N, DEFAULT_FORM_SETTINGS as O, toTitleCase as P, SCHEMA_ONLY_CONTEXT as Q, formsEmailTemplates as R, isFormFieldType as S, isTextFormField as T, exportToJSON as U, exportAndDownload as V, formatExportValue as W, NEW_SUBMISSIONS_WIDGET_ID as X, isValidComparisonOperator as Y, readNewSubmissions as Z, BUILT_IN_FORM_FIELD_TYPES as _, renameInNotifications as a, addressedFormPages as at, isFileFormField as b, emailFieldsToCompare as c, generateZodSchema as d, documentReachability as et, getValidationErrors as f, enforcedValidationRules as g, validateFormData as h, renameInFieldConditions as i, FORM_PAGES as it, applyFormDefaults as j, DEFAULT_NOTIFICATION_SETTINGS as k, oneResponseEditProblem as l, transformFormData as m, oneResponseEmailField as n, pickedDocumentField as nt, ONE_RESPONSE_FIELD_REASON as o, formPageId as ot, getValidationIssues as p, evaluateSingleCondition as q, parseFieldRef as r, FORM_EDITOR_VIEW as rt, comparesByEmail as s, formPageOf as st, buildFieldReferenceMap as t, parseRedirectReference as tt, oneResponseFieldProblem as u, isCheckboxFormField as v, isSelectFormField as w, isFormField as x, isEmailFormField as y, starterTemplateFor as z };
+//# sourceMappingURL=field-references-oCuFEwkr.js.map