@graview/core 0.1.28 → 0.1.30

package/dist/document/edit.js

@@ -1,26 +1,37 @@
+import { DERIVED_ACTS, derivedActOf, derivedActsOf, givenWhenNeverArchived, givenWhenNeverTidied } from "../mutations/derived-names.js";
 import { z } from "zod";
 import { ExprSyntaxError, parseExpr } from "./expr/parse.js";
 import { printExpr } from "./expr/print.js";
 import { error } from "./findings.js";
 import { coerce } from "./migrate.js";
 import { outsideRange, rangeWords } from "./range.js";
+import { formatWords } from "./format-words.js";
+import { formatFits, formatMisplaced } from "./format-rules.js";
+/** Why a format is refused where it does not fit, in the checker's words (`field-format`). */
+const refusedFormat = (format, type) => {
+    const { sentence, fix } = formatMisplaced(format, type);
+    return `${sentence}; ${fix}`;
+};
 import { farEnd } from "./far-end.js";
 import { ActSpec, EDGE_NAME, EdgeSpec, FIELD_NAME, FIELD_TYPES, FieldSpec, GrantSpec, KindSpec, NAME, RuleSpec, SightSpec, } from "./schema.js";
 import { SHIPPED_LENSES, isShippedLens, SHIPPED_LENS_NAMES } from "../places.js";
 import { placeSlug } from "../views/types.js";
+import { documentListFields, kindListFindings, kindListWords, listGroup, listSort, sortTypeOfDocumentField } from "../kind-list.js";
 import { computedOf, validateComputed } from "./computed.js";
 import { parseTemplate, templateBraces, TemplateError } from "./template-parse.js";
 import { validateViews, VIEW_SLOTS } from "./views.js";
-import { brandFindings } from "./brand-check.js";
+import { brandFindings, emojiIconSentence } from "./brand-check.js";
+import { emojiOf } from "../theme/marks.js";
 import { canonicalize } from "./canonical.js";
 import { quotedAtTheEnd } from "./quote.js";
 import { isRecord as isObject, respellDocument } from "./respell.js";
 import { refName } from "./compiled.js";
+import { localeSentence } from "./diff.js";
 import { accentProblem } from "../theme/accent.js";
 import { pageFieldFindings, pageNames, renamedOnPage, withoutOnPage } from "./page-fields.js";
 import { capitalize, listed as listOf } from "../capital.js";
 import { quoted } from "./quote.js";
-import { FIRST_GRANT, FIRST_SIGHT, grantBody, grantGone, grantSentence, NO_GRANT_LEFT, NO_SIGHT_LEFT, peopleKinds, peopleSentence, nounWords, pluralWords as pluralOf, sightGone, sightSentence, sightWords, whoWords } from "./policy-words.js";
+import { FIRST_GRANT, FIRST_SIGHT, grantBody, grantGone, grantSentence, NO_GRANT_LEFT, NO_SIGHT_LEFT, peopleKinds, peopleSentence, archivesSentence, tidyingSentence, nounWords, pluralWords as pluralOf, sightGone, sightSentence, sightWords, whoWords } from "./policy-words.js";
 /** The ops, for tool schemas and the guide. */
 export const EDIT_OPS = [
     "add-kind",
@@ -31,8 +42,10 @@ export const EDIT_OPS = [
     "retype-field",
     "set-options",
     "set-range",
+    "set-format",
     "set-required",
     "set-default",
+    "set-repeats",
     "remove-field",
     "add-relation",
     "rename-relation",
@@ -51,10 +64,13 @@ export const EDIT_OPS = [
     "set-page-fields",
     "add-lens",
     "remove-lens",
+    "set-lens-hidden",
     "set-home",
     "arrange-pages",
     "set-computed",
     "set-people",
+    "set-archives",
+    "set-tidying",
     "add-grant",
     "remove-grant",
     "add-sight",
@@ -65,6 +81,10 @@ const KEYWORDS = new Set(["and", "or", "not", "in", "where", "true", "false", "n
 const MAX_EDITS = 50;
 // ── shapes ─────────────────────────────────────────────────────────────────
 const kindName = z.string().regex(NAME, 'kind names are lower-case words joined by hyphens, like "guest-list"');
+const listKey = z.string().min(1).max(120);
+const listDirection = z.enum(["asc", "desc"]).optional();
+const listSortShape = z.union([listKey, z.object({ by: listKey, direction: listDirection, then: z.union([listKey, z.object({ by: listKey, direction: listDirection }).strict()]).optional() }).strict()]);
+const listGroupShape = z.union([listKey, z.object({ by: listKey, order: z.array(z.string().min(1).max(80)).max(40).optional(), closed: z.array(z.string().min(1).max(80)).max(40).optional() }).strict()]);
 const fieldName = z.string().regex(FIELD_NAME, 'field names are one word or camelCase, like "dueDate"');
 const edgeName = z.string().regex(EDGE_NAME, 'relation names are one camelCase word, like "tendedBy"');
 const actName = z.string().regex(NAME, 'act names are lower-case words joined by hyphens, like "mark-paid"');
@@ -75,11 +95,13 @@ const SHAPES = {
     "remove-kind": z.object({ op: z.literal("remove-kind"), kind: kindName }).strict(),
     "add-field": z.object({ op: z.literal("add-field"), kind: kindName, field: fieldName, fill: z.unknown().optional(), spec: z.record(z.string(), z.unknown()).optional() }).passthrough(),
     "rename-field": z.object({ op: z.literal("rename-field"), kind: kindName, field: fieldName, to: fieldName }).strict(),
-    "retype-field": z.object({ op: z.literal("retype-field"), kind: kindName, field: fieldName, type: z.enum(FIELD_TYPES), options: z.array(z.string().min(1).max(80)).min(1).max(100).optional(), of: z.enum(["string", "number", "date", "image", "file"]).optional(), format: z.enum(["money", "percent", "duration"]).optional() }).strict(),
+    "retype-field": z.object({ op: z.literal("retype-field"), kind: kindName, field: fieldName, type: z.enum(FIELD_TYPES), options: z.array(z.string().min(1).max(80)).min(1).max(100).optional(), of: z.enum(["string", "number", "date", "image", "file"]).optional(), format: z.enum(["money", "percent", "duration", "markdown"]).optional() }).strict(),
     "set-options": z.object({ op: z.literal("set-options"), kind: kindName, field: fieldName, add: z.array(z.string().min(1).max(80)).optional(), remove: z.array(z.string().min(1).max(80)).optional() }).strict(),
+    "set-format": z.object({ op: z.literal("set-format"), kind: kindName, field: fieldName, format: z.union([z.enum(["money", "percent", "duration", "markdown"]), z.null()]).optional(), unit: z.union([z.string().min(1).max(12), z.null()]).optional() }).strict(),
     "set-range": z.object({ op: z.literal("set-range"), kind: kindName, field: fieldName, min: z.union([z.number(), z.null()]).optional(), max: z.union([z.number(), z.null()]).optional(), step: z.union([z.number().positive(), z.null()]).optional() }).strict(),
     "set-required": z.object({ op: z.literal("set-required"), kind: kindName, field: fieldName, required: z.boolean() }).strict(),
     "set-default": z.object({ op: z.literal("set-default"), kind: kindName, field: fieldName, default: z.unknown() }).strict(),
+    "set-repeats": z.object({ op: z.literal("set-repeats"), kind: kindName, field: fieldName, repeats: z.boolean() }).strict(),
     "remove-field": z.object({ op: z.literal("remove-field"), kind: kindName, field: fieldName }).strict(),
     "add-relation": z.object({ op: z.literal("add-relation"), kind: kindName, relation: edgeName }).passthrough(),
     "rename-relation": z.object({ op: z.literal("rename-relation"), kind: kindName, relation: edgeName, to: edgeName }).strict(),
@@ -97,7 +119,7 @@ const SHAPES = {
         locale: z.union([z.string(), z.null()]).optional(),
         // The rest of the brand (FR-124, FR-125): each as the document holds it, null to clear it.
         logo: z.union([z.string().min(1), z.object({ src: z.string().min(1), alt: z.string().min(1).max(120).optional() }).strict(), z.null()]).optional(),
-        favicon: z.union([z.string().min(1), z.null()]).optional(),
+        favicon: z.union([z.string().min(1), z.object({ emoji: z.string() }).strict(), z.null()]).optional(),
         typography: z.union([z.object({ display: z.union([z.string().min(1).max(200), z.null()]).optional(), body: z.union([z.string().min(1).max(200), z.null()]).optional(), mono: z.union([z.string().min(1).max(200), z.null()]).optional() }).strict(), z.null()]).optional(),
         shape: z.union([z.object({ radius: z.union([z.number().min(0).max(32), z.null()]).optional(), density: z.union([z.number().min(0.75).max(1.5), z.null()]).optional() }).strict(), z.null()]).optional(),
         accents: z.union([z.record(z.string(), z.union([z.number().min(0).max(360), z.null()])), z.null()]).optional(),
@@ -128,11 +150,15 @@ const SHAPES = {
         on: kindName.optional(),
         bindings: z.record(z.string(), z.unknown()).optional(),
         options: z.record(z.string(), z.unknown()).optional(),
+        // False: the place's page leaves off the forms that begin its kind.
+        create: z.boolean().optional(),
         at: z.number().int().min(0).optional(),
         replace: lensTitle.optional(),
     })
         .strict(),
     "remove-lens": z.object({ op: z.literal("remove-lens"), title: lensTitle, on: kindName.optional() }).strict(),
+    // A lens kept off the bar's places, the page list and the home's gallery, still reached by its address, a link or navigate.
+    "set-lens-hidden": z.object({ op: z.literal("set-lens-hidden"), title: lensTitle, on: kindName.optional(), hidden: z.boolean() }).strict(),
     "set-home": z.object({ op: z.literal("set-home"), blocks: z.union([z.array(z.unknown()).min(1), z.null()]) }).strict(),
     "arrange-pages": z
         .object({
@@ -143,6 +169,12 @@ const SHAPES = {
         primary: z.union([z.array(z.string().min(1).max(80)).max(40), z.null()]).optional(),
         scene: z.union([z.string().min(1).max(40), z.null()]).optional(),
         pages: z.union([z.string().min(1).max(40), z.null()]).optional(),
+        // What a kind's list offers to filter by: `{ "request": ["status", "became.stage"] }`; null or [] gives a kind back its derived filters.
+        filters: z.record(kindName, z.union([z.array(z.string().min(1).max(120)).max(40), z.null()])).optional(),
+        // The order a kind's list opens in: `{ "feature": { "by": "score", "direction": "desc", "then": "label" } }` or a key; null gives it back its own.
+        sort: z.record(kindName, z.union([listSortShape, z.null()])).optional(),
+        // How a kind's list opens grouped: `{ "request": { "by": "status", "order": [...], "closed": ["done"] } }` or a field; null opens it ungrouped.
+        group: z.record(kindName, z.union([listGroupShape, z.null()])).optional(),
         // The scene's word as a chat or a tool written before 0.1.17 sends it (FR-132's key, RESPELLED as `scene`).
         overview: z.union([z.string().min(1).max(40), z.null()]).optional(),
     })
@@ -159,6 +191,10 @@ const SHAPES = {
         .strict(),
     // Who the people are, and who may do and see what (FR-170): a grant and a sight as the document holds one.
     "set-people": z.object({ op: z.literal("set-people"), kind: kindName, people: z.boolean() }).strict(),
+    // Whether a kind's records are archived and merged, or only kept and removed (FR-173).
+    "set-archives": z.object({ op: z.literal("set-archives"), kind: kindName, archives: z.boolean() }).strict(),
+    // What the app's own actor may do on its own to a kind, or to one relation of it (`@graview/core/tidying`).
+    "set-tidying": z.object({ op: z.literal("set-tidying"), kind: kindName, relation: z.optional(z.string()), tidying: z.enum(["never", "no-links", "allowed"]) }).strict(),
     "add-grant": z.object({ op: z.literal("add-grant") }).passthrough(),
     "remove-grant": z.object({ op: z.literal("remove-grant") }).passthrough(),
     "add-sight": z.object({ op: z.literal("add-sight") }).passthrough(),
@@ -271,9 +307,10 @@ function mapNames(doc, e, ctx, rename) {
                 const first = x.args[0];
                 const literal = first?.t === "lit" && typeof first.value === "string" ? first.value : undefined;
                 let args;
-                if ((x.fn === "out" || x.fn === "in" || x.fn === "all") && literal !== undefined && x.args.length === 1) {
+                if ((x.fn === "out" || x.fn === "in" || x.fn === "all") && literal !== undefined && (x.args.length === 1 || (x.fn === "all" && x.args.length === 2))) {
                     const name = rename({ role: x.fn === "all" ? "kind" : "edge", kinds: NONE, name: literal });
-                    args = name === literal ? [...x.args] : [{ ...first, value: name }];
+                    // all('task', 'all') keeps what it asked of the archived (FR-173).
+                    args = name === literal ? [...x.args] : [{ ...first, value: name }, ...x.args.slice(1)];
                 }
                 else if ((x.fn === "out" || x.fn === "in") && x.args.length === 2 && x.args[1].t === "lit" && typeof x.args[1].value === "string") {
                     // out(S, 'edge'): the set is read where the walk stands, and its relation renamed like any walk's (FR-101).
@@ -481,7 +518,7 @@ class Editor {
         const emptyPart = ["typography", "shape", "accents"].find((key) => isObject(e[key]) && Object.keys(e[key]).length === 0);
         if (emptyPart)
             return this.fail(i, emptyPart, `${emptyPart} names no part to set; name one, or give null to clear all of it`);
-        const judged = brandFindings({ ...(typeof e.logo === "string" || isObject(e.logo) ? { logo: e.logo } : {}), ...(typeof e.favicon === "string" ? { favicon: e.favicon } : {}), ...(isObject(e.typography) ? { typography: Object.fromEntries(Object.entries(e.typography).filter(([, v]) => typeof v === "string")) } : {}) }, { at, ...(this.options.fonts ? { fonts: this.options.fonts } : {}) });
+        const judged = brandFindings({ ...(typeof e.logo === "string" || isObject(e.logo) ? { logo: e.logo } : {}), ...(typeof e.favicon === "string" || isObject(e.favicon) ? { favicon: e.favicon } : {}), ...(isObject(e.typography) ? { typography: Object.fromEntries(Object.entries(e.typography).filter(([, v]) => typeof v === "string")) } : {}) }, { at, ...(this.options.fonts ? { fonts: this.options.fonts } : {}) });
         if (judged.length > 0)
             return void this.findings.push(...judged);
         if (e.accent === null) {
@@ -507,13 +544,17 @@ class Editor {
             brand["currency"] = e.currency;
             this.said.push(`Money is said in ${e.currency}.`);
         }
-        if (e.locale === null)
+        if (e.locale === null) {
+            if (brand["locale"] !== undefined)
+                this.said.push(localeSentence(undefined));
             delete brand["locale"];
+        }
         else if (e.locale !== undefined) {
             if (!/^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/.test(e.locale))
                 return this.fail(i, "locale", 'a locale is a language tag, like "en-US" or "de-DE"');
             brand["locale"] = e.locale;
-            this.said.push(`Money is written for ${e.locale}.`);
+            // Its days, times and numbers as well as its money (FR-178).
+            this.said.push(localeSentence(e.locale));
         }
         if (e.name === null) {
             delete brand["name"];
@@ -535,6 +576,8 @@ class Editor {
             const alt = (mark) => (isObject(mark) && typeof mark["alt"] === "string" ? mark["alt"] : undefined);
             if (e[key] === null)
                 this.said.push(`The app has no ${what}.`);
+            else if (key === "favicon" && emojiOf(e[key]) !== undefined)
+                this.said.push(emojiIconSentence(emojiOf(e[key]), brand["logo"] !== undefined));
             else if (was === undefined)
                 this.said.push(`The app gets a ${what}.`);
             else if (canonicalize(was) === canonicalize(e[key]))
@@ -651,6 +694,8 @@ class Editor {
                 return this.setOptions(i, e);
             case "set-range":
                 return this.setRange(i, e);
+            case "set-format":
+                return this.setFormat(i, e);
             case "set-required": {
                 const f = this.field(i, e.kind, e.field);
                 if (!f)
@@ -681,6 +726,20 @@ class Editor {
                 }
                 return;
             }
+            case "set-repeats": {
+                // A date that repeats keeps how it does beside it, as `<field>Repeat` (`repeat.ts`).
+                const f = this.field(i, e.kind, e.field);
+                if (!f)
+                    return;
+                if (e.repeats && f.type !== "date" && f.type !== "datetime")
+                    return this.fail(i, "repeats", `${e.kind}'s ${e.field} is ${f.type === "enum" ? "a choice" : `a ${f.type}`}, and only a date or a date and time can repeat`);
+                if (e.repeats)
+                    f.repeats = true;
+                else
+                    delete f.repeats;
+                this.said.push(e.repeats ? `${e.kind}'s ${e.field} may repeat: weekly, monthly, on chosen days, until a day.` : `${e.kind}'s ${e.field} no longer repeats.`);
+                return;
+            }
             case "remove-field":
                 return this.removeField(i, e.kind, e.field);
             case "add-relation":
@@ -792,6 +851,8 @@ class Editor {
                 return this.addLens(i, e);
             case "remove-lens":
                 return this.removeLens(i, e);
+            case "set-lens-hidden":
+                return this.setLensHidden(i, e);
             case "set-home":
                 return this.setHome(i, e.blocks);
             case "arrange-pages":
@@ -800,6 +861,10 @@ class Editor {
                 return this.setComputed(i, e);
             case "set-people":
                 return this.setPeople(i, e);
+            case "set-archives":
+                return this.setArchives(i, e);
+            case "set-tidying":
+                return this.setTidying(i, e);
             case "add-grant":
             case "remove-grant":
             case "add-sight":
@@ -930,7 +995,8 @@ class Editor {
                 return;
             was = lenses[at];
         }
-        const lens = { name, title: e.title, ...(e.on !== undefined ? { on: e.on } : {}), ...(e.bindings !== undefined ? { bindings: e.bindings } : {}), ...(e.options !== undefined ? { options: e.options } : {}) };
+        // A lens drawn anew in another's place stays off the lists if that one was.
+        const lens = { name, title: e.title, ...(e.on !== undefined ? { on: e.on } : {}), ...(e.bindings !== undefined ? { bindings: e.bindings } : {}), ...(e.options !== undefined ? { options: e.options } : {}), ...(was?.["hidden"] === true ? { hidden: true } : {}), ...(e.create === false ? { create: false } : {}) };
         // A title is an address: one lens a title on a kind.
         const clash = lenses.findIndex((other, index) => index !== at && isObject(other) && typeof other["title"] === "string" && placeSlug(other["title"]) === placeSlug(e.title) && (e.on === undefined || other["on"] === undefined || other["on"] === e.on));
         if (clash >= 0)
@@ -952,8 +1018,9 @@ class Editor {
             return;
         const over = lens.on ?? kindsBound(lens)[0];
         const where = over ? `, over ${pluralWords(this.doc, over)}` : "";
+        const formless = lens.create === false ? "; its page offers no form to add one" : "";
         if (!was) {
-            this.said.push(`A lens "${e.title}" is added${where}.`);
+            this.said.push(`A lens "${e.title}" is added${where}${formless}.`);
             return;
         }
         const retitled = was["title"] !== e.title;
@@ -994,6 +1061,31 @@ class Editor {
         }
         return true;
     }
+    /**
+     * A LENS KEPT OFF THE LISTS, or put back on them: still a place at its
+     * address, reached by a link or `navigate`, but not offered by the bar,
+     * the page list or the home's gallery. A lens a custom home links to.
+     */
+    setLensHidden(i, e) {
+        const index = this.lensIndex(i, e.title, e.on);
+        if (index < 0)
+            return;
+        const lens = this.doc.lenses[index];
+        const title = String(lens["title"]);
+        const primary = Array.isArray(this.doc.pages?.primary) ? this.doc.pages.primary : [];
+        if (e.hidden && primary.some((word) => namesLens(word, title))) {
+            return this.fail(i, "hidden", `pages.primary stands "${title}" on the bar, so it cannot be kept off the lists`, 'take it out of "primary" with arrange-pages first');
+        }
+        const was = lens["hidden"] === true;
+        if (e.hidden)
+            lens["hidden"] = true;
+        else
+            delete lens["hidden"];
+        if (was === e.hidden)
+            this.said.push(e.hidden ? `The lens "${title}" was already kept off the lists.` : `The lens "${title}" was already listed.`);
+        else
+            this.said.push(e.hidden ? `The lens "${title}" is kept off the bar and the page list; a link or navigate still reaches it.` : `The lens "${title}" is listed on the bar and the page list again.`);
+    }
     removeLens(i, e) {
         const index = this.lensIndex(i, e.title, e.on);
         if (index < 0)
@@ -1005,8 +1097,29 @@ class Editor {
         // `overview` is the scene's word as 0.1.15 and 0.1.16 took it (FR-134): read as `scene`, which wins when both are said.
         const { overview, ...rest } = given;
         const e = rest.scene === undefined && overview !== undefined ? { ...rest, scene: overview } : rest;
-        if (e.order === undefined && e.hide === undefined && e.first === undefined && e.scene === undefined && e.pages === undefined && e.primary === undefined)
-            return this.fail(i, "", 'arrange-pages says at least one of "order", "hide", "first", "primary", "scene" or "pages"');
+        if (e.order === undefined && e.hide === undefined && e.first === undefined && e.scene === undefined && e.pages === undefined && e.primary === undefined && e.filters === undefined && e.sort === undefined && e.group === undefined)
+            return this.fail(i, "", 'arrange-pages says at least one of "order", "hide", "first", "primary", "scene", "pages", "filters", "sort" or "group"');
+        // A list's order and grouping are judged as the checker judges them, each refusal its sentence.
+        for (const part of ["sort", "group"]) {
+            for (const [kind, spec] of Object.entries((e[part] ?? {}))) {
+                if (!this.doc.kinds[kind])
+                    return this.fail(i, `${part}.${kind}`, `"${kind}" is not a kind this app has; it has ${Object.keys(this.doc.kinds).join(", ")}`);
+                if (spec === null)
+                    continue;
+                const [finding] = kindListFindings(kind, { [part]: spec }, documentListFields(this.doc.kinds[kind]), `${part}.${kind}`);
+                if (finding)
+                    return this.fail(i, finding.path.replace(new RegExp(`^${part}\\.${kind}\\.${part}`), `${part}.${kind}`), finding.message.replace(/\.$/, ""), finding.fix.replace(/\.$/, ""));
+            }
+        }
+        for (const [kind, keys] of Object.entries((e.filters ?? {}))) {
+            if (!this.doc.kinds[kind])
+                return this.fail(i, `filters.${kind}`, `"${kind}" is not a kind this app has; it has ${Object.keys(this.doc.kinds).join(", ")}`);
+            for (const [n, key] of (keys ?? []).entries()) {
+                const offered = this.filterKeys(kind);
+                if (!offered.includes(key))
+                    return this.fail(i, `filters.${kind}.${n}`, `${kind} cannot be filtered by "${key}"`, `name one of ${offered.join(", ")}`);
+            }
+        }
         for (const [n, word] of (e.primary ?? []).entries()) {
             if (typeof word !== "string" || !this.opens(word) || word.trim().toLowerCase() === "home") {
                 const titles = (this.doc.lenses ?? []).flatMap((lens) => (isObject(lens) && typeof lens["title"] === "string" ? [`"${lens["title"]}"`] : []));
@@ -1085,10 +1198,156 @@ class Editor {
                 said.push(`the switch calls the ${face} "${pages[face]}"`);
             }
         }
+        // Each kind's list keeps what this edit does not say: its filters, its order, its grouping.
+        const listOfKind = (kind, part, value) => {
+            const lists = (pages.lists ??= {});
+            const list = (lists[kind] ??= {});
+            if (value === null)
+                delete list[part];
+            else
+                list[part] = value;
+            if (Object.keys(list).length === 0)
+                delete lists[kind];
+            if (Object.keys(lists).length === 0)
+                delete pages.lists;
+        };
+        for (const [kind, keys] of Object.entries((e.filters ?? {}))) {
+            if (keys === null || keys.length === 0) {
+                listOfKind(kind, "filters", null);
+                said.push(`the list of ${pluralWords(this.doc, kind)} offers its own filters again`);
+            }
+            else {
+                listOfKind(kind, "filters", [...keys]);
+                said.push(`the list of ${pluralWords(this.doc, kind)} filters by ${listOf(keys.map((key) => `"${key}"`))}`);
+            }
+        }
+        for (const part of ["sort", "group"]) {
+            for (const [kind, spec] of Object.entries((e[part] ?? {}))) {
+                listOfKind(kind, part, spec === null ? null : clone(spec));
+                const plural = pluralWords(this.doc, kind);
+                if (spec === null)
+                    said.push(part === "sort" ? `the list of ${plural} opens in its own order again` : `the list of ${plural} opens ungrouped again`);
+                else
+                    said.push(`the list of ${plural} opens ${kindListWords({ [part]: spec }, this.listKeyType(kind))[part]}`);
+            }
+        }
         if (Object.keys(pages).length === 0)
             delete this.doc.pages;
         this.said.push(`${capitalize(listOf(said))}.`);
     }
+    /**
+     * A KIND'S LIST FOLLOWS ITS FIELDS. Its order and grouping name a field
+     * renamed by its new name; one gone (or a computed field no longer worked
+     * out) lets go of the part that named it — a tiebreak, the order, the
+     * grouping — and says so. A list left saying nothing is unsaid.
+     */
+    listsFollow(kind, from, to) {
+        const list = this.doc.pages?.lists?.[kind];
+        if (!list)
+            return [];
+        const out = [];
+        const sort = listSort(list.sort);
+        if (sort && (sort.by === from || sort.then?.by === from)) {
+            if (to !== undefined) {
+                if (typeof list.sort === "string")
+                    list.sort = to;
+                else {
+                    if (list.sort.by === from)
+                        list.sort.by = to;
+                    if (list.sort.then === from)
+                        list.sort.then = to;
+                    else if (isObject(list.sort.then) && list.sort.then["by"] === from)
+                        list.sort.then.by = to;
+                }
+            }
+            else if (sort.by === from)
+                delete list.sort;
+            else
+                delete list.sort.then;
+            out.push(`the ${kind} list's order`);
+        }
+        if (listGroup(list.group)?.by === from) {
+            if (to === undefined)
+                delete list.group;
+            else if (typeof list.group === "string")
+                list.group = to;
+            else
+                list.group.by = to;
+            out.push(`the ${kind} list's grouping`);
+        }
+        this.listsTidied(kind);
+        return out;
+    }
+    /** A field retyped or a choice dropped: the list's order and grouping keep what still holds, and let go of what does not. */
+    listsHold(kind, removedOptions = []) {
+        const list = this.doc.pages?.lists?.[kind];
+        if (!list)
+            return [];
+        const out = [];
+        if (isObject(list.group) && removedOptions.length > 0) {
+            for (const part of ["order", "closed"]) {
+                if (!Array.isArray(list.group[part]))
+                    continue;
+                const kept = list.group[part].filter((value) => !removedOptions.includes(value));
+                if (kept.length === list.group[part].length)
+                    continue;
+                if (kept.length > 0)
+                    list.group[part] = kept;
+                else
+                    delete list.group[part];
+                if (!out.includes(`the ${kind} list's grouping`))
+                    out.push(`the ${kind} list's grouping`);
+            }
+        }
+        for (const finding of kindListFindings(kind, list, documentListFields(this.doc.kinds[kind]))) {
+            const part = finding.path.slice(`pages.lists.${kind}.`.length).startsWith("sort") ? "sort" : "group";
+            if (list[part] === undefined)
+                continue;
+            delete list[part];
+            out.push(`the ${kind} list's ${part === "sort" ? "order" : "grouping"}`);
+        }
+        this.listsTidied(kind);
+        return out;
+    }
+    listsTidied(kind) {
+        const lists = this.doc.pages?.lists;
+        if (!lists)
+            return;
+        if (lists[kind] && Object.keys(lists[kind]).length === 0)
+            delete lists[kind];
+        if (Object.keys(lists).length === 0)
+            delete this.doc.pages.lists;
+        if (Object.keys(this.doc.pages).length === 0)
+            delete this.doc.pages;
+    }
+    /** What a key of a kind's list reads as, for the words its order is said in: a computed field is a number. */
+    listKeyType(kind) {
+        const spec = this.doc.kinds[kind];
+        return (key) => (spec?.computed?.[key] !== undefined ? "number" : sortTypeOfDocumentField(spec?.fields?.[key]?.type));
+    }
+    /** What a kind's list may be filtered by: its fields, its relations either way, `is`, and a choice at a relation's single far kind. */
+    filterKeys(kind) {
+        const kinds = this.doc.kinds;
+        const keys = new Set(["is", ...Object.keys(kinds[kind]?.fields ?? {})]);
+        const edges = new Map();
+        for (const [edge, spec] of Object.entries((kinds[kind]?.edges ?? {})))
+            edges.set(edge, spec.to === "*" ? [] : [spec.to].flat());
+        for (const [other, spec] of Object.entries(kinds)) {
+            for (const [edge, declared] of Object.entries((spec.edges ?? {}))) {
+                if (other !== kind && !edges.has(edge) && (declared.to === "*" || [declared.to].flat().includes(kind)))
+                    edges.set(edge, [other]);
+            }
+        }
+        for (const [edge, far] of edges) {
+            keys.add(edge);
+            if (far.length !== 1 || far[0] === kind)
+                continue;
+            for (const [field, spec] of Object.entries((kinds[far[0]]?.fields ?? {})))
+                if (spec.type === "enum")
+                    keys.add(`${edge}.${field}`);
+        }
+        return [...keys];
+    }
     /** Whether `first` names something the app can open on: home, a kind or its plural, a titled lens. */
     opens(first) {
         const word = first.trim();
@@ -1179,6 +1438,73 @@ class Editor {
             delete spec.people;
         this.said.push(peopleSentence(this.doc.kinds, e.kind, e.people, already));
     }
+    /** A kind's records kept or removed, never archived (FR-173) — or archived and merged again. */
+    setArchives(i, e) {
+        const spec = this.kind(i, e.kind);
+        if (!spec)
+            return;
+        const already = (spec.archives !== false) === e.archives;
+        if (!e.archives && !already) {
+            // A grant that names one of the three acts would name an act the app no longer has.
+            const gone = new Set(["archive", "unarchive", "merge"].map((verb) => `${verb}-${e.kind}`).filter((act) => !this.doc.acts?.[act]));
+            const grant = (this.doc.policy?.grants ?? []).find((g) => Array.isArray(g.mutations) && g.mutations.some((m) => gone.has(m)));
+            if (grant) {
+                const named = grant.mutations.filter((m) => gone.has(m));
+                return this.failAs("grant-unknown-mutation", i, "archives", `a grant names ${listOf(named.map((m) => `"${m}"`))}, which ${pluralOf(this.doc.kinds, e.kind)} would no longer have`, `{"op": "remove-grant", "roles": ${JSON.stringify(grant.roles)}, "mutations": ${JSON.stringify(grant.mutations)}} first, in the same change`);
+            }
+            spec.archives = false;
+        }
+        else if (e.archives)
+            delete spec.archives;
+        if (!already)
+            this.toolsMoved.add(`archive-${e.kind}, unarchive-${e.kind} and merge-${e.kind} ${e.archives ? "are offered" : "are gone"}`);
+        this.said.push(archivesSentence(this.doc.kinds, e.kind, e.archives, already));
+    }
+    /**
+     * WHAT THE APP'S OWN ACTOR MAY DO ON ITS OWN (`@graview/core/tidying`):
+     * a kind never tidied, or never linked automatically, or tidied again; a
+     * relation never made or broken automatically, or tidied again. A kind
+     * never tidied is given no leave-alone-<kind> or allow-tidying-<kind>,
+     * which a grant may not then name.
+     */
+    setTidying(i, e) {
+        const spec = this.kind(i, e.kind);
+        if (!spec)
+            return;
+        const tidying = e.tidying;
+        if (e.relation !== undefined) {
+            const relation = spec.edges?.[e.relation];
+            if (!relation)
+                return this.failAs("edit", i, "relation", `${e.kind} has no relation "${e.relation}"; it has ${Object.keys(spec.edges ?? {}).join(", ") || "none"}`);
+            if (tidying === "no-links")
+                return this.failAs("edit", i, "tidying", `a relation is tidied or never ("never"); "no-links" is said of a kind`, `{"op": "set-tidying", "kind": "${e.kind}", "relation": "${e.relation}", "tidying": "never"}`);
+            const already = (relation.tidying === "never") === (tidying === "never");
+            if (tidying === "never")
+                relation.tidying = "never";
+            else
+                delete relation.tidying;
+            this.said.push(tidyingSentence(this.doc.kinds, e.kind, e.relation, tidying, already));
+            return;
+        }
+        const was = spec.tidying ?? "allowed";
+        const already = was === tidying;
+        if (tidying === "never" && !already) {
+            // A grant that names leave-alone-<kind> or allow-tidying-<kind> would name an act the app no longer has.
+            const gone = new Set(["leave-alone", "allow-tidying"].map((verb) => `${verb}-${e.kind}`).filter((act) => !this.doc.acts?.[act]));
+            const grant = (this.doc.policy?.grants ?? []).find((g) => Array.isArray(g.mutations) && g.mutations.some((m) => gone.has(m)));
+            if (grant) {
+                const named = grant.mutations.filter((m) => gone.has(m));
+                return this.failAs("grant-unknown-mutation", i, "tidying", `a grant names ${listOf(named.map((m) => `"${m}"`))}, which ${pluralOf(this.doc.kinds, e.kind)} would no longer have`, `{"op": "remove-grant", "roles": ${JSON.stringify(grant.roles)}, "mutations": ${JSON.stringify(grant.mutations)}} first, in the same change`);
+            }
+        }
+        if (tidying === "allowed")
+            delete spec.tidying;
+        else
+            spec.tidying = tidying;
+        if (!already && (was === "never" || tidying === "never"))
+            this.toolsMoved.add(`leave-alone-${e.kind} and allow-tidying-${e.kind} ${tidying === "never" ? "are gone" : "are offered"}`);
+        this.said.push(tidyingSentence(this.doc.kinds, e.kind, undefined, tidying, already));
+    }
     /** A grant or a sight as the document holds one, or undefined having said why not. */
     policyPart(i, e, sight) {
         const { op: _op, ...rest } = e;
@@ -1202,12 +1528,21 @@ class Editor {
             if (!this.doc.kinds[kind])
                 return this.failAs(sight ? "sight-kind" : "edit", i, `kinds.${n}`, `"${kind}" is not a kind this app has; it has ${Object.keys(this.doc.kinds).join(", ")}`);
         }
+        // A field a sight shows or hides is one of the kinds it shows (Roadmap f-field-sight).
+        for (const key of sight ? ["fields", "hide"] : []) {
+            for (const [n, field] of (part[key] ?? []).entries()) {
+                const kinds = part.kinds;
+                if (kinds.some((kind) => this.doc.kinds[kind]?.fields[field]))
+                    continue;
+                return this.failAs("sight-field", i, `${key}.${n}`, `"${field}" is not a field of ${kinds.join(" or ")}`, `one of ${[...new Set(kinds.flatMap((kind) => Object.keys(this.doc.kinds[kind]?.fields ?? {})))].join(", ")}`);
+            }
+        }
         if (!sight && part.mutations !== "*") {
             for (const [n, act] of part.mutations.entries()) {
-                const derived = /^(?:edit|remove)-(.+)$/.exec(act);
-                if (this.doc.acts?.[act] || (derived && this.doc.kinds[derived[1]]))
+                const derived = derivedActOf(act);
+                if (this.doc.acts?.[act] || (derived && this.doc.kinds[derived.kind] && (this.doc.kinds[derived.kind].archives !== false || givenWhenNeverArchived(derived.act)) && (this.doc.kinds[derived.kind].tidying !== "never" || givenWhenNeverTidied(derived.act))))
                     continue;
-                return this.failAs("grant-act", i, `mutations.${n}`, `"${act}" is not an act this app has`, `one of ${[...Object.keys(this.doc.acts ?? {}), ...Object.keys(this.doc.kinds).flatMap((kind) => [`edit-${kind}`, `remove-${kind}`])].join(", ")}`);
+                return this.failAs("grant-act", i, `mutations.${n}`, `"${act}" is not an act this app has`, `one of ${[...Object.keys(this.doc.acts ?? {}), ...Object.keys(this.doc.kinds).flatMap(derivedActsOf)].join(", ")}`);
             }
         }
         const said = [];
@@ -1306,8 +1641,8 @@ class Editor {
         const to = e.to;
         const touched = this.rewriteAll({ t: "kind", from, to });
         // The acts the framework derives for every kind are named for it, so they move with it.
-        this.toolsMoved.add(`edit-${from} is now edit-${to}`);
-        this.toolsMoved.add(`remove-${from} is now remove-${to}`);
+        for (const act of DERIVED_ACTS)
+            this.toolsMoved.add(`${act}-${from} is now ${act}-${to}`);
         // The kind itself, in order, continuing its records.
         const kinds = {};
         for (const [k, v] of Object.entries(this.doc.kinds))
@@ -1338,6 +1673,13 @@ class Editor {
             spec.plural = e.plural;
         else if (spec.plural && (spec.plural === `${words(from)}s` || spec.plural === `${from}s`))
             spec.plural = `${words(to)}s`;
+        // Its list's filters, order and grouping follow it.
+        const lists = this.doc.pages?.lists;
+        if (lists?.[from] !== undefined && lists[to] === undefined) {
+            lists[to] = lists[from];
+            delete lists[from];
+            touched.push(`its list`);
+        }
         // Where the app opens, when it named the kind by its plural, follows the plural (FR-80).
         const pluralNow = spec.plural ?? `${words(to)}s`;
         if (typeof this.doc.pages?.first === "string" && placeSlug(this.doc.pages.first) === placeSlug(pluralWas) && placeSlug(pluralWas) !== placeSlug(pluralNow)) {
@@ -1424,7 +1766,7 @@ class Editor {
          * whose last act is removed — kept, it read as a grant on every kind.
          */
         if (this.doc.policy) {
-            const derived = [`edit-${kind}`, `remove-${kind}`];
+            const derived = derivedActsOf(kind);
             this.doc.policy.grants = this.doc.policy.grants.flatMap((g) => {
                 const kinds = Array.isArray(g.kinds) ? g.kinds.filter((k) => k !== kind) : g.kinds;
                 const mutations = Array.isArray(g.mutations) ? g.mutations.filter((m) => !derived.includes(m) || this.doc.acts?.[m]) : g.mutations;
@@ -1491,6 +1833,8 @@ class Editor {
         delete f.renamedFrom;
         if (f.type === "enum" && f.default !== undefined && !f.options.includes(f.default))
             return this.fail(i, "default", `"${String(f.default)}" is not one of the options`);
+        if (f.format && !formatFits(f.format, f.type))
+            return this.fail(i, "format", refusedFormat(f.format, f.type));
         spec.fields[field] = f;
         this.fieldOrigin.set(`${kind}.${field}`, undefined);
         let filled = "";
@@ -1510,7 +1854,9 @@ class Editor {
                 filled = `, set to ${JSON.stringify(fill)} on the records already there`;
             }
         }
-        this.said.push(`${kind} gains a field, ${field} (${f.type}${f.required ? ", required" : ""})${filled}.`);
+        // What it is said as, in words: "(number, money in USD — 10000 reads $10,000)".
+        const said = formatWords(f, this.doc.brand);
+        this.said.push(`${kind} gains a field, ${field} (${f.type}${said ? `, ${said}` : ""}${f.required ? ", required" : ""})${filled}.`);
     }
     renameField(i, kind, field, to) {
         const f = this.field(i, kind, field);
@@ -1554,6 +1900,7 @@ class Editor {
             spec.page = renamedOnPage(spec.page, field, to);
             touched.push(`${kind}'s page`);
         }
+        touched.push(...this.listsFollow(kind, field, to));
         for (const x of this.fills) {
             if (x.kind === kind && x.field === field)
                 x.field = to;
@@ -1572,6 +1919,9 @@ class Editor {
             return;
         if (e.type === "enum" && !e.options && !f.options)
             return this.fail(i, "options", `to make ${e.field} a choice, list its "options"`);
+        // A format goes where it says something (FR-180): money, a percent and a duration on a number, Markdown on a text field.
+        if (e.format && !formatFits(e.format, e.type))
+            return this.fail(i, "format", refusedFormat(e.format, e.type));
         const was = f.type;
         f.type = e.type;
         if (e.type === "enum")
@@ -1584,25 +1934,73 @@ class Editor {
             delete f.of;
         if (e.format)
             f.format = e.format;
-        else if (e.type !== "number" && e.type !== "integer")
+        else if (e.type === "text" || !formatFits(f.format ?? "", e.type))
             delete f.format;
         // A range is a number's (FR-114): a field that is no longer one lets it go.
-        if (e.type !== "number" && e.type !== "integer")
+        if (e.type !== "number" && e.type !== "integer" && e.type !== "duration")
             for (const key of ["min", "max", "step"])
                 delete f[key];
+        // Only a date repeats: a field that is no longer one lets its repeat go.
+        if (e.type !== "date" && e.type !== "datetime")
+            delete f.repeats;
         if (f.default !== undefined && coerce(f.default, was, f) === undefined)
             delete f.default;
         else if (f.default !== undefined)
             f.default = coerce(f.default, was, f);
-        this.said.push(`${e.kind}'s ${e.field} changes from ${was} to ${e.type}; values that convert are kept.`);
+        const said = f.format && f.format !== "markdown" ? formatWords(f, this.doc.brand) : undefined;
+        // A list grouped by a choice that is no longer one opens ungrouped, and says so.
+        const held = this.listsHold(e.kind);
+        if (held.length > 0)
+            this.said.push(`${capitalize(listOf(held))} ${held.length === 1 ? "goes" : "go"} back to the list's own, since ${e.field} is no longer ${was === "enum" ? "a choice" : `a ${was}`}.`);
+        if (was === e.type && e.type === "text")
+            this.said.push(`${e.kind}'s ${e.field} ${e.format === "markdown" ? "is now written in Markdown, drawn as prose on the record's page" : "is drawn as written, not as Markdown"}; its values are kept.`);
+        else
+            this.said.push(`${e.kind}'s ${e.field} changes from ${was} to ${e.type}${said ? `, said as ${said}` : ""}; values that convert are kept.`);
+    }
+    /**
+     * HOW A FIELD IS SAID, and nothing else about it: a number's `format`
+     * (money, a percent, a duration) and `unit` (a currency like "EUR" for
+     * money, a measure like "kg"), or a text field's `format`, `markdown`
+     * (FR-180) — each set by a value, cleared by `null`, kept when left out.
+     * The values stay as they are; every face says them anew.
+     */
+    setFormat(i, e) {
+        const f = this.field(i, e.kind, e.field);
+        if (!f)
+            return;
+        if (e.format === undefined && e.unit === undefined)
+            return this.fail(i, "format", 'say a "format" ("money", "percent" or "duration" for a number, "markdown" for a text field, or null for neither), a "unit" ("EUR", "kg", or null), or both');
+        if (f.type === "text") {
+            if (e.unit !== undefined && e.unit !== null)
+                return this.fail(i, "unit", refusedFormat("a unit", f.type));
+            if (e.format && e.format !== "markdown")
+                return this.fail(i, "format", refusedFormat(e.format, f.type));
+            if (e.format === "markdown")
+                f.format = "markdown";
+            else if (e.format === null)
+                delete f.format;
+            this.said.push(`${e.kind}'s ${e.field} ${f.format === "markdown" ? "is now written in Markdown, drawn as prose on the record's page" : "is drawn as written, not as Markdown"}; its values are kept.`);
+            return;
+        }
+        if (!formatFits(typeof e.format === "string" ? e.format : "money", f.type))
+            return this.fail(i, "field", refusedFormat(typeof e.format === "string" ? e.format : "a unit", f.type));
+        const before = formatWords(f, this.doc.brand);
+        for (const key of ["format", "unit"]) {
+            if (e[key] === null)
+                delete f[key];
+            else if (e[key] !== undefined)
+                f[key] = e[key];
+        }
+        const now = formatWords(f, this.doc.brand);
+        this.said.push(`${e.kind}'s ${e.field} is said as ${now ?? "a plain number"}${before ? `, where it was ${before.replace(/ — .*/, "")}` : ""}; its values are kept.`);
     }
     /** A number's range (FR-114): a key given sets it, `null` clears it, one left out stays. */
     setRange(i, e) {
         const f = this.field(i, e.kind, e.field);
         if (!f)
             return;
-        if (f.type !== "number" && f.type !== "integer")
-            return this.fail(i, "field", `${e.field} is ${f.type === "integer" ? "an" : "a"} ${f.type}, not a number; a range belongs on a number or integer field`);
+        if (f.type !== "number" && f.type !== "integer" && f.type !== "duration")
+            return this.fail(i, "field", `${e.field} is ${f.type === "integer" ? "an" : "a"} ${f.type}, not a number; a range belongs on a number, integer or duration field`);
         const next = { ...f };
         for (const key of ["min", "max", "step"]) {
             if (e[key] === null)
@@ -1647,6 +2045,9 @@ class Editor {
             delete f.default;
             out.push("has no default now");
         }
+        const held = this.listsHold(e.kind, remove);
+        if (held.length > 0)
+            out.push(`${listOf(held)} ${held.length === 1 ? "lets" : "let"} go of ${remove.length === 1 ? "it" : "them"}`);
         // An act that sets a dropped option cannot stand.
         for (const [name, act] of Object.entries(this.doc.acts ?? {})) {
             for (const t of setTargets(act, this.doc))
@@ -2025,7 +2426,7 @@ class Editor {
                 rule.over = r.to;
             for (const rep of rule.repairs ?? []) {
                 if (r.t === "kind")
-                    rep.act = rep.act === `edit-${r.from}` ? `edit-${r.to}` : rep.act === `remove-${r.from}` ? `remove-${r.to}` : rep.act;
+                    rep.act = renamedAct(rep.act, r.from, r.to);
                 const args = renamedArgs.get(rep.act);
                 if (args && rep.args)
                     for (const [a, b] of args)
@@ -2052,7 +2453,7 @@ class Editor {
                 if (Array.isArray(g.kinds))
                     g.kinds = g.kinds.map(swap);
                 if (Array.isArray(g.mutations))
-                    g.mutations = g.mutations.map((m) => (m === `edit-${r.from}` ? `edit-${r.to}` : m === `remove-${r.from}` ? `remove-${r.to}` : m));
+                    g.mutations = g.mutations.map((m) => renamedAct(m, r.from, r.to));
             }
             for (const s of doc.policy.sees ?? [])
                 s.kinds = s.kinds.map(swap);
@@ -2115,6 +2516,9 @@ class Editor {
     dropMentions(r, worked = false) {
         const doc = this.doc;
         const gone = [];
+        // A kind's list ordered or grouped by it lets that go (a stored field removed, a computed one no longer worked out).
+        if (r.t === "field")
+            gone.push(...this.listsFollow(r.kind, r.from, undefined));
         for (const [kind, spec] of Object.entries(doc.kinds)) {
             for (const key of ["label", "describe"]) {
                 if (templateMentions(doc, spec[key], new Set([kind]), r)) {
@@ -2808,4 +3212,9 @@ export function renameIn(kinds, over, text, change) {
         return rewriteTemplate(doc, text.template, ctx, r);
     return undefined;
 }
+/** A derived act of a renamed kind, renamed with it: `archive-task` becomes `archive-chore`. Any other act as it was. */
+function renamedAct(act, from, to) {
+    const derived = derivedActOf(act);
+    return derived && derived.kind === from ? `${derived.act}-${to}` : act;
+}
 //# sourceMappingURL=edit.js.map