@geekity/cms 0.3.0 → 0.5.0

package/dist/admin/documents.js

@@ -2,11 +2,19 @@ import { mkdir, readFile, rename, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { parseDocument } from '../content/parser.js';
 import { contentFilePath, freeSlug, saveDocument } from '../content/save.js';
+import { scheduledFor } from '../content/schedule.js';
 import { defaultPermalink, slugify } from '../content/slug.js';
 import { DuplicatePermalinkError, isTrashedPath, TRASH_DIRECTORY } from '../content/store.js';
+import { calendarDayIn, DEFAULT_TIMEZONE, toUtcInstant, wallClockIn, zoneLabel, } from '../content/time.js';
 import { normalizeBody, serializeDocument } from '../content/writer.js';
 import { isPublicDocument } from '../web/documents.js';
+import { COMMENTS_FRONT_MATTER_KEY } from '../comments/policy.js';
+import { CONTACT_FRONT_MATTER_KEY } from '../contact/form.js';
+import { userForAuthor } from '../web/authors.js';
+import { findUserById, listUsers } from './accounts.js';
 import { flash } from './flash.js';
+import { formatInTimezone } from './formatting.js';
+import { readSiteSettings } from './settings.js';
 import { PREVIEW_PATH } from './preview.js';
 import { ADMIN_PREFIX } from './session.js';
 import { ADMIN_TEMPLATES } from './templates.js';
@@ -19,7 +27,30 @@ import { UPLOADS_PATH } from './uploads.js';
  * there, alongside every other key somebody added by hand.
  */
 export const EXCLUDE_KEY = 'eleventyExcludeFromCollections';
-/** The posts screens: dated, tagged, filed under `posts/`. */
+/**
+ * What the editor's Comments field can say: leave it to the site's rules, hold
+ * this document open, or close it.
+ *
+ * The values are the strings the form submits and the template renders as
+ * options, spelled once so the two cannot drift.
+ */
+export const COMMENT_SETTINGS = { site: '', open: 'open', closed: 'closed' };
+/** A submitted Comments field, or the site default for anything else. */
+function commentSetting(value) {
+    return value === COMMENT_SETTINGS.open || value === COMMENT_SETTINGS.closed
+        ? value
+        : COMMENT_SETTINGS.site;
+}
+/** What a document's front matter already says about comments. */
+function commentSettingOf(document) {
+    const own = document.extra[COMMENTS_FRONT_MATTER_KEY];
+    if (own === true)
+        return COMMENT_SETTINGS.open;
+    if (own === false)
+        return COMMENT_SETTINGS.closed;
+    return COMMENT_SETTINGS.site;
+}
+/** The posts screens: dated, tagged, categorised, filed under `posts/`. */
 export const POST_KIND = {
     type: 'post',
     section: 'posts',
@@ -28,7 +59,9 @@ export const POST_KIND = {
     plural: 'Posts',
     dated: true,
     tagged: true,
+    categorised: true,
     excludable: false,
+    contactable: false,
 };
 /** The pages screens: standing content, no date prefix and no taxonomy. */
 export const PAGE_KIND = {
@@ -39,7 +72,9 @@ export const PAGE_KIND = {
     plural: 'Pages',
     dated: false,
     tagged: false,
+    categorised: false,
     excludable: true,
+    contactable: true,
 };
 /** The URL of the editor for one document. */
 export function editorPath(kind, slug) {
@@ -50,7 +85,13 @@ export function newEditorPath(kind) {
     return `${kind.basePath}/new`;
 }
 /** The filters, in the order they are shown. */
-export const DOCUMENT_FILTERS = ['all', 'published', 'draft', 'trash'];
+export const DOCUMENT_FILTERS = [
+    'all',
+    'published',
+    'scheduled',
+    'draft',
+    'trash',
+];
 /** How many rows one page of a listing holds. */
 export const DOCUMENTS_PER_PAGE = 25;
 /** The filter a query string asked for, defaulting to everything live. */
@@ -62,7 +103,8 @@ export function listOptionsFor(kind, filter) {
     return {
         type: kind.type,
         trashed: filter === 'trash',
-        ...(filter === 'published' ? { draft: false } : {}),
+        ...(filter === 'published' ? { draft: false, scheduled: false } : {}),
+        ...(filter === 'scheduled' ? { draft: false, scheduled: true } : {}),
         ...(filter === 'draft' ? { draft: true } : {}),
     };
 }
@@ -72,7 +114,7 @@ export function listOptionsFor(kind, filter) {
  * Both `/admin/posts` and `/admin/pages` are this function with a different
  * {@link DocumentKind}: the screens, the templates and the write path are
  * shared, and the kind decides what a file is called, whether the form has a
- * date and tags, and which section of the navigation marks itself.
+ * date and a taxonomy, and which section of the navigation marks itself.
  */
 export function mountDocumentScreens(app, options) {
     const { kind, render } = options;
@@ -89,6 +131,7 @@ export function mountDocumentScreens(app, options) {
         const rows = found.slice(0, DOCUMENTS_PER_PAGE);
         return render(c, ADMIN_TEMPLATES.documentList, {
             section: kind.section,
+            child: 'all',
             kind,
             filter,
             filters: DOCUMENT_FILTERS.map((name) => ({
@@ -97,7 +140,7 @@ export function mountDocumentScreens(app, options) {
                 url: listingUrl(kind, name, 1),
                 current: name === filter,
             })),
-            documents: rows.map((document) => listRow(kind, document)),
+            documents: rows.map((document) => listRow(kind, document, c.var.store.now(), pageRole(kind, document, c))),
             newUrl: newEditorPath(kind),
             returnUrl: listingUrl(kind, filter, pageNumber),
             page: pageNumber,
@@ -111,14 +154,14 @@ export function mountDocumentScreens(app, options) {
         kind,
         render,
         document: undefined,
-        form: blankForm(kind),
+        form: blankForm(kind, siteTimezone(c), c.var.store.now()),
     }));
     app.post(newEditorPath(kind), async (c) => saveFromForm(c, { kind, render, document: undefined, body: await c.req.parseBody() }));
     app.get(`${kind.basePath}/:slug`, (c) => {
         const document = findBySlug(c.var.store, kind, c.req.param('slug'));
         if (document === undefined)
             return c.notFound();
-        return renderEditor(c, { kind, render, document, form: formFor(document) });
+        return renderEditor(c, { kind, render, document, form: formFor(document, siteTimezone(c)) });
     });
     app.post(`${kind.basePath}/:slug`, async (c) => {
         const document = findBySlug(c.var.store, kind, c.req.param('slug'));
@@ -151,9 +194,13 @@ async function saveFromForm(c, options) {
         permalink: text(body['permalink']).trim(),
         date: text(body['date']).trim(),
         tags: text(body['tags']).trim(),
+        categories: text(body['categories']).trim(),
         description: text(body['description']).trim(),
+        author: text(body['author']).trim(),
         draft: body['draft'] !== undefined,
         exclude: body['exclude'] !== undefined,
+        contact: body['contact'] !== undefined,
+        comments: commentSetting(text(body['comments'])),
         body: normalizeBody(text(body['body'])),
         hash: text(body['hash']),
     };
@@ -173,19 +220,57 @@ async function saveFromForm(c, options) {
     }
     if (form.title === '')
         return refuse(`A ${kind.singular} needs a title.`);
-    const date = kind.dated ? (form.date === '' ? new Date().toISOString() : form.date) : undefined;
-    if (date !== undefined && !/^\d{4}-\d{2}-\d{2}/.test(date)) {
+    const timezone = siteTimezone(c);
+    // decision-11: what the file gets is a UTC instant, and an offset-less field
+    // is the site's own wall clock rather than the server's.
+    const typed = kind.dated ? (form.date === '' ? store.now().toISOString() : form.date) : undefined;
+    if (typed !== undefined && !/^\d{4}-\d{2}-\d{2}/.test(typed)) {
         return refuse('A date has to start with a year, a month and a day, like 2026-03-04.');
     }
+    const date = typed === undefined ? undefined : toUtcInstant(typed, timezone);
+    if (typed !== undefined && date === undefined) {
+        return refuse('That date is not one anybody can read. Try 2026-03-04 09:00.');
+    }
     const slug = slugify(form.slug) || slugify(form.title) || (document?.slug ?? '') || 'untitled';
     const trashed = document !== undefined && isTrashedPath(document.path);
+    // The calendar day the document is filed under: the site zone's day at its
+    // date for a new one, and the day already in the filename for one whose date
+    // has not moved, so a zone changed later never moves a URL that exists.
+    const filed = filedDay({ date, document, timezone });
     // A new document gets out of the way of anything that already holds its
     // name; an existing one keeps the slug it was given.
     const finalSlug = document === undefined
-        ? await freeSlug({ contentDir, store, type: kind.type, slug, date })
+        ? await freeSlug({ contentDir, store, type: kind.type, slug, date: filed })
         : slug;
-    const permalink = resolvePermalink({ kind, form, slug: finalSlug, date, document });
-    const target = documentPath({ kind, slug: finalSlug, date, trashed });
+    // decision-13: a published post's permalink is its name in the fediverse as
+    // well as on the web, and the two are one promise. Moving it hands every
+    // follower a second object and breaks every link somebody already shared, so
+    // the editor refuses. A draft has promised nothing yet and may still move;
+    // a site that really means to move a published post can still do it in the
+    // file, knowing what it costs.
+    const promised = promisedDocument(kind, document, store.now());
+    if (promised !== undefined) {
+        if (finalSlug !== promised.slug) {
+            return refuse(`The permalink of a published post is permanent, and the slug names the file it is filed under: this ${kind.singular} keeps the slug ${promised.slug}.`);
+        }
+        // An empty field is not a request to move: it is a form that carried no
+        // permalink, and the promised one is what it keeps. Only a field naming
+        // some other URL is somebody asking for the one thing this refuses.
+        const submitted = normalizePermalink(form.permalink);
+        if (submitted !== undefined && submitted !== promised.permalink) {
+            return refuse(`The permalink of a published post is permanent: this ${kind.singular} stays at ${promised.permalink}.`);
+        }
+    }
+    const permalink = promised?.permalink ??
+        resolvePermalink({
+            kind,
+            form,
+            slug: finalSlug,
+            date: filed,
+            document,
+            timezone,
+        });
+    const target = documentPath({ kind, slug: finalSlug, date: filed, trashed });
     if (document !== undefined) {
         const conflict = await conflictWith(contentDir, document, form.hash);
         if (conflict !== undefined) {
@@ -198,14 +283,15 @@ async function saveFromForm(c, options) {
     const content = {
         title: form.title,
         ...(date === undefined ? {} : { date }),
-        updated: new Date().toISOString(),
+        updated: store.now().toISOString(),
         permalink,
         tags: kind.tagged ? splitTags(form.tags) : [],
+        categories: kind.categorised ? splitTags(form.categories) : [],
         draft,
         ...(form.description === '' ? {} : { description: form.description }),
-        ...optional('author', document?.author ?? currentUsername(c)),
+        ...optional('author', chosenAuthor(c, form.author, document)),
         ...optional('activitypub', document?.activitypub),
-        extra: resolveExtra(kind, document, form.exclude),
+        extra: resolveExtra(kind, document, form),
         body: form.body,
     };
     // The row for the old path goes first: a rename briefly leaves two rows
@@ -215,7 +301,7 @@ async function saveFromForm(c, options) {
         store.remove(renamedFrom.path);
     let saved;
     try {
-        saved = await saveDocument({ contentDir, store, path: target, content });
+        saved = await saveDocument({ contentDir, store, path: target, content, timezone });
     }
     catch (error) {
         // Nothing was written, so the row that was taken out of the way goes back.
@@ -241,13 +327,18 @@ async function saveFromForm(c, options) {
         next: saved,
         origin: 'admin',
     });
-    flash(c, 'notice', savedMessage(kind, document, saved));
+    flash(c, 'notice', savedMessage(kind, document, saved, store.now()));
     return c.redirect(editorPath(kind, saved.slug), 303);
 }
 /** What the flash says after a save, which depends on what the save did. */
-function savedMessage(kind, previous, saved) {
+function savedMessage(kind, previous, saved, now) {
     if (saved.draft)
         return `Draft saved: ${saved.title}`;
+    // A date in the future is not a refusal to publish, it is an instruction
+    // about when, and the flash has to say so or the author will think the
+    // Publish button did nothing.
+    if (scheduledFor(saved, now) !== undefined)
+        return `Scheduled: ${saved.title}`;
     if (previous === undefined || previous.draft)
         return `Published: ${saved.title}`;
     return `Updated: ${saved.title}`;
@@ -257,6 +348,21 @@ function documentPath(input) {
     const relative = contentFilePath({ type: input.kind.type, slug: input.slug, date: input.date });
     return input.trashed ? `${TRASH_DIRECTORY}/${relative}` : relative;
 }
+/**
+ * The document whose permalink has already been promised, or `undefined` when
+ * nothing has been promised yet.
+ *
+ * A published post, and only a published post. decision-13 makes its permalink
+ * its ActivityStreams object id, so the URL is a name its followers, its
+ * replies and its feed subscribers are all holding; a draft, a trashed post
+ * and one whose date has not arrived have been shown to nobody, and a page
+ * federates nothing at all.
+ */
+function promisedDocument(kind, document, now) {
+    if (document === undefined || kind.type !== 'post')
+        return undefined;
+    return isPublicDocument(document, now) ? document : undefined;
+}
 /**
  * The permalink to write.
  *
@@ -276,20 +382,60 @@ function resolvePermalink(input) {
     if (submitted === undefined)
         return fallback;
     const document = input.document;
-    if (document !== undefined && submitted === previousDefaultPermalink(input.kind, document)) {
+    if (document !== undefined &&
+        submitted === previousDefaultPermalink(input.kind, document, input.timezone)) {
         return fallback;
     }
     return submitted;
 }
-/** The permalink a document would have had if it had never been customised. */
-function previousDefaultPermalink(kind, document) {
+/**
+ * The permalink a document would have had if it had never been customised:
+ * its own slug over the day it is filed under, which is the day in its
+ * filename rather than one re-derived from a setting that may have moved.
+ */
+function previousDefaultPermalink(kind, document, timezone) {
     try {
-        return defaultPermalink({ type: kind.type, slug: document.slug, date: document.date });
+        return defaultPermalink({
+            type: kind.type,
+            slug: document.slug,
+            date: filedDay({ date: document.date, document, timezone }),
+        });
     }
     catch {
         return undefined;
     }
 }
+/**
+ * The calendar day a document is filed under, which is what its filename and
+ * its `/{yyyy}/{mm}/` permalink are cut from.
+ *
+ * For a new document it is the day the site's own zone was on at its date, so
+ * a post published at half past midnight on 1 October in Berlin is filed under
+ * October rather than the September UTC was still on.
+ *
+ * For a document whose date has not moved it is the day already in its
+ * filename. That is the whole of decision-11's promise that changing the
+ * timezone setting cannot move an existing URL: the instant is the same, the
+ * zone is a lens, and the day this post was filed under was decided once, when
+ * it was written, and is on disk where no setting can reach it.
+ */
+function filedDay(input) {
+    const { document } = input;
+    const date = input.date === undefined ? undefined : toUtcInstant(input.date, input.timezone);
+    if (date === undefined)
+        return undefined;
+    const was = document?.date === undefined ? undefined : toUtcInstant(document.date, input.timezone);
+    if (was === date) {
+        const existing = /(?:^|\/)(\d{4}-\d{2}-\d{2})-/.exec(document?.path ?? '')?.[1];
+        if (existing !== undefined)
+            return existing;
+    }
+    return calendarDayIn(date, input.timezone) ?? date;
+}
+/** The site's time zone, which is what every offset-less date in the admin means. */
+function siteTimezone(c) {
+    return readSiteSettings(c.var.config.contentDir).timezone;
+}
 /** A submitted permalink as a URL path, or `undefined` when the field is empty. */
 function normalizePermalink(value) {
     const trimmed = value.trim();
@@ -314,17 +460,38 @@ function normalizePermalink(value) {
  * the `false` is written, because a key somebody wrote by hand is not the
  * editor's to delete.
  */
-function resolveExtra(kind, document, exclude) {
+function resolveExtra(kind, document, form) {
     const extra = { ...(document?.extra ?? {}) };
-    if (!kind.excludable)
-        return extra;
-    if (exclude)
-        extra[EXCLUDE_KEY] = true;
-    else if (EXCLUDE_KEY in extra)
-        extra[EXCLUDE_KEY] = false;
+    // The post's own answer about comments, or none at all: "site default" is
+    // the absence of the key rather than a value, because that is what every
+    // reader of it — the CMS, an Eleventy build, a person looking at the file —
+    // already understands, and writing `comments: null` would say nothing new.
+    if (form.comments === COMMENT_SETTINGS.open)
+        extra[COMMENTS_FRONT_MATTER_KEY] = true;
+    else if (form.comments === COMMENT_SETTINGS.closed)
+        extra[COMMENTS_FRONT_MATTER_KEY] = false;
+    else
+        delete extra[COMMENTS_FRONT_MATTER_KEY];
+    if (kind.excludable) {
+        if (form.exclude)
+            extra[EXCLUDE_KEY] = true;
+        else if (EXCLUDE_KEY in extra)
+            extra[EXCLUDE_KEY] = false;
+    }
+    if (kind.contactable) {
+        // Written or removed, never `false`: it is the CMS's own key, and absent
+        // and false mean the same thing to everything that reads it (TASK-56).
+        if (form.contact)
+            extra[CONTACT_FRONT_MATTER_KEY] = true;
+        else
+            delete extra[CONTACT_FRONT_MATTER_KEY];
+    }
     return extra;
 }
-/** A comma-separated tag field as a list, without the blanks and the repeats. */
+/**
+ * A comma-separated taxonomy field as a list, without the blanks and the
+ * repeats. Tags and categories are both entered this way.
+ */
 export function splitTags(value) {
     const tags = [];
     for (const tag of value.split(',')) {
@@ -339,7 +506,62 @@ function currentUsername(c) {
     const userId = c.var.session?.userId;
     if (userId == null)
         return undefined;
-    return c.var.admin.getUserById(userId)?.username;
+    return findUserById(c.var.config.dataDir, userId)?.username;
+}
+/**
+ * What a save writes into the front matter's `author`.
+ *
+ * The submitted value is resolved through the same rule the public site reads
+ * it by ({@link userForAuthor}), and what is written is that user's login: so
+ * a file carrying a display name from before decision-14 is rewritten as a
+ * username the first time somebody saves it, which is exactly the "until it is
+ * next saved" doc-2 promises.
+ *
+ * A value naming nobody this site has changes nothing. There is no form this
+ * CMS renders that could submit one — the select only ever offers the users
+ * and, for a file that names a stranger, that file's own value — so the case
+ * is either a hand-made request or a user deleted between the load and the
+ * save, and neither is a reason to reattribute somebody's post.
+ */
+function chosenAuthor(c, submitted, document) {
+    const named = userForAuthor(listUsers(c.var.config.dataDir), submitted);
+    if (named !== undefined)
+        return named.username;
+    return document?.author ?? currentUsername(c);
+}
+/**
+ * The Author select: every user, whoever the document names, and — for a file
+ * naming somebody with no account here — that name too.
+ *
+ * The stranger's option is what keeps the editor honest. Without it, opening a
+ * post written by a colleague whose account has gone and pressing Update would
+ * quietly move the post to whoever happened to be first in the list; with it,
+ * the form submits back what the file says and changing the attribution stays
+ * a thing somebody chose to do.
+ *
+ * A new document starts on the signed-in user, which is what doc-5 says the
+ * editor does and what {@link blankForm} deliberately leaves to a request.
+ */
+export function authorChoices(c, current) {
+    const users = listUsers(c.var.config.dataDir);
+    const named = userForAuthor(users, current);
+    const chosen = named?.username ?? (current === '' ? currentUsername(c) : current);
+    const choices = users.map((user) => ({
+        value: user.username,
+        label: authorLabel(user),
+        chosen: user.username === chosen,
+    }));
+    // A name the file holds that is nobody here: offered last, and marked, so it
+    // is plain that the post is attributed to somebody this site cannot reach.
+    if (named === undefined && current !== '') {
+        choices.push({ value: current, label: `${current} (no account here)`, chosen: true });
+    }
+    return choices;
+}
+/** How one user reads in the select: their name, and the login behind it. */
+function authorLabel(user) {
+    const displayName = user.profile?.displayName;
+    return displayName === undefined ? user.username : `${displayName} (${user.username})`;
 }
 /**
  * Whether the file has moved on since the form loaded, per doc-1: files win,
@@ -385,16 +607,19 @@ function renderConflict(c, options) {
         ...(form.date === '' ? {} : { date: form.date }),
         permalink: form.permalink === '' ? document.permalink : form.permalink,
         tags: kind.tagged ? splitTags(form.tags) : [],
+        categories: kind.categorised ? splitTags(form.categories) : [],
         draft: form.draft,
         ...(form.description === '' ? {} : { description: form.description }),
         ...optional('author', document.author),
         ...optional('activitypub', document.activitypub),
-        extra: resolveExtra(kind, document, form.exclude),
+        extra: resolveExtra(kind, document, form),
         body: form.body,
     });
     c.status(409);
     return options.render(c, ADMIN_TEMPLATES.documentConflict, {
         section: kind.section,
+        // Editing something that exists, so the listing is where the menu stands.
+        child: 'all',
         kind,
         form,
         // The hash the file has now, so resubmitting this form is a deliberate
@@ -485,32 +710,56 @@ function optional(key, value) {
 function text(value) {
     return typeof value === 'string' ? value : '';
 }
-/** The editor for a document that does not exist yet. */
-export function blankForm(kind) {
+/**
+ * The editor for a document that does not exist yet.
+ *
+ * The date field is filled in with the clock as the site's own zone reads it,
+ * not with an instant: what a form offers is what a form takes back, and per
+ * decision-11 an offset-less date in this field means the site's zone.
+ */
+export function blankForm(kind, timezone = DEFAULT_TIMEZONE, now = new Date()) {
     return {
         title: '',
         slug: '',
         permalink: '',
-        date: kind.dated ? new Date().toISOString() : '',
+        date: kind.dated ? wallClockIn(now, timezone) : '',
         tags: '',
+        categories: '',
         description: '',
+        // Empty rather than the signed-in user: `blankForm` is a pure function
+        // over a kind and a clock, and who is signed in is a fact about a request.
+        // {@link authorChoices} is where the default is applied.
+        author: '',
         draft: false,
         exclude: false,
+        contact: false,
+        comments: COMMENT_SETTINGS.site,
         body: '',
         hash: '',
     };
 }
-/** The editor for a document that does. */
-export function formFor(document) {
+/**
+ * The editor for a document that does.
+ *
+ * The stored instant is shown as the clock in the site's zone reads it, and
+ * {@link wallClockIn} keeps whatever precision the instant has, so a form
+ * submitted with the field untouched writes back the very instant it was
+ * filled in from.
+ */
+export function formFor(document, timezone = DEFAULT_TIMEZONE) {
     return {
         title: document.title,
         slug: document.slug,
         permalink: document.permalink,
-        date: document.date ?? '',
+        date: document.date === undefined ? '' : wallClockIn(document.date, timezone),
         tags: document.tags.join(', '),
+        categories: document.categories.join(', '),
         description: document.description ?? '',
+        author: document.author ?? '',
         draft: document.draft,
         exclude: document.extra[EXCLUDE_KEY] === true,
+        contact: document.extra[CONTACT_FRONT_MATTER_KEY] === true,
+        comments: commentSettingOf(document),
         body: document.body,
         hash: document.hash,
     };
@@ -526,6 +775,11 @@ export function formFor(document) {
 function renderEditor(c, options) {
     const { kind, document, form } = options;
     const trashed = document !== undefined && isTrashedPath(document.path);
+    const now = c.var.store.now();
+    const timezone = siteTimezone(c);
+    // Printed in the site's own time zone rather than in UTC: an author who
+    // scheduled a post for nine in the morning meant their own morning.
+    const scheduledAt = document === undefined || trashed || document.draft ? undefined : scheduledFor(document, now);
     const actions = [];
     if (document === undefined || document.draft) {
         actions.push({ value: 'save-draft', label: 'Save draft' });
@@ -542,16 +796,26 @@ function renderEditor(c, options) {
         c.status(options.status);
     return options.render(c, ADMIN_TEMPLATES.documentEditor, {
         section: kind.section,
+        // The blank form is Add new; editing one that exists is still All posts,
+        // the way WordPress leaves the listing marked while you are in the editor.
+        child: document === undefined ? 'new' : 'all',
         kind,
         form,
         actions,
         trashed,
+        commentSettings: COMMENT_SETTINGS,
+        // Who this can be attributed to, and who it is attributed to now.
+        authors: authorChoices(c, form.author),
         heading: document === undefined ? `Add ${kind.singular}` : `Edit ${kind.singular}: ${document.title}`,
         saveUrl: document === undefined ? newEditorPath(kind) : editorPath(kind, document.slug),
         listUrl: kind.basePath,
         previewUrl: PREVIEW_PATH,
         uploadUrl: UPLOADS_PATH,
-        viewUrl: document !== undefined && isPublicDocument(document) ? document.permalink : undefined,
+        viewUrl: document !== undefined && isPublicDocument(document, now) ? document.permalink : undefined,
+        // Named beside the date field, because a wall clock with no zone on it is
+        // exactly the ambiguity decision-11 exists to remove.
+        ...(kind.dated ? { dateZone: zoneLabel(form.date === '' ? now : form.date, timezone) } : {}),
+        ...(scheduledAt === undefined ? {} : { scheduledFor: formatInTimezone(scheduledAt, timezone) }),
         ...(options.error === undefined ? {} : { error: options.error }),
     });
 }
@@ -576,13 +840,33 @@ export function findBySlug(store, kind, slug) {
     }
     return undefined;
 }
-function listRow(kind, document) {
-    const isPublic = isPublicDocument(document);
+/**
+ * WordPress's own two labels for the pages the Reading setting names, beside
+ * the title on the pages screen, so it is plain from the list which page is
+ * the front page and which carries the posts.
+ */
+export const PAGE_ROLE_LABELS = { homepage: 'Front Page', postsPage: 'Posts Page' };
+/** What one row's page is to the site, if anything. */
+function pageRole(kind, document, c) {
+    if (kind.type !== 'page')
+        return undefined;
+    const settings = readSiteSettings(c.var.config.contentDir);
+    if (settings.homepage === '')
+        return undefined;
+    if (document.slug === settings.homepage)
+        return PAGE_ROLE_LABELS.homepage;
+    if (document.slug === settings.postsPage)
+        return PAGE_ROLE_LABELS.postsPage;
+    return undefined;
+}
+function listRow(kind, document, now, role) {
+    const isPublic = isPublicDocument(document, now);
     return {
         title: document.title,
         slug: document.slug,
         author: document.author,
         tags: document.tags.join(', '),
+        categories: document.categories.join(', '),
         date: document.date,
         // Both come out of the index, so the listing costs no reads of its own.
         // A page that has never been saved through the admin has no `updated`, and
@@ -590,13 +874,16 @@ function listRow(kind, document) {
         updated: document.updated ?? document.date,
         draft: document.draft,
         trashed: isTrashedPath(document.path),
+        scheduled: scheduledFor(document, now) !== undefined,
         editUrl: editorPath(kind, document.slug),
         viewUrl: isPublic ? document.permalink : undefined,
+        role,
     };
 }
 const FILTER_LABELS = {
     all: 'All',
     published: 'Published',
+    scheduled: 'Scheduled',
     draft: 'Drafts',
     trash: 'Trash',
 };