@@ -13,4 +13,4 @@ A date-only value naming a day its month does not have — `2026-02-30`, `2024-0
 - **A dataset measure agrees with the list cell on the refusal.** A date-only measure value of `2024-02-30` renders `—`, the same as the `date` cell beside it. The measure takes that answer from the shared path and makes no judgement of its own.
 - **`@object-ui/fields`:** the `date` and `datetime` cells, the readonly `DateField` and a date-returning `FormulaField` show the shared "No value" placeholder for such a day, exactly as for an unparsable value, instead of a bare dash.
 
-A value that carries a time (`2026-02-30T10:00:00Z`) still rolls. This change covers date-only values only.
+This change covers date-only values only. (A value that carries a time, such as `2026-02-30T10:00:00Z`, is refused by the same path too — objectui#10301, a separate entry in this release.)
@@ -0,0 +1,12 @@
+---
+'@object-ui/core': patch
+'@object-ui/fields': patch
+---
+
+fix(core,fields): a date-time written on a calendar day that does not exist is refused, not rolled into another day
+
+`2026-02-30T10:00:00Z` names a day February does not have. The engine parses it anyway and rolls the surplus forward, so it rendered as `Mar 2, 2026, 10:00 AM`: a real day nobody wrote, with nothing to say the stored value was wrong. objectui#10026 made the shared date path refuse such a day on a date-only value; this extends the same refusal to a value that carries a time.
+
+- **`toDisplayDate` returns an Invalid Date for an ISO date-time whose leading `YYYY-MM-DD` is not a real calendar day** (the `isRealCalendarDate` judgement). The day is read from the stored string as written, so a real day written with an offset — `2026-02-28T23:30:00-05:00`, which is March 1st in UTC — is not refused, and a real date-time renders exactly as before. `formatDateTime`, `formatDate` and `formatRelativeDate` render `—` for such a value, `formatDateTimeCompactParts` returns `null`, and a dataset measure over it renders the same `—`: each function's existing answer for an unparsable value.
+- **`@object-ui/fields`:** the `datetime` and `date` cells, the readonly `date` widget and a date-returning `FormulaField` show the shared "No value" placeholder for such a value, and the readonly `datetime` widget shows `—`, exactly as each does for an unparsable value.
+- **The sub-grid (`GridField` / `LineItemsField`) `date` and `datetime` columns read the shared parse step instead of building their own `Date`.** A value that step refuses shows the stored string, this surface's existing face for a value it cannot parse: an impossible day in either column (`2026-02-30`, which the `date` column still rolled into March after objectui#10026), and an out-of-range month (`2026-13-45`, which the `date` column rendered as `Feb 14, 2027`). A `date` value with a year below 100 (`0026-08-01`) now renders that year, as the `date` cell does, instead of 1926.
@@ -0,0 +1,138 @@
+/**
+ * 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#10301 — the shared date path refuses a DATE-TIME spelled on a
+ * calendar day that does not exist, the way objectui#10026 made it refuse a
+ * date-only one.
+ *
+ * ── The defect ───────────────────────────────────────────────────────────
+ * objectui#10026 taught `toDisplayDate` to hand back an Invalid Date for
+ * `2026-02-30`, but only on the date-only shape. The engine parses
+ * `2026-02-30T10:00:00Z` just as happily and rolls it into March 2nd, so
+ * `formatDateTime` rendered `Mar 2, 2026, 10:00 AM`: a real day nobody wrote,
+ * with nothing to say so. The maintainer's ruling on objectui#10026 ("a
+ * silently wrong day is the failure North Star rule 4 forbids") covers it;
+ * triage graded this card an inherited branch of that ruling.
+ *
+ * ── What "the day" is ─────────────────────────────────────────────────────
+ * The judgement reads the LEADING `YYYY-MM-DD` of the stored string, the day
+ * the value was written on, never the day the parsed instant lands on in some
+ * zone. A parsed `Date` always names a real day, so a check made after any
+ * conversion could only ever miss a refusal. The offset case below is the
+ * control on the other side: a real day written with an offset that moves
+ * the instant into March in UTC must not be refused.
+ *
+ * ── Directions, predicted before the run ───────────────────────────────────
+ *   pre-card sources         every refusal case reds with a rendered March
+ *                            date; the controls stay green
+ *   the new arm deleted      same as pre-card
+ * The date-only refusal pins of objectui#10026 (`impossibleDay-10026` beside
+ * this file) are untouched by this card and must stay green.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { formatMeasure } from '../dataset-format.js';
+import {
+  formatDate,
+  formatDateTime,
+  formatDateTimeCompactParts,
+  formatRelativeDate,
+  toDisplayDate,
+} from '../date-display.js';
+
+const EN = 'en-US';
+
+/**
+ * Date-times whose day does not exist, in the spellings the engine accepts:
+ * `Z`, an offset, fractional seconds, no zone, and a space separator.
+ */
+const IMPOSSIBLE_DATETIMES = [
+  '2026-02-30T10:00:00Z',
+  '2024-02-31T08:15:00.000Z',
+  '2025-02-29T10:00',
+  '2026-04-31T23:59:59+09:00',
+  '2026-02-30 10:00',
+] as const;
+
+/** A real day written with an offset: 2026-03-01T04:30Z, in UTC. */
+const REAL_DAY_WITH_OFFSET = '2026-02-28T23:30:00-05:00';
+
+/** The card's positive control: a real date-time. */
+const REAL_DATETIME = '2026-02-28T10:00:00Z';
+
+describe('premise: the engine does not refuse these date-times (objectui#10301)', () => {
+  it('parses each one, so the refusal has to come from the shared path', () => {
+    for (const v of IMPOSSIBLE_DATETIMES) {
+      expect(Number.isNaN(Date.parse(v)), v).toBe(false);
+    }
+  });
+});
+
+describe('toDisplayDate refuses a date-time written on a nonexistent day (objectui#10301)', () => {
+  it('hands back an Invalid Date, the answer the engine gives an unparsable value', () => {
+    for (const v of IMPOSSIBLE_DATETIMES) {
+      expect(Number.isNaN(toDisplayDate(v).getTime()), v).toBe(true);
+    }
+  });
+
+  it('control: a real date-time is the engine instant, unchanged', () => {
+    expect(toDisplayDate(REAL_DATETIME).getTime()).toBe(Date.parse(REAL_DATETIME));
+    expect(toDisplayDate('2024-02-29T10:00:00Z').getTime()).toBe(Date.parse('2024-02-29T10:00:00Z'));
+  });
+
+  it('control: the day is read from the string, so an offset that moves the instant into March is not refused', () => {
+    // In UTC this instant is March 1st, 04:30. The written day, February 28th,
+    // is real, and the instant is kept exactly as the engine parsed it.
+    expect(new Date(REAL_DAY_WITH_OFFSET).toISOString()).toBe('2026-03-01T04:30:00.000Z');
+    expect(toDisplayDate(REAL_DAY_WITH_OFFSET).getTime()).toBe(Date.parse(REAL_DAY_WITH_OFFSET));
+  });
+});
+
+describe('every function on the shared path answers with its own unparsable face (objectui#10301)', () => {
+  it('formatDateTime, on both of its faces', () => {
+    for (const v of IMPOSSIBLE_DATETIMES) {
+      expect(formatDateTime(v, { locale: EN }), v).toBe(formatDateTime('not-a-date', { locale: EN }));
+      expect(formatDateTime(v, { locale: EN, style: 'compact' }), v).toBe(
+        formatDateTime('not-a-date', { locale: EN, style: 'compact' }),
+      );
+    }
+  });
+
+  it('formatDateTimeCompactParts answers null', () => {
+    for (const v of IMPOSSIBLE_DATETIMES) {
+      expect(formatDateTimeCompactParts(v, { locale: EN }), v).toBeNull();
+    }
+  });
+
+  it('formatDate and formatRelativeDate', () => {
+    for (const v of IMPOSSIBLE_DATETIMES) {
+      expect(formatDate(v, undefined, { locale: EN }), v).toBe(formatDate('not-a-date', undefined, { locale: EN }));
+      expect(formatRelativeDate(v, { locale: EN }), v).toBe(formatRelativeDate('not-a-date', { locale: EN }));
+    }
+  });
+
+  it('a dataset measure agrees with the list cell on the refusal', () => {
+    // The measure's datetime arm hands the string to `formatDateTime`, so it
+    // inherits the refusal instead of judging the day itself.
+    for (const v of IMPOSSIBLE_DATETIMES) {
+      expect(formatMeasure(v, undefined, undefined, undefined, EN), v).toBe(formatDateTime('not-a-date', { locale: EN }));
+    }
+  });
+
+  it('control: a real date-time displays as before', () => {
+    // This suite runs in UTC (`vitest.config.mts` pins it).
+    expect(formatDateTime(REAL_DATETIME, { locale: EN })).toBe('Feb 28, 2026, 10:00 AM');
+    expect(formatDateTimeCompactParts(REAL_DATETIME, { locale: EN })).toEqual({ date: '2/28/2026', time: '10:00 am' });
+  });
+
+  it('control: a real day written with an offset renders its instant, not the marker', () => {
+    expect(formatDateTime(REAL_DAY_WITH_OFFSET, { locale: EN })).toBe('Mar 1, 2026, 04:30 AM');
+  });
+});
@@ -153,10 +153,10 @@ const ISO_DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
  * pattern admits — such a value falls through untouched.
  *
  * ⛔ A DAY that overflows its month does NOT fall through. `2026-02-30T09:30`
- * parses, reaches the shared date path and renders rolled over: that path
- * refuses a nonexistent day only on a DATE-ONLY value (objectui#10026), and
- * whether it should refuse one spelled with a time is open on that card. See
- * the note inside {@link formatMeasureDate}.
+ * parses and reaches the shared date path, which refuses it with the dash
+ * `formatDateTime` renders for any unparsable value (objectui#10301, the
+ * date-time half of objectui#10026). The refusal is that path's, not this
+ * pattern's. See the note inside {@link formatMeasureDate}.
  */
 const ISO_DATETIME_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/;
 
 
@@ -105,6 +105,18 @@ export interface DateDisplayOptions {
  */
 const ISO_DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
 
+/**
+ * An ISO date carrying a time part — `2026-08-01T09:30:00Z`, the same with a
+ * space separator, with or without seconds or an offset. Matched only as far
+ * as `HH:mm`, so its first ten characters are the `YYYY-MM-DD` the value was
+ * written on.
+ *
+ * Spelled exactly as `dataset-format.ts`'s `ISO_DATETIME_RE`, which sniffs the
+ * same shape to route a measure to its datetime arm, for the same reason as
+ * {@link ISO_DATE_ONLY_RE} above: one convention, one spelling.
+ */
+const ISO_DATETIME_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/;
+
 /**
  * A date that exists — the pattern alone would accept `2024-02-31`.
  *
@@ -177,9 +189,10 @@ export function isRealCalendarDate(dateOnly: string): boolean {
  * parse already lands on the right day — the co-located suite drives both.
  * `GridField`'s sub-grid cell already parsed its own date-only values this
  * way before reaching `formatDate`; this is that treatment, moved to the one
- * place every caller passes through.
+ * place every caller passes through (the sub-grid reads it from here since
+ * objectui#10301).
  *
- * A value with a time part is untouched, in both spellings: it HAS an
+ * A value with a time part is not rebuilt, in both spellings: it HAS an
  * instant, and rendering an instant in the viewer's zone is the whole point
  * of a `datetime`. The regex is what separates them, so the split is the
  * VALUE's shape and never the field's declared type, which this module (pure,
@@ -204,10 +217,15 @@ export function isRealCalendarDate(dateOnly: string): boolean {
  * objectui#4576 recorded. {@link isRealCalendarDate} is the one judgement,
  * shared with the filter builder's authoring boundary.
  *
- * ⚠️ A value that carries a TIME (`2026-02-30T10:00:00Z`) is not judged here
- * and still rolls. The ruling names date-only values; whether an instant
- * spelled on a nonexistent day is refused too is an open question on that
- * card, not a decision this step makes by itself.
+ * A value that carries a TIME is refused the same way when the day it is
+ * written on does not exist (objectui#10301): `2026-02-30T10:00:00Z` parses
+ * too, and rendered `Mar 2, 2026, 10:00 AM` on every datetime face. Triage
+ * graded that an inherited branch of the same ruling. The judgement reads the
+ * value's leading `YYYY-MM-DD` AS WRITTEN, never the day its instant lands on
+ * in some zone: a parsed `Date` always names a real day, so a check made after
+ * any conversion could only miss the refusal, and a real day written with an
+ * offset (`2026-02-28T23:30:00-05:00`, March 1st in UTC) is kept. A real
+ * date-time is otherwise untouched — no rebuild, the engine's instant.
  *
  * ## Why it is exported (objectui#10183)
  *
@@ -227,6 +245,11 @@ export function isRealCalendarDate(dateOnly: string): boolean {
  */
 export function toDisplayDate(value: string | Date | number): Date {
   const parsed = value instanceof Date ? value : new Date(value as any);
+  // The engine rolls a date-time written on a nonexistent day forward too;
+  // judge the day as written and refuse it (objectui#10301).
+  if (typeof value === 'string' && ISO_DATETIME_RE.test(value) && !isRealCalendarDate(value.slice(0, 10))) {
+    return new Date(NaN);
+  }
   if (typeof value !== 'string' || !ISO_DATE_ONLY_RE.test(value) || isNaN(parsed.getTime())) {
     return parsed;
   }
 
@@ -0,0 +1,130 @@
+/**
+ * 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#10301 — a date-time written on a calendar day that does not exist
+ * reaches the field faces as the refusal, not as a rolled March date.
+ *
+ * ── Why the `datetime` cell needs no code of its own ──────────────────────
+ * `DateTimeCellRenderer` hands its formatters the engine's `new Date(value)`,
+ * a `Date` no parse step can refuse, so on its own it would paint
+ * `2026-02-30T10:00:00Z` as `3/2/2026 10:00 am`. What stops that is its
+ * validity guard, which reads the shared parse step `toDisplayDate` (since
+ * objectui#10026) and so returns `EmptyValue` before any formatter runs. This
+ * card adds the date-time arm to that step; the cases below measure that it
+ * reaches the cell through the guard, with no second realness check in the
+ * renderer.
+ *
+ * ── Directions, predicted before the run ───────────────────────────────────
+ *   pre-card sources                   RED — a rolled compact face (`3/2/2026`)
+ *   the new arm deleted from the step  RED — same as pre-card
+ *   the cell's guard back to `new Date(safe)`
+ *                                      RED — the rolled face again, although
+ *                                      the step refuses
+ *   controls                           green in all three
+ */
+
+import React from 'react';
+import { afterEach, describe, expect, it } from 'vitest';
+import { cleanup, render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { I18nProvider, LocalizationProvider } from '@object-ui/i18n';
+import { formatDateTimeCompactParts } from '@object-ui/core';
+import { getCellRenderer, resolveCellRendererType } from '../index';
+import { DateField } from '../widgets/DateField';
+import { DateTimeField } from '../widgets/DateTimeField';
+import { FormulaField } from '../widgets/FormulaField';
+
+afterEach(() => cleanup());
+
+const IMPOSSIBLE_DATETIMES = ['2026-02-30T10:00:00Z', '2024-02-31T08:15:00.000Z', '2025-02-29T10:00'] as const;
+
+/** A real day written with an offset: 2026-03-01T04:30Z, in UTC. */
+const REAL_DAY_WITH_OFFSET = '2026-02-28T23:30:00-05:00';
+
+/** The card's positive control. */
+const REAL_DATETIME = '2026-02-28T10:00:00Z';
+
+function session(node: React.ReactNode) {
+  return render(
+    <I18nProvider config={{ defaultLanguage: 'en', detectBrowserLanguage: false }} persistLanguage={false}>
+      <LocalizationProvider value={{ locale: undefined }}>{node}</LocalizationProvider>
+    </I18nProvider>,
+  );
+}
+
+function renderCell(type: string, value: unknown): HTMLElement {
+  const Renderer = getCellRenderer(resolveCellRendererType({ type }) || type);
+  return session(<Renderer value={value as any} field={{ type, name: type } as any} />).container;
+}
+
+const affordanceIn = (root: HTMLElement) => root.querySelector<HTMLElement>('[data-slot="empty-value"]');
+
+/** Faces a date-time value reaches, each compared with its own unparsable face. */
+const FACES: ReadonlyArray<readonly [string, (value: unknown) => HTMLElement]> = [
+  ['DateTimeCellRenderer (`datetime` cell)', (value) => renderCell('datetime', value)],
+  ['DateCellRenderer (`date` cell holding a date-time)', (value) => renderCell('date', value)],
+  [
+    'DateTimeField (readonly `datetime` widget)',
+    (value) =>
+      session(
+        <DateTimeField value={value as string} onChange={() => {}} field={{ type: 'datetime', name: 'at' } as any} readonly />,
+      ).container,
+  ],
+  [
+    'DateField (readonly `date` widget holding a date-time)',
+    (value) =>
+      session(
+        <DateField value={value as string} onChange={() => {}} field={{ type: 'date', name: 'when' } as any} readonly />,
+      ).container,
+  ],
+  [
+    'FormulaField (`return_type: date`, a date-time result)',
+    (value) =>
+      session(
+        <FormulaField value={value as any} onChange={() => {}} field={{ type: 'formula', name: 'c', return_type: 'date' } as any} />,
+      ).container,
+  ],
+];
+
+describe.each(FACES)('objectui#10301 — %s', (_name, renderFace) => {
+  it.each(IMPOSSIBLE_DATETIMES)('%s renders exactly what an unparsable value renders', (value) => {
+    const refused = renderFace(value).innerHTML;
+    cleanup();
+    expect(refused).toBe(renderFace('not-a-date').innerHTML);
+  });
+
+  it('control: a real date-time still renders a formatted face', () => {
+    const root = renderFace(REAL_DATETIME);
+    cleanup();
+    expect(root.innerHTML).not.toBe(renderFace('not-a-date').innerHTML);
+  });
+});
+
+describe('objectui#10301 — the `datetime` cell', () => {
+  it.each(IMPOSSIBLE_DATETIMES)('%s draws the shared affordance, not a rolled date', (value) => {
+    const root = renderCell('datetime', value);
+    expect(affordanceIn(root)).not.toBeNull();
+    // The day the engine rolls `2026-02-30` into, on the compact face.
+    expect(root.textContent).not.toContain('3/2/2026');
+  });
+
+  it('control: a real date-time displays as before', () => {
+    // This suite runs in UTC (`vitest.config.mts` pins it).
+    const root = renderCell('datetime', REAL_DATETIME);
+    expect(affordanceIn(root)).toBeNull();
+    expect(root.textContent).toBe('2/28/202610:00 am');
+  });
+
+  it('control: a real day written with an offset renders its instant, not the affordance', () => {
+    const root = renderCell('datetime', REAL_DAY_WITH_OFFSET);
+    expect(affordanceIn(root)).toBeNull();
+    const parts = formatDateTimeCompactParts(new Date(REAL_DAY_WITH_OFFSET), { locale: 'en' });
+    expect(root.textContent).toBe(`${parts!.date}${parts!.time}`);
+  });
+});