@graview/core 0.1.28 → 0.1.30

package/dist/store.js

@@ -1,7 +1,8 @@
-import { hidesFrom, readingOf, seatLens, seenBy, seesId } from "./seen.js";
+import { hidesFrom, readingOf, seatLens, seenBy, seesEveryRecord, seesId } from "./seen.js";
+import { isoToday } from "./days.js";
 import { Graph, GraphError, MissingRecordError } from "./graph/graph.js";
 import { resolveModules } from "./modules.js";
-import { diffSnapshots, EMPTY_DIFF, isEmptyDiff } from "./graph/diff.js";
+import { diffSnapshots, diffTouched, EMPTY_DIFF, isEmptyDiff } from "./graph/diff.js";
 import { invert, normalize, writesOf } from "./graph/primitives.js";
 import { LabelIndex, refusalFor } from "./labels.js";
 import { nodeRefArgs } from "./mutations/node-ref.js";
@@ -10,16 +11,29 @@ import { evaluate } from "./invariants/engine.js";
 import { compileMutation } from "./mutations/define-mutation.js";
 import { deriveMutations, derivedVia } from "./mutations/derive-edits.js";
 import { OperationLog } from "./ops/log.js";
+import { lineageOf } from "./ops/lineage.js";
+import { KEEP_LINK, keepLinkMutation, keepLinkVia } from "./mutations/keep-link.js";
+import { declinedIn, isAutomated, tidyingRefusal } from "./ops/tidying.js";
+import { nameOfAuthor } from "./who.js";
 import { actingAs, grantsTo, isSystem, permits, permittedMutations, subjectKinds } from "./permissions/policy.js";
 import { namesUnseen, redact } from "./ops/withheld.js";
 import { nounOf } from "./schema/define-node.js";
-import { creatorsBefore } from "./permissions/sight.js";
+import { creatorsBefore, fieldsJudged, partialSight, recordsOf } from "./permissions/sight.js";
 import { PermissionDeniedError } from "./permissions/types.js";
 import { checkUndo, UndoBlockedError, undoPrimitives } from "./ops/undo.js";
 import { validateGraph } from "./validate-graph.js";
-import { tellTheWatchItsNames, tellTheWatchOfAStore, tellTheWatchOfAnAuthor, tellTheWatchOfARefusal } from "./watched.js";
+import { tellTheWatchOfAStore, tellTheWatchOfAnAuthor, tellTheWatchOfARefusal } from "./watched.js";
 import { capitalize } from "./capital.js";
+import { dayOf } from "./clock.js";
 import { pluralOf } from "./schema/define-node.js";
+import { linkedReaderOf } from "./schema/linked.js";
+/** A change asked of a store of the past (Roadmap f-playback): the past is read, never changed. */
+export class PastError extends GraphError {
+    constructor(at) {
+        super(`This is the app as it stood${at.at ? ` at ${at.at}` : " at the start"}: the past is read, never changed`);
+        this.name = "PastError";
+    }
+}
 /** The batch a preview's ops are under when it was given none: no store mints it. */
 export const PREVIEW_BATCH = "preview";
 /** `{ [key]: value }` where the value is said, and nothing where it is not: an optional key left off rather than undefined. */
@@ -53,6 +67,10 @@ const putsBack = (op) => op.mutation === null && op.undoes === undefined;
 export function violationKey(v, shaped) {
     return `${v.invariant}|${v.subjectId ?? ""}|${v.line || shaped?.has(v.invariant) ? v.label : v.message}`;
 }
