@graview/core 0.1.27 → 0.1.29

package/dist/document/edit.js

@@ -1,11 +1,19 @@
+import { DERIVED_ACTS, derivedActOf, derivedActsOf, givenWhenNeverArchived } from "../mutations/derived-names.js";
 import { z } from "zod";
 import { ExprSyntaxError, parseExpr } from "./expr/parse.js";
 import { printExpr } from "./expr/print.js";
 import { error } from "./findings.js";
 import { coerce } from "./migrate.js";
 import { outsideRange, rangeWords } from "./range.js";
+import { formatWords } from "./format-words.js";
+import { formatFits, formatMisplaced } from "./format-rules.js";
+/** Why a format is refused where it does not fit, in the checker's words (`field-format`). */
+const refusedFormat = (format, type) => {
+    const { sentence, fix } = formatMisplaced(format, type);
+    return `${sentence}; ${fix}`;
+};
 import { farEnd } from "./far-end.js";
-import { ActSpec, EDGE_NAME, EdgeSpec, FIELD_NAME, FIELD_TYPES, FieldSpec, KindSpec, NAME, RuleSpec, } from "./schema.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 { computedOf, validateComputed } from "./computed.js";
@@ -16,9 +24,12 @@ import { canonicalize } from "./canonical.js";
 import { quotedAtTheEnd } from "./quote.js";
 import { isRecord as isObject, respellDocument } from "./respell.js";
 import { refName } from "./compiled.js";
+import { localeSentence } from "./diff.js";
 import { accentProblem } from "../theme/accent.js";
 import { pageFieldFindings, pageNames, renamedOnPage, withoutOnPage } from "./page-fields.js";
