@graview/core 0.1.62 → 0.1.64

package/dist/document/edit.js

@@ -16,13 +16,14 @@ const refusedFormat = (format, type) => {
 import { farEnd } from "./far-end.js";
 import { jobFindings, jobWorldOfDocument } from "../job-findings.js";
 import { JobSpec } from "./purpose-spec.js";
+import { WORKFLOW_JUDGING } from "../workflows/judging.js";
 import { aliasWord, documentAliasFindings } from "../alias-findings.js";
 import { humanizeField, withArticle } from "../schema/define-node.js";
-import { ConnectionSpec } from "./connection-spec.js";
+import { ConnectionSpec, connectionKinds } from "./connection-spec.js";
 import { linkedRelationFindings } from "./linked-relation-findings.js";
 import { linkedRelationOfSpec, reachesAnotherApp } from "../schema/linked.js";
-import { ActSpec, ALIAS, MOST_ALIASES, EDGE_NAME, EdgeSpec, FIELD_NAME, FIELD_TYPES, FieldSpec, GrantSpec, KindSpec, NAME, RuleSpec, SightSpec, } from "./schema.js";
-import { SHIPPED_LENSES, isShippedLens, SHIPPED_LENS_NAMES, unknownLensOption, viewReference } from "../places.js";
+import { ActSpec, ALIAS, MOST_ALIASES, MOST_COMPUTED, EDGE_NAME, EdgeSpec, FIELD_NAME, FIELD_TYPES, FieldSpec, GrantSpec, KindSpec, NAME, RuleSpec, SightSpec, } from "./schema.js";
+import { SHIPPED_LENSES, isShippedLens, SHIPPED_LENS_NAMES, TIMELINE_AXIS_ROLES, timelineBindingsWords, unknownLensOption, viewReference } from "../places.js";
 import { LENSES_THAT_LIST, listsRecords } from "../lenses-that-list.js";
 import { placeSlug, VIEW_REFERENCE } from "../views/types.js";
 import { documentListFields, kindListFindings, kindListWords, listGroup, listSort, sortTypeOfDocumentField } from "../kind-list.js";
@@ -36,13 +37,15 @@ 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, timeZoneSentence } from "./diff.js";
+import { derivesSentence, localeSentence, timeZoneSentence } from "./diff.js";
 import { accentProblem } from "../theme/accent.js";
 import { darkPageFor, groundProblem } from "../theme/ground-check.js";
 import { pageFieldFindings, pageNames, renamedOnPage, withoutOnPage } from "./page-fields.js";
+/** Whether a field or a computed field is said as money: its format, or a unit that is a currency. */
+const isMoney = (f) => f["format"] === "money" || (f["format"] === undefined && typeof f["unit"] === "string" && /^[A-Z]{3}$/.test(f["unit"]));
 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, tidyingSentence, 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, appTidyingSentence, 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",