+/** Every rule, as `violationKey` reads its `shaped`: a problem known by its rule, its record and its name. */
+/** The derived acts that take a record out or fold it away: riding the making of a kind, they reach only what the principal made (W-201). */
+const UNMAKING = new Set(["remove", "archive", "unarchive", "merge"]);
+const EVERY_RULE = { has: () => true };
 /** The rules that have a shape, by name: what `violationKey` keys by the rule and the record. */
 export const shapedRules = (rules) => new Set(rules.filter((rule) => rule.shape).map((rule) => rule.name));
 /**
@@ -66,7 +84,29 @@ export function problemsMoved(rules, before, after) {
     const key = (v) => violationKey(v, shaped);
     const was = new Set(before.map(key));
     const is = new Set(after.map(key));
-    return { introduces: after.filter((v) => !was.has(key(v))), resolves: before.filter((v) => !is.has(key(v))) };
+    const introduces = after.filter((v) => !was.has(key(v)));
+    const resolves = before.filter((v) => !is.has(key(v)));
+    if (introduces.length === 0 || resolves.length === 0)
+        return { introduces, resolves };
+    /*
+     * REWORDED IS NOT MENDED (the ninth walk, W-191). A rule that is a
+     * function says its count in its message — "not opened for 22 days" —
+     * so the day turning, or an act that leaves it broken, rewords it. The
+     * same rule about the same record under the same name, said differently,
+     * is the problem it was: paired off one for one, it is neither made nor
+     * mended.
+     */
+    // Who a problem is when its words are set aside: its rule, its record and its name, as a rule with a line is known.
+    const who = (v) => v.subjectId && violationKey(v, EVERY_RULE);
+    // Each mended problem's who, until a reworded one is paired off with it (null).
+    const left = resolves.map(who);
+    return {
+        introduces: introduces.filter((v) => {
+            const at = who(v) ? left.indexOf(who(v)) : -1;
+            return at < 0 || ((left[at] = null), false);
+        }),
+        resolves: resolves.filter((_, at) => left[at] !== null),
+    };
 }
 /**
  * The unit of the framework an app holds: a graph, the log it folds from,
@@ -123,6 +163,8 @@ export class Store {
     graph;
     log;
     mutations = new Map();
+    /** The store's own "Keep this link" (FR-172), when the app declared none by that name. */
+    keeper;
     invariants;
     invariantOptions;
     policy;
