@@ -0,0 +1,12 @@
+---
+'@objectstack/plugin-email': patch
+---
+
+fix(plugin-email): a mail template's `{{ stage | option:opportunity.stage }}` hole prints the option's label in each recipient's language, and a hole the deployment cannot label refuses the send `TEMPLATE_INVALID`
+
+Clause-②: no
+Metadata-protocol: none
+
+- **What was wrong.** A template using the `option` formatter passed every authoring door, and then every send of it failed: the email service handed the formatter no label table, so `sendTemplate` and `renderTemplate` threw a bare `RangeError` outside the `TEMPLATE_INVALID` vocabulary, and nothing was sent.
+- **What changes.** Before rendering, the email service builds a label table for each `object.field` the template's `option` holes name, once per send, from the deployment's served object (`IDataEngine.getObject`) with the `i18n` service's bundle laid over it by `translateObject` — the path `GET /meta/object/:name` serves the object with and a formula's `label()` reads. The locale is the send's own `locale`, the recipient's, never an execution context's: a scheduled flow that runs as the system still mails each recipient in their language. A send that names no locale reads the declared labels. A value outside the field's options prints as stored; a multi-select value prints each label, joined with `, `.
+- **What is refused.** An object the deployment does not serve, a field the object does not have, a field that declares no options, and a field whose option list is empty refuse the whole send with `TEMPLATE_INVALID`, naming the template, the hole and the rule, before any face is rendered; nothing reaches the transport. A host with no data engine builds no table, and such a hole is refused `TEMPLATE_INVALID` by the renderer, with the formula's `optionTableRefusal` sentence.
@@ -595,6 +595,18 @@ export class EmailServicePlugin implements Plugin {
       return i18n?.getFallbackLocale?.();
     });
 
+    // A template's `option` holes read the served objects and the i18n
+    // service, resolved at each send (resolve where it is used): an engine or
+    // an i18n service registered after this plugin is seen, and a host with
+    // no data engine builds no table, so such a hole is refused at render.
+    this.service.setOptionLabelSources(() => {
+      const engine = resolveDataEngine(ctx) as { getObject?: (name: string) => unknown } | null;
+      if (!engine || typeof engine.getObject !== 'function') return undefined;
+      let i18n: II18nService | undefined;
+      try { i18n = ctx.getService<II18nService>('i18n'); } catch { i18n = undefined; }
+      return { getObject: (name) => engine.getObject!(name), ...(i18n ? { i18n } : {}) };
+    });
+
     // [#23946] Persistence + the template loader are wired HERE, before the
     // service is handed out, and not at this plugin's `kernel:ready`. A
     // plugin that STARTS before this one runs its own `kernel:ready` hooks
 
@@ -15,7 +15,8 @@ import type {
   IQueueService,
   QueueBackoffPolicy,
 } from '@objectstack/spec/contracts';
