canopycms 0.8.2 → 0.9.0

package/dist/cli/sync.js

@@ -16,13 +16,20 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { simpleGit } from 'simple-git';
 import * as p from '@clack/prompts';
+import { z } from 'zod';
+import { resolveBranchParam } from '../branch-param.js';
+import { readBranchMetadataFile } from '../branch-metadata-file.js';
+import { namesNoWorkspace, resolveBranchPath } from '../paths/branch.js';
+import { exactBranchName, exactBranchSegment, isExactBranchForm, parseBranchRef, } from '../paths/validation.js';
+import { getErrorMessage } from '../utils/error.js';
 import { filePathExists } from '../utils/fs.js';
-import { isCanopyInternalPath, stageAllExceptCanopyState } from '../utils/git.js';
+import { detectHeadBranch, isCanopyInternalPath, stageAllExceptCanopyState } from '../utils/git.js';
 import { assertWithinDir, copyDir, listFilesRecursive, pushContentToWorkspace, safeReplaceDir, SYNC_BASE_TAG, } from '../sync-core.js';
 import { invalidateBranchContentCaches } from '../content-index-generation.js';
 import { ContentWriteLockBusyError, withContentWriteLock } from '../utils/content-write-lock.js';
 import { ensureGitExcludePattern } from '../git-manager.js';
 import { operatingStrategy } from '../operating-mode/index.js';
