@yuneta/gobj-ui 7.25.14 → 7.25.16

package/src/c_yui_treedb_graph.js

@@ -1504,7 +1504,7 @@ function treedb_update_node(gobj, treedb_name, topic_name, record, options)
 
     if(!priv.gobj_remote_yuno) {
         log_error(`${gobj_short_name(gobj)}: No gobj_remote_yuno defined`);
-        return;
+        return -1;
     }
 
     let command = "update-node";
@@ -1528,7 +1528,9 @@ function treedb_update_node(gobj, treedb_name, topic_name, record, options)
     );
     if(ret) {
         log_error(ret);
+        return -1;
     }
+    return 0;
 }
 
 /************************************************************
@@ -2113,6 +2115,11 @@ function ac_mt_command_answer(gobj, event, kw, src)
              *  would tell a schema editor that the schema changed because
              *  somebody dragged a node.
              */
+            if(result < 0 && command === "update-node") {
+                graphs_write_refused(gobj,
+                    kw_get_str(gobj, kw_command, "topic_name", "", 0),
+                    kw_get_dict(gobj, kw_command, "record", {}, 0));
+            }
             if(result >= 0 &&
                 kw_get_str(gobj, kw_command, "topic_name", "", 0) !== "__graphs__") {
                 gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
@@ -2473,22 +2480,62 @@ function ac_update_node(gobj, event, kw, src)
 {
     let priv = gobj.priv;
 
-    if(refuse_if_readonly(gobj, event)) {
-        return -1;
-    }
-
     let treedb_name = priv.treedb_name;
     let topic_name = kw.topic_name;
     let record = kw.record;
     let options = kw.options || {};
 
-    return treedb_update_node(
+    if(refuse_if_readonly(gobj, event)) {
+        graphs_write_refused(gobj, topic_name, record);
+        return -1;
+    }
+
+    /*  The engine's arrangement is sent with no way back when it lands,
+     *  so one that cannot leave must be said here: out of session the
+     *  transport may answer nothing at all.  */
+    if(topic_name === "__graphs__" && !is_connected(gobj)) {
+        log_warning(`${gobj_short_name(gobj)}: no session, the arrangement ` +
+            `was not sent`);
+        graphs_write_refused(gobj, topic_name, record);
+        return -1;
+    }
+
+    let ret = treedb_update_node(
         gobj,
         treedb_name,
         topic_name,
         record,
         options
     );
+    if(ret < 0) {
+        graphs_write_refused(gobj, topic_name, record);
+    }
+    return ret;
+}
+
+/************************************************************
+ *  A write of `__graphs__` did not land. The engine
+ *  (C_G6_NODES_TREE) took it for granted when it left -- nothing
+ *  answers it when it lands -- so it is told, and its next Save
+ *  writes the topic again. Other topics are the operator's data:
+ *  the answer's error says what happened to them.
+ ************************************************************/
+function graphs_write_refused(gobj, topic_name, record)
+{
+    let priv = gobj.priv;
+
+    if(topic_name !== "__graphs__") {
+        return;
+    }
+    let topic = (record && typeof record === "object") ? (record.topic || record.id) : "";
+    if(!topic) {
+        log_error(`${gobj_short_name(gobj)}: a refused __graphs__ write names no topic`);
+        return;
+    }
+    if(!priv.gobj_nodes_tree) {
+        return;     /*  no engine: nothing believes it was saved  */
+    }
+    gobj_send_event(priv.gobj_nodes_tree, "EV_GRAPHS_WRITE_REFUSED", {topic: topic}, gobj);
 }
 
 /********************************************

package/src/c_yui_treedb_topic_with_form.js

@@ -1500,8 +1500,8 @@ function create_tabulator(gobj)
          *  what the ceiling costs is having to widen the column, or open
          *  the record, to read the end of it.
          *  `maxInitialWidth`, not `maxWidth`: the latter is a HARD ceiling
-         *  that neither the drag handle nor the double click could pass
-         *  (M29 of the 2026-09-21 review); this one caps only the width the
+         *  that neither the drag handle nor the double click could pass;
+         *  this one caps only the width the
          *  layout gives, and leaves the column to the reader.  */
         if(max_col_width > 0) {
             colDef.maxInitialWidth = max_col_width;
@@ -2153,8 +2153,8 @@ function transform__treedb_value_2_table_value(gobj, col, value, row, field)
             let items = treedb_hook_data_size(value);
 
             if(items > 0) {
-                /*  DOM, not an HTML string: the row id is record data (M31
-                 *  of the 2026-09-21 review). A language change re-runs
+                /*  DOM, not an HTML string: the row id is record data. A
+                 *  language change re-runs
                  *  setColumns(), which re-runs this.  */
                 value = createElement2(hook_cell_spec(
                     row.id, col.id, items, t("show linked records"), "show linked records"
@@ -2250,7 +2250,7 @@ function transform__treedb_value_2_table_value(gobj, col, value, row, field)
     /*
      *  A string is record data, and Tabulator would parse it as markup
      *  (innerHTML): `a<b` lost its text, a field holding an `<img onerror>`
-     *  ran it (M31 of the 2026-09-21 review). Shown as a text node.
+     *  ran it. Shown as a text node.
      */
     if(typeof value === "string" && value !== "") {
         value = cell_text(value);
@@ -4035,7 +4035,7 @@ function ac_new_row(gobj, event, kw, src)
  *  What crosses the confirmation is the rows' IDENTITY, never their
  *  position: the view applies EV_TREEDB_NODE_* of every writer while the
  *  dialog is open, and a position names whatever row sits there when the
- *  person answers -- with force:true (A6 of the 2026-09-21 review).
+ *  person answers -- with force:true.
  ************************************************************/
 function ac_delete_rows(gobj, event, kw, src)
 {
@@ -4103,8 +4103,8 @@ function ac_confirmed(gobj, event, kw, src)
              *  them): never replaced by the row that took their place.  */
             log_error(`${gobj_short_name(gobj)}: ${event}: rows gone while ` +
                 `confirming the delete, not deleted: ${found.missing.join(", ")}`);
-            /*  The person who answered "yes" is told, not only the log
-             *  (a low of the 2026-09-22 review).  */
+            /*  The person who answered "yes" is told, not only the
+             *  log.  */
             yui_shell_show_error(yui_shell_of(gobj), "some records were gone before the delete", {t: t});
         }
         if(!found.rows.length) {
@@ -4374,8 +4374,8 @@ function ac_files_read(gobj, event, kw, src)
  *  open and BUSY, and the serial it waits for is taken here.
  *
  *  A refused write used to close the form all the same and throw
- *  away what was typed, although the README said it stayed open
- *  (M25 of the 2026-09-21 review): the close was posted with the
+ *  away what was typed, although the README said it stayed open:
+ *  the close was posted with the
  *  publish, before the backend had answered anything.
  ************************************************************/
 function wait_for_write_answer(gobj)

package/src/c_yui_treedb_topics.js

@@ -188,7 +188,7 @@ function mt_start(gobj)
      *  (yui_shell_set_connection_state). A write in flight when it drops
      *  is never answered, and its form waited for ever in every host
      *  that did not forward EV_TRANSPORT_STATE -- wattyzer and yunovatios
-     *  among them (M8 of the 2026-09-23 review). The transport itself is
+     *  among them. The transport itself is
      *  not subscribed to: see ac_transport_state().  */
     let shell = yui_shell_of(gobj);
     if(shell) {
@@ -2476,8 +2476,8 @@ function ac_transport_state(gobj, event, kw, src)
 
     /*
      *  A write in flight when the transport closes is never answered by
-     *  the backend: its form stayed open and busy for ever (N8 of the
-     *  2026-09-22 review). Answered refused: the form stays open on what
+     *  the backend: its form stayed open and busy for ever. Answered
+     *  refused: the form stays open on what
      *  was typed, and the person saves again when the session is back.
      */
     if(!connected) {
@@ -2648,8 +2648,8 @@ function ac_create_record(gobj, event, kw, src)
 
     /*  `create_only`: +New makes a NEW record. With `create` alone a taken
      *  id was an update -- the record overwritten and, through autolink
-     *  with the selects empty, unlinked, answered "Node update!" (M28 of
-     *  the 2026-09-21 review). A backend older than the option ignores it
+     *  with the selects empty, unlinked, answered "Node update!". A
+     *  backend older than the option ignores it
      *  and keeps the old upsert.  */
     let options = {
         list_dict: true,
@@ -2895,8 +2895,8 @@ function ac_update_record(gobj, event, kw, src)
 /************************************************************
  *  A write sent with no session never leaves: C_IEVENT_CLI logs
  *  "Not in session" and answers null, as it does when the command
- *  went -- so a form waiting for the answer waited for ever (N8 of
- *  the 2026-09-22 review). Refused before it is sent, aloud.
+ *  went -- so a form waiting for the answer waited for ever. Refused
+ *  before it is sent, aloud.
  ************************************************************/
 function refuse_without_session(gobj, topic_name)
 {

package/src/form_busy.js

@@ -10,9 +10,8 @@
  *          that back. So a second busy(true) while already busy must not
  *          run at all -- it read the buttons it had just disabled as
  *          "disabled on their own", and the busy(false) of a refused write
- *          left Save and Cancel dead (N9 of the 2026-09-22 review: a record
- *          with a picked file went busy for the read, then busy again for
- *          the write). The caller owns `state` ({busy}) for the form's life.
+ *          left Save and Cancel dead (a record with a picked file went
+ *          busy for the read, then busy again for the write). The caller owns `state` ({busy}) for the form's life.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.

package/src/form_busy.test.js

@@ -53,7 +53,7 @@ describe("set_toolbar_busy", () => {
         expect(tb.save.classList.contains("is-loading")).toBe(false);
     });
 
-    it("busy twice then free: Save and Cancel come back (N9)", () => {
+    it("busy twice then free: Save and Cancel come back", () => {
         /*  A record with a picked file went busy for the read and busy
          *  again for the write; the second pass recorded the buttons the
          *  first had disabled as disabled on their own, and the free of a

package/src/form_time_value.js

@@ -37,7 +37,7 @@
  *  A Date -> the value of a `datetime-local` input, in local time,
  *  WITH seconds: the input is built with `step: 1`, which is what
  *  lets it hold them. Written as "YYYY-MM-DDTHH:mm" it lost them on
- *  every save of any field (M26 of the 2026-09-21 review).
+ *  every save of any field.
  ************************************************************/
 function date_to_datetime_local(value)
 {

package/src/form_time_value.test.js

@@ -4,7 +4,7 @@ import {date_to_datetime_local, datetime_local_to_epoch} from "./form_time_value
 describe("form_time_value", () => {
 
     it("an epoch with seconds survives a round trip through the input", () => {
-        /*  M26 of the 2026-09-21 review: the input was written without
+        /*  The input was written without
          *  seconds, so every save of ANY field moved a writable time
          *  column back up to 59 s. */
         const epoch = 1790000037;   // :37 seconds

package/src/form_writes_in_flight.js

@@ -7,8 +7,7 @@
  *          answers, so the host has to answer EVERY way a write ends --
  *          and the transport closing under a write in flight, or a
  *          command that never left because there was no session, are two
- *          of them that nobody answered: the form stayed busy for ever
- *          (N8 of the 2026-09-22 review).
+ *          of them that nobody answered: the form stayed busy for ever.
  *
  *          A write is known by its TOPIC and its `form_write` serial,
  *          never by the serial alone: each topic has its own form, and

package/src/form_writes_in_flight.test.js

@@ -30,7 +30,7 @@ describe("form writes in flight", () => {
         ]);
     });
 
-    it("the transport closes: every write in flight is abandoned, once (N8)", () => {
+    it("the transport closes: every write in flight is abandoned, once", () => {
         /*  The form of each one is answered EV_WRITE_REFUSED by the host
          *  and stays open on what was typed; before, it stayed busy for
          *  ever, because nobody answered a write whose answer was lost.  */

package/src/g6_graphs_write_owed.wiring.test.js

@@ -0,0 +1,200 @@
+/***********************************************************************
+ *          g6_graphs_write_owed.wiring.test.js
+ *
+ *      A `__graphs__` write that did not land is OWED, and the Save
+ *      button says so until a Save writes it again.
+ *
+ *      EV_GRAPHS_WRITE_REFUSED lit the Save (in edition only), and
+ *      the next repaint of the history buttons put it out again:
+ *      update_history_buttons() decides the Save from
+ *      `history.canUndo()` alone, and it runs on every history
+ *      change, every change of mode and every redraw of the theme.
+ *      A refusal heard in reading was never shown at all.
+ *
+ *      The real C_G6_NODES_TREE, on a fake G6 graph: only the history
+ *      plugin and the Save button are what is looked at.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+const {
+    SDATA, SDATA_END, data_type_t,
+    gclass_create, gobj_start_up, gobj_create_yuno, gobj_create_pure_child,
+    gobj_send_event, register_c_timer, set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_g6_nodes_tree} = await import("./c_g6_nodes_tree.js");
+
+const logged = [];
+const published = [];
+
+/*  G6, as far as these paths ask it: plugins by key, and nothing on
+ *  screen. Any other method answers undefined.  */
+function fake_graph(history)
+{
+    let plugins = [];
+    const known = {
+        rendered: true,
+        getPlugins: () => plugins,
+        setPlugins: (fn) => {
+            plugins = (typeof fn === "function") ? fn(plugins) : fn;
+        },
+        getPluginInstance: (key) => (key === "history") ? history : {on() {}, off() {}},
+        updatePlugin: () => {},
+        getBehaviors: () => [],
+        setBehaviors: () => {},
+        getData: () => ({nodes: [], edges: [], combos: []}),
+        getZoom: () => 1,
+    };
+    return new Proxy(known, {
+        get: (t, k) => (k in t) ? t[k] : (() => undefined)
+    });
+}
+
+let yuno = null;
+
+beforeAll(() => {
+    gobj_start_up(null, null, null, null, null, null, null);
+    set_log_callback((level, msg) => {
+        logged.push({level: String(level), msg: String(msg)});
+    });
+    register_c_timer();
+    register_c_g6_nodes_tree();
+    /*  The host: what the tree publishes lands here.  */
+    const host_events = ["EV_UPDATE_NODE"];
+    gclass_create(
+        "C_TEST_GRAPH_HOST",
+        host_events.map((e) => [e, 0]),
+        [["ST_IDLE", host_events.map((e) => [e, (gobj, ev, kw) => {
+            published.push({event: ev, kw: kw});
+            return 0;
+        }, null])]],
+        {}, 0,
+        [SDATA(data_type_t.DTP_STRING, "node_uuid", 0, "test-node-uuid", ""), SDATA_END()],
+        {}, 0, 0, 0, 0
+    );
+    yuno = gobj_create_yuno("owed_yuno", "C_TEST_GRAPH_HOST", {});
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    published.length = 0;
+});
+
+let seq = 0;
+
+/*  A tree whose `users` arrangement the backend holds, in `mode`,
+ *  with a Save button in its container and a history that has
+ *  nothing to undo.  */
+function build(mode)
+{
+    const $container = document.createElement("div");
+    const tree = gobj_create_pure_child(`tree_${++seq}`, "C_G6_NODES_TREE",
+        {$container: $container}, yuno);
+    const listeners = [];
+    const history = {
+        undo: false,
+        canUndo() {
+            return this.undo;
+        },
+        canRedo: () => false,
+        on: (ev, fn) => {
+            listeners.push(fn);
+        },
+        clear() {
+            this.undo = false;
+        }
+    };
+    tree.priv.graph = fake_graph(history);
+    tree.priv.graph_rendered = true;
+    tree.priv.treedb_name = "treedb_x";
+    tree.priv._graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+    tree.priv._saved_graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+
+    const $save = document.createElement("div");
+    $save.className = "EV_SAVE_GRAPH";
+    $save.setAttribute("disabled", "");
+    $container.appendChild($save);
+
+    gobj_send_event(tree, "EV_SET_OPERATION_MODE", {operation_mode: mode}, tree);
+    return {
+        tree,
+        lit: () => !$save.hasAttribute("disabled"),
+        history_changed: () => {
+            for(const fn of listeners) {
+                fn();
+            }
+        }
+    };
+}
+
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+describe("a refused __graphs__ write keeps the Save lit", () => {
+
+    test("in edition: a history change does not put it out", () => {
+        const g = build("edition");
+        expect(g.lit()).toBe(false);
+
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+        expect(g.lit()).toBe(true);
+
+        g.history_changed();                /*  nothing to undo  */
+        expect(g.lit()).toBe(true);
+
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        expect(g.lit()).toBe(true);
+        expect(errors()).toEqual([]);
+    });
+
+    test("heard in reading, it is shown on entering edition", () => {
+        const g = build("reading");
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        expect(g.lit()).toBe(true);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the Save writes it again, and then the Save goes dark", () => {
+        const g = build("edition");
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const writes = published.filter((p) => p.event === "EV_UPDATE_NODE");
+        expect(writes.map((w) => w.kw.record.id)).toEqual(["users"]);
+        expect(g.lit()).toBe(false);
+
+        g.history_changed();
+        expect(g.lit()).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("refused again after that Save: lit again", () => {
+        const g = build("edition");
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+
+        g.history_changed();
+        expect(g.lit()).toBe(true);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a reload forgets it: the view holds what the backend holds", () => {
+        const g = build("edition");
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+        gobj_send_event(g.tree, "EV_CLEAR_DATA", {}, g.tree);
+        /*  What the load does once the data is in again.  */
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        expect(g.lit()).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+});

package/src/g6_nodes_tree_fsm.test.js

@@ -0,0 +1,33 @@
+/***********************************************************************
+ *          g6_nodes_tree_fsm.test.js
+ *
+ *      The machine of the real C_G6_NODES_TREE: the events its host
+ *      sends it are declared, and each has an action. The host's own
+ *      tests drive a fake engine, which cannot see this.
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+const {
+    gclass_find_by_name, gclass_event_type, gclass_check_fsm,
+} = await import("@yuneta/gobj-js");
+const {register_c_g6_nodes_tree} = await import("./c_g6_nodes_tree.js");
+
+describe("C_G6_NODES_TREE", () => {
+
+    test("hears EV_GRAPHS_WRITE_REFUSED, the host's word on a __graphs__ write", () => {
+        register_c_g6_nodes_tree();
+        const gclass = gclass_find_by_name("C_G6_NODES_TREE", false);
+        expect(gclass).toBeTruthy();
+        expect(gclass_event_type(gclass, "EV_GRAPHS_WRITE_REFUSED")).toBeTruthy();
+        const idle = gclass.dl_states.find((st) => st.state_name === "ST_IDLE");
+        expect(idle.dl_actions.some((a) => a.event_name === "EV_GRAPHS_WRITE_REFUSED" &&
+            typeof a.action === "function")).toBe(true);
+        expect(gclass_check_fsm(gclass)).toBe(0);
+    });
+});

package/src/graph_save_plan.js

@@ -140,7 +140,35 @@ function apply_graphs_echo(live, saved, records, rec)
     }
 }
 
+/***************************************************************
+ *  A write of one topic's arrangement did NOT land: the backend
+ *  refused it, the transport refused it on the way out, or there
+ *  was no session to send it on.
+ *
+ *      saved       {topic_name: properties}  what the backend has
+ *      topic_name  the topic of the refused record
+ *
+ *  The view records a write as saved BEFORE it leaves, because
+ *  nothing answers it when it lands. So a refused one left the view
+ *  believing the backend held an arrangement it does not, and the
+ *  next Save found nothing to write. What the backend holds for the
+ *  topic is not known any more, so it is forgotten: the next Save
+ *  writes the topic again (plan_graph_saves()).
+ *
+ *  Returns TRUE if there was something to forget.
+ ***************************************************************/
+function forget_refused_graphs_write(saved, topic_name)
+{
+    if(!is_object(saved) || !topic_name ||
+            !Object.prototype.hasOwnProperty.call(saved, topic_name)) {
+        return false;
+    }
+    delete saved[topic_name];
+    return true;
+}
+
 export {
+    forget_refused_graphs_write,
     apply_graphs_echo,
     plan_graph_saves,
     topic_arrangement_changed,

package/src/graph_save_plan.test.js

@@ -18,7 +18,8 @@
  ***********************************************************************/
 import {describe, test, expect} from "vitest";
 import {
-    plan_graph_saves, topic_arrangement_changed, arrangement_of, apply_graphs_echo
+    plan_graph_saves, topic_arrangement_changed, arrangement_of, apply_graphs_echo,
+    forget_refused_graphs_write
 } from "./graph_save_plan.js";
 
 const ORIGIN = "f3163a9f-1f37-412a-b8c9-87a4341f14de";
@@ -150,7 +151,7 @@ describe("arrangement_of", () => {
  *  save by another browser, sends back. It used to rebuild the saved
  *  snapshot of EVERY topic, taking the copies from the live objects the
  *  view had already rearranged: what was unsaved in OTHER topics counted
- *  as saved, and the next Save skipped it (M32 of the 2026-09-21 review).
+ *  as saved, and the next Save skipped it.
  */
 describe("an echo of one __graphs__ record", () => {
     function state()
@@ -200,3 +201,36 @@ describe("an echo of one __graphs__ record", () => {
         expect(live.yunos).toBeDefined();
     });
 });
+
+/*
+ *  A write of `__graphs__` that the backend REFUSED. The view takes the
+ *  write for granted before it leaves (nothing answers it when it lands),
+ *  so a refused one was recorded as saved: the next Save found nothing to
+ *  write, and the arrangement was never stored.
+ */
+describe("a refused __graphs__ write", () => {
+
+    test("is planned again by the next Save", () => {
+        let live = five_topics();
+        let saved = five_topics();
+        live.yunos.nodes["1"].x = 500;
+        expect(plan_graph_saves(live, saved)).toEqual(["yunos"]);
+
+        /*  What save_topic_graph_properties() does before the publish.  */
+        saved.yunos = JSON.parse(JSON.stringify(live.yunos));
+        expect(plan_graph_saves(live, saved)).toEqual([]);
+
+        expect(forget_refused_graphs_write(saved, "yunos")).toBe(true);
+        expect(plan_graph_saves(live, saved)).toEqual(["yunos"]);
+        expect(Object.keys(saved)).not.toContain("yunos");
+        expect(Object.keys(saved).length).toBe(4);
+    });
+
+    test("a topic the view never believed saved: nothing to forget", () => {
+        let saved = five_topics();
+        expect(forget_refused_graphs_write(saved, "nothing")).toBe(false);
+        expect(forget_refused_graphs_write(saved, "")).toBe(false);
+        expect(forget_refused_graphs_write(null, "yunos")).toBe(false);
+        expect(Object.keys(saved).length).toBe(5);
+    });
+});

package/src/host_drafts.js

@@ -7,9 +7,8 @@
  *          it, and that mark lived in the memory of the session only:
  *          a reload of the page, a reconnect or a refresh of the model
  *          lost the chip, the banner and the export warning while
- *          __system__ still differed from the file in use (N13 of the
- *          2026-09-22 review). The host reads that difference from
- *          C_TREEDB's `saved-schema` (`draft_changed`, by treedb) and
+ *          __system__ still differed from the file in use. The host
+ *          reads that difference from C_TREEDB's `saved-schema` (`draft_changed`, by treedb) and
  *          hands it here; the editor applies it to its model, in place
  *          of what the host said before.
  *

package/src/host_drafts.test.js

@@ -15,7 +15,7 @@ const model = {
 
 describe("mark_host_drafts", () => {
 
-    it("marks the topics the host names, by treedb (N13)", () => {
+    it("marks the topics the host names, by treedb", () => {
         /*  The mark lived in the memory of one session: after a reload the
          *  editor showed no draft while __system__ still differed from the
          *  file in use. Rebuilt from the host's data.  */
@@ -68,7 +68,7 @@ describe("host_draft_ids", () => {
             .toEqual({"treedb_a^users": true, "treedb_b^users": true});
     });
 
-    it("is a fresh map every time: what the host stopped naming is gone (M1)", () => {
+    it("is a fresh map every time: what the host stopped naming is gone", () => {
         /*  mark_host_drafts() only ADDS, and the editor fed it the same map
          *  every time: a topic the host named before the Save stayed a
          *  draft after it.  */

package/src/schema_editor_drafts.wiring.test.js

@@ -4,7 +4,7 @@
  *      EV_DRAFTS driven through a real C_YUI_SCHEMA_EDITOR on a document
  *      double. The helper was right and tested; the ACTION folded the
  *      host's marks into the session's, so a topic the host named before
- *      a Save stayed a draft after it (M1 of the 2026-09-23 review).
+ *      a Save stayed a draft after it.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
@@ -138,7 +138,7 @@ describe("EV_DRAFTS: the host is the truth", () => {
         expect(drafts_on_screen(editor)).toBe(1);
     });
 
-    test("the host names none any more (a Save): the mark goes (M1)", () => {
+    test("the host names none any more (a Save): the mark goes", () => {
         /*  It only ever ADDED: after the Save the editor still said
          *  "unsaved schema changes".  */
         const {editor, host} = build("d2");