@zeyos/zx 4.4.0 → 5.0.0

package/src/zeyos/form.js

@@ -1,6 +1,9 @@
 import { Form, Message, Select } from '../index.js';
-import { connect } from './connect.js';
-import { dateToUnixSeconds, unixSecondsToDate } from './query.js';
+import { overlayHost } from '../core/overlay-host.js';
+import { connect, errorMessage } from './connect.js';
+import {
+  calendarDayToUnixSeconds, dateToUnixSeconds, unixSecondsToCalendarDay, unixSecondsToDate
+} from './query.js';
 import { fieldToZxField, resolveFields } from './schema.js';
 import { buildZeyosSelectConfig } from './select.js';
 
@@ -9,11 +12,21 @@ import { buildZeyosSelectConfig } from './select.js';
  * @property {string[]} [fields] Curated ordered field allow-list.
  * @property {string[]} [exclude] Field ids to omit.
  * @property {Record<string, string>} [labels] Per-field label overrides.
+ * @property {Record<string, string>} [formats] Per-field semantic format overrides, such as
+ * `{ duedate: 'date' }` for a Unix-second field that holds a calendar day.
+ * @property {string} [timeZone] IANA time zone of the ZeyOS instance. A date-only field's stored
+ * midnight is read as the calendar day it names in this zone, and a picked day is saved as midnight
+ * in it; defaults to the runtime's own zone.
  * @property {string} [title=''] Fieldset legend.
  * @property {1|2|3} [columns=2] Fieldset column count.
  * @property {Record<string, unknown>} [value] Initial record using ZeyOS storage values.
  * @property {unknown} [id] Initial record id to load.
  * @property {(record: Record<string, unknown>) => unknown|Promise<unknown>} [onSaved] Success callback.
+ * @property {Element|string|null} [scope=null] Element or selector whose theme scope shows the
+ * binding's toasts — the save confirmation and the report of a failed request. Null uses the form's
+ * own element, so a form inside a scoped shell or dialog toasts inside that scope.
+ * @property {boolean} [notify=true] Whether the binding raises toasts. `false` keeps it silent:
+ * `save()`, `load()`, and `ready` still resolve or reject, and reporting is the caller's.
  */
 
 /**
@@ -22,8 +35,10 @@ import { buildZeyosSelectConfig } from './select.js';
  * @property {Record<string, Record<string, any>>} fields Field descriptors keyed by id.
  * @property {Array<{id: string, resource: string}>} entityFields Referenced-resource fields.
  * @property {Record<string, any>} formOptions Plain Zx Form options.
- * @property {(record: Record<string, unknown>) => Record<string, unknown>} mapFromRecord Maps Unix seconds to Date values.
- * @property {(values: Record<string, unknown>) => Record<string, unknown>} mapToRecord Maps Date and enum values to API storage values.
+ * @property {(record: Record<string, unknown>) => Record<string, unknown>} mapFromRecord Maps Unix
+ * seconds to Date values: a date-only field to local midnight of its calendar day in `timeZone`.
+ * @property {(values: Record<string, unknown>) => Record<string, unknown>} mapToRecord Maps Date and
+ * enum values to API storage values: a date-only field to midnight of its day in `timeZone`.
  */
 
 /**
@@ -31,7 +46,8 @@ import { buildZeyosSelectConfig } from './select.js';
  * @property {Form} form Generated Zx form.
  * @property {Promise<Record<string, unknown>|null>} ready Initial value/load readiness.
  * @property {(id: unknown) => Promise<Record<string, unknown>>} load Loads and maps one record.
- * @property {() => Promise<Record<string, unknown>|null>} save Validates and creates or updates the record.
+ * @property {() => Promise<Record<string, unknown>|null>} save Validates and creates or updates the
+ * record, then confirms with a toast in the form's scope unless `notify` is false.
  * @property {() => Form} getForm Returns the generated Zx Form.
  * @property {() => void} destroy Destroys the form and all owned fields/selects.
  */
@@ -39,7 +55,8 @@ import { buildZeyosSelectConfig } from './select.js';
 /**
  * Builds the DOM-free form configuration consumed by {@link zeyosForm}. Entity descriptors retain
  * the `zxselect` type and receive the same async options used by {@link zeyosSelect}; enum options
- * come from normalized schema metadata, and the returned mappers handle Unix-second dates.
+ * come from normalized schema metadata with readable labels, and the returned mappers handle
+ * Unix-second dates — date-only fields as calendar days in `opts.timeZone`.
  * @param {Record<string, any>} client Injected ZeyOS client instance.
  * @param {string} resource Resource name such as `transactions`.
  * @param {ZeyosFormOptions} [opts={}] Schema curation and layout options.
@@ -49,9 +66,14 @@ export function buildZeyosFormConfig(client, resource, opts = {}) {
   const fieldMeta = resolveFields(client, resource, opts);
   const fields = {};
   const entityFields = [];
+  /** @type {Map<string, 'date'|'datetime'>} */
+  const dateKinds = new Map();
 
   for (const meta of fieldMeta) {
     const descriptor = fieldToZxField(meta);
+    if (descriptor.type === 'date' || descriptor.type === 'datetime') {
+      dateKinds.set(String(meta.id), descriptor.type);
+    }
     const referencedResource = descriptor.type === 'zxselect' && typeof descriptor.props?.entity === 'string'
       ? descriptor.props.entity
       : null;
@@ -78,16 +100,18 @@ export function buildZeyosFormConfig(client, resource, opts = {}) {
         fields
       }]
     },
-    mapFromRecord: (record) => mapFromRecord(record, fieldMeta),
-    mapToRecord: (values) => mapToRecord(values, fieldMeta)
+    mapFromRecord: (record) => mapFromRecord(record, fieldMeta, dateKinds),
+    mapToRecord: (values) => mapToRecord(values, fieldMeta, dateKinds)
   };
 }
 
 /**
  * Generates a schema-driven Zx Form and a small async binding object. `load(id)` hydrates entity
  * labels and converts Unix seconds to Date objects. `save()` validates, maps values back to API
- * storage types, calls create/update through the WP14 connection facade, shows a success toast,
- * and invokes `onSaved(record)`. Await `ready` when `opts.id` or `opts.value` is supplied.
+ * storage types, calls create/update through the WP14 connection facade, invokes
+ * `onSaved(record)`, and shows a success toast. Its toasts — that confirmation and the report of a
+ * failed request — appear in the theme scope of `opts.scope` or of the form itself, and
+ * `notify: false` silences them. Await `ready` when `opts.id` or `opts.value` is supplied.
  * @param {Record<string, any>} client Injected ZeyOS client instance.
  * @param {string} resource Resource name such as `transactions`.
  * @param {ZeyosFormOptions} [opts={}] Schema, initial value, and save options.
@@ -97,8 +121,14 @@ export function zeyosForm(client, resource, opts = {}) {
   if (opts.onSaved != null && typeof opts.onSaved !== 'function') {
     throw new TypeError('zeyosForm onSaved must be a function');
   }
+  const notify = opts.notify !== false;
   const config = buildZeyosFormConfig(client, resource, opts);
-  const facade = connect(client);
+  // The caller's scope, or the form's own element, decides where a toast appears — never whatever
+  // element happens to hold focus when a request settles.
+  const toastScope = () => opts.scope ?? form.el;
+  const facade = connect(client, {
+    onError: (error) => notify ? Message.error(errorMessage(error), { scope: toastScope() }) : undefined
+  });
   const form = new Form(null, config.formOptions);
   let currentId = opts.value?.ID ?? opts.id ?? null;
   let destroyed = false;
@@ -133,6 +163,8 @@ export function zeyosForm(client, resource, opts = {}) {
     if (destroyed) return Promise.reject(new Error('Cannot save a destroyed ZeyOS form'));
     if (savePending) return savePending;
     if (!form.submit()) return Promise.resolve(null);
+    // Resolved now, while the form is in place: `onSaved` may close the dialog that holds it.
+    const host = notify ? overlayHost(toastScope()) : null;
 
     savePending = (async () => {
       let payload;
@@ -157,7 +189,7 @@ export function zeyosForm(client, resource, opts = {}) {
           throw error;
         }
       }
-      Message.success(`${recordLabel(record, resource)} saved successfully.`);
+      if (host) Message.success(`${recordLabel(record, resource)} saved successfully.`, { scope: host });
       return record;
     })().finally(() => {
       savePending = null;
@@ -183,27 +215,41 @@ export function zeyosForm(client, resource, opts = {}) {
   };
 }
 
-/** @param {Record<string, unknown>} record @param {Record<string, any>[]} meta @returns {Record<string, unknown>} */
-function mapFromRecord(record, meta) {
+/**
+ * @param {Record<string, unknown>} record
+ * @param {Record<string, any>[]} meta
+ * @param {Map<string, 'date'|'datetime'>} dateKinds
+ * @returns {Record<string, unknown>}
+ */
+function mapFromRecord(record, meta, dateKinds) {
   const values = {};
   for (const field of meta) {
     const id = String(field.id);
     const value = record[id];
-    values[id] = isDateField(field) && value != null && value !== ''
-      ? unixSecondsToDate(/** @type {number|string} */ (value))
-      : value;
+    const kind = dateKinds.get(id);
+    if (!kind || value == null || value === '') values[id] = value;
+    else if (kind === 'date') values[id] = unixSecondsToCalendarDay(/** @type {number|string} */ (value), field.timeZone);
+    else values[id] = unixSecondsToDate(/** @type {number|string} */ (value));
   }
   return values;
 }
 
-/** @param {Record<string, unknown>} values @param {Record<string, any>[]} meta @returns {Record<string, unknown>} */
-function mapToRecord(values, meta) {
+/**
+ * @param {Record<string, unknown>} values
+ * @param {Record<string, any>[]} meta
+ * @param {Map<string, 'date'|'datetime'>} dateKinds
+ * @returns {Record<string, unknown>}
+ */
+function mapToRecord(values, meta, dateKinds) {
   const record = {};
   for (const field of meta) {
     const id = String(field.id);
     let value = values[id];
-    if (isDateField(field)) {
-      value = value == null || value === '' ? null : dateToUnixSeconds(/** @type {Date} */ (value));
+    const kind = dateKinds.get(id);
+    if (kind) {
+      if (value == null || value === '') value = null;
+      else if (kind === 'date') value = calendarDayToUnixSeconds(/** @type {Date} */ (value), field.timeZone);
+      else value = dateToUnixSeconds(/** @type {Date} */ (value));
     } else if (hasEnum(field) && isNumericType(field.type) && value !== '' && value != null) {
       const numeric = Number(value);
       if (Number.isFinite(numeric)) value = numeric;
@@ -213,12 +259,6 @@ function mapToRecord(values, meta) {
   return record;
 }
 
-/** @param {Record<string, any>} meta @returns {boolean} */
-function isDateField(meta) {
-  const descriptor = fieldToZxField(meta);
-  return descriptor.type === 'date' || descriptor.type === 'datetime';
-}
-
 /** @param {Record<string, any>} meta @returns {boolean} */
 function hasEnum(meta) {
   return meta.enums != null || meta.enum != null;

package/src/zeyos/index.js

@@ -8,7 +8,7 @@ export {
 } from './schema.js';
 export {
   buildListQuery, tableSortToQuery, dataFilterStateToFilters,
-  dateToUnixSeconds, unixSecondsToDate
+  dateToUnixSeconds, unixSecondsToDate, calendarDayToUnixSeconds, unixSecondsToCalendarDay
 } from './query.js';
 export { connect } from './connect.js';
 export {

package/src/zeyos/query.js

@@ -55,6 +55,159 @@ export function unixSecondsToDate(seconds) {
   return new Date(value * 1000);
 }
 
+/**
+ * @typedef {Object} CalendarDay
+ * @property {number} year Full year.
+ * @property {number} month Zero-based month, as `Date` counts them.
+ * @property {number} day Day of the month.
+ */
+
+/**
+ * @typedef {Object} CalendarZone
+ * @property {string|undefined} timeZone Canonical IANA zone, or undefined for the runtime's own zone.
+ * @property {(milliseconds: number) => CalendarDay} dayOf Calendar day an instant falls on in the zone.
+ * @property {(year: number, month: number, day: number) => number} midnightOf Epoch milliseconds of
+ * the first moment of a calendar day in the zone (its midnight, or the first minute after a
+ * daylight-saving gap that swallows midnight).
+ */
+
+/**
+ * Reads a ZeyOS date-only value as the calendar day it names. Date-only fields — an invoice's
+ * `date` and `duedate`, a contact's `birthdate` — hold Unix seconds at midnight of a day in the
+ * instance's time zone: a calendar day, not an instant. The result is midnight of that same day in
+ * the runtime's own zone, which is what Datebox and DatePicker edit, so the day survives a viewer in
+ * another zone and a daylight-saving change.
+ * @param {number|string|null|undefined} seconds Unix seconds; numeric strings are accepted.
+ * @param {string} [timeZone] IANA zone of the instance, such as `Europe/Vienna`; the runtime's own
+ * zone when omitted.
+ * @returns {Date|null} Local midnight of the day, or null for a nullish or empty input.
+ */
+export function unixSecondsToCalendarDay(seconds, timeZone) {
+  if (seconds == null || seconds === '') return null;
+  const value = Number(seconds);
+  if (!Number.isFinite(value)) throw new TypeError('Expected finite Unix seconds');
+  const { year, month, day } = calendarZone(timeZone).dayOf(value * 1000);
+  return localMidnight(year, month, day);
+}
+
+/**
+ * Converts the calendar day of a Date to the Unix seconds a ZeyOS date-only field stores: midnight
+ * of that day in the instance's time zone. Only the Date's local year, month, and day count — its
+ * time of day is ignored — so a Datebox value round-trips through {@link unixSecondsToCalendarDay}.
+ * @param {Date|null|undefined} date Day to store.
+ * @param {string} [timeZone] IANA zone of the instance; the runtime's own zone when omitted.
+ * @returns {number|null} Unix seconds, or null for a nullish input.
+ */
+export function calendarDayToUnixSeconds(date, timeZone) {
+  if (date == null) return null;
+  if (!(date instanceof Date)) throw new TypeError('Expected a Date');
+  if (!Number.isFinite(date.getTime())) throw new RangeError('Invalid Date');
+  const midnight = calendarZone(timeZone).midnightOf(date.getFullYear(), date.getMonth(), date.getDate());
+  return Math.floor(midnight / 1000);
+}
+
+/**
+ * Validates an IANA time-zone name.
+ * @param {unknown} timeZone Zone name; nullish or empty selects the runtime's own zone.
+ * @returns {string|undefined} The canonical zone name, or undefined for the runtime's own zone.
+ * @throws {RangeError} When the runtime does not know the zone.
+ */
+export function normalizeTimeZone(timeZone) {
+  if (timeZone == null || timeZone === '') return undefined;
+  try {
+    return new Intl.DateTimeFormat('en-US', { timeZone: String(timeZone) }).resolvedOptions().timeZone;
+  } catch {
+    throw new RangeError(`Unknown time zone "${String(timeZone)}"`);
+  }
+}
+
+/**
+ * Calendar arithmetic for one time zone. The `Intl` formatter is built once, so a table column can
+ * hold one zone for all of its cells.
+ * @param {string} [timeZone] IANA zone; the runtime's own zone when omitted.
+ * @returns {CalendarZone} Day lookup and midnight construction for the zone.
+ */
+export function calendarZone(timeZone) {
+  const zone = normalizeTimeZone(timeZone);
+  if (!zone) {
+    return {
+      timeZone: undefined,
+      dayOf: (milliseconds) => {
+        const date = new Date(milliseconds);
+        return { year: date.getFullYear(), month: date.getMonth(), day: date.getDate() };
+      },
+      midnightOf: (year, month, day) => localMidnight(year, month, day).getTime()
+    };
+  }
+
+  const formatter = new Intl.DateTimeFormat('en-US', {
+    timeZone: zone,
+    hourCycle: 'h23',
+    year: 'numeric',
+    month: 'numeric',
+    day: 'numeric',
+    hour: 'numeric',
+    minute: 'numeric',
+    second: 'numeric'
+  });
+  /** @param {number} milliseconds @returns {CalendarDay & {seconds: number}} */
+  const wallClock = (milliseconds) => {
+    const parts = {};
+    for (const part of formatter.formatToParts(new Date(milliseconds))) parts[part.type] = Number(part.value);
+    return {
+      year: parts.year,
+      month: parts.month - 1,
+      day: parts.day,
+      seconds: (parts.hour % 24) * 3600 + parts.minute * 60 + parts.second
+    };
+  };
+  /** @param {number} milliseconds @returns {number} The zone's UTC offset at that instant, in milliseconds. */
+  const offsetAt = (milliseconds) => {
+    const wall = wallClock(milliseconds);
+    return utcMidnight(wall.year, wall.month, wall.day) + wall.seconds * 1000
+      - Math.floor(milliseconds / 1000) * 1000;
+  };
+
+  return {
+    timeZone: zone,
+    dayOf: (milliseconds) => {
+      const { year, month, day } = wallClock(milliseconds);
+      return { year, month, day };
+    },
+    midnightOf: (year, month, day) => {
+      // Midnight is the instant whose wall clock reads the target day at 00:00. Two offset
+      // corrections settle it on either side of a daylight-saving change; where a change skips
+      // midnight altogether, the earlier candidate lands on the previous evening and the later one
+      // on the first minute of the day, which is the one kept.
+      const target = utcMidnight(year, month, day);
+      const first = target - offsetAt(target);
+      const second = target - offsetAt(first);
+      let best = null;
+      for (const candidate of [second, first]) {
+        const wall = wallClock(candidate);
+        if (wall.year !== year || wall.month !== month || wall.day !== day) continue;
+        if (!best || wall.seconds < best.seconds) best = { candidate, seconds: wall.seconds };
+      }
+      return best ? best.candidate : second;
+    }
+  };
+}
+
+/** @param {number} year @param {number} month @param {number} day @returns {Date} */
+function localMidnight(year, month, day) {
+  const date = new Date(2000, 0, 1);
+  date.setFullYear(year, month, day);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+
+/** @param {number} year @param {number} month @param {number} day @returns {number} */
+function utcMidnight(year, month, day) {
+  const date = new Date(0);
+  date.setUTCFullYear(year, month, day);
+  return date.getTime();
+}
+
 /**
  * Converts one or more Zx Table sort records to the signed field notation used by ZeyOS.
  * A missing sort produces an empty array.

package/src/zeyos/schema.js

@@ -1,4 +1,4 @@
-import { dateToUnixSeconds, unixSecondsToDate } from './query.js';
+import { calendarZone, dateToUnixSeconds, normalizeTimeZone, unixSecondsToDate } from './query.js';
 
 /** @typedef {Record<string, unknown>} FieldMeta */
 /**
@@ -11,6 +11,13 @@ import { dateToUnixSeconds, unixSecondsToDate } from './query.js';
  * @property {string[]} [fields] Curated allow-list; its order becomes the output order.
  * @property {string[]} [exclude] Field ids to omit.
  * @property {Record<string, string>} [labels] Per-field label overrides.
+ * @property {Record<string, string>} [formats] Per-field semantic format overrides (`date`,
+ * `datetime`, `money`, or any registered key). The schema types a timestamp only by its storage,
+ * so this is how a Unix-second field the built-in rules misread is declared a calendar day
+ * (`date`) or an instant (`datetime`).
+ * @property {string} [timeZone] IANA time zone of the ZeyOS instance, such as `Europe/Vienna`.
+ * Date-only fields store midnight of a calendar day in this zone; it is copied onto every field's
+ * metadata as `timeZone`. Defaults to the runtime's own zone.
  */
 
 /**
@@ -22,6 +29,49 @@ import { dateToUnixSeconds, unixSecondsToDate } from './query.js';
  */
 export const TYPE_MAP = Object.create(null);
 
+/**
+ * Unix-second fields ZeyOS stores as calendar days (midnight in the instance's zone) rather than
+ * instants: document and due dates, validity ranges, birthdays. `date` counts only when indexed —
+ * the unindexed ones (`imports`, `couponcodes`) record when something happened.
+ */
+const DATE_ONLY_FIELDS = new Set(['date', 'duedate', 'birthdate', 'datefrom', 'dateto', 'datecancel', 'lastbilling']);
+
+/**
+ * Fields with a date-only name that hold instants on their resource: appointment and event times,
+ * and when a stream record, comment, or document version was written.
+ */
+const INSTANT_FIELDS = new Set([
+  'appointments.datefrom', 'appointments.dateto', 'events.datefrom', 'events.dateto',
+  'comments.date', 'documentversions.date', 'records.date'
+]);
+
+/** Readable words for the ZeyOS enum constants that run several words together. */
+const ENUM_WORDS = Object.freeze({
+  AWAITINGACCEPTANCE: 'awaiting acceptance',
+  AWAITINGAPPROVAL: 'awaiting approval',
+  BILLINGONLY: 'billing only',
+  CUSTOMERANDSUPPLIER: 'customer and supplier',
+  FEEDBACKREQUIRED: 'feedback required',
+  INEVALUATION: 'in evaluation',
+  INNEGOTIATION: 'in negotiation',
+  INREVISION: 'in revision',
+  NOSTOCK: 'no stock',
+  NOTSTARTED: 'not started',
+  PARTLYDELIVERED: 'partly delivered',
+  PARTLYINVOICED: 'partly invoiced',
+  PARTLYORDERED: 'partly ordered',
+  PARTLYPAID: 'partly paid',
+  PROCUREMENTONLY: 'procurement only',
+  REMOTECALL: 'remote call',
+  SERIALSANDCHARGES: 'serials and charges'
+});
+
+/** Labels for a priority field whose schema carries no enum. */
+const PRIORITY_LABELS = Object.freeze({ 0: 'Lowest', 1: 'Low', 2: 'Medium', 3: 'High', 4: 'Highest' });
+
+/** An enum name in the constant style ZeyOS uses for stored values (`INVOICED`, `BILLING_QUOTE`). */
+const ENUM_CONSTANT = /^[A-Z][A-Z\d]*(?:_[A-Z\d]+)*$/;
+
 const warnedUnknownTypes = new Set();
 
 /**
@@ -74,7 +124,8 @@ export function fieldToZxField(meta) {
 /**
  * Converts normalized ZeyOS field metadata to a Zx Table column configuration. Renderers return
  * strings only (never DOM): references/enums show labels, numeric columns are right-aligned,
- * booleans show a check, and Unix seconds are formatted as dates.
+ * booleans show a check, and Unix seconds are formatted as dates — a date-only field as the
+ * calendar day it names in `meta.timeZone`, with no time; a date-time field with its time.
  * @param {FieldMeta} meta Normalized metadata containing at least `id` or `name`.
  * @returns {Record<string, unknown>} Plain Zx Table column descriptor.
  */
@@ -94,6 +145,8 @@ export function fieldToZxColumn(meta) {
  * client returns names from `schema.fields(resource)` and definitions from
  * `schema.describe(resource).fields`; embedded `enum` data is authoritative. A compatible
  * `schema.enums(resource, field)` is used when supplied by another client version/stub.
+ * `formats` overrides a field's semantic `format`, and `timeZone` is validated once and copied
+ * onto every field.
  * @param {Record<string, any>} client Injected `@zeyos/client` instance.
  * @param {string} resource Schema resource name such as `tickets`.
  * @param {ResolveFieldOptions} [opts={}] Curation options.
@@ -119,6 +172,8 @@ export function resolveFields(client, resource, opts = {}) {
   const requested = Array.isArray(opts.fields) ? opts.fields.map(String) : [...available.keys()];
   const excluded = new Set(Array.isArray(opts.exclude) ? opts.exclude.map(String) : []);
   const labels = opts.labels && typeof opts.labels === 'object' ? opts.labels : {};
+  const formats = opts.formats && typeof opts.formats === 'object' ? opts.formats : {};
+  const timeZone = normalizeTimeZone(opts.timeZone);
   const result = [];
 
   for (const id of requested) {
@@ -131,6 +186,8 @@ export function resolveFields(client, resource, opts = {}) {
       if (meta.enum == null) meta.enum = enumValues;
     }
     if (Object.prototype.hasOwnProperty.call(labels, id)) meta.label = String(labels[id]);
+    if (Object.prototype.hasOwnProperty.call(formats, id) && formats[id]) meta.format = String(formats[id]);
+    if (timeZone) meta.timeZone = timeZone;
     result.push(meta);
   }
   return result;
@@ -164,7 +221,7 @@ const enumColumn = {
 };
 const priorityColumn = {
   field: { type: 'zxselect', props: { preset: 'priority' } },
-  column: (meta) => ({ render: enumRenderer(meta, priorityOptions()) })
+  column: (meta) => ({ render: enumRenderer(meta, PRIORITY_LABELS) })
 };
 const percentColumn = {
   field: { type: 'float', props: { min: 0, max: 100 } },
@@ -212,10 +269,13 @@ for (const type of ['email', 'tel', 'url', 'uri']) {
 function dateStrategy(type) {
   return {
     field: { type },
-    column: (meta) => ({
-      render: (row) => formatUnixDate(rowValue(row, meta), type === 'datetime'),
-      sortValue: (row) => unixSortValue(rowValue(row, meta))
-    })
+    column: (meta) => {
+      const format = type === 'datetime' ? instantFormatter() : calendarDayFormatter(meta.timeZone);
+      return {
+        render: (row) => format(rowValue(row, meta)),
+        sortValue: (row) => unixSortValue(rowValue(row, meta))
+      };
+    }
   };
 }
 
@@ -241,9 +301,8 @@ function strategyKey(meta) {
 
   const raw = normalizeType(meta.type);
   if (raw === 'bigint' || raw === 'int64') {
-    const id = String(meta.id).toLowerCase();
-    if (id === 'date' && meta.indexed) return 'date';
-    if (/(?:date|time)$/.test(id)) return 'datetime';
+    const temporal = timestampKind(meta);
+    if (temporal) return temporal;
   }
   if (isLongText(meta, raw)) return 'longtext';
   if (raw && TYPE_MAP[raw]) return raw;
@@ -255,6 +314,22 @@ function strategyKey(meta) {
   return raw || semantic;
 }
 
+/**
+ * Tells a calendar-day timestamp from an instant by the field's name and resource, since the schema
+ * types both as `bigint`.
+ * @param {FieldMeta} meta
+ * @returns {'date'|'datetime'|null}
+ */
+function timestampKind(meta) {
+  const id = String(meta.id).toLowerCase();
+  const resource = String(meta.resource ?? '').toLowerCase();
+  if (DATE_ONLY_FIELDS.has(id) && !INSTANT_FIELDS.has(`${resource}.${id}`)) {
+    if (id !== 'date' || meta.indexed) return 'date';
+  }
+  if (INSTANT_FIELDS.has(`${resource}.${id}`) || /(?:date|time)$|^lastmodified$/.test(id)) return 'datetime';
+  return null;
+}
+
 /** @param {FieldMeta} meta @returns {FieldMeta & {id: string}} */
 function normalizeMeta(meta) {
   if (!meta || typeof meta !== 'object' || Array.isArray(meta)) throw new TypeError('Field metadata must be an object');
@@ -362,31 +437,41 @@ function normalizeEnumOptions(values) {
     return Object.fromEntries(values.map((entry, index) => {
       if (Array.isArray(entry)) {
         const [value = index, label = value] = entry;
-        return [String(value), String(label)];
+        return [String(value), enumLabel(label)];
       }
       if (entry && typeof entry === 'object') {
         const value = entry.value ?? entry.id ?? index;
-        return [String(value), String(entry.label ?? entry.name ?? value)];
+        return [String(value), entry.label != null ? String(entry.label) : enumLabel(entry.name ?? value)];
       }
-      return [String(index), String(entry)];
+      return [String(index), enumLabel(entry)];
     }));
   }
   if (values && typeof values === 'object') {
-    return Object.fromEntries(Object.entries(values).map(([value, label]) => [value, String(label)]));
+    return Object.fromEntries(Object.entries(values).map(([value, label]) => [value, enumLabel(label)]));
   }
   return {};
 }
 
+/**
+ * Turns a stored enum name into its label. A label the schema gives (`{value, label}`) never reaches
+ * this; what does is usually a constant such as `INVOICED` or `PARTLYPAID_CANCELLED`, shown in
+ * sentence case with its words separated ("Invoiced", "Partly paid cancelled"). Anything else is
+ * already a label and is kept as it is.
+ * @param {unknown} name Stored enum name.
+ * @returns {string}
+ */
+function enumLabel(name) {
+  const text = String(name ?? '');
+  if (!ENUM_CONSTANT.test(text)) return text;
+  const words = text.split('_').map((part) => ENUM_WORDS[part] ?? part.toLowerCase()).join(' ');
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
 /** @param {FieldMeta} meta @returns {'optionlist'|'select'} */
 function enumFieldType(meta) {
   return Object.keys(enumOptions(meta)).length <= 5 ? 'optionlist' : 'select';
 }
 
-/** @returns {Record<string, string>} */
-function priorityOptions() {
-  return { '0': 'LOWEST', '1': 'LOW', '2': 'MEDIUM', '3': 'HIGH', '4': 'HIGHEST' };
-}
-
 /** @param {FieldMeta} meta @param {Record<string, string>} [fallback] @returns {(row: Record<string, unknown>) => string} */
 function enumRenderer(meta, fallback = {}) {
   const labels = { ...fallback, ...enumOptions(meta) };
@@ -426,17 +511,49 @@ function formatPercent(value) {
   return number == null ? '' : `${new Intl.NumberFormat().format(number)}%`;
 }
 
-/** @param {unknown} value @param {boolean} includeTime @returns {string} */
-function formatUnixDate(value, includeTime) {
-  if (value == null || value === '') return '';
+/**
+ * Formats a date-time field: the instant, in the viewer's zone, with its time.
+ * @returns {(value: unknown) => string}
+ */
+function instantFormatter() {
+  const formatter = new Intl.DateTimeFormat(undefined, { dateStyle: 'medium', timeStyle: 'short' });
+  return (value) => {
+    const date = timestampDate(value);
+    return date ? formatter.format(date) : '';
+  };
+}
+
+/**
+ * Formats a date-only field: the calendar day the stored midnight names in the instance's zone,
+ * with no time, so neither the viewer's zone nor daylight saving can move it.
+ * @param {unknown} timeZone Instance zone from the field metadata; the runtime's own when absent.
+ * @returns {(value: unknown) => string}
+ */
+function calendarDayFormatter(timeZone) {
+  const zone = calendarZone(/** @type {string|undefined} */ (timeZone ?? undefined));
+  // The day is formatted as a UTC date so the formatter cannot shift it a second time.
+  const formatter = new Intl.DateTimeFormat(undefined, { dateStyle: 'medium', timeZone: 'UTC' });
+  return (value) => {
+    const date = timestampDate(value);
+    if (!date) return '';
+    // A Date value is already a local calendar day (a form's own value, say); seconds are stored.
+    const { year, month, day } = value instanceof Date
+      ? { year: date.getFullYear(), month: date.getMonth(), day: date.getDate() }
+      : zone.dayOf(date.getTime());
+    const utc = new Date(0);
+    utc.setUTCFullYear(year, month, day);
+    return formatter.format(utc);
+  };
+}
+
+/** @param {unknown} value Unix seconds or a Date. @returns {Date|null} */
+function timestampDate(value) {
+  if (value == null || value === '') return null;
   try {
     const date = value instanceof Date ? value : unixSecondsToDate(/** @type {number|string} */ (value));
-    if (!date || !Number.isFinite(date.getTime())) return '';
-    return new Intl.DateTimeFormat(undefined, includeTime
-      ? { dateStyle: 'medium', timeStyle: 'short' }
-      : { dateStyle: 'medium' }).format(date);
+    return date && Number.isFinite(date.getTime()) ? date : null;
   } catch {
-    return '';
+    return null;
   }
 }