@@ -160,8 +202,23 @@ export class Store {
     quiet = 0;
     /** True of a rehearsal (`previewAll`): what it does is told to nobody. */
     rehearsing = false;
+    /** True of a rehearsal for a suggestion: the actor is held to what a person said, not to the declaration's `tidying`, since a person decides it. */
+    suggesting = false;
+    /**
+     * The day a host last ticked this store to (FR-176), and the day the clock
+     * read when it did: what its rules are judged on, where nothing pins one,
+     * until the clock's day moves past the one it was ticked on — a timer
+     * that slept through midnight never leaves the store on yesterday.
+     */
+    ticked;
+    /** Where this store stands in the past, when it is one (`pastOf`): read, never changed. */
+    past;
+    /** How often `pastOf` keeps a point to fold from, in ops (`StoreOptions.pastEvery`). */
+    pastEvery;
     listeners = new Set();
     constructor(options) {
+        this.pastEvery = Math.max(1, options.pastEvery ?? 64);
+        this.past = options.past;
         this.schema = options.schema;
         this.invariants = options.invariants ?? [];
         this.invariantOptions = options.invariantOptions ?? {};
@@ -180,7 +237,8 @@ export class Store {
         const tag = storeTag();
         this.batchTag = options.batchIds ? undefined : tag;
         this.mintBatch = options.batchIds ?? ((kind) => `${kind}:${tag}:${++this.counter}`);
-        for (const mutation of options.mutations ?? []) {
+        // A store of the past offers no act: not one declared, derived or kept (Roadmap f-playback).
+        for (const mutation of options.past ? [] : (options.mutations ?? [])) {
             if (this.mutations.has(mutation.name)) {
                 throw new GraphError(`Duplicate mutation "${mutation.name}"`);
             }
@@ -194,10 +252,14 @@ export class Store {
          * invariants — and by the policy, through the acts that already write or
          * create the kind (see `permits`). Nothing an app declares is replaced.
          */
-        for (const mutation of deriveMutations(options.schema, options.mutations ?? [])) {
+        for (const mutation of options.past ? [] : deriveMutations(options.schema, options.mutations ?? [])) {
             this.mutations.set(mutation.name, mutation);
         }
-        tellTheWatchItsNames(options.schema, this.mutations.values(), options.policy);
+        // "Keep this link" (FR-172): answered by every store, offered by no list. An app's own `keep-link` keeps its name.
+        if (!options.past && !this.mutations.has(KEEP_LINK)) {
+            this.keeper = keepLinkMutation(options.schema);
+            this.mutations.set(KEEP_LINK, this.keeper);
+        }
         const horizon = given("horizon", options.horizon);
         const validate = { validate: this.validate };
         if (options.log) {
@@ -227,9 +289,16 @@ export class Store {
          * Only the DEFAULT generators are wound forward; an app that supplies
          * its own `ids` owns their uniqueness.
          */
+        if (options.past)
+            return;
         this.countPastTheLog();
         tellTheWatchOfAStore(this);
     }
+    /** Refuses any change to a store of the past (Roadmap f-playback). */
+    stillNow() {
+        if (this.past)
+            throw new PastError(this.past);
+    }
     /** Winds the default op and batch counters past every id the log holds, and past the horizon (FR-23). */
     countPastTheLog() {
         const trailing = (value) => {
@@ -288,6 +357,7 @@ export class Store {
      * when the set is the one the store already has.
      */
     setEnabledModules(enabled, options = {}) {
+        this.stillNow();
         const before = this.modules.enabled;
         const after = resolveModules(this.declaredModules, enabled).enabled;
         const off = [...before].filter((name) => !after.has(name));
@@ -339,10 +409,12 @@ export class Store {
         return mutation.derived !== undefined && this.modules.disabledKinds.has(mutation.derived.kind);
     }
     allMutations() {
-        return [...this.mutations.values()].filter((mutation) => !this.mutationDisabled(mutation));
+        return [...this.mutations.values()].filter((mutation) => mutation !== this.keeper && !this.mutationDisabled(mutation));
     }
-    /** The declared acts a derived act resolves its permission through. */
-    viaOf(mutation) {
+    /** The declared acts a derived act resolves its permission through; keeping a link, those that make or break its relation. */
+    viaOf(mutation, call) {
+        if (mutation !== undefined && mutation === this.keeper)
+            return keepLinkVia(this.mutations.values(), call?.args["kind"]);
         if (!mutation?.derived)
             return undefined;
         return derivedVia(this.schema, [...this.mutations.values()], mutation);
@@ -384,6 +456,9 @@ export class Store {
          * repair as the starter seat, which may only add, and the press met
          * "starter may not take-off here" (W-110).
          */
+        // The app as it was is read, never changed (Roadmap f-playback): a control asking says so rather than offering a press.
+        if (this.past)
+            return { ok: false, refusal: { mutation: call.name, wouldNeed: [], message: "Nothing changes while you look back." } };
         const narrowed = this.refusesAgent(call, principal) ?? this.namesTurnedOff(call, principal);
         if (narrowed)
             return { ok: false, refusal: narrowed };
@@ -396,7 +471,7 @@ export class Store {
          * names. A call that cannot be compiled is refused by `apply`, in its
          * own words.
          */
-        return permits(this.policy, principal, call.name, this.subjectKindOf(call, principal), this.viaOf(mutation), typeof id === "string" ? id : undefined, this.words, () => {
+        return permits(this.policy, principal, call.name, this.subjectKindOf(call, principal), this.viaOf(mutation, call), typeof id === "string" ? id : undefined, this.words, () => {
             const me = actingAs(principal).id;
             const far = this.namedIn(call, false);
             try {
@@ -408,7 +483,11 @@ export class Store {
                 // Refused by `apply`.
             }
             return far;
-        });
+        }, 
+        // Who made the record a derived act is about: riding only everybody's grant, it reaches what this principal made (W-201).
+        mutation?.derived && (() => recordsOf(this.log).creatorOf(id)), 
+        // Taking a record out, or folding it away, rides the making of the kind only over what this principal made (W-201).
+        mutation?.derived !== undefined && UNMAKING.has(mutation.derived.act));
     }
     /** The ids a call names in its record arguments: its subject's too, unless `subject` is false (the far ends of what it links). */
     namedIn(call, subject = true) {
@@ -493,7 +572,7 @@ export class Store {
             return me;
         // And a seat that writes a value naming what it may not see has written its own words, though the store held them already.
         const hidden = seesId(this, author);
-        return { ...me, seen: seenBy(this, author).graph, keepUnchanged: (value) => namesUnseen(value, hidden) };
+        return { ...me, seen: seenBy(this, author).graph, keepUnchanged: (value) => namesUnseen(value, hidden), seesInFull: seesEveryRecord(this, author) };
     }
     /**
      * A CALL THAT NAMES A RECORD THAT IS NOT THERE FOR ITS CALLER IS REFUSED
@@ -568,9 +647,14 @@ export class Store {
         if (named && visible(given))
             return { ok: true, id: given, label: this.labels.labelOf(given) ?? given, by: "id" };
         const found = this.labels.lookup(arg.kinds, given);
-        const exact = found.exact.filter(visible);
+        // A name is a live record's when one has it, and an archived one's only when none does (FR-173).
+        const live = (ids) => {
+            const kept = ids.filter((id) => !this.graph.isArchived(id));
+            return kept.length ? kept : ids;
+        };
+        const exact = live(found.exact.filter(visible));
         const exactly = exact.length > 0;
-        const candidates = (exactly ? exact : found.prefix.filter(visible))
+        const candidates = (exactly ? exact : live(found.prefix.filter(visible)))
             .map((id) => ({ id, kind: this.graph.getNode(id).kind, label: this.labels.labelOf(id) ?? id }))
             .sort((a, b) => (a.label < b.label ? -1 : a.label > b.label ? 1 : a.id < b.id ? -1 : 1));
         if (candidates.length === 1)
@@ -595,9 +679,11 @@ export class Store {
         const sights = this.policy?.sees ?? [];
         if (sights.length > 0 && !isSystem(principal)) {
             const creatable = new Set(this.permittedMutations(principal).flatMap((mutation) => mutation.creates ?? []));
+            // A sight that shows only some fields shows nothing until they can be judged, as `sees` says (Roadmap f-field-sight).
+            const judged = fieldsJudged(this);
             // Every kind: once a policy says who sees what, a kind no sight names is seen by nobody.
             for (const kind of this.schema.kinds) {
-                const seeing = sights.some((sight) => sight.kinds.includes(kind) && grantsTo(sight, principal) && ((!sight.own && !sight.via) || principal.id !== undefined));
+                const seeing = sights.some((sight) => sight.kinds.includes(kind) && grantsTo(sight, principal) && ((!sight.own && !sight.via) || principal.id !== undefined) && (judged || !partialSight(sight)));
                 if (!seeing && !creatable.has(kind))
                     kept.add(kind);
             }
@@ -653,19 +739,75 @@ export class Store {
      * a day (a test, a demo, a replay) is asked about that day.
      */
     today() {
+        return this.pinned() ?? (this.ticked && this.ticked.on === isoToday() ? this.ticked.day : undefined);
+    }
+    /** The day `invariantOptions` pins, if it pins one: a tick does not move it. */
+    pinned() {
         const context = this.invariantOptions.context;
         const pinned = this.invariantOptions.today ?? context?.today;
         return typeof pinned === "string" && /^\d{4}-\d{2}-\d{2}$/.test(pinned) ? pinned : undefined;
     }
+    /** What every judgment is handed: the store's options, a call's context, and the day it judges on. */
+    judging(context) {
+        const today = this.today();
+        // A rule that walks a link to another app reads it as the viewer this graph is read for (FR-171), unless the call hands its own reader.
+        const linked = linkedReaderOf(this.graph);
+        const given = context ?? this.invariantOptions.context;
+        const judged = linked && !(given && "linked" in given) ? { ...given, linked } : context;
+        return { ...this.invariantOptions, ...(judged === undefined ? {} : { context: judged }), ...(today === undefined ? {} : { today }) };
+    }
+    /**
+     * THE DAY TURNED (FR-176). Rules are judged on every change and once on
+     * load; one that reads the clock — "overdue", "due this week" — is broken
+     * or mended by the day turning with nothing changed, and a room that stays
+     * open for weeks would go on saying the day it last heard a change. A host
+     * calls this when the day turns (`tickEachDay` does, just after each
+     * midnight by the clock `today()` reads; `@graview/ship`'s `openStore`
+     * and `openRemote` start it): from now on the store's rules are judged on
+     * `now`'s day (UTC, as `today()` reads the clock; or a day given as
+     * `YYYY-MM-DD`), and the answer is the problems that appeared and cleared
+     * with it. Which rules those can be is the declaration's to say
+     * (`clockReaders` on `@graview/core/check`, which `graview check` reads);
+     * the store judges every rule on the day before and the day after, once
+     * a day, and so needs no list. Every subscriber hears the day turn, with
+     * an empty diff and no ops, so the bar, the problems page and a count
+     * read again. Nothing is written or logged. A store whose day is pinned
+     * (`invariantOptions.today`) is judged on that day still, and answers
+     * that nothing moved.
+     */
+    tick(now = new Date()) {
+        const pinned = this.pinned();
+        if (pinned !== undefined)
+            return { day: pinned, was: pinned, appeared: [], cleared: [] };
+        const day = dayOf(now);
+        const was = this.today();
+        const before = this.violations();
+        this.ticked = { day, on: isoToday() };
+        const moved = this.moved(before, this.violations());
+        if (day !== was && !this.rehearsing && this.quiet === 0)
+            for (const listener of this.listeners)
+                listener(EMPTY_DIFF, []);
+        return { day, ...(was === undefined ? {} : { was }), appeared: moved.introduces, cleared: moved.resolves };
+    }
+    /**
+     * SOMETHING READ BESIDE THE GRAPH ANSWERED (FR-171): a record in another
+     * app that a computed field, a rule or a label walks to has been read, or
+     * read again. Nothing here changed, and nothing is written or logged;
+     * every subscriber hears it, as they hear the day turn, with an empty
+     * diff and no ops, so what reads through the link reads again.
+     */
+    reread() {
+        if (this.rehearsing || this.quiet > 0)
+            return;
+        for (const listener of this.listeners)
+            listener(EMPTY_DIFF, []);
+    }
     /**
      * Current violations, evaluated fresh — nothing is cached or stale. `over`
      * judges them over another reading of this graph: a seat's (FR-55).
      */
     violations(context, over = this.graph) {
-        return evaluate(over, this.allInvariants(), {
-            ...this.invariantOptions,
-            ...(context === undefined ? {} : { context }),
-        });
+        return evaluate(over, this.allInvariants(), this.judging(context));
     }
     /**
      * What a mutation would do, without doing it. Every action in the interface
@@ -755,10 +897,7 @@ export class Store {
         const before = this.violations(meta.context);
         const trial = Graph.from(this.schema, this.graph.snapshot());
         const diff = trial.applyPrimitives(primitives, { restoring: meta.restoring === true });
-        const after = evaluate(trial, this.allInvariants(), {
-            ...this.invariantOptions,
-            ...(meta.context === undefined ? {} : { context: meta.context }),
-        });
+        const after = evaluate(trial, this.allInvariants(), this.judging(meta.context));
         return {
             diff,
             primitives,
@@ -783,8 +922,10 @@ export class Store {
      * (`openRemote` sends each one down the wire).
      */
     applying(calls, options, context) {
+        this.stillNow();
         const batch = options.batch ?? this.mintBatch("batch");
         const author = options.author ?? this.by;
+        const lineage = lineageOf(options.lineage);
         const ops = [];
         const allPrimitives = [];
         const reads = new Set();
@@ -824,6 +965,16 @@ export class Store {
             if (refusal)
                 this.refuse(refusal, author.id);
         }
+        /*
+         * THE APP'S OWN ACTOR IS HELD TO WHAT PEOPLE SAID: a change a person
+         * declined is not made again, a record a person said to leave alone is
+         * not changed, and what the declaration says is never tidied is not
+         * tidied on its own (`@graview/core/tidying`). Each refused in a
+         * sentence, and the whole gesture with it.
+         */
+        const automated = isAutomated(author);
+        if (automated)
+            this.refuseDeclined(calls, author);
         if (!this.rehearsing)
             tellTheWatchOfAnAuthor(author.id);
         try {
@@ -833,6 +984,11 @@ export class Store {
                 if (missing)
                     throw missing;
                 const compiled = compileMutation(this.graph, definition, call.args, this.sighted(author));
+                if (automated) {
+                    const refused = tidyingRefusal(this.schema, this.graph, compiled.primitives, this.authorName(author), { declaration: !this.suggesting });
+                    if (refused)
+                        this.refuse({ mutation: call.name, message: refused, wouldNeed: [] }, author.id);
+                }
                 /*
                  * AN ACT THAT DID NOTHING DOES NOT GO IN THE HISTORY.
                  *
@@ -872,8 +1028,10 @@ export class Store {
                     writes: compiled.writes,
                     // Which records its sentence read, so a reader who may not see one is not handed the sentence (FR-55).
                     ...(definition.describe !== undefined && compiled.described && compiled.described.length > 0 ? { described: compiled.described } : {}),
+                    ...given("mergedInto", compiled.mergedInto),
                     at: this.now(),
                     ...given("via", options.via),
+                    ...given("lineage", lineage),
                 };
                 this.graph.applyPrimitives(op.primitives);
                 this.log.append(op);
@@ -891,7 +1049,8 @@ export class Store {
             this.putBack(rollback, kept);
             throw error;
         }
-        const diff = diffSnapshots(rollback, this.graph.snapshot());
+        // What the act touched, never the whole graph again (W-205).
+        const diff = diffTouched(rollback, this.graph.snapshot(), allPrimitives);
         this.admitted(options, ops, allPrimitives, diff, rollback, kept);
         const after = this.violations(context);
         this.notify(diff, ops);
@@ -936,6 +1095,7 @@ export class Store {
      * sequence must keep it themselves; `openRemote` does.
      */
     receive(ops, options = {}) {
+        this.stillNow();
         const known = new Set(this.log.all().map((op) => op.id));
         const fresh = ops.filter((op) => !known.has(op.id));
         if (fresh.length === 0)
@@ -973,7 +1133,7 @@ export class Store {
             this.log.append(here);
             landed.push(here);
         }
-        this.notify(diffSnapshots(before, this.graph.snapshot()), landed);
+        this.notify(diffTouched(before, this.graph.snapshot(), fresh.flatMap((op) => op.primitives)), landed);
         return landed;
     }
     /**
@@ -995,6 +1155,7 @@ export class Store {
      * lands. Subscribers hear one change, and every op undoes like any other.
      */
     append(ops, options = {}) {
+        this.stillNow();
         if (ops.length === 0)
             return [];
         const taken = new Set(this.log.all().map((op) => op.id));
@@ -1016,6 +1177,7 @@ export class Store {
                 at: made.at ?? this.now(),
                 ...given("undoes", made.undoes),
                 ...given("via", made.via),
+                ...given("lineage", lineageOf(made.lineage)),
             };
             if (taken.has(op.id))
                 throw new GraphError(`Op "${op.id}" (${op.intent}) is already in the log`, "A host-made op needs an id of its own; leave `id` out and the store mints one.");
@@ -1036,7 +1198,7 @@ export class Store {
             this.log.append(op);
         for (const op of built)
             tellTheWatchOfAnAuthor(op.author.id);
-        this.notify(diffSnapshots(before, this.graph.snapshot()), built);
+        this.notify(diffTouched(before, this.graph.snapshot(), built.flatMap((op) => op.primitives)), built);
         return built;
     }
     /**
@@ -1050,11 +1212,13 @@ export class Store {
      * primitive that does not fit leaves the store as it was and throws.
      */
     applyPrimitives(primitives, options = {}) {
+        this.stillNow();
         const batch = options.batch ?? this.mintBatch("batch");
         const author = options.author ?? this.by;
         const before = this.violations();
         const rollback = this.graph.snapshot();
         const intent = options.intent ?? "Apply a change";
+        const lineage = lineageOf(options.lineage);
         const recorded = primitives.map(normalize);
         const ops = [];
         if (recorded.length > 0) {
@@ -1071,6 +1235,7 @@ export class Store {
                 writes: [...new Set(recorded.flatMap(writesOf))],
                 at: this.now(),
                 ...given("via", options.via),
+                ...given("lineage", lineage),
             };
             this.graph.applyPrimitives(op.primitives);
             this.log.append(op);
@@ -1078,7 +1243,7 @@ export class Store {
             tellTheWatchOfAnAuthor(author.id);
         }
         const after = this.violations();
-        const diff = diffSnapshots(rollback, this.graph.snapshot());
+        const diff = diffTouched(rollback, this.graph.snapshot(), recorded);
         this.notify(diff, ops);
         return {
             batch,
@@ -1145,6 +1310,7 @@ export class Store {
     }
     /** `undo` itself, kept apart for the same reason as `applying`. */
     undoing(batchIds, options) {
+        this.stillNow();
         const ids = typeof batchIds === "string" ? [batchIds] : batchIds;
         const author = options.author ?? this.by;
         /*
@@ -1167,6 +1333,7 @@ export class Store {
                 : check);
         }
         const batch = options.batch ?? this.mintBatch("undo");
+        const lineage = lineageOf(options.lineage);
         /*
          * Undo is a CHANGE, and it is judged like one.
          *
@@ -1215,12 +1382,15 @@ export class Store {
                 at: this.now(),
                 undoes: target.id,
                 ...given("via", options.via),
+                ...given("lineage", lineage),
+                // What was declined, kept on the declining (FR-172): "do not make this again".
+                ...given("undoneLineage", target.lineage),
             };
             this.graph.applyPrimitives(op.primitives, { restoring: putsBack(target) });
             this.log.append(op);
             ops.push(op);
         }
-        const diff = diffSnapshots(rollback, this.graph.snapshot());
+        const diff = diffTouched(rollback, this.graph.snapshot(), ops.flatMap((op) => [...op.primitives]));
         this.admitted(options, ops, ops.flatMap((op) => [...op.primitives]), diff, rollback, kept);
         const after = this.violations();
         this.notify(diff, ops);
@@ -1236,6 +1406,16 @@ export class Store {
             violationsAfter: after,
         };
     }
+    /** An author named as Activity names one, for a sentence that refuses them. */
+    authorName(author) {
+        return nameOfAuthor(author, { graph: this.graph, schema: this.schema });
+    }
+    /** A change a person declined is not made or suggested again: refused, in a sentence. */
+    refuseDeclined(calls, author) {
+        const declined = declinedIn(this.log.all(), calls);
+        if (declined)
+            this.refuse({ mutation: calls[0].name, message: `${this.authorName(author)} may not make this again: a person declined it on ${declined.at.slice(0, 10)}.`, wouldNeed: [] }, author.id);
+    }
     /** A change not kept: the graph as it was, and the log cut back to where it stood. */
     putBack(rollback, kept) {
         this.graph.load(rollback);
@@ -1319,6 +1499,7 @@ export class Store {
      * never flickers through the states in between.
      */
     rebase(change) {
+        this.stillNow();
         const settling = new Set([...change.pending, ...(change.drop ?? [])]);
         const all = this.log.all();
         const first = all.findIndex((op) => settling.has(op.batch));
@@ -1412,6 +1593,7 @@ export class Store {
      * store did not hold before and the re-applied ones.
      */
     adopt(state) {
+        this.stillNow();
         const dropped = new Set(state.drop ?? []);
         const pending = (state.pending ?? []).filter((batch) => !dropped.has(batch));
         const held = this.log.all();
@@ -1468,6 +1650,7 @@ export class Store {
             batch,
             ...given("intent", head.batchIntent),
             ...given("via", head.via),
+            ...given("lineage", head.lineage),
         };
         if (head.undoes !== undefined) {
             const targets = ops.map((op) => this.log.get(op.undoes ?? ""));
@@ -1550,6 +1733,7 @@ export class Store {
      * Ship's `opened.compact()` archives first and calls this after.
      */
     compact(checkpoint) {
+        this.stillNow();
         return this.log.compact(checkpoint);
     }
 }