@graview/core 0.1.29 → 0.1.32

package/dist/document/edit.js

@@ -1,4 +1,4 @@
-import { DERIVED_ACTS, derivedActOf, derivedActsOf, givenWhenNeverArchived } from "../mutations/derived-names.js";
+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";
@@ -16,10 +16,12 @@ 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";
@@ -29,7 +31,7 @@ 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, archivesSentence, 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",
@@ -62,11 +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",
@@ -77,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"');
@@ -111,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(),
@@ -142,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({
@@ -159,6 +171,10 @@ const SHAPES = {
         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(),
     })
@@ -177,6 +193,8 @@ const SHAPES = {
     "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(),
@@ -500,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) {
@@ -558,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]))
@@ -831,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":
@@ -841,6 +863,8 @@ class Editor {
                 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":
@@ -971,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)
@@ -993,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;
@@ -1035,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)
@@ -1046,8 +1097,20 @@ 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 && e.filters === undefined)
-            return this.fail(i, "", 'arrange-pages says at least one of "order", "hide", "first", "primary", "scene", "pages" or "filters"');
+        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(", ")}`);
@@ -1135,23 +1198,133 @@ class Editor {
                 said.push(`the switch calls the ${face} "${pages[face]}"`);
             }
         }
-        for (const [kind, keys] of Object.entries((e.filters ?? {}))) {
+        // 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 ??= {});
-            if (keys === null || keys.length === 0) {
+            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 {
-                lists[kind] = { filters: [...keys] };
+                listOfKind(kind, "filters", [...keys]);
                 said.push(`the list of ${pluralWords(this.doc, kind)} filters by ${listOf(keys.map((key) => `"${key}"`))}`);
             }
-            if (Object.keys(lists).length === 0)
-                delete pages.lists;
+        }
+        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;
@@ -1287,6 +1460,51 @@ class Editor {
             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;
@@ -1322,7 +1540,7 @@ class Editor {
         if (!sight && part.mutations !== "*") {
             for (const [n, act] of part.mutations.entries()) {
                 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))))
+                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(derivedActsOf)].join(", ")}`);
             }
@@ -1455,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)) {
@@ -1675,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;
@@ -1722,6 +1948,10 @@ class Editor {
         else if (f.default !== undefined)
             f.default = coerce(f.default, was, f);
         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
@@ -1815,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))
@@ -2283,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)) {