@nextlyhq/plugin-form-builder 0.0.2-alpha.74 → 0.0.2-alpha.76

package/dist/submission-title-CVixn15Z.js

@@ -0,0 +1,2699 @@
+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.
+*
+* Three arrive in practice and they are not interchangeable: a polymorphic
+* field stores `{ relationTo, value }`; a read at depth replaces `value` with
+* the populated row; and a single-target field stores the bare id. The last
+* names no collection, so it resolves only when exactly one is configured —
+* guessing which of several a bare id belongs to would send visitors to a
+* URL built from the wrong collection's pattern.
+*/
+function parseRedirectReference(value, collections) {
+	if (value == null) return null;
+	if (typeof value === "string") {
+		const id = value.trim();
+		return id && collections.length === 1 ? {
+			collection: collections[0],
+			id
+		} : null;
+	}
+	if (typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const relationTo = record.relationTo;
+	const inner = record.value;
+	if (typeof relationTo === "string" && relationTo.trim()) {
+		const id = referenceId(inner);
+		return id ? {
+			collection: relationTo.trim(),
+			id
+		} : null;
+	}
+	const id = referenceId(record);
+	if (!id) return null;
+	return collections.length === 1 ? {
+		collection: collections[0],
+		id
+	} : null;
+}
+function referenceId(value) {
+	if (typeof value === "string") return value.trim() || null;
+	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+		const { id } = value;
+		if (typeof id === "string" && id) return id;
+	}
+	return null;
+}
+/**
+* The field the publish lifecycle puts on every row it manages.
+*
+* A collection without the lifecycle may legally define an ordinary field
+* named `status` — "active", "archived", anything — so the NAME `status` does
+* not identify a lifecycle and reading it as one marks live documents as
+* drafts. This field does identify it: it is written by the framework, not by
+* a schema author.
+*
+* Measured on 2026-08-25, creating one document in each kind of collection:
+* a `status: true` collection returns
+* `[createdAt, firstPublishedAt, id, slug, status, title, updatedAt]`, and a
+* plain collection carrying its own `status` text field returns the same list
+* WITHOUT `firstPublishedAt`. It is present on a never-published draft too, so
+* presence marks the lifecycle rather than the act of publishing.
+*/
+const PUBLISH_LIFECYCLE_FIELD = "firstPublishedAt";
+/**
+* Whether this document comes from a collection with the publish lifecycle.
+*
+* Callers that project their reads must request
+* {@link PUBLISH_LIFECYCLE_FIELD}; a projection that omits it makes every
+* document look unmanaged, which reads as "always reachable".
+*/
+function hasPublishLifecycle(document) {
+	return PUBLISH_LIFECYCLE_FIELD in document;
+}
+/**
+* Whether a visitor can reach this document.
+*
+* `collectionIsLocalized` is the caller's knowledge of the target collection's
+* `localized` setting, or `undefined` where the caller has no way to know.
+*
+* A localized collection publishes PER LOCALE, on a companion row that no read
+* available here returns. Measured on 2026-08-25 against a collection with
+* `localized: true` whose Spanish translation was published while the default
+* locale stayed a draft: `findByID` answers `status: "draft"` at the default
+* locale AND at `es`, and a `find` filtered to `status: "published"` returns
+* the document at no locale at all — no locale, `en` or `es`. So the main
+* row's `status` does not answer for a localized document, and reading it as
+* an answer marks a page visitors can reach as a draft, refuses a correct save
+* and drops a working redirect.
+*
+* `firstPublishedAt` is the one fact that survives that: it records whether the
+* document has ever been public in ANY language, so its absence is decisive
+* whether or not the collection is localized.
+*/
+function documentReachability(document, collectionIsLocalized) {
+	if (!hasPublishLifecycle(document)) return "reachable";
+	if (document.status === "published") return "reachable";
+	if (collectionIsLocalized === false) return "unreachable";
+	return "unknown";
+}
+/**
+* Which settings key names the document this form redirects to, if any.
+*
+* TWO options carry one. "Redirect to a page" stores `redirectPage`, and the
+* URL option falls back to `redirectRelation` when no URL is typed — the shape
+* code-first and legacy forms use, and one the submission path has always
+* resolved. One definition of the question, so the rule that guards a target
+* cannot recognise fewer shapes than the resolver that acts on it: a form the
+* rule skips is a form the resolver still redirects.
+*
+* The two are not equally strict about being EMPTY, deliberately. Naming
+* nothing under "Redirect to a page" contradicts the option itself, so it is
+* reported. Under the URL option an absent relation only means no destination
+* is configured yet — `validateFormConfig` already governs that, and refusing
+* it here would reject saves this rule never governed.
+*/
+function pickedDocumentField(settings) {
+	if (settings.confirmationType === "relationship") return "redirectPage";
+	if (settings.confirmationType === "redirect" && !settings.redirectUrl && settings.redirectRelation != null) return "redirectRelation";
+	return null;
+}
+
+// src/utils/schema-only-read.ts
+/**
+* The hook context that tells the forms collection's `afterRead` hook a read
+* wants the forms themselves and nothing only a display needs, so it skips
+* the submission count it would otherwise run per form: a write checking a
+* submission against its form, and the dashboard card scanning which forms a
+* reader may read, need the count no more than they need a second copy of
+* the form.
+*
+* @module utils/schema-only-read
+*/
+/** The context key the forms `afterRead` hook reads; `true` skips the count. */
+const SCHEMA_ONLY_READ = "formBuilder.schemaOnlyRead";
+/** The context a schema-only read hands the forms collection's hooks. */
+const SCHEMA_ONLY_CONTEXT = { [SCHEMA_ONLY_READ]: true };
+
+// src/dashboard/new-submissions.ts
+/** The widget's id, the one core's default names. */
+const NEW_SUBMISSIONS_WIDGET_ID = "form-builder/new-submissions";
+/** The status a submission arrives with, and keeps until someone opens it. */
+const NEW_STATUS = "new";
+/** The admin's root, which a row's link and the list's link start from. */
+const ADMIN_ROOT = "/admin";
+/** The most forms one read answers, the widget reads' own cap. */
+const FORM_PAGE = 50;
+/**
+* The most pages of forms read for the filter: 1,000 forms. Past that, the
+* later forms' submissions are left out of the card and the count, never
+* shown: what is missed is a reader's own, not someone else's. The count then
+* says it is a floor (`atLeast`), so nobody reads it as every one.
+*/
+const MAX_FORM_PAGES = 20;
+/** The submission fields a row is made from; no other is asked for. */
+const SUBMISSION_FIELDS = [
+	"id",
+	"form",
+	"data",
+	"submittedAt",
+	"createdAt"
+];
+/** The form fields a row is made from. */
+const FORM_FIELDS = [
+	"id",
+	"name",
+	"fields"
+];
+/**
+* Field names and labels that mark a form's name field, compared as letters
+* only (`lettersOf`), so case, spaces, underscores, hyphens and camelCase do
+* not matter: `firstName`, `first_name` and "First name" are all "firstname".
+*/
+const NAME_KEYS = /* @__PURE__ */ new Set([
+	"name",
+	"fullname",
+	"firstname",
+	"yourname",
+	"yourfullname",
+	"yourfirstname"
+]);
+/**
+* The most characters of an answer or a name a row carries. A form may leave
+* a field's length open, so a visitor's answer can be any length; the card
+* draws one line, and the rest would only weigh down its data and the page.
+*/
+const MAX_ROW_TEXT = 140;
+/** The answer types whose first line a row may show under its title. */
+const TEXT_TYPES = /* @__PURE__ */ new Set(["text", "textarea"]);
+/** Up to `limit` ids of forms the reader may read, by id, after `after`. */
+async function formIdPage(services, forms, page) {
+	const { items } = await services.find(forms, {
+		...page.after === void 0 ? {} : { where: { id: { greater_than: page.after } } },
+		sort: "id",
+		limit: page.limit,
+		select: ["id"],
+		status: "all",
+		context: SCHEMA_ONLY_CONTEXT,
+		...page.signal === void 0 ? {} : { signal: page.signal }
+	});
+	return items.flatMap((item) => typeof item.id === "string" ? [item.id] : []);
+}
+/**
+* The ids of the forms the reader may read, in pages of `FORM_PAGE`, by id,
+* at most `MAX_FORM_PAGES` of them. A form a read rule keeps from them is
+* never among them. Where the budget is spent, one more id says whether any
+* form was left out.
+*/
+async function readableFormIds(services, forms, signal) {
+	const ids = [];
+	let after;
+	for (let page = 0; page < MAX_FORM_PAGES; page += 1) {
+		const pageIds = await formIdPage(services, forms, {
+			after,
+			limit: FORM_PAGE,
+			signal
+		});
+		ids.push(...pageIds);
+		after = pageIds.at(-1);
+		if (pageIds.length < FORM_PAGE) return {
+			ids,
+			complete: true
+		};
+	}
+	return {
+		ids,
+		complete: (await formIdPage(services, forms, {
+			after,
+			limit: 1,
+			signal
+		})).length === 0
+	};
+}
+/**
+* The forms the reader may read, scanned once in `scope` where one is given:
+* the card's data and the header's count, answered in one request, share one
+* scan. Keyed by the forms collection, so a site that renamed it scans its own.
+*/
+function readableFormsOnce(services, forms, read) {
+	const scan = () => readableFormIds(services, forms, read.signal);
+	return read.scope === void 0 ? scan() : read.scope.getOrCompute(`readable-forms:${forms}`, scan);
+}
+/** The new submissions of the forms named: what the card lists and the header counts. */
+function newSubmissionsWhere(formIds) {
+	return {
+		status: { equals: "new" },
+		form: { in: [...formIds] }
+	};
+}
+/**
+* The card's data: the newest new submissions the card holds, and how many
+* there are. Asked with a `limit` of 0 it reads no rows and still counts
+* them, which is the header's count.
+*/
+async function readNewSubmissions(services, collections, read) {
+	const signal = read.signal === void 0 ? {} : { signal: read.signal };
+	const allHref = `${ADMIN_ROOT}/collections/${read.submissionsPath}`;
+	const collection = read.submissionsPath;
+	const readable = await readableFormsOnce(services, collections.forms, read);
+	if (readable.ids.length === 0) return {
+		items: [],
+		total: 0,
+		allHref,
+		collection
+	};
+	const found = await services.find(collections.submissions, {
+		where: newSubmissionsWhere(readable.ids),
+		sort: "-submittedAt",
+		limit: read.limit,
+		select: SUBMISSION_FIELDS,
+		status: "all",
+		total: true,
+		depth: 0,
+		...signal
+	});
+	const forms = await formsOf(services, collections.forms, found.items, signal);
+	return {
+		items: found.items.map((item) => submissionRow(item, forms.get(formIdOf(item.form) ?? ""), allHref)),
+		total: found.total ?? found.items.length,
+		...found.atLeast === true || !readable.complete ? { atLeast: true } : {},
+		allHref,
+		collection
+	};
+}
+/** The forms of the submissions drawn, by id: one read, of those forms only. */
+async function formsOf(services, forms, submissions, signal) {
+	const ids = [...new Set(submissions.flatMap((row) => formIdOf(row.form) ?? []))];
+	if (ids.length === 0) return /* @__PURE__ */ new Map();
+	const { items } = await services.find(forms, {
+		where: { id: { in: ids } },
+		limit: ids.length,
+		select: FORM_FIELDS,
+		status: "all",
+		context: SCHEMA_ONLY_CONTEXT,
+		...signal
+	});
+	return new Map(items.flatMap((item) => typeof item.id === "string" ? [[item.id, item]] : []));
+}
+/**
+* One submission as its row: who sent it, which form and what it opens with,
+* and when. `form` is absent where the reader may not read it, and every value
+* comes from a field the read answered, so a field kept from the reader is a
+* part of the row left out, never guessed.
+*/
+function submissionRow(submission, form, allHref) {
+	const id = typeof submission.id === "string" ? submission.id : "";
+	const answers = recordOf(submission.data);
+	const fields = fieldsOf(form?.fields);
+	const titleField = [fields.find(isNameField), fields.find((field) => field.type === "email")].find((field) => field !== void 0 && firstLine(answers[field.name]) !== void 0);
+	const title = titleField === void 0 ? void 0 : firstLine(answers[titleField.name]);
+	const excerpt = fields.filter((field) => TEXT_TYPES.has(field.type) && field !== titleField).map((field) => firstLine(answers[field.name])).find((line) => line !== void 0);
+	const formName = firstLine(form?.name);
+	const at = instantOf(submission.submittedAt) ?? instantOf(submission.createdAt);
+	return {
+		id,
+		title: title ?? "Submission",
+		...formName === void 0 ? {} : { form: formName },
+		...excerpt === void 0 ? {} : { excerpt },
+		...at === void 0 ? {} : { at },
+		href: `${allHref}/${encodeURIComponent(id)}`
+	};
+}
+/** Whether a form field asks for the submitter's name, by its name or its label. */
+function isNameField(field) {
+	return field.type === "text" && (NAME_KEYS.has(lettersOf(field.name)) || NAME_KEYS.has(lettersOf(field.label ?? "")));
+}
+/** A name or label as its letters alone, lower case: "Full name" is "fullname". */
+function lettersOf(text) {
+	return text.toLowerCase().replace(/[^a-z]/g, "");
+}
+/**
+* The first line of a text answer, trimmed and held to `MAX_ROW_TEXT`
+* characters, or `undefined` for none.
+*/
+function firstLine(value) {
+	if (typeof value !== "string") return void 0;
+	const line = value.split(/\r?\n/).map((part) => part.trim()).find((part) => part !== "");
+	return line === void 0 ? void 0 : clipped(line);
+}
+/**
+* `text` cut to its first `MAX_ROW_TEXT` characters with an ellipsis, where it
+* is longer. Counted in whole characters, so an emoji is never split in two.
+*/
+function clipped(text) {
+	const characters = Array.from(text);
+	if (characters.length <= MAX_ROW_TEXT) return text;
+	return `${characters.slice(0, MAX_ROW_TEXT).join("").trimEnd()}…`;
+}
+/** A relationship's id, whether the read answered the id or the related row. */
+function formIdOf(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "object" && value !== null && "id" in value) {
+		const { id } = value;
+		return typeof id === "string" ? id : void 0;
+	}
+}
+/** A JSON column's value, which some dialects answer as its text. */
+function parsedJson(value) {
+	if (typeof value !== "string") return value;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+/** A submission's answers, by field name. */
+function recordOf(value) {
+	const parsed = parsedJson(value);
+	return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+}
+/** A form's fields, as far as a row reads them; any other entry is skipped. */
+function fieldsOf(value) {
+	const parsed = parsedJson(value);
+	if (!Array.isArray(parsed)) return [];
+	return parsed.flatMap((entry) => {
+		if (typeof entry !== "object" || entry === null) return [];
+		const { type, name, label } = entry;
+		if (typeof type !== "string" || typeof name !== "string") return [];
+		return [{
+			type,
+			name,
+			...typeof label === "string" ? { label } : {}
+		}];
+	});
+}
+/** A date as an ISO string, or `undefined` when it is not one. */
+function instantOf(value) {
+	if (typeof value !== "string" && typeof value !== "number") return void 0;
+	const at = new Date(value);
+	return Number.isNaN(at.getTime()) ? void 0 : at.toISOString();
+}
+
+// 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;
+}
+/**
+* Converts a value to a number for numeric comparisons.
+* Returns NaN if conversion is not possible.
+*/
+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;
+}
+/**
+* Converts a value to a string for string comparisons.
+*/
+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);
+}
+/**
+* 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 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;
+	}
+}
+/**
+* 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 evaluateSingleCondition(condition, formData) {
+	const { field, comparison, value: conditionValue } = condition;
+	return compareValues(comparison, getNestedValue(formData, field), conditionValue);
+}
+/**
+* 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 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;
+}
+/**
+* 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 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;
+}
+/**
+* Checks if a comparison operator is valid.
+*
+* @param operator - The operator to check
+* @returns Whether the operator is valid
+*/
+function isValidComparisonOperator(operator) {
+	return [
+		"equals",
+		"notEquals",
+		"contains",
+		"isEmpty",
+		"isNotEmpty",
+		"greaterThan",
+		"lessThan"
+	].includes(operator);
+}
+/**
+* Gets the list of supported comparison operators.
+*
+* @returns Array of supported operator names
+*/
+function getSupportedComparisonOperators() {
+	return [
+		"equals",
+		"notEquals",
+		"contains",
+		"isEmpty",
+		"isNotEmpty",
+		"greaterThan",
+		"lessThan"
+	];
+}
+
+// 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) : [];
+}
+/**
+* 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 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/utils/asked-fields.ts
+/** A stored option value or label as text: a string or a number. */
+function textOf(value) {
+	if (typeof value === "string") return value;
+	return typeof value === "number" ? String(value) : "";
+}
+/** One form field as a submission keeps it. */
+function askedField(field) {
+	const options = field.options;
+	return {
+		name: field.name,
+		label: field.label || field.name,
+		type: field.type,
+		...Array.isArray(options) ? { options: options.map((option) => {
+			const { value, label } = option;
+			const text = textOf(value);
+			return {
+				value: text,
+				label: textOf(label) || text
+			};
+		}) } : {}
+	};
+}
+/** What a new submission with `data` was asked, from its form's fields. */
+function askedSnapshotOf(fields, data) {
+	const hidden = fieldsHiddenByCondition([...fields], data);
+	return {
+		fields: fields.map(askedField),
+		hidden: fields.map((field) => field.name).filter((name) => hidden.has(name))
+	};
+}
+/** A stored snapshot, read: as written, or a JSON string of it. */
+function readAskedSnapshot(value) {
+	let parsed = value;
+	if (typeof parsed === "string") try {
+		parsed = JSON.parse(parsed);
+	} catch {
+		return;
+	}
+	if (!parsed || typeof parsed !== "object") return void 0;
+	const { fields, hidden } = parsed;
+	if (!Array.isArray(fields)) return void 0;
+	return {
+		fields: fields.filter((field) => !!field && typeof field.name === "string" && typeof field.label === "string" && typeof field.type === "string"),
+		hidden: Array.isArray(hidden) ? hidden.filter((name) => typeof name === "string") : []
+	};
+}
+/**
+* The snapshot after staff edit answers. An answer that changed is read with
+* the field as it was when edited to, so an edit to an option added later
+* keeps that option's label; every other field stays as the visitor was
+* asked it. A submission with no snapshot keeps none.
+*/
+function askedAfterEdit(stored, fields, before, after) {
+	if (stored === void 0) return void 0;
+	const changed = new Set(fields.map((field) => field.name).filter((name) => JSON.stringify(before[name]) !== JSON.stringify(after[name])));
+	if (changed.size === 0) return stored;
+	const current = new Map(fields.map((field) => [field.name, field]));
+	const kept = stored.fields.map((field) => changed.has(field.name) && current.has(field.name) ? askedField(current.get(field.name)) : field);
+	for (const name of changed) if (!kept.some((field) => field.name === name) && current.has(name)) kept.push(askedField(current.get(name)));
+	return {
+		fields: kept,
+		hidden: stored.hidden.filter((name) => !changed.has(name))
+	};
+}
+/**
+* The fields a submission's page reads its answers with: as it was asked, or
+* the form as it is now for one stored before submissions kept that.
+*/
+function askedFieldsOf(stored, formFields, data) {
+	return readAskedSnapshot(stored) ?? askedSnapshotOf(formFields, data);
+}
+
+// src/utils/consent.ts
+/** Said when an edit of a submission would change a consent. */
+const CONSENT_EDIT_REFUSED = "A consent cannot be edited: it keeps what the visitor agreed to";
+/** Whether a value is a stored consent answer. */
+function isConsentAnswer(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const answer = value;
+	return typeof answer.agreed === "boolean" && typeof answer.text === "string";
+}
+/**
+* Whether the visitor agreed. Only an explicit yes counts: a box sends `on`,
+* a script `true`; anything else, a stray string included, is not consent.
+*/
+function agreedIn(value) {
+	if (value === true) return true;
+	if (typeof value === "string") return value === "true" || value === "1" || value === "on";
+	if (isConsentAnswer(value)) return value.agreed;
+	return false;
+}
+/**
+* The answer to store for what the visitor sent. The text is the form's, so a
+* visitor who posts an answer object with a text of their own still stores
+* the text the form shows.
+*/
+function consentAnswerOf(value, field) {
+	return {
+		agreed: agreedIn(value),
+		text: field.agreementText
+	};
+}
+function sameConsent(before, after) {
+	if (before === void 0) return after === void 0;
+	if (isConsentAnswer(before)) return isConsentAnswer(after) && before.agreed === after.agreed && before.text === after.text;
+	return JSON.stringify(before) === JSON.stringify(after);
+}
+/**
+* The answers of a stored submission that are consents: each consent field
+* of the form, and any answer stored as a consent, whatever field now has
+* its name. Read from the submission as well as the form, since a form can
+* lose its consent field, or give its name to another field, while its
+* submissions keep what was agreed to.
+*/
+function storedConsentNames(fields, stored) {
+	const names = new Set(fields.filter((field) => field.type === "consent").map((field) => field.name));
+	for (const [name, value] of Object.entries(stored)) if (isConsentAnswer(value)) names.add(name);
+	return [...names];
+}
+/**
+* The consents whose stored answer an edit would change: the edit's answers
+* against the stored ones, for each consent the submission holds. One left
+* out of the edit is a change too, since it would drop the answer.
+*/
+function editedConsents(fields, stored, edited) {
+	return storedConsentNames(fields, stored).filter((name) => !sameConsent(stored[name], edited[name]));
+}
+/** Said when the builder is asked to make a consent optional. */
+const CONSENT_REQUIRED_REASON = "A consent is always required: an answer nobody has to give records nothing";
+/**
+* A field as the builder keeps it after an edit, or why the edit is refused.
+* A consent stays required, so turning Required off is refused and said; a
+* field just made a consent becomes required, with a text to agree to.
+*/
+function consentFieldEdit(before, after) {
+	if (after.type !== "consent") return { field: after };
+	if (before.type === "consent" && after.required !== true) return { refused: CONSENT_REQUIRED_REASON };
+	const text = after.agreementText;
+	return { field: {
+		...after,
+		required: true,
+		agreementText: typeof text === "string" ? text : "I agree to the privacy policy"
+	} };
+}
+/** Said when a consent has no text to agree to. */
+const CONSENT_TEXT_REQUIRED = "A consent field needs the text the visitor agrees to.";
+/**
+* The consent fields with no text to agree to. A consent with a blank text
+* would record agreement to nothing, so a form holding one is not saved, by
+* the builder or any other door.
+*/
+function blankConsentFields(fields) {
+	return fields.filter((field) => field.type === "consent" && (typeof field.agreementText !== "string" || field.agreementText.trim() === ""));
+}
+/** Said when a visitor agreed to a text the form no longer shows. */
+const CONSENT_TEXT_CHANGED = "The text to agree to has changed since the form was loaded. Review it and agree again.";
+/**
+* The consent fields a new submission agreed to under a text the form no
+* longer shows. A visitor who sends the text they were shown (an answer of
+* `{ agreed, text }`) is held to it: if the author changed it while the form
+* was open, the submission is refused rather than recorded as agreement to
+* terms the visitor never saw. A bare yes carries no text, so it is taken
+* as agreement to the text the form shows now.
+*/
+function staleConsentNames(fields, data) {
+	return fields.filter((field) => field.type === "consent").filter((field) => {
+		const sent = data[field.name];
+		if (!sent || typeof sent !== "object" || Array.isArray(sent)) return false;
+		const text = sent.text;
+		return typeof text === "string" && text !== field.agreementText;
+	}).map((field) => field.name);
+}
+
+// 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.
+*/
+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.
+*
+* @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 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);
+		case "consent":
+			if (isConsentAnswer(value)) return `${value.agreed ? "Agreed" : "Not agreed"}: "${value.text}"`;
+			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);
+}
+/**
+* A choice answer by its options' labels as asked, several joined. A value
+* no option has (an option removed since) reads as itself.
+*/
+function optionLabels(field, value) {
+	return (Array.isArray(value) ? value : [value]).map((each) => {
+		const text = typeof each === "string" ? each : formatExportValue(each);
+		return field.options?.find((option) => option.value === text)?.label ?? text;
+	}).join(", ");
+}
+/** The kinds of field answered by picking among options. */
+const CHOICE_TYPES = /* @__PURE__ */ new Set(["select", "radio"]);
+/**
+* An answer as one line of text, read with the field as it was asked: a
+* choice by its options' labels, so a list and an export read "Backend
+* engineer" rather than the stored `backend-engineer`; anything else as
+* `formatExportValue` reads it.
+*/
+function answerText(value, field) {
+	if (value === null || value === void 0) return "";
+	return CHOICE_TYPES.has(field.type) ? optionLabels(field, value) : formatExportValue(value, field);
+}
+/**
+* A submission's answers as text, each read with its field as the submission
+* was asked it, or as the form has it now for a field it was not asked (one
+* added since) or a submission stored before submissions kept that. The
+* submissions list and the CSV export both read answers through this, so the
+* two cannot show one answer differently.
+*/
+function answerReader(submission, formFields) {
+	const data = submission.data ?? {};
+	const asked = new Map(askedFieldsOf(submission.asked, formFields, data).fields.map((each) => [each.name, each]));
+	return (field) => answerText(data[field.name], asked.get(field.name) ?? askedField(field));
+}
+/**
+* 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), headed by the
+*   fields' labels, a choice answer by its option's label
+* - 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 answer = answerReader(submission, exportableFields);
+		for (const field of exportableFields) row.push(escapeCSVValue(answer(field), 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
+/** Forms already told, so a config passing through both entry points hears it once. */
+const warned = /* @__PURE__ */ new Set();
+/**
+* Say so when a form config still sets `notifications.webhooks`.
+*
+* The plugin sends no webhooks of its own: a submission reaches other systems
+* through Nextly's `form.submission.created` webhook, so the option sends
+* nothing and the config is told what to use instead.
+*/
+function warnIfWebhooksConfigured(config) {
+	const notifications = config.notifications;
+	if (typeof notifications !== "object" || notifications === null) return;
+	if (!("webhooks" in notifications) || warned.has(config.slug)) return;
+	warned.add(config.slug);
+	console.warn(`[form-builder] Form "${config.slug}" sets notifications.webhooks, which the Form Builder no longer reads, so those webhooks are not sent. Subscribe an endpoint to Nextly's form.submission.created webhook instead: https://nextlyhq.com/docs/plugins/form-builder#webhooks`);
+}
+
+// src/config/defaults.ts
+/**
+* Default form settings.
+*/
+const DEFAULT_FORM_SETTINGS = {
+	submitButtonText: "Submit",
+	confirmationType: "message",
+	successMessage: "Thank you for your submission!",
+	allowMultipleSubmissions: true,
+	oneResponse: "off",
+	oneResponseVersion: 0,
+	botCheck: "default",
+	storeIpAndBrowser: true
+};
+/**
+* Default notification settings.
+*/
+const DEFAULT_NOTIFICATION_SETTINGS = {
+	enabled: true,
+	replyTo: true
+};
+/**
+* Converts a slug to title case.
+*
+* @param str - The slug string to convert
+* @returns Title case string
+*
+* @example
+* ```typescript
+* toTitleCase('contact-form'); // 'Contact Form'
+* toTitleCase('newsletter_signup'); // 'Newsletter Signup'
+* ```
+*/
+function toTitleCase(str) {
+	return str.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+/**
+* Generates a plural form from a singular label.
+* Handles common English pluralization rules.
+*
+* @param singular - The singular form
+* @returns The plural form
+*
+* @example
+* ```typescript
+* pluralize('Form'); // 'Forms'
+* pluralize('Category'); // 'Categories'
+* pluralize('Quiz'); // 'Quizzes'
+* ```
+*/
+function pluralize(singular) {
+	if (singular.endsWith("y") && !/[aeiou]y$/i.test(singular)) return singular.slice(0, -1) + "ies";
+	if (singular.endsWith("s") || singular.endsWith("x") || singular.endsWith("z") || singular.endsWith("ch") || singular.endsWith("sh")) return singular + "es";
+	return singular + "s";
+}
+/**
+* Apply default values to form configuration.
+*
+* This function takes a partial form configuration and returns a complete
+* configuration with all default values applied. User-specified values
+* are preserved and take precedence over defaults.
+*
+* @param config - Form configuration (may be partial)
+* @returns Configuration with defaults applied
+*
+* @example
+* ```typescript
+* import { applyFormDefaults } from '@nextly/plugin-form-builder';
+*
+* const config = {
+*   slug: 'contact-form',
+*   fields: [
+*     { type: 'text', name: 'name', label: 'Name' },
+*     { type: 'email', name: 'email', label: 'Email' },
+*   ],
+* };
+*
+* const result = applyFormDefaults(config);
+*
+* // Result:
+* // {
+* //   slug: 'contact-form',
+* //   labels: { singular: 'Contact Form', plural: 'Contact Forms' },
+* //   fields: [...],
+* //   settings: {
+* //     submitButtonText: 'Submit',
+* //     confirmationType: 'message',
+* //     successMessage: 'Thank you for your submission!',
+* //     allowMultipleSubmissions: true,
+* //   },
+* //   access: {
+* //     submit: () => true,
+* //     read: ({ req }) => !!req.user,
+* //   },
+* // }
+* ```
+*/
+function applyFormDefaults(config) {
+	warnIfWebhooksConfigured(config);
+	const singularLabel = config.labels?.singular || toTitleCase(config.slug);
+	return {
+		...config,
+		labels: {
+			singular: singularLabel,
+			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
+		},
+		notifications: config.notifications ? {
+			enabled: config.notifications.enabled ?? DEFAULT_NOTIFICATION_SETTINGS.enabled,
+			recipients: config.notifications.recipients || [],
+			subject: config.notifications.subject || `New submission for ${singularLabel}`,
+			replyTo: config.notifications.replyTo ?? DEFAULT_NOTIFICATION_SETTINGS.replyTo,
+			template: config.notifications.template
+		} : void 0,
+		access: {
+			submit: config.access?.submit || (() => true),
+			read: config.access?.read || (({ req }) => !!req.user)
+		}
+	};
+}
+/**
+* Apply default values to individual form field.
+*
+* This is a utility function for applying defaults to a single field,
+* useful when processing fields individually (e.g., in the Schema Builder).
+*
+* @param field - The field to apply defaults to
+* @returns Field with defaults applied
+*
+* @example
+* ```typescript
+* import { applyFieldDefaults } from '@nextly/plugin-form-builder';
+*
+* const field = { type: 'text', name: 'firstName' };
+* const fieldWithDefaults = applyFieldDefaults(field);
+* // { type: 'text', name: 'firstName', label: 'First Name', required: false }
+* ```
+*/
+function applyFieldDefaults(field) {
+	const label = field.label || (field.name ? toTitleCase(field.name.replace(/([A-Z])/g, " $1").trim()) : "");
+	return {
+		...field,
+		label,
+		required: field.required ?? false
+	};
+}
+/**
+* Creates a complete form config with minimal input.
+*
+* This is a convenience function for quickly creating form configs
+* with sensible defaults. Only the slug and fields are required.
+*
+* @param slug - The form slug
+* @param fields - Array of form fields
+* @param options - Optional additional configuration
+* @returns Complete form configuration
+*
+* @example
+* ```typescript
+* import { createFormConfig } from '@nextly/plugin-form-builder';
+*
+* const config = createFormConfig('contact', [
+*   { type: 'text', name: 'name', label: 'Name', required: true },
+*   { type: 'email', name: 'email', label: 'Email', required: true },
+*   { type: 'textarea', name: 'message', label: 'Message' },
+* ]);
+* ```
+*/
+function createFormConfig(slug, fields, options) {
+	return applyFormDefaults({
+		slug,
+		fields,
+		...options
+	});
+}
+
+// src/utils/form-settings.ts
+/**
+* The ONE reader for stored form settings. Settings were historically
+* written in two shapes (the builder's old context shape and the collection
+* group's declared shape), so every consumer — the builder UI and the
+* submit handler alike — normalizes through here instead of trusting the
+* stored keys.
+*/
+function asOptionalBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+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 `captchaSiteKey`, and its
+*   `enabled` read as `botCheck`
+* - `allowMultipleSubmissions` → `oneResponse`; `captchaEnabled` → `botCheck`
+*
+* Keys with no consumer (`showResetButton`, `resetButtonText`,
+* `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 };
+	const source = raw;
+	const legacyMessage = asOptionalString(source.confirmationMessage);
+	const legacyCaptcha = source.captcha && typeof source.captcha === "object" ? source.captcha : void 0;
+	const confirmationType = source.confirmationType === "redirect" || source.confirmationType === "relationship" ? source.confirmationType : "message";
+	return {
+		submitButtonText: asOptionalString(source.submitButtonText) ?? DEFAULT_FORM_SETTINGS.submitButtonText,
+		confirmationType,
+		successMessage: asOptionalString(source.successMessage) ?? legacyMessage ?? DEFAULT_FORM_SETTINGS.successMessage,
+		redirectUrl: asOptionalString(source.redirectUrl),
+		redirectPage: source.redirectPage ?? void 0,
+		redirectRelation: source.redirectRelation && typeof source.redirectRelation === "object" ? source.redirectRelation : void 0,
+		oneResponse: oneResponseOf(source),
+		oneResponseField: asOptionalString(source.oneResponseField),
+		oneResponseVersion: asWholeNumber(source.oneResponseVersion) ?? DEFAULT_FORM_SETTINGS.oneResponseVersion,
+		oneResponseKeyedVersion: asWholeNumber(source.oneResponseKeyedVersion),
+		honeypotEnabled: asOptionalBoolean(source.honeypotEnabled),
+		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/send-status.ts
+/** The states in which another attempt may still come. */
+const IN_PROGRESS = /* @__PURE__ */ new Set([
+	"waiting",
+	"retrying",
+	"sending"
+]);
+/** Where a send stands, an unrecorded one read as waiting. */
+function stateOf(send) {
+	return send.state ?? "waiting";
+}
+/** Whether another attempt at `send` may still come. */
+function sendInProgress(send) {
+	return IN_PROGRESS.has(stateOf(send));
+}
+/** The recipients a send lists: those it went to, else those it was for. */
+function listedOf(send) {
+	const sent = send.recipients ?? [];
+	return sent.length > 0 ? sent : send.configured ?? [];
+}
+/** A recipient's state in one send, from its outcome and the send's state. */
+function recipientState(send, recipient) {
+	if (recipient.outcome === "accepted") return "sent";
+	const state = stateOf(send);
+	if (state === "sent") return "failed";
+	return state;
+}
+/** One recipient's result in one send. */
+function statusIn(send, recipient) {
+	const state = recipientState(send, recipient);
+	return {
+		digest: recipient.digest,
+		hint: recipient.hint,
+		kind: recipient.kind,
+		source: recipient.source,
+		state,
+		retries: state === "sent" ? recipient.retries ?? 0 : 0,
+		at: send.changedAt ?? send.createdAt ?? null,
+		...state === "cancelled" && send.cancel ? { cancel: send.cancel } : {}
+	};
+}
+/**
+* Every recipient a notification's sends had for a submission, each with its
+* latest result, oldest first. A recipient a send left out (one Resend found
+* already reached) keeps the result it had.
+*/
+function latestByRecipient(sends) {
+	const latest = /* @__PURE__ */ new Map();
+	for (const send of sends) for (const recipient of listedOf(send)) {
+		if (recipient.outcome === "skipped") continue;
+		latest.set(recipient.digest, statusIn(send, recipient));
+	}
+	return [...latest.values()];
+}
+/**
+* Who Resend can send a notification to now: each recipient the notification
+* addresses as it is now (`configured`), then each recipient a send filter
+* added that its sends have not reached, since the filters add it again to
+* the next send. Whether each has received it is read from `history`, the
+* latest result per recipient.
+*/
+function addressableNow(configured, history) {
+	const latest = new Map(history.map((status) => [status.digest, status]));
+	const now = configured.map((recipient) => ({
+		digest: recipient.digest,
+		hint: recipient.hint,
+		source: recipient.source,
+		reached: latest.get(recipient.digest)?.state === "sent"
+	}));
+	const listed = new Set(now.map((recipient) => recipient.digest));
+	const missedAdded = history.filter((status) => status.source === "added" && status.state !== "sent" && !listed.has(status.digest)).map((status) => ({
+		digest: status.digest,
+		hint: status.hint,
+		source: status.source,
+		reached: false
+	}));
+	return [...now, ...missedAdded];
+}
+/**
+* The recipients a resend leaves out: each one `history` shows has received
+* it, except those ticked to send it to again.
+*/
+function reachedExcept(history, ticked) {
+	const again = new Set(ticked);
+	return history.filter((status) => status.state === "sent" && !again.has(status.digest)).map((status) => status.digest);
+}
+/** A recipient's status in words. */
+function recipientLook(status) {
+	switch (status.state) {
+		case "sent": return status.retries === 0 ? {
+			label: "Sent",
+			tone: "ok"
+		} : {
+			label: `Sent after ${status.retries} ${status.retries === 1 ? "retry" : "retries"}`,
+			tone: "warn"
+		};
+		case "failed": return {
+			label: "Failed",
+			tone: "bad"
+		};
+		case "cancelled": return {
+			label: "Cancelled",
+			tone: "quiet"
+		};
+		case "sending": return {
+			label: "Sending",
+			tone: "quiet"
+		};
+		case "retrying": return {
+			label: "Retrying",
+			tone: "warn"
+		};
+		default: return {
+			label: "Waiting",
+			tone: "quiet"
+		};
+	}
+}
+/**
+* A notification's status in words: the one its recipients share, or Partly
+* sent when they differ. Recipients all sent read as the one that took the
+* most retries.
+*/
+function notificationLook(statuses) {
+	const [first] = statuses;
+	if (!first) return {
+		label: "Waiting",
+		tone: "quiet"
+	};
+	if (!statuses.every((status) => status.state === first.state)) return {
+		label: "Partly sent",
+		tone: "warn"
+	};
+	return recipientLook(statuses.reduce((latest, status) => status.retries > latest.retries ? status : latest, first));
+}
+/** Why a send was cancelled, in words. */
+function cancelText(cancel) {
+	switch (cancel?.by) {
+		case "person": return "Cancelled in Settings › Email";
+		case "spam": return "Cancelled when the submission was marked Spam";
+		case "erasure": return "Cancelled when the address was erased";
+		default: return "Cancelled";
+	}
+}
+
+// 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",
+	"consent"
+];
+const BUILT_IN_FORM_FIELD_TYPES_SET = new Set(BUILT_IN_FORM_FIELD_TYPES);
+/**
+* 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 isKnownFormField(field) {
+	return BUILT_IN_FORM_FIELD_TYPES_SET.has(field.type);
+}
+/**
+* Check if a value is a FormField.
+*/
+function isFormField(value) {
+	return typeof value === "object" && value !== null && "type" in value && "name" in value && "label" in value;
+}
+/**
+* Check if a FormField is a specific type.
+*/
+function isFormFieldType(field, type) {
+	return field.type === type;
+}
+/**
+* Type guard for text field.
+*/
+function isTextFormField(field) {
+	return field.type === "text";
+}
+/**
+* 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.
+*
+* 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"],
+	consent: ["message"]
+};
+/**
+* The rules a field of this type both accepts and has enforced.
+*
+* 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.
+*
+* Creates a dynamic Zod schema based on the form fields array,
+* applying appropriate validation rules for each field type.
+*
+* @param fields - Array of form field configurations
+* @returns Zod object schema for validating submission data
+*
+* @example
+* ```typescript
+* 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 } },
+* ];
+*
+* const schema = generateZodSchema(fields);
+* const result = schema.safeParse({ firstName: 'John', email: 'john@example.com', age: 25 });
+* ```
+*/
+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] = field.required ? answered(fieldSchema, requiredMessage(field)) : fieldSchema;
+	}
+	return z.object(schemaShape);
+}
+/** What a required field missing from a submission says. */
+function requiredMessage(field) {
+	return customMessage(field) || `${field.label || field.name} is required`;
+}
+/**
+* `schema`, after a check that an answer was given at all. A required field
+* left out of a submission would otherwise fail on its type ("expected
+* string, received undefined"), which tells the visitor nothing; it is
+* refused as required instead, and the field's own checks run on an answer
+* that is there.
+*/
+function answered(schema, message) {
+	return z.custom((value) => value !== void 0 && value !== null, { message }).pipe(schema);
+}
+/**
+* Generate a Zod schema for a single field.
+*/
+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);
+		case "consent": return generateConsentSchema(field);
+		default: return z.unknown();
+	}
+}
+/**
+* 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.
+*
+* 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 enforcedValidation(field) {
+	return {
+		...field.validation ?? {},
+		errorMessage: customMessage(field)
+	};
+}
+/**
+* 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.
+*/
+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);
+}
+/**
+* Constrain a string schema by the rules this field's TYPE enforces.
+*
+* 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.
+*
+* `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 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();
+	}
+	const schema = z.enum(validValues, { error: () => customMessage(field) || "Please select a valid option" });
+	if (field.required) return schema;
+	return schema.optional();
+}
+/**
+* Generate schema for checkbox field.
+*/
+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();
+}
+/**
+* Generate schema for radio field.
+*/
+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();
+}
+/**
+* Generate schema for file field.
+*
+* Note: File validation is typically handled server-side.
+* This schema validates file references (IDs or URLs).
+*/
+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();
+	}
+	return applyRequired(z.string(), field.required, customMessage(field));
+}
+/**
+* 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 a consent field: the stored answer, which must say the
+* visitor agreed. Always required, whatever the field's own flag says, since
+* a consent nobody has to give records nothing.
+*/
+function generateConsentSchema(field) {
+	return z.object({
+		agreed: z.boolean(),
+		text: z.string()
+	}).refine((answer) => answer.agreed, { message: customMessage(field) || "This field is required" });
+}
+/**
+* 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.
+*
+* Handles type coercion and normalization:
+* - Converts string numbers to actual numbers
+* - Converts string booleans to actual booleans
+* - Trims string values
+* - Handles empty strings
+*
+* @param data - Raw form data
+* @param fields - Form field configurations
+* @returns Transformed data ready for validation
+*/
+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 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 "consent": return consentAnswerOf(value, field);
+		case "select":
+			if (field.allowMultiple) {
+				if (!Array.isArray(value)) return value ? [value] : [];
+			}
+			return value;
+		default: return value;
+	}
+}
+/**
+* Validate form data against a form's field configuration.
+*
+* Combines transformation and validation in one step.
+*
+* @param data - Raw form data
+* @param fields - Form field configurations
+* @returns Zod safe parse result
+*
+* @example
+* ```typescript
+* const result = validateFormData({ name: 'John', email: 'john@example.com' }, fields);
+*
+* if (result.success) {
+*   console.log('Valid data:', result.data);
+* } else {
+*   console.log('Validation errors:', result.error.flatten());
+* }
+* ```
+*/
+function validateFormData(data, fields) {
+	const transformed = transformFormData(data, fields);
+	return generateZodSchema(fields).safeParse(transformed);
+}
+/**
+* Whether the visitor supplied nothing at this field.
+*
+* The same four shapes the endpoint has always counted as blank. A `false`
+* checkbox and a `0` are answers, so neither is absent.
+*/
+function isBlank(value) {
+	return value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+}
+/**
+* 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.
+*
+* 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 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/sent-from.ts
+/**
+* The page a submission was sent from, as the submission keeps it: the web
+* address the visitor's browser reported in `Referer`, reduced to its origin
+* and path. Its query and fragment are dropped, since a page's address can
+* carry personal data there (a search, an email in a link, a token), and an
+* address that is not a web page (another scheme, or none) is not kept. The
+* browser reports it, so it is a hint for staff, not evidence.
+*
+* @module utils/sent-from
+*/
+/** The longest address kept, in characters; a longer one is not kept. */
+const PAGE_MAX = 2048;
+/** The page a `Referer` names, or undefined when it names no web page. */
+function pageFromReferer(referer) {
+	if (!referer) return void 0;
+	let url;
+	try {
+		url = new URL(referer);
+	} catch {
+		return;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") return void 0;
+	const page = `${url.origin}${url.pathname}`;
+	return page.length <= PAGE_MAX ? page : void 0;
+}
+
+// src/admin/components/submissions/submission-list-scope.ts
+const STATUS_TABS = [
+	"all",
+	"new",
+	"read",
+	"archived",
+	"spam"
+];
+/**
+* The scope's dates as a filter of `submittedAt`, or none for any date. The
+* upper bound is exclusive, so a range ending at the start of a day leaves
+* that day out, whatever the precision a dialect stores the time with.
+*/
+function sentBetween(scope) {
+	if (!scope.from && !scope.to) return void 0;
+	return {
+		...scope.from ? { greater_than_equal: scope.from } : {},
+		...scope.to ? { less_than: scope.to } : {}
+	};
+}
+/** The list's filter as the entries API takes it. */
+function listWhere(scope) {
+	const where = {};
+	if (scope.form) where.form = { equals: scope.form };
+	where.status = scope.status === "all" ? { not_equals: "spam" } : { equals: scope.status };
+	const sent = sentBetween(scope);
+	if (sent) where.submittedAt = sent;
+	return where;
+}
+/**
+* The list's order: newest first, and among submissions sent at the same
+* moment, by id. The id makes the order total, so a submission's newer and
+* older neighbours are always defined even when timestamps tie (imported
+* rows can share one). It is the tiebreak the entries API adds last anyway,
+* spelled out so the page's neighbour queries mirror it exactly.
+*/
+const LIST_SORT = "-submittedAt,id";
+/**
+* The list a submission's page counts it in: the list's filter, and the
+* submission itself. Opened from the New tab, the submission is marked Read
+* and leaves that filter; archiving or recovering it can too. Counted with
+* it, the page's "3 of 3" stays true to the list it was opened from rather
+* than reading "3 of 2", and its newer neighbours still count its place.
+*/
+function listWithWhere(scope, id) {
+	return { or: [listWhere(scope), { id: { equals: id } }] };
+}
+/**
+* The queries that find the submissions just newer and just older than the
+* one sent at `at` with id `id`, in LIST_SORT's order: each side is a strict
+* comparison on the timestamp, or the same timestamp and the id on that side.
+* The newer side is read in reverse, so its first row is the nearest one, and
+* its total is how many rows come before this submission in the list.
+*/
+function neighbourQueries(scope, at, id) {
+	const base = listWhere(scope);
+	const side = (time, tie) => ({
+		...base,
+		or: [{ submittedAt: { [time]: at } }, { and: [{ submittedAt: { equals: at } }, { id: { [tie]: id } }] }]
+	});
+	return {
+		newer: {
+			where: side("greater_than", "less_than"),
+			sort: "submittedAt,-id"
+		},
+		older: {
+			where: side("less_than", "greater_than"),
+			sort: LIST_SORT
+		}
+	};
+}
+/** The scope as an address carries it: a submission page's, or the export's. */
+function scopeParams(scope) {
+	const params = new URLSearchParams({ status: scope.status });
+	if (scope.form) params.set("form", scope.form);
+	if (scope.from) params.set("from", scope.from);
+	if (scope.to) params.set("to", scope.to);
+	return params;
+}
+/** A moment an address names, as an ISO date and time; none for anything else. */
+function momentOf(text) {
+	if (!text) return void 0;
+	const at = Date.parse(text);
+	return Number.isNaN(at) ? void 0 : new Date(at).toISOString();
+}
+/**
+* The scope an address carries, read defensively: an unknown status reads as
+* "all" and a date that is not one as no bound, so a hand-edited address
+* still lists something.
+*/
+function scopeFromSearch(search) {
+	const params = new URLSearchParams(search);
+	const status = params.get("status");
+	const form = params.get("form");
+	const from = momentOf(params.get("from"));
+	const to = momentOf(params.get("to"));
+	return {
+		status: STATUS_TABS.includes(status) ? status : "all",
+		...form ? { form } : {},
+		...from ? { from } : {},
+		...to ? { to } : {}
+	};
+}
+/** A submission's page, opened from the list `scope`. */
+function submissionPageAddress(submissionsSlug, id, scope) {
+	return `/admin/collections/${encodeURIComponent(submissionsSlug)}/${encodeURIComponent(id)}?${scopeParams(scope).toString()}`;
+}
+/** The export route, as the admin's API serves it. */
+const EXPORT_ROUTE = "/admin/api/plugins/@nextlyhq/plugin-form-builder/submissions/export";
+/**
+* The export of what a list shows, in `format`: every submission its scope
+* matches, or, given `ids`, exactly those (the rows ticked in it).
+*/
+function exportAddress(scope, format, ids) {
+	const params = scopeParams(scope);
+	params.set("format", format);
+	if (ids !== void 0) params.set("ids", ids.join(","));
+	return `${EXPORT_ROUTE}?${params.toString()}`;
+}
+
+// src/utils/notification-model.ts
+/**
+* Split typed addresses into a list: separated by commas, semicolons,
+* spaces or new lines, each trimmed, blanks and repeats dropped.
+*/
+function parseAddressList(text) {
+	const seen = /* @__PURE__ */ new Set();
+	const list = [];
+	for (const part of text.split(/[\s,;]+/)) {
+		const address = part.trim();
+		if (!address || seen.has(address.toLowerCase())) continue;
+		seen.add(address.toLowerCase());
+		list.push(address);
+	}
+	return list;
+}
+/**
+* A team notification's addresses: its list, or the single address it was
+* saved with. Trimmed, blanks dropped.
+*/
+function teamAddressesOf(notification) {
+	return (Array.isArray(notification.recipients) ? notification.recipients : typeof notification.to === "string" ? [notification.to] : []).map((address) => typeof address === "string" ? address.trim() : "").filter(Boolean);
+}
+/** A notification's conditions, as a match and a list. */
+function conditionsOf(notification) {
+	const stored = notification.conditions;
+	if (stored && Array.isArray(stored.list)) return {
+		match: stored.match === "any" ? "any" : "all",
+		list: stored.list.filter(isCondition)
+	};
+	return {
+		match: "all",
+		list: notification.condition ? [notification.condition] : []
+	};
+}
+function isCondition(value) {
+	return !!value && typeof value === "object" && typeof value.field === "string" && typeof value.comparison === "string";
+}
+/**
+* Whether a notification sends for these answers: every condition holds
+* (all) or one does (any). One with no conditions always sends.
+*/
+function conditionsMet(conditions, data) {
+	if (conditions.list.length === 0) return true;
+	const holds = (condition) => evaluateSingleCondition(condition, data);
+	return conditions.match === "any" ? conditions.list.some(holds) : conditions.list.every(holds);
+}
+/**
+* The file fields whose files go with a notification, by name: its own
+* choice, or for a rule saved before it, the fields marked to attach.
+*/
+function attachFieldsOf(notification, fields) {
+	if (Array.isArray(notification.attachFields)) return notification.attachFields.filter((name) => typeof name === "string");
+	return fieldsMarkedToAttach(fields);
+}
+/**
+* The file fields marked to attach to notification emails, by name: what
+* every email carried before each notification chose its own.
+*/
+function fieldsMarkedToAttach(fields) {
+	return fields.filter((field) => field.type === "file" && field.attachToEmail === true && typeof field.name === "string").map((field) => field.name);
+}
+/** The media ids a submission holds under the named file fields. */
+function attachmentsFrom(fieldNames, data) {
+	const attachments = [];
+	for (const name of fieldNames) {
+		const value = data[name];
+		for (const item of Array.isArray(value) ? value : [value]) if (typeof item === "string" && item) attachments.push({ mediaId: item });
+	}
+	return attachments;
+}
+
+// src/utils/field-references.ts
+/**
+* The one spelling of a field reference this plugin recognises: `{{fieldName}}`
+* with no spaces, and `\w` names.
+*
+* Exact, because the SEND path is exact — a value the admin accepts as a
+* reference and the send path does not is delivered with its braces intact,
+* straight to the mail provider. Both sides read this constant so the question
+* has one answer.
+*/
+const FIELD_REF_PATTERN = /^\{\{(\w+)\}\}$/;
+/** The field named by a reference, or `null` when the value is not one. */
+function parseFieldRef(value) {
+	if (!value) return null;
+	const match = value.match(FIELD_REF_PATTERN);
+	return match ? match[1] : null;
+}
+/**
+* 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 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, 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;
+		if ((field.conditionalLogic.conditions ?? []).some((condition) => condition.field === fieldName)) references.push({
+			kind: "condition",
+			label: field.label || field.name
+		});
+	}
+	for (const notification of notifications) {
+		if (!notification.enabled) continue;
+		const referencedByTemplate = [
+			notification.to,
+			...notification.cc ?? [],
+			...notification.bcc ?? [],
+			notification.replyTo
+		].filter((value) => typeof value === "string").some((template) => referencesInTemplate(template, fieldName));
+		const referencedByCondition = conditionsOf(notification).list.some((condition) => condition.field === fieldName);
+		const referencedByAttachment = notification.attachFields?.includes(fieldName) ?? false;
+		if (referencedByTemplate || referencedByCondition || referencedByAttachment) references.push({
+			kind: "notification",
+			label: notification.name || "Notification"
+		});
+	}
+	return references;
+}
+/**
+* Reference lists for every field in one pass, keyed by field name, so a
+* per-card lookup is O(1) instead of re-walking fields and notifications for
+* each card on every render.
+*/
+function buildFieldReferenceMap(fields, notifications, settings) {
+	const map = /* @__PURE__ */ new Map();
+	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 }}`), the conditions and the attached file fields
+* `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
+		};
+		if (notification.conditions) next.conditions = {
+			...notification.conditions,
+			list: notification.conditions.list.map((condition) => condition.field === from ? {
+				...condition,
+				field: to
+			} : condition)
+		};
+		if (notification.attachFields) next.attachFields = notification.attachFields.map((name) => name === from ? to : name);
+		return next;
+	});
+}
+
+// src/utils/submission-title.ts
+/**
+* Who sent a submission, as the admin names it: the first answer to a text
+* field named or labelled as a name, else the first email address answered,
+* else none. One rule, read by the write seam (which keeps it as the
+* submission's title, the admin's breadcrumb and list name) and by the
+* submission's page.
+*
+* @module utils/submission-title
+*/
+/**
+* The longest title kept, in characters. The title is a display copy of an
+* answer, stored as a text column, which MySQL holds to 255 characters; an
+* answer has no such limit, so a longer one is shortened here rather than
+* refusing the submission it names.
+*/
+const TITLE_MAX = 200;
+/**
+* The title a submission is stored with: who sent it, shortened to
+* TITLE_MAX characters with an ellipsis, or none.
+*/
+function submissionTitleOf(fields, data) {
+	const sender = senderOf(fields, data);
+	if (sender === void 0) return void 0;
+	const characters = Array.from(sender);
+	return characters.length <= TITLE_MAX ? sender : `${characters.slice(0, 199).join("").trimEnd()}…`;
+}
+function senderOf(fields, data) {
+	const answer = (name) => {
+		const value = data[name];
+		return typeof value === "string" ? value.trim() : "";
+	};
+	const named = fields.find((field) => field.type === "text" && /name/i.test(`${field.name} ${field.label ?? ""}`) && answer(field.name));
+	if (named) return answer(named.name);
+	const email = fields.find((field) => field.type === "email" && answer(field.name));
+	return email ? answer(email.name) : void 0;
+}
+
+export { applyFieldDefaults as $, getValidationIssues as A, fieldsHiddenByCondition as At, isKnownFormField as B, pickedDocumentField as Bt, ONE_RESPONSE_FIELD_REASON as C, isConsentAnswer as Ct, oneResponseFieldProblem as D, askedFieldsOf as Dt, oneResponseEditProblem as E, askedAfterEdit as Et, isCheckboxFormField as F, readNewSubmissions as Ft, latestByRecipient as G, formPageOf as Gt, isTextFormField as H, FORM_PAGES as Ht, isEmailFormField as I, SCHEMA_ONLY_CONTEXT as It, recipientLook as J, notificationLook as K, isFileFormField as L, SCHEMA_ONLY_READ as Lt, validateFormData as M, getSupportedComparisonOperators as Mt, enforcedValidationRules as N, isValidComparisonOperator as Nt, generateZodSchema as O, askedSnapshotOf as Ot, BUILT_IN_FORM_FIELD_TYPES as P, NEW_SUBMISSIONS_WIDGET_ID as Pt, DEFAULT_NOTIFICATION_SETTINGS as Q, isFormField as R, documentReachability as Rt, pageFromReferer as S, editedConsents as St, emailFieldsToCompare as T, storedConsentNames as Tt, addressableNow as U, addressedFormPages as Ut, isSelectFormField as V, FORM_EDITOR_VIEW as Vt, cancelText as W, formPageId as Wt, normalizeFormSettings as X, sendInProgress as Y, DEFAULT_FORM_SETTINGS as Z, listWhere as _, CONSENT_EDIT_REFUSED as _t, parseFieldRef as a, FORM_CONFIRMATION_TEMPLATE as at, scopeFromSearch as b, blankConsentFields as bt, attachFieldsOf as c, starterTemplateFor as ct, conditionsOf as d, exportAndDownload as dt, applyFormDefaults as et, fieldsMarkedToAttach as f, exportToCSV as ft, exportAddress as g, optionLabels as gt, LIST_SORT as h, generateExportFilename as ht, oneResponseEmailField as i, warnIfWebhooksConfigured as it, transformFormData as j, evaluateConditions as jt, getValidationErrors as k, readAskedSnapshot as kt, attachmentsFrom as l, answerReader as lt, teamAddressesOf as m, formatExportValue as mt, submissionTitleOf as n, pluralize as nt, renameInFieldConditions as o, FORM_SUBMISSION_TEMPLATE as ot, parseAddressList as p, exportToJSON as pt, reachedExcept as q, buildFieldReferenceMap as r, toTitleCase as rt, renameInNotifications as s, formsEmailTemplates as st, senderOf as t, createFormConfig as tt, conditionsMet as u, downloadFile as ut, listWithWhere as v, CONSENT_TEXT_CHANGED as vt, comparesByEmail as w, staleConsentNames as wt, submissionPageAddress as x, consentFieldEdit as xt, neighbourQueries as y, CONSENT_TEXT_REQUIRED as yt, isFormFieldType as z, parseRedirectReference as zt };
+//# sourceMappingURL=submission-title-CVixn15Z.js.map