@graview/core 0.1.60 → 0.1.62

package/dist/document/edit.js

@@ -18,6 +18,7 @@ import { jobFindings, jobWorldOfDocument } from "../job-findings.js";
 import { JobSpec } from "./purpose-spec.js";
 import { aliasWord, documentAliasFindings } from "../alias-findings.js";
 import { humanizeField, withArticle } from "../schema/define-node.js";
+import { ConnectionSpec } 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";
@@ -28,7 +29,7 @@ import { documentListFields, kindListFindings, kindListWords, listGroup, listSor
 import { computedOf, validateComputed } from "./computed.js";
 import { parseTemplate, templateBraces, TemplateError } from "./template-parse.js";
 import { validateViews, VIEW_SLOTS } from "./views.js";
-import { brandFindings, emojiIconSentence, groundWords, subtitleSentence } from "./brand-check.js";
+import { brandFindings, emojiIconSentence, groundWords, splashSentence, subtitleSentence, viewsCssSentence, viewsMotionSentence } from "./brand-check.js";
 import { darkLogoSentence, logoParts } from "./logo.js";
 import { emojiOf } from "../theme/marks.js";
 import { canonicalize } from "./canonical.js";
@@ -93,6 +94,7 @@ export const EDIT_OPS = [
     "remove-job",
     "add-alias",
     "set-aliases",
+    "set-connection",
 ];
 /** 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"]);
@@ -122,7 +124,7 @@ function buildShapes() {
         "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", "video", "file"]).optional(), format: z.enum(["money", "percent", "duration", "markdown"]).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(), 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-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(),
@@ -165,6 +167,15 @@ function buildShapes() {
             scheme: z.union([z.enum(["light", "dark", "auto"]), z.null()]).optional(),
             // 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(),
+            // 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([
+                z.object({ css: z.union([z.string().min(1), z.null()]).optional(), motion: z.union([z.enum(["none", "fade"]), z.null()]).optional() }).strict(),
+                z.null(),
+            ])
+                .optional(),
         })
             .strict(),
         "set-name": z.object({ op: z.literal("set-name"), name: z.string().min(1).max(80) }).strict(),
@@ -269,6 +280,8 @@ function buildShapes() {
         "add-alias": z.object({ op: z.literal("add-alias"), kind: kindName, field: fieldName.optional(), alias: z.string().min(1).max(40) }).strict(),
         // All of a kind's or a field's other words at once; null or [] takes them away.
         "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(),
     };
 }
 let shapes;
@@ -276,6 +289,13 @@ const opShapes = () => (shapes ??= buildShapes());
 const NONE = new Set();
 const clone = (v) => structuredClone(v);
 const asArray = (v) => [v ?? []].flat();
+/** The first of a choice's default that is none of its options — a list of them where the choice takes several (FR-233) — or undefined when every one is. */
+function defaultOutsideOptions(f, given) {
+    const options = f.options ?? [];
+    if (!f.multiple)
+        return Array.isArray(given) || !options.includes(String(given)) ? given : undefined;
+    return (Array.isArray(given) ? given : [given]).find((one) => !options.includes(String(one)));
+}
 const kebab = (camel) => camel.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
 const words = (name) => kebab(name).replace(/-/g, " ");
 /** Another app's kinds as people say them: "one house in the app @nick/house", "houses or flats in the app @nick/house". Their plural is that app's to say; this one says the plain one. */
@@ -539,6 +559,11 @@ function setTargets(act, doc) {
         const end = doc && relation ? farEnd(doc.kinds, relation, asArray(act.on)) : undefined;
         out.push({ set: act.setsOther, kinds: end && end.kinds !== "*" ? new Set(end.kinds) : "*", where: "setsOther" });
     }
+    // What it carries to the records linked to its subject, by relation: the kinds at each relation's far end.
+    for (const [relation, set] of Object.entries(act.setsLinked ?? {})) {
+        const end = doc ? farEnd(doc.kinds, relation, asArray(act.on)) : undefined;
+        out.push({ set, kinds: end && end.kinds !== "*" ? new Set(end.kinds) : "*", where: "setsLinked", relation });
+    }
     (act.effects ?? []).forEach((e, index) => {
         if (e.create)
             out.push({ set: e.set ?? {}, kinds: new Set([e.create]), where: "create", index });
@@ -591,10 +616,18 @@ class Editor {
         const named = Object.keys(e).filter((key) => key !== "op" && e[key] !== undefined);
         if (named.length === 0)
             return this.fail(i, "", "a set-brand edit names at least one key of the brand to set, or null to clear one", '{"op": "set-brand", "accent": "#0f6e5c"}');
-        const emptyPart = ["typography", "shape", "accents"].find((key) => isObject(e[key]) && Object.keys(e[key]).length === 0);
+        const emptyPart = ["typography", "shape", "accents", "views"].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.timeZone === "string" ? { timeZone: e.timeZone } : {}), ...(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 } : {}) });
+        const judged = brandFindings({
+            ...(typeof e.timeZone === "string" ? { timeZone: e.timeZone } : {}),
+            ...(isObject(e.splash) ? { splash: e.splash } : {}),
+            ...(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")) } : {}),
+            // The stylesheet every view gets is judged as a page draws it (Roadmap f-app-wide-view-theme): an edit that would leave part of it undrawn is refused, saying which part.
+            ...(isObject(e.views) && typeof e.views["css"] === "string" ? { views: { css: e.views["css"] } } : {}),
+        }, { at, ...(this.options.fonts ? { fonts: this.options.fonts } : {}) });
         if (judged.length > 0)
             return void this.findings.push(...judged);
         if (e.accent === null) {
@@ -768,6 +801,45 @@ class Editor {
                 delete brand["subtitle"];
             this.said.push(subtitleSentence(e.subtitle !== false));
         }
+        // The opening screen is set whole or cleared: its keys are few, and half of one is nothing a page could draw.
+        if (e.splash !== undefined) {
+            if (e.splash === null)
+                delete brand["splash"];
+            else
+                brand["splash"] = e.splash;
+            if (!(e.splash === null && !isObject(this.doc.brand?.splash)))
+                this.said.push(splashSentence(e.splash));
+        }
+        /* What every view inherits (Roadmap f-app-wide-view-theme): the stylesheet and the fade, each set or cleared on its own, null clearing both. */
+        if (e.views === null) {
+            const had = brand["views"] ?? {};
+            if (had["css"] !== undefined || had["motion"] === undefined)
+                this.said.push(viewsCssSentence(false));
+            if (had["motion"] === "fade")
+                this.said.push(viewsMotionSentence(undefined));
+            delete brand["views"];
+        }
+        else if (isObject(e.views)) {
+            const into = { ...(brand["views"] ?? {}) };
+            if (e.views["css"] !== undefined) {
+                if (e.views["css"] === null)
+                    delete into["css"];
+                else
+                    into["css"] = e.views["css"];
+                this.said.push(viewsCssSentence(e.views["css"] !== null));
+            }
+            if (e.views["motion"] !== undefined) {
+                if (e.views["motion"] === "fade")
+                    into["motion"] = "fade";
+                else
+                    delete into["motion"];
+                this.said.push(viewsMotionSentence(e.views["motion"] === "fade" ? "fade" : undefined));
+            }
+            if (Object.keys(into).length === 0)
+                delete brand["views"];
+            else
+                brand["views"] = into;
+        }
         if (Object.keys(brand).length === 0)
             delete this.doc.brand;
         else
@@ -860,8 +932,8 @@ class Editor {
                     this.said.push(`${e.kind}'s ${e.field} has no default now.`);
                 }
                 else {
-                    if (f.type === "enum" && !(f.options ?? []).includes(e.default))
-                        return this.fail(i, "default", `"${String(e.default)}" is not one of ${e.field}'s options (${(f.options ?? []).join(", ")})`);
+                    if (f.type === "enum" && defaultOutsideOptions(f, e.default) !== undefined)
+                        return this.fail(i, "default", `"${String(defaultOutsideOptions(f, e.default))}" is not one of ${e.field}'s options (${(f.options ?? []).join(", ")})`);
                     const outside = outsideRange(e.default, f, e.field);
                     if (outside)
                         return this.fail(i, "default", outside);
@@ -1030,8 +1102,37 @@ class Editor {
                 return this.setAliases(i, e.kind, e.field, [...this.aliasesOf(e.kind, e.field), e.alias], e.alias);
             case "set-aliases":
                 return this.setAliases(i, e.kind, e.field, e.aliases ?? []);
+            case "set-connection":
+                return this.setConnection(i, e.name, e.connection);
         }
     }
+    // ── a connection, declared whole (FR-229) ──
+    /**
+     * A CONNECTION SET BY NAME: its shape is judged here, as the document's
+     * is; what it says of the kind and the fields it maps, and the acts an
+     * inbound change lands through, the checker judges of the document it
+     * leaves (`connection-findings.ts`). Null takes the connection away.
+     */
+    setConnection(i, name, connection) {
+        if (connection === null) {
+            if (!this.doc.connections?.[name])
+                return this.fail(i, "name", `there is no connection called "${name}"${this.doc.connections ? `; there ${Object.keys(this.doc.connections).length === 1 ? "is" : "are"} ${Object.keys(this.doc.connections).join(", ")}` : ""}`);
+            delete this.doc.connections[name];
+            if (Object.keys(this.doc.connections).length === 0)
+                delete this.doc.connections;
+            this.said.push(`The connection ${name} is gone: nothing keeps its records in step now.`);
+            return;
+        }
+        const parsed = ConnectionSpec.safeParse(connection);
+        if (!parsed.success) {
+            this.refuse(i, parsed.error.issues.map((issue) => ({ ...issue, path: ["connection", ...issue.path] })), "a connection");
+            return;
+        }
+        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"}.`);
+    }
     // ── other words for a kind or a field (Roadmap f-learned-suggestions) ──
     aliasesOf(kind, field) {
         const spec = this.doc.kinds[kind];
@@ -1361,9 +1462,10 @@ class Editor {
                 return (this.fail(i, `bindings.${kind}.column`, `the board does not say which field of ${kind} its columns are`, example), false);
             if (!(field in fields))
                 return (this.fail(i, `bindings.${kind}.column`, `${kind} has no field "${field}"; it has ${Object.keys(fields).join(", ")}`), false);
-            if (fields[field]["type"] !== "enum") {
-                const choices = Object.keys(fields).filter((one) => fields[one]["type"] === "enum");
-                return (this.fail(i, `bindings.${kind}.column`, `${kind}'s ${field} is not a choice, so it has no columns`, choices.length > 0 ? `bind one of ${choices.join(", ")}` : `give ${kind} a choice field first: add-field with "type": "enum" and its "options", in the order the columns go`), false);
+            // A choice that takes several of its options (FR-233) has no columns: a record would stand in several.
+            if (fields[field]["type"] !== "enum" || fields[field]["multiple"] === true) {
+                const choices = Object.keys(fields).filter((one) => fields[one]["type"] === "enum" && fields[one]["multiple"] !== true);
+                return (this.fail(i, `bindings.${kind}.column`, `${kind}'s ${field} is ${fields[field]["multiple"] === true ? "a choice of several, so a record would stand in more than one column" : "not a choice, so it has no columns"}`, choices.length > 0 ? `bind one of ${choices.join(", ")}` : `give ${kind} a choice field first: add-field with "type": "enum" and its "options", in the order the columns go`), false);
             }
             const others = Object.keys(roles).filter((role) => role !== "column");
             if (others.length > 0)
@@ -2237,6 +2339,12 @@ 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 hue follows it.
+        if (isObject(this.doc.brand?.accents) && from in this.doc.brand.accents && !(to in this.doc.brand.accents)) {
+            this.doc.brand.accents[to] = this.doc.brand.accents[from];
+            delete this.doc.brand.accents[from];
+            touched.push("its hue");
+        }
         // Its list's filters, order and grouping follow it.
         const lists = this.doc.pages?.lists;
         if (lists?.[from] !== undefined && lists[to] === undefined) {
@@ -2288,6 +2396,7 @@ class Editor {
                     gone.push(what);
         }
         const removedPlural = this.doc.kinds[kind].plural ?? `${words(kind)}s`;
+        const people = this.doc.kinds[kind].people === true;
         // Its own relations' connect and disconnect go with it.
         const ownRelationActs = relationActsOf(documentRelations({ [kind]: this.doc.kinds[kind] }));
         delete this.doc.kinds[kind];
@@ -2306,17 +2415,27 @@ class Editor {
                 }
             }
         }
+        // With the people kind gone, an act on the acting person's own record (`$me`) has no record to reach: it goes too.
         for (const [name, act] of Object.entries(this.doc.acts ?? {})) {
             const on = asArray(act.on);
-            if (act.creates === kind || (act.effects ?? []).some((x) => x.create === kind) || (on.includes(kind) && on.length === 1)) {
+            if (act.creates === kind || (act.effects ?? []).some((x) => x.create === kind) || (on.includes(kind) && on.length === 1) || (people && JSON.stringify(act).includes('"$me"'))) {
                 gone.push(titled("act", name, act));
                 this.removeActQuietly(name);
             }
             else if (on.includes(kind))
                 act.on = on.filter((k) => k !== kind);
         }
+        // Its hue goes with it: an accent for a kind nobody declares is refused by the checker.
+        if (isObject(this.doc.brand?.accents) && kind in this.doc.brand.accents) {
+            delete this.doc.brand.accents[kind];
+            if (Object.keys(this.doc.brand.accents).length === 0)
+                delete this.doc.brand.accents;
+            if (Object.keys(this.doc.brand).length === 0)
+                delete this.doc.brand;
+            gone.push("its hue");
+        }
         for (const [name, rule] of Object.entries(this.doc.rules ?? {})) {
-            if (rule.over === kind || exprMentions(this.doc, rule.when, rule.over === "graph" ? NONE : new Set([rule.over]), { t: "kind", from: kind, to: "\u0000" }) || exprMentions(this.doc, rule.require, rule.over === "graph" ? NONE : new Set([rule.over]), { t: "kind", from: kind, to: "\u0000" })) {
+            if (rule.over === kind || rule.covers?.every === kind || exprMentions(this.doc, rule.when, rule.over === "graph" ? NONE : new Set([rule.over]), { t: "kind", from: kind, to: "\u0000" }) || exprMentions(this.doc, rule.require, rule.over === "graph" ? NONE : new Set([rule.over]), { t: "kind", from: kind, to: "\u0000" })) {
                 delete this.doc.rules[name];
                 gone.push(titled("rule", name, rule));
             }
@@ -2342,7 +2461,12 @@ class Editor {
             });
         }
         if (this.doc.policy?.sees) {
-            this.doc.policy.sees = this.doc.policy.sees.map((s) => ({ ...s, kinds: s.kinds.filter((k) => k !== kind) })).filter((s) => s.kinds.length > 0);
+            // A sight of other kinds through a relation that went with the kind would show nothing: it goes too.
+            const declared = new Set(Object.values(this.doc.kinds).flatMap((spec) => Object.keys(spec.edges ?? {})));
+            const through = this.doc.policy.sees.filter((s) => typeof s.via === "string" && !declared.has(s.via) && s.kinds.some((k) => k !== kind));
+            if (through.length > 0)
+                gone.push(`${through.length === 1 ? "the sight" : "the sights"} through ${listOf([...new Set(through.map((s) => `"${String(s.via)}"`))])}`);
+            this.doc.policy.sees = this.doc.policy.sees.filter((s) => !through.includes(s)).map((s) => ({ ...s, kinds: s.kinds.filter((k) => k !== kind) })).filter((s) => s.kinds.length > 0);
             if (this.doc.policy.sees.length === 0)
                 delete this.doc.policy.sees;
         }
@@ -2397,8 +2521,8 @@ class Editor {
         }
         const f = { ...parsed.data };
         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.type === "enum" && f.default !== undefined && defaultOutsideOptions(f, f.default) !== undefined)
+            return this.fail(i, "default", `"${String(defaultOutsideOptions(f, 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;
@@ -2489,11 +2613,18 @@ class Editor {
         if (e.format && !formatFits(e.format, e.type))
             return this.fail(i, "format", refusedFormat(e.format, e.type));
         const was = f.type;
+        const wasSeveral = f.multiple === true;
         f.type = e.type;
         if (e.type === "enum")
             f.options = e.options ?? f.options;
         else
             delete f.options;
+        // A choice that takes several of its options (FR-233), or one again: only an enum says it, and a retype says it anew.
+        if (e.type === "enum" && e.multiple)
+            f.multiple = true;
+        else
+            delete f.multiple;
+        const several = f.multiple === true;
         // An option's label goes with the option.
         if (f.optionLabels) {
             f.optionLabels = Object.fromEntries(Object.entries(f.optionLabels).filter(([o]) => (f.options ?? []).includes(o)));
@@ -2523,9 +2654,11 @@ class Editor {
         // 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}`}.`);
+            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" ? (several ? "a choice of one" : "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 if (was === e.type && e.type === "enum" && wasSeveral !== several)
+            this.said.push(several ? `${e.kind}'s ${e.field} now takes several of its options at once; the one each record held is kept as a list of one.` : `${e.kind}'s ${e.field} takes one of its options again; the first each record held is 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.`);
     }
@@ -2986,6 +3119,12 @@ class Editor {
                     act.severs = r.to;
                 if (Array.isArray(act.replaces))
                     act.replaces = act.replaces.map((e) => (e === r.from ? r.to : e));
+                if (act.setsLinked?.[r.from] !== undefined) {
+                    const carried = {};
+                    for (const [k, v] of Object.entries(act.setsLinked))
+                        carried[k === r.from ? r.to : k] = v;
+                    act.setsLinked = carried;
+                }
                 for (const e of act.effects ?? []) {
                     if (e.connect === r.from)
                         e.connect = r.to;
@@ -3009,6 +3148,8 @@ class Editor {
                         act.sets = renamed;
                     else if (t.where === "setsOther")
                         act.setsOther = renamed;
+                    else if (t.where === "setsLinked")
+                        act.setsLinked[t.relation] = renamed;
                     else
                         act.effects[t.index].set = renamed;
                 }
@@ -3072,7 +3213,17 @@ class Editor {
             const ctx = rule.over === "graph" ? NONE : new Set([rule.over]);
             if (rule.when !== undefined)
                 rule.when = exprAt(rule.when, ctx);
-            rule.require = exprAt(rule.require, ctx);
+            if (rule.require !== undefined)
+                rule.require = exprAt(rule.require, ctx);
+            // A coverage rule names its kind and its relations outright: each follows its rename.
+            if (rule.covers) {
+                if (r.t === "kind" && rule.covers.every === r.from)
+                    rule.covers.every = r.to;
+                if (r.t === "edge")
+                    for (const key of ["through", "via"])
+                        if (rule.covers[key] === r.from)
+                            rule.covers[key] = r.to;
+            }
             const mentioned = JSON.stringify(rule) !== before;
             if (rule.says !== undefined)
                 rule.says = tmplAt(rule.says, ctx, mentioned ? prose : undefined);
@@ -3253,6 +3404,15 @@ class Editor {
             let uses = exprMentions(doc, act.allowedWhen, on, r) || templateMentions(doc, act.refusal, on, r);
             if (r.t === "edge")
                 uses ||= act.connects === r.from || act.severs === r.from || (act.effects ?? []).some((e) => e.connect === r.from || e.sever === r.from);
+            // A relation it carried values through carries nothing now: the entry goes; an act that did nothing else goes with it.
+            if (r.t === "edge" && !uses && act.setsLinked?.[r.from] !== undefined) {
+                delete act.setsLinked[r.from];
+                if (Object.keys(act.setsLinked).length === 0)
+                    delete act.setsLinked;
+                const stillDoes = act.creates || act.writes || act.sets || act.setsLinked || act.connects || act.severs || act.removes || (act.effects ?? []).length > 0;
+                if (!stillDoes)
+                    uses = true;
+            }
             // A relation it only replaced goes from the list; one that replaced nothing else goes with it (FR-115).
             if (r.t === "edge" && !uses && Array.isArray(act.replaces) && act.replaces.includes(r.from)) {
                 act.replaces = act.replaces.filter((e) => e !== r.from);
@@ -3283,7 +3443,13 @@ class Editor {
                     delete act.sets;
                 if (act.setsOther && Object.keys(act.setsOther).length === 0)
                     delete act.setsOther;
-                const doesSomething = act.creates || act.writes || act.sets || act.connects || act.severs || act.removes || (act.effects ?? []).some((e) => e.create || e.connect || e.sever || e.remove || (e.set && Object.keys(e.set).length > 0));
+                // A relation whose carried fields are all gone carries nothing: it goes from `setsLinked`, and an empty `setsLinked` goes with it.
+                for (const [relation, set] of Object.entries(act.setsLinked ?? {}))
+                    if (Object.keys(set).length === 0)
+                        delete act.setsLinked[relation];
+                if (act.setsLinked && Object.keys(act.setsLinked).length === 0)
+                    delete act.setsLinked;
+                const doesSomething = act.creates || act.writes || act.sets || act.setsLinked || act.connects || act.severs || act.removes || (act.effects ?? []).some((e) => e.create || e.connect || e.sever || e.remove || (e.set && Object.keys(e.set).length > 0));
                 if (!doesSomething)
                     uses = true;
                 else if (act.effects) {
@@ -3298,7 +3464,9 @@ class Editor {
         }
         for (const [name, rule] of Object.entries(doc.rules ?? {})) {
             const ctx = rule.over === "graph" ? NONE : new Set([rule.over]);
-            if (exprMentions(doc, rule.when, ctx, r) || exprMentions(doc, rule.require, ctx, r) || templateMentions(doc, rule.says, ctx, r)) {
+            // A coverage rule goes with the kind it covers or a relation it walks.
+            const walked = rule.covers !== undefined && ((r.t === "kind" && rule.covers.every === r.from) || (r.t === "edge" && (rule.covers.through === r.from || rule.covers.via === r.from)));
+            if (walked || exprMentions(doc, rule.when, ctx, r) || exprMentions(doc, rule.require, ctx, r) || templateMentions(doc, rule.says, ctx, r)) {
                 delete doc.rules[name];
                 gone.push(titled("rule", name, rule));
             }