-import { renderTemplate, renderPlainTextTemplate, requireVars, htmlToText } from './template-engine.js';
+import { renderTemplate, renderPlainTextTemplate, requireVars, htmlToText, type RenderOptions } from './template-engine.js';
+import { buildOptionLabelTable, type OptionLabelSources } from './option-label-table.js';
 import {
   SYS_EMAIL_ATTACHMENT_LIMIT_BYTES,
   encodeAttachmentsForRow,
@@ -679,6 +680,14 @@ export class EmailService implements IEmailService {
   /** [#28880] The stack's declared fallback locale, read at each resolve. Unset ⇒ none declared. */
   private templateFallbackLocale?: () => string | undefined;
 
+  /**
+   * Where an `option` hole's labels come from (the served objects and the
+   * i18n service), read at each render. Unset, or answering `undefined`, ⇒ no
+   * label table is built, and a template with an `option` hole is refused
+   * `TEMPLATE_INVALID` by the renderer.
+   */
+  private optionLabelSources?: () => OptionLabelSources | undefined;
+
   /**
    * Set once queue delivery has been reported as unavailable, so the
    * degradation is stated at the FIRST send and not on every one
@@ -718,6 +727,16 @@ export class EmailService implements IEmailService {
     this.templateFallbackLocale = read;
   }
 
+  /**
+   * Wire where a template's `{{ stage | option:opportunity.stage }}` holes
+   * read their option labels: the served object by name and the i18n
+   * service. Read at each render, so services registered after this one are
+   * seen.
+   */
+  setOptionLabelSources(read: () => OptionLabelSources | undefined): void {
+    this.optionLabelSources = read;
+  }
+
   private declaredFallbackLocale(): string | undefined {
     try {
       const declared = this.templateFallbackLocale?.();
@@ -1572,13 +1591,37 @@ export class EmailService implements IEmailService {
     // `' zh-CN '` must not reach `Intl`, which throws a RangeError on it and
     // took the whole send down.
     const locale = preferred || row.locale;
-    const renderOpts = {
+    const renderOpts: RenderOptions = {
       ...(locale ? { locale } : {}),
       ...(input.timezone ? { timeZone: input.timezone } : {}),
       // The tenant default a `{{ amount | currency }}` hole formats in. The
       // caller supplies it; absent, such a hole refuses below, never USD.
       ...(input.currency ? { currency: input.currency } : {}),
     };
+    // An `option` hole prints a select value as its option's label in the
+    // RECIPIENT's language (ruling F on the option-label card): the table is
+    // built here, once for the three faces, from the served objects in the
+    // send's own locale — `preferred`, the recipient's, never the row's
+    // fallback and never an execution context's, so a scheduled flow running
+    // as the system still mails each recipient in their language. No locale ⇒
+    // the declared labels. An object, field or option list the table cannot be
+    // built from refuses the whole send `TEMPLATE_INVALID`, before any face is
+    // rendered; with no sources wired the renderer refuses the hole instead.
+    let optionLabels: ReturnType<typeof buildOptionLabelTable>;
+    try {
+      const sources = this.optionLabelSources?.();
+      optionLabels = sources
+        ? buildOptionLabelTable([row.subject, row.body_html, row.body_text], preferred || undefined, sources)
+        : undefined;
+    } catch (err: any) {
+      const message = String(err?.message ?? err);
+      if (!message.startsWith('TEMPLATE_INVALID: ')) throw err;
+      throw new Error(
+        `TEMPLATE_INVALID: email template ${input.template} (locale=${row.locale}): `
+        + message.slice('TEMPLATE_INVALID: '.length),
+      );
+    }
+    if (optionLabels) renderOpts.optionLabels = optionLabels;
     // Each face is rendered in ITS OWN encoding. Only `body_html` is markup,
     // so only it HTML-escapes its `{{x}}` holes. The subject (a mail header,
     // an inbox title) and `body_text` (the plain-text part, an inbox body) are
 
@@ -0,0 +1,200 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * # The label table a mail template's `option` holes read
+ *
+ * `{{ stage | option:opportunity.stage }}` prints a select field's stored
+ * value as its option's label, in the RECIPIENT's language (ruling F on the
+ * option-label card, parameter 3). `@objectstack/formula`'s `option`
+ * formatter only reads a table it is handed (`OptionLabelTable`, keyed by the
+ * hole's `object.field`); this module is where the mail renderer builds that
+ * table, once per send, before the synchronous render of its three faces.
+ *
+ * ## One translation path
+ *
+ * The labels are the ones the object's metadata is served with in the
+ * recipient's locale: the SERVED object's declared `options` (a
+ * picklist-bound field carries its resolved list there), with the translation
+ * bundle laid over them by `translateObject` (`@objectstack/spec/system`) —
+ * the function behind `GET /meta/object/:name`, built from the i18n service
+ * with the same locale options. It is the path `@objectstack/objectql`'s
+ * `readerOptionLabels` (`formula-option-labels.ts`) gives a formula's
+ * `label()`, step for step; that module is not reachable from here
+ * (`@objectstack/objectql` is only this package's dev dependency), so the
+ * steps are taken through the same two published functions, `translateObject`
+ * and `declaresOptions`, and `option-label-table.test.ts` holds the two
+ * answers equal. ⛔ No translation key is spelled here.
+ *
+ * ## Which locale
+ *
+ * The send's own `locale` — the recipient's, which the messaging channels
+ * resolve per recipient and hand to `sendTemplate` / `renderTemplate`. Never an
+ * execution context's: a scheduled flow runs as the system, with no reader,
+ * and still mails each recipient in their own language. A send that names no
+ * locale gets the DECLARED labels.
+ *
+ * ## Refusals
+ *
+ * Judged against the deployment's served objects with
+ * `judgeMailHoleGrammar(face, { objects, liveUniverse: true })`, the sentences
+ * the authoring doors show: an object no one serves, a field the object does
+ * not have, a field with no options — and, decided here, a field whose served
+ * option list is EMPTY, which has no option to label a value with either.
+ * Each is `TEMPLATE_INVALID` and refuses the whole send, before any face is
+ * rendered.
+ */
+
+import { declaresOptions, judgeMailHoleGrammar, mailHolePattern, parseMailHole } from '@objectstack/formula';
+import type { OptionLabelTable } from '@objectstack/formula';
+import { translateObject, type ObjectFieldLike, type TranslationBundle } from '@objectstack/spec/system';
+
+/** The slice of `II18nService` the labels are translated through — what the metadata route reads. */
+export interface OptionLabelI18n {
+  getLocales?: () => string[];
+  getTranslations?: (locale: string) => Record<string, unknown>;
+  getFallbackLocale?: () => string | undefined;
+  getDefaultLocale?: () => string | undefined;
+}
+
+/**
+ * Where a send's option labels come from, resolved at each send (a service
+ * registered after the email plugin is seen): the served object by name
+ * (`IDataEngine.getObject`, the registry's answer — what
+ * `GET /meta/object/:name` serves before translation) and the i18n service.
+ */
+export interface OptionLabelSources {
+  getObject: (name: string) => unknown;
+  i18n?: OptionLabelI18n;
+}
+
+/** The `object.field` keys the `option` holes of `faces` name, in first-seen order. */
+export function optionHoleKeys(faces: ReadonlyArray<string | null | undefined>): Array<{ key: string; object: string; field: string }> {
+  const seen = new Map<string, { key: string; object: string; field: string }>();
+  for (const face of faces) {
+    if (typeof face !== 'string' || face === '') continue;
+    for (const m of face.matchAll(mailHolePattern())) {
+      const ref = parseMailHole(m[2], m[0])?.optionField;
+      if (!ref) continue;
+      const key = `${ref.object}.${ref.field}`;
+      if (!seen.has(key)) seen.set(key, { key, object: ref.object, field: ref.field });
+    }
+  }
+  return [...seen.values()];
+}
+
+/** The fields of a served object, by name, when it carries a fields map. */
+function fieldsOf(schema: unknown): Record<string, ObjectFieldLike> | undefined {
+  const fields = (schema as { fields?: unknown } | undefined)?.fields;
+  if (!fields || typeof fields !== 'object' || Array.isArray(fields)) return undefined;
+  return fields as Record<string, ObjectFieldLike>;
+}
+
+/** Stored value (as text) → label, read off one field's option list. */
+function labelsOf(def: ObjectFieldLike | undefined): Record<string, string> {
+  const labels: Record<string, string> = {};
+  for (const option of Array.isArray(def?.options) ? def.options : []) {
+    if (!option || typeof option !== 'object' || option.value === undefined || option.value === null) continue;
+    if (typeof option.label === 'string' && option.label.length > 0) labels[String(option.value)] = option.label;
+  }
+  return labels;
+}
+
+/**
+ * The bundle the metadata route translates with — every locale the service
+ * holds, keyed by locale — or `undefined` when the service holds none.
+ */
+function bundleOf(i18n: OptionLabelI18n): TranslationBundle | undefined {
+  if (typeof i18n.getLocales !== 'function' || typeof i18n.getTranslations !== 'function') return undefined;
+  const bundle: Record<string, unknown> = {};
+  for (const locale of i18n.getLocales()) {
+    const data = i18n.getTranslations(locale);
+    if (data && typeof data === 'object') bundle[locale] = data;
+  }
+  return Object.keys(bundle).length > 0 ? (bundle as TranslationBundle) : undefined;
+}
+
+/**
+ * The option-declaring fields of `schema`, translated into `locale` as the
+ * object is served in it. No locale, no i18n service, or one holding no
+ * translations: the declared fields. A misbehaving service never fails the
+ * send — the declared labels stand, as `readerOptionLabels` answers.
+ */
+function servedOptionFields(
+  name: string,
+  optionFields: Record<string, ObjectFieldLike>,
+  locale: string | undefined,
+  i18n: OptionLabelI18n | undefined,
+): Record<string, ObjectFieldLike> {
+  if (!locale || !i18n || Object.keys(optionFields).length === 0) return optionFields;
+  try {
+    const bundle = bundleOf(i18n);
+    if (!bundle) return optionFields;
+    const fallback = typeof i18n.getFallbackLocale === 'function' ? i18n.getFallbackLocale() : undefined;
+    const defaultLocale = typeof i18n.getDefaultLocale === 'function' ? i18n.getDefaultLocale() : undefined;
+    const translated = translateObject({ name, fields: optionFields }, bundle, {
+      locale,
+      ...(typeof fallback === 'string' && fallback.length > 0 ? { fallbackChain: [fallback] } : {}),
+      ...(typeof defaultLocale === 'string' && defaultLocale.length > 0 ? { defaultLocale } : {}),
+    });
+    const fields = fieldsOf(translated);
+    return fields ?? optionFields;
+  } catch {
+    return optionFields;
+  }
+}
+
+/**
+ * The label table the `option` holes of `faces` read, in `locale` (the
+ * recipient's; `undefined` ⇒ the declared labels), or `undefined` when no face
+ * has an `option` hole. Throws `TEMPLATE_INVALID: …` when a hole names an
+ * object the deployment does not serve, a field that object does not have, or
+ * a field with no options (none declared, or an empty list).
+ */
+export function buildOptionLabelTable(
+  faces: ReadonlyArray<string | null | undefined>,
+  locale: string | undefined,
+  sources: OptionLabelSources,
+): OptionLabelTable | undefined {
+  const keys = optionHoleKeys(faces);
+  if (keys.length === 0) return undefined;
+
+  // The served object of every name a hole gives, judged as the live universe:
+  // a name nothing serves is unknown here, whatever its prefix.
+  const schemas = new Map<string, { name: string; fields: Record<string, ObjectFieldLike> }>();
+  const objects = new Map<string, ReadonlyMap<string, boolean>>();
+  for (const { object } of keys) {
+    if (objects.has(object)) continue;
+    const schema = sources.getObject(object);
+    const fields = schema === undefined || schema === null ? undefined : fieldsOf(schema);
+    if (!fields) continue;
+    const servedName = (schema as { name?: unknown }).name;
+    schemas.set(object, { name: typeof servedName === 'string' && servedName ? servedName : object, fields });
+    // An option list with no option in it labels nothing: judged as a field
+    // with no options, so the send is refused rather than print every value
+    // as stored under a formatter that promises a label.
+    objects.set(object, new Map(Object.entries(fields).map(([field, def]) => [
+      field,
+      declaresOptions(def) && Object.keys(labelsOf(def)).length > 0,
+    ])));
+  }
+  for (const face of faces) {
+    if (typeof face !== 'string' || face === '') continue;
+    const [finding] = judgeMailHoleGrammar(face, { objects, liveUniverse: true });
+    if (finding) throw new Error(`TEMPLATE_INVALID: ${finding.refusal.message}`);
+  }
+
+  const table: Record<string, Record<string, string>> = {};
+  const translatedBy = new Map<string, Record<string, ObjectFieldLike>>();
+  for (const { key, object, field } of keys) {
+    const schema = schemas.get(object)!;
+    let served = translatedBy.get(object);
+    if (!served) {
+      const optionFields: Record<string, ObjectFieldLike> = {};
+      for (const [name, def] of Object.entries(schema.fields)) if (declaresOptions(def)) optionFields[name] = def;
+      served = servedOptionFields(schema.name, optionFields, locale, sources.i18n);
+      translatedBy.set(object, served);
+    }
+    table[key] = labelsOf(served[field]);
+  }
+  return table;
+}