@@ -0,0 +1,17 @@
+---
+'@object-ui/plugin-gantt': patch
+---
+
+fix(plugin-gantt): a number row in the gantt tooltip shows the field's declared decimals, and none when it declares none
+
+A tooltip row over a `number` field (and the `integer`, `float` and `decimal`
+spellings the tooltip groups with it) always read two decimals, whatever the field
+declared. A field declaring `scale: 3` read `1.50`, a field declaring `scale: 0` read
+`1.50`, and a `number` with no `scale` read `1.50` while the list cell for the same
+value read `1.5`. The row now reads the field's width through `resolveFieldScale`
+from `@objectstack/spec/data`, as the list cell does. A declared `scale` is that
+width. A field with no `scale` shows the value as stored (`1.5`, `12`, `7`), because
+the protocol gives these types no default width.
+
+Only the decimals change. The row still uses the display locale, and it still groups
+thousands as before.
@@ -0,0 +1,16 @@
+---
+'@object-ui/fields': patch
+---
+
+fix(fields): the number cell ignores a malformed `scale` instead of flooring it or crashing
+
+`NumberCellRenderer` took any JavaScript number in `scale` as the decimal width. A
+non-integer `scale: 1.5` rendered `3.14159` as `3.1`, a width nobody declared. A
+negative `scale: -1` made the cell throw a `RangeError`, which took the row down. The
+cell now reads the width through `resolveFieldScale` from `@objectstack/spec/data`,
+the function the percent cell, the detail view and the grid footer already use. A
+malformed declaration counts as no declaration, so the value shows as stored.
+
+A well-formed `scale`, or no `scale` at all, renders exactly as before. The grouping
+rule is unchanged too: a declared `scale: 0` (a year, for example) still renders
+without thousands separators, and a field with no `scale` still groups.
@@ -0,0 +1,79 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectui#11254 — `NumberCellRenderer` reads its width through
+ * `resolveFieldScale`, a carrier of ruling A′ (objectstack-ai/objectstack#19628),
+ * instead of `typeof scale === 'number'`.
+ *
+ * The two reads agree for every WELL-FORMED declaration and for an absent one.
+ * They part only on a malformed declaration that is still a JS number — the
+ * resolver's door is `Number.isInteger(scale) && scale >= 0`, the one
+ * `objectql`'s record validator applies, and anything else is "no declaration":
+ *   - `scale: 1.5` — `Intl` floored it to one place, so `3.14159` read `3.1`, a
+ *     width nobody declared, while the grid footer (already on the resolver)
+ *     read the same column at its natural precision;
+ *   - `scale: -1` — `Intl` refused it, so the cell threw a `RangeError` and
+ *     took its row down.
+ * A string `scale: "2"` was already no declaration on both reads (a control).
+ *
+ * The resolved value also feeds the grouping POLICY (objectui#4033) the way
+ * the raw one did: a declared `scale: 0` is an ordinal and renders ungrouped,
+ * an absent one keeps grouping.
+ *
+ * ── Directions on the base tree (predicted before the first run) ──────────
+ *   `scale: 1.5`                 RED   (`3.1` before)
+ *   `scale: -1`                  RED   (RangeError before)
+ *   `scale: "2"`                 GREEN (no declaration on both reads)
+ *   `scale: 2` / absent          GREEN
+ *   `scale: 0` year / absent year GREEN (ungrouped / grouped)
+ */
+
+import { describe, it, expect } from 'vitest';
+import React from 'react';
+import { render } from '@testing-library/react';
+import { LocalizationProvider } from '@object-ui/i18n';
+import { NumberCellRenderer } from '../index';
+
+const cellText = (value: unknown, field: Record<string, unknown> = {}): string => {
+  const { container, unmount } = render(
+    <LocalizationProvider value={{ locale: 'en' }}>
+      <NumberCellRenderer value={value as any} field={{ type: 'number', ...field } as any} />
+    </LocalizationProvider>,
+  );
+  const text = container.textContent ?? '';
+  unmount();
+  return text;
+};
+
+describe('NumberCellRenderer reads the resolved width (objectui#11254)', () => {
+  it('a non-integer `scale: 1.5` is no declaration: natural precision, not a floored width', () => {
+    expect(cellText(3.14159, { scale: 1.5 })).toBe('3.14159');
+  });
+
+  it('a negative `scale: -1` is no declaration: the cell renders instead of throwing', () => {
+    expect(cellText(3.14159, { scale: -1 })).toBe('3.14159');
+  });
+
+  it('a string `scale: "2"` is no declaration (control)', () => {
+    expect(cellText(3.14159, { scale: '2' })).toBe('3.14159');
+  });
+
+  it('a declared `scale: 2` is that width (control)', () => {
+    expect(cellText(3.14159, { scale: 2 })).toBe('3.14');
+  });
+
+  it('an absent `scale` has no fixed width (control)', () => {
+    expect(cellText(3.14159)).toBe('3.14159');
+  });
+
+  it('a declared `scale: 0` still renders ungrouped, an absent one still groups (objectui#4033)', () => {
+    expect(cellText(2026, { scale: 0 })).toBe('2026');
+    expect(cellText(2026)).toBe('2,026');
+  });
+});
@@ -784,7 +784,20 @@ export function NumberCellRenderer({ value, field }: CellRendererProps): React.R
   //
   // No clamp: the objectui#10071 one retired at the objectui#9808 SUNSET
   // (objectui#11073) — `@objectstack/spec` 17.5.0 refuses a `scale` above 100.
-  const scale = typeof numField.scale === 'number' ? numField.scale : undefined;
+  //
+  // objectui#11254 — the width is read through `resolveFieldScale` (ruling A′
+  // on objectstack-ai/objectstack#19628), the function the percent cell, the
+  // detail chip, the grid footer and the gantt tooltip ask. For `number` the
+  // protocol has no absent-`scale` row, so an undeclared field answers
+  // `undefined`, no fixed width, exactly as before. The read changed only for a
+  // malformed declaration that is still a JS number: `typeof === 'number'`
+  // let `1.5` through for `Intl` to floor to one place (a width nobody
+  // declared) and `-1` through for `Intl` to throw on, taking the row down.
+  // The resolver's door is the record validator's own (`Number.isInteger` and
+  // `>= 0`), and it answers "no declaration" for both. The resolved value feeds
+  // the grouping policy exactly as the raw one did: a declared `0` stays `0`.
+  // ⛔ No `?? N` beside this call: `undefined` is the protocol's answer.
+  const scale = resolveFieldScale({ type: numField.type, scale: numField.scale });
   // The author's digit-grouping hint (objectui#11026): `FieldSchema.useGrouping`,
   // declared on `NumberFieldMetadata`, so it is read off the typed `field` and
   // not through `numField`. An authored boolean overrides the `scale` heuristic
@@ -796,13 +809,17 @@ export function NumberCellRenderer({ value, field }: CellRendererProps): React.R
       ? field.useGrouping
       : undefined;
   const num = Number(safe);
+  // Two arms, spelled out: a resolved width is fixed at both bounds; no width
+  // is the value's natural precision (the minimum 0 / maximum 20 described
+  // above), which is not a width of its own.
   const formatted = !isNaN(num)
     ? formatDisplayNumber(num, {
         locale,
         scale,
         useGrouping,
-        minimumFractionDigits: scale ?? 0,
-        maximumFractionDigits: scale ?? 20,
+        ...(scale === undefined
+          ? { minimumFractionDigits: 0, maximumFractionDigits: 20 }
+          : { minimumFractionDigits: scale, maximumFractionDigits: scale }),
       })
     : String(safe);
 
 
@@ -154,7 +154,14 @@ const OBJECT_SCHEMA = {
     name: { type: 'text' },
     start_date: { type: 'date' },
     end_date: { type: 'date' },
-    qty: { type: 'number', label: 'Qty' },
+    // `scale: 2` is DECLARED since objectui#11254. This file measures the
+    // locale, not the width: before, the row padded every number to two places
+    // whatever it declared, and these expectations rode on that constant. Under
+    // ruling A′ (objectstack-ai/objectstack#19628) an undeclared `number` has
+    // no fixed width, so the two places are now the field's own, and every
+    // expectation below keeps its bytes. The width itself is pinned in
+    // `ObjectGantt.numberResolvedWidth-11254.test.tsx`.
+    qty: { type: 'number', label: 'Qty', scale: 2 },
     amount: { type: 'currency', label: 'Amount', currency: 'EUR' },
     ratio: { type: 'percent', label: 'Ratio' },
     due_date: { type: 'date', label: 'Due' },
 
@@ -0,0 +1,195 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectui#11254 — the gantt tooltip's numeric row (`number` / `integer` /
+ * `float` / `decimal`) reads its width through `resolveFieldScale`, a carrier
+ * of ruling A′ (objectstack-ai/objectstack#19628).
+ *
+ * `formatFieldValue` handed `formatNumber` an `undefined` width, so the
+ * function's own parameter default (two places) decided: every numeric field
+ * read two decimals in the tooltip, whatever it declared. A declared `scale: 3`
+ * read `1.50`, a declared `scale: 0` read `1.50`, and an undeclared `number`
+ * read `1.50` beside a list cell reading `1.5`. Under A′ a `number` has no
+ * absent-`scale` row, so absent means NO fixed width (the value's natural
+ * precision), and a declared width is that width.
+ *
+ * The agreement rows render the REAL list cell (`NumberCellRenderer`) for the
+ * same value and field; the absolute-byte expectations guard against a joint
+ * move of both faces.
+ *
+ * ── Directions on the base tree (predicted before the first run) ──────────
+ *   `scale: 3`                 RED   (`1.50` before)
+ *   `scale: 2`                 GREEN (the old default equals the declaration)
+ *   `scale: 0`                 RED   (`1.50` before)
+ *   no `scale`                 RED   (`1.50` before)
+ *   `integer`, no `scale`      RED   (`7.00` before; the protocol has no row)
+ *   malformed `scale: "2"`     RED   (`1.50` before; no declaration, no width)
+ *
+ * Harness: the GanttView stub and the module-constant schema / data source of
+ * `ObjectGantt.numberLocale.test.tsx`, for the reasons stated there.
+ */
+
+import React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, screen, waitFor, cleanup } from '@testing-library/react';
+import { I18nProvider, LocalizationProvider } from '@object-ui/i18n';
+import { NumberCellRenderer } from '@object-ui/fields';
+import { ObjectGantt } from './ObjectGantt';
+import type { DataSource } from '@object-ui/types';
+
+vi.mock('./GanttView', () => ({
+  GanttView: ({ tasks }: any) => (
+    <div data-testid="gantt-view">
+      {tasks.map((t: any) => (
+        <div key={t.id} data-testid="gantt-task">
+          <span>{t.title}</span>
+          {t.fields ? (
+            <div data-testid={`gv-fields-${t.id}`}>
+              {t.fields.map((f: any, i: number) => (
+                <span key={i} data-testid={`gv-field-${t.id}-${i}`}>{f.value}</span>
+              ))}
+            </div>
+          ) : null}
+        </div>
+      ))}
+    </div>
+  ),
+}));
+
+const STORED = 1.5;
+const STORED_INTEGER = 7;
+
+const FIELDS = {
+  scale3: { type: 'number', label: 'Scale 3', scale: 3 },
+  scale2: { type: 'number', label: 'Scale 2', scale: 2 },
+  scale0: { type: 'number', label: 'Scale 0', scale: 0 },
+  undeclared: { type: 'number', label: 'Undeclared' },
+  integer: { type: 'integer', label: 'Integer' },
+  malformed: { type: 'number', label: 'Malformed', scale: '2' },
+} as const;
+
+/** Tooltip order, and each row's stored value. */
+const ORDER = ['scale3', 'scale2', 'scale0', 'undeclared', 'integer', 'malformed'] as const;
+const VALUE: Record<(typeof ORDER)[number], number> = {
+  scale3: STORED,
+  scale2: STORED,
+  scale0: STORED,
+  undeclared: STORED,
+  integer: STORED_INTEGER,
+  malformed: STORED,
+};
+
+const ROWS = [
+  {
+    id: '1',
+    name: 'Task 1',
+    start_date: '2024-01-01',
+    end_date: '2024-01-10',
+    ...VALUE,
+  },
+];
+
+const OBJECT_SCHEMA = {
+  fields: {
+    name: { type: 'text' },
+    start_date: { type: 'date' },
+    end_date: { type: 'date' },
+    ...FIELDS,
+  },
+};
+
+const DATA_SOURCE: DataSource = {
+  find: vi.fn().mockResolvedValue({ data: ROWS }),
+  findOne: vi.fn(),
+  create: vi.fn(),
+  update: vi.fn(),
+  delete: vi.fn(),
+  getObjectSchema: vi.fn().mockResolvedValue(OBJECT_SCHEMA),
+} as any;
+
+const SCHEMA: any = {
+  type: 'gantt',
+  gantt: {
+    titleField: 'name',
+    startDateField: 'start_date',
+    endDateField: 'end_date',
+    tooltipFields: [...ORDER],
+  },
+  data: { provider: 'object', object: 'tasks' },
+};
+
+function Providers({ children }: { children: React.ReactNode }) {
+  return (
+    <I18nProvider config={{ defaultLanguage: 'en', detectBrowserLanguage: false }} persistLanguage={false}>
+      <LocalizationProvider value={{ locale: 'en' }}>{children}</LocalizationProvider>
+    </I18nProvider>
+  );
+}
+
+/** What the list cell renders for `key`'s stored value on its field. */
+function cellText(key: (typeof ORDER)[number]): string {
+  const { container, unmount } = render(
+    <Providers>
+      <NumberCellRenderer value={VALUE[key]} field={FIELDS[key] as any} />
+    </Providers>,
+  );
+  const text = container.textContent ?? '';
+  unmount();
+  return text;
+}
+
+async function tooltipRow(key: (typeof ORDER)[number]): Promise<string> {
+  render(
+    <Providers>
+      <ObjectGantt schema={SCHEMA} dataSource={DATA_SOURCE} />
+    </Providers>,
+  );
+  await waitFor(() => expect(screen.getByTestId('gv-fields-1')).toBeDefined());
+  return screen.getByTestId(`gv-field-1-${ORDER.indexOf(key)}`).textContent ?? '';
+}
+
+afterEach(() => cleanup());
+
+describe('the gantt tooltip numeric row reads the resolved width (objectui#11254)', () => {
+  it('a declared `scale: 3` reads three places, as the list cell does', async () => {
+    const expected = cellText('scale3');
+    expect(expected).toBe('1.500');
+    expect(await tooltipRow('scale3')).toBe(expected);
+  });
+
+  it('a declared `scale: 2` reads two places, as the list cell does', async () => {
+    const expected = cellText('scale2');
+    expect(expected).toBe('1.50');
+    expect(await tooltipRow('scale2')).toBe(expected);
+  });
+
+  it('a declared `scale: 0` reads no places, as the list cell does', async () => {
+    const expected = cellText('scale0');
+    expect(expected).toBe('2');
+    expect(await tooltipRow('scale0')).toBe(expected);
+  });
+
+  it('an undeclared `number` has no fixed width: its natural precision, as the list cell reads', async () => {
+    const expected = cellText('undeclared');
+    expect(expected).toBe('1.5');
+    expect(await tooltipRow('undeclared')).toBe(expected);
+  });
+
+  it('an undeclared `integer` has no protocol row either: no padded places', async () => {
+    const expected = cellText('integer');
+    expect(expected).toBe('7');
+    expect(await tooltipRow('integer')).toBe(expected);
+  });
+
+  it('a malformed `scale: "2"` is no declaration: no fixed width', async () => {
+    const expected = cellText('malformed');
+    expect(expected).toBe('1.5');
+    expect(await tooltipRow('malformed')).toBe(expected);
+  });
+});
@@ -138,8 +138,12 @@ describe('ObjectGantt', () => {
     expect(screen.getByTestId('gv-field-1-1').textContent).toBe('Status=In Progress');
     // Date field formatted (not the raw ISO string).
     expect(screen.getByTestId('gv-field-1-2').textContent).not.toContain('2024-01-05');
-    // Number field formatted.
-    expect(screen.getByTestId('gv-field-1-3').textContent).toBe('Effort=12.00');
+    // Number field formatted. MOVED by objectui#11254: `effort` declares no
+    // `scale`, and under ruling A′ (objectstack-ai/objectstack#19628) an
+    // undeclared `number` has no fixed width, so the stored `12` reads `12`
+    // (as the list cell reads it), not the `12.00` a constant two-place
+    // default padded it to.
+    expect(screen.getByTestId('gv-field-1-3').textContent).toBe('Effort=12');
   });
 
   it('formats a multi-value lookup (array of records) by joining display names', async () => {