@@ -68,7 +68,7 @@ import {
     type ExportCellMeta,
 } from './export-format.js';
 import { importControlOptOutRefusal, prepareImportRequest } from './import-prepare.js';
-import { readTemplateMode, templateFieldDefs } from './import-template.js';
+import { readTemplateMode, templateFieldDefs, templateText } from './import-template.js';
 import { refuseRepeatedQueryParams } from './query-multiplicity.js';
 import { refuseUnknownQueryParams } from './query-allowlist.js';
 import { handleRouteError, logUnexpectedRouteError, mapDataError, nestedRefusalEnvelope } from './error-response.js';
@@ -200,6 +200,8 @@ export interface DataActionRouteHost {
     translateMetaItem: RestServer['translateMetaItem'];
     resolveMessageTranslator: RestServer['resolveMessageTranslator'];
     resolveSecurityService: RestServer['resolveSecurityService'];
+    resolveI18nService: RestServer['resolveI18nService'];
+    extractLocale: RestServer['extractLocale'];
     answerImportTemplate: RestServer['answerImportTemplate'];
 }
 
@@ -884,8 +886,15 @@ export function registerDataActionEndpoints(this: DataActionRouteHost, basePath:
     //
     // Values are formatted for readability from the object schema: lookup /
     // user fields resolve to a name (via injected $expand), select fields to
-    // their option label, booleans to 是/否, dates to YYYY-MM-DD. When the
-    // schema is unavailable the raw stored values stream through unchanged.
+    // their option label, booleans to the caller's yes / no words, dates to
+    // YYYY-MM-DD. When the schema is unavailable the raw stored values stream
+    // through unchanged.
+    //
+    // [#24945] Boolean / toggle cells are written in the language of the
+    // header row: `templateText(locale).booleanWords` (yes / no, or 是 / 否 for
+    // a `zh*` locale), for the locale the header labels are translated to
+    // (`Accept-Language`, then `?locale=`, then the i18n service's default).
+    // The importer reads both languages back, so the file re-imports.
     //
     // [#8373] `datetime` cells render in the caller's BUSINESS timezone
     // (`ExecutionContext.timezone`), so the file agrees with the screen;
@@ -1084,7 +1093,7 @@ export function registerDataActionEndpoints(this: DataActionRouteHost, basePath:
                 const fieldsExplicit = !!fields && fields.length > 0;
 
                 // Field metadata drives readable formatting (lookup names, select
-                // labels, 是/否, formatted dates) and the $expand that resolves
+                // labels, yes / no words, formatted dates) and the $expand that resolves
                 // references. Best-effort: when the schema is unavailable the export
                 // falls back to raw values, byte-identical to the un-formatted path.
                 let metaMap = new Map<string, ExportCellMeta>();
@@ -1111,13 +1120,23 @@ export function registerDataActionEndpoints(this: DataActionRouteHost, basePath:
                     }
                     return schema;
                 };
+                // [#24945] The file's language, read once for both of its halves:
+                // the header labels below are translated with THIS i18n service,
+                // which `extractLocale` also reads the request's locale from (its
+                // default locale is the last fallback), and the boolean cells are
+                // written in the words of the same locale — the pair the import
+                // template offers (`templateText`, `./import-template.ts`). One
+                // service and one locale, so the header and the cells cannot read
+                // two different languages.
+                const i18n = await this.resolveI18nService(environmentId, req).catch(() => undefined);
+                const booleanWords = templateText(this.extractLocale(req, i18n)).booleanWords;
                 try {
                     let schema: any = await readObjectSchema(objectName);
                     // Localize field labels to the request locale (Accept-Language /
                     // `?locale=`) the same way the metadata endpoints do, so the
                     // export header row matches the UI column headers instead of
                     // leaking the raw, untranslated `field.label` values.
-                    schema = await this.translateMetaItem(req, 'object', environmentId, schema);
+                    schema = await this.translateMetaItem(req, 'object', environmentId, schema, i18n);
                     if (typeof schema?.label === 'string' && schema.label.length > 0) {
                         objectLabel = schema.label;
                     }
@@ -1291,15 +1310,15 @@ export function registerDataActionEndpoints(this: DataActionRouteHost, basePath:
                     }
 
                     if (format === 'csv') {
-                        const text = rowsToCsv(fields ?? [], rows, firstChunk && includeHeader, metaMap, timezone);
+                        const text = rowsToCsv(fields ?? [], rows, firstChunk && includeHeader, metaMap, timezone, booleanWords);
                         res.write(text);
                     } else if (format === 'xlsx') {
                         if (firstChunk && includeHeader) {
                             xlsx!.ws.addRow((fields ?? []).map((f) => headerLabel(f, metaMap))).commit();
                         }
                         const cols = fields ?? [];
                         for (const row of rows) {
-                            const r = xlsx!.ws.addRow(formatRowCells(row, cols, metaMap, timezone));
+                            const r = xlsx!.ws.addRow(formatRowCells(row, cols, metaMap, timezone, booleanWords));
                             if (styled) {
                                 cols.forEach((f, i) => {
                                     const argb = cellFontColor(row?.[f], metaMap.get(f));
@@ -1320,7 +1339,7 @@ export function registerDataActionEndpoints(this: DataActionRouteHost, basePath:
                         for (let i = 0; i < rows.length; i++) {
                             const prefix = (firstChunk && i === 0) ? '' : ',';
                             const row = fieldsExplicit ? pickExportKeys(rows[i], fields!) : rows[i];
-                            res.write(prefix + JSON.stringify(formatRowForJson(row, metaMap, timezone)));
+                            res.write(prefix + JSON.stringify(formatRowForJson(row, metaMap, timezone, booleanWords)));
                         }
                     }
                     firstChunk = false;
 
@@ -32,6 +32,7 @@
 
 import { temporalStorageForm, type ExportFieldMeta } from '@objectstack/core';
 import { resolveDisplayField } from '@objectstack/spec/data';
+import { templateText, type TemplateText } from './import-template.js';
 
 // `ExportFieldMeta` and `buildFieldMetaMap` live in `@objectstack/core`
 // (`utils/import-field-meta.ts`), beside the import runner that reads them.
@@ -433,24 +434,43 @@ function formatReference(value: unknown, displayField?: string, titleField?: str
   return one(value);
 }
 
+/**
+ * The words a boolean / toggle cell is written as, `[true, false]`.
+ *
+ * [#24945] The export route resolves them once per export, as
+ * `templateText(locale).booleanWords` (`./import-template.ts`) for the locale
+ * its header row is translated to, so the header and the cells of one file read
+ * one language. That is the table the import template already offers the same
+ * words from, and the importer reads both of its languages back
+ * (`IMPORT_BOOLEAN_TRUE_TOKENS` / `IMPORT_BOOLEAN_FALSE_TOKENS`), so a file
+ * exported in either language re-imports. ⛔ No second table here.
+ */
+export type ExportBooleanWords = TemplateText['booleanWords'];
+
 /**
  * Format one storage value into a display value using its field metadata.
  *
  * `timezone` is the request's business timezone (`ExecutionContext.timezone`).
  * It reaches only the `datetime` branch; absent, the cell renders in UTC —
  * see {@link formatDate} for why `date` never reads it at all.
+ *
+ * `booleanWords` ({@link ExportBooleanWords}) reaches only the boolean /
+ * toggle branch; absent, the cell is written in the words the table answers
+ * for no locale at all.
  */
 export function formatCellValue(
   value: unknown,
   meta?: ExportCellMeta,
   timezone?: string,
+  booleanWords: ExportBooleanWords = templateText(undefined).booleanWords,
 ): unknown {
   if (value === null || value === undefined) return value;
   if (!meta || !meta.type) return value;
   const t = meta.type;
   if (t === 'boolean' || t === 'toggle') {
-    if (value === true || value === 'true' || value === 1) return '是';
-    if (value === false || value === 'false' || value === 0) return '否';
+    const [yes, no] = booleanWords;
+    if (value === true || value === 'true' || value === 1) return yes;
+    if (value === false || value === 'false' || value === 0) return no;
     return value;
   }
   if (OPTION_TYPES.has(t)) return optionLabel(value, meta.options);
@@ -467,16 +487,18 @@ export function formatCellValue(
 /**
  * Ordered display cells for one row — the CSV / XLSX column path.
  *
- * `timezone` is threaded straight through to {@link formatCellValue}; the
- * export route reads it off the `ExecutionContext` it already resolved.
+ * `timezone` and `booleanWords` are threaded straight through to
+ * {@link formatCellValue}; the export route reads the timezone off the
+ * `ExecutionContext` it already resolved, and the words off the request locale.
  */
 export function formatRowCells(
   row: Record<string, unknown>,
   fields: string[],
   metaMap: Map<string, ExportCellMeta>,
   timezone?: string,
+  booleanWords?: ExportBooleanWords,
 ): unknown[] {
-  return fields.map((f) => formatCellValue(row?.[f], metaMap.get(f), timezone));
+  return fields.map((f) => formatCellValue(row?.[f], metaMap.get(f), timezone, booleanWords));
 }
 
 /**
@@ -488,13 +510,14 @@ export function formatRowForJson(
   row: Record<string, unknown>,
   metaMap: Map<string, ExportCellMeta>,
   timezone?: string,
+  booleanWords?: ExportBooleanWords,
 ): Record<string, unknown> {
   if (metaMap.size === 0 || !row || typeof row !== 'object') return row;
   let copy: Record<string, unknown> | null = null;
   for (const key of Object.keys(row)) {
     const meta = metaMap.get(key);
     if (!meta) continue;
-    const formatted = formatCellValue(row[key], meta, timezone);
+    const formatted = formatCellValue(row[key], meta, timezone, booleanWords);
     if (formatted !== row[key]) {
       if (!copy) copy = { ...row };
       copy[key] = formatted;
 
@@ -93,6 +93,14 @@ const TASK = {
   },
 };
 
+/**
+ * [#24945] The caller these Chinese fixtures are read by. A boolean cell is
+ * written in the caller's language (`templateText(locale).booleanWords`), so a
+ * pin on `是` / `否` names a Chinese caller; a caller naming no locale gets the
+ * words `templateText(undefined)` answers (`export-boolean-locale.test.ts`).
+ */
+const ZH_CALLER = { 'accept-language': 'zh-CN' };
+
 function createMockServer() {
   const noop = () => {};
   return { get: noop, post: noop, put: noop, delete: noop, patch: noop, use: noop, listen: async () => {}, close: async () => {} };
@@ -191,7 +199,7 @@ describe('export route — real engine + protocol integration', () => {
 
   it('CSV: formats every value type readably; owner name comes from a REAL $expand', async () => {
     const { res, chunks, headers } = makeRes();
-    await route.handler({ params: { object: 'task' }, query: { format: 'csv' } } as any, res);
+    await route.handler({ params: { object: 'task' }, query: { format: 'csv' }, headers: ZH_CALLER } as any, res);
 
     expect(headers['Content-Type']).toBe('text/csv; charset=utf-8');
     const rows = parseCsv(chunks.join(''));
@@ -213,7 +221,7 @@ describe('export route — real engine + protocol integration', () => {
 
   it('XLSX: opens as a real workbook with formatted cells', async () => {
     const { res, getBuffer, headers } = makeBinRes();
-    await route.handler({ params: { object: 'task' }, query: { format: 'xlsx' } } as any, res);
+    await route.handler({ params: { object: 'task' }, query: { format: 'xlsx' }, headers: ZH_CALLER } as any, res);
 
     expect(headers['Content-Type']).toBe(
       'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
@@ -247,7 +255,7 @@ describe('export route — real engine + protocol integration', () => {
   it('XLSX: exceeding the style cap drops styling but keeps all rows', async () => {
     const { res, getBuffer, headers } = makeBinRes();
     await route.handler(
-      { params: { object: 'task' }, query: { format: 'xlsx', limit: '20000' } } as any,
+      { params: { object: 'task' }, query: { format: 'xlsx', limit: '20000' }, headers: ZH_CALLER } as any,
       res,
     );
 
@@ -263,7 +271,7 @@ describe('export route — real engine + protocol integration', () => {
 
   it('JSON: readable values, all rows present', async () => {
     const { res, chunks, headers } = makeRes();
-    await route.handler({ params: { object: 'task' }, query: { format: 'json' } } as any, res);
+    await route.handler({ params: { object: 'task' }, query: { format: 'json' }, headers: ZH_CALLER } as any, res);
 
     expect(headers['Content-Type']).toBe('application/json; charset=utf-8');
     const arr = JSON.parse(chunks.join(''));
@@ -276,6 +284,7 @@ describe('export route — real engine + protocol integration', () => {
     await route.handler({
       params: { object: 'task' },
       query: { format: 'csv', filter: JSON.stringify({ done: true }), orderby: 'id:desc' },
+      headers: ZH_CALLER,
     } as any, res);
 
     const dataRows = parseCsv(chunks.join('')).slice(1);
 
@@ -49,7 +49,9 @@ afterEach(async () => {
 /**
  * `title` is the name field, so the companion's real producer declares
  * `__search` on this object (and the read strips its value). `done` is a
- * boolean, so a projected value is visibly formatted (`是` / `否`).
+ * boolean, so a projected value is visibly formatted (`yes` / `no`: the
+ * requests name no locale, so the cells take the words `templateText(undefined)`
+ * answers, #24945).
  */
 const NOTE = provisionSearchCompanion({
   name: 'note',
@@ -161,8 +163,8 @@ describe('format=json honours an explicit ?fields= (#24183)', () => {
       ['done', 'internal_code', 'title', 'id'],
       ['done', 'internal_code', 'title', 'id'],
     ]);
-    expect(rows[0]).toEqual({ done: '是', internal_code: 'IC-1', title: 'Note 1', id: '1' });
-    expect(rows[1]).toEqual({ done: '否', internal_code: 'IC-2', title: 'Note 2', id: '2' });
+    expect(rows[0]).toEqual({ done: 'yes', internal_code: 'IC-1', title: 'Note 1', id: '1' });
+    expect(rows[1]).toEqual({ done: 'no', internal_code: 'IC-2', title: 'Note 2', id: '2' });
   });
 
   it('JSON: a named key the read did not return is absent, never invented as null (the stripped companion)', async () => {
 
@@ -777,7 +777,10 @@ async function exportOnce(query: Record<string, string>, security?: Record<strin
   try {
     const { route, findData } = await bootExportFixture(security);
     const out = makeRes();
-    await route.handler({ params: { object: 'task' }, query } as any, out.res);
+    // [#24945] A Chinese caller: a boolean cell follows the caller's language
+    // now, and the recorded bytes below are this Chinese fixture's `是` / `否`
+    // file — the bytes every caller got before, and a zh-CN caller still gets.
+    await route.handler({ params: { object: 'task' }, query, headers: { 'accept-language': 'zh-CN' } } as any, out.res);
     return { ...out, findData };
   } finally {
     vi.useRealTimers();
 
@@ -72,7 +72,10 @@ import {
   isMultiValueField,
 } from '@objectstack/spec/data';
 import type { ISecurityService, SecurityContext } from '@objectstack/spec/contracts';
-import { buildFieldMetaMap, type ExportFieldMeta } from './export-format.js';
+// From core, where they live, not through `./export-format.js`'s re-export:
+// that module reads `templateText` from here (#24945), and the two modules do
+// not import each other.
+import { buildFieldMetaMap, type ExportFieldMeta } from '@objectstack/core';
 import { loadExcelJs, type Workbook, type Worksheet } from './xlsx-module.js';
 
 // ── the column rule ─────────────────────────────────────────────────
 
@@ -285,6 +285,7 @@ import {
     headerLabel,
     formatRowCells,
     exportContentDisposition,
+    type ExportBooleanWords,
     type ExportFieldMeta,
 } from './export-format.js';
 // [#23050 slice 1] The data-action routes' body moved to its own module — see its header.
@@ -1142,23 +1143,27 @@ function formatCsvCell(value: any): string {
  * Serialise a list of rows to RFC-4180 CSV text. Caller supplies the ordered
  * list of field names and a (possibly empty) field-metadata map. With metadata,
  * the header row uses field labels and cell values are formatted to readable
- * display values (lookup names, select labels, 是/否, formatted dates). With an
- * empty map the output is byte-identical to the raw, un-formatted behaviour.
+ * display values (lookup names, select labels, yes / no words, formatted
+ * dates). With an empty map the output is byte-identical to the raw,
+ * un-formatted behaviour.
  *
  * `timezone` (#8373) is the caller's business timezone, used to render
  * `datetime` cells in the same clock the UI shows; absent, they render in UTC.
+ * `booleanWords` (#24945) are the words of the caller's language that a boolean
+ * cell is written as (`ExportBooleanWords` in `./export-format.ts`).
  */
 export function rowsToCsv(
     fields: string[],
     rows: Array<Record<string, any>>,
     includeHeader: boolean,
     metaMap: Map<string, ExportFieldMeta>,
     timezone?: string,
+    booleanWords?: ExportBooleanWords,
 ): string {
     const lines: string[] = [];
     if (includeHeader) lines.push(fields.map(f => formatCsvCell(headerLabel(f, metaMap))).join(','));
     for (const row of rows) {
-        lines.push(formatRowCells(row, fields, metaMap, timezone).map(formatCsvCell).join(','));
+        lines.push(formatRowCells(row, fields, metaMap, timezone, booleanWords).map(formatCsvCell).join(','));
     }
     return lines.join('\r\n') + (lines.length > 0 ? '\r\n' : '');
 }
@@ -5528,6 +5533,8 @@ export class RestServer {
             translateMetaItem: (...a) => this.translateMetaItem(...a),
             resolveMessageTranslator: (...a) => this.resolveMessageTranslator(...a),
             resolveSecurityService: (...a) => this.resolveSecurityService(...a),
+            resolveI18nService: (...a) => this.resolveI18nService(...a),
+            extractLocale: (...a) => this.extractLocale(...a),
             answerImportTemplate: (...a) => this.answerImportTemplate(...a),
         };
         registerDataActionEndpoints.call(host, basePath);