@@ -1,4 +1,5 @@
 ---
+'@object-ui/core': patch
 '@object-ui/i18n': patch
 '@object-ui/fields': patch
 '@object-ui/components': patch
@@ -23,6 +24,7 @@ An amount declaring `currencyConfig: { currencyMode: 'record', currencyField: 'c
 - **Filters.** In the list's filter builder, a condition on a `record`-mode amount gains a required currency picker, defaulting to the organization currency, and the filter reads `amount op X AND code = C`: the code condition is a second row of the same group, so stored filters keep their shape. A group holding such a pair stays on AND (under OR the pair would split), and a stored OR group says so. Presence checks (`is null`, `is empty`, …) need no currency.
 - **Create forms.** A code field that a `record`-mode amount points at opens pre-filled with `localization.currency`, as a value the user submits; a declared `defaultValue` and the caller's record win, and nothing is seeded while the setting is unset.
 - **Totals.** The grid footer draws no sum, average, minimum or maximum for a `record`-mode amount (its rows are in different currencies); counts stand. A group header keeps those aggregates only when the grid is grouped by the amount's code field. Consolidated totals belong to the home field, a `dynamic` amount that totals as before.
+- **Dataset answers.** A grouped analytics answer over a `record`-mode amount marks its measure column with `currencyField`, the result column holding each row's code. The dashboard `table` widget and the Studio dataset preview format each row in that row's currency; a row without a code, and the totals row, show a plain number. `measureCellCurrency(field, row)` in `@object-ui/core` is the one read. Columns without `currencyField` format exactly as before.
 - **Studio.** A currency field (or a formula returning `currency`) gains a currency section: the mode (dynamic, fixed, record), the fixed code, and under `record` a `currencyField` picker listing the object's ISO 4217 code fields, with "Create currency field", which adds `currency_code` (`text`, `valueDomain: 'iso_4217_currency'`, required) and points the amount at it.
 
 ⛔ Not released alone: this ships in the same release as `currencyMode: 'record'` itself and its aggregate refusals.
@@ -147,6 +147,25 @@ describe('DatasetPreview follows the display locale (objectui#4575)', () => {
     ).toBeInTheDocument();
   });
 
+  it('formats a record-mode column in each row\'s own currency (objectstack#27188, ADR-0144 D9)', async () => {
+    // A grouped answer over a `record`-mode amount: the measure column names
+    // the result column holding each row's code (objectstack#27338).
+    queryDataset.mockResolvedValue({
+      rows: [
+        { bucket: 1, currency_code: 'USD', revenue: 1234.5 },
+        { bucket: 2, currency_code: 'EUR', revenue: 99 },
+      ],
+      fields: [
+        { name: 'bucket', type: 'number', label: 'Bucket' },
+        { name: 'currency_code', type: 'text', label: 'Currency' },
+        { name: 'revenue', type: 'number', label: 'Revenue', format: '0.00', currencyField: 'currency_code' },
+      ],
+    });
+    renderIn('en-US', <DatasetPreview {...baseProps} draft={draft} />);
+    expect(await screen.findByText('$1,234.50', { normalizer: (t: string) => t.trim() })).toBeInTheDocument();
+    expect(screen.getByText('€99.00', { normalizer: (t: string) => t.trim() })).toBeInTheDocument();
+  });
+
   it('keeps the en currency form byte-identical (must-not-change)', async () => {
     queryDataset.mockResolvedValue({
       rows: [{ bucket: 1, revenue: 1234.5 }],
 
@@ -23,6 +23,7 @@ import type { MetadataPreviewProps } from '../preview-registry.js';
 import { PreviewShell, PreviewEmptyState, PreviewErrorBoundary } from './PreviewShell.js';
 import {
   formatMeasure,
+  measureCellCurrency,
   formatDimensionValue,
   buildDatasetFieldHelpers,
   relabelDimensions,
@@ -308,7 +309,7 @@ export function DatasetPreview({ draft, locale }: MetadataPreviewProps) {
                     {columns.map((c) => (
                       <td key={c} className="px-2 py-1 tabular-nums whitespace-nowrap">
                         {measureNames.includes(c)
-                          ? formatMeasure(row[c], measureField(c)?.format, measureField(c)?.currency, measureField(c)?.percentScale, displayLocale)
+                          ? formatMeasure(row[c], measureField(c)?.format, measureCellCurrency(measureField(c), state.rows[i]), measureField(c)?.percentScale, displayLocale)
                           : formatDimensionValue(row[c], displayLocale)}
                       </td>
                     ))}
 
@@ -0,0 +1,37 @@
+/**
+ * objectstack#27188 — a grouped answer over a `record`-mode amount marks its
+ * measure column with `currencyField` (objectstack#27338), and each CELL takes
+ * the currency of its own row (ADR-0144 D9). A column without the marker keeps
+ * its declared `currency`, unchanged.
+ */
+import { describe, it, expect } from 'vitest';
+import { formatMeasure, measureCellCurrency, type DatasetResultField } from '../dataset-format';
+
+const RECORD_COLUMN = { name: 'amount_sum', type: 'number', currencyField: 'currency_code' } as unknown as DatasetResultField;
+const FIXED_COLUMN = { name: 'amount_sum', type: 'number', currency: 'EUR' } as unknown as DatasetResultField;
+
+describe('measureCellCurrency', () => {
+  it('reads each row\'s code from the column `currencyField` names', () => {
+    expect(measureCellCurrency(RECORD_COLUMN, { currency_code: 'USD', amount_sum: 10 })).toBe('USD');
+    expect(measureCellCurrency(RECORD_COLUMN, { currency_code: 'JPY', amount_sum: 10 })).toBe('JPY');
+  });
+
+  it('gives no symbol to a row without a code, nor to a cell with no row of its own', () => {
+    expect(measureCellCurrency(RECORD_COLUMN, { currency_code: null })).toBeUndefined();
+    expect(measureCellCurrency(RECORD_COLUMN, { currency_code: '' })).toBeUndefined();
+    expect(measureCellCurrency(RECORD_COLUMN)).toBeUndefined();
+  });
+
+  it('keeps a column\'s declared currency when it carries no currencyField', () => {
+    expect(measureCellCurrency(FIXED_COLUMN, { currency_code: 'USD' })).toBe('EUR');
+    expect(measureCellCurrency(undefined, { currency_code: 'USD' })).toBeUndefined();
+  });
+
+  it('formats two rows of one column in their two currencies', () => {
+    const cell = (row: Record<string, unknown>) =>
+      formatMeasure(row.amount_sum, '0.00', measureCellCurrency(RECORD_COLUMN, row), undefined, 'en-US');
+    expect(cell({ currency_code: 'USD', amount_sum: 1234.5 })).toBe('$1,234.50');
+    expect(cell({ currency_code: 'EUR', amount_sum: 1234.5 })).toBe('€1,234.50');
+    expect(cell({ currency_code: null, amount_sum: 1234.5 })).toBe('1,234.50');
+  });
+});
@@ -487,6 +487,32 @@ export function formatMeasure(
  * reproduces the previous machine-locale output byte for byte. Integers stay
  * verbatim here for the same measured reason as there.
  */
+/**
+ * The currency one measure CELL displays in.
+ *
+ * A column the answer marks with `currencyField` — a grouped answer over a
+ * `record`-mode amount (ADR-0144 D9) — has no currency of its own: each row's
+ * is the code in the result column `currencyField` names. So `row` is the RAW
+ * row (before `relabelDimensions`), and a row with no code there renders a plain
+ * number, never another row's symbol nor a column-wide one. Every other column
+ * keeps its declared `currency`, byte for byte.
+ *
+ * A cell with no row of its own (a total, a cross-tab cell) passes none and so
+ * gets no symbol on such a column: it may add amounts in several currencies.
+ *
+ * `currencyField` is read structurally: it is objectstack#27338's addition to
+ * `AnalyticsResult.fields[]`, which the spec type here does not carry yet.
+ */
+export function measureCellCurrency(
+  field: DatasetResultField | undefined,
+  row?: Readonly<Record<string, unknown>>,
+): string | undefined {
+  const codeColumn = (field as { currencyField?: unknown } | undefined)?.currencyField;
+  if (typeof codeColumn !== 'string' || codeColumn === '') return field?.currency;
+  const code = row?.[codeColumn];
+  return typeof code === 'string' && code !== '' ? code : undefined;
+}
+
 export function formatDimensionValue(v: unknown, locale?: string): string {
   if (v == null) return '—';
   if (typeof v === 'number') {
 
@@ -52,6 +52,7 @@ import {
   dimensionOptionTranslator,
   findChartSeriesRow,
   formatMeasure,
+  measureCellCurrency,
   formatDimensionValue,
   buildDatasetFieldHelpers,
   buildDatasetDrillFilter,
@@ -1902,7 +1903,7 @@ export function DatasetWidget({ widget, dataSource, heading, onForbidden }: {
                   return (
                     <td key={c} className={cn('px-2 py-1 whitespace-nowrap tabular-nums', numericColumns.has(c) && 'text-right')}>
                       {measure
-                        ? formatMeasure(row[c], measureField(measure)?.format, measureField(measure)?.currency, measureField(measure)?.percentScale, displayLocale)
+                        ? formatMeasure(row[c], measureField(measure)?.format, measureCellCurrency(measureField(measure), state.rows[index]), measureField(measure)?.percentScale, displayLocale)
                         : formatDimensionValue(row[c], displayLocale)}
                     </td>
                   );
 
@@ -0,0 +1,57 @@
+/**
+ * objectstack#27188 — a dashboard `table` over a grouped `record`-mode answer
+ * shows each row's amount in that row's own currency (ADR-0144 D9). The
+ * measure column names the result column holding the code (`currencyField`,
+ * objectstack#27338); the grand-total cell, which may add several currencies,
+ * gets no symbol.
+ */
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, cleanup, waitFor } from '@testing-library/react';
+import { DatasetWidget } from '../DatasetWidget';
+
+vi.mock('../DrillDownDrawer', () => ({ DrillDownDrawer: () => null }));
+
+/** Plain TEXT dimension field, no `options` — nothing here relabels. */
+const OPPORTUNITY = { name: 'opportunity', fields: { currency_code: { type: 'text' } } };
+
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+const source = () => ({
+  queryDataset: vi.fn(async () => ({
+    rows: [
+      { currency_code: 'USD', amount_sum: 1234.5 },
+      { currency_code: 'EUR', amount_sum: 99 },
+      { currency_code: null, amount_sum: 7 },
+    ],
+    fields: [
+      { name: 'currency_code', type: 'text', label: 'Currency' },
+      { name: 'amount_sum', type: 'number', label: 'Amount', format: '0.00', currencyField: 'currency_code' },
+    ],
+    totals: [{ dimensions: [] as string[], rows: [{ amount_sum: 1340.5 }] }],
+  })),
+});
+
+const TABLE_WIDGET = { type: 'table', dataset: 'amount_by_currency', dimensions: ['currency_code'], values: ['amount_sum'] };
+
+const amountColumn = () =>
+  Array.from(document.querySelectorAll('tbody tr')).map((r) => r.querySelectorAll('td')[1]?.textContent?.trim() ?? '');
+
+describe('DatasetWidget table — record-mode amounts (ADR-0144 D9)', () => {
+  it('formats each row in its own currency, and a row without a code as a plain number', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => ({ ok: true, json: async () => ({ item: OPPORTUNITY }) })));
+    render(<DatasetWidget widget={TABLE_WIDGET} dataSource={source()} />);
+    await screen.findByText('Amount');
+    await waitFor(() => expect(amountColumn()).toEqual(['$1,234.50', '€99.00', '7.00']));
+  });
+
+  it('gives the grand total no symbol', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => ({ ok: true, json: async () => ({ item: OPPORTUNITY }) })));
+    render(<DatasetWidget widget={TABLE_WIDGET} dataSource={source()} />);
+    const foot = await screen.findByTestId('dataset-table-total-row');
+    expect(foot.querySelectorAll('td')[1]?.textContent?.trim()).toBe('1,340.50');
+  });
+});