@@ -0,0 +1,16 @@
+---
+'@objectstack/formula': minor
+'@objectstack/objectql': minor
+---
+
+feat(formula): `label(record.<field>)` reads a select field's option label in the reader's locale, so a record name composed in a formula renders `v2 · 清稿` to a zh-CN reader and `v2 · Clean` to an en-US one (#26608)
+
+Clause-②: yes (widening)
+Metadata-protocol: added
+
+A select field stores its option's value, so a formula `nameField` such as `'v' + string(record.version_no) + ' · ' + record.kind` printed `v2 · clean` to every reader. Wrap the field in `label()` and the name prints the label the select control shows that reader.
+
+- **The function (`@objectstack/formula`).** `label(record.<field>)` is a new CEL stdlib function, advertised in `CEL_STDLIB_FUNCTIONS`. It takes exactly `record.<field>`; any other argument is refused when the expression compiles. It reads only data: the new `EvalContext.optionLabels` (field → stored value → label, type `EvalOptionLabels`), which the caller resolves in the reader's locale before evaluating. An empty value reads `''`; a value no option declares reads as itself; a field with no options, a multi-value select, and an evaluation whose context carries no `optionLabels` fail loudly.
+- **Where it answers (`@objectstack/objectql`).** The engine pins the map for every read and write it serves formula fields on: `find`, `findOne`, and the insert and update responses. The labels are the object's declared `options` with the i18n service's bundle laid over them by `translateObject`, the function `GET /meta/object/:name` serves the object with, in `ExecutionContext.locale` (the request's `Accept-Language`). The field-level key `objects.<object>.fields.<field>.options.<value>` wins over a shared picklist's `picklists.<picklist>.options.<value>`, and both over the declared label. No new keys and no new bundle. A read with no locale, an engine with no i18n service, and an i18n service that throws all read the declared labels.
+- **Stored values.** A stored computed field (a non-formula field with an `expression`) is computed once, on the write, so it stores the declared label whatever the writer's locale. Search never indexes formula fields, so what search indexes is unchanged.
+- **`setI18nService`** accepts the optional `getTranslations`, `getFallbackLocale` and `getDefaultLocale` the engine now reads. An `II18nService` already carries all three.
@@ -196,6 +196,7 @@ All functions are pure given a pinned `now`, which is what makes
 | `abs(x)` / `round(x)` | number | Numeric helpers |
 | `floor(x)` / `ceil(x)` | number | Round toward −∞ / +∞ (`floor(-1.2) == -2`) — **not** integer-division's round-toward-zero |
 | `min(a, b)` / `max(a, b)` | dyn | Smaller / larger operand (numeric comparison) |
+| `label(record.f)` | string | A select field's option label in the reader's locale — see [Record name from an option label](#record-name-from-an-option-label) |
 
 Add new helpers in
 [`packages/formula/src/stdlib.ts`](https://github.com/objectstack-ai/objectstack/blob/main/packages/formula/src/stdlib.ts).
@@ -265,6 +266,40 @@ type-soundness check applies.
 Building the string by hand with `+` would also work, but CEL throws on
 `null + string`, so each nullable operand must be wrapped in `coalesce(..., '')`.
 
+### Record name from an option label
+
+A select field stores its option's **value** (`clean`), not its label. To put
+the label a reader reads into a composed name, wrap the field in `label()`:
+
+```ts
+{
+  name: 'display_name',            // the object's nameField
+  type: 'formula',
+  expression: F`'v' + string(record.version_no) + ' · ' + label(record.kind)`,
+}
+```
+
+The same record reads `v2 · 清稿` to a reader whose locale is `zh-CN` and
+`v2 · Clean` to an `en-US` reader. The label is the one the select control
+shows that reader: the field's declared option label, with the object's
+translation bundle laid over it (`objects.<object>.fields.<field>.options.<value>`,
+then a shared picklist's `picklists.<picklist>.options.<value>`), exactly as
+`GET /meta/object/:name` serves it. The locale is the request's
+`Accept-Language`, so the write response the save toast reads, the record
+page title, related lists and lookups all follow it.
+
+- `label()` takes exactly `record.<field>`, a field that declares `options`.
+  An empty value reads `''`; a stored value no option declares reads as itself.
+  A multi-value select is refused.
+- A read with no locale (a script, a scheduled job) reads the declared labels.
+- A **stored** computed field (a `text` field with an `expression`) is computed
+  once, on the write, so it stores the declared label whatever the writer's
+  locale. Search never indexes a formula field, so it is unaffected.
+- `label()` answers only where the engine serves formula fields. A validation
+  rule, predicate or flow condition that calls it fails loudly instead of
+  comparing against a label; compare the stored value there
+  (`record.kind == 'clean'`).
+
 ### Conditional formula
 
 ```ts
 
@@ -511,13 +511,15 @@ describe('celEngine', () => {
         isBlank: 'isBlank("")', isEmpty: 'isEmpty([])', coalesce: 'coalesce(null, "x")', len: 'len("ab")',
         size: 'size([1, 2])', has: 'has(record.a)', int: 'int("3")', string: 'string(3)',
         bool: 'bool("true")', double: 'double("3.5")', timestamp: 'timestamp("2026-01-01T00:00:00Z")',
-        duration: 'duration("3600s")',
+        duration: 'duration("3600s")', label: 'label(record.a)',
       };
       const unresolved: string[] = [];
       for (const fn of CEL_STDLIB_FUNCTIONS) {
         const src = call[fn];
         expect(src, `no probe call defined for advertised function \`${fn}\``).toBeTruthy();
-        const r = celEngine.evaluate(cel(src), { now, record: { a: 1 } });
+        // `optionLabels` is the data `label()` answers from (#26608); the other
+        // probes read nothing from it.
+        const r = celEngine.evaluate(cel(src), { now, record: { a: 1 }, optionLabels: { a: { 1: 'One' } } });
         if (!r.ok) unresolved.push(`${fn}: ${r.error.message.split('\n')[0]}`);
       }
       expect(unresolved, `advertised functions that fault at runtime:\n${unresolved.join('\n')}`).toEqual([]);
 
@@ -82,7 +82,8 @@ export function buildEnv(
 /**
  * The one constructor behind {@link buildEnv} and the shared evaluation
  * environment: the same options and the same registrations, with the stdlib
- * reading its `now`, timezone and permission binding through `read`.
+ * reading its `now`, timezone, permission binding and option labels through
+ * `read`.
  */
 function buildEnvReading(read: () => StdLibBinding): Environment {
   const env = new Environment(CEL_ENV_OPTIONS);
@@ -121,8 +122,8 @@ let activeBinding: StdLibBinding = UNBOUND;
  * state: each evaluation gets its own `RootContext`, the parser resets its
  * input and limit counters at the start of every parse, and what the registry
  * caches (type declarations, overload resolution) is keyed on types, never on
- * values. What did vary per evaluation, the stdlib's `now`, timezone and
- * permission binding, is read from {@link activeBinding}.
+ * values. What did vary per evaluation, the stdlib's `now`, timezone,
+ * permission binding and option labels, is read from {@link activeBinding}.
  */
 let evaluationEnv: Environment | undefined;
 
@@ -2046,6 +2047,7 @@ export const celEngine: DialectEngine = {
           permissions: ctx.permissions,
           systemPermissions: ctx.systemPermissions,
         },
+        optionLabels: ctx.optionLabels,
       };
       try {
         // #3183 — coerce a date-field operand compared with `==`/`!=` against a
 
@@ -170,4 +170,4 @@ export type {
   ExpressionSourceKind,
 } from './expression-refusal';
 export type { SeedValue, SeedPrimitive } from './seed-eval';
-export type { DialectEngine, EvalContext, EvalResult, EvalError, EvalPermissions, EvalSystemPermissions } from './types';
+export type { DialectEngine, EvalContext, EvalResult, EvalError, EvalPermissions, EvalSystemPermissions, EvalOptionLabels } from './types';
@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'vitest';
+
+import { celEngine } from './cel-engine';
+import { inferExpressionType } from './validate';
+import type { EvalOptionLabels } from './types';
+import type { Expression } from '@objectstack/spec';
+
+/**
+ * `label(record.<field>)` — a select field's stored value as the label its
+ * reader reads (#26608). The record name a formula composes out of option
+ * values (`v2 · clean`) renders in the reader's locale (`v2 · 清稿`).
+ *
+ * The labels are DATA the caller pinned (`EvalContext.optionLabels`), resolved
+ * in the reader's locale before evaluation; these tests hand the two maps a
+ * zh-CN and an en-US reader receive and pin what each reads.
+ */
+
+const cel = (source: string): Expression => ({ dialect: 'cel', source });
+
+const NAME = "'v' + string(record.version_no) + ' · ' + label(record.kind)";
+
+const zhCN: EvalOptionLabels = { kind: { clean: '清稿', redline: '修订稿' }, stage: { draft: '草稿' } };
+const enUS: EvalOptionLabels = { kind: { clean: 'Clean', redline: 'Redline' }, stage: { draft: 'Draft' } };
+
+const record = { version_no: 2, kind: 'clean', stage: 'draft', title: 'Master agreement', tags: ['a'] };
+
+describe('label(record.<field>) — option labels in the reader\'s locale (#26608)', () => {
+  it('composes a record name in zh-CN and in en-US from the same stored value', () => {
+    expect(celEngine.evaluate(cel(NAME), { record, optionLabels: zhCN })).toEqual({ ok: true, value: 'v2 · 清稿' });
+    expect(celEngine.evaluate(cel(NAME), { record, optionLabels: enUS })).toEqual({ ok: true, value: 'v2 · Clean' });
+  });
+
+  it('reads each field\'s own options — the field name picks the map, not the value', () => {
+    const r = celEngine.evaluate(cel("label(record.kind) + ' / ' + label(record.stage)"), {
+      record,
+      optionLabels: zhCN,
+    });
+    expect(r).toEqual({ ok: true, value: '清稿 / 草稿' });
+  });
+
+  it('answers \'\' for an empty select, so a composed name still evaluates', () => {
+    const r = celEngine.evaluate(cel(NAME), { record: { ...record, kind: null }, optionLabels: zhCN });
+    expect(r).toEqual({ ok: true, value: 'v2 · ' });
+  });
+
+  it('shows a stored value no option declares as itself, as the select control does', () => {
+    const r = celEngine.evaluate(cel('label(record.kind)'), { record: { kind: 'retired' }, optionLabels: zhCN });
+    expect(r).toEqual({ ok: true, value: 'retired' });
+  });
+
+  it('refuses at run time when the context carries no option labels — never the stored value', () => {
+    const r = celEngine.evaluate(cel(NAME), { record });
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.error.kind).toBe('runtime');
+      expect(r.error.message).toContain('label(record.kind) cannot be answered');
+      expect(r.error.message).toContain('optionLabels');
+    }
+  });
+
+  it('refuses a field that declares no options, on every row, and a list value', () => {
+    const plain = celEngine.evaluate(cel('label(record.title)'), { record, optionLabels: zhCN });
+    expect(plain.ok).toBe(false);
+    if (!plain.ok) {
+      expect(plain.error.kind).toBe('runtime');
+      expect(plain.error.message).toContain('`title` declares no options');
+    }
+    // …on every row: an empty value does not hide that the field has no options.
+    const empty = celEngine.evaluate(cel('label(record.title)'), { record: { ...record, title: null }, optionLabels: zhCN });
+    expect(empty.ok).toBe(false);
+    if (!empty.ok) expect(empty.error.message).toContain('`title` declares no options');
+    const list = celEngine.evaluate(cel('label(record.tags)'), {
+      record,
+      optionLabels: { ...zhCN, tags: { a: 'A' } },
+    });
+    expect(list.ok).toBe(false);
+    if (!list.ok) expect(list.error.message).toContain('renders ONE option value');
+  });
+
+  it('compiles the one argument shape and refuses every other at the type check', () => {
+    expect(celEngine.compile(NAME).ok).toBe(true);
+    for (const source of [
+      "label('clean')",
+      'label(record.account.type)',
+      'label(record.?kind)',
+      'label(previous.kind)',
+      "label(record.kind + '')",
+    ]) {
+      const r = celEngine.compile(source);
+      expect(r.ok, source).toBe(false);
+      if (!r.ok) {
+        expect(r.error.kind, source).toBe('type');
+        expect(r.error.message, source).toContain('label(record.<field>)');
+      }
+    }
+  });
+
+  it('types as text, so a formula built on it is a text formula', () => {
+    expect(inferExpressionType(NAME)).toBe('text');
+    expect(inferExpressionType('label(record.kind)')).toBe('text');
+  });
+});