-import { capitalize } from "../capital.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";
 /** The ops, for tool schemas and the guide. */
 export const EDIT_OPS = [
     "add-kind",
@@ -29,8 +40,10 @@ export const EDIT_OPS = [
     "retype-field",
     "set-options",
     "set-range",
+    "set-format",
     "set-required",
     "set-default",
+    "set-repeats",
     "remove-field",
     "add-relation",
     "rename-relation",
@@ -52,6 +65,12 @@ export const EDIT_OPS = [
     "set-home",
     "arrange-pages",
     "set-computed",
+    "set-people",
+    "set-archives",
+    "add-grant",
+    "remove-grant",
+    "add-sight",
+    "remove-sight",
 ];
 /** 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"]);
@@ -68,11 +87,13 @@ const SHAPES = {
     "remove-kind": z.object({ op: z.literal("remove-kind"), kind: kindName }).strict(),
     "add-field": z.object({ op: z.literal("add-field"), kind: kindName, field: fieldName, fill: z.unknown().optional(), spec: z.record(z.string(), z.unknown()).optional() }).passthrough(),
     "rename-field": z.object({ op: z.literal("rename-field"), kind: kindName, field: fieldName, to: fieldName }).strict(),
-    "retype-field": z.object({ op: z.literal("retype-field"), kind: kindName, field: fieldName, type: z.enum(FIELD_TYPES), options: z.array(z.string().min(1).max(80)).min(1).max(100).optional(), of: z.enum(["string", "number", "date", "image", "file"]).optional(), format: z.enum(["money", "percent", "duration"]).optional() }).strict(),
+    "retype-field": z.object({ op: z.literal("retype-field"), kind: kindName, field: fieldName, type: z.enum(FIELD_TYPES), options: z.array(z.string().min(1).max(80)).min(1).max(100).optional(), of: z.enum(["string", "number", "date", "image", "file"]).optional(), format: z.enum(["money", "percent", "duration", "markdown"]).optional() }).strict(),
     "set-options": z.object({ op: z.literal("set-options"), kind: kindName, field: fieldName, add: z.array(z.string().min(1).max(80)).optional(), remove: z.array(z.string().min(1).max(80)).optional() }).strict(),
+    "set-format": z.object({ op: z.literal("set-format"), kind: kindName, field: fieldName, format: z.union([z.enum(["money", "percent", "duration", "markdown"]), z.null()]).optional(), unit: z.union([z.string().min(1).max(12), z.null()]).optional() }).strict(),
     "set-range": z.object({ op: z.literal("set-range"), kind: kindName, field: fieldName, min: z.union([z.number(), z.null()]).optional(), max: z.union([z.number(), z.null()]).optional(), step: z.union([z.number().positive(), z.null()]).optional() }).strict(),
     "set-required": z.object({ op: z.literal("set-required"), kind: kindName, field: fieldName, required: z.boolean() }).strict(),
     "set-default": z.object({ op: z.literal("set-default"), kind: kindName, field: fieldName, default: z.unknown() }).strict(),
+    "set-repeats": z.object({ op: z.literal("set-repeats"), kind: kindName, field: fieldName, repeats: z.boolean() }).strict(),
     "remove-field": z.object({ op: z.literal("remove-field"), kind: kindName, field: fieldName }).strict(),
     "add-relation": z.object({ op: z.literal("add-relation"), kind: kindName, relation: edgeName }).passthrough(),
     "rename-relation": z.object({ op: z.literal("rename-relation"), kind: kindName, relation: edgeName, to: edgeName }).strict(),
@@ -136,6 +157,8 @@ const SHAPES = {
         primary: z.union([z.array(z.string().min(1).max(80)).max(40), z.null()]).optional(),
         scene: z.union([z.string().min(1).max(40), z.null()]).optional(),
         pages: z.union([z.string().min(1).max(40), z.null()]).optional(),
+        // What a kind's list offers to filter by: `{ "request": ["status", "became.stage"] }`; null or [] gives a kind back its derived filters.
+        filters: z.record(kindName, z.union([z.array(z.string().min(1).max(120)).max(40), z.null()])).optional(),
         // The 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(),
     })
@@ -150,6 +173,14 @@ const SHAPES = {
         description: z.union([z.string().min(1).max(500), z.null()]).optional(),
     })
         .strict(),
+    // Who the people are, and who may do and see what (FR-170): a grant and a sight as the document holds one.
+    "set-people": z.object({ op: z.literal("set-people"), kind: kindName, people: z.boolean() }).strict(),
+    // Whether a kind's records are archived and merged, or only kept and removed (FR-173).
+    "set-archives": z.object({ op: z.literal("set-archives"), kind: kindName, archives: z.boolean() }).strict(),
+    "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(),
+    "remove-sight": z.object({ op: z.literal("remove-sight") }).passthrough(),
 };
 const NONE = new Set();
 const clone = (v) => structuredClone(v);
@@ -258,9 +289,10 @@ function mapNames(doc, e, ctx, rename) {
                 const first = x.args[0];
                 const literal = first?.t === "lit" && typeof first.value === "string" ? first.value : undefined;
                 let args;
-                if ((x.fn === "out" || x.fn === "in" || x.fn === "all") && literal !== undefined && x.args.length === 1) {
+                if ((x.fn === "out" || x.fn === "in" || x.fn === "all") && literal !== undefined && (x.args.length === 1 || (x.fn === "all" && x.args.length === 2))) {
                     const name = rename({ role: x.fn === "all" ? "kind" : "edge", kinds: NONE, name: literal });
-                    args = name === literal ? [...x.args] : [{ ...first, value: name }];
+                    // all('task', 'all') keeps what it asked of the archived (FR-173).
+                    args = name === literal ? [...x.args] : [{ ...first, value: name }, ...x.args.slice(1)];
                 }
                 else if ((x.fn === "out" || x.fn === "in") && x.args.length === 2 && x.args[1].t === "lit" && typeof x.args[1].value === "string") {
                     // out(S, 'edge'): the set is read where the walk stands, and its relation renamed like any walk's (FR-101).
@@ -494,13 +526,17 @@ class Editor {
             brand["currency"] = e.currency;
             this.said.push(`Money is said in ${e.currency}.`);
         }
-        if (e.locale === null)
+        if (e.locale === null) {
+            if (brand["locale"] !== undefined)
+                this.said.push(localeSentence(undefined));
             delete brand["locale"];
+        }
         else if (e.locale !== undefined) {
             if (!/^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/.test(e.locale))
                 return this.fail(i, "locale", 'a locale is a language tag, like "en-US" or "de-DE"');
             brand["locale"] = e.locale;
-            this.said.push(`Money is written for ${e.locale}.`);
+            // Its days, times and numbers as well as its money (FR-178).
+            this.said.push(localeSentence(e.locale));
         }
         if (e.name === null) {
             delete brand["name"];
@@ -638,6 +674,8 @@ class Editor {
                 return this.setOptions(i, e);
             case "set-range":
                 return this.setRange(i, e);
+            case "set-format":
+                return this.setFormat(i, e);
             case "set-required": {
                 const f = this.field(i, e.kind, e.field);
                 if (!f)
@@ -668,6 +706,20 @@ class Editor {
                 }
                 return;
             }
+            case "set-repeats": {
+                // A date that repeats keeps how it does beside it, as `<field>Repeat` (`repeat.ts`).
+                const f = this.field(i, e.kind, e.field);
+                if (!f)
+                    return;
+                if (e.repeats && f.type !== "date" && f.type !== "datetime")
+                    return this.fail(i, "repeats", `${e.kind}'s ${e.field} is ${f.type === "enum" ? "a choice" : `a ${f.type}`}, and only a date or a date and time can repeat`);
+                if (e.repeats)
+                    f.repeats = true;
+                else
+                    delete f.repeats;
+                this.said.push(e.repeats ? `${e.kind}'s ${e.field} may repeat: weekly, monthly, on chosen days, until a day.` : `${e.kind}'s ${e.field} no longer repeats.`);
+                return;
+            }
             case "remove-field":
                 return this.removeField(i, e.kind, e.field);
             case "add-relation":
@@ -785,6 +837,15 @@ class Editor {
                 return this.arrangePages(i, e);
             case "set-computed":
                 return this.setComputed(i, e);
+            case "set-people":
+                return this.setPeople(i, e);
+            case "set-archives":
+                return this.setArchives(i, e);
+            case "add-grant":
+            case "remove-grant":
+            case "add-sight":
+            case "remove-sight":
+                return this.policyEdit(i, e);
         }
     }
     /** How a record's page orders and groups its facts (FR-148): judged as the compile judges `kinds.<kind>.page`. */
@@ -985,8 +1046,17 @@ class Editor {
         // `overview` is the scene's word as 0.1.15 and 0.1.16 took it (FR-134): read as `scene`, which wins when both are said.
         const { overview, ...rest } = given;
         const e = rest.scene === undefined && overview !== undefined ? { ...rest, scene: overview } : rest;
-        if (e.order === undefined && e.hide === undefined && e.first === undefined && e.scene === undefined && e.pages === undefined && e.primary === undefined)
-            return this.fail(i, "", 'arrange-pages says at least one of "order", "hide", "first", "primary", "scene" or "pages"');
+        if (e.order === undefined && e.hide === undefined && e.first === undefined && e.scene === undefined && e.pages === undefined && e.primary === undefined && e.filters === undefined)
+            return this.fail(i, "", 'arrange-pages says at least one of "order", "hide", "first", "primary", "scene", "pages" or "filters"');
+        for (const [kind, keys] of Object.entries((e.filters ?? {}))) {
+            if (!this.doc.kinds[kind])
+                return this.fail(i, `filters.${kind}`, `"${kind}" is not a kind this app has; it has ${Object.keys(this.doc.kinds).join(", ")}`);
+            for (const [n, key] of (keys ?? []).entries()) {
+                const offered = this.filterKeys(kind);
+                if (!offered.includes(key))
+                    return this.fail(i, `filters.${kind}.${n}`, `${kind} cannot be filtered by "${key}"`, `name one of ${offered.join(", ")}`);
+            }
+        }
         for (const [n, word] of (e.primary ?? []).entries()) {
             if (typeof word !== "string" || !this.opens(word) || word.trim().toLowerCase() === "home") {
                 const titles = (this.doc.lenses ?? []).flatMap((lens) => (isObject(lens) && typeof lens["title"] === "string" ? [`"${lens["title"]}"`] : []));
@@ -1065,10 +1135,46 @@ class Editor {
                 said.push(`the switch calls the ${face} "${pages[face]}"`);
             }
         }
+        for (const [kind, keys] of Object.entries((e.filters ?? {}))) {
+            const lists = (pages.lists ??= {});
+            if (keys === null || keys.length === 0) {
+                delete lists[kind];
+                said.push(`the list of ${pluralWords(this.doc, kind)} offers its own filters again`);
+            }
+            else {
+                lists[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;
+        }
         if (Object.keys(pages).length === 0)
             delete this.doc.pages;
         this.said.push(`${capitalize(listOf(said))}.`);
     }
+    /** What a kind's list may be filtered by: its fields, its relations either way, `is`, and a choice at a relation's single far kind. */
+    filterKeys(kind) {
+        const kinds = this.doc.kinds;
+        const keys = new Set(["is", ...Object.keys(kinds[kind]?.fields ?? {})]);
+        const edges = new Map();
+        for (const [edge, spec] of Object.entries((kinds[kind]?.edges ?? {})))
+            edges.set(edge, spec.to === "*" ? [] : [spec.to].flat());
+        for (const [other, spec] of Object.entries(kinds)) {
+            for (const [edge, declared] of Object.entries((spec.edges ?? {}))) {
+                if (other !== kind && !edges.has(edge) && (declared.to === "*" || [declared.to].flat().includes(kind)))
+                    edges.set(edge, [other]);
+            }
+        }
+        for (const [edge, far] of edges) {
+            keys.add(edge);
+            if (far.length !== 1 || far[0] === kind)
+                continue;
+            for (const [field, spec] of Object.entries((kinds[far[0]]?.fields ?? {})))
+                if (spec.type === "enum")
+                    keys.add(`${edge}.${field}`);
+        }
+        return [...keys];
+    }
     /** Whether `first` names something the app can open on: home, a kind or its plural, a titled lens. */
     opens(first) {
         const word = first.trim();
@@ -1136,6 +1242,151 @@ class Editor {
         else
             this.said.push(`${plural}' "${name}" is ${next.label ? `shown as "${next.label}"` : "shown by its name"}${next.description ? `, described as "${next.description}"` : ""}.`);
     }
+    // ── who the people are, and who may do and see what (FR-170) ──
+    /** The last edit that changed the people or the policy: where what they make together is judged. */
+    lastPolicyEdit = -1;
+    failAs(code, i, path, message, fix) {
+        this.findings.push(error(code, `edits.${i}${path ? `.${path}` : ""}`, message, fix));
+    }
+    setPeople(i, e) {
+        const spec = this.kind(i, e.kind);
+        if (!spec)
+            return;
+        this.lastPolicyEdit = i;
+        const already = (spec.people === true) === e.people;
+        if (e.people && !already) {
+            // Exactly one kind is the people: a principal's id is a record of it, never of one of two.
+            const other = peopleKinds(this.doc.kinds)[0];
+            if (other)
+                return this.failAs("people-ambiguous", i, "kind", `${pluralOf(this.doc.kinds, other)} are already the people who sign in, and an app has one kind for them`, `{"op": "set-people", "kind": "${other}", "people": false} first, in the same change`);
+            spec.people = true;
+        }
+        else if (!e.people)
+            delete spec.people;
+        this.said.push(peopleSentence(this.doc.kinds, e.kind, e.people, already));
+    }
+    /** A kind's records kept or removed, never archived (FR-173) — or archived and merged again. */
+    setArchives(i, e) {
+        const spec = this.kind(i, e.kind);
+        if (!spec)
+            return;
+        const already = (spec.archives !== false) === e.archives;
+        if (!e.archives && !already) {
+            // A grant that names one of the three acts would name an act the app no longer has.
+            const gone = new Set(["archive", "unarchive", "merge"].map((verb) => `${verb}-${e.kind}`).filter((act) => !this.doc.acts?.[act]));
+            const grant = (this.doc.policy?.grants ?? []).find((g) => Array.isArray(g.mutations) && g.mutations.some((m) => gone.has(m)));
+            if (grant) {
+                const named = grant.mutations.filter((m) => gone.has(m));
+                return this.failAs("grant-unknown-mutation", i, "archives", `a grant names ${listOf(named.map((m) => `"${m}"`))}, which ${pluralOf(this.doc.kinds, e.kind)} would no longer have`, `{"op": "remove-grant", "roles": ${JSON.stringify(grant.roles)}, "mutations": ${JSON.stringify(grant.mutations)}} first, in the same change`);
+            }
+            spec.archives = false;
+        }
+        else if (e.archives)
+            delete spec.archives;
+        if (!already)
+            this.toolsMoved.add(`archive-${e.kind}, unarchive-${e.kind} and merge-${e.kind} ${e.archives ? "are offered" : "are gone"}`);
+        this.said.push(archivesSentence(this.doc.kinds, e.kind, e.archives, already));
+    }
+    /** 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;
+        const parsed = (sight ? SightSpec : GrantSpec).safeParse(rest);
+        if (!parsed.success)
+            return void this.refuse(i, parsed.error.issues, sight ? "a sight" : "a grant");
+        return parsed.data;
+    }
+    policyEdit(i, e) {
+        const sight = e.op === "add-sight" || e.op === "remove-sight";
+        const part = this.policyPart(i, e, sight);
+        if (!part)
+            return;
+        this.lastPolicyEdit = i;
+        if (e.op === "remove-grant" || e.op === "remove-sight")
+            return this.removePolicyPart(i, part, sight);
+        // What it names is the app's: its kinds, and a grant's acts (a kind's derived edit and remove among them).
+        if (!sight && Array.isArray(part.kinds) && part.kinds.length === 0)
+            return this.fail(i, "kinds", "a grant on no kind gives nothing", "leave kinds out for every kind, or name the kinds it is on");
+        for (const [n, kind] of (Array.isArray(part.kinds) ? part.kinds : []).entries()) {
+            if (!this.doc.kinds[kind])
+                return this.failAs(sight ? "sight-kind" : "edit", i, `kinds.${n}`, `"${kind}" is not a kind this app has; it has ${Object.keys(this.doc.kinds).join(", ")}`);
+        }
+        // A field a sight shows or hides is one of the kinds it shows (Roadmap f-field-sight).
+        for (const key of sight ? ["fields", "hide"] : []) {
+            for (const [n, field] of (part[key] ?? []).entries()) {
+                const kinds = part.kinds;
+                if (kinds.some((kind) => this.doc.kinds[kind]?.fields[field]))
+                    continue;
+                return this.failAs("sight-field", i, `${key}.${n}`, `"${field}" is not a field of ${kinds.join(" or ")}`, `one of ${[...new Set(kinds.flatMap((kind) => Object.keys(this.doc.kinds[kind]?.fields ?? {})))].join(", ")}`);
+            }
+        }
+        if (!sight && part.mutations !== "*") {
+            for (const [n, act] of part.mutations.entries()) {
+                const derived = derivedActOf(act);
+                if (this.doc.acts?.[act] || (derived && this.doc.kinds[derived.kind] && (this.doc.kinds[derived.kind].archives !== false || givenWhenNeverArchived(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(", ")}`);
+            }
+        }
+        const said = [];
+        // A role the app has not declared becomes one of its roles, where it declares them.
+        if (Array.isArray(this.doc.roles) && part.roles !== "*") {
+            for (const role of part.roles) {
+                if (this.doc.roles.includes(role))
+                    continue;
+                this.doc.roles.push(role);
+                said.push(`${capitalize(whoWords([role]))} is a new role.`);
+            }
+        }
+        if (!this.doc.policy) {
+            // No policy permits everything; a sight alone would take every act away, so its policy says everyone may still do them.
+            const everything = { roles: "*", mutations: "*" };
+            this.doc.policy = { grants: sight ? [everything] : [] };
+            said.push(FIRST_GRANT, ...(sight ? [grantSentence(this.doc, everything)] : []));
+        }
+        if (sight) {
+            if (!this.doc.policy.sees?.length)
+                said.push(FIRST_SIGHT);
+            (this.doc.policy.sees ??= []).push(part);
+            said.push(sightSentence(this.doc, part));
+        }
+        else {
+            this.doc.policy.grants.push(part);
+            said.push(grantSentence(this.doc, part));
+        }
+        this.said.push(...said);
+    }
+    /**
+     * A GRANT OR A SIGHT, NAMED BY WHAT IT SAYS. A chat names one the way it
+     * would say it — "the grant that lets everyone take back a vote" — so a
+     * removal names it by its keys: roles and acts (or kinds) in any order,
+     * and any other key it gives must match too. Never by its place in the
+     * list, which another change can move.
+     */
+    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 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])));
+        const what = sight ? "sight" : "grant";
+        const say = (one) => (sight ? `${whoWords(one.roles)} ${sightWords(this.doc, one)}` : grantBody(this.doc, one));
+        if (matches.length === 0) {
+            const there = list.map(say);
+            return this.fail(i, "", `no ${what} ${sight ? "shows" : "says"} ${say(part)}${there.length ? `; the ${what}s ${sight ? "show" : "say"} ${there.length > 1 ? `${there.slice(0, -1).join("; ")}; and ${there.at(-1)}` : there[0]}` : `; the app has no ${what}s`}`);
+        }
+        if (matches.length > 1)
+            return this.fail(i, "", `${matches.length} ${what}s ${sight ? "show" : "say"} ${say(part)}`, `say ${sight ? "own or via" : "ownEnd, self, kinds or describe"} as the one to remove says them`);
+        const gone = matches[0];
+        list.splice(list.indexOf(gone), 1);
+        this.said.push(sight ? sightGone(this.doc, gone) : grantGone(this.doc, gone));
+        if (sight && list.length === 0) {
+            delete this.doc.policy.sees;
+            this.said.push(NO_SIGHT_LEFT);
+        }
+        else if (!sight && list.length === 0)
+            this.said.push(NO_GRANT_LEFT);
+    }
     // ── kinds ──
     addKind(i, e) {
         const { op: _op, kind, act, ...rest } = e;
@@ -1172,8 +1423,8 @@ class Editor {
         const to = e.to;
         const touched = this.rewriteAll({ t: "kind", from, to });
         // The acts the framework derives for every kind are named for it, so they move with it.
-        this.toolsMoved.add(`edit-${from} is now edit-${to}`);
-        this.toolsMoved.add(`remove-${from} is now remove-${to}`);
+        for (const act of DERIVED_ACTS)
+            this.toolsMoved.add(`${act}-${from} is now ${act}-${to}`);
         // The kind itself, in order, continuing its records.
         const kinds = {};
         for (const [k, v] of Object.entries(this.doc.kinds))
@@ -1228,6 +1479,11 @@ class Editor {
             return;
         if (Object.keys(this.doc.kinds).length === 1)
             return this.fail(i, "kind", "an app keeps at least one kind");
+        // The last sight gone would show everyone everything, every other kind included: the policy's to change first, as a relation a sight reads is.
+        const sees = this.doc.policy?.sees ?? [];
+        if (sees.length > 0 && sees.every((sight) => sight.kinds.every((k) => k === kind))) {
+            return this.fail(i, "kind", `every sight shows only ${pluralWords(this.doc, kind)}, so with them gone everyone would see everything`, `remove those sights first, in the same change ({"op": "remove-sight", …}), which says so`);
+        }
         const gone = [];
         /*
          * The relations it declares go with it — and so does what walks them
@@ -1262,8 +1518,8 @@ class Editor {
         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)) {
+                gone.push(titled("act", name, act));
                 this.removeActQuietly(name);
-                gone.push(`act ${name}`);
             }
             else if (on.includes(kind))
                 act.on = on.filter((k) => k !== kind);
@@ -1271,7 +1527,7 @@ class Editor {
         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" })) {
                 delete this.doc.rules[name];
-                gone.push(`rule ${name}`);
+                gone.push(titled("rule", name, rule));
             }
         }
         if (this.doc.views?.[kind] && !Array.isArray(this.doc.views[kind])) {
@@ -1279,9 +1535,21 @@ class Editor {
             if (Object.keys(this.doc.views).length === 0)
                 delete this.doc.views;
         }
-        for (const g of this.doc.policy?.grants ?? [])
-            if (Array.isArray(g.kinds))
-                g.kinds = g.kinds.filter((k) => k !== kind);
+        /*
+         * A grant no longer names the kind, nor its derived edit and remove; one
+         * left naming no kind or no act gives nothing, and goes, as a grant does
+         * whose last act is removed — kept, it read as a grant on every kind.
+         */
+        if (this.doc.policy) {
+            const derived = derivedActsOf(kind);
+            this.doc.policy.grants = this.doc.policy.grants.flatMap((g) => {
+                const kinds = Array.isArray(g.kinds) ? g.kinds.filter((k) => k !== kind) : g.kinds;
+                const mutations = Array.isArray(g.mutations) ? g.mutations.filter((m) => !derived.includes(m) || this.doc.acts?.[m]) : g.mutations;
+                if ((Array.isArray(g.kinds) && g.kinds.length > 0 && kinds.length === 0) || (Array.isArray(mutations) && mutations.length === 0))
+                    return [];
+                return [{ ...g, ...(kinds !== undefined ? { kinds } : {}), mutations }];
+            });
+        }
         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);
             if (this.doc.policy.sees.length === 0)
@@ -1319,7 +1587,7 @@ class Editor {
         for (const f of [...this.fills])
             if (f.kind === kind)
                 this.fills.splice(this.fills.indexOf(f), 1);
-        this.said.push(`The ${kind} kind is removed, and every ${kind} with it${gone.length ? `; so are ${listOf(gone)}` : ""}.`);
+        this.said.push(`The ${kind} kind is removed, and every ${kind} with it${gone.length ? `; so ${gone.length === 1 ? "is" : "are"} ${listOf(gone)}` : ""}.`);
     }
     // ── fields ──
     addField(i, e) {
@@ -1340,6 +1608,8 @@ class Editor {
         delete f.renamedFrom;
         if (f.type === "enum" && f.default !== undefined && !f.options.includes(f.default))
             return this.fail(i, "default", `"${String(f.default)}" is not one of the options`);
+        if (f.format && !formatFits(f.format, f.type))
+            return this.fail(i, "format", refusedFormat(f.format, f.type));
         spec.fields[field] = f;
         this.fieldOrigin.set(`${kind}.${field}`, undefined);
         let filled = "";
@@ -1359,7 +1629,9 @@ class Editor {
                 filled = `, set to ${JSON.stringify(fill)} on the records already there`;
             }
         }
-        this.said.push(`${kind} gains a field, ${field} (${f.type}${f.required ? ", required" : ""})${filled}.`);
+        // What it is said as, in words: "(number, money in USD — 10000 reads $10,000)".
+        const said = formatWords(f, this.doc.brand);
+        this.said.push(`${kind} gains a field, ${field} (${f.type}${said ? `, ${said}` : ""}${f.required ? ", required" : ""})${filled}.`);
     }
     renameField(i, kind, field, to) {
         const f = this.field(i, kind, field);
@@ -1421,6 +1693,9 @@ class Editor {
             return;
         if (e.type === "enum" && !e.options && !f.options)
             return this.fail(i, "options", `to make ${e.field} a choice, list its "options"`);
+        // A format goes where it says something (FR-180): money, a percent and a duration on a number, Markdown on a text field.
+        if (e.format && !formatFits(e.format, e.type))
+            return this.fail(i, "format", refusedFormat(e.format, e.type));
         const was = f.type;
         f.type = e.type;
         if (e.type === "enum")
@@ -1433,25 +1708,69 @@ class Editor {
             delete f.of;
         if (e.format)
             f.format = e.format;
-        else if (e.type !== "number" && e.type !== "integer")
+        else if (e.type === "text" || !formatFits(f.format ?? "", e.type))
             delete f.format;
         // A range is a number's (FR-114): a field that is no longer one lets it go.
-        if (e.type !== "number" && e.type !== "integer")
+        if (e.type !== "number" && e.type !== "integer" && e.type !== "duration")
             for (const key of ["min", "max", "step"])
                 delete f[key];
+        // Only a date repeats: a field that is no longer one lets its repeat go.
+        if (e.type !== "date" && e.type !== "datetime")
+            delete f.repeats;
         if (f.default !== undefined && coerce(f.default, was, f) === undefined)
             delete f.default;
         else if (f.default !== undefined)
             f.default = coerce(f.default, was, f);
-        this.said.push(`${e.kind}'s ${e.field} changes from ${was} to ${e.type}; values that convert are kept.`);
+        const said = f.format && f.format !== "markdown" ? formatWords(f, this.doc.brand) : undefined;
+        if (was === e.type && e.type === "text")
+            this.said.push(`${e.kind}'s ${e.field} ${e.format === "markdown" ? "is now written in Markdown, drawn as prose on the record's page" : "is drawn as written, not as Markdown"}; its values are kept.`);
+        else
+            this.said.push(`${e.kind}'s ${e.field} changes from ${was} to ${e.type}${said ? `, said as ${said}` : ""}; values that convert are kept.`);
+    }
+    /**
+     * HOW A FIELD IS SAID, and nothing else about it: a number's `format`
+     * (money, a percent, a duration) and `unit` (a currency like "EUR" for
+     * money, a measure like "kg"), or a text field's `format`, `markdown`
+     * (FR-180) — each set by a value, cleared by `null`, kept when left out.
+     * The values stay as they are; every face says them anew.
+     */
+    setFormat(i, e) {
+        const f = this.field(i, e.kind, e.field);
+        if (!f)
+            return;
+        if (e.format === undefined && e.unit === undefined)
+            return this.fail(i, "format", 'say a "format" ("money", "percent" or "duration" for a number, "markdown" for a text field, or null for neither), a "unit" ("EUR", "kg", or null), or both');
+        if (f.type === "text") {
+            if (e.unit !== undefined && e.unit !== null)
+                return this.fail(i, "unit", refusedFormat("a unit", f.type));
+            if (e.format && e.format !== "markdown")
+                return this.fail(i, "format", refusedFormat(e.format, f.type));
+            if (e.format === "markdown")
+                f.format = "markdown";
+            else if (e.format === null)
+                delete f.format;
+            this.said.push(`${e.kind}'s ${e.field} ${f.format === "markdown" ? "is now written in Markdown, drawn as prose on the record's page" : "is drawn as written, not as Markdown"}; its values are kept.`);
+            return;
+        }
+        if (!formatFits(typeof e.format === "string" ? e.format : "money", f.type))
+            return this.fail(i, "field", refusedFormat(typeof e.format === "string" ? e.format : "a unit", f.type));
+        const before = formatWords(f, this.doc.brand);
+        for (const key of ["format", "unit"]) {
+            if (e[key] === null)
+                delete f[key];
+            else if (e[key] !== undefined)
+                f[key] = e[key];
+        }
+        const now = formatWords(f, this.doc.brand);
+        this.said.push(`${e.kind}'s ${e.field} is said as ${now ?? "a plain number"}${before ? `, where it was ${before.replace(/ — .*/, "")}` : ""}; its values are kept.`);
     }
     /** A number's range (FR-114): a key given sets it, `null` clears it, one left out stays. */
     setRange(i, e) {
         const f = this.field(i, e.kind, e.field);
         if (!f)
             return;
-        if (f.type !== "number" && f.type !== "integer")
-            return this.fail(i, "field", `${e.field} is ${f.type === "integer" ? "an" : "a"} ${f.type}, not a number; a range belongs on a number or integer field`);
+        if (f.type !== "number" && f.type !== "integer" && f.type !== "duration")
+            return this.fail(i, "field", `${e.field} is ${f.type === "integer" ? "an" : "a"} ${f.type}, not a number; a range belongs on a number, integer or duration field`);
         const next = { ...f };
         for (const key of ["min", "max", "step"]) {
             if (e[key] === null)
@@ -1679,7 +1998,7 @@ class Editor {
                 continue;
             const kept = rule.repairs.filter((r) => r.act !== act);
             if (kept.length !== rule.repairs.length)
-                gone.push(`the "${rule.repairs.find((r) => r.act === act)?.label ?? act}" repair of rule ${name}`);
+                gone.push(`the "${rule.repairs.find((r) => r.act === act)?.label ?? act}" repair of ${titled("rule", name, rule)}`);
             if (kept.length > 0)
                 rule.repairs = kept;
             else
@@ -1874,7 +2193,7 @@ class Editor {
                 rule.over = r.to;
             for (const rep of rule.repairs ?? []) {
                 if (r.t === "kind")
-                    rep.act = rep.act === `edit-${r.from}` ? `edit-${r.to}` : rep.act === `remove-${r.from}` ? `remove-${r.to}` : rep.act;
+                    rep.act = renamedAct(rep.act, r.from, r.to);
                 const args = renamedArgs.get(rep.act);
                 if (args && rep.args)
                     for (const [a, b] of args)
@@ -1901,7 +2220,7 @@ class Editor {
                 if (Array.isArray(g.kinds))
                     g.kinds = g.kinds.map(swap);
                 if (Array.isArray(g.mutations))
-                    g.mutations = g.mutations.map((m) => (m === `edit-${r.from}` ? `edit-${r.to}` : m === `remove-${r.from}` ? `remove-${r.to}` : m));
+                    g.mutations = g.mutations.map((m) => renamedAct(m, r.from, r.to));
             }
             for (const s of doc.policy.sees ?? [])
                 s.kinds = s.kinds.map(swap);
@@ -2035,14 +2354,14 @@ class Editor {
                 }
             }
             if (uses) {
-                gone.push(`act ${name}`, ...this.removeActQuietly(name));
+                gone.push(titled("act", name, act), ...this.removeActQuietly(name));
             }
         }
         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)) {
                 delete doc.rules[name];
-                gone.push(`rule ${name}`);
+                gone.push(titled("rule", name, rule));
             }
         }
         if (doc.rules && Object.keys(doc.rules).length === 0)
@@ -2242,6 +2561,70 @@ class Editor {
         return said;
     }
 }
+/** What the people and the policy make together, as `graview check` judges it (`checkPeople`), said over the document. */
+function peopleProblems(doc, at) {
+    const out = [];
+    const kinds = doc.kinds;
+    const people = peopleKinds(kinds);
+    const policy = doc.policy;
+    const reads = policy?.sees?.some((sight) => sight.via !== undefined) ? "a sight via a relation" : policy?.grants.some((grant) => grant.ownEnd) ? "a grant held to a person's own end of a link" : undefined;
+    if (people.length === 0 && reads)
+        out.push(error("people-unsaid", at, `${reads} reads each person's own record, and no kind is the people who sign in`, '{"op": "set-people", "kind": "<the kind whose records are the people>", "people": true}'));
+    for (const sight of policy?.sees ?? []) {
+        const via = sight.via;
+        if (via === undefined)
+            continue;
+        const from = Object.keys(kinds).filter((kind) => kinds[kind].edges?.[via]);
+        if (from.length === 0) {
+            out.push(error("sight-via-unknown-edge", at, `no kind has a relation ${quoted(via)}, so a sight via it shows nothing`, `name a relation that joins ${listOf(sight.kinds.map((kind) => pluralOf(kinds, kind)))} to the people`));
+            continue;
+        }
+        if (people.length === 0)
+            continue;
+        const reaches = (target) => from.some((kind) => {
+            const to = kinds[kind].edges[via].to;
+            return to === "*" || to.includes(target);
+        });
+        for (const kind of sight.kinds) {
+            if ((from.includes(kind) && people.some(reaches)) || (people.some((one) => from.includes(one)) && reaches(kind)))
+                continue;
+            out.push(error("sight-via-misses-people", at, `${quoted(via)} never joins ${pluralOf(kinds, kind)} to ${pluralOf(kinds, people[0])}, so the sight shows no ${nounOf(doc, kind)} to anyone`, `name a relation between ${nounOf(doc, kind)} and ${nounOf(doc, people[0])}, or say own: true`));
+        }
+    }
+    for (const grant of policy?.grants ?? []) {
+        if (!grant.ownEnd)
+            continue;
+        if (grant.mutations === "*") {
+            out.push(error("grant-own-end-without-link", at, "a grant held to a person's own end of a link names every act, and most link nothing", "name the acts it holds: the ones that connect or sever"));
+            continue;
+        }
+        for (const name of grant.mutations) {
+            const ends = linkEnds(doc.acts?.[name]);
+            if (ends === "far")
+                continue;
+            const title = quoted(doc.acts?.[name]?.title ?? name);
+            out.push(ends === "near"
+                ? error("grant-own-end-without-link", at, `${title} takes no record at the other end of what it links, so a grant held to a person's own end of it is never met`, 'take the record at its far end as an argument, or say "$me" there and drop ownEnd')
+                : error("grant-own-end-without-link", at, `${title} connects and severs nothing, so a grant held to a person's own end of a link has no end to hold`, "hold it with self: true for the subject, or name an act that connects or severs"));
+        }
+    }
+    return out;
+}
+/** Whether an act links, and whether it takes the record at the far end of a link as an argument: "far", "near" (only its subject, "$me" or what it made) or "none". */
+function linkEnds(act) {
+    if (!act)
+        return "none";
+    if (act.connects || act.severs)
+        return "far";
+    const own = new Set(["subject", "me", "new", ...(act.effects ?? []).flatMap((e) => (e.create && e.as ? [e.as] : []))]);
+    const links = (act.effects ?? []).filter((e) => e.connect || e.sever);
+    if (links.length === 0)
+        return "none";
+    return links.some((e) => [e.from, e.to].some((end) => {
+        const ref = refName(end);
+        return ref !== undefined && !own.has(ref);
+    })) ? "far" : "near";
+}
 /** A `$name` reference or bare argument name in a guard, renamed (for an argument that followed its field). */
 function rewriteBinding(source, from, to) {
     try {
@@ -2263,7 +2646,6 @@ function swapToken(name, from, to) {
     }
     return name;
 }
-const listOf = (xs) => (xs.length <= 1 ? xs.join("") : `${xs.slice(0, -1).join(", ")} and ${xs.at(-1)}`);
 /** Map every block of a view, nested ones included; a block mapped to null is dropped. */
 function mapBlocks(blocks, f) {
     const out = [];
@@ -2284,13 +2666,12 @@ function mapBlocks(blocks, f) {
     return out;
 }
 // ── words for what changed ───────────────────────────────────────────────────
+/** An act or a rule that goes with something, as a person reads it: 'the act "Draw a match"', by its id only when it has no title. */
+const titled = (what, name, spec) => `the ${what} "${spec.title ?? name}"`;
 const withA = (noun) => `${/^[aeiou]/i.test(noun) ? "an" : "a"} ${noun}`;
-const nounOf = (doc, kind) => doc.kinds[kind]?.noun ?? words(kind);
+const nounOf = (doc, kind) => nounWords(doc.kinds, kind);
 /** A kind's plural as a person reads it: "packages", "people and teams". */
-function pluralWords(doc, kind) {
-    const plural = doc.kinds[kind]?.plural;
-    return plural ? plural.charAt(0).toLowerCase() + plural.slice(1) : `${words(kind)}s`;
-}
+const pluralWords = (doc, kind) => pluralOf(doc.kinds, kind);
 /** The kinds a lens binds, for saying where it stands. */
 function kindsBound(lens) {
     const bindings = lens["bindings"];
@@ -2545,6 +2926,20 @@ export function editDocument(document, edits, options = {}) {
     });
     if (editor.findings.length > 0)
         return { ok: false, findings: editor.findings };
+    /*
+     * WHAT THE PEOPLE AND THE POLICY MAKE TOGETHER, judged once the change is
+     * whole (FR-170): moving the people from one kind to another is two edits,
+     * and the first alone leaves a sight reading nobody. What the change made
+     * wrong is refused at its last such edit; what was wrong before is not
+     * this change's to answer for.
+     */
+    if (editor.lastPolicyEdit >= 0) {
+        const at = `edits.${editor.lastPolicyEdit}`;
+        const before = new Set(peopleProblems(current, at).map((finding) => finding.message));
+        const made = peopleProblems(editor.doc, at).filter((finding) => !before.has(finding.message));
+        if (made.length > 0)
+            return { ok: false, findings: made };
+    }
     /*
      * THE TOOL INTERFACE MOVED, AND SAYS SO (FR-34). A derived act is named for
      * its kind and asks for its fields by name, so a rename changes what an
@@ -2581,4 +2976,9 @@ export function renameIn(kinds, over, text, change) {
         return rewriteTemplate(doc, text.template, ctx, r);
     return undefined;
 }
+/** A derived act of a renamed kind, renamed with it: `archive-task` becomes `archive-chore`. Any other act as it was. */
+function renamedAct(act, from, to) {
+    const derived = derivedActOf(act);
+    return derived && derived.kind === from ? `${derived.act}-${to}` : act;
+}
 //# sourceMappingURL=edit.js.map