@@ -84,6 +87,8 @@ export const EDIT_OPS = [
     "set-people",
     "set-archives",
     "set-tidying",
+    "set-app-tidying",
+    "set-derives",
     "add-grant",
     "remove-grant",
     "add-sight",
@@ -95,6 +100,11 @@ export const EDIT_OPS = [
     "add-alias",
     "set-aliases",
     "set-connection",
+    "add-workflow",
+    "set-workflow",
+    "remove-workflow",
+    "pause-workflow",
+    "resume-workflow",
 ];
 /** Words the rule language keeps: a field or relation renamed to one could not be named in a rule. */
 const KEYWORDS = new Set(["and", "or", "not", "in", "where", "true", "false", "null"]);
@@ -126,7 +136,7 @@ function buildShapes() {
         "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(), multiple: z.boolean().optional(), of: z.enum(["string", "number", "date", "image", "video", "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(), labels: z.record(z.string().min(1).max(80), z.union([z.string().min(1).max(80), z.null()])).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-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(), places: z.union([z.literal(0), 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(),
@@ -168,7 +178,7 @@ function buildShapes() {
             // Whether the home draws the description as the line under the name (Roadmap f-home-subtitle-separate): false keeps it off, true or null draws it again.
             subtitle: z.union([z.boolean(), z.null()]).optional(),
             // The opening screen (Roadmap f-splash-in-document), whole; null for Graview's own.
-            splash: z.union([z.object({ style: z.string(), image: z.string().min(1).optional(), title: z.string().min(1).max(80).optional(), kicker: z.string().min(1).max(80).optional(), shader: z.string().min(1).max(40).optional() }).strict(), z.null()]).optional(),
+            splash: z.union([z.object({ style: z.string(), image: z.string().min(1).optional(), title: z.string().min(1).max(80).optional(), kicker: z.string().min(1).max(80).optional(), shader: z.string().min(1).max(40).optional(), scheme: z.enum(["light", "dark", "device"]).optional() }).strict(), z.null()]).optional(),
             // What every worker view inherits (Roadmap f-app-wide-view-theme): a stylesheet drawn before each view's own (its length the sanitizer's to refuse, in `brandFindings`), and a fade between records; null clears either, or all of it.
             views: z
                 .union([
@@ -254,6 +264,10 @@ function buildShapes() {
         "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(),
+        // What the app says of suggestions as a whole (`tidying` at the top of the document): the votes at which the app's own actor makes one; null takes it away.
+        "set-app-tidying": z.object({ op: z.literal("set-app-tidying"), autoAcceptAt: z.union([z.number().int().min(1).max(10_000), z.null()]) }).strict(),
+        // What a kind follows (Roadmap f-keep-linked): the kind, the relation joining them and the fields worked out from it; null, it follows nothing.
+        "set-derives": z.object({ op: z.literal("set-derives"), kind: kindName, derives: z.union([z.object({ from: kindName, via: z.string(), set: z.record(z.string(), z.unknown()) }).strict(), z.null()]) }).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(),
@@ -282,6 +296,12 @@ function buildShapes() {
         "set-aliases": z.object({ op: z.literal("set-aliases"), kind: kindName, field: fieldName.optional(), aliases: z.union([z.array(z.string().min(1).max(40)).max(MOST_ALIASES), z.null()]) }).strict(),
         // A connection declared whole, by its name: set where there was none, or replaced (FR-229); null takes it away.
         "set-connection": z.object({ op: z.literal("set-connection"), name: kindName, connection: z.union([z.record(z.string(), z.unknown()), z.null()]) }).strict(),
+        // A workflow by its name (Roadmap f-jobs-declared): added where there was none, replaced whole, removed, paused or resumed.
+        "add-workflow": z.object({ op: z.literal("add-workflow"), name: kindName, workflow: z.record(z.string(), z.unknown()) }).strict(),
+        "set-workflow": z.object({ op: z.literal("set-workflow"), name: kindName, workflow: z.record(z.string(), z.unknown()) }).strict(),
+        "remove-workflow": z.object({ op: z.literal("remove-workflow"), name: kindName }).strict(),
+        "pause-workflow": z.object({ op: z.literal("pause-workflow"), name: kindName }).strict(),
+        "resume-workflow": z.object({ op: z.literal("resume-workflow"), name: kindName }).strict(),
     };
 }
 let shapes;
@@ -1045,8 +1065,12 @@ class Editor {
                 const fields = e.fields;
                 const seen = new Set();
                 for (const [n, field] of fields.entries()) {
-                    if (!spec.fields[field])
-                        return this.fail(i, `fields.${n}`, `a glance at ${e.kind} is to say "${field}", and ${e.kind} has no field called that`, `use one of: ${Object.keys(spec.fields).join(", ")}`);
+                    // A computed field may be glanced at (FR-83): worked out for each card, as its page works it out — unless it is kept off what a record says of itself.
+                    const worked = spec.computed?.[field];
+                    if (!spec.fields[field] && worked === undefined)
+                        return this.fail(i, `fields.${n}`, `a glance at ${e.kind} is to say "${field}", and ${e.kind} has no field or computed field called that`, `use one of: ${[...Object.keys(spec.fields), ...Object.keys(spec.computed ?? {})].join(", ")}`);
+                    if (!spec.fields[field] && isObject(worked) && worked["hidden"] === true)
+                        return this.fail(i, `fields.${n}`, `${e.kind}'s "${field}" is worked out and kept off its card, page and CSV, so a glance cannot say it`, `show it first: set-computed with "hidden": false`);
                     if (seen.has(field))
                         return this.fail(i, `fields.${n}`, `"${field}" is in the glance twice; name each field once`);
                     seen.add(field);
@@ -1085,6 +1109,10 @@ class Editor {
                 return this.setArchives(i, e);
             case "set-tidying":
                 return this.setTidying(i, e);
+            case "set-app-tidying":
+                return this.setAppTidying(e);
+            case "set-derives":
+                return this.setDerives(i, e);
             case "add-grant":
             case "remove-grant":
             case "add-sight":
@@ -1104,6 +1132,15 @@ class Editor {
                 return this.setAliases(i, e.kind, e.field, e.aliases ?? []);
             case "set-connection":
                 return this.setConnection(i, e.name, e.connection);
+            case "add-workflow":
+                return this.placeWorkflow(i, e.name, e.workflow, "add");
+            case "set-workflow":
+                return this.placeWorkflow(i, e.name, e.workflow, "set");
+            case "remove-workflow":
+                return this.removeWorkflow(i, e.name);
+            case "pause-workflow":
+            case "resume-workflow":
+                return this.setWorkflowStatus(i, e.name, e.op === "pause-workflow" ? "paused" : "active");
         }
     }
     // ── a connection, declared whole (FR-229) ──
@@ -1131,7 +1168,9 @@ class Editor {
         const was = this.doc.connections?.[name] !== undefined;
         (this.doc.connections ??= {})[name] = parsed.data;
         const system = parsed.data.system === "notion" ? "a Notion database" : "a Google calendar";
-        this.said.push(`The connection ${name} ${was ? "now keeps" : "keeps"} ${pluralOf(this.doc.kinds, parsed.data.kind)} in step with ${system}${parsed.data.direction === "read" ? ", which owns them" : ", both ways"}.`);
+        const kinds = connectionKinds(parsed.data).map((kind) => pluralOf(this.doc.kinds, kind));
+        const said = kinds.length <= 1 ? kinds.join("") : `${kinds.slice(0, -1).join(", ")} and ${kinds.at(-1)}`;
+        this.said.push(`The connection ${name} ${was ? "now keeps" : "keeps"} ${said} in step with ${system}${parsed.data.direction === "read" ? ", which owns them" : ", both ways"}.`);
     }
     // ── other words for a kind or a field (Roadmap f-learned-suggestions) ──
     aliasesOf(kind, field) {
@@ -1258,6 +1297,58 @@ class Editor {
         this.keepPurpose({ ...this.doc.purpose });
         this.said.push(`The job "${job.name}" (${quotedAtTheEnd(job.ask)}) is removed.`);
     }
+    // ── what the app does on its own, and when (Roadmap f-jobs-declared) ──
+    /** The workflow a name names, or undefined having said why. */
+    workflowNamed(i, name) {
+        const workflows = this.doc.workflows ?? {};
+        if (Object.hasOwn(workflows, name))
+            return workflows[name];
+        const names = Object.keys(workflows);
+        this.fail(i, "name", `there is no workflow "${name}"${names.length > 0 ? `; the workflows are ${names.map((one) => `"${one}"`).join(", ")}` : ""}`);
+        return undefined;
+    }
+    /** A workflow added or replaced whole, judged as `graview check` judges it (`workflow-*`): kept only when nothing is wrong with it. */
+    placeWorkflow(i, name, workflow, how) {
+        const workflows = { ...(this.doc.workflows ?? {}) };
+        if (how === "add" && Object.hasOwn(workflows, name))
+            return this.fail(i, "name", `there is already a workflow "${name}"`, `Change it with {"op": "set-workflow", "name": "${name}", …}, or name this one otherwise.`);
+        if (how === "set" && !Object.hasOwn(workflows, name) && !this.workflowNamed(i, name))
+            return;
+        const shaped = typeof workflow.title === "string" && Array.isArray(workflow.when) && workflow.when.length > 0 && Array.isArray(workflow.steps) && workflow.steps.length > 0;
+        if (!shaped)
+            return this.fail(i, "workflow", "a workflow is { title, when: [...], steps: [...] }, each list with at least one", `{"op": "${how}-workflow", "name": "${name}", "workflow": {"title": "…", "when": [{"every": "day 03:00"}], "steps": [{"act": "…"}]}}`);
+        // Judged as `graview check` judges it, where the checker is loaded; else kept as shaped, and the check says the rest.
+        const judged = WORKFLOW_JUDGING.judge?.(name, workflow, { ...this.doc, workflows });
+        for (const finding of judged?.errors ?? [])
+            this.failAs(finding.code, i, `workflow${finding.path ? `.${finding.path}` : ""}`, finding.message, finding.fix);
+        if (judged && judged.errors.length > 0)
+            return;
+        workflows[name] = workflow;
+        this.doc.workflows = workflows;
+        const steps = workflow.steps.length;
+        this.said.push(`${how === "add" ? "A new workflow" : "The workflow"} “${workflow.title}”${how === "add" ? "" : " is now"}: ${judged?.said ?? `${steps === 1 ? "one step" : `${steps} steps`}${workflow.status === "paused" ? ", paused" : ""}`}.`);
+        for (const warning of judged?.warnings ?? [])
+            this.said.push(warning);
+    }
+    removeWorkflow(i, name) {
+        const workflow = this.workflowNamed(i, name);
+        if (!workflow)
+            return;
+        const { [name]: _gone, ...rest } = this.doc.workflows;
+        if (Object.keys(rest).length === 0)
+            delete this.doc.workflows;
+        else
+            this.doc.workflows = rest;
+        this.said.push(`The workflow “${workflow.title ?? name}” is removed.`);
+    }
+    setWorkflowStatus(i, name, status) {
+        const workflow = this.workflowNamed(i, name);
+        if (!workflow)
+            return;
+        const { status: _was, ...rest } = workflow;
+        this.doc.workflows = { ...this.doc.workflows, [name]: status === "paused" ? { ...rest, status } : rest };
+        this.said.push(status === "paused" ? `The workflow “${workflow.title ?? name}” is paused: it runs on no clock and no change until it is resumed.` : `The workflow “${workflow.title ?? name}” runs again.`);
+    }
     /** How a record's page orders and groups its facts (FR-148): judged as the compile judges `kinds.<kind>.page`. */
     setPageFields(i, e) {
         const spec = this.kind(i, e.kind);
@@ -1401,6 +1492,8 @@ class Editor {
         }
         if (name === "columns" && !(this.columnsHold(i, e.bindings) && this.boardOptionsHold(i, e.bindings, e.options)))
             return;
+        if (name === "timeline" && !this.timelineHolds(i, e.bindings, e.options))
+            return;
         if (was)
             lenses[at] = lens;
         else
@@ -1473,6 +1566,44 @@ class Editor {
         }
         return true;
     }
+    /**
+     * A TIMELINE THAT WOULD DRAW, held before it is added: a timeline lays out
+     * spans by number across columns, so each kind it binds is a kind, its
+     * `start` and `end` are number fields, and its columns are named in the
+     * options or read from a choice field bound to `column`. A timeline over a
+     * project's start and end dates was accepted, said nothing and drew
+     * nothing — never a place; it is refused here in the words the checker
+     * uses (`lens-cannot-draw`), pointing spans of dates at the calendar.
+     */
+    timelineHolds(i, bindings, options) {
+        const refuse = (path, message, kind, start, end) => (this.failAs("lens-cannot-draw", i, path, `a timeline here would not draw: ${message}`, timelineBindingsWords(kind, typeof start === "string" ? start : "start", typeof end === "string" ? end : "end")), false);
+        if (!isObject(bindings) || Object.keys(bindings).length === 0)
+            return refuse("bindings", "it binds no kind", "<kind>");
+        let columns = Array.isArray(options?.["columns"]) && options["columns"].length > 0;
+        for (const [kind, roles] of Object.entries(bindings)) {
+            if (!isObject(this.doc.kinds[kind]))
+                return (this.fail(i, `bindings.${kind}`, `"${kind}" is not a kind this app has; it has ${Object.keys(this.doc.kinds).join(", ")}`), false);
+            if (!isObject(roles))
+                return refuse(`bindings.${kind}`, `it does not say which fields of ${kind} it lays out`, kind);
+            const fields = this.doc.kinds[kind].fields;
+            for (const role of TIMELINE_AXIS_ROLES) {
+                const field = roles[role];
+                if (typeof field !== "string")
+                    return refuse(`bindings.${kind}.${role}`, `it does not say which field of ${kind} is its ${role}`, kind, roles["start"], roles["end"]);
+                if (!(field in fields))
+                    return (this.fail(i, `bindings.${kind}.${role}`, `${kind} has no field "${field}"; it has ${Object.keys(fields).join(", ")}`), false);
+                const type = fields[field]["type"];
+                if (type !== "number" && type !== "integer" && type !== "duration")
+                    return refuse(`bindings.${kind}.${role}`, `${kind}'s ${field} is ${withArticle(String(type ?? "text"))} field, and a timeline's axis is a number`, kind, roles["start"], roles["end"]);
+            }
+            const column = typeof roles["column"] === "string" ? roles["column"] : typeof roles["columns"] === "string" ? roles["columns"] : undefined;
+            if (column !== undefined && fields[column]?.["type"] === "enum")
+                columns = true;
+        }
+        if (!columns)
+            return refuse("options.columns", "it has no columns — no option names them and no `column` role is bound to a choice field", Object.keys(bindings)[0]);
+        return true;
+    }
     /**
      * WHAT A BOARD SHOWS OF ITSELF (Roadmap f-lens-search-filter): fields of
      * its kind for Find and the chips, columns of its field to open shut or
@@ -2035,8 +2166,8 @@ class Editor {
                 return this.fail(i, "name", `${e.kind} already has a ${spec.fields[name] ? "field" : "relation"} called "${name}"`);
             if (KEYWORDS.has(name))
                 return this.fail(i, "name", `"${name}" is a word the rule language keeps; pick another name`);
-            if (Object.keys(spec.computed ?? {}).length >= 20)
-                return this.fail(i, "name", "a kind works out at most 20 computed fields");
+            if (Object.keys(spec.computed ?? {}).length >= MOST_COMPUTED)
+                return this.fail(i, "name", `a kind works out at most ${MOST_COMPUTED} computed fields`);
         }
         const was = existing === undefined ? {} : typeof existing === "string" ? { expr: existing } : { ...existing };
         const next = { ...was };
@@ -2128,6 +2259,86 @@ class Editor {
      * never tidied is given no leave-alone-<kind> or allow-tidying-<kind>,
      * which a grant may not then name.
      */
+    /**
+     * WHAT A KIND FOLLOWS (Roadmap f-keep-linked): each record of it linked
+     * through `via` to a record of `from` takes the fields `set` works out
+     * from it, kept in step by the store in the same change; null, it
+     * follows nothing and its records keep the values they hold.
+     */
+    setDerives(i, e) {
+        const spec = this.kind(i, e.kind);
+        if (!spec)
+            return;
+        if (e.derives === null) {
+            const was = spec.derives?.from;
+            delete spec.derives;
+            this.said.push(was ? derivesSentence(e.kind, undefined) : `${e.kind} follows nothing, as before.`);
+            return;
+        }
+        const { from, via, set } = e.derives;
+        if (!this.doc.kinds[from])
+            return this.fail(i, "derives.from", `"${from}" is not a kind this app has`);
+        const joins = (spec.edges?.[via] && (spec.edges[via].to === "*" || spec.edges[via].to.includes(from))) || (this.doc.kinds[from].edges?.[via] && (this.doc.kinds[from].edges[via].to === "*" || this.doc.kinds[from].edges[via].to.includes(e.kind)));
+        if (!joins)
+            return this.fail(i, "derives.via", `"${via}" does not join ${words(e.kind)} to ${words(from)}`, `name a relation of ${e.kind} to ${from}, or of ${from} to ${e.kind} (add one with add-relation in the same change)`);
+        spec.derives = { from, via, set };
+        this.said.push(derivesSentence(e.kind, spec.derives));
+    }
+    /**
+     * WHAT A KIND FOLLOWS, held to a rename or a removal (Roadmap
+     * f-keep-linked): the names it says follow a rename; a value reading
+     * what is removed goes, and a `derives` left setting nothing, or
+     * following a kind or relation that is gone, goes with it.
+     */
+    followDerives(r, removing) {
+        const touched = [];
+        for (const [kind, spec] of Object.entries(this.doc.kinds)) {
+            const d = spec.derives;
+            if (!d)
+                continue;
+            const before = JSON.stringify(d);
+            const ctx = new Set([d.from]);
+            if ((r.t === "kind" && d.from === r.from) || (r.t === "edge" && d.via === r.from)) {
+                if (removing) {
+                    delete spec.derives;
+                    touched.push(`what ${kind} follows`);
+                    continue;
+                }
+            }
+            const set = {};
+            for (const [field, value] of Object.entries(d.set ?? {})) {
+                let key = field;
+                if (r.t === "field" && r.kind === kind && field === r.from) {
+                    if (removing)
+                        continue;
+                    key = r.to;
+                }
+                if (isObject(value) && typeof value.expr === "string") {
+                    const source = value.expr;
+                    if (removing) {
+                        if (!exprMentions(this.doc, source, ctx, r))
+                            set[key] = value;
+                    }
+                    else
+                        set[key] = { expr: rewriteExpr(this.doc, source, ctx, r) };
+                }
+                else
+                    set[key] = value;
+            }
+            if (!removing && r.t === "kind" && d.from === r.from)
+                d.from = r.to;
+            if (!removing && r.t === "edge" && d.via === r.from)
+                d.via = r.to;
+            d.set = set;
+            if (Object.keys(set).length === 0) {
+                delete spec.derives;
+                touched.push(`what ${kind} follows`);
+            }
+            else if (JSON.stringify(d) !== before)
+                touched.push(`what ${kind} follows`);
+        }
+        return touched;
+    }
     setTidying(i, e) {
         const spec = this.kind(i, e.kind);
         if (!spec)
@@ -2166,6 +2377,26 @@ class Editor {
             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));
     }
+    /**
+     * WHAT THE APP SAYS OF SUGGESTIONS AS A WHOLE (Roadmap f-suggestion-votes):
+     * `tidying.autoAcceptAt`, the votes for a suggestion at which the app's
+     * own actor makes it; null takes it away, and a suggestion waits for
+     * somebody who may decide. A `tidying` left saying nothing goes.
+     */
+    setAppTidying(e) {
+        const autoAcceptAt = e.autoAcceptAt;
+        const was = this.doc.tidying?.autoAcceptAt;
+        const tidying = { ...(this.doc.tidying ?? {}) };
+        if (autoAcceptAt === null)
+            delete tidying.autoAcceptAt;
+        else
+            tidying.autoAcceptAt = autoAcceptAt;
+        if (Object.keys(tidying).length === 0)
+            delete this.doc.tidying;
+        else
+            this.doc.tidying = tidying;
+        this.said.push(appTidyingSentence(autoAcceptAt ?? undefined, was === (autoAcceptAt ?? undefined)));
+    }
     /** 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;
@@ -2198,13 +2429,15 @@ class Editor {
                 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()) {
+        for (const key of sight ? [] : ["mutations", "propose"]) {
+            if (part[key] === undefined || part[key] === "*")
+                continue;
+            for (const [n, act] of part[key].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)) && (this.doc.kinds[derived.kind].tidying !== "never" || givenWhenNeverTidied(derived.act))) || givesRelationAct(act, this.doc.kinds))
                     continue;
                 const relationActs = relationActsOf(documentRelations(this.doc.kinds)).filter((name) => givesRelationAct(name, this.doc.kinds));
-                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), ...relationActs].join(", ")}`);
+                return this.failAs("grant-act", i, `${key}.${n}`, `"${act}" is not an act this app has`, `one of ${[...Object.keys(this.doc.acts ?? {}), ...Object.keys(this.doc.kinds).flatMap(derivedActsOf), ...relationActs].join(", ")}`);
             }
         }
         const said = [];
@@ -2245,10 +2478,10 @@ class Editor {
     removePolicyPart(i, part, sight) {
         const list = (sight ? this.doc.policy?.sees : this.doc.policy?.grants) ?? [];
         const sameSet = (a, b) => a === b || (Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((x) => b.includes(x)));
-        const keys = sight ? ["own", "via"] : ["kinds", "self", "ownEnd", "describe"];
+        const keys = sight ? ["own", "via"] : ["kinds", "self", "ownEnd", "propose", "describe"];
         const matches = list.filter((one) => sameSet(one.roles, part.roles) &&
             (sight ? sameSet(one.kinds, part.kinds) : sameSet(one.mutations, part.mutations)) &&
-            keys.every((key) => part[key] === undefined || (typeof part[key] === "boolean" ? (one[key] ?? false) === part[key] : key === "kinds" ? sameSet(one[key] ?? "*", part[key]) : one[key] === part[key])));
+            keys.every((key) => part[key] === undefined || (typeof part[key] === "boolean" ? (one[key] ?? false) === part[key] : key === "kinds" ? sameSet(one[key] ?? "*", part[key]) : key === "propose" ? sameSet(one[key], part[key]) : one[key] === part[key])));
         const what = sight ? "sight" : "grant";
         const say = (one) => (sight ? `${whoWords(one.roles)} ${sightWords(this.doc, one)}` : grantBody(this.doc, one));
         if (matches.length === 0) {
@@ -2477,6 +2710,7 @@ class Editor {
          * kind, or drew by it, goes, and `pages.first` with it when it named it.
          */
         const swept = { t: "kind", from: kind, to: "\u0000" };
+        gone.push(...this.followDerives(swept, true));
         for (const [other, spec] of Object.entries(this.doc.kinds)) {
             for (const [name, c] of Object.entries(spec.computed ?? {})) {
                 if (exprMentions(this.doc, typeof c === "string" ? c : c.expr, new Set([other]), swept))
@@ -2676,8 +2910,8 @@ class Editor {
         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 (e.format === undefined && e.unit === undefined && e.places === 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), "places" (0 for money in whole units, or null), or some of them');
         if (f.type === "text") {
             if (e.unit !== undefined && e.unit !== null)
                 return this.fail(i, "unit", refusedFormat("a unit", f.type));
@@ -2693,12 +2927,14 @@ class Editor {
         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"]) {
+        for (const key of ["format", "unit", "places"]) {
             if (e[key] === null)
                 delete f[key];
             else if (e[key] !== undefined)
                 f[key] = e[key];
         }
+        if (f.places !== undefined && !isMoney(f))
+            return this.fail(i, "places", `"places" is said of money, and ${e.kind}'s ${e.field} is ${formatWords(f, this.doc.brand) ?? "a plain number"}`, 'say "format": "money" with it, or leave "places" out');
         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.`);
     }
@@ -2710,19 +2946,21 @@ class Editor {
      * its expression is left.
      */
     setComputedFormat(i, e, worked) {
-        if (e.format === undefined && e.unit === undefined)
-            return this.fail(i, "format", 'say a "format" ("money", "percent" or "duration", or null for none), a "unit" ("EUR", "kg", or null), or both');
+        if (e.format === undefined && e.unit === undefined && e.places === undefined)
+            return this.fail(i, "format", 'say a "format" ("money", "percent" or "duration", or null for none), a "unit" ("EUR", "kg", or null), "places" (0 for money in whole units, or null), or some of them');
         if (e.format === "markdown")
             return this.fail(i, "format", `${e.field} is worked out, not written, so it cannot be Markdown; a computed field is said as "money", "percent" or "duration"`);
         const spec = this.doc.kinds[e.kind];
         const next = typeof worked === "string" ? { expr: worked } : { ...worked };
         const before = formatWords(next, this.doc.brand);
-        for (const key of ["format", "unit"]) {
+        for (const key of ["format", "unit", "places"]) {
             if (e[key] === null)
                 delete next[key];
             else if (e[key] !== undefined)
                 next[key] = e[key];
         }
+        if (next.places !== undefined && !isMoney(next))
+            return this.fail(i, "places", `"places" is said of money, and ${e.kind}'s ${e.field} is ${formatWords(next, this.doc.brand) ?? "a plain number"}`, 'say "format": "money" with it, or leave "places" out');
         spec.computed[e.field] = Object.keys(next).length === 1 ? next.expr : next;
         const now = formatWords(next, this.doc.brand);
         this.said.push(`${e.kind}'s ${e.field} is worked out as before and said as ${now ?? "a plain number"}${before ? `, where it was ${before.replace(/ — .*/, "")}` : ""}.`);
@@ -3065,6 +3303,8 @@ class Editor {
         const prose = r.t === "field" ? proseSwap(r.from, r.to) : r.t === "kind" ? proseSwap(r.from, r.to) : undefined;
         const exprAt = (source, ctx) => (source === undefined ? undefined : rewriteExpr(doc, source, ctx, r));
         const tmplAt = (source, ctx, words) => (source === undefined ? undefined : rewriteTemplate(doc, source, ctx, r, words));
+        // What a kind follows (Roadmap f-keep-linked): its kind, relation and values follow the rename.
+        touched.push(...this.followDerives(r, false));
         // Kinds: templates, the lifecycle, where relations lead.
         for (const [kind, spec] of Object.entries(doc.kinds)) {
             const here = new Set([kind]);
@@ -3373,6 +3613,7 @@ class Editor {
         // 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));
+        gone.push(...this.followDerives(r, true));
         for (const [kind, spec] of Object.entries(doc.kinds)) {
             for (const key of ["label", "describe"]) {
                 if (templateMentions(doc, spec[key], new Set([kind]), r)) {