+import { importSiteServerConfig } from './site-config.js';
 /**
  * Sync precondition failure (missing content dir, unknown branch, …).
  * Thrown so the CLI exits non-zero — scripts/CI must not sail past a
@@ -78,12 +85,183 @@ async function detectCurrentBranch(projectDir) {
         throw new Error('Detached HEAD — use --branch to specify a branch name');
     return branch;
 }
+/** The site config fields that decide which workspace a branch name names. */
+const branchConfigSchema = z.object({
+    branchNamespace: z.string().optional(),
+    deploymentName: z.string().optional(),
+    defaultBaseBranch: z.string().optional(),
+    defaultActiveBranch: z.string().optional(),
+});
+/** {@link branchConfigSchema}'s fields from the site config: none, with a warning, when unusable. */
+async function readBranchConfigFields(projectDir) {
+    if (!(await filePathExists(path.join(projectDir, 'canopycms.config.ts'))))
+        return {};
+    let why;
+    try {
+        const parsed = branchConfigSchema.safeParse((await importSiteServerConfig(projectDir)).server);
+        if (parsed.success)
+            return parsed.data;
+        why = parsed.error.message;
+    }
+    catch (err) {
+        why = getErrorMessage(err);
+    }
+    p.log.warn(`Could not use canopycms.config.ts (${why}); branch names resolve against the default branch settings.`);
+    return {};
+}
+/**
+ * The config {@link resolveBranchParam} resolves names against, built as the dev server builds
+ * it: dev mode, the site config's branch fields, and an unset base or active branch taken from the
+ * project's git HEAD (services.ts).
+ */
+async function loadBranchParamConfig(projectDir) {
+    const fields = await readBranchConfigFields(projectDir);
+    const head = await detectHeadBranch(projectDir, fields.defaultBaseBranch ?? 'main');
+    return {
+        ...fields,
+        mode: 'dev',
+        defaultBaseBranch: fields.defaultBaseBranch ?? head,
+        defaultActiveBranch: fields.defaultActiveBranch ?? head,
+    };
+}
+/**
+ * Refuses a directory that is not the top of its own git repository. Git run there would walk up
+ * to the developer's own repository and commit and tag in it.
+ */
+async function assertOwnRepository(branchPath) {
+    const top = await simpleGit({ baseDir: branchPath })
+        .revparse(['--show-toplevel'])
+        .then((out) => out.trim())
+        .catch(() => '');
+    if (top && (await fs.realpath(top)) === (await fs.realpath(branchPath)))
+        return;
+    throw new SyncError(`"${path.basename(branchPath)}" under content-branches/ is not a branch workspace: git does not report it as the top of its own repository.`);
+}
+/** The branch a workspace's HEAD is on (an unborn one included), or null when it is detached. */
+async function workspaceHead(branchPath) {
+    return simpleGit({ baseDir: branchPath })
+        .raw(['symbolic-ref', '--short', '-q', 'HEAD'])
+        .then((out) => out.trim() || null)
+        .catch(() => null);
+}
+/** The workspace at directory `key` under content-branches/, named by its branch.json or HEAD. */
+async function keyWorkspace(key, projectDir) {
+    const branchPath = path.join(operatingStrategy('dev').getContentBranchesRoot(projectDir), key);
+    await assertOwnRepository(branchPath);
+    const meta = await readBranchMetadataFile(branchPath);
+    return { branchName: meta?.branch.name ?? (await workspaceHead(branchPath)) ?? key, branchPath };
+}
+/** The ref `name` gives: decoded from the exact form (`~fix~x`), else `name` itself. */
+function refOf(name) {
+    if (!isExactBranchForm(name))
+        return name;
+    const ref = exactBranchName(name);
+    if (ref === null)
+        throw new SyncError(`"${name}" is not a valid branch name.`);
+    return ref;
+}
+/**
+ * The workspace `name` names, as the dev server resolves it, or null:
+ * 1. what the runtime resolves it to (`resolveBranchParam`): the ref, a namespace branch's short
+ *    name, or the exact form;
+ * 2. a workspace key, the directory itself;
+ * 3. the directory the ref keys to, when it holds a workspace sync built (no branch.json) on that
+ *    ref. Two refs can sanitize to one key, so one whose branch.json or HEAD names another branch
+ *    is refused.
+ * A `name` read from git HEAD (`byRef`) is a ref, never a short name or key: it resolves in its
+ * exact form and skips step 2, so a local branch never lands in an editor's branch or in another
+ * ref's workspace that shares its key.
+ */
+async function resolveSyncWorkspace(name, projectDir, keys, byRef) {
+    const config = await loadBranchParamConfig(projectDir);
+    const param = byRef ? exactBranchSegment(name) : name;
+    const resolved = await resolveBranchParam(param, config, { basePathOverride: projectDir }).catch((err) => {
+        if (namesNoWorkspace(err))
+            return null;
+        throw err;
+    });
+    if (resolved) {
+        // The base and active branch resolve by directory alone, without branch.json's name.
+        const ref = refOf(name);
+        if (resolved.branch.name !== ref && resolved.branchRoot === refKeyPath(ref, projectDir)) {
+            throw holdsAnotherBranch(resolved.branchRoot, resolved.branch.name, ref);
+        }
+        await assertOwnRepository(resolved.branchRoot);
+        return { branchName: resolved.branch.name, branchPath: resolved.branchRoot };
+    }
+    if (!byRef && keys.includes(name))
+        return keyWorkspace(name, projectDir);
+    const ref = refOf(name);
+    const branchPath = refKeyPath(ref, projectDir);
+    const present = await filePathExists(branchPath).catch((err) => {
+        if (namesNoWorkspace(err))
+            throw new SyncError(`"${ref}" cannot name a branch workspace.`);
+        throw err;
+    });
+    if (!present)
+        return null;
+    await assertOwnRepository(branchPath);
+    const meta = await readBranchMetadataFile(branchPath);
+    const holder = meta ? meta.branch.name : await workspaceHead(branchPath);
+    if (holder !== ref)
+        throw holdsAnotherBranch(branchPath, holder, ref);
+    return { branchName: ref, branchPath };
+}
+/** The refusal for a workspace another ref, sharing `ref`'s key, holds (`holder`; null: detached). */
+function holdsAnotherBranch(branchPath, holder, ref) {
+    // mergeIntoWorkspace's temporary branch, left checked out when `both` was interrupted.
+    const recovery = holder?.startsWith('sync-incoming-')
+        ? ` An interrupted "sync both" left it there: run "git checkout ${ref}" in that workspace.`
+        : '';
+    return new SyncError(`Branch workspace "${path.basename(branchPath)}" holds ${holder === null ? 'a detached HEAD' : `branch "${holder}"`}, not "${ref}".${recovery}`);
+}
+/** The workspace directory the runtime keys ref `name` to (`resolveBranchPath`). */
+function refKeyPath(name, projectDir) {
+    try {
+        return resolveBranchPath({ mode: 'dev', branchName: name, basePathOverride: projectDir })
+            .branchRoot;
+    }
+    catch (err) {
+        if (namesNoWorkspace(err))
+            throw new SyncError(`"${name}" cannot name a branch workspace.`);
+        throw err;
+    }
+}
+/**
+ * Auto-create a minimal workspace for the branch `name` gives (git init + empty commit) so push
+ * can copy content in, at the directory the dev server reads for that ref. This is lighter than
+ * BranchWorkspaceManager's clone-based setup -- no remote config, content structure or
+ * branch.json -- and the dev server adopts it in place when it provisions that ref
+ * (BranchWorkspaceManager.provisionBranch).
+ */
+async function createSyncWorkspace(name, projectDir) {
+    const ref = refOf(name);
+    const parsed = parseBranchRef(ref);
+    if (!parsed.ok)
+        throw new SyncError(`"${ref}" is not a valid branch name: ${parsed.error}`);
+    const branchPath = refKeyPath(ref, projectDir);
+    await fs.mkdir(branchPath, { recursive: true });
+    const wsGit = simpleGit({ baseDir: branchPath });
+    await wsGit.init();
+    await wsGit.checkoutLocalBranch(ref);
+    await wsGit.raw(['commit', '--allow-empty', '-m', 'init: workspace created by sync']);
+    // Runtime metadata (.canopy-meta/: branch metadata, comments, content-index
+    // marker) must never be staged by sync's `add -A`. Fully provisioned workspaces
+    // get this exclude from GitManager.initializeWorkspace; this minimal one needs it
+    // too. Sync is dev-mode-only, so this asks the dev strategy for the pattern
+    // rather than hardcoding it.
+    await ensureGitExcludePattern(branchPath, operatingStrategy('dev').getGitExcludePattern());
+    p.log.info(`Created branch workspace: ${path.basename(branchPath)}`);
+    return { branchName: ref, branchPath };
+}
 /**
- * Select a branch workspace. Auto-selects if only one exists, prompts if
- * multiple, or uses the --branch flag (defaulting to the current git branch).
- * When autoCreate is true, creates a new workspace if the branch doesn't exist.
+ * Select a branch workspace. Uses the --branch flag (defaulting to the current git branch),
+ * resolved as the dev server resolves it ({@link resolveSyncWorkspace}); else auto-selects the
+ * only workspace directory, or prompts for one. When autoCreate is true, creates a new workspace
+ * if a named branch has none.
  */
-async function selectBranch(options, branchesDir) {
+async function selectBranch(options) {
+    const branchesDir = operatingStrategy('dev').getContentBranchesRoot(options.projectDir);
     let branches = [];
     if (await filePathExists(branchesDir)) {
         const entries = await fs.readdir(branchesDir, { withFileTypes: true });
@@ -93,6 +271,7 @@ async function selectBranch(options, branchesDir) {
         branches = entries.filter((e) => e.isDirectory() && !e.name.startsWith('.')).map((e) => e.name);
     }
     let branchName = options.branch;
+    const byRef = !branchName;
     if (!branchName) {
         try {
             branchName = await detectCurrentBranch(options.projectDir);
@@ -105,48 +284,25 @@ async function selectBranch(options, branchesDir) {
         if (branches.length === 0) {
             throw new SyncError('No branch workspaces found and could not detect current git branch. Use --branch to specify.');
         }
-        if (branches.length === 1) {
-            branchName = branches[0];
-        }
-        else {
-            const result = await p.select({
-                message: 'Which branch?',
-                options: branches.map((b) => ({ value: b, label: b })),
-            });
-            if (p.isCancel(result)) {
-                p.cancel('Sync cancelled.');
-                return null;
-            }
-            branchName = result;
-        }
-    }
-    // Validate branch name does not escape the branches directory
-    const branchPath = path.join(branchesDir, branchName);
-    assertWithinDir(branchPath, branchesDir, '--branch');
-    if (!branches.includes(branchName)) {
-        if (options.autoCreate) {
-            // Auto-create a minimal workspace (git init + empty commit) so push can
-            // copy content in. This is lighter than BranchWorkspaceManager's clone-based
-            // setup — no remote config or content structure — but sufficient for sync.
-            await fs.mkdir(branchPath, { recursive: true });
-            const wsGit = simpleGit({ baseDir: branchPath });
-            await wsGit.init();
-            await wsGit.checkoutLocalBranch(branchName);
-            await wsGit.raw(['commit', '--allow-empty', '-m', 'init: workspace created by sync']);
-            // Runtime metadata (.canopy-meta/: branch metadata, comments, content-index
-            // marker) must never be staged by sync's `add -A`. Fully provisioned workspaces
-            // get this exclude from GitManager.initializeWorkspace; this minimal one needs it
-            // too. Sync is dev-mode-only (see branchesDir), so this asks the dev strategy for
-            // the pattern rather than hardcoding it.
-            await ensureGitExcludePattern(branchPath, operatingStrategy('dev').getGitExcludePattern());
-            p.log.info(`Created branch workspace: ${branchName}`);
-        }
-        else {
-            const available = branches.length > 0 ? ` Available branches: ${branches.join(', ')}` : '';
-            throw new SyncError(`Branch workspace "${branchName}" not found.${available}`);
+        if (branches.length === 1)
+            return keyWorkspace(branches[0], options.projectDir);
+        const result = await p.select({
+            message: 'Which branch?',
+            options: branches.map((b) => ({ value: b, label: b })),
+        });
+        if (p.isCancel(result)) {
+            p.cancel('Sync cancelled.');
+            return null;
         }
-    }
-    return branchName;
+        return keyWorkspace(result, options.projectDir);
+    }
+    const existing = await resolveSyncWorkspace(branchName, options.projectDir, branches, byRef);
+    if (existing)
+        return existing;
+    if (options.autoCreate)
+        return createSyncWorkspace(branchName, options.projectDir);
+    const available = branches.length > 0 ? ` Available branches: ${branches.join(', ')}` : '';
+    throw new SyncError(`Branch workspace "${branchName}" not found.${available}`);
 }
 /**
  * Push: copy working-tree content into a branch workspace and commit.
@@ -155,7 +311,6 @@ async function selectBranch(options, branchesDir) {
 async function syncPush(options) {
     const { projectDir } = options;
     const contentRoot = options.contentRoot || 'content';
-    const branchesDir = path.join(projectDir, '.canopy-dev', 'content-branches');
     // Validate source content BEFORE selectBranch, which may create a workspace —
     // a push with nothing to push must not leave side effects behind.
     const srcContentDir = path.join(projectDir, contentRoot);
@@ -163,11 +318,10 @@ async function syncPush(options) {
     if (!(await filePathExists(srcContentDir))) {
         throw new SyncError(`Content directory not found: ${contentRoot}/ (expected at ${srcContentDir})`);
     }
-    const branchName = await selectBranch({ ...options, projectDir, autoCreate: true }, branchesDir);
-    if (!branchName)
+    const ws = await selectBranch({ ...options, projectDir, autoCreate: true });
+    if (!ws)
         return { fileCount: 0 };
-    const branchPath = path.join(branchesDir, branchName);
-    assertWithinDir(branchPath, branchesDir, '--branch');
+    const { branchName, branchPath } = ws;
     const wsGit = simpleGit({ baseDir: branchPath });
     const status = await wsGit.status();
     if (status.conflicted.length > 0) {
@@ -235,18 +389,20 @@ async function syncPush(options) {
  * Pull: copy content from a branch workspace back into the working tree.
  */
 async function syncPull(options) {
+    const ws = await selectBranch({ ...options, projectDir: options.projectDir });
+    if (!ws)
+        return { fileCount: 0 };
+    return pullFromWorkspace(options, ws);
+}
+/** The body of {@link syncPull}, once its workspace is chosen. */
+async function pullFromWorkspace(options, ws) {
     const { projectDir } = options;
     const contentRoot = options.contentRoot || 'content';
-    const branchesDir = path.join(projectDir, '.canopy-dev', 'content-branches');
-    const branchName = await selectBranch({ ...options, projectDir }, branchesDir);
-    if (!branchName)
-        return { fileCount: 0 };
-    const branchPath = path.join(branchesDir, branchName);
-    assertWithinDir(branchPath, branchesDir, '--branch');
+    const { branchName, branchPath } = ws;
     const branchContentDir = path.join(branchPath, contentRoot);
     assertWithinDir(branchContentDir, branchPath, '--content-root');
     if (!(await filePathExists(branchContentDir))) {
-        throw new SyncError(`Content directory not found in branch workspace: ${branchName}/${contentRoot}`);
+        throw new SyncError(`Content directory not found in branch workspace: ${path.basename(branchPath)}/${contentRoot}`);
     }
     p.log.step(`Pulling content from branch: ${branchName}`);
     const destContentDir = path.join(projectDir, contentRoot);
@@ -342,18 +498,16 @@ async function syncPull(options) {
 async function syncBoth(options) {
     const { projectDir } = options;
     const contentRoot = options.contentRoot || 'content';
-    const branchesDir = path.join(projectDir, '.canopy-dev', 'content-branches');
     // Validate source content BEFORE selectBranch, which may create a workspace
     const srcContentDir = path.join(projectDir, contentRoot);
     assertWithinDir(srcContentDir, projectDir, '--content-root');
     if (!(await filePathExists(srcContentDir))) {
         throw new SyncError(`Content directory not found: ${contentRoot}/ (expected at ${srcContentDir})`);
     }
-    const branchName = await selectBranch({ ...options, projectDir, autoCreate: true }, branchesDir);
-    if (!branchName)
+    const ws = await selectBranch({ ...options, projectDir, autoCreate: true });
+    if (!ws)
         return { pushed: 0, pulled: 0 };
-    const branchPath = path.join(branchesDir, branchName);
-    assertWithinDir(branchPath, branchesDir, '--branch');
+    const { branchName, branchPath } = ws;
     const wsGit = simpleGit({ baseDir: branchPath });
     const status = await wsGit.status();
     if (status.conflicted.length > 0) {
@@ -375,7 +529,7 @@ async function syncBoth(options) {
 }
 /** The locked body of {@link syncBoth}: everything that rewrites the workspace. */
 async function mergeIntoWorkspace(options, ws) {
-    const { branchName, branchPath, srcContentDir, contentRoot } = ws;
+    const { branchPath, srcContentDir, contentRoot } = ws;
     const wsGit = simpleGit({ baseDir: branchPath });
     const status = await wsGit.status();
     // Auto-commit uncommitted workspace changes (preserves editor work for the merge)
@@ -421,7 +575,7 @@ async function mergeIntoWorkspace(options, ws) {
             await wsGit.checkout(currentBranch);
             await wsGit.raw(['branch', '-D', incomingBranch]);
             p.log.info('No working-tree changes to merge — pulling editor changes only');
-            const pullResult = await syncPull({ ...options, branch: branchName, force: true });
+            const pullResult = await pullFromWorkspace({ ...options, force: true }, ws);
             return { pushed: 0, pulled: pullResult.fileCount };
         }
         await wsGit.commit('sync: incoming working-tree changes');
@@ -446,8 +600,9 @@ async function mergeIntoWorkspace(options, ws) {
                     p.log.error(`  ${file}`);
                 }
                 p.log.info('The branch workspace is now in a merge state.');
-                p.log.info('Resolve the conflicts in the workspace, then run: canopycms sync pull');
-                p.log.info('Or abort the merge with: canopycms sync abort');
+                const branchFlag = options.branch ? ` --branch ${options.branch}` : '';
+                p.log.info(`Resolve the conflicts in the workspace, then run: canopycms sync pull${branchFlag}`);
+                p.log.info(`Or abort the merge with: canopycms sync abort${branchFlag}`);
                 // Clean up the incoming branch (leave merge state for user resolution)
                 await wsGit.raw(['branch', '-D', incomingBranch]).catch(() => { });
                 return { pushed: 0, pulled: 0 };
@@ -459,7 +614,7 @@ async function mergeIntoWorkspace(options, ws) {
         await wsGit.raw(['branch', '-D', incomingBranch]);
         await wsGit.tag(['-f', SYNC_BASE_TAG]);
         p.log.success('Merged working-tree changes with editor changes');
-        const pullResult = await syncPull({ ...options, branch: branchName, force: true });
+        const pullResult = await pullFromWorkspace({ ...options, force: true }, ws);
         return { pushed: incomingFiles.length, pulled: pullResult.fileCount };
     }
     finally {
@@ -471,13 +626,10 @@ async function mergeIntoWorkspace(options, ws) {
  * Restores the workspace to its pre-merge state.
  */
 async function syncAbort(options) {
-    const { projectDir } = options;
-    const branchesDir = path.join(projectDir, '.canopy-dev', 'content-branches');
-    const branchName = await selectBranch({ ...options, projectDir }, branchesDir);
-    if (!branchName)
+    const ws = await selectBranch({ ...options, projectDir: options.projectDir });
+    if (!ws)
         return;
-    const branchPath = path.join(branchesDir, branchName);
-    assertWithinDir(branchPath, branchesDir, '--branch');
+    const { branchName, branchPath } = ws;
     if (!(await abortWorkspaceMerge(branchPath, branchName))) {
         p.log.info(`Branch workspace "${branchName}" is not in a merge state — nothing to abort.`);
         return;

package/dist/config/types.d.ts

@@ -10,10 +10,10 @@ import type { PermissionPath } from '../authorization/types.js';
 import type { EntryLinkUrlResolver } from '../entry-link-resolver.js';
 import type { CropRect } from '../assets/transform-directives.js';
 import type { SeoFieldLocation } from '../static/seo.js';
-declare const scalarFieldTypes: readonly ["string", "number", "boolean", "datetime", "code"];
+declare const scalarFieldTypes: readonly ["string", "number", "boolean", "date", "datetime", "code"];
 export declare const markdownFieldTypes: readonly ["markdown", "mdx"];
-export declare const primitiveFieldTypes: readonly ["string", "number", "boolean", "datetime", "code", "markdown", "mdx"];
-export declare const fieldTypes: readonly ["string", "number", "boolean", "datetime", "code", "markdown", "mdx", "image", "select", "reference", "object", "block", "group"];
+export declare const primitiveFieldTypes: readonly ["string", "number", "boolean", "date", "datetime", "code", "markdown", "mdx"];
+export declare const fieldTypes: readonly ["string", "number", "boolean", "date", "datetime", "code", "markdown", "mdx", "image", "select", "reference", "object", "block", "group"];
 export type PrimitiveFieldType = (typeof primitiveFieldTypes)[number];
 export type FieldType = (typeof fieldTypes)[number];
 export type ContentFormat = 'md' | 'mdx' | 'json' | 'yaml';
@@ -211,7 +211,7 @@ export interface ObjectFieldConfig extends BaseFieldConfig {
     type: 'object';
     fields: FieldConfig[];
     /**
-     * On a `list: true` object, a direct `string` or `number` child whose value titles each
+     * On a `list: true` object, a direct `string`, `number` or `date` child whose value titles each
      * item's card; a blank or non-finite value falls back to the item's first non-blank `string`
      * field, then "Item N".
      */

package/dist/config/types.js

@@ -2,7 +2,7 @@
  * Type definitions for CanopyCMS configuration.
  * These are pure TypeScript types - Zod schemas are in ./schemas/
  */
-const scalarFieldTypes = ['string', 'number', 'boolean', 'datetime', 'code'];
+const scalarFieldTypes = ['string', 'number', 'boolean', 'date', 'datetime', 'code'];
 export const markdownFieldTypes = ['markdown', 'mdx'];
 export const primitiveFieldTypes = [...scalarFieldTypes, ...markdownFieldTypes];
 // 'image' is not a primitive: it has a structured value (ImageFieldValue) and

package/dist/config/validation.d.ts

@@ -34,9 +34,9 @@ export declare const ensureReferenceFieldsHaveScope: (fields: unknown) => void;
 export declare const forEachReferenceField: (fields: unknown, visit: (field: Record<string, unknown>) => void) => void;
 /**
  * Check that every `itemLabel` is non-blank text and, like every `itemTitleField`, sits on a
- * `list: true` object, and that every `itemTitleField` names a direct child of type `string` or
- * `number`, the only values the card heading shows as typed (a reference would show its raw id, a
- * select its stored value). Throws an error when it does not. Entry schemas reach the editor
+ * `list: true` object, and that every `itemTitleField` names a direct child of type `string`,
+ * `number` or `date`, the only values the card heading shows as typed (a reference would show its
+ * raw id, a select its stored value). Throws an error when it does not. Entry schemas reach the editor
  * through these checks, not the zod field schema.
  */
 export declare const ensureItemTitleFieldsExist: (fields: unknown) => void;
@@ -68,6 +68,12 @@ export declare const ensureStampOnPublishPlacement: (fields: unknown, scopeLabel
  * `ensureStampOnPublishPlacement`. Throws on the first problem.
  */
 export declare const ensureMaxItemsPlacement: (fields: unknown, scopeLabel?: string) => void;
+/**
+ * Check that no `date` field is `list: true`: the editor has one picker for one day, and an object
+ * list with a `date` child gives a list of days its rows. Recurses into groups, objects and block
+ * templates like `ensureStampOnPublishPlacement`. Throws on the first problem.
+ */
+export declare const ensureSingleDateFields: (fields: unknown, scopeLabel?: string) => void;
 /**
  * Check every markdown and mdx field's `mdxAllow` against its schema and its `renderAs`,
  * `mdxAllow` and `executable` against each other. Throws on the first problem.

package/dist/config/validation.js

@@ -110,9 +110,9 @@ export const forEachReferenceField = (fields, visit) => {
 };
 /**
  * Check that every `itemLabel` is non-blank text and, like every `itemTitleField`, sits on a
- * `list: true` object, and that every `itemTitleField` names a direct child of type `string` or
- * `number`, the only values the card heading shows as typed (a reference would show its raw id, a
- * select its stored value). Throws an error when it does not. Entry schemas reach the editor
+ * `list: true` object, and that every `itemTitleField` names a direct child of type `string`,
+ * `number` or `date`, the only values the card heading shows as typed (a reference would show its
+ * raw id, a select its stored value). Throws an error when it does not. Entry schemas reach the editor
  * through these checks, not the zod field schema.
  */
 export const ensureItemTitleFieldsExist = (fields) => {
@@ -140,8 +140,8 @@ export const ensureItemTitleFieldsExist = (fields) => {
                 if (typeof f.itemTitleField !== 'string' || !child) {
                     throw new Error(`${label}, which is not one of its child fields`);
                 }
-                if (child.type !== 'string' && child.type !== 'number') {
-                    throw new Error(`${label}, which must name a string or number field`);
+                if (child.type !== 'string' && child.type !== 'number' && child.type !== 'date') {
+                    throw new Error(`${label}, which must name a string, number or date field`);
                 }
             }
             ensureItemTitleFieldsExist(children);
@@ -327,6 +327,31 @@ export const ensureMaxItemsPlacement = (fields, scopeLabel = 'entry schema') =>
     };
     check(fields);
 };
+/**
+ * Check that no `date` field is `list: true`: the editor has one picker for one day, and an object
+ * list with a `date` child gives a list of days its rows. Recurses into groups, objects and block
+ * templates like `ensureStampOnPublishPlacement`. Throws on the first problem.
+ */
+export const ensureSingleDateFields = (fields, scopeLabel = 'entry schema') => {
+    const check = (scopeFields) => {
+        if (!Array.isArray(scopeFields))
+            return;
+        for (const field of scopeFields) {
+            const f = field;
+            if (f?.type === 'date' && f.list === true) {
+                throw new Error(`${scopeLabel}: field "${String(f.name)}" is a date with list: true; use an object list with a date field inside`);
+            }
+            if (f?.type === 'group' || f?.type === 'object')
+                check(f.fields);
+            if (f?.type === 'block' && Array.isArray(f.templates)) {
+                for (const template of f.templates) {
+                    check(template.fields);
+                }
+            }
+        }
+    };
+    check(fields);
+};
 /**
  * Check every markdown and mdx field's `mdxAllow` against its schema and its `renderAs`,
  * `mdxAllow` and `executable` against each other. Throws on the first problem.

package/dist/content-listing.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import matter from 'gray-matter';
 import { parse as yamlParse } from 'yaml';
 import { findBodyFieldName } from './utils/body-field.js';
+import { entryAsRead } from './utils/calendar-day.js';
 import { computeEntryUrl } from './utils/entry-url.js';
 import { asRecord, getFormatExtension } from './utils/format.js';
 import { resolveCollectionPath, toLogicalCollectionPath } from './content-id-index.js';
@@ -15,7 +16,6 @@ import { isNotFoundError, getErrorMessage } from './utils/error.js';
 import { createDebugLogger } from './utils/debug.js';
 import { ContentStore, ContentStoreError, createReferenceResolveCache, } from './content-store.js';
 import { isBuildMode } from './build-mode.js';
-import { withItemKeys } from './item-keys.js';
 const log = createDebugLogger({ prefix: 'ContentListing' });
 /** Validate and normalize `target` under `root`; throws ContentStoreError on a traversal. */
 const normalizePath = (root, target) => {
@@ -444,8 +444,7 @@ export const listCollectionEntries = async (root, collection, onSkip, readsId) =
             fs.stat(absolutePath),
             readEntryData(absolutePath, format, bodyField),
         ]);
-        // Keyed as `ContentStore.read` keys it, so every reader names an item alike.
-        const data = withItemKeys(entryType?.schema ?? [], rawData, 'content');
+        const data = entryAsRead(entryType?.schema ?? [], rawData);
         const item = {
             logicalPath: entryLogicalPath(collection.logicalPath, slug),
             contentId,

package/dist/content-store.js

@@ -21,7 +21,7 @@ import { serializeJson } from './utils/json-source-splice.js';
 import { withLock } from './utils/async-mutex.js';
 import { assertContentWriteLockHeld, ContentWriteLockBusyError, DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS, withContentWriteLock, } from './utils/content-write-lock.js';
 import { findBodyFieldName, linkOnlyReferenceData } from './utils/body-field.js';
-import { withItemKeys } from './item-keys.js';
+import { entryAsRead } from './utils/calendar-day.js';
 import { buildMissingReference, buildResolvedReference, buildRestrictedReference, } from './entry-schema.js';
 import { warnDanglingReference } from './dangling-reference-log.js';
 import { canopyLogError } from './utils/logger.js';
@@ -786,9 +786,9 @@ export class ContentStore {
                 absolutePath,
             };
         }
-        // Keys an item saved without one by its content, before references resolve into it, as the
-        // listing and the write path do (`item-keys.ts`).
-        doc.data = withItemKeys(fields, doc.data, 'content');
+        // Before references resolve into it. An item saved without a key is keyed by its content, as
+        // the listing and the write path do (`item-keys.ts`).
+        doc.data = entryAsRead(fields, doc.data);
         if (options.resolveReferences !== false) {
             doc.data = await this.resolveReferencesInData(doc.data, fields, undefined, options.referenceAccess, {
                 entry: slug ? entryLogicalPath(schemaItem.logicalPath, slug) : schemaItem.logicalPath,
@@ -1031,7 +1031,7 @@ export class ContentStore {
                         content = serializeYaml(input.data ?? {}, existingRaw);
                     }
                     else {
-                        content = serializeFrontmatter(input.body, input.data ?? {}, existingRaw, input.format);
+                        content = serializeFrontmatter(input.body, input.data ?? {}, existingRaw, input.format, fields);
                     }
                     await atomicWriteFile(absolutePath, content);
                     // Update the ID index after a successful write. Look up and mutate the LIVE index

package/dist/editor/FormRenderer.js

@@ -12,6 +12,7 @@ import { TextField } from './fields/TextField.js';
 import { ToggleField } from './fields/ToggleField.js';
 import { NumberField } from './fields/NumberField.js';
 import { NumberListField } from './fields/NumberListField.js';
+import { DateField } from './fields/DateField.js';
 import { DateTimeField } from './fields/DateTimeField.js';
 import { BlockField } from './fields/BlockField.js';
 import { SelectField } from './fields/SelectField.js';
@@ -53,6 +54,8 @@ const normalizeOptions = (options) => {
     return options.map((opt) => (typeof opt === 'string' ? { label: opt, value: opt } : opt));
 };
 const fieldKey = (path) => formatCanopyPath(path);
+/** A value of another type as text, for `DateField` to quote: the form cannot save it. */
+const dateFieldText = (value) => typeof value === 'string' ? value : value == null ? '' : JSON.stringify(value);
 const noop = () => { };
 const FENCE_STYLE = { border: 0, padding: 0, margin: 0, minWidth: 0 };
 const READ_ONLY_FORM_CLASS = 'canopy-read-only-form';
@@ -214,6 +217,8 @@ export const FormRenderer = ({ fields, value, onChange, customRenderers, branch
                             : [], onChange: (v) => update(v), dataCanopyField: normalizeCanopyPath(path), readOnly: readOnly, maxItems: field.maxItems }, fieldKey(path)));
                 }
                 return wrapWithComments(_jsx(NumberField, { id: fieldId, label: label, description: field.description, value: typeof currentValue === 'number' ? currentValue : undefined, onChange: (v) => update(v), dataCanopyField: normalizeCanopyPath(path), readOnly: readOnly }, fieldKey(path)));
+            case 'date':
+                return wrapWithComments(_jsx(DateField, { id: fieldId, label: label, description: field.description, value: dateFieldText(currentValue), onChange: (v) => update(v), dataCanopyField: normalizeCanopyPath(path), readOnly: readOnly, required: field.required === true }, fieldKey(path)));
             case 'datetime':
                 return wrapWithComments(_jsx(DateTimeField, { id: fieldId, label: label, description: field.description, value: typeof currentValue === 'string' ? currentValue : '', onChange: (v) => update(v), dataCanopyField: normalizeCanopyPath(path), readOnly: readOnly, stampOnPublish: 'stampOnPublish' in field && field.stampOnPublish === true }, fieldKey(path)));
             case 'markdown':

package/dist/editor/components/EntryChangesDrawer.js

@@ -266,9 +266,10 @@ const Value = ({ value, alt, }) => {
 };
 /**
  * A date in full, in the viewer's time zone: a comparison needs the value, so this is the one
- * place the editor shows a date absolute first and relative after.
+ * place the editor shows a date absolute first and relative after. A day has no relative form: it
+ * may be a future event, and a past one is not hours ago.
  */
-const DateValue = ({ value, text }) => (_jsxs(Stack, { gap: 0, children: [_jsx(Text, { size: "sm", style: TEXT_STYLE, children: text ?? value.text }), _jsx(Text, { size: "xs", c: "dimmed", children: formatRelativeTime(value.dateOnly ? `${value.iso}T00:00:00` : value.iso) })] }));
+const DateValue = ({ value, text }) => (_jsxs(Stack, { gap: 0, children: [_jsx(Text, { size: "sm", style: TEXT_STYLE, children: text ?? value.text }), !value.dateOnly && (_jsx(Text, { size: "xs", c: "dimmed", children: formatRelativeTime(value.iso) }))] }));
 const SideColumn = ({ label, change, side, }) => {
     const value = change[side] ?? { kind: 'empty' };
     const words = change.text?.mode === 'words' ? change.text : undefined;