@@ -0,0 +1,20 @@
+---
+'@objectstack/plugin-email': patch
+---
+
+fix(plugin-email): a templated email to a named locale folds it against the template's locales and tries the stack's declared fallback before en-US (#28880)
+
+Clause-②: no
+Metadata-protocol: none
+Skills-docs: none — no file under `skills/**` teaches the email template locale ladder.
+
+`sendTemplate` and `renderTemplate` used to try a named recipient locale exactly, then `en-US`, then fail with `TEMPLATE_NOT_FOUND`. A recipient whose tag differed from a template row only by region (`en-GB` against an `en` row, `zh-TW` against `zh-CN`) or by case got nothing, and the stack's `i18n.fallbackLocale` was never read, so those deliveries dead-lettered.
+
+With the built-in template loader, a call that names a locale now resolves, in order:
+
+1. that locale against the template's own locales by the platform's BCP-47 rules (`resolveBundleLocale`): exact, case-insensitive, base language (`en-GB` → `en`), then variant expansion (`zh-TW` → `zh-CN`), taking the first match in ascending tag order;
+2. the stack's declared fallback (`i18n.fallbackLocale`, else `defaultLocale`, from the i18n service), folded the same way;
+3. `en-US`;
+4. `TEMPLATE_NOT_FOUND`, still a permanent failure.
+
+An exact match answers as before. A call that names no locale keeps its ladder (`en-US`, then the lowest tag) and does not read the declared fallback. A replacement `TemplateLoader` keeps the exact ladder: the fold is a capability of the built-in loader, and no exported type changes.
@@ -1,7 +1,7 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import type { Plugin, PluginContext } from '@objectstack/core';
-import type { IDataEngine } from '@objectstack/spec/contracts';
+import type { IDataEngine, II18nService } from '@objectstack/spec/contracts';
 import type {
   IEmailTransport,
   EmailAddress,
@@ -507,6 +507,16 @@ export class EmailServicePlugin implements Plugin {
       logger: ctx.logger,
     });
 
+    // [#28880] The stack's declared fallback locale joins a named-locale
+    // template ladder (after the recipient's own tag, before en-US). Read
+    // from the i18n service at each send, so one registered after this
+    // plugin is seen; a host with no i18n service declares none.
+    this.service.setTemplateFallbackLocale(() => {
+      let i18n: II18nService | undefined;
+      try { i18n = ctx.getService<II18nService>('i18n'); } catch { return undefined; }
+      return i18n?.getFallbackLocale?.();
+    });
+
     // [#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
 
@@ -41,6 +41,7 @@ import {
   TENANT_EMAIL_OBJECT,
   type EmailLogObject,
 } from './email-log-objects.js';
+import { resolveBundleLocale } from '@objectstack/spec/system';
 
 /**
  * Queue topic durable email delivery is published to and consumed from
@@ -522,6 +523,20 @@ export interface TemplateLoader {
   load(name: string, locale: string | undefined): Promise<EmailTemplateRow | null>;
 }
 
+/**
+ * [#28880] The built-in registry loader's own capability, kept off
+ * {@link TemplateLoader} and out of the package's exports: under this key it
+ * answers the locale tags a template name's bundle carries, sorted ascending.
+ * With it, {@link EmailService}'s ladder folds a named locale against that
+ * list (`resolveBundleLocale`) before loading the resolved tag exactly, and
+ * the stack's declared fallback joins the ladder. A loader without it — any
+ * replacement loader — answers the exact ladder it always did.
+ */
+export const TEMPLATE_BUNDLE_LOCALES = Symbol('@objectstack/plugin-email:template-bundle-locales');
+
+/** What the built-in loader answers under {@link TEMPLATE_BUNDLE_LOCALES}. */
+export type TemplateBundleLocales = (name: string) => Promise<string[]>;
+
 /**
  * What the loader answers: the render input of one resolved `email_template`
  * definition, spelled as the `sys_email_template` columns were — the shape
@@ -609,6 +624,9 @@ export class EmailService implements IEmailService {
    */
   private readonly managedRowIds = new Set<string>();
 
+  /** [#28880] The stack's declared fallback locale, read at each resolve. Unset ⇒ none declared. */
+  private templateFallbackLocale?: () => string | undefined;
+
   /**
    * Set once queue delivery has been reported as unavailable, so the
    * degradation is stated at the FIRST send and not on every one
@@ -639,6 +657,24 @@ export class EmailService implements IEmailService {
     this.options.templateLoader = loader;
   }
 
+  /**
+   * [#28880] Wire the stack's declared fallback locale (`i18n.fallbackLocale`,
+   * else `defaultLocale`, as the i18n service's `getFallbackLocale` answers
+   * it). Read at each resolve, so a later-registered i18n service is seen.
+   */
+  setTemplateFallbackLocale(read: () => string | undefined): void {
+    this.templateFallbackLocale = read;
+  }
+
+  private declaredFallbackLocale(): string | undefined {
+    try {
+      const declared = this.templateFallbackLocale?.();
+      return typeof declared === 'string' && declared.trim() ? declared.trim() : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
   /** Wire (or replace) persistence after construction. */
   setPersistence(persistence: EmailPersistence | undefined): void {
     this.options.persistence = persistence;
@@ -1404,8 +1440,33 @@ export class EmailService implements IEmailService {
     // locale means the DOCUMENTED default, so ask for it by name.
     const preferred = input.locale && String(input.locale).trim();
     const wanted = preferred || DEFAULT_TEMPLATE_LOCALE;
-    let row = await loader.load(input.template, wanted);
-    if (!row && wanted !== DEFAULT_TEMPLATE_LOCALE) {
+    // [#28880] A named locale, over the built-in loader, is folded against the
+    // bundle's own tags by the platform's one BCP-47 ladder (exact →
+    // case-insensitive → base language → variant expansion, the first match
+    // in ascending tag order), then the stack's declared fallback is folded
+    // the same way, before the `en-US` rung below. Each rung loads the tag it
+    // resolved to, exactly. A no-locale call keeps its ladder: en-US, then the
+    // loader's own answer.
+    const bundleLocales = (loader as { [TEMPLATE_BUNDLE_LOCALES]?: TemplateBundleLocales })[TEMPLATE_BUNDLE_LOCALES];
+    const locales = preferred && typeof bundleLocales === 'function'
+      ? await bundleLocales.call(loader, input.template)
+      : undefined;
+    const tried = new Set<string>();
+    let row: EmailTemplateRow | null = null;
+    if (locales) {
+      const bundle: Record<string, true> = Object.fromEntries(locales.map((tag) => [tag, true] as const));
+      for (const requested of [wanted, this.declaredFallbackLocale()]) {
+        const tag = requested === undefined ? undefined : resolveBundleLocale(bundle, requested);
+        if (tag === undefined || tried.has(tag)) continue;
+        tried.add(tag);
+        row = await loader.load(input.template, tag);
+        if (row) break;
+      }
+    } else {
+      tried.add(wanted);
+      row = await loader.load(input.template, wanted);
+    }
+    if (!row && !tried.has(DEFAULT_TEMPLATE_LOCALE)) {
       row = await loader.load(input.template, DEFAULT_TEMPLATE_LOCALE);
     }
     if (!row && !preferred) {
 
@@ -32,7 +32,7 @@
 
 import { stripReadDecorations } from '@objectstack/spec/kernel';
 import { EmailTemplateDefinitionSchema, type EmailTemplateDefinitionParsed } from '@objectstack/spec/system';
-import { DEFAULT_TEMPLATE_LOCALE, type EmailTemplateRow, type TemplateLoader } from './email-service.js';
+import { DEFAULT_TEMPLATE_LOCALE, TEMPLATE_BUNDLE_LOCALES, type EmailTemplateRow, type TemplateLoader, type TemplateBundleLocales } from './email-service.js';
 
 /**
  * The package the built-in auth templates are code-declared under: the email
@@ -171,7 +171,14 @@ export function createRegistryEmailTemplateLoader(
     return toRenderInput(parsed.data);
   };
 
-  return {
+  // [#28880] The bundle's tags, for the service's fold (module-private key,
+  // not on `TemplateLoader`): sorted, so variant expansion's "first match" is
+  // the lowest tag, whatever order the list carries.
+  const bundleLocales: TemplateBundleLocales = async (name) =>
+    [...new Set((await readBundle(name)).map(itemLocale))].sort();
+
+  const loader: TemplateLoader & { [TEMPLATE_BUNDLE_LOCALES]: TemplateBundleLocales } = {
+    [TEMPLATE_BUNDLE_LOCALES]: bundleLocales,
     async load(name, locale) {
       const bundle = await readBundle(name);
       if (locale) return render(pick(bundle, locale));
@@ -182,4 +189,5 @@ export function createRegistryEmailTemplateLoader(
       return lowest === undefined ? null : render(pick(bundle, lowest));
     },
   };
+  return loader;
 }
@@ -0,0 +1,105 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+//
+// [#28880] The duly shape, booted: an app ships an `en` + `zh-CN` bundle (no
+// `en-US` row), and the real `EmailServicePlugin` sends it through the
+// built-in registry loader it wires. Measured on `origin/main` (`b15b634c`):
+// `en-GB` and `zh-TW` recipients both threw `TEMPLATE_NOT_FOUND` (the ladder
+// tried the named tag, then `en-US`), so each delivery dead-lettered. On this
+// head `en-GB` reaches the `en` row and `zh-TW` the `zh-CN` row, and a
+// recipient whose language the bundle lacks reaches the stack's declared
+// fallback (the i18n service's `getFallbackLocale`) before `en-US`.
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { ObjectKernel } from '@objectstack/core';
+import type { Plugin, PluginContext } from '@objectstack/core';
+import { ObjectQLPlugin } from '@objectstack/objectql';
+import type { IEmailService, IEmailTransport, NormalizedEmailMessage, TransportSendResult } from '@objectstack/spec/contracts';
+import { EmailServicePlugin } from './email-plugin.js';
+
+const PACKAGE_ID = 'com.test.mail-locale-fold';
+
+const bundle = (locale: string) => ({
+  name: 'lf_lead_time',
+  label: 'Lead time',
+  locale,
+  subject: `[${locale}] {{title}} is due`,
+  bodyHtml: `<p>[${locale}] {{title}}</p>`,
+});
+
+/** A driver that stores nothing: the template is metadata, not a row. */
+const emptyDriver = {
+  name: 'mail-locale-fold-driver',
+  version: '1.0.0',
+  supports: {},
+  connect: async () => {},
+  disconnect: async () => {},
+  find: async () => [],
+  findOne: async () => null,
+  count: async () => 0,
+  create: async (_o: string, d: any) => d,
+  update: async (_o: string, _i: any, d: any) => d,
+  delete: async () => true,
+  syncSchema: async () => {},
+};
+
+/** Registers the driver, the app body through the `manifest` service, and an i18n service declaring `fallback`. */
+class AppFixture implements Plugin {
+  name = 'test.mail-locale-fold.app';
+  type = 'standard' as const;
+  version = '1.0.0';
+  constructor(private readonly fallback: string | undefined) {}
+  async init(ctx: PluginContext) {
+    ctx.registerService('driver.mail-locale-fold', emptyDriver);
+    if (this.fallback !== undefined) {
+      const fallback = this.fallback;
+      ctx.registerService('i18n', { getFallbackLocale: () => fallback });
+    }
+    const manifest = { id: PACKAGE_ID, name: 'mail_locale_fold', type: 'app', version: '1.0.0' };
+    ctx.getService<{ register(m: unknown): void }>('manifest').register({
+      ...manifest, manifest, emailTemplates: [bundle('en'), bundle('zh-CN')],
+    });
+  }
+}
+
+class CaptureTransport implements IEmailTransport {
+  readonly subjects: string[] = [];
+  async send(message: NormalizedEmailMessage): Promise<TransportSendResult> {
+    this.subjects.push(message.subject);
+    return { messageId: `<fold-${this.subjects.length}@test>` };
+  }
+}
+
+describe('[#28880] the booted email service folds a recipient locale over the built-in loader', () => {
+  let kernel: ObjectKernel | undefined;
+
+  afterEach(async () => {
+    if (kernel?.getState() === 'running') await kernel.shutdown();
+    kernel = undefined;
+  });
+
+  async function boot(fallback?: string) {
+    kernel = new ObjectKernel({ logger: { level: 'silent' }, gracefulShutdown: false });
+    const transport = new CaptureTransport();
+    await kernel.use(new ObjectQLPlugin());
+    await kernel.use(new AppFixture(fallback));
+    await kernel.use(new EmailServicePlugin({ persist: false, transport, defaultFrom: { address: 'no-reply@example.com' } }));
+    await kernel.bootstrap();
+    const email = kernel.getService<IEmailService>('email');
+    return async (locale: string) => {
+      const res = await email.sendTemplate({ template: 'lf_lead_time', to: 'ann@example.com', locale, data: { title: 'Visa' } });
+      expect(res.status).toBe('sent');
+      return transport.subjects[transport.subjects.length - 1];
+    };
+  }
+
+  it('en-GB reaches the en row and zh-TW the zh-CN row', async () => {
+    const send = await boot();
+    expect(await send('en-GB')).toBe('[en] Visa is due');
+    expect(await send('zh-TW')).toBe('[zh-CN] Visa is due');
+  });
+
+  it('a recipient language the bundle lacks reaches the declared fallback', async () => {
+    const send = await boot('zh-CN');
+    expect(await send('ja')).toBe('[zh-CN] Visa is due');
+  });
+});