canopycms 0.8.2 → 0.9.0

package/dist/editor/entry-diff.js

@@ -8,6 +8,7 @@ import { diffLines, diffWordsWithSpace } from 'diff';
 import equal from 'fast-deep-equal';
 import { ITEM_KEY } from '../item-keys.js';
 import { findBodyFieldName } from '../utils/body-field.js';
+import { isCalendarDay, localMidnight } from '../utils/calendar-day.js';
 import { flattenGroupFields } from '../utils/flatten-group-fields.js';
 import { isPlainRecord, resolveBlockItem } from '../validation/field-traversal.js';
 import { listItemHeading, listItemTitle } from './fields/list-item-title.js';
@@ -89,7 +90,7 @@ const ISO_CHARS = /^[\d:.+\-TZ]+$/;
 const formatDate = (iso, dateOnly, precision = 'minute') => {
     if (dateOnly) {
         const [year, month, day] = iso.split('-').map(Number);
-        return new Date(year, month - 1, day).toLocaleDateString(undefined, {
+        return localMidnight(year, month, day).toLocaleDateString(undefined, {
             year: 'numeric',
             month: 'short',
             day: 'numeric',
@@ -190,6 +191,11 @@ class Walker {
                 }
                 break;
             }
+            case 'date':
+                if (isCalendarDay(value)) {
+                    return { kind: 'date', iso: value, text: formatDate(value, true), dateOnly: true };
+                }
+                break;
             case 'datetime':
                 if (typeof value === 'string' && !Number.isNaN(Date.parse(value))) {
                     return DATE_ONLY.test(value)

package/dist/editor/fields/DateField.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export interface DateFieldProps {
+    id?: string;
+    label?: string;
+    description?: string;
+    value: string;
+    onChange: (value: string) => void;
+    dataCanopyField?: string;
+    /** Shows the value without accepting edits. */
+    readOnly?: boolean;
+    /** A required field has no Remove: a save needs a day in it. */
+    required?: boolean;
+}
+/**
+ * Editor for `type: 'date'` fields: a day, stored as `YYYY-MM-DD`, with no time and no zone. Only
+ * a pick or Remove writes, so a loaded value saves back unchanged, and a save refuses one that is
+ * no real day.
+ */
+export declare const DateField: React.FC<DateFieldProps>;

package/dist/editor/fields/DateField.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useId, useRef } from 'react';
+import { ActionIcon, Tooltip } from '@mantine/core';
+import { DatePickerInput } from '@mantine/dates';
+import { IconX } from '@tabler/icons-react';
+import dayjs from 'dayjs';
+import { calendarDayToLocalDate, localDateToCalendarDay } from '../../utils/calendar-day.js';
+import { CALENDAR_LABELS } from './DateTimeField.js';
+import { LabelledInput } from './FieldLabel.js';
+const VALUE_FORMAT = 'D MMM YYYY';
+const REMOVE_LABEL = 'Remove date';
+/**
+ * A level change unmounts the control that made it, and Esc only closes the calendar from inside
+ * it, so focus moves to the new level's first control.
+ */
+const keepFocusInCalendar = () => {
+    requestAnimationFrame(() => {
+        if (document.activeElement !== document.body)
+            return;
+        document.querySelector('[data-dates-dropdown] button')?.focus();
+    });
+};
+/** What a stored value that is no real day says: it is the only clue to the day meant. */
+const notADay = (value, readOnly, required) => {
+    const next = required ? 'Pick a date.' : 'Pick a date or remove it.';
+    return `Stored as “${value}”, which isn't a real date.${readOnly ? '' : ` ${next}`}`;
+};
+/**
+ * Editor for `type: 'date'` fields: a day, stored as `YYYY-MM-DD`, with no time and no zone. Only
+ * a pick or Remove writes, so a loaded value saves back unchanged, and a save refuses one that is
+ * no real day.
+ */
+export const DateField = ({ id, label, description, value, onChange, dataCanopyField, readOnly = false, required = false, }) => {
+    const generatedId = useId();
+    const inputId = id ?? generatedId;
+    const triggerRef = useRef(null);
+    const date = calendarDayToLocalDate(value);
+    const invalid = value !== '' && date === null;
+    const shown = date ? dayjs(date).format(VALUE_FORMAT) : invalid ? 'invalid value' : 'not set';
+    return (_jsx(LabelledInput, { label: label, inputId: inputId, canopyPath: dataCanopyField, children: _jsx(DatePickerInput, { ref: triggerRef, id: inputId, "aria-label": `${label ?? 'Date'}, ${shown}`, description: description, error: invalid ? notADay(value, readOnly, required) : undefined, size: "sm", value: date, onChange: (next) => {
+                if (readOnly || !next)
+                    return;
+                onChange(localDateToCalendarDay(next));
+                // The day is about to unmount under focus, which would drop a keyboard user to the page.
+                triggerRef.current?.focus();
+            }, valueFormat: VALUE_FORMAT, placeholder: readOnly ? undefined : 'Pick a date', ariaLabels: CALENDAR_LABELS, onLevelChange: keepFocusInCalendar, 
+            // Red is for errors here, so weekends look like other days.
+            weekendDays: [], rightSection: value && !readOnly && !required ? (_jsx(Tooltip, { label: REMOVE_LABEL, children: _jsx(ActionIcon, { variant: "subtle", color: "gray", "aria-label": REMOVE_LABEL, onClick: () => {
+                        onChange('');
+                        // The control goes with the value, so focus returns to the field.
+                        triggerRef.current?.focus();
+                    }, children: _jsx(IconX, { size: 14, "aria-hidden": true }) }) })) : undefined, rightSectionPointerEvents: "all", readOnly: readOnly, "data-canopy-field": dataCanopyField }) }));
+};

package/dist/editor/fields/DateTimeField.d.ts

@@ -11,4 +11,14 @@ export interface DateTimeFieldProps {
     /** The field's `stampOnPublish`: the description says when a submit fills it. */
     stampOnPublish?: boolean;
 }
+export declare const CALENDAR_LABELS: {
+    previousMonth: string;
+    nextMonth: string;
+    previousYear: string;
+    nextYear: string;
+    previousDecade: string;
+    nextDecade: string;
+    monthLevelControl: string;
+    yearLevelControl: string;
+};
 export declare const DateTimeField: React.FC<DateTimeFieldProps>;

package/dist/editor/fields/DateTimeField.js

@@ -4,6 +4,7 @@ import { ActionIcon, Tooltip } from '@mantine/core';
 import { DateTimePicker } from '@mantine/dates';
 import { IconX } from '@tabler/icons-react';
 import dayjs from 'dayjs';
+import { isRealDay, localMidnight } from '../../utils/calendar-day.js';
 import { LabelledInput } from './FieldLabel.js';
 /** Whether the locale uses a 12-hour clock, as the dropdown's native time input then does. */
 const usesTwelveHourClock = () => {
@@ -15,7 +16,7 @@ const usesTwelveHourClock = () => {
 const valueFormat = () => `D MMM YYYY, ${usesTwelveHourClock() ? 'h:mm:ss A' : 'HH:mm:ss'}`;
 const REMOVE_LABEL = 'Remove date and time';
 // The picker's own controls are icon-only or unlabelled without these.
-const CALENDAR_LABELS = {
+export const CALENDAR_LABELS = {
     previousMonth: 'Previous month',
     nextMonth: 'Next month',
     previousYear: 'Previous year',
@@ -26,12 +27,6 @@ const CALENDAR_LABELS = {
     yearLevelControl: 'Choose a year',
 };
 const DATE_PART = /^(\d{4})-(\d{2})-(\d{2})([Tt ]|$)/;
-/** Whether the written year, month and day name a real day; `Date` rolls 30 Feb on to 1 Mar. */
-const isCalendarDate = (year, month, day) => {
-    const lastOfMonth = new Date(0);
-    lastOfMonth.setUTCFullYear(year, month, 0);
-    return month >= 1 && month <= 12 && day >= 1 && day <= lastOfMonth.getUTCDate();
-};
 /**
  * The stored value as a Date, or null for '', an unparsable value or a day that does not exist. A
  * date-only value is local midnight; `Date` reads UTC midnight, the evening before west of UTC.
@@ -42,15 +37,10 @@ const toDate = (iso) => {
     const datePart = DATE_PART.exec(iso);
     if (datePart) {
         const [year, month, day] = datePart.slice(1, 4).map(Number);
-        if (!isCalendarDate(year, month, day))
+        if (!isRealDay(year, month, day))
             return null;
-        if (datePart[4] === '') {
-            // setFullYear, since the constructor maps years 0-99 to 1900-1999.
-            const local = new Date(0);
-            local.setFullYear(year, month - 1, day);
-            local.setHours(0, 0, 0, 0);
-            return local;
-        }
+        if (datePart[4] === '')
+            return localMidnight(year, month, day);
     }
     const date = new Date(iso);
     return Number.isNaN(date.getTime()) ? null : date;

package/dist/editor/fields/list-item-title.js

@@ -22,7 +22,8 @@ const optionLabel = (field, value) => {
 const textFields = (fields) => flattenFields(fields).filter((f) => (f.type === 'string' || f.type === 'number' || f.type === 'select') && !f.list);
 /**
  * Which field titles an object-list item, and its text: its `itemTitleField` value when that is
- * a non-blank string or a number, else its first non-blank single-line string field.
+ * a non-blank string, which a `date` holds too, or a number, else its first non-blank single-line
+ * string field.
  */
 const titleSource = (record, objectField) => {
     const named = objectField.itemTitleField;

package/dist/editor/theme.js

@@ -295,6 +295,7 @@ const canopyCssVariablesResolver = (theme) => ({
         '--mantine-color-dimmed': 'var(--mantine-color-gray-7)',
         '--mantine-color-placeholder': 'color-mix(in srgb, var(--mantine-color-gray-6) 60%, var(--mantine-color-gray-7))',
         '--canopy-danger-text': 'var(--mantine-color-red-9)',
+        '--mantine-color-error': 'var(--canopy-danger-text)',
         '--canopy-input-border': 'color-mix(in srgb, var(--mantine-color-gray-6) 80%, var(--mantine-color-gray-7))',
         '--canopy-surface-subtle': 'var(--mantine-color-gray-0)',
         '--canopy-surface-muted': 'var(--mantine-color-gray-1)',
@@ -307,6 +308,7 @@ const canopyCssVariablesResolver = (theme) => ({
         '--mantine-color-dimmed': 'color-mix(in srgb, var(--mantine-color-dark-1) 85%, var(--mantine-color-dark-2))',
         '--mantine-color-placeholder': 'color-mix(in srgb, var(--mantine-color-dark-2) 60%, var(--mantine-color-dark-1))',
         '--canopy-danger-text': 'var(--mantine-color-red-3)',
+        '--mantine-color-error': 'var(--canopy-danger-text)',
         '--canopy-input-border': 'color-mix(in srgb, var(--mantine-color-dark-2) 80%, var(--mantine-color-dark-1))',
         '--canopy-surface-subtle': 'var(--mantine-color-dark-6)',
         '--canopy-surface-muted': 'var(--mantine-color-dark-5)',
@@ -383,11 +385,15 @@ const CANOPY_STYLES = `
   box-shadow: inset 0 0 0 1px currentColor;
 }
 .mantine-DateTimePicker-day[data-selected],
-.mantine-DateTimePicker-pickerControl[data-selected] {
+.mantine-DateTimePicker-pickerControl[data-selected],
+.mantine-DatePickerInput-day[data-selected],
+.mantine-DatePickerInput-pickerControl[data-selected] {
   background-color: var(--canopy-primary-fill);
 }
 .mantine-DateTimePicker-day[data-selected]:hover,
-.mantine-DateTimePicker-pickerControl[data-selected]:hover {
+.mantine-DateTimePicker-pickerControl[data-selected]:hover,
+.mantine-DatePickerInput-day[data-selected]:hover,
+.mantine-DatePickerInput-pickerControl[data-selected]:hover {
   background-color: var(--canopy-primary-fill-hover);
 }
 input.mantine-TimeInput-input::-webkit-datetime-edit-hour-field:focus,
@@ -398,10 +404,12 @@ input.mantine-TimeInput-input::-webkit-datetime-edit-ampm-field:focus {
 }
 .mantine-Menu-item[aria-disabled='true'],
 .mantine-Combobox-empty,
-.mantine-DateTimePicker-day[data-outside] {
+.mantine-DateTimePicker-day[data-outside],
+.mantine-DatePickerInput-day[data-outside] {
   font-style: var(--canopy-dimmed-font-style);
 }
-.mantine-DateTimePicker-day[data-outside]:not([data-disabled]) {
+.mantine-DateTimePicker-day[data-outside]:not([data-disabled]),
+.mantine-DatePickerInput-day[data-outside]:not([data-disabled]) {
   opacity: 1;
 }
 `;

package/dist/entry-schema-registry.js

@@ -2,7 +2,7 @@ import { countTitleFields, findInvalidTitleFields, findTitleFieldsInLists, } fro
 import { countBodyFields, findInvalidBodyFields, findReservedBodyFieldName, } from './utils/body-field.js';
 import { RESOLVED_REFERENCE_KEYS, RESTRICTED_REFERENCE_MARKER } from './entry-schema.js';
 import { flattenGroupFields } from './utils/flatten-group-fields.js';
-import { ensureFieldNamesSpellInPaths, ensureSelectFieldsHaveOptions, ensureReferenceFieldsHaveScope, ensureItemTitleFieldsExist, ensureNoFlattenedFieldNameCollisions, ensureNoGroupsInsideComplexFields, ensureMarkdownFieldOptions, ensureMaxItemsPlacement, ensureStampOnPublishPlacement, } from './config/validation.js';
+import { ensureFieldNamesSpellInPaths, ensureSelectFieldsHaveOptions, ensureReferenceFieldsHaveScope, ensureItemTitleFieldsExist, ensureNoFlattenedFieldNameCollisions, ensureNoGroupsInsideComplexFields, ensureMarkdownFieldOptions, ensureMaxItemsPlacement, ensureSingleDateFields, ensureStampOnPublishPlacement, } from './config/validation.js';
 /** Look up a field's type by dotted path (e.g., "meta.order").
  * Groups are transparent — their children are searched at the same path level. */
 function findFieldType(fields, dottedPath) {
@@ -103,6 +103,7 @@ export function createEntrySchemaRegistry(registry) {
         ensureMarkdownFieldOptions(schema);
         ensureStampOnPublishPlacement(schema, `Entry schema registry entry "${key}"`);
         ensureMaxItemsPlacement(schema, `Entry schema registry entry "${key}"`);
+        ensureSingleDateFields(schema, `Entry schema registry entry "${key}"`);
         ensureNoFlattenedFieldNameCollisions(schema, `entry schema "${key}"`);
     }
     return registry;

package/dist/services.d.ts

@@ -36,8 +36,9 @@ export interface CanopyServices {
     config: CanopyConfig;
     /**
      * Re-detect the active branch from git HEAD (dev mode only, cached 5s).
-     * Silently updates config if the branch changed — only affects non-editor
-     * content serving since the editor is pinned to its own branch via URL params.
+     * Silently updates config if the branch changed — non-editor content serving follows it, as
+     * does which branch gets dev's active-branch access grant (authorization/branch.ts); the editor
+     * is pinned to its own branch via URL params.
      */
     refreshActiveBranch: () => Promise<void>;
     /**

package/dist/static/index.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { isBuildMode } from '../build-mode.js';
 import { findUnknownKeys, validateEntryData, } from '../validation/entry-validator.js';
 import { findBodyFieldName } from '../utils/body-field.js';
+import { withCalendarDays } from '../utils/calendar-day.js';
 import { isDataOnlyFormat } from '../utils/format.js';
 import { parseSlug } from '../paths/index.js';
 import { collectReferenceIds } from '../validation/field-traversal.js';
@@ -112,7 +113,9 @@ export async function collectStaticPaths(ctx, options = {}) {
  * gray-matter parses unquoted YAML dates in hand-authored frontmatter (`date: YYYY-MM-DD`) into
  * JS `Date` objects rather than strings. The shared validator's datetime check requires a string
  * (see `validateScalar` in entry-validator.ts), so a legitimate hand-authored or migrated entry
- * would otherwise fail this build guard. CMS-authored entries round-trip as quoted strings, so
+ * would otherwise fail this build guard. A bare date under a `date` field is read as the day
+ * written (`withCalendarDays`), and its ISO string is no day, so the scan does the same first.
+ * CMS-authored entries round-trip as quoted strings, so
  * this only affects pre-existing content — which is the primary path for adopters retrofitting
  * CanopyCMS onto an existing repo.
  *
@@ -157,7 +160,7 @@ export function findInvalidEntries(items) {
     for (const item of items) {
         if (!item.schema)
             continue;
-        const data = normalizeDatesDeep(item.data);
+        const data = normalizeDatesDeep(withCalendarDays(item.schema, item.data));
         const errors = validateEntryData(item.schema, data);
         if (errors.length > 0) {
             invalid.push({ entryPath: item.entryPath, errors });

package/dist/system-users.d.ts

@@ -8,5 +8,7 @@ export declare const SYSTEM_USER_ID = "canopycms-system";
 export declare const CONTENT_READER_USER_ID = "canopycms-content-reader";
 /** Owner recorded for the active branch a server context provisions (context.ts). */
 export declare const CONTEXT_USER_ID = "canopycms-context";
+/** Owner recorded for the active branch the AI content route provisions (ai/resolve-branch.ts). */
+export declare const AI_USER_ID = "canopycms-ai";
 /** True for a user id CanopyCMS acts as; the editor shows these as "CanopyCMS bot". */
 export declare const isSystemUserId: (userId: string) => boolean;

package/dist/system-users.js

@@ -8,5 +8,10 @@ export const SYSTEM_USER_ID = 'canopycms-system';
 export const CONTENT_READER_USER_ID = 'canopycms-content-reader';
 /** Owner recorded for the active branch a server context provisions (context.ts). */
 export const CONTEXT_USER_ID = 'canopycms-context';
+/** Owner recorded for the active branch the AI content route provisions (ai/resolve-branch.ts). */
+export const AI_USER_ID = 'canopycms-ai';
 /** True for a user id CanopyCMS acts as; the editor shows these as "CanopyCMS bot". */
-export const isSystemUserId = (userId) => userId === SYSTEM_USER_ID || userId === CONTENT_READER_USER_ID || userId === CONTEXT_USER_ID;
+export const isSystemUserId = (userId) => userId === SYSTEM_USER_ID ||
+    userId === CONTENT_READER_USER_ID ||
+    userId === CONTEXT_USER_ID ||
+    userId === AI_USER_ID;

package/dist/utils/calendar-day.d.ts

@@ -0,0 +1,23 @@
+import type { FieldConfig } from '../config/index.js';
+/** Whether the year, month and day name a real day; `Date` rolls 30 Feb on into March. */
+export declare const isRealDay: (year: number, month: number, day: number) => boolean;
+/** Whether `value` is a `date` field's value: `YYYY-MM-DD`, naming a real day. */
+export declare const isCalendarDay: (value: unknown) => value is string;
+/**
+ * The first moment of that day in the browser's zone: 01:00 where a clock change skips midnight,
+ * the next day where a zone skipped the day whole. `new Date('YYYY-MM-DD')` is UTC midnight
+ * instead, the evening before west of UTC.
+ */
+export declare const localMidnight: (year: number, month: number, day: number) => Date;
+/** A `date` value as a picker's local `Date`, or null when it is not a real day. */
+export declare const calendarDayToLocalDate: (value: string) => Date | null;
+/** The day a picker's local `Date` shows, as a `date` value. */
+export declare const localDateToCalendarDay: (date: Date) => string;
+/**
+ * `data` with each `date` field's bare YAML date as its `YYYY-MM-DD` string, nested fields
+ * included; the same object when none needed it, so a parser's shared object is never written to.
+ * Only the schema knows a field wants a day, so other fields' bare dates stay `Date`s.
+ */
+export declare function withCalendarDays(fields: readonly FieldConfig[], data: Record<string, unknown>): Record<string, unknown>;
+/** `data` parsed from an entry file as every reader hands it on, so all of them agree. */
+export declare const entryAsRead: (fields: readonly FieldConfig[], data: Record<string, unknown>) => Record<string, unknown>;

package/dist/utils/calendar-day.js

@@ -0,0 +1,102 @@
+import { withItemKeys } from '../item-keys.js';
+import { isPlainRecord, resolveBlockItem } from '../validation/field-traversal.js';
+/**
+ * The value of a `date` field: `YYYY-MM-DD`, a day on the calendar with no time and no zone. It
+ * only meets a `Date` at its edges, a picker or a display and a YAML parser, and there it goes
+ * through the local or the UTC parts named below, never from one to the other.
+ */
+const DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const MS_PER_DAY = 86_400_000;
+const twoDigits = (n) => String(n).padStart(2, '0');
+/** Whether the year, month and day name a real day; `Date` rolls 30 Feb on into March. */
+export const isRealDay = (year, month, day) => {
+    const lastOfMonth = new Date(0);
+    lastOfMonth.setUTCFullYear(year, month, 0);
+    return month >= 1 && month <= 12 && day >= 1 && day <= lastOfMonth.getUTCDate();
+};
+const dayParts = (value) => {
+    const match = typeof value === 'string' ? DAY.exec(value) : null;
+    if (!match)
+        return undefined;
+    const [year, month, day] = match.slice(1).map(Number);
+    return isRealDay(year, month, day) ? [year, month, day] : undefined;
+};
+/** Whether `value` is a `date` field's value: `YYYY-MM-DD`, naming a real day. */
+export const isCalendarDay = (value) => dayParts(value) !== undefined;
+/**
+ * The first moment of that day in the browser's zone: 01:00 where a clock change skips midnight,
+ * the next day where a zone skipped the day whole. `new Date('YYYY-MM-DD')` is UTC midnight
+ * instead, the evening before west of UTC.
+ */
+export const localMidnight = (year, month, day) => {
+    // setFullYear, since the constructor maps years 0-99 to 1900-1999.
+    const local = new Date(0);
+    local.setFullYear(year, month - 1, day);
+    local.setHours(0, 0, 0, 0);
+    return local;
+};
+/** A `date` value as a picker's local `Date`, or null when it is not a real day. */
+export const calendarDayToLocalDate = (value) => {
+    const parts = dayParts(value);
+    return parts ? localMidnight(...parts) : null;
+};
+/** The day a picker's local `Date` shows, as a `date` value. */
+export const localDateToCalendarDay = (date) => `${String(date.getFullYear()).padStart(4, '0')}-${twoDigits(date.getMonth() + 1)}-${twoDigits(date.getDate())}`;
+/**
+ * The day gray-matter's js-yaml reads a bare `YYYY-MM-DD` as, or undefined for any other time of
+ * day. js-yaml reads it as UTC midnight, so the UTC parts are the day written whatever the
+ * machine's zone. A timestamp at UTC midnight reads alike, so it counts as a day.
+ */
+const dayOfBareDate = (value) => value.getTime() % MS_PER_DAY === 0 ? value.toISOString().slice(0, 10) : undefined;
+const mapItems = (items, mapItem) => {
+    const next = items.map((item) => (isPlainRecord(item) ? mapItem(item) : item));
+    return next.every((item, i) => item === items[i]) ? items : next;
+};
+const blockItemWithDays = (field, item) => {
+    const resolved = resolveBlockItem(field, item);
+    if (!resolved)
+        return item;
+    const data = withCalendarDays(resolved.fields, resolved.data);
+    if (data === resolved.data)
+        return item;
+    return resolved.data === item ? data : { ...item, value: data };
+};
+const valueWithDays = (field, value) => {
+    if (field.type === 'date') {
+        return value instanceof Date ? (dayOfBareDate(value) ?? value) : value;
+    }
+    if (field.type === 'object') {
+        const { fields, list } = field;
+        if (list) {
+            return Array.isArray(value)
+                ? mapItems(value, (item) => withCalendarDays(fields ?? [], item))
+                : value;
+        }
+        return isPlainRecord(value) ? withCalendarDays(fields ?? [], value) : value;
+    }
+    if (field.type === 'block' && Array.isArray(value)) {
+        return mapItems(value, (item) => blockItemWithDays(field, item));
+    }
+    return value;
+};
+/**
+ * `data` with each `date` field's bare YAML date as its `YYYY-MM-DD` string, nested fields
+ * included; the same object when none needed it, so a parser's shared object is never written to.
+ * Only the schema knows a field wants a day, so other fields' bare dates stay `Date`s.
+ */
+export function withCalendarDays(fields, data) {
+    let out = data;
+    for (const field of fields) {
+        if (field.type === 'group') {
+            out = withCalendarDays(field.fields, out);
+            continue;
+        }
+        const value = out[field.name];
+        const next = valueWithDays(field, value);
+        if (next !== value)
+            out = { ...out, [field.name]: next };
+    }
+    return out;
+}
+/** `data` parsed from an entry file as every reader hands it on, so all of them agree. */
+export const entryAsRead = (fields, data) => withItemKeys(fields, withCalendarDays(fields, data), 'content');

package/dist/utils/content-serialize.d.ts

@@ -16,6 +16,7 @@
  * is a schema question, answered one layer up by `findUnknownKeys`
  * (validation/entry-validator.ts) at the API boundary, not by a schema-blind serialiser.
  */
+import type { FieldConfig } from '../config/index.js';
 import { type MarkdownBodyFormat } from './markdown-body-splice.js';
 /**
  * Serialise entry data as a YAML file, carrying the comments of `existingRaw` through.
@@ -34,6 +35,7 @@ export declare function serializeYaml(data: Record<string, unknown>, existingRaw
  * would have produced. The result is kept only if the read path reads `data` back from it;
  * otherwise gray-matter writes it, without the comments. A fresh string the read path would
  * misread is quoted (`readsAsAnotherValue`), so this is left for a changed value meeting text the
- * two parsers read differently, as 14 meets a file's `014`.
+ * two parsers read differently, as 14 meets a file's `014`. `fields`, the entry's schema, shapes
+ * what the read path reads, so a `date` field's bare date counts as the day it writes.
  */
-export declare function serializeFrontmatter(editorBody: string, data: Record<string, unknown>, existingRaw: string | undefined, format: MarkdownBodyFormat): string;
+export declare function serializeFrontmatter(editorBody: string, data: Record<string, unknown>, existingRaw: string | undefined, format: MarkdownBodyFormat, fields?: readonly FieldConfig[]): string;

package/dist/utils/content-serialize.js

@@ -21,6 +21,7 @@ import matter from 'gray-matter';
 import { isCollection, isMap, isNode, isScalar, isSeq, parseDocument, Scalar, stringify as yamlStringify, visit, } from 'yaml';
 import { isBlockStructuralKey } from '../validation/block-structural-keys.js';
 import { ITEM_KEY, isItemKey } from '../item-keys.js';
+import { withCalendarDays } from './calendar-day.js';
 import { createDebugLogger } from './debug.js';
 import { getErrorMessage } from './error.js';
 import { preserveMarkdownSource } from './markdown-body-splice.js';
@@ -552,9 +553,9 @@ function asJson(value) {
     return key === undefined || key === 'undefined' ? undefined : JSON.parse(key);
 }
 /** Frontmatter data as the read path hands it over the API, or undefined when it cannot split. */
-function frontmatterAsRead(raw) {
+function frontmatterAsRead(raw, fields) {
     try {
-        return asJson(matter(raw, {}).data);
+        return asJson(withCalendarDays(fields, matter(raw, {}).data));
     }
     catch {
         return undefined;
@@ -648,9 +649,10 @@ function readsAsAnotherValue(text, asKey) {
  * would have produced. The result is kept only if the read path reads `data` back from it;
  * otherwise gray-matter writes it, without the comments. A fresh string the read path would
  * misread is quoted (`readsAsAnotherValue`), so this is left for a changed value meeting text the
- * two parsers read differently, as 14 meets a file's `014`.
+ * two parsers read differently, as 14 meets a file's `014`. `fields`, the entry's schema, shapes
+ * what the read path reads, so a `date` field's bare date counts as the day it writes.
  */
-export function serializeFrontmatter(editorBody, data, existingRaw, format) {
+export function serializeFrontmatter(editorBody, data, existingRaw, format, fields = []) {
     // An object, never the body string: `matter.stringify` re-parses a string as a whole file, so a
     // body starting with `---` would be read as frontmatter and dropped.
     const file = { content: bodyToWrite(editorBody, data, format, existingRaw) };
@@ -661,7 +663,7 @@ export function serializeFrontmatter(editorBody, data, existingRaw, format) {
         return matter.stringify(file, data);
     const onDisk = parseDocument(existingFrontmatter);
     const toReconcile = onDisk.errors.length === 0
-        ? withUnchangedAsOnDisk(data, frontmatterAsRead(existingRaw), onDisk.toJS())
+        ? withUnchangedAsOnDisk(data, frontmatterAsRead(existingRaw, fields), onDisk.toJS())
         : data;
     const reconciled = reconcileYamlSource(existingFrontmatter, isPlainRecord(toReconcile) ? toReconcile : data, { rootAtColumnZero: true, quote: readsAsAnotherValue });
     if (reconciled === undefined)
@@ -674,7 +676,7 @@ export function serializeFrontmatter(editorBody, data, existingRaw, format) {
             },
         },
     });
-    if (isDeepStrictEqual(frontmatterAsRead(written), asJson(data)))
+    if (isDeepStrictEqual(frontmatterAsRead(written, fields), asJson(data)))
         return written;
     log.debug('content-serialize', 'reconciled frontmatter reads back differently; writing as gray-matter prints it');
     return matter.stringify(file, data);

package/dist/validation/entry-validator.js

@@ -19,6 +19,7 @@ import { referenceValueId, resolveBlockItem, traverseFields } from './field-trav
 import { findBodyFieldName } from '../utils/body-field.js';
 import { flattenGroupFields } from '../utils/flatten-group-fields.js';
 import { isDataOnlyFormat } from '../utils/format.js';
+import { isCalendarDay } from '../utils/calendar-day.js';
 const KNOWN_FIELD_TYPES = new Set(fieldTypes);
 /** Field types whose value is a plain string. */
 const STRING_FIELD_TYPES = new Set(['string', 'markdown', 'mdx', 'code']);
@@ -104,6 +105,11 @@ function validateScalar(field, value, path) {
                 return [{ fieldPath: path, message: 'Expected true or false' }];
             }
             return [];
+        case 'date':
+            if (value !== '' && !isCalendarDay(value)) {
+                return [{ fieldPath: path, message: 'Expected a real date, written YYYY-MM-DD' }];
+            }
+            return [];
         case 'datetime':
             if (typeof value !== 'string' || (value !== '' && Number.isNaN(Date.parse(value)))) {
                 return [{ fieldPath: path, message: 'Expected a valid date/time string' }];
@@ -143,7 +149,7 @@ function isEmptyForRequired(field, value) {
     if (Array.isArray(value))
         return value.length === 0;
     if (typeof value === 'string') {
-        // Strings, selects, references, datetimes: empty string means "not filled in".
+        // Strings, selects, references, dates: empty string means "not filled in".
         return value.trim() === '';
     }
     return false;

package/dist/validation/field-traversal.js

@@ -7,7 +7,7 @@
  */
 /** A record of named fields: not null, and not an array, which spreading would index-key. */
 export function isPlainRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return (typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date));
 }
 /**
  * Resolve a block item to its template fields and nested data record.

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CANOPYCMS_VERSION = "0.8.2";
+export declare const CANOPYCMS_VERSION = "0.9.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by scripts/bump-version.mjs, its only writer. The package builds with plain
 // tsc (rootDir: src), so src/ cannot import ../package.json; version.test.ts keeps the two equal.
-export const CANOPYCMS_VERSION = '0.8.2';
+export const CANOPYCMS_VERSION = '0.9.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@codemirror/language, @lezer/highlight: workaround — @mdxeditor/editor uses cm6-theme-basic-light which peer-requires these but mdxeditor doesn't declare them as dependencies",
   "name": "canopycms",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "CanopyCMS core package: schema-driven content, branch-aware editing, and editor UI for Next.js.",
   "license": "MIT",
   "repository": {