@graview/core 0.1.49 → 0.1.50

package/dist/store.js

@@ -17,6 +17,7 @@ import { namesMade, resolveMade } from "./mutations/made.js";
 import { OperationLog } from "./ops/log.js";
 import { lineageOf } from "./ops/lineage.js";
 import { KEEP_LINK, keepLinkMutation, keepLinkVia } from "./mutations/keep-link.js";
+import { TYPE_TEXT, TYPING } from "./text/typing-hook.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";
@@ -25,13 +26,14 @@ import { writersBehind } from "./ops/writers.js";
 import { nounOf } from "./schema/define-node.js";
 import { behind, fieldsJudged, partialSight, recordsOf } from "./permissions/sight.js";
 import { PermissionDeniedError } from "./permissions/types.js";
-import { checkUndo, UndoBlockedError, undoPrimitives } from "./ops/undo.js";
+import { checkUndo, UndoBlockedError, undoneInverses, undoPrimitives } from "./ops/undo.js";
 import { validateGraph } from "./validate-graph.js";
 import { tellTheWatchOfAStore, tellTheWatchOfAnAuthor, tellTheWatchOfARefusal, tellTheWatchOfAnInputRefusal } 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";
+import { onPublish, PUBLISH, PUBLISHING } from "./publish.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) {
@@ -174,9 +176,13 @@ export class Store {
     mutations = new Map();
     /** The store's own "Keep this link" (FR-172), when the app declared none by that name. */
     keeper;
+    /** "Type text", when the store answers to its own (Roadmap f-collab-text). */
+    typer;
     invariants;
     invariantOptions;
     policy;
+    /** When edits reach readers (`StoreOptions.publishing`). */
+    publishing;
     /**
      * The intelligence the app declared, so a surface can read the DOORS.
      *
@@ -238,6 +244,7 @@ export class Store {
         if (this.timeZone)
             this.ticked = { day: isoToday(this.timeZone), on: isoToday(this.timeZone) };
         this.policy = options.policy;
+        this.publishing = options.publishing;
         this.by = options.principal ?? HUMAN;
         this.intelligence = options.intelligence ?? [];
         for (const provider of options.intelligence ?? []) {
@@ -336,6 +343,35 @@ export class Store {
      * between reads and re-read only past what it has read — a log only ever
      * grows at its end, and a rebase that cut it is read again from the start.
      */
+    /**
+     * WHERE WHAT THIS STORE SERVES ENDS: the ops before this seq are in what
+     * it reads, none after. A store's own is its head (`log.length`), a past
+     * (`pastOf(store, seq)`) is `seq`, and a seat's view (`seenBy`) is the
+     * seq that seat is served through — the head today. A seat's served state
+     * may end before the head, chosen by policy (docs/stability.md, "Served
+     * state and the head"), as narrowing; a write is always judged at the
+     * head, whatever this says. Read-only: nothing sets it.
+     */
+    get servedSeq() {
+        return this.log.length;
+    }
+    /**
+     * HOW FAR READERS ARE SERVED (Roadmap f-publishing-lifecycle): the
+     * `publishedThrough` of the last publish that stands, or `undefined`
+     * when nothing was ever published. Read from the log, as the modules
+     * are, and kept between reads while the log is the one it was read from.
+     */
+    get publishedSeq() {
+        return PUBLISHING.seq?.(this);
+    }
+    /**
+     * "PUBLISH" (Roadmap f-publishing-lifecycle): answered by every store of
+     * an app whose readers are served what was published, and that declared
+     * no act by the name, once `@graview/core/publishing` is loaded.
+     */
+    get publisher() {
+        return PUBLISHING.act?.(this, this.mutations);
+    }
     get modules() {
         const all = this.log.all();
         const last = all.at(-1)?.id;
@@ -405,7 +441,7 @@ export class Store {
         return op;
     }
     mutation(name) {
-        const found = this.mutations.get(this.spelled(name));
+        const found = this.mutations.get(this.spelled(name)) ?? (name === PUBLISH ? this.publisher : undefined);
         if (!found) {
             throw new UnknownMutationError(name, [...this.mutations.keys()]);
         }
@@ -422,6 +458,9 @@ export class Store {
      * as it was given, to be refused by that name.
      */
     spelled(name) {
+        // "Type text" (Roadmap f-collab-text): answered by every store once `@graview/core/typing` is loaded, and offered by no list.
+        if (name === TYPE_TEXT && !this.typer && TYPING.typeText && !this.past && !this.mutations.has(name))
+            this.mutations.set(name, (this.typer = TYPING.typeText(this)));
         return this.mutations.has(name) ? name : (actSpelledAs(name, this.mutations.keys()) ?? name);
     }
     /** A call with its act's name as the store spells it, so the log and every check read the one name. */
@@ -436,10 +475,10 @@ export class Store {
         return mutation.derived !== undefined && this.modules.disabledKinds.has(mutation.derived.kind);
     }
     allMutations() {
-        return [...this.mutations.values()].filter((mutation) => mutation !== this.keeper && !this.mutationDisabled(mutation));
+        return [...this.mutations.values(), ...(this.publisher ? [this.publisher] : [])].filter((mutation) => mutation !== this.keeper && mutation !== this.typer && !this.mutationDisabled(mutation));
     }
     /** The declared acts a derived act resolves its permission through; keeping a link, those that make or break its relation. */
-    viaOf(mutation, call) {
+    viaOf(mutation, call, principal) {
         if (mutation !== undefined && mutation === this.keeper) {
             const declared = keepLinkVia(this.mutations.values(), call?.args["kind"]);
             if (declared.length > 0)
@@ -448,6 +487,9 @@ export class Store {
             const all = [...this.mutations.values()];
             return [...new Set(all.filter((one) => one.derived?.relation === call?.args["kind"]).flatMap((one) => derivedVia(this.schema, all, one) ?? []))];
         }
+        // Typing into a field: whoever may run an act that writes that field of that record.
+        if (mutation !== undefined && mutation === this.typer)
+            return TYPING.via(this.schema, [...this.mutations.values()], this.subjectKindOf(call, principal), call?.args["field"]);
         if (!mutation?.derived)
             return undefined;
         return derivedVia(this.schema, [...this.mutations.values()], mutation);
@@ -496,7 +538,10 @@ export class Store {
         const narrowed = this.refusesAgent(call, principal) ?? this.namesTurnedOff(call, principal);
         if (narrowed)
             return { ok: false, refusal: narrowed };
-        const mutation = this.mutations.get(call.name);
+        const mutation = this.mutations.get(call.name) ?? (call.name === PUBLISH ? this.publisher : undefined);
+        // Publishing is the declaration's `publishers`, not a grant's.
+        if (mutation && mutation === this.publisher)
+            return PUBLISHING.verdict(this, principal);
         const id = mutation?.subject && call.args[mutation.subject.arg];
         /*
          * An own-end grant holds the records the call names at the far end of
@@ -505,7 +550,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, call), typeof id === "string" ? id : undefined, this.words, () => {
+        return permits(this.policy, principal, call.name, this.subjectKindOf(call, principal), this.viaOf(mutation, call, principal), typeof id === "string" ? id : undefined, this.words, () => {
             const me = actingAs(principal).id;
             const far = this.namedIn(call, false);
             try {
@@ -519,7 +564,7 @@ export class Store {
             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)), 
+        mutation !== undefined && (mutation.derived !== undefined || mutation === this.typer) ? () => recordsOf(this.log).creatorOf(id) : undefined, 
         // 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));
     }
@@ -608,6 +653,18 @@ export class Store {
         const hidden = seesId(this, author);
         return { ...me, seen: seenBy(this, author).graph, keepUnchanged: (value) => namesUnseen(value, hidden), seesInFull: seesEveryRecord(this, author) };
     }
+    /**
+     * WHETHER ONE FIELD OF A RECORD IS TYPED TOGETHER (Roadmap f-collab-text),
+     * read off the declaration of the record's kind, never off its value:
+     * `isCollaborativeField`. False for a record that is not here.
+     */
+    collaborative(node, field) {
+        return TYPING.collaborative?.(this.schema, this.graph.getNode(node)?.kind, field) ?? false;
+    }
+    /** A whole value written over text typed together, as a splice, where `@graview/core/typing` is loaded; as written otherwise. */
+    asSplices(primitives, base) {
+        return TYPING.asSplices ? TYPING.asSplices(this, primitives, base) : primitives;
+    }
     /**
      * A CALL THAT NAMES A RECORD THAT IS NOT THERE FOR ITS CALLER IS REFUSED
      * AS MISSING (FR-02, FR-55) — one that does not exist, and one the caller
@@ -652,12 +709,17 @@ export class Store {
         });
     }
     /**
-     * The store as one principal may see it: its graph, log, history and
-     * problems hold only what the policy's `sees` lets them see, and every
-     * act still comes here. With no `sees`, this store itself (see `seen.ts`).
+     * The app as this seat is served it: its graph, log, history and problems
+     * hold only what the policy's `sees` lets the seat see, through the seq it
+     * is served (`servedSeq`), and every act still comes here, judged at the
+     * head. A reader of an `on-publish` app is served what was published; a
+     * collaborator the head, or — `{ as: "published" }` — what readers are
+     * served, to preview it. With no `sees` and nothing held back, this store
+     * itself (see `seen.ts`). Nothing promises it is the head, nor that one
+     * principal has one view.
      */
-    seenBy(principal) {
-        return seenBy(this, principal);
+    seenBy(principal, options) {
+        return seenBy(this, principal, options);
     }
     /** Whether a principal may see one record (the policy's `sees`). */
     sees(principal, id) {
@@ -734,11 +796,13 @@ export class Store {
      */
     permittedMutations(principal = HUMAN) {
         const all = this.allMutations();
-        const declared = permittedMutations(this.policy, principal, all.filter((mutation) => !mutation.derived));
+        const declared = permittedMutations(this.policy, principal, all.filter((mutation) => !mutation.derived && mutation !== this.publisher));
+        // Publishing is offered to the declaration's publishers (Roadmap f-publishing-lifecycle).
+        const publishing = this.publisher && PUBLISHING.verdict(this, principal).ok ? [this.publisher] : [];
         // A derived act is offered when the kind's own acts it rides are.
         const derived = all.filter((mutation) => mutation.derived !== undefined &&
             permits(this.policy, principal, mutation.name, mutation.derived.kind, this.viaOf(mutation), actingAs(principal).id).ok);
-        return [...declared, ...derived];
+        return [...declared, ...publishing, ...derived];
     }
     /**
      * The kind a call acts on, read off the mutation's own subject binding.
@@ -918,7 +982,7 @@ export class Store {
         call = this.spelledCall(call);
         const definition = this.mutation(call.name);
         const compiled = compileMutation(this.graph, definition, call.args, this.sighted(options.author));
-        return this.previewPrimitives(compiled.primitives, {
+        return this.previewPrimitives(this.asSplices(compiled.primitives), {
             reads: compiled.reads,
             writes: compiled.writes,
             intent: compiled.intent,
@@ -971,6 +1035,9 @@ export class Store {
             mintBatch: () => PREVIEW_BATCH,
             rehearsing: true,
         });
+        // Its own acts, so "Type text" reads the text back off the rehearsal's log, as the apply would off this one's.
+        const typer = this.typer && TYPING.typeText(twin);
+        Object.assign(twin, { typer, mutations: typer ? new Map(this.mutations).set(TYPE_TEXT, typer) : new Map(this.mutations) });
         return twin;
     }
     previewPrimitives(primitives, meta) {
@@ -1036,7 +1103,7 @@ export class Store {
          * was brought in for, and the narrower of the two wins.
          */
         const permitted = (call) => {
-            const verdict = this.policy ? this.permits(call, author) : undefined;
+            const verdict = this.policy || (this.publisher && call.name === PUBLISH) ? this.permits(call, author) : undefined;
             if (verdict && !verdict.ok)
                 this.refuse(verdict.refusal, author.id);
         };
@@ -1063,18 +1130,35 @@ export class Store {
             tellTheWatchOfAnAuthor(author.id);
         /* The first record each call made, for a later call that names it (FR-193). */
         const madeIds = [];
+        const minted = [];
+        /*
+         * A CLIENT'S OWN ID, A HINT (Roadmap f-1-0-client-ids). A call it applied
+         * first says the id it minted there (`mintedHint`); the record is made
+         * under it when it is free, and minted as ever when somebody holds it —
+         * and a later call of this change naming the hint names the record made.
+         */
+        const renamed = new Map();
+        const rename = (value) => (typeof value === "string" ? (renamed.get(value) ?? value) : Array.isArray(value) ? value.map(rename) : value);
         try {
-            for (const [at, asked] of calls.entries()) {
+            for (const [at, sent] of calls.entries()) {
+                const { mintedHint: hint, ...plain } = sent;
+                const asked = renamed.size ? { ...plain, args: Object.fromEntries(Object.entries(plain.args).map(([key, value]) => [key, rename(value)])) } : plain;
                 const call = naming[at] ? resolveMade(asked, madeIds, at) : asked;
                 if (naming[at])
                     (permitted(call), declared(call));
                 const definition = this.mutation(call.name);
+                if (definition === this.publisher) {
+                    const op = PUBLISHING.op(this, { id: this.nextId(), at: this.now() }, call, batch, author, options);
+                    ops.push(op);
+                    intents.push(op.intent);
+                    continue;
+                }
                 const missing = this.missingFor(call, author);
                 if (missing)
                     throw missing;
                 let compiled;
                 try {
-                    compiled = compileMutation(this.graph, definition, call.args, this.sighted(author));
+                    compiled = compileMutation(this.graph, definition, call.args, { ...this.sighted(author), hint });
                 }
                 catch (error) {
                     // A press the act's own input refused: the watch tells a form filled wrongly from an act offered whole.
@@ -1082,6 +1166,8 @@ export class Store {
                         tellTheWatchOfAnInputRefusal(error, author.id);
                     throw error;
                 }
+                if (hint !== undefined && compiled.firstMinted !== undefined && compiled.firstMinted !== hint)
+                    renamed.set(hint, compiled.firstMinted);
                 if (automated) {
                     const refused = tidyingRefusal(this.schema, this.graph, compiled.primitives, this.authorName(author), { declaration: !this.suggesting });
                     if (refused)
@@ -1100,6 +1186,7 @@ export class Store {
                  */
                 if (compiled.primitives.length === 0)
                     continue;
+                minted[at] = compiled.firstMinted;
                 madeIds[at] = compiled.primitives.find((primitive) => primitive.op === "add-node")?.node.id;
                 const op = {
                     id: this.nextId(),
@@ -1121,7 +1208,7 @@ export class Store {
                      * instruction is lost the moment the op is written to JSON and the
                      * inverse quietly does nothing. See `normalize` in primitives.ts.
                      */
-                    primitives: compiled.primitives.map(normalize),
+                    primitives: this.asSplices(compiled.primitives, options.base).map(normalize),
                     reads: compiled.reads,
                     writes: compiled.writes,
                     // Which records its sentence read, so a reader who may not see one is not handed the sentence (FR-55).
@@ -1155,6 +1242,7 @@ export class Store {
         return {
             batch,
             ops,
+            ...(minted.length > 0 ? { minted } : {}),
             diff,
             primitives: allPrimitives,
             reads: [...reads],
@@ -1317,7 +1405,7 @@ export class Store {
         const rollback = this.graph.snapshot();
         const intent = options.intent ?? "Apply a change";
         const lineage = lineageOf(options.lineage);
-        const recorded = primitives.map(normalize);
+        const recorded = this.asSplices(primitives, options.base).map(normalize);
         const ops = [];
         if (recorded.length > 0) {
             const op = {
@@ -1379,7 +1467,7 @@ export class Store {
         const check = this.canUndo(batchIds);
         if (!check.ok)
             return { ok: false, check };
-        const primitives = undoPrimitives(check.ops);
+        const primitives = undoPrimitives(check.ops, this.log.all());
         const writes = new Set();
         for (const op of check.ops)
             for (const id of op.writes)
@@ -1440,7 +1528,7 @@ export class Store {
          * what you may have done — the mutation each operation ran, judged
          * again now.
          */
-        if (this.policy) {
+        if (this.policy || this.publisher) {
             for (const target of check.ops) {
                 if (!target.mutation)
                     continue;
@@ -1463,7 +1551,7 @@ export class Store {
         const before = this.violations();
         const ops = [];
         const kept = this.log.length;
-        for (const target of [...check.ops].sort((a, b) => b.seq - a.seq)) {
+        for (const { op: target, primitives } of undoneInverses(this.log.all(), check.ops)) {
             const op = {
                 id: this.nextId(),
                 seq: this.log.length,
@@ -1472,7 +1560,7 @@ export class Store {
                 intent: `Undo: ${target.intent}`,
                 ...given("batchIntent", options.intent),
                 mutation: null,
-                primitives: inverseOf(target),
+                primitives,
                 reads: target.reads,
                 writes: target.writes,
                 at: this.now(),
@@ -1814,6 +1902,12 @@ export class Store {
             const byDays = kept ? kept.seq : this.log.length;
             seq = Math.min(byOps, byDays);
         }
+        // Never past a seq somebody is served at: a reader's past (`pastOf`) folds from the log, so the lowest pin is the furthest it goes.
+        // And readers' own (Roadmap f-publishing-lifecycle): what was published — or, before the first publish, where the log begins.
+        const readers = onPublish(this.publishing) ? [this.publishedSeq ?? 0] : [];
+        const pinned = [...(options.pins ?? []), ...readers].filter((pin) => Number.isInteger(pin));
+        if (pinned.length > 0)
+            seq = Math.min(seq, ...pinned);
         seq = Math.min(Math.max(seq, this.log.horizon), this.log.length);
         // Never inside a gesture: back to where the batch it would split began.
         while (seq > this.log.horizon && seq < this.log.length && ops[seq - this.log.horizon].batch === ops[seq - 1 - this.log.horizon].batch)