@10x-media/form-builder 0.1.0-beta.4 → 0.1.0-beta.6

package/CHANGELOG.md

@@ -1,5 +1,117 @@
 # @10x-media/form-builder
 
+## 0.1.0-beta.6
+
+### Minor Changes
+
+- Email actions and consent polish, plus paddle-worldwide handoff asks.
+
+  - **New creatable multi-recipient email field.** To, Reply-to, CC, and BCC on the Email Team and
+    Confirmation actions accept multiple recipients as native badges, mixing picked department
+    addresses, free-typed emails, and `{{field}}` recipient tokens (drag-reorderable, `admin.width`
+    aware). Configurable via `email.recipients` (`allowCustom`, `fieldTokens`, `tokenFieldTypes`).
+  - **Half-width pairing** of the email address fields (To/Reply-to, CC/BCC).
+  - **Consent field polish:** no more redundant description (the source statement is the content); the
+    field block title and the source array rows now show the consent source's name; the condensed
+    department-emails array centers its remove control on the input.
+  - **Consent statements on every read.** An `afterRead` hook resolves statements onto the form doc, so
+    consent renders wherever the form is fetched (modal/client, not only RSC); `toFormDocument` falls
+    back to the doc-carried statements.
+  - **`toFormDocument`** accepts a populated redirect `reference` (`value: string | number | object |
+null`) and an optional `resolveRedirect` seam that fills `redirect.url`.
+  - **Versioned consent proof.** Submissions snapshot the agreed wording via `consent.snapshot`
+    (default `both`: a statement hash, the plain text, and the source name), for an audit trail
+    independent of later source edits.
+  - **File MIME picker** constrained to the host upload collection's `mimeTypes` (with an optional
+    `uploads.mimeTypes` override).
+
+  **BREAKING:** `emailTeam`/`confirmation` `to`, `cc`, `bcc`, and `replyTo` are now `string[]` (`text`
+  `hasMany`). A legacy single-string value reads as one recipient; Postgres consumers regenerate a
+  migration.
+
+## 0.1.0-beta.5
+
+### Minor Changes
+
+- Finish localizing the flow builder: the remaining transition, hint, empty-state, and fallback-title strings now go through the translation system (en and de).
+
+  Ship shadcn `country` and `state` field renderers so the shadcn registry covers every built-in field type, and export `COUNTRIES` and `US_STATES` from `@10x-media/form-builder/react` for them. A parity test now asserts the registry renderer set matches the package's `defaultRenderers`, so a new field type cannot ship without its shadcn renderer. The country and state option labels are intentionally left unlocalized (the stored value is the stable code).
+
+- Feedback round: host-owned consent sources with live statements, bare message blocks, form-level button labels, sequential step flow, poll field eligibility and outcome selection, and per-request sender addresses, plus a field-config cleanup pass (drop dead shared fields, source poll options from a field, admin polish). Also: consent sources identified by their own row id, a two-checkbox form header driving conditional Flow/Poll tabs, poll outcomes that support ties with extensible auto-close strategies, fully localized and department-routable email, concise list-view columns, and response messages with the same recall fidelity as action emails. This pass also redesigns the submission answers view around native Payload fields, adds a manual poll-close action with self-managing `mostVoted` outcomes, clarifies field labels in the flow builder, and adds a server-side `createSubmission` helper alongside a documented submit contract. Validation is simplified to a binary pass-or-fail (severities and warnings are gone), every rule now opens with a plain-language description, `matchesField` and custom rules target another field through a validated picker, `country` and `state` become opt-in field types, and the redirect response gains a field-composition seam.
+
+  **Breaking:**
+
+  - **Display settings are gone; the form's title is exposed instead.** The `display` group (`showTitle`/`title`/`intro`), its Display tab, `FormDocument.display`, and `FormDisplaySettings` are all removed, and `<Form>` no longer renders a heading or intro above the fields. Whether a form's title appears is the host's call: `FormDocument.title` carries the document title (the collection's existing required `useAsTitle` field) for a page to render, or not. Authored `display` data is orphaned on next save.
+  - **`message` is a bare, nameless block.** The block is its `content` rich text alone: no name, label, width, required, placeholder, description, validation, or `visibleWhen`. `FormFieldDefinition` gains `bare`, `FormFieldInstance.name` becomes optional, and instances are addressed by key (a name, else Payload's hidden block row id), so flow step assignment, render keys, and the builder's picker all keep working. Stored named message rows keep rendering, but resaving a form through the admin drops the name, so a flow referencing a legacy message by name needs that message re-assigned to its step. Bare blocks are excluded from repeater `subFields`, whose row plumbing is name-keyed. A bare definition must declare `value: 'none'`; the plugin throws at boot otherwise.
+  - **`response.submitLabel` is removed in favour of a `buttons` group.** Every form now carries `buttons` at the bottom of its Fields tab: `submitLabel` at full width, then `prevLabel` and `nextLabel` side by side in a row (previous first). Store the label at `buttons.submitLabel`; `FormResponseSettings` no longer carries `submitLabel` and `<Form>` ignores legacy stored values. The `<Form>`/`<FormControls>` label prop and the `buttons.fields` seam key are `prevLabel`/`defaultFields.prev` (the `renderBack` prop, `backButtonClassName`, `BackButtonRenderProps`, and the `fb-form__back` class keep the `back` name; only the label concept moved to `prev`).
+  - **A flow step's unset `next` falls through instead of ending the form.** `next` now has three states: absent falls through to the next step in array order (the last step ends the form), `null` is an explicit end of form regardless of position, and a step id is a jump. Matching transitions still win over all three. Flows relying on an unset `next` to end the form mid-array must set that step's next to "End of form" (`next: null`). Newly added steps previously carried no `next` and were silently terminal, so a fresh two-step flow showed Submit on step one and never reached step two. `__end__` is reserved as the builder's sentinel and rejected as a step id.
+  - **Consent references sources you own, not fields on the form.** A consent field now stores one thing, a source `key`. The statement, its policy page, and its link live on a `consentSourcesField()` you place on any collection or global you own, read back through a `consent.sources` resolver. The old machinery is removed wholesale: `defineConsentSource`, the consent-source registry, the `static` and `pageReference` built-ins, `resolveConsentLinks`, `buildConsentSourceConfig`, the per-source `sourceConfig` group, the `consentSources` plugin option, and the consent block's own `statement` and `optional` fields. Without a `consent.sources` resolver the `consent` field type is not registered at all, mirroring `uploads: false` removing `file`. The statement is a live reference resolved per request in the visitor's locale via `resolveConsentStatements()` (root + `/rsc`) and injected by `toFormDocument(doc, { consentStatements })`, so correcting a sentence corrects every form pointing at it, with nothing to re-save. Proof is id-based: `ConsentProof` is now `{ agreed, source, page?: { relationTo, id }, versionRef?, at }` (the old `ref` slug is gone); `versionRef` is the published version document's own id, captured only when the page's collection has drafts enabled (a collection with versions but no drafts, or none at all, records no `versionRef` rather than a misleading null). `required` now actually enforces (the field gained an intrinsic validator, since a missing consent coerces to `false`, a present value the shared required guard skipped), and `label`/`placeholder` drop off the block via `omitShared` because the statement is the visible text and the accessible name. Authored statements and source config from the previous shape are orphaned. New exports: `consentSourcesField`, `resolveConsentStatements`, the `ConsentSourceEntry`/`ConsentSourcePage`/`ConsentSourcesResolver` types, and `sanitizeUrl` (now also from `./react`).
+  - **`poll.resultsField` is a select over eligible fields.** It was free text. It now lists the form's named instances of field types declaring `pollEligible` (built-in: `select`), and server validation enforces the same rule on save, so a free-text or PII field can never be stored while the poll is enabled.
+  - **Some field types no longer store shared basics they never read.** `FormFieldDefinition.omitShared` lets a type leave chosen shared config fields (`label`, `placeholder`, `description`, `width`, `required`) unauthored while keeping the rest of the chrome; `name` is never omittable. Applied where the renderer proves the field dead: `checkbox`, `file`, `repeater`, and `date` no longer store a `placeholder` (browsers ignore one on a date input), and `calculation`, being server-derived and read-only, stores neither `placeholder` nor `required`. Those columns are dropped, orphaning any authored values. `OmittableSharedField` is exported.
+  - **`richText.editor` is now plugin-wide.** It previously overrode the action body fields only; it is now the default editor for every plugin rich text field (message content, response message, action bodies). The new `richText.bodyEditor` is the action-body-specific override and falls back to `editor`. A host that set `editor` to give email authors a different toolbar should rename it to `bodyEditor` to keep that scope. Consent statements are unaffected: they live on your `consentSourcesField()`, which carries its own `editor` option.
+  - **A consent source is identified by its own row id, not a hand-authored `key`.** `consentSourcesField()`'s rows no longer have a `key`; the array row's own auto-assigned id is the stable reference a consent field stores and a proof records, so renaming or reordering a row can never orphan either. The row's name, shown when picking a source and used as the policy-link text, is now called `name` (was `label`). Row-level descriptions were trimmed to the array itself and the page field, relabeled "Statement source" and described as: set it if you want a submission to save a reference to your policy. A `consent.sources` resolver returning the previous `{ key, label, ... }` shape must return `{ id, name, ... }` instead; existing consent field values referencing an old `key` no longer resolve to a source.
+  - **The form header gained two independent checkboxes, and the `buttons` group is gone.** `multistep` and `pollEnabled` are new top-level checkboxes: `multistep` reveals a **Flow** tab (previously always visible) and drives the client's step navigation, `pollEnabled` reveals a new **Poll** tab and replaces the previous nested `poll.enabled` (the poll group's own fields are otherwise unchanged). The **Buttons** group is gone: `submitLabel` now sits directly at the bottom of the Fields tab, and `nextLabel`/`prevLabel` sit in a row at the bottom of the Flow tab (shown once the flow has a step); all three are still reassembled into `FormDocument.buttons` the same way for `<Form>`. The `buttons.fields` composition seam now receives and returns a `{ submit, prev, next }` map keyed by slot instead of a single field array. A field a host adds alongside a default label no longer rides along automatically into `FormDocument.buttons`: `buttons`, like `poll`, is now a fixed allowlist on `toFormDocument` (previously it, like `response` still is, passed the whole group through), so surfacing a custom button field to the client now needs merging it into `toFormDocument`'s output by hand. `FormDocument` gains `multistep: boolean` and `pollEnabled: boolean`.
+  - **A poll outcome records a set of winners, not one.** `poll.outcome.winningValue` is `poll.outcome.winningValues`, an array: the admin winner picker is a multi-select, and a tie records every tied value instead of forcing a single pick. `resolvePollOutcome`'s `winningValue` argument is `winningValues`, also an array. `definePollOptionSource.resolveOutcome` may now return a single value, an array (a tie), or `undefined`.
+  - **The form title is localized.** `title` (the collection's `useAsTitle` field) now follows `localizeContent` like the rest of a form's visitor-facing text, required only in the default locale so other locales fall back to it instead of forcing a translation everywhere.
+  - **A poll's outcome type defaults to `mostVoted`, not `manual`, and the winner picker is hidden for every auto-resolving type, not just `mostVoted`.** A freshly enabled poll now resolves itself at close with no admin action required; picking `manual` still opts back into a hand-set winner. `poll.outcome.winningValues` shows only for `manual` now; it used to show for anything except `mostVoted`, so a `source` poll (or a host `definePollType` strategy) that previously let an editor hand-override its winner no longer offers that picker at all. A poll that already has an explicit `type` stored is unaffected; only one whose `type` was never saved picks up the new default.
+  - **Enabling a poll now requires a vote field.** With `pollEnabled` on and no `poll.resultsField` set, saving auto-picks the form's one eligible field (a named `select`, an opted-in `country`/`state`, or a custom `pollEligible` instance), asks you to choose when there are several, and refuses the save when there are none, unless the poll is driven by an option source or the `source` outcome type, which need no on-form field. Previously an enabled poll with no vote field saved without complaint and simply had nothing to aggregate.
+  - **Validation is binary; `severity` and `warnings` are gone.** A rule either blocks or passes, so the per-rule `severity` select, the `{ message, severity }` result form, `ValidationSeverity`, and the entire non-blocking `warnings` pathway are removed: the `FieldRendererProps.warnings` prop, the form state's `warnings`, `FieldShell`'s warning region, and `ValidateFieldResult.warnings`. A rule's `validate` now returns `true` (pass) or a `string` (a blocking error); every failure blocks submission. A custom renderer that read `warnings` should drop it, and a rule returning `{ message, severity: 'warning' }` now blocks like any other error.
+  - **`matchesField`'s target is a picker validated on save.** Its `field` param is authored by choosing from the form's own fields instead of typing a name (the value is still a stored field name, so no data migration), and it is checked on save: a target that no longer resolves to a field is a save error rather than a rule that silently never fires. The same picker and check are available to custom rules through the exported `fieldTargetParam`.
+
+  **Features:**
+
+  - Host-owned consent sources: `consentSourcesField()` is an array (`name`, rich text `statement`, optional polymorphic `page`) you place wherever your policies live, and `consent.sources` is the async `req`-scoped resolver that reads it back. The statement is authored rich text serialized through the same escaping and URL-sanitizing pipeline as action bodies; the policy link (a source's `name` plus a resolver-provided `url`) renders beside it, and the checkbox takes its accessible name from the statement flattened to its visible words. That flattener, `textOfBody`, is exported (root and `./react`) and handles rich text, legacy Slate, or a plain string. Multi-tenancy needs no plugin support: place the field on a tenant-scoped document and scope the resolver by `req`.
+  - Form-level button labels: `submitLabel`/`nextLabel`/`prevLabel`, localized following `localizeContent`, each resolved as `<Form>` prop, then the stored value, then the translated default. `buildSubmitLabelField`, `buildNextLabelField`, `buildPrevLabelField`, and `buildDefaultButtonFields` (keyed `submit`/`next`/`prev`) are exported, and `useFormContext()` now exposes the `form` document so custom chrome can read them.
+  - Sequential step fall-through: the flow builder's Default next select gains "Next step in order" as the default for an unset `next`, "End of form" maps to an explicit `null`, `normalizeFlow` preserves `null` as distinct from absent, and deleting a step cascades, clearing every `next` and transition aimed at it.
+  - Poll field eligibility: `pollEligible` on a field definition marks a type choosable as a poll's results field. The results endpoint gates anonymous reads on the same rule, serves option-source polls anonymously (buckets seeded in resolved order with the source's labels), fails closed with a 503 when a source throws, and refuses with a 403 while resolution is empty.
+  - A field type can source its own poll options: `FormFieldDefinition.resolveOptions` lets a `pollEligible` type produce its poll choices from the configured instance itself (for example a `hasMany` relationship to the voteable records) rather than from authored options or a shared source. The one resolution backs submission validation, the admin winner select, and results labeling alike; it is consulted after an `optionSource` and before the instance's authored `options`. `resolveEffectivePollOptions` (root and `/rsc`) and `ResolveFieldOptionsArgs` are exported.
+  - Poll outcome selection: `poll.outcome.winningValues` is admin-editable through a multi-select backed by an authenticated `GET /api/forms/:id/poll-options`, with `resolvedAt` server-stamped and access-locked (set, changed, or cleared by a hook; direct writes dropped). The group is composable through the `poll.outcomeFields` option, which receives the two default fields (`winningValues`, `resolvedAt`) and returns the group's fields verbatim, so a host can swap the winner picker for its own component; membership validation runs server-side regardless, so a swap cannot bypass it. `definePollOptionSource` gains a `resolveOutcome` seam, so `resolvePollOutcome` runs in auto mode with `winningValues` omitted and returns the recorded set either way. `resolveEffectivePollOptions` is the single option set backing the admin select, the endpoint, outcome validation, and a field type's `resolveOptions`, so what the admin offers and what the server accepts cannot drift. `buildWinningValuesField`, `buildResolvedAtField`, `buildDefaultOutcomeFields`, and `OutcomeFieldsOverride` are exported.
+  - Per-request sender addresses: `email.fromAddresses`, an async `req`-scoped resolver, gives both email actions a From select backed by an authenticated `GET /api/forms/:id/from-addresses`, validated for membership on save and passed through to `payload.sendEmail`. Intended for multi-tenant hosts scoping senders to the tenant derived from `req`. Absent (the default) adds no field and keeps the adapter's default sender.
+  - Admin polish: select option rows label their two fields `Label`/`Value` (were `Option label`/`Option value`) beneath an array already titled Option/Options; the flow step title's hardcoded, untranslatable placeholder is gone and the remaining English strings in the flow builder are translated; and `poll.outcome` and `response.redirect`, the two groups nested inside another group, render flush via `admin.hideGutter`.
+  - Extensible poll outcome types: `definePollType` registers a named outcome strategy (`resolveOutcome`), chosen per form via the poll's `type` select and configured plugin-wide via `poll.types`. Three ship and are always available: `manual` (default; an admin always sets the winner), `mostVoted` (auto-resolves to the top-voted value(s) once there are responses, a tie recording every co-winner, declining to decide on a truncated sample), and `source` (delegates to the poll's option source's own `resolveOutcome`). A poll with a `closesAt` and a non-`manual` type schedules its own resolution as a native Payload job (`waitUntil: closesAt`, re-enqueued on every save so the newest close date always wins); this needs a wired job runner (`config.jobs.autoRun`, a worker, or a serverless cron) to actually run. As a safety net with no runner, a closed, unresolved, non-manual poll also resolves the next time its results are read, by an admin or through the public endpoint alike.
+  - Department-routed email: the new `email.departments` plugin option turns `emailTeam`'s **To** into a select over host-managed addresses (an authenticated endpoint, validated on save, fails closed like `email.fromAddresses`). `departmentsField()` is the array a host places anywhere (a settings global, a tenant document) to hold the addresses, rendered as condensed flat rows with no per-row collapsible, and `resolveDepartmentOptions` builds the resolver's return value from it with a reusable current-locale -> default-locale -> next-available fallback. Independent of departments, **To** is now always localized like the subject and body, so a submission routes to the address stored for its own locale; the queued (job) dispatch path loads the form at the submission's own stored locale for the same reason.
+  - Concise, localized list columns: the `forms` list shows a field count ("6 Fields") and a step count ("2 steps", or none with no flow) instead of Payload's raw block/JSON summaries, plus a curated default column set (title, fields, flow, poll, updated at); `form-submissions` gets a curated default set too (form, status, locale, created at).
+  - Response messages interpolate recall tokens: a form's success message (`response.message`) now supports the same `{{field}}` / `{{field|fallback}}` / `{{field||fallback}}` tokens as an action body, resolved against the submission's own formatted answers (option labels, Yes/No, localized dates) and field descriptors, matching what `emailTeam`'s body already gave an admin.
+  - The submission answers view now renders with native Payload field components (the same `TextInput`/`FieldLabel`/`Pill` building blocks Payload's own fields use) instead of bespoke markup, and honors each field's authored width so the admin layout matches the widths editors set on the form. Consent renders as an Agreed/Declined `Pill` beside its source link and capture timestamp; `locale` and the submission `meta` (received-at time, IP/user agent when captured, spam signal) are folded into a single Submission-details section instead of separate top-level fields. `showSubmissionRawFields` now also gates `locale` and `meta`, alongside the existing `values`/`descriptors`/`consent`. `SubmissionDescriptor` gains `width`, and `SubmissionWidth` (`full`/`half`/`third`/`twoThirds`) is exported.
+  - A poll with no scheduled `closesAt` gets a manual **Close poll now** button in the admin, backed by an authenticated `POST /api/forms/:id/close`: it stamps `closesAt` to now and, for the `mostVoted`/`source` outcome types, resolves the winner the same way a scheduled auto-close would. A `manual` poll must already have a winner recorded, closing refuses (400) otherwise, and closing an already-closed poll is refused the same way. A `mostVoted` poll now manages its own outcome end to end: its `winningValues` field is hidden from the outcome group entirely (the strategy decides the winner, so there is nothing to hand-pick), whether it resolves on schedule or via this new button. The outcome `type` select reads more plainly, now with a description of what it does ("How the winning option is decided when the poll closes."): its options are `Set the winner manually`, `Most-voted option wins`, and `Winner from the option source` (the last hidden from the select until an option source is registered).
+  - The flow builder's field picker and unassigned-fields list now label each field with its authored `label` (falling back to the machine name) instead of the raw name, and label a bare message block with a short snippet of its authored content (falling back to its translated type label, numbered when the form has more than one) instead of a generic placeholder.
+  - A server-side `createSubmission(payload, { form, values, req? })` (root export) wraps `payload.create` for the `form-submissions` collection, giving server code (a script, a queued job, another collection's hook) a typed, documented entry point instead of hand-rolling the collection slug and body shape. It runs the exact pipeline the browser and REST paths run: server-authoritative validation, spam metadata when `req` is threaded through, descriptor snapshotting, consent capture, and post-submit action dispatch are all `form-submissions` collection hooks, not a route handler. Access is unchanged (`create: () => true`; `read` logged-in only; `update` disabled), so a raw REST `POST` and `createSubmission` reach the identical pipeline `submitForm` does.
+  - Admin and docs polish: a new Options API conventions section documents the plugin's few configuration shapes (opt-in flags, resolver-gated features, composition seams, registry seams), so which pattern a given option follows is no longer a guess. A field block's collapsed row header now shows the field's own label once set, falling back to its translated type name, instead of Payload's default block-name placeholder that reads "Untitled" until filled in (`FieldBlockLabel`, exported from `./client`). Two field descriptions duplicating their own field's obvious purpose are gone: the previous/next button-label fields' "Shown on multi-step forms only" and the department-routed **To** field's "The department this submission is routed to. Each locale keeps its own address."
+  - Save-through poll close and reopen: the Poll tab's button now saves the whole document through the admin's own submit instead of posting to a dedicated endpoint, so a `manual` poll's winner, even one picked in the same sitting, persists together with the close in one request rather than needing a prior save. The same button now also reopens: once closed, clicking it clears `closesAt` and the recorded `winningValues` together, for every outcome type. The `POST /:id/close` endpoint keeps its previous behavior unchanged for programmatic callers; only the admin button stopped using it.
+  - Email actions gain **Cc**, **Bcc**, and **Reply-to**: `emailTeam` and `confirmation` both carry all three, localized like `subject` and interpolated with the same recall tokens, each accepting a comma-separated address list forwarded to `payload.sendEmail` as-is.
+  - Internal-reference redirects: the new `redirectRelationships` plugin option (a `CollectionSlug[]`, named after `@payloadcms/plugin-form-builder`'s option of the same purpose) adds a polymorphic `reference` field to `response.redirect`, so an author can point a successful submit at an internal document instead of, or alongside, a URL. `toFormDocument` passes the raw `{ relationTo, value }` pair through unresolved; resolving it to a URL is the host's job, since the plugin has no notion of your routing.
+  - Two opt-in field types, `country` and `state`: fixed-option pickers (every ISO 3166-1 country; the 50 US states plus DC) that store the code and `format` it to the English name, poll-eligible like `select`. They are not registered by default; a host enables them with `fields: { country: countryField, state: stateField }` (both exported). Their renderers are always registered, so opting in needs no frontend wiring.
+  - Every validation rule opens with a plain-language description. Each rule's config block leads with a short, localized sentence explaining what makes it fail, so an editor never has to infer a rule's mechanics from its name (`matchesField`, for instance, states that it fails when the two answers differ). `ValidationRuleDefinition.description` carries it as a localizable key; the built-ins ship English and German.
+  - `fieldTargetParam(name, opts?)` is a reusable rule/action param that targets another field on the same form: a text value authored by the field-name picker, with a save-time existence check so a removed target is caught. `matchesField` uses it, and it is exported for custom rules that need to point at another field.
+  - A composition seam for the redirect response, `response.redirect.fields`: it hands you the group's default fields (the `url` text field, plus the `reference` relationship when `redirectRelationships` is set) and takes your array back, so you can drop in a custom link field, swap `url` for your own picker, reorder, or filter, mirroring `buttons.fields` and `poll.outcomeFields`. `RedirectFieldsOverride`, `ResponseOption`, and `RedirectOption` are exported. The plugin's built-in redirect still reads `redirect.url` / `redirect.reference`, so a host that replaces `url` owns resolving its own field to a destination.
+
+  **Fixes:**
+
+  - **A required checkbox accepted an explicit "unchecked".** The engine's required guard fires on `isEmpty(value)`, and `false` is a present value, so an untouched box (never sent) was rejected while a checked-then-unchecked one (sent as `false`) passed. `checkbox` (and `consent`) gained the intrinsic validator they lacked rather than widening the global `isEmpty`, which would ripple to every boolean. The one `runValidation` engine backs both client and server, so the fix binds them alike.
+  - **Admins saw raw stored values for sourced polls.** The authenticated results endpoint now injects the results field's effective options (source-resolved, `resolveOptions`-backed, or authored) too, so a sourced or resolver-backed poll renders labels in the admin instead of raw values, best-effort: a resolve failure there degrades to raw values rather than blocking the trusted read (the anonymous path still fails closed).
+  - The `pattern` rule's params are validated at authoring time, so an uncompilable expression or flag set is a save error instead of a rule that silently never fires. `pattern` compiles against its sibling `flags`, since flags decide validity, and an invalid flag is left to the `flags` field so one typo reports once. The submit-time fail-open stays as the safety net for rules stored before the guard existed.
+  - The unused-translation-key guard could never fail. It listed key-enumerating files by name and so missed `de.ts`, which then entered the usage corpus and, keying every entry as `keys.<name>`, matched all keys on its own, leaving `unused` permanently empty and the guard passing unconditionally. The corpus now excludes `src/translations/` by directory rather than by naming the files inside it, so no future locale can rejoin it and re-blind the scan however it happens to be written; nothing in that directory consumes a `keys.X` reference, so a key used only from there was never a used key anyway. Unreferenced keys are now reported, and no orphans exist once the scan works.
+  - A defaulted admin select was clearable with a silent consequence: a cleared submission `status` (which defaults to `complete`, and aggregation counts `complete`) dropped the submission out of every poll result with nothing in the UI saying so. It is now `isClearable: false`, matching the precedent on `width`, `response.type`, and `poll.resultsVisibility`.
+  - The shadcn registry's consent field rendered no required marker, making a required consent the only labelled field in the registry giving the visitor no sign it was mandatory until submit failed.
+  - Three fields with a custom select component silently rendered no description. A custom `Field` replaces Payload's whole default render, and a function `admin.description` is dropped from the client field before it ever gets there, so the text was configured but unreachable: the confirmation action's recipient field ("The email field on this form the confirmation is sent to.") and the file field's maximum size both lost theirs in earlier releases, and the poll's results field lost the sentence naming the rule it exists to enforce ("Use a choice field, never a free-text or PII field."). All three now pass a translated description key to their component, which renders it.
+  - The condition builder's value input for a `select` or `date` operand threw and broke the builder. Payload's native `Select`/`Date` leaf field components read `field.admin.placeholder` unconditionally, and the client field the builder synthesizes for a leaf condition carried no `admin` object at all; every synthesized leaf (`text` and `number` too, for consistency) now carries an empty `admin: {}`.
+  - Closing a `manual` poll with no winner recorded used to round-trip to the server and fail with a toast error after the click. The Close button now disables itself first, with an inline hint ("Select a winning value first."), so the invalid click is prevented rather than attempted and rejected.
+  - The poll's vote-field select was labelled "Results field," easy to misread as a display setting rather than the question being voted on. It is now "Vote field," with its description explaining the new auto-fill behavior.
+  - The email actions' **Cc** and **Bcc** labels are now cased **CC** and **BCC** (both locales), matching how the headers are conventionally written.
+  - The shadcn `form-results` registry snapshot was rebuilt. It still shipped the single-winner `winningValue?: string` component after the source moved to `winningValues?: string[]` for tie support, so a project pulling the registry got a component that could not highlight a tie; `registry:build` now matches the source.
+
+  **Notes:**
+
+  - No migrations, as ever pre-1.0: the removed `display` group, `response.submitLabel`, the consent `statement`/`optional` fields, the per-source `sourceConfig`, the dropped `placeholder`/`required` columns, and the form title's move to localized storage are orphaned rather than dropped. Write your own if you carry data.
+  - The From select and the poll winner select are both document-scoped, so each stays empty until the form's first save: their endpoints need a document id to resolve against. Save the form, then pick. The consent-sources select is the same.
+  - `email.fromAddresses` fails closed, and Payload runs the validate on every save rather than only when `from` changed, so while the resolver is throwing, no form whose email action has a From set can be saved at all, including edits that never touch the address. Failing open would persist a sender the host can no longer vouch for; a resolver reaching a flaky upstream should cache or fall back internally instead of throwing.
+  - Internal, no changeset of its own: the shared test harness gained `warmVersionCollections`, initializing drafts-enabled collections so consent version-capture is exercisable in integration tests. It is tooling (`@10x-media/test-harness`), not published.
+  - The plugin now registers `form-submissions` before `forms` (Payload lists collections in registration order within a nav group), so the shared "Forms" sidebar group reads alphabetically. Ordering the rest of a host's own sidebar against it stays the host's config concern; Payload has no global nav-sort option.
+
+### Patch Changes
+
+- Correct `payload` and `@payloadcms/ui` peer ranges to `^3.83.0`. The plugin uses `definePlugin`, which shipped in Payload 3.83.0, so 3.82.x installs satisfied the old range but failed at import.
+
 ## 0.1.0-beta.4
 
 ### Minor Changes

package/README.md

@@ -8,8 +8,8 @@ Part of the [@10x-media Payload plugins](https://github.com/10x-media/payload-pl
 
 ## Features
 
-- **Fields**: text, textarea, email, number, date, select, checkbox, file, consent, calculation, and repeater (dynamic row lists with per-row sub-field validation), authored as Payload blocks; custom types via `defineFormField` are never second-class.
-- **Validation**: declarative per-field rules, custom messages and severities, cross-field and async server-only rules, a Standard Schema escape hatch (zod, valibot, ...), one server-authoritative engine.
+- **Fields**: text, textarea, email, number, date, select, checkbox, file, consent, calculation, repeater (dynamic row lists with per-row sub-field validation), and message, authored as Payload blocks; `country` and `state` are opt-in, and custom types via `defineFormField` are never second-class.
+- **Validation**: declarative per-field rules with plain-language descriptions, custom messages, cross-field and async server-only rules, a Standard Schema escape hatch (zod, valibot, ...), one server-authoritative engine.
 - **Conditional logic**: `visibleWhen` / `validateWhen` in Payload's `Where` shape, one isomorphic engine on client and server.
 - **Multi-step flows** with conditional branching, authored in the admin flow builder.
 - **Headless rendering**: `<Form>` with progressive validation and lifecycle events, accessible primitives, an optional layout grid; style via CSS hooks, a shadcn registry, or your own renderers.
@@ -17,7 +17,7 @@ Part of the [@10x-media Payload plugins](https://github.com/10x-media/payload-pl
 - **Recall and prefill**: pipe answers into labels and messages; URL prefill; hidden context fields.
 - **Calculations**: a safe no-eval expression engine for totals and quiz scores, recomputed on the server.
 - **Post-submit actions**: email, confirmation, signed webhook, and custom actions, queued via Payload jobs with a bounded inline fallback.
-- **Consent** with proof by reference and policy-version capture; **file uploads** into your own upload collection with server-enforced MIME/size; **polls** with a gated public results endpoint.
+- **Consent** referencing statements you own, resolved live per request, with proof stored as document ids and published versions; **file uploads** into your own upload collection with server-enforced MIME/size; **polls** with a gated public results endpoint.
 - **Spam protection** on by default: honeypot, per-identity rate limiting, bundled captcha adapters (Turnstile, reCAPTCHA, hCaptcha), upload-ownership scoping, privacy-first metadata.
 - **Accessibility** verified by automated axe checks; **typed translations** via `@10x-media/form-builder/i18n`.
 - **Collection overrides**: extend `forms` and `form-submissions` with extra fields, hooks, and access rules using an explicit spread API that guarantees plugin-critical hooks always run.

package/dist/actions/body/serializeBody.d.ts

@@ -27,16 +27,19 @@ type SerializeBodyArgs = {
   req?: PayloadRequest;
 };
 /**
- * Customizes how action bodies are authored and rendered. `converters` spread over the default
- * Lexical node converters; `serialize` replaces the whole pipeline (for non-HTML channels like
- * chat or plain text, or to hand the body plus the submitted `form`/`req` off to a renderer like
- * react-email). `editor` overrides the Lexical/richText editor on both the emailTeam and
- * confirmation action body fields (see `buildDefaultActionDefinitions`).
+ * Customizes how the plugin's rich text is authored and rendered. `converters` spread over the
+ * default Lexical node converters; `serialize` replaces the whole action-body pipeline (for
+ * non-HTML channels like chat or plain text, or to hand the body plus the submitted `form`/`req`
+ * off to a renderer like react-email). `editor` is the default Lexical/richText editor for every
+ * plugin-authored richText field: message content, consent statement, the response message, and
+ * the action body fields. `bodyEditor` overrides the action body fields specifically (emailTeam
+ * and confirmation), falling back to `editor` when absent.
  */
 type RichTextBodyOption = {
   converters?: Record<string, BodyConverter>;
   serialize?: (args: SerializeBodyArgs) => Promise<string> | string;
   editor?: RichTextField['editor'];
+  bodyEditor?: RichTextField['editor'];
 };
 /**
  * Serialize an action's `body` config into HTML. A legacy string body is interpolated as-is

package/dist/actions/body/serializeBody.js.map

@@ -1 +1 @@
-{"version":3,"file":"serializeBody.js","names":[],"sources":["../../../src/actions/body/serializeBody.ts"],"sourcesContent":["import type { PayloadRequest, RichTextField } from 'payload'\nimport { interpolate } from '../../recall/interpolate'\nimport type { SubmissionDescriptor, SubmissionValue } from '../../submissions/types'\nimport type { BodyConverter, BodyRender } from './converters'\nimport { defaultBodyConverters } from './converters'\nimport { escapeHtml } from './escapeHtml'\nimport { serializeSlate } from './serializeSlate'\nimport { renderAllValues, renderAllValuesTable } from './wildcards'\n\n/** Minimal form identity threaded alongside a rendered body (e.g. per-tenant template lookups). */\ntype SerializeBodyForm = { id: number | string; title?: string }\n\n/** Submission data plus optional converter overrides available while serializing a body. */\nexport type BodyContext = {\n\tvalues: SubmissionValue[]\n\tdescriptors: SubmissionDescriptor[]\n\tconverters?: Record<string, BodyConverter>\n}\n\n/**\n * Args a custom `richText.serialize` replacement receives per rendered body. Always populated by\n * `makeRenderBody` (the action-body pipeline): `form` and `req` enable per-tenant template\n * lookups or handing the body off to a renderer like react-email.\n */\nexport type SerializeBodyArgs = {\n\tbody: unknown\n\tvalues: SubmissionValue[]\n\tdescriptors: SubmissionDescriptor[]\n\tform: SerializeBodyForm\n\treq?: PayloadRequest\n}\n\n/**\n * Customizes how action bodies are authored and rendered. `converters` spread over the default\n * Lexical node converters; `serialize` replaces the whole pipeline (for non-HTML channels like\n * chat or plain text, or to hand the body plus the submitted `form`/`req` off to a renderer like\n * react-email). `editor` overrides the Lexical/richText editor on both the emailTeam and\n * confirmation action body fields (see `buildDefaultActionDefinitions`).\n */\nexport type RichTextBodyOption = {\n\tconverters?: Record<string, BodyConverter>\n\tserialize?: (args: SerializeBodyArgs) => Promise<string> | string\n\teditor?: RichTextField['editor']\n}\n\n/** Recall resolver over submission values: field name to stringified value, `''` when absent. */\nexport const resolverFor =\n\t(values: SubmissionValue[]) =>\n\t(name: string): string => {\n\t\tconst entry = values.find((value) => value.field === name)\n\t\treturn entry == null ? '' : String(entry.value ?? '')\n\t}\n\nconst renderFor = (ctx: BodyContext): BodyRender => {\n\tconst resolve = resolverFor(ctx.values)\n\tconst htmlResolve = (name: string): string => {\n\t\tif (name === '*') {\n\t\t\treturn renderAllValues(ctx.values, ctx.descriptors)\n\t\t}\n\t\tif (name === '*:table') {\n\t\t\treturn renderAllValuesTable(ctx.values, ctx.descriptors)\n\t\t}\n\t\treturn escapeHtml(resolve(name))\n\t}\n\treturn {\n\t\ttext: (raw) => interpolate(escapeHtml(raw), htmlResolve),\n\t\tinterpolate: (raw) => interpolate(raw, resolve),\n\t}\n}\n\nconst serializeNodes = (\n\tnodes: unknown[],\n\tconverters: Record<string, BodyConverter>,\n\trender: BodyRender\n): string =>\n\tnodes\n\t\t.map((node) => {\n\t\t\tif (node == null || typeof node !== 'object') {\n\t\t\t\treturn ''\n\t\t\t}\n\t\t\tconst lexicalNode = node as Record<string, unknown>\n\t\t\tconst children = Array.isArray(lexicalNode.children)\n\t\t\t\t? serializeNodes(lexicalNode.children, converters, render)\n\t\t\t\t: ''\n\t\t\tconst converter =\n\t\t\t\ttypeof lexicalNode.type === 'string' ? converters[lexicalNode.type] : undefined\n\t\t\treturn converter ? converter({ node: lexicalNode, children, render }) : children\n\t\t})\n\t\t.join('')\n\nconst lexicalRootOf = (body: unknown): Record<string, unknown> | null => {\n\tif (body == null || typeof body !== 'object' || Array.isArray(body)) {\n\t\treturn null\n\t}\n\tconst root = (body as { root?: unknown }).root\n\treturn root != null && typeof root === 'object' ? (root as Record<string, unknown>) : null\n}\n\n/**\n * Serialize an action's `body` config into HTML. A legacy string body is interpolated as-is\n * (pre-richText behavior, no escaping); a Lexical state walks the converter registry; a Slate\n * array uses the minimal legacy serializer; anything else yields `''`. Rendered text is\n * HTML-escaped and supports `{{ name|fallback }}`, `{{*}}`, and `{{*:table}}` tokens.\n */\nexport const serializeBody = (body: unknown, ctx: BodyContext): string => {\n\tif (typeof body === 'string') {\n\t\treturn interpolate(body, resolverFor(ctx.values))\n\t}\n\tconst render = renderFor(ctx)\n\tif (Array.isArray(body)) {\n\t\treturn serializeSlate(body, render)\n\t}\n\tconst root = lexicalRootOf(body)\n\tif (root) {\n\t\tconst converters = { ...defaultBodyConverters, ...(ctx.converters ?? {}) }\n\t\treturn serializeNodes(Array.isArray(root.children) ? root.children : [], converters, render)\n\t}\n\treturn ''\n}\n\n/** Build the `renderBody` passed to actions, honoring a plugin-level `richText` customization. */\nexport const makeRenderBody =\n\t(args: {\n\t\tvalues: SubmissionValue[]\n\t\tdescriptors: SubmissionDescriptor[]\n\t\tform: SerializeBodyForm\n\t\treq?: PayloadRequest\n\t\trichText?: RichTextBodyOption\n\t}) =>\n\tasync (body: unknown): Promise<string> => {\n\t\tif (args.richText?.serialize) {\n\t\t\treturn await args.richText.serialize({\n\t\t\t\tbody,\n\t\t\t\tvalues: args.values,\n\t\t\t\tdescriptors: args.descriptors,\n\t\t\t\tform: args.form,\n\t\t\t\treq: args.req,\n\t\t\t})\n\t\t}\n\t\treturn serializeBody(body, {\n\t\t\tvalues: args.values,\n\t\t\tdescriptors: args.descriptors,\n\t\t\tconverters: args.richText?.converters,\n\t\t})\n\t}\n"],"mappings":";;;;;;;AA8CA,MAAa,eACX,YACA,SAAyB;CACzB,MAAM,QAAQ,OAAO,MAAM,UAAU,MAAM,UAAU,IAAI;CACzD,OAAO,SAAS,OAAO,KAAK,OAAO,MAAM,SAAS,EAAE;AACrD;AAED,MAAM,aAAa,QAAiC;CACnD,MAAM,UAAU,YAAY,IAAI,MAAM;CACtC,MAAM,eAAe,SAAyB;EAC7C,IAAI,SAAS,KACZ,OAAO,gBAAgB,IAAI,QAAQ,IAAI,WAAW;EAEnD,IAAI,SAAS,WACZ,OAAO,qBAAqB,IAAI,QAAQ,IAAI,WAAW;EAExD,OAAO,WAAW,QAAQ,IAAI,CAAC;CAChC;CACA,OAAO;EACN,OAAO,QAAQ,YAAY,WAAW,GAAG,GAAG,WAAW;EACvD,cAAc,QAAQ,YAAY,KAAK,OAAO;CAC/C;AACD;AAEA,MAAM,kBACL,OACA,YACA,WAEA,MACE,KAAK,SAAS;CACd,IAAI,QAAQ,QAAQ,OAAO,SAAS,UACnC,OAAO;CAER,MAAM,cAAc;CACpB,MAAM,WAAW,MAAM,QAAQ,YAAY,QAAQ,IAChD,eAAe,YAAY,UAAU,YAAY,MAAM,IACvD;CACH,MAAM,YACL,OAAO,YAAY,SAAS,WAAW,WAAW,YAAY,QAAQ,KAAA;CACvE,OAAO,YAAY,UAAU;EAAE,MAAM;EAAa;EAAU;CAAO,CAAC,IAAI;AACzE,CAAC,EACA,KAAK,EAAE;AAEV,MAAM,iBAAiB,SAAkD;CACxE,IAAI,QAAQ,QAAQ,OAAO,SAAS,YAAY,MAAM,QAAQ,IAAI,GACjE,OAAO;CAER,MAAM,OAAQ,KAA4B;CAC1C,OAAO,QAAQ,QAAQ,OAAO,SAAS,WAAY,OAAmC;AACvF;;;;;;;AAQA,MAAa,iBAAiB,MAAe,QAA6B;CACzE,IAAI,OAAO,SAAS,UACnB,OAAO,YAAY,MAAM,YAAY,IAAI,MAAM,CAAC;CAEjD,MAAM,SAAS,UAAU,GAAG;CAC5B,IAAI,MAAM,QAAQ,IAAI,GACrB,OAAO,eAAe,MAAM,MAAM;CAEnC,MAAM,OAAO,cAAc,IAAI;CAC/B,IAAI,MAAM;EACT,MAAM,aAAa;GAAE,GAAG;GAAuB,GAAI,IAAI,cAAc,CAAC;EAAG;EACzE,OAAO,eAAe,MAAM,QAAQ,KAAK,QAAQ,IAAI,KAAK,WAAW,CAAC,GAAG,YAAY,MAAM;CAC5F;CACA,OAAO;AACR;;AAGA,MAAa,kBACX,SAOD,OAAO,SAAmC;CACzC,IAAI,KAAK,UAAU,WAClB,OAAO,MAAM,KAAK,SAAS,UAAU;EACpC;EACA,QAAQ,KAAK;EACb,aAAa,KAAK;EAClB,MAAM,KAAK;EACX,KAAK,KAAK;CACX,CAAC;CAEF,OAAO,cAAc,MAAM;EAC1B,QAAQ,KAAK;EACb,aAAa,KAAK;EAClB,YAAY,KAAK,UAAU;CAC5B,CAAC;AACF"}
+{"version":3,"file":"serializeBody.js","names":[],"sources":["../../../src/actions/body/serializeBody.ts"],"sourcesContent":["import type { PayloadRequest, RichTextField } from 'payload'\nimport { interpolate } from '../../recall/interpolate'\nimport type { SubmissionDescriptor, SubmissionValue } from '../../submissions/types'\nimport type { BodyConverter, BodyRender } from './converters'\nimport { defaultBodyConverters } from './converters'\nimport { escapeHtml } from './escapeHtml'\nimport { serializeSlate } from './serializeSlate'\nimport { renderAllValues, renderAllValuesTable } from './wildcards'\n\n/** Minimal form identity threaded alongside a rendered body (e.g. per-tenant template lookups). */\ntype SerializeBodyForm = { id: number | string; title?: string }\n\n/** Submission data plus optional converter overrides available while serializing a body. */\nexport type BodyContext = {\n\tvalues: SubmissionValue[]\n\tdescriptors: SubmissionDescriptor[]\n\tconverters?: Record<string, BodyConverter>\n}\n\n/**\n * Args a custom `richText.serialize` replacement receives per rendered body. Always populated by\n * `makeRenderBody` (the action-body pipeline): `form` and `req` enable per-tenant template\n * lookups or handing the body off to a renderer like react-email.\n */\nexport type SerializeBodyArgs = {\n\tbody: unknown\n\tvalues: SubmissionValue[]\n\tdescriptors: SubmissionDescriptor[]\n\tform: SerializeBodyForm\n\treq?: PayloadRequest\n}\n\n/**\n * Customizes how the plugin's rich text is authored and rendered. `converters` spread over the\n * default Lexical node converters; `serialize` replaces the whole action-body pipeline (for\n * non-HTML channels like chat or plain text, or to hand the body plus the submitted `form`/`req`\n * off to a renderer like react-email). `editor` is the default Lexical/richText editor for every\n * plugin-authored richText field: message content, consent statement, the response message, and\n * the action body fields. `bodyEditor` overrides the action body fields specifically (emailTeam\n * and confirmation), falling back to `editor` when absent.\n */\nexport type RichTextBodyOption = {\n\tconverters?: Record<string, BodyConverter>\n\tserialize?: (args: SerializeBodyArgs) => Promise<string> | string\n\teditor?: RichTextField['editor']\n\tbodyEditor?: RichTextField['editor']\n}\n\n/** Recall resolver over submission values: field name to stringified value, `''` when absent. */\nexport const resolverFor =\n\t(values: SubmissionValue[]) =>\n\t(name: string): string => {\n\t\tconst entry = values.find((value) => value.field === name)\n\t\treturn entry == null ? '' : String(entry.value ?? '')\n\t}\n\nconst renderFor = (ctx: BodyContext): BodyRender => {\n\tconst resolve = resolverFor(ctx.values)\n\tconst htmlResolve = (name: string): string => {\n\t\tif (name === '*') {\n\t\t\treturn renderAllValues(ctx.values, ctx.descriptors)\n\t\t}\n\t\tif (name === '*:table') {\n\t\t\treturn renderAllValuesTable(ctx.values, ctx.descriptors)\n\t\t}\n\t\treturn escapeHtml(resolve(name))\n\t}\n\treturn {\n\t\ttext: (raw) => interpolate(escapeHtml(raw), htmlResolve),\n\t\tinterpolate: (raw) => interpolate(raw, resolve),\n\t}\n}\n\nconst serializeNodes = (\n\tnodes: unknown[],\n\tconverters: Record<string, BodyConverter>,\n\trender: BodyRender\n): string =>\n\tnodes\n\t\t.map((node) => {\n\t\t\tif (node == null || typeof node !== 'object') {\n\t\t\t\treturn ''\n\t\t\t}\n\t\t\tconst lexicalNode = node as Record<string, unknown>\n\t\t\tconst children = Array.isArray(lexicalNode.children)\n\t\t\t\t? serializeNodes(lexicalNode.children, converters, render)\n\t\t\t\t: ''\n\t\t\tconst converter =\n\t\t\t\ttypeof lexicalNode.type === 'string' ? converters[lexicalNode.type] : undefined\n\t\t\treturn converter ? converter({ node: lexicalNode, children, render }) : children\n\t\t})\n\t\t.join('')\n\nconst lexicalRootOf = (body: unknown): Record<string, unknown> | null => {\n\tif (body == null || typeof body !== 'object' || Array.isArray(body)) {\n\t\treturn null\n\t}\n\tconst root = (body as { root?: unknown }).root\n\treturn root != null && typeof root === 'object' ? (root as Record<string, unknown>) : null\n}\n\n/**\n * Serialize an action's `body` config into HTML. A legacy string body is interpolated as-is\n * (pre-richText behavior, no escaping); a Lexical state walks the converter registry; a Slate\n * array uses the minimal legacy serializer; anything else yields `''`. Rendered text is\n * HTML-escaped and supports `{{ name|fallback }}`, `{{*}}`, and `{{*:table}}` tokens.\n */\nexport const serializeBody = (body: unknown, ctx: BodyContext): string => {\n\tif (typeof body === 'string') {\n\t\treturn interpolate(body, resolverFor(ctx.values))\n\t}\n\tconst render = renderFor(ctx)\n\tif (Array.isArray(body)) {\n\t\treturn serializeSlate(body, render)\n\t}\n\tconst root = lexicalRootOf(body)\n\tif (root) {\n\t\tconst converters = { ...defaultBodyConverters, ...(ctx.converters ?? {}) }\n\t\treturn serializeNodes(Array.isArray(root.children) ? root.children : [], converters, render)\n\t}\n\treturn ''\n}\n\n/** Build the `renderBody` passed to actions, honoring a plugin-level `richText` customization. */\nexport const makeRenderBody =\n\t(args: {\n\t\tvalues: SubmissionValue[]\n\t\tdescriptors: SubmissionDescriptor[]\n\t\tform: SerializeBodyForm\n\t\treq?: PayloadRequest\n\t\trichText?: RichTextBodyOption\n\t}) =>\n\tasync (body: unknown): Promise<string> => {\n\t\tif (args.richText?.serialize) {\n\t\t\treturn await args.richText.serialize({\n\t\t\t\tbody,\n\t\t\t\tvalues: args.values,\n\t\t\t\tdescriptors: args.descriptors,\n\t\t\t\tform: args.form,\n\t\t\t\treq: args.req,\n\t\t\t})\n\t\t}\n\t\treturn serializeBody(body, {\n\t\t\tvalues: args.values,\n\t\t\tdescriptors: args.descriptors,\n\t\t\tconverters: args.richText?.converters,\n\t\t})\n\t}\n"],"mappings":";;;;;;;AAiDA,MAAa,eACX,YACA,SAAyB;CACzB,MAAM,QAAQ,OAAO,MAAM,UAAU,MAAM,UAAU,IAAI;CACzD,OAAO,SAAS,OAAO,KAAK,OAAO,MAAM,SAAS,EAAE;AACrD;AAED,MAAM,aAAa,QAAiC;CACnD,MAAM,UAAU,YAAY,IAAI,MAAM;CACtC,MAAM,eAAe,SAAyB;EAC7C,IAAI,SAAS,KACZ,OAAO,gBAAgB,IAAI,QAAQ,IAAI,WAAW;EAEnD,IAAI,SAAS,WACZ,OAAO,qBAAqB,IAAI,QAAQ,IAAI,WAAW;EAExD,OAAO,WAAW,QAAQ,IAAI,CAAC;CAChC;CACA,OAAO;EACN,OAAO,QAAQ,YAAY,WAAW,GAAG,GAAG,WAAW;EACvD,cAAc,QAAQ,YAAY,KAAK,OAAO;CAC/C;AACD;AAEA,MAAM,kBACL,OACA,YACA,WAEA,MACE,KAAK,SAAS;CACd,IAAI,QAAQ,QAAQ,OAAO,SAAS,UACnC,OAAO;CAER,MAAM,cAAc;CACpB,MAAM,WAAW,MAAM,QAAQ,YAAY,QAAQ,IAChD,eAAe,YAAY,UAAU,YAAY,MAAM,IACvD;CACH,MAAM,YACL,OAAO,YAAY,SAAS,WAAW,WAAW,YAAY,QAAQ,KAAA;CACvE,OAAO,YAAY,UAAU;EAAE,MAAM;EAAa;EAAU;CAAO,CAAC,IAAI;AACzE,CAAC,EACA,KAAK,EAAE;AAEV,MAAM,iBAAiB,SAAkD;CACxE,IAAI,QAAQ,QAAQ,OAAO,SAAS,YAAY,MAAM,QAAQ,IAAI,GACjE,OAAO;CAER,MAAM,OAAQ,KAA4B;CAC1C,OAAO,QAAQ,QAAQ,OAAO,SAAS,WAAY,OAAmC;AACvF;;;;;;;AAQA,MAAa,iBAAiB,MAAe,QAA6B;CACzE,IAAI,OAAO,SAAS,UACnB,OAAO,YAAY,MAAM,YAAY,IAAI,MAAM,CAAC;CAEjD,MAAM,SAAS,UAAU,GAAG;CAC5B,IAAI,MAAM,QAAQ,IAAI,GACrB,OAAO,eAAe,MAAM,MAAM;CAEnC,MAAM,OAAO,cAAc,IAAI;CAC/B,IAAI,MAAM;EACT,MAAM,aAAa;GAAE,GAAG;GAAuB,GAAI,IAAI,cAAc,CAAC;EAAG;EACzE,OAAO,eAAe,MAAM,QAAQ,KAAK,QAAQ,IAAI,KAAK,WAAW,CAAC,GAAG,YAAY,MAAM;CAC5F;CACA,OAAO;AACR;;AAGA,MAAa,kBACX,SAOD,OAAO,SAAmC;CACzC,IAAI,KAAK,UAAU,WAClB,OAAO,MAAM,KAAK,SAAS,UAAU;EACpC;EACA,QAAQ,KAAK;EACb,aAAa,KAAK;EAClB,MAAM,KAAK;EACX,KAAK,KAAK;CACX,CAAC;CAEF,OAAO,cAAc,MAAM;EAC1B,QAAQ,KAAK;EACb,aAAa,KAAK;EAClB,YAAY,KAAK,UAAU;CAC5B,CAAC;AACF"}

package/dist/actions/body/textOfBody.d.ts

@@ -0,0 +1,13 @@
+//#region src/actions/body/textOfBody.d.ts
+/**
+ * Plain-text content of a body (Lexical rich text, legacy Slate, or a legacy string): leaf text
+ * nodes concatenated in document order, block-level nodes (paragraph, heading, list item, quote)
+ * joined by single spaces, whitespace collapsed, so multi-block content flattens to a readable
+ * sentence. For accessible names and previews, where formatting and links collapse to their
+ * visible words. A plain string passes through untouched; unrecognized shapes yield `''`;
+ * never throws.
+ */
+declare const textOfBody: (body: unknown) => string;
+//#endregion
+export { textOfBody };
+//# sourceMappingURL=textOfBody.d.ts.map

package/dist/actions/body/textOfBody.js

@@ -0,0 +1,35 @@
+//#region src/actions/body/textOfBody.ts
+const isNode = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+/** Children-bearing block-level node types whose text reads as a separate run. */
+const BLOCK_TYPES = new Set([
+	"paragraph",
+	"heading",
+	"listitem",
+	"quote"
+]);
+const textOfNode = (node) => {
+	if (!isNode(node)) return "";
+	if (typeof node.text === "string") return node.text;
+	const children = Array.isArray(node.children) ? node.children.map(textOfNode).join("") : "";
+	if (children !== "" && typeof node.type === "string" && BLOCK_TYPES.has(node.type)) return ` ${children} `;
+	return children;
+};
+/**
+* Plain-text content of a body (Lexical rich text, legacy Slate, or a legacy string): leaf text
+* nodes concatenated in document order, block-level nodes (paragraph, heading, list item, quote)
+* joined by single spaces, whitespace collapsed, so multi-block content flattens to a readable
+* sentence. For accessible names and previews, where formatting and links collapse to their
+* visible words. A plain string passes through untouched; unrecognized shapes yield `''`;
+* never throws.
+*/
+const textOfBody = (body) => {
+	if (typeof body === "string") return body;
+	const root = isNode(body) ? body.root : void 0;
+	const nodes = Array.isArray(body) ? body : isNode(root) && Array.isArray(root.children) ? root.children : null;
+	if (!nodes) return "";
+	return nodes.map(textOfNode).join("").replace(/\s+/g, " ").trim();
+};
+//#endregion
+export { textOfBody };
+
+//# sourceMappingURL=textOfBody.js.map

package/dist/actions/body/textOfBody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textOfBody.js","names":[],"sources":["../../../src/actions/body/textOfBody.ts"],"sourcesContent":["type BodyNode = Record<string, unknown>\n\nconst isNode = (value: unknown): value is BodyNode =>\n\tvalue != null && typeof value === 'object' && !Array.isArray(value)\n\n/** Children-bearing block-level node types whose text reads as a separate run. */\nconst BLOCK_TYPES = new Set(['paragraph', 'heading', 'listitem', 'quote'])\n\nconst textOfNode = (node: unknown): string => {\n\tif (!isNode(node)) {\n\t\treturn ''\n\t}\n\tif (typeof node.text === 'string') {\n\t\treturn node.text\n\t}\n\tconst children = Array.isArray(node.children) ? node.children.map(textOfNode).join('') : ''\n\tif (children !== '' && typeof node.type === 'string' && BLOCK_TYPES.has(node.type)) {\n\t\treturn ` ${children} `\n\t}\n\treturn children\n}\n\n/**\n * Plain-text content of a body (Lexical rich text, legacy Slate, or a legacy string): leaf text\n * nodes concatenated in document order, block-level nodes (paragraph, heading, list item, quote)\n * joined by single spaces, whitespace collapsed, so multi-block content flattens to a readable\n * sentence. For accessible names and previews, where formatting and links collapse to their\n * visible words. A plain string passes through untouched; unrecognized shapes yield `''`;\n * never throws.\n */\nexport const textOfBody = (body: unknown): string => {\n\tif (typeof body === 'string') {\n\t\treturn body\n\t}\n\tconst root = isNode(body) ? body.root : undefined\n\tconst nodes = Array.isArray(body)\n\t\t? body\n\t\t: isNode(root) && Array.isArray(root.children)\n\t\t\t? root.children\n\t\t\t: null\n\tif (!nodes) {\n\t\treturn ''\n\t}\n\treturn nodes.map(textOfNode).join('').replace(/\\s+/g, ' ').trim()\n}\n"],"mappings":";AAEA,MAAM,UAAU,UACf,SAAS,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;;AAGnE,MAAM,cAAc,IAAI,IAAI;CAAC;CAAa;CAAW;CAAY;AAAO,CAAC;AAEzE,MAAM,cAAc,SAA0B;CAC7C,IAAI,CAAC,OAAO,IAAI,GACf,OAAO;CAER,IAAI,OAAO,KAAK,SAAS,UACxB,OAAO,KAAK;CAEb,MAAM,WAAW,MAAM,QAAQ,KAAK,QAAQ,IAAI,KAAK,SAAS,IAAI,UAAU,EAAE,KAAK,EAAE,IAAI;CACzF,IAAI,aAAa,MAAM,OAAO,KAAK,SAAS,YAAY,YAAY,IAAI,KAAK,IAAI,GAChF,OAAO,IAAI,SAAS;CAErB,OAAO;AACR;;;;;;;;;AAUA,MAAa,cAAc,SAA0B;CACpD,IAAI,OAAO,SAAS,UACnB,OAAO;CAER,MAAM,OAAO,OAAO,IAAI,IAAI,KAAK,OAAO,KAAA;CACxC,MAAM,QAAQ,MAAM,QAAQ,IAAI,IAC7B,OACA,OAAO,IAAI,KAAK,MAAM,QAAQ,KAAK,QAAQ,IAC1C,KAAK,WACL;CACJ,IAAI,CAAC,OACJ,OAAO;CAER,OAAO,MAAM,IAAI,UAAU,EAAE,KAAK,EAAE,EAAE,QAAQ,QAAQ,GAAG,EAAE,KAAK;AACjE"}

package/dist/actions/builtin/confirmation.js

@@ -5,6 +5,8 @@ import { keys } from "../../translations/keys.js";
 import { asTranslate, labelFor } from "../../translations/server.js";
 import { resolverFor } from "../body/serializeBody.js";
 import { defineAction } from "../defineAction.js";
+import { buildRecipientField, resolveRecipients } from "../emailRecipients.js";
+import { buildFromField } from "../fromAddresses.js";
 //#region src/actions/builtin/confirmation.ts
 const TO_FIELD_REF = "@10x-media/form-builder/client#FieldNameSelect";
 /**
@@ -16,57 +18,88 @@ const validateToField = (value, { data, req }) => {
 	return fieldNamesOfType(data && typeof data === "object" ? data.fields : void 0, ["email"]).includes(value) ? true : asTranslate(req.t)(keys.validationEmailFieldUnknown);
 };
 /**
-* `subject` and `body` are email content and follow `localize`; `toField` is an identifier and never does.
-* `editor` overrides the body field's Lexical/richText editor (from the plugin's `richText.editor` option).
+* `toField` names the form's own email field the confirmation is sent to (a `FieldNameSelect`, not a
+* recipient list). `replyTo`, `cc`, and `bcc` are recipient lists (`RecipientsSelect`, `string[]`):
+* literal emails, picked department addresses (when `departments` is set), or `{{field}}` tokens
+* resolved from the submission at send. `from` is a single address, added only when `fromAddresses`
+* is set. `subject`/`body` are content; `editor` overrides the body editor; `recipients` narrows the
+* recipient fields' behavior. Content and recipient fields carry `localized: true` when `localize`.
 */
-const buildConfirmation = (localize, editor) => defineAction({
-	type: "confirmation",
-	label: keys.actionConfirmation,
-	config: [
-		{
-			name: "toField",
-			type: "text",
-			label: labelFor(keys.actionConfigToField),
-			admin: {
-				description: labelFor(keys.actionConfigToFieldDescription),
-				components: { Field: {
-					path: TO_FIELD_REF,
-					clientProps: { types: ["email"] }
-				} }
-			},
-			validate: validateToField
-		},
-		{
-			name: "subject",
-			type: "text",
-			label: labelFor(keys.actionConfigSubject),
-			...localizedIf(localize)
+const buildConfirmation = (localize, editor, fromAddresses, departments, recipients) => {
+	const endpoint = departments ? "departments" : void 0;
+	const recip = (name, labelKey) => buildRecipientField(name, labelKey, localize, {
+		endpoint,
+		recipients,
+		width: "50%"
+	});
+	const toField = {
+		name: "toField",
+		type: "text",
+		label: labelFor(keys.actionConfigToField),
+		admin: {
+			width: "50%",
+			components: { Field: {
+				path: TO_FIELD_REF,
+				clientProps: {
+					types: ["email"],
+					descriptionKey: keys.actionConfigToFieldDescription
+				}
+			} }
 		},
-		{
-			name: "body",
-			type: "richText",
-			label: labelFor(keys.actionConfigBody),
-			admin: { description: labelFor(keys.actionConfigBodyDescription) },
-			...localizedIf(localize),
-			...editor ? { editor } : {}
+		validate: validateToField
+	};
+	return defineAction({
+		type: "confirmation",
+		label: keys.actionConfirmation,
+		config: [
+			{
+				type: "row",
+				fields: [toField, recip("replyTo", keys.actionConfigReplyTo)]
+			},
+			...fromAddresses ? [buildFromField(fromAddresses)] : [],
+			{
+				type: "row",
+				fields: [recip("cc", keys.actionConfigCc), recip("bcc", keys.actionConfigBcc)]
+			},
+			{
+				name: "subject",
+				type: "text",
+				label: labelFor(keys.actionConfigSubject),
+				...localizedIf(localize)
+			},
+			{
+				name: "body",
+				type: "richText",
+				label: labelFor(keys.actionConfigBody),
+				admin: { description: labelFor(keys.actionConfigBodyDescription) },
+				...localizedIf(localize),
+				...editor ? { editor } : {}
+			}
+		],
+		run: async (args) => {
+			const { config, values, payload, renderBody } = args;
+			if (!config.toField) return;
+			const resolve = resolverFor(values);
+			const to = resolve(config.toField);
+			if (!to) return;
+			if (typeof payload.sendEmail !== "function") throw new Error("confirmation: no email adapter configured");
+			const subject = interpolate(config.subject ?? "", resolve);
+			const html = await renderBody(config.body);
+			const cc = resolveRecipients(config.cc, resolve);
+			const bcc = resolveRecipients(config.bcc, resolve);
+			const replyTo = resolveRecipients(config.replyTo, resolve);
+			await payload.sendEmail({
+				to,
+				subject,
+				html,
+				...config.from ? { from: config.from } : {},
+				...cc ? { cc } : {},
+				...bcc ? { bcc } : {},
+				...replyTo ? { replyTo } : {}
+			});
 		}
-	],
-	run: async (args) => {
-		const { config, values, payload, renderBody } = args;
-		if (!config.toField) return;
-		const resolve = resolverFor(values);
-		const to = resolve(config.toField);
-		if (!to) return;
-		if (typeof payload.sendEmail !== "function") throw new Error("confirmation: no email adapter configured");
-		const subject = interpolate(config.subject ?? "", resolve);
-		const html = await renderBody(config.body);
-		await payload.sendEmail({
-			to,
-			subject,
-			html
-		});
-	}
-});
+	});
+};
 buildConfirmation(true);
 //#endregion
 export { buildConfirmation };

package/dist/actions/builtin/confirmation.js.map

@@ -1 +1 @@
-{"version":3,"file":"confirmation.js","names":[],"sources":["../../../src/actions/builtin/confirmation.ts"],"sourcesContent":["import type { PayloadRequest, RichTextField } from 'payload'\nimport { fieldNamesOfType } from '../../fields/fieldNamesOfType'\nimport { localizedIf } from '../../fields/localizedIf'\nimport { interpolate } from '../../recall/interpolate'\nimport { keys } from '../../translations/keys'\nimport { asTranslate, labelFor } from '../../translations/server'\nimport { resolverFor } from '../body/serializeBody'\nimport { defineAction } from '../defineAction'\n\ntype ConfirmationConfig = { toField?: string; subject?: string; body?: unknown }\n\nconst TO_FIELD_REF = '@10x-media/form-builder/client#FieldNameSelect'\n\n/**\n * Validates the confirmation action's `toField`: unset is fine, otherwise it must name an\n * existing `email`-type field on the form. Exported for unit testing.\n */\nexport const validateToField = (\n\tvalue: unknown,\n\t{ data, req }: { data?: unknown; req: PayloadRequest }\n): string | true => {\n\tif (typeof value !== 'string' || value.length === 0) {\n\t\treturn true\n\t}\n\tconst fields =\n\t\tdata && typeof data === 'object' ? (data as Record<string, unknown>).fields : undefined\n\treturn fieldNamesOfType(fields, ['email']).includes(value)\n\t\t? true\n\t\t: asTranslate(req.t)(keys.validationEmailFieldUnknown)\n}\n\n/**\n * `subject` and `body` are email content and follow `localize`; `toField` is an identifier and never does.\n * `editor` overrides the body field's Lexical/richText editor (from the plugin's `richText.editor` option).\n */\nexport const buildConfirmation = (localize: boolean, editor?: RichTextField['editor']) =>\n\tdefineAction<ConfirmationConfig>({\n\t\ttype: 'confirmation',\n\t\tlabel: keys.actionConfirmation,\n\t\tconfig: [\n\t\t\t{\n\t\t\t\tname: 'toField',\n\t\t\t\ttype: 'text',\n\t\t\t\tlabel: labelFor(keys.actionConfigToField),\n\t\t\t\tadmin: {\n\t\t\t\t\tdescription: labelFor(keys.actionConfigToFieldDescription),\n\t\t\t\t\tcomponents: { Field: { path: TO_FIELD_REF, clientProps: { types: ['email'] } } },\n\t\t\t\t},\n\t\t\t\tvalidate: validateToField,\n\t\t\t},\n\t\t\t{\n\t\t\t\tname: 'subject',\n\t\t\t\ttype: 'text',\n\t\t\t\tlabel: labelFor(keys.actionConfigSubject),\n\t\t\t\t...localizedIf(localize),\n\t\t\t},\n\t\t\t{\n\t\t\t\tname: 'body',\n\t\t\t\ttype: 'richText',\n\t\t\t\tlabel: labelFor(keys.actionConfigBody),\n\t\t\t\tadmin: { description: labelFor(keys.actionConfigBodyDescription) },\n\t\t\t\t...localizedIf(localize),\n\t\t\t\t...(editor ? { editor } : {}),\n\t\t\t},\n\t\t],\n\t\trun: async (args) => {\n\t\t\tconst { config, values, payload, renderBody } = args\n\n\t\t\tif (!config.toField) {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tconst resolve = resolverFor(values)\n\t\t\tconst to = resolve(config.toField)\n\n\t\t\tif (!to) {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tif (typeof payload.sendEmail !== 'function') {\n\t\t\t\tthrow new Error('confirmation: no email adapter configured')\n\t\t\t}\n\n\t\t\tconst subject = interpolate(config.subject ?? '', resolve)\n\t\t\tconst html = await renderBody(config.body)\n\n\t\t\tawait payload.sendEmail({ to, subject, html })\n\t\t},\n\t})\n\nexport const confirmation = buildConfirmation(true)\n"],"mappings":";;;;;;;;AAWA,MAAM,eAAe;;;;;AAMrB,MAAa,mBACZ,OACA,EAAE,MAAM,UACW;CACnB,IAAI,OAAO,UAAU,YAAY,MAAM,WAAW,GACjD,OAAO;CAIR,OAAO,iBADN,QAAQ,OAAO,SAAS,WAAY,KAAiC,SAAS,KAAA,GAC/C,CAAC,OAAO,CAAC,EAAE,SAAS,KAAK,IACtD,OACA,YAAY,IAAI,CAAC,EAAE,KAAK,2BAA2B;AACvD;;;;;AAMA,MAAa,qBAAqB,UAAmB,WACpD,aAAiC;CAChC,MAAM;CACN,OAAO,KAAK;CACZ,QAAQ;EACP;GACC,MAAM;GACN,MAAM;GACN,OAAO,SAAS,KAAK,mBAAmB;GACxC,OAAO;IACN,aAAa,SAAS,KAAK,8BAA8B;IACzD,YAAY,EAAE,OAAO;KAAE,MAAM;KAAc,aAAa,EAAE,OAAO,CAAC,OAAO,EAAE;IAAE,EAAE;GAChF;GACA,UAAU;EACX;EACA;GACC,MAAM;GACN,MAAM;GACN,OAAO,SAAS,KAAK,mBAAmB;GACxC,GAAG,YAAY,QAAQ;EACxB;EACA;GACC,MAAM;GACN,MAAM;GACN,OAAO,SAAS,KAAK,gBAAgB;GACrC,OAAO,EAAE,aAAa,SAAS,KAAK,2BAA2B,EAAE;GACjE,GAAG,YAAY,QAAQ;GACvB,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAC5B;CACD;CACA,KAAK,OAAO,SAAS;EACpB,MAAM,EAAE,QAAQ,QAAQ,SAAS,eAAe;EAEhD,IAAI,CAAC,OAAO,SACX;EAGD,MAAM,UAAU,YAAY,MAAM;EAClC,MAAM,KAAK,QAAQ,OAAO,OAAO;EAEjC,IAAI,CAAC,IACJ;EAGD,IAAI,OAAO,QAAQ,cAAc,YAChC,MAAM,IAAI,MAAM,2CAA2C;EAG5D,MAAM,UAAU,YAAY,OAAO,WAAW,IAAI,OAAO;EACzD,MAAM,OAAO,MAAM,WAAW,OAAO,IAAI;EAEzC,MAAM,QAAQ,UAAU;GAAE;GAAI;GAAS;EAAK,CAAC;CAC9C;AACD,CAAC;AAE0B,kBAAkB,IAAI"}
+{"version":3,"file":"confirmation.js","names":[],"sources":["../../../src/actions/builtin/confirmation.ts"],"sourcesContent":["import type { Field, PayloadRequest, RichTextField } from 'payload'\nimport type { DepartmentEmailsResolver } from '../../email/departments'\nimport { fieldNamesOfType } from '../../fields/fieldNamesOfType'\nimport { localizedIf } from '../../fields/localizedIf'\nimport { interpolate } from '../../recall/interpolate'\nimport { keys } from '../../translations/keys'\nimport { asTranslate, labelFor } from '../../translations/server'\nimport { resolverFor } from '../body/serializeBody'\nimport { defineAction } from '../defineAction'\nimport { buildRecipientField, type RecipientsConfig, resolveRecipients } from '../emailRecipients'\nimport { buildFromField, type FromAddressesResolver } from '../fromAddresses'\n\ntype ConfirmationConfig = {\n\ttoField?: string\n\tfrom?: string\n\tcc?: string[]\n\tbcc?: string[]\n\treplyTo?: string[]\n\tsubject?: string\n\tbody?: unknown\n}\n\nconst TO_FIELD_REF = '@10x-media/form-builder/client#FieldNameSelect'\n\n/**\n * Validates the confirmation action's `toField`: unset is fine, otherwise it must name an\n * existing `email`-type field on the form. Exported for unit testing.\n */\nexport const validateToField = (\n\tvalue: unknown,\n\t{ data, req }: { data?: unknown; req: PayloadRequest }\n): string | true => {\n\tif (typeof value !== 'string' || value.length === 0) {\n\t\treturn true\n\t}\n\tconst fields =\n\t\tdata && typeof data === 'object' ? (data as Record<string, unknown>).fields : undefined\n\treturn fieldNamesOfType(fields, ['email']).includes(value)\n\t\t? true\n\t\t: asTranslate(req.t)(keys.validationEmailFieldUnknown)\n}\n\n/**\n * `toField` names the form's own email field the confirmation is sent to (a `FieldNameSelect`, not a\n * recipient list). `replyTo`, `cc`, and `bcc` are recipient lists (`RecipientsSelect`, `string[]`):\n * literal emails, picked department addresses (when `departments` is set), or `{{field}}` tokens\n * resolved from the submission at send. `from` is a single address, added only when `fromAddresses`\n * is set. `subject`/`body` are content; `editor` overrides the body editor; `recipients` narrows the\n * recipient fields' behavior. Content and recipient fields carry `localized: true` when `localize`.\n */\n// biome-ignore lint/complexity/useMaxParams: positional args thread plugin options (localize, editor, fromAddresses, departments, recipients)\nexport const buildConfirmation = (\n\tlocalize: boolean,\n\teditor?: RichTextField['editor'],\n\tfromAddresses?: FromAddressesResolver,\n\tdepartments?: DepartmentEmailsResolver,\n\trecipients?: RecipientsConfig\n) => {\n\tconst endpoint = departments ? 'departments' : undefined\n\tconst recip = (name: string, labelKey: string) =>\n\t\tbuildRecipientField(name, labelKey, localize, { endpoint, recipients, width: '50%' })\n\tconst toField: Field = {\n\t\tname: 'toField',\n\t\ttype: 'text',\n\t\tlabel: labelFor(keys.actionConfigToField),\n\t\tadmin: {\n\t\t\twidth: '50%',\n\t\t\tcomponents: {\n\t\t\t\tField: {\n\t\t\t\t\tpath: TO_FIELD_REF,\n\t\t\t\t\tclientProps: { types: ['email'], descriptionKey: keys.actionConfigToFieldDescription },\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t\tvalidate: validateToField,\n\t}\n\treturn defineAction<ConfirmationConfig>({\n\t\ttype: 'confirmation',\n\t\tlabel: keys.actionConfirmation,\n\t\tconfig: [\n\t\t\t{ type: 'row', fields: [toField, recip('replyTo', keys.actionConfigReplyTo)] },\n\t\t\t...(fromAddresses ? [buildFromField(fromAddresses)] : []),\n\t\t\t{\n\t\t\t\ttype: 'row',\n\t\t\t\tfields: [recip('cc', keys.actionConfigCc), recip('bcc', keys.actionConfigBcc)],\n\t\t\t},\n\t\t\t{\n\t\t\t\tname: 'subject',\n\t\t\t\ttype: 'text',\n\t\t\t\tlabel: labelFor(keys.actionConfigSubject),\n\t\t\t\t...localizedIf(localize),\n\t\t\t},\n\t\t\t{\n\t\t\t\tname: 'body',\n\t\t\t\ttype: 'richText',\n\t\t\t\tlabel: labelFor(keys.actionConfigBody),\n\t\t\t\tadmin: { description: labelFor(keys.actionConfigBodyDescription) },\n\t\t\t\t...localizedIf(localize),\n\t\t\t\t...(editor ? { editor } : {}),\n\t\t\t},\n\t\t],\n\t\trun: async (args) => {\n\t\t\tconst { config, values, payload, renderBody } = args\n\n\t\t\tif (!config.toField) {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tconst resolve = resolverFor(values)\n\t\t\tconst to = resolve(config.toField)\n\n\t\t\tif (!to) {\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tif (typeof payload.sendEmail !== 'function') {\n\t\t\t\tthrow new Error('confirmation: no email adapter configured')\n\t\t\t}\n\n\t\t\tconst subject = interpolate(config.subject ?? '', resolve)\n\t\t\tconst html = await renderBody(config.body)\n\t\t\tconst cc = resolveRecipients(config.cc, resolve)\n\t\t\tconst bcc = resolveRecipients(config.bcc, resolve)\n\t\t\tconst replyTo = resolveRecipients(config.replyTo, resolve)\n\n\t\t\t// `from` was validated at save time against `fromAddresses(req)`; not re-checked here\n\t\t\t// (the job's `req` may differ from the authoring admin's, and the config is\n\t\t\t// admin-authored, not visitor-controlled), so the stored value is forwarded verbatim.\n\t\t\tawait payload.sendEmail({\n\t\t\t\tto,\n\t\t\t\tsubject,\n\t\t\t\thtml,\n\t\t\t\t...(config.from ? { from: config.from } : {}),\n\t\t\t\t...(cc ? { cc } : {}),\n\t\t\t\t...(bcc ? { bcc } : {}),\n\t\t\t\t...(replyTo ? { replyTo } : {}),\n\t\t\t})\n\t\t},\n\t})\n}\n\nexport const confirmation = buildConfirmation(true)\n"],"mappings":";;;;;;;;;;AAsBA,MAAM,eAAe;;;;;AAMrB,MAAa,mBACZ,OACA,EAAE,MAAM,UACW;CACnB,IAAI,OAAO,UAAU,YAAY,MAAM,WAAW,GACjD,OAAO;CAIR,OAAO,iBADN,QAAQ,OAAO,SAAS,WAAY,KAAiC,SAAS,KAAA,GAC/C,CAAC,OAAO,CAAC,EAAE,SAAS,KAAK,IACtD,OACA,YAAY,IAAI,CAAC,EAAE,KAAK,2BAA2B;AACvD;;;;;;;;;AAWA,MAAa,qBACZ,UACA,QACA,eACA,aACA,eACI;CACJ,MAAM,WAAW,cAAc,gBAAgB,KAAA;CAC/C,MAAM,SAAS,MAAc,aAC5B,oBAAoB,MAAM,UAAU,UAAU;EAAE;EAAU;EAAY,OAAO;CAAM,CAAC;CACrF,MAAM,UAAiB;EACtB,MAAM;EACN,MAAM;EACN,OAAO,SAAS,KAAK,mBAAmB;EACxC,OAAO;GACN,OAAO;GACP,YAAY,EACX,OAAO;IACN,MAAM;IACN,aAAa;KAAE,OAAO,CAAC,OAAO;KAAG,gBAAgB,KAAK;IAA+B;GACtF,EACD;EACD;EACA,UAAU;CACX;CACA,OAAO,aAAiC;EACvC,MAAM;EACN,OAAO,KAAK;EACZ,QAAQ;GACP;IAAE,MAAM;IAAO,QAAQ,CAAC,SAAS,MAAM,WAAW,KAAK,mBAAmB,CAAC;GAAE;GAC7E,GAAI,gBAAgB,CAAC,eAAe,aAAa,CAAC,IAAI,CAAC;GACvD;IACC,MAAM;IACN,QAAQ,CAAC,MAAM,MAAM,KAAK,cAAc,GAAG,MAAM,OAAO,KAAK,eAAe,CAAC;GAC9E;GACA;IACC,MAAM;IACN,MAAM;IACN,OAAO,SAAS,KAAK,mBAAmB;IACxC,GAAG,YAAY,QAAQ;GACxB;GACA;IACC,MAAM;IACN,MAAM;IACN,OAAO,SAAS,KAAK,gBAAgB;IACrC,OAAO,EAAE,aAAa,SAAS,KAAK,2BAA2B,EAAE;IACjE,GAAG,YAAY,QAAQ;IACvB,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;GAC5B;EACD;EACA,KAAK,OAAO,SAAS;GACpB,MAAM,EAAE,QAAQ,QAAQ,SAAS,eAAe;GAEhD,IAAI,CAAC,OAAO,SACX;GAGD,MAAM,UAAU,YAAY,MAAM;GAClC,MAAM,KAAK,QAAQ,OAAO,OAAO;GAEjC,IAAI,CAAC,IACJ;GAGD,IAAI,OAAO,QAAQ,cAAc,YAChC,MAAM,IAAI,MAAM,2CAA2C;GAG5D,MAAM,UAAU,YAAY,OAAO,WAAW,IAAI,OAAO;GACzD,MAAM,OAAO,MAAM,WAAW,OAAO,IAAI;GACzC,MAAM,KAAK,kBAAkB,OAAO,IAAI,OAAO;GAC/C,MAAM,MAAM,kBAAkB,OAAO,KAAK,OAAO;GACjD,MAAM,UAAU,kBAAkB,OAAO,SAAS,OAAO;GAKzD,MAAM,QAAQ,UAAU;IACvB;IACA;IACA;IACA,GAAI,OAAO,OAAO,EAAE,MAAM,OAAO,KAAK,IAAI,CAAC;IAC3C,GAAI,KAAK,EAAE,GAAG,IAAI,CAAC;IACnB,GAAI,MAAM,EAAE,IAAI,IAAI,CAAC;IACrB,GAAI,UAAU,EAAE,QAAQ,IAAI,CAAC;GAC9B,CAAC;EACF;CACD,CAAC;AACF;AAE4B,kBAAkB,IAAI"}

package/dist/actions/builtin/emailTeam.js

@@ -4,48 +4,77 @@ import { keys } from "../../translations/keys.js";
 import { labelFor } from "../../translations/server.js";
 import { resolverFor } from "../body/serializeBody.js";
 import { defineAction } from "../defineAction.js";
+import { buildRecipientField, resolveRecipients } from "../emailRecipients.js";
+import { buildFromField } from "../fromAddresses.js";
 //#region src/actions/builtin/emailTeam.ts
 /**
-* `subject` and `body` are email content and follow `localize`; the `to` address never does.
-* `editor` overrides the body field's Lexical/richText editor (from the plugin's `richText.editor` option).
+* `to`, `replyTo`, `cc`, and `bcc` are recipient lists (`RecipientsSelect`, stored as `string[]`):
+* each entry is a literal email, a picked department address (when `departments` is set its options
+* back the select), or a `{{field}}` token resolved from the submission at send. `from` is a single
+* address that never localizes, added only when `fromAddresses` is set. `subject` and `body` are email
+* content; `editor` overrides the body's richText editor. `recipients` narrows the recipient fields'
+* behavior (free-typed emails, field tokens). Content and recipient fields carry `localized: true`
+* when `localize` is true. At send, every recipient list is interpolated, empties dropped, and joined
+* into the comma-separated string `payload.sendEmail` (nodemailer) accepts.
 */
-const buildEmailTeam = (localize, editor) => defineAction({
-	type: "emailTeam",
-	label: keys.actionEmailTeam,
-	config: [
-		{
-			name: "to",
-			type: "text",
-			label: labelFor(keys.actionConfigTo)
-		},
-		{
-			name: "subject",
-			type: "text",
-			label: labelFor(keys.actionConfigSubject),
-			...localizedIf(localize)
-		},
-		{
-			name: "body",
-			type: "richText",
-			label: labelFor(keys.actionConfigBody),
-			admin: { description: labelFor(keys.actionConfigBodyDescription) },
-			...localizedIf(localize),
-			...editor ? { editor } : {}
+const buildEmailTeam = (localize, editor, fromAddresses, departments, recipients) => {
+	const endpoint = departments ? "departments" : void 0;
+	const recip = (name, labelKey) => buildRecipientField(name, labelKey, localize, {
+		endpoint,
+		recipients,
+		width: "50%"
+	});
+	return defineAction({
+		type: "emailTeam",
+		label: keys.actionEmailTeam,
+		config: [
+			{
+				type: "row",
+				fields: [recip("to", keys.actionConfigTo), recip("replyTo", keys.actionConfigReplyTo)]
+			},
+			...fromAddresses ? [buildFromField(fromAddresses)] : [],
+			{
+				type: "row",
+				fields: [recip("cc", keys.actionConfigCc), recip("bcc", keys.actionConfigBcc)]
+			},
+			{
+				name: "subject",
+				type: "text",
+				label: labelFor(keys.actionConfigSubject),
+				...localizedIf(localize)
+			},
+			{
+				name: "body",
+				type: "richText",
+				label: labelFor(keys.actionConfigBody),
+				admin: { description: labelFor(keys.actionConfigBodyDescription) },
+				...localizedIf(localize),
+				...editor ? { editor } : {}
+			}
+		],
+		run: async (args) => {
+			const { config, values, payload, renderBody } = args;
+			const resolve = resolverFor(values);
+			const to = resolveRecipients(config.to, resolve);
+			if (!to) throw new Error("emailTeam: missing \"to\" address");
+			if (typeof payload.sendEmail !== "function") throw new Error("emailTeam: no email adapter configured");
+			const subject = interpolate(config.subject ?? "", resolve);
+			const html = await renderBody(config.body);
+			const cc = resolveRecipients(config.cc, resolve);
+			const bcc = resolveRecipients(config.bcc, resolve);
+			const replyTo = resolveRecipients(config.replyTo, resolve);
+			await payload.sendEmail({
+				to,
+				subject,
+				html,
+				...config.from ? { from: config.from } : {},
+				...cc ? { cc } : {},
+				...bcc ? { bcc } : {},
+				...replyTo ? { replyTo } : {}
+			});
 		}
-	],
-	run: async (args) => {
-		const { config, values, payload, renderBody } = args;
-		if (!config.to) throw new Error("emailTeam: missing \"to\" address");
-		if (typeof payload.sendEmail !== "function") throw new Error("emailTeam: no email adapter configured");
-		const subject = interpolate(config.subject ?? "", resolverFor(values));
-		const html = await renderBody(config.body);
-		await payload.sendEmail({
-			to: config.to,
-			subject,
-			html
-		});
-	}
-});
+	});
+};
 buildEmailTeam(true);
 //#endregion
 export { buildEmailTeam };