@@ -0,0 +1,9 @@
+---
+'@object-ui/types': minor
+'@object-ui/components': minor
+---
+
+`CalendarSchema.defaultValue` / `.value` cross the JSON/TS boundary once (objectui#10293, objectui#7759 ruling D1-(iii)).
+
+- `@object-ui/types`: the declaration is now `Date | string`, the same set the zod mirror accepts. JSON authors an ISO 8601 date string; TypeScript callers may still pass a `Date`. Breaking for TypeScript only: the `Date[]` arm is gone from the declaration, so a `Date[]` passed to a `multiple`-mode calendar no longer type-checks. The mirror never accepted a list, and the renderer still forwards one unchanged at runtime.
+- `@object-ui/components`: the `ui:calendar` renderer coerces a string `value` / `defaultValue` to a `Date` at its read site, through `toDisplayDate` from `@object-ui/core`. A date-only string such as `2026-09-15` now selects the 15th in every time zone. Before, it selected the 14th west of UTC. `Date` values and date-time strings select the same day as before.
@@ -22,6 +22,14 @@ The Calendar component allows users to select dates in various modes including s
 
 <SchemaExample id="components-form-calendar/multiple-dates" />
 
+## Selected Date
+
+`value` and `defaultValue` take an ISO 8601 date string in JSON (`"2026-09-15"` or `"2026-09-15T09:00:00Z"`); a TypeScript caller may also pass a `Date`. A date-only string selects the day it names in every time zone.
+
+```json
+{ "type": "ui:calendar", "mode": "single", "defaultValue": "2026-09-15" }
+```
+
 ## Schema
 
 ```plaintext
@@ -30,8 +38,8 @@ interface CalendarSchema {
   
   // Selection
   mode?: 'single' | 'multiple' | 'range';  // Selection mode (default: 'single')
-  defaultValue?: Date | Date[];             // Default selected date(s)
-  value?: Date | Date[];                    // Controlled selected date(s)
+  defaultValue?: Date | string;             // Default selected date (ISO 8601 string in JSON)
+  value?: Date | string;                    // Controlled selected date (ISO 8601 string in JSON)
   
   // Constraints
   minDate?: Date | string;                  // Minimum selectable date
 
@@ -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#10293 — the `ui:calendar` primitive selects the day an ISO string
+ * names, the same day the equivalent `Date` selects.
+ *
+ * ── What was measured ───────────────────────────────────────────────────────
+ * The renderer handed `schema.value || schema.defaultValue` to `DayPicker`
+ * untouched. `DayPicker` compares through date-fns, which parses a string
+ * with the engine's own `Date` parse, so a date-only string was UTC midnight
+ * read back in local time: `2026-09-15` selected the 14th in
+ * `America/Los_Angeles` and the 15th in UTC, while `new Date(2026, 8, 15)`
+ * selected the 15th in both. A date-time string already selected its local
+ * day. The read site now coerces a string through `toDisplayDate`
+ * (`@object-ui/core`, the objectui#10183 convention).
+ *
+ * ── ⚠️ The zone cases run ONLY when driven, in a FORKS child ────────────────
+ * `process.env.TZ` written inside a test of the normal run does not move the
+ * zone (the root config runs `pool: 'threads'`), so the zone cases are
+ * skipped there and `scripts/__tests__/date-only-zone-pins-10183.test.ts`
+ * runs them on the forks pool and fails unless every one ran and passed. Each
+ * zone opens with a rig case, so a child whose zone did not move reds instead
+ * of going quietly green. The UTC cases below run in the normal run too; they
+ * cannot tell the repair from its absence, because UTC is the one offset where
+ * the two parses agree, and they are here for the `Date` / date-time faces.
+ *
+ * `Asia/Shanghai` is the control: east of UTC the UTC-midnight parse already
+ * landed on the named day, and an hour-offset "repair" would break it.
+ */
+import React from 'react';
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { render, cleanup } from '@testing-library/react';
+import { ComponentRegistry } from '@object-ui/core';
+// Registers the renderers at module scope, NOT inside a hook (objectui#3010).
+import '../../../renderers';
+
+const DRIVEN = process.env.OBJECTUI_DATE_ZONE_CHILD === '1';
+
+/** UTC-7 in September — the card's direction. */
+const WEST = 'America/Los_Angeles';
+/** UTC+8 — the control. */
+const EAST = 'Asia/Shanghai';
+
+/** Frozen inside September 2026, so the calendar opens on the month under test. */
+const CLOCK = '2026-09-03T10:35:00.000Z';
+const DATE_ONLY = '2026-09-15';
+/** A fixed instant: 21:00 on the 15th in the west, 12:00 on the 16th in the east. */
+const INSTANT = '2026-09-16T04:00:00.000Z';
+
+/** Freeze the clock, moving this forked process into `zone` first when given. */
+function enter(zone?: string): void {
+  if (zone) process.env.TZ = zone;
+  vi.useFakeTimers({ toFake: ['Date'] });
+  vi.setSystemTime(new Date(CLOCK));
+}
+
+afterEach(() => {
+  cleanup();
+  vi.useRealTimers();
+});
+
+/** The `data-day` of every selected cell the calendar paints. */
+function selectedDays(extra: Record<string, unknown>): string[] {
+  const Calendar = ComponentRegistry.get('ui:calendar')!;
+  const { container } = render(<Calendar schema={{ type: 'ui:calendar', mode: 'single', ...extra }} />);
+  const days = Array.from(container.querySelectorAll('td[data-selected="true"]'))
+    .map((td) => td.getAttribute('data-day') ?? '');
+  cleanup();
+  return days;
+}
+
+describe('ui:calendar selected date, in the suite zone (objectui#10293)', () => {
+  it('a local `Date` selects the day it names (the reference face)', () => {
+    enter();
+    expect(selectedDays({ value: new Date(2026, 8, 15) })).toEqual(['2026-09-15']);
+  });
+
+  it('a date-only string selects that same day, through `value` and `defaultValue`', () => {
+    enter();
+    expect(selectedDays({ value: DATE_ONLY })).toEqual(['2026-09-15']);
+    expect(selectedDays({ defaultValue: DATE_ONLY })).toEqual(['2026-09-15']);
+  });
+
+  it('an invalid string still selects nothing, as it did before the coercion', () => {
+    enter();
+    expect(selectedDays({ value: 'not a date' })).toEqual([]);
+  });
+});
+
+describe.runIf(DRIVEN)('ui:calendar date-only value west of UTC (objectui#10293)', () => {
+  it('rig: the zone really moved', () => {
+    enter(WEST);
+    expect(Intl.DateTimeFormat().resolvedOptions().timeZone).toBe(WEST);
+    expect(new Date(INSTANT).getHours()).toBe(21);
+  });
+
+  it('fixture validity: the engine parse of the string lands on the day before here', () => {
+    enter(WEST);
+    // Without this the cases below would be green for free.
+    expect(new Date(DATE_ONLY).getDate()).toBe(14);
+  });
+
+  it('`2026-09-15` selects the 15th, the day `new Date(2026, 8, 15)` selects', () => {
+    enter(WEST);
+    expect(selectedDays({ value: new Date(2026, 8, 15) })).toEqual(['2026-09-15']);
+    expect(selectedDays({ value: DATE_ONLY })).toEqual(['2026-09-15']);
+    expect(selectedDays({ defaultValue: DATE_ONLY })).toEqual(['2026-09-15']);
+  });
+
+  it('an instant keeps selecting its local day, the 15th here', () => {
+    enter(WEST);
+    expect(selectedDays({ value: INSTANT })).toEqual(['2026-09-15']);
+  });
+});
+
+describe.runIf(DRIVEN)('ui:calendar date-only value east of UTC, the control (objectui#10293)', () => {
+  it('rig: the zone really moved', () => {
+    enter(EAST);
+    expect(Intl.DateTimeFormat().resolvedOptions().timeZone).toBe(EAST);
+    expect(new Date(INSTANT).getHours()).toBe(12);
+  });
+
+  it('`2026-09-15` selects the 15th, as it already did', () => {
+    enter(EAST);
+    expect(selectedDays({ value: DATE_ONLY })).toEqual(['2026-09-15']);
+  });
+
+  it('an instant keeps selecting its local day, the 16th here', () => {
+    enter(EAST);
+    expect(selectedDays({ value: INSTANT })).toEqual(['2026-09-16']);
+  });
+});
@@ -6,15 +6,27 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { ComponentRegistry } from '@object-ui/core';
+import { ComponentRegistry, toDisplayDate } from '@object-ui/core';
 import type { CalendarSchema } from '@object-ui/types';
 import { Calendar } from '../../ui';
 
+/**
+ * The selected-date read (objectui#10293). JSON authors an ISO 8601 string
+ * and `DayPicker` compares `Date`s, so a string is coerced here, through the
+ * shared parse step: a date-only string is rebuilt at LOCAL midnight of the
+ * day it names, where the engine's own parse read it as UTC midnight and
+ * selected the day before west of UTC (the objectui#10183 convention). Any
+ * other value — a `Date`, or nothing — reaches `DayPicker` unchanged.
+ */
+function toSelected(value: unknown): unknown {
+  return typeof value === 'string' ? toDisplayDate(value) : value;
+}
+
 ComponentRegistry.register('calendar', 
   ({ schema, className, ...props }: { schema: CalendarSchema; className?: string; [key: string]: any }) => (
     <Calendar
       mode={(schema.mode || "single") as any}
-      selected={(schema.value || schema.defaultValue) as any}
+      selected={toSelected(schema.value || schema.defaultValue) as any}
       className={className}
       {...props}
     />
 
@@ -0,0 +1,64 @@
+/**
+ * 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#10293 — `CalendarSchema.defaultValue` / `.value` cross the JSON/TS
+ * boundary once (objectui#7759, ruling D1-(iii)).
+ *
+ * - The MIRROR's authoring type is an ISO 8601 date string. Its `z.date()`
+ *   arm stays for in-process callers, the shape every settled date-value key
+ *   in `form.zod.ts` already has (`DatePickerSchema`'s `defaultValue` /
+ *   `value`, and this schema's own `minDate` / `maxDate`).
+ * - The DECLARATION keeps `Date` and gains the ISO string, so the two faces
+ *   are the same set: `Date | string`. It was `Date | Date[]`, disjoint from
+ *   the mirror on the string arm and wider on the list arm, and ledgered in
+ *   `zod-mirror-parity.test.ts` until this card removed the rows.
+ * - The `calendar` renderer coerces the string (its own pin sits beside it in
+ *   `packages/components`, `calendar.dateValueZone-10293.test.tsx`).
+ *
+ * The type-level half reddens under `tsc -p tsconfig.test.json` (this
+ * package's `type-check`), not under vitest; the runtime half reddens here.
+ */
+import { describe, it, expect, expectTypeOf } from 'vitest';
+import type { z } from 'zod';
+import { CalendarSchema, UiCalendarSchema } from '../zod/form.zod';
+import type { CalendarSchema as TsCalendarSchema } from '../form';
+
+type MirrorInput = z.input< typeof CalendarSchema >;
+
+describe('CalendarSchema date-value keys: one face on each side of the boundary (objectui#10293)', () => {
+  it('the declaration and the mirror admit the same set, `Date | string`', () => {
+    expectTypeOf< TsCalendarSchema['value'] >().toEqualTypeOf< Date | string | undefined >();
+    expectTypeOf< TsCalendarSchema['defaultValue'] >().toEqualTypeOf< Date | string | undefined >();
+    expectTypeOf< MirrorInput['value'] >().toEqualTypeOf< TsCalendarSchema['value'] >();
+    expectTypeOf< MirrorInput['defaultValue'] >().toEqualTypeOf< TsCalendarSchema['defaultValue'] >();
+  });
+
+  it('a TypeScript author can write the ISO string the mirror accepts', () => {
+    const node: TsCalendarSchema = { type: 'calendar', value: '2026-09-15', defaultValue: '2026-09-15T09:00:00Z' };
+    expect(CalendarSchema.safeParse(node).success).toBe(true);
+  });
+
+  it('the mirror accepts an ISO date-only string, an ISO date-time string and a `Date`', () => {
+    for (const value of ['2026-09-15', '2026-09-15T09:00:00Z', new Date(2026, 8, 15)]) {
+      expect(CalendarSchema.safeParse({ type: 'calendar', value }).success, String(value)).toBe(true);
+      expect(CalendarSchema.safeParse({ type: 'calendar', defaultValue: value }).success, String(value)).toBe(true);
+      expect(UiCalendarSchema.safeParse({ type: 'ui:calendar', value }).success, String(value)).toBe(true);
+    }
+  });
+
+  it('the mirror refuses a list — the arm the declaration gave up', () => {
+    const list = ['2026-09-15', '2026-09-17'];
+    const parsed = CalendarSchema.safeParse({ type: 'calendar', value: list });
+    expect(parsed.success).toBe(false);
+    expect(parsed.error?.issues.map((issue) => issue.path.join('.'))).toEqual(['value']);
+    // @ts-expect-error — `Date[]` left the declaration with objectui#10293.
+    const listNode: TsCalendarSchema = { type: 'calendar', value: [new Date(2026, 8, 15)] };
+    expect(listNode.type).toBe('calendar');
+  });
+});
@@ -154,7 +154,12 @@
  *     a delta to this number; count the registry. Nothing asserts it against a written
  *     one, so this line is prose and can rot; the pin that cannot is the one
  *     comparing the two halves to each other.
- *   - **49 entries** in `KnownDrift`, **90 keys** across them — 46 / 85 until
+ *   - **48 entries** in `KnownDrift`, **88 keys** across them — 49 / 90 until
+ *     objectui#10293 settled `form.zod.ts#CalendarSchema`'s `defaultValue` and `value`
+ *     under objectui#7759 D1-(iii): the declaration gained the ISO string the mirror
+ *     accepts and gave up the `Date[]` arm the mirror refused, so both keys measure
+ *     clean and the entry, its two keys and nothing else LEFT — entry count and key
+ *     total moved together, by one and by two. It was 46 / 85 until
  *     objectui#7759 group E turned the four bare `z.function()` arms into
  *     `handlerKeyRefusal()` arms. THREE entries are NEW (`TableColumnSchema.cell`,
  *     `FieldConstraintsSchema.validate`, and `FormFieldSchema.validation`, which
@@ -405,8 +410,12 @@
  *     spelled "six" rots exactly as fast as one spelled `6`, it is just harder to
  *     point a regex at. ⛔ Do not spell a live figure out again, and ⛔ do not
  *     restate one without checking that the pin's spelling still reaches it.
- *   - **12 entries** in `WiderThanDeclared`, **18 keys** across them, and **22 arms**
- *     under those keys — split **5** SCHEMA-NODE, **13** CONCRETE, **0** MIXED, **4** unions.
+ *   - **11 entries** in `WiderThanDeclared`, **16 keys** across them, and **18 arms**
+ *     under those keys — split **5** SCHEMA-NODE, **11** CONCRETE, **0** MIXED, **2** unions.
+ *     It read 12 / 18 / 22 — 5 / 13 / 0 / 4 — until objectui#10293 made
+ *     `form.zod.ts#CalendarSchema`'s `defaultValue` and `value` declare the ISO string their
+ *     mirror accepts: the entry and both of its two-arm keys left together, so `arms` fell
+ *     by four where `keys` fell by two and `unions` by two.
  *     It read 17 / 26 / 30 — 5 / 21 / 0 / 4 — until objectui#7759 group E replaced the
  *     four bare `z.function()` arms (`renderCellEditor`, `cell`, `validate`, `custom`)
  *     with `handlerKeyRefusal()`. EIGHT keys left, one CONCRETE arm each, and five whole
@@ -592,7 +601,7 @@
  *
  * ## KNOWN_DRIFT is a ratchet, not a waiver
  *
- * 49 of the registered pairs carry TYPE drift TODAY (measured, not assumed). Each is
+ * 48 of the registered pairs carry TYPE drift TODAY (measured, not assumed). Each is
  * pinned to its EXACT drifted key set, so the entry fails when new drift appears on
  * that mirror AND when the recorded drift is fixed — a stale entry cannot rot
  * quietly. Correcting them is not one change: the pairs below split into DISJOINT
@@ -2033,8 +2042,6 @@ interface KnownDrift {
    * to the DOM `<button>` (`onClick` is on `SDUI_DOM_PASS_THROUGH_KEYS`).
    */
   'form.zod.ts#ButtonSchema': 'onClick';
-  /** DISJOINT: TS `Date | Date[]`, mirror `string | Date`. The mirror refuses `Date[]`; the TS side refuses the ISO string the mirror accepts. (`onChange` is NOT here: the `calendar` renderer spreads it onto `DayPicker`, whose callback is `onSelect`, so nothing reads it — both faces retire it.) */
-  'form.zod.ts#CalendarSchema': 'defaultValue' | 'value';
   /** RUNTIME SLOT (objectui#6124): the `checkbox` renderer calls `props.onChange(checked)` after `SchemaRenderer`'s spread. */
   'form.zod.ts#CheckboxSchema': 'onChange';
   /** RUNTIME SLOT (objectui#6124): `plugin-editor` reads `onChange ?? schema.onChange`. */
@@ -3100,8 +3107,6 @@ interface WiderThanDeclared {
   // fourth. ⛔ Do not re-add them for the class labels they carried (F,
   // "inline shape against a named declaration"; D, "disjoint") — a row this
   // ledger records must be a measured widening.
-  /** CONCRETE and DISJOINT — the mirror admits a string, the declaration a list of dates; also in `KnownDrift`. */
-  'form.zod.ts#CalendarSchema': 'defaultValue' | 'value';
   /**
    * CONCRETE. `layout` is the clearest single instance in this ledger: the mirror
    * is `z.enum(['vertical', 'horizontal', 'grid'])` and the declaration states the
@@ -3280,8 +3285,6 @@ const WIDER_ARMS: Readonly< Record< string, readonly WiderArmClass[] > > = {
   'complex.zod.ts#DashboardComponentSchema::dateRange': ['CONCRETE'],
   'complex.zod.ts#FilterBuilderSchema::fields': ['CONCRETE'],
   'complex.zod.ts#FilterFieldSchema::operators': ['CONCRETE'],
-  'form.zod.ts#CalendarSchema::defaultValue': ['CONCRETE', 'CONCRETE'],
-  'form.zod.ts#CalendarSchema::value': ['CONCRETE', 'CONCRETE'],
   'form.zod.ts#FormSchema::layout': ['CONCRETE'],
   'form.zod.ts#FormSchema::mode': ['CONCRETE'],
   'layout.zod.ts#ContainerSchema::maxWidth': ['CONCRETE', 'CONCRETE'],
 
@@ -1151,13 +1151,17 @@ export interface DatePickerSchema extends BaseSchema {
 export interface CalendarSchema extends BaseSchema {
   type: 'calendar';
   /**
-   * Default selected date(s)
+   * Default selected date: an ISO 8601 date string (the JSON authoring type)
+   * or a `Date` (in-process callers). The `calendar` renderer coerces a string
+   * to a `Date` at its read site; a date-only string (`2026-09-15`) selects
+   * the day it names in every zone (objectui#10293).
    */
-  defaultValue?: Date | Date[];
+  defaultValue?: Date | string;
   /**
-   * Controlled selected date(s)
+   * Controlled selected date: an ISO 8601 date string or a `Date`, read as
+   * {@link CalendarSchema.defaultValue} is.
    */
-  value?: Date | Date[];
+  value?: Date | string;
   /**
    * Selection mode
    * @default 'single'
 
@@ -549,8 +549,13 @@ export const DatePickerSchema = BaseSchema.extend({
  */
 export const CalendarSchema = BaseSchema.extend({
   type: z.literal('calendar'),
-  defaultValue: z.union([z.string(), z.date()]).optional().describe('Default value'),
-  value: z.union([z.string(), z.date()]).optional().describe('Controlled value'),
+  // objectui#10293: the string arm is the JSON authoring type, an ISO 8601
+  // date string, which the `calendar` renderer coerces to a `Date`. The
+  // `z.date()` arm stays for in-process callers, as on `DatePickerSchema`.
+  defaultValue: z.union([z.string(), z.date()]).optional()
+    .describe('Default selected date, an ISO 8601 date string'),
+  value: z.union([z.string(), z.date()]).optional()
+    .describe('Controlled selected date, an ISO 8601 date string'),
   mode: z.enum(['single', 'multiple', 'range']).optional().describe('Selection mode'),
   minDate: z.union([z.string(), z.date()]).optional().describe('Minimum date'),
   maxDate: z.union([z.string(), z.date()]).optional().describe('Maximum date'),