@yuneta/gobj-ui 7.25.16 → 7.25.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuneta/gobj-ui",
-  "version": "7.25.16",
+  "version": "7.25.18",
   "type": "module",
   "main": "dist/gobj-ui.cjs.js",
   "module": "dist/gobj-ui.es.js",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@rollup/plugin-terser": "^1.0.0",
     "@vitest/coverage-v8": "^4.1.10",
-    "@yuneta/gobj-js": "^7.25.2",
+    "@yuneta/gobj-js": "^7.25.3",
     "vite": "^8.2.1",
     "vitest": "^4.1.10"
   },

package/src/c_yui_schema_editor.js

@@ -403,7 +403,11 @@ function el_attrs(attrs)
 }
 
 /***************************************************************
- *  The body stops answering while a write is in flight.
+ *  The body stops answering while a write is in flight. For the
+ *  keyboard too: `pointer-events` stops the mouse alone, and the
+ *  shell's focus trap puts the focus back on the row control that
+ *  had it, where Enter or Delete sent an action ST_SAVING does
+ *  not declare. `inert` takes the whole body out of reach.
  ***************************************************************/
 function set_busy(gobj, busy)
 {
@@ -411,6 +415,7 @@ function set_busy(gobj, busy)
 
     if($body) {
         $body.classList.toggle("SCHEMA_BUSY", !!busy);
+        $body.toggleAttribute("inert", !!busy);
     }
 }
 
@@ -707,7 +712,7 @@ function request_model(gobj, keep_written)
         priv.records_before = null;
         priv.load_round++;
         priv.reload_on_open = true;
-        priv.load_error = t("cannot reach the treedb");
+        priv.load_error = "cannot reach the treedb";   /*  a key: the notice translates it  */
         if(priv.model) {
             yui_shell_show_error(yui_shell_of(gobj), "cannot reach the treedb", {t: t});
         }
@@ -993,9 +998,14 @@ function show_notice(gobj, key, detail)
     $notice.appendChild(createElement2(
         ["span", {class: "SCHEMA_NOTICE_TEXT", i18n: key}, t(key)]
     ));
-    if(detail) {
+    /*  The detail is a KEY too (ours, or the backend's words, which
+     *  translate to themselves when no locale has them), so a change
+     *  of language changes it with the rest. One that repeats the
+     *  title says nothing.  */
+    if(detail && detail !== key) {
         $notice.appendChild(createElement2(
-            ["span", {class: "SCHEMA_NOTICE_DETAIL yui-text-quiet ml-2"}, `${detail}`]
+            ["span", {class: "SCHEMA_NOTICE_DETAIL yui-text-quiet ml-2", i18n: `${detail}`},
+                t(`${detail}`)]
         ));
     }
 }
@@ -3350,7 +3360,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
         }
         priv.pending--;
         if(result < 0) {
-            priv.load_error = comment || t("cannot load the schemas");
+            priv.load_error = comment || "cannot load the schemas";   /*  a key  */
         } else if(priv.records && Array.isArray(priv.records[topic_name])) {
             priv.records[topic_name] = Array.isArray(data) ? data : [];
         }
@@ -3427,10 +3437,11 @@ function ac_mt_command_answer(gobj, event, kw, src)
             return end_writes(gobj, comment || t("the treedb refused the write"));
         }
         priv.save_wrote = true;
+        let record = null;
         if(command === "delete-node") {
             forget_record(gobj, topic_name, kw_get_str(gobj, md, "record_id", "", 0));
         } else {
-            let record = is_object(data) ? data
+            record = is_object(data) ? data
                 : (Array.isArray(data) && is_object(data[0]) ? data[0] : null);
             if(record) {
                 patch_record(gobj, topic_name, record);
@@ -3453,7 +3464,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 }
                 if(topic_name === T_TOPICS || topic_name === T_COLS) {
                     let write = priv.save_queue[0];
-                    mark_written(gobj, topic_name, write ? write.record : null);
+                    mark_written(gobj, topic_name, null, write ? write.record : null);
                 }
                 priv.reload_after_write = false;
                 priv.save_queue = [];
@@ -3471,11 +3482,12 @@ function ac_mt_command_answer(gobj, event, kw, src)
             }
         }
         if(topic_name === T_TOPICS || topic_name === T_COLS) {
-            /*  Which record it was is in the QUEUE, not in the answer: an
-             *  adapter echoes only what it was asked to echo, and the
-             *  record is not small enough to be worth echoing.  */
+            /*  Which record it was: the one the store answered, else the
+             *  one in the QUEUE -- an adapter echoes only what it was
+             *  asked to echo, and the record is not small enough to be
+             *  worth echoing.  */
             let write = priv.save_queue[0];
-            mark_written(gobj, topic_name, write ? write.record : null);
+            mark_written(gobj, topic_name, record, write ? write.record : null);
         }
         priv.save_queue.shift();
         return run_next_write(gobj);
@@ -3544,35 +3556,46 @@ function late_write_done(gobj, command, topic_name, data)
 function mark_written_record(gobj, topic_name, record)
 {
     let priv = gobj.priv;
+    let marked = 0;
 
     if(!record) {
-        return;
+        return 0;
     }
     if(topic_name === T_TOPICS && typeof record.id === "string" && record.id) {
         priv.written[record.id] = true;
-        return;
+        return 1;
     }
     if(topic_name !== T_COLS) {
-        return;
+        return 0;
     }
     for(let ref of parse_fkey_ref(record.topics)) {
         priv.written[ref.id] = true;
+        marked++;
     }
+    return marked;
 }
 
 /***************************************************************
  *  Remember which topic this write belongs to, which is what
  *  "its version still has to move" is asked about.
+ *
+ *  Asked of the RECORD first: the one the store answered (a new
+ *  topic has its id only there), then the one queued (a column
+ *  names its topic in its fkey). The screen is the last resort,
+ *  and a poor one: an import writes topics the operator is not
+ *  on, and from the topics screen there is no topic on it at all.
  ***************************************************************/
-function mark_written(gobj, topic_name, record)
+function mark_written(gobj, topic_name, answered, queued)
 {
     let priv = gobj.priv;
-    let topic = current_topic(gobj);
 
-    if(topic_name === T_TOPICS && record && record.id) {
-        priv.written[record.id] = true;
+    if(mark_written_record(gobj, topic_name, answered) > 0) {
         return;
     }
+    if(mark_written_record(gobj, topic_name, queued) > 0) {
+        return;
+    }
+    let topic = current_topic(gobj);
     if(topic) {
         priv.written[topic.id] = true;
     }

package/src/c_yui_treedb_graph.js

@@ -1520,6 +1520,12 @@ function treedb_update_node(gobj, treedb_name, topic_name, record, options)
     kw.__md_command__ = { // Data to be returned
         topic_name: topic_name,
     };
+    /*  The answer carries this echo and nothing else of the request: a
+     *  refused `__graphs__` write is told to the engine by the topic it
+     *  arranges, so that topic has to travel here.  */
+    if(topic_name === "__graphs__") {
+        kw.__md_command__.graph_topic = graph_topic_of(record);
+    }
 
     let ret = gobj_command(priv.gobj_remote_yuno,
         command,
@@ -1569,6 +1575,38 @@ function treedb_delete_node(gobj, treedb_name, topic_name, record, options)
     }
 }
 
+/************************************************************
+ *  What a link or an unlink asks back with its answer: the
+ *  topic of the CHILD (the node a link saves) and both refs.
+ *  `child_ref` is "topic^id", `parent_ref` "topic^id^hook".
+ ************************************************************/
+function link_echo(parent_ref, child_ref)
+{
+    let child_topic = (typeof child_ref === "string") ? child_ref.split("^")[0] : "";
+    return {
+        topic_name: child_topic,
+        parent_ref: parent_ref,
+        child_ref:  child_ref
+    };
+}
+
+/************************************************************
+ *  The record a write answered: the node the store wrote (an
+ *  update or a create), deleted, or the child of a link. The
+ *  answer's frame carries back only `__md_command__`, never the
+ *  request's own record.
+ ************************************************************/
+function answered_record(data)
+{
+    if(data && typeof data === "object" && !Array.isArray(data)) {
+        return data;
+    }
+    if(Array.isArray(data) && data[0] && typeof data[0] === "object") {
+        return data[0];
+    }
+    return {};
+}
+
 /************************************************************
  *  Command to remote service
  ************************************************************/
@@ -1590,6 +1628,7 @@ function treedb_link_nodes(gobj, treedb_name, parent_ref, child_ref, options)
         child_ref: child_ref,
         options: options || {}
     };
+    kw.__md_command__ = link_echo(parent_ref, child_ref);
 
     let ret = gobj_command(priv.gobj_remote_yuno,
         command,
@@ -1622,6 +1661,7 @@ function treedb_unlink_nodes(gobj, treedb_name, parent_ref, child_ref, options)
         child_ref: child_ref,
         options: options || {}
     };
+    kw.__md_command__ = link_echo(parent_ref, child_ref);
 
     let ret = gobj_command(priv.gobj_remote_yuno,
         command,
@@ -2105,8 +2145,12 @@ function ac_mt_command_answer(gobj, event, kw, src)
              *  answering its own writes in a loop.
              *
              *  Same event and same kw as C_YUI_TREEDB_TOPICS, plus `command`:
-             *  in a graph a LINK is as much a write as a record is, and the
-             *  three of them carry different halves of the kw.
+             *  in a graph a LINK is as much a write as a record is, and a
+             *  link adds its two refs. Read from what THIS view knows and
+             *  from the answer, never from the request: the frame carries
+             *  back only `__md_command__`. `treedb_name` is the view's,
+             *  `record` is the node the store answered (the child, for a
+             *  link).
              *
              *  `__graphs__` is EXCLUDED, and that exclusion is the point of
              *  reading this comment: the view writes that topic ITSELF, one
@@ -2118,17 +2162,22 @@ function ac_mt_command_answer(gobj, event, kw, src)
             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));
+                    kw_get_str(gobj, kw_command, "graph_topic", "", 0));
             }
             if(result >= 0 &&
                 kw_get_str(gobj, kw_command, "topic_name", "", 0) !== "__graphs__") {
-                gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
-                    treedb_name: kw_get_str(gobj, kw_command, "treedb_name", "", 0),
+                let written = {
+                    treedb_name: priv.treedb_name,
                     topic_name:  kw_get_str(gobj, kw_command, "topic_name", "", 0),
-                    record:      kw_get_dict(gobj, kw_command, "record", {}, 0),
+                    record:      answered_record(data),
                     created:     (command === "create-node"),
                     command:     command
-                });
+                };
+                if(command === "link-nodes" || command === "unlink-nodes") {
+                    written.parent_ref = kw_get_str(gobj, kw_command, "parent_ref", "", 0);
+                    written.child_ref = kw_get_str(gobj, kw_command, "child_ref", "", 0);
+                }
+                gobj_publish_event(gobj, "EV_RECORD_WRITTEN", written);
             }
             break;
 
@@ -2486,7 +2535,7 @@ function ac_update_node(gobj, event, kw, src)
     let options = kw.options || {};
 
     if(refuse_if_readonly(gobj, event)) {
-        graphs_write_refused(gobj, topic_name, record);
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
         return -1;
     }
 
@@ -2496,7 +2545,7 @@ function ac_update_node(gobj, event, kw, src)
     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);
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
         return -1;
     }
 
@@ -2508,11 +2557,22 @@ function ac_update_node(gobj, event, kw, src)
         options
     );
     if(ret < 0) {
-        graphs_write_refused(gobj, topic_name, record);
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
     }
     return ret;
 }
 
+/************************************************************
+ *  The topic a `__graphs__` record arranges.
+ ************************************************************/
+function graph_topic_of(record)
+{
+    if(!record || typeof record !== "object") {
+        return "";
+    }
+    return record.topic || record.id || "";
+}
+
 /************************************************************
  *  A write of `__graphs__` did not land. The engine
  *  (C_G6_NODES_TREE) took it for granted when it left -- nothing
@@ -2520,14 +2580,13 @@ function ac_update_node(gobj, event, kw, src)
  *  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)
+function graphs_write_refused(gobj, topic_name, topic)
 {
     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;

package/src/c_yui_treedb_topics.js

@@ -1624,6 +1624,23 @@ function treedb_nodes(gobj, treedb_name, topic_name, options, page, purpose)
     return 0;
 }
 
+/************************************************************
+ *  The record a write answered: the node the store wrote (an
+ *  update or a create), deleted, or the child of a link. The
+ *  answer's frame carries back only `__md_command__`, never the
+ *  request's own record.
+ ************************************************************/
+function answered_record(data)
+{
+    if(data && typeof data === "object" && !Array.isArray(data)) {
+        return data;
+    }
+    if(Array.isArray(data) && data[0] && typeof data[0] === "object") {
+        return data[0];
+    }
+    return {};
+}
+
 /************************************************************
  *  Command to remote service
  ************************************************************/
@@ -2210,10 +2227,14 @@ function ac_mt_command_answer(gobj, event, kw, src)
              *  and cannot use the node events without answering its own writes
              *  in a loop.
              */
+            /*  From what THIS view knows and from the answer, never from
+             *  the request: the frame carries back only `__md_command__`,
+             *  so `treedb_name` and `record` read there arrived empty.
+             *  `record` is the node the store answered, as it was written.  */
             gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
-                treedb_name: kw_get_str(gobj, kw_command, "treedb_name", "", 0),
+                treedb_name: gobj_read_str_attr(gobj, "treedb_name"),
                 topic_name:  kw_get_str(gobj, kw_command, "topic_name", "", 0),
-                record:      kw_get_dict(gobj, kw_command, "record", {}, 0),
+                record:      answered_record(data),
                 created:     (command === "create-node"),
                 command:     command
             });

package/src/schema_editor_reload.wiring.test.js

@@ -1501,3 +1501,164 @@ describe("EV_REFRESH while a write is in flight", () => {
         expect(not_defined()).toEqual([]);
     });
 });
+
+describe("the body while a write is in flight", () => {
+
+    /*  pointer-events stops the mouse and nothing else: the shell's
+     *  focus trap puts the focus back on the row control that had it,
+     *  and Delete or Enter there sent an action ST_SAVING does not
+     *  declare. `inert` takes the body out of the keyboard's reach too.  */
+    test("is inert, and answers again when the write ends", () => {
+        const {editor, remote, host} = build("r16k1", "db/users");
+        const $body = $in(editor, ".SCHEMA_BODY");
+        expect($body.hasAttribute("inert")).toBe(false);
+
+        const write = start_a_write(editor, host, "name");
+        expect($body.hasAttribute("inert")).toBe(true);
+
+        answer(editor, remote, write, 0, write.kw.record);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect($in(editor, ".SCHEMA_BODY").hasAttribute("inert")).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a drop that ends the write gives the body back too", () => {
+        const {editor, remote, host} = build("r16k2", "db/users");
+        start_a_write(editor, host, "name");
+        drop(editor, remote, host);
+        expect($in(editor, ".SCHEMA_BODY").hasAttribute("inert")).toBe(false);
+    });
+});
+
+describe("the writes of an import mark the topic they write", () => {
+
+    /*  An import that adds a topic, `roles`.  */
+    const IMPORT = JSON.stringify({id: "db", topics: [
+        {id: "users", pkey: "id", cols: [
+            {id: "id", type: "string", flag: ["persistent", "required"]}
+        ]},
+        {id: "roles", pkey: "id", cols: [
+            {id: "id", type: "string", flag: ["persistent", "required"]}
+        ]}
+    ]});
+
+    /*  The record as the store answers it: with the id it gave a new
+     *  one, and its fkeys in list_dict.  */
+    function as_the_store_answers(write)
+    {
+        const record = JSON.parse(JSON.stringify(write.kw.record));
+        const to_dict = (refs) => refs.map((ref) => {
+            const [topic_name, id, hook_name] = ref.split("^");
+            return {topic_name, id, hook_name};
+        });
+        if(write.kw.topic_name === "topics") {
+            record.id = record.id || `db.${record.value}`;
+            record.treedbs = to_dict(record.treedbs || []);
+        }
+        if(write.kw.topic_name === "cols") {
+            record.id = record.id || `${record.topics[0].split("^")[1]}.${record.value}`;
+            record.topics = to_dict(record.topics || []);
+        }
+        return record;
+    }
+
+    function run_the_import(editor, host)
+    {
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        gobj_send_event(editor, "EV_PREVIEW_IMPORT", {prune: false, text: IMPORT,
+            model_gen: editor.priv.model_gen}, editor);
+        expect(editor.priv.import_plan.writes.length).toBeGreaterThan(0);
+        gobj_send_event(editor, "EV_APPLY_IMPORT", {model_gen: editor.priv.model_gen}, editor);
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+    }
+
+    function answer_every_write(editor, remote)
+    {
+        for(let i = 0; i < 10; i++) {
+            const [write] = take("update-node");
+            if(!write) {
+                break;
+            }
+            answer(editor, remote, write, 0, as_the_store_answers(write));
+        }
+    }
+
+    test("from another topic's screen: the topic it wrote, not the one on screen", () => {
+        const {editor, remote, host} = build("r16m1", "db/users");
+        run_the_import(editor, host);
+        answer_every_write(editor, remote);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.written).toEqual({"db.roles": true});
+        expect(errors()).toEqual([]);
+    });
+
+    test("from the topics screen, where no topic is on screen", () => {
+        const {editor, remote, host} = build("r16m2", "db");
+        run_the_import(editor, host);
+        answer_every_write(editor, remote);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.written).toEqual({"db.roles": true});
+        expect(errors()).toEqual([]);
+    });
+
+    test("a column answered with no record: the record it queued says the topic", () => {
+        const {editor, remote, host} = build("r16m3", "db/users");
+        run_the_import(editor, host);
+        const [topic] = take("update-node");
+        expect(topic.kw.topic_name).toBe("topics");
+        answer(editor, remote, topic, 0, as_the_store_answers(topic));
+        const [col] = take("update-node");
+        expect(col.kw.topic_name).toBe("cols");
+        answer(editor, remote, col, 0, null);
+        expect(editor.priv.written).toEqual({"db.roles": true});
+    });
+});
+
+describe("the reason a load failed", () => {
+
+    test("is a key the notice translates, not a string frozen in one language", () => {
+        const remote = gobj_create_service("r16e1_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_SESSION");
+        const host = gobj_create("r16e1_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("r16e1_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        for(const c of take("nodes")) {
+            answer(editor, remote, c, -1, null, "");
+        }
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+        expect(editor.priv.load_error).toBe("cannot load the schemas");
+        /*  The notice already says it: no detail repeating the title.  */
+        expect($in(editor, ".SCHEMA_NOTICE_DETAIL")).toBe(null);
+    });
+
+    test("the backend's own words travel as its key", () => {
+        const remote = gobj_create_service("r16e2_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_SESSION");
+        const host = gobj_create("r16e2_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("r16e2_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        for(const c of take("nodes")) {
+            answer(editor, remote, c, -1, null, "treedb not found");
+        }
+        const $detail = $in(editor, ".SCHEMA_NOTICE_DETAIL");
+        expect($detail.getAttribute("data-i18n")).toBe("treedb not found");
+    });
+
+    test("a load that cannot leave keeps its key", () => {
+        const remote = gobj_create_service("r16e3_remote", "C_TEST_REMOTE", {}, yuno);
+        const host = gobj_create("r16e3_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("r16e3_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(editor.priv.load_error).toBe("cannot reach the treedb");
+        const $detail = $in(editor, ".SCHEMA_NOTICE_DETAIL");
+        expect($detail.getAttribute("data-i18n")).toBe("cannot reach the treedb");
+    });
+});

package/src/treedb_graph_writes.wiring.test.js

@@ -43,6 +43,7 @@ const {
 } = await import("@yuneta/gobj-js");
 
 const logged = [];
+const written = [];         /*  the EV_RECORD_WRITTEN the host heard  */
 const commands = [];        /*  what the fake transport was asked  */
 const told = [];            /*  what the fake engine was told  */
 let refuse_on_the_way = false;
@@ -65,6 +66,20 @@ beforeAll(async () => {
     });
 
     gclass_create("C_TEST_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    /*  The host of the view: it hears what the view publishes.  */
+    gclass_create(
+        "C_TEST_GRAPH_HOST",
+        [["EV_RECORD_WRITTEN", 0], ["EV_TOPIC_SELECTED", 0], ["EV_OPERATION_MODE_CHANGED", 0]],
+        [["ST_IDLE", [
+            ["EV_RECORD_WRITTEN", (gobj, event, kw) => {
+                written.push(kw);
+                return 0;
+            }, null],
+            ["EV_TOPIC_SELECTED", () => 0, null],
+            ["EV_OPERATION_MODE_CHANGED", () => 0, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
     gclass_create(
         "C_TEST_REMOTE",
         [],
@@ -120,6 +135,7 @@ beforeAll(async () => {
 
 beforeEach(() => {
     logged.length = 0;
+    written.length = 0;
     commands.length = 0;
     told.length = 0;
     refuse_on_the_way = false;
@@ -129,9 +145,11 @@ function build(name)
 {
     const remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
     gobj_change_state(remote, "ST_SESSION");
+    const view_host = gobj_create(`${name}_view_host`, "C_TEST_GRAPH_HOST", {}, yuno);
     const host = gobj_create_service(`${name}_graph`, "C_YUI_TREEDB_GRAPH", {
         gobj_remote_yuno: remote,
-        treedb_name: "treedb_test"
+        treedb_name: "treedb_test",
+        subscriber: view_host
     }, yuno);
     const engine = host.priv.gobj_nodes_tree;
     expect(engine).toBeTruthy();
@@ -149,13 +167,19 @@ function save_arrangement(engine, topic)
     });
 }
 
-function answer(host, remote, request, result, comment)
+/*  The answer as the real transports build it: the command frame
+ *  carries ONLY the request's `__md_command__` (C_IEVENT_CLI's
+ *  mt_command, gui_agent's C_AGENT_TREEDB_LINK), never the request's
+ *  own kw. Echoing the whole kw here once hid that the refusal read
+ *  its topic from a `record` no real answer carries.  */
+function answer(host, remote, request, result, comment, data)
 {
+    const md_command = request.kw.__md_command__ || {};
     gobj_send_event(host, "EV_MT_COMMAND_ANSWER", {
         result: result,
         comment: comment || "",
-        data: null,
-        __md_iev__: {command_stack: [{command: request.command, kw: request.kw}]}
+        data: (data === undefined) ? null : data,
+        __md_iev__: {command_stack: [{command: request.command, kw: md_command}]}
     }, remote);
 }
 
@@ -172,6 +196,7 @@ describe("a __graphs__ write that does not land is said to the engine", () => {
         expect(commands.length).toBe(1);
         answer(host, remote, commands[0], -1, "not authorized");
         expect(refused()).toEqual(["yunos"]);
+        expect(logged.filter((l) => /names no topic/.test(l.msg))).toEqual([]);
     });
 
     test("landed: nothing is said", () => {
@@ -206,3 +231,53 @@ describe("a __graphs__ write that does not land is said to the engine", () => {
         expect(refused()).toEqual([]);
     });
 });
+
+/*  What THIS view wrote, told to its host. The answer carries back only
+ *  `__md_command__`: `treedb_name` and `record` read from that frame
+ *  arrived empty with every real transport.  */
+describe("EV_RECORD_WRITTEN carries what it says", () => {
+
+    test("an update: the treedb, the topic and the record the store answered", () => {
+        const {remote, host, engine} = build("w1");
+        logged.length = 0;      /*  the fake engine's fixture, not the check  */
+        gobj_send_event(host, "EV_UPDATE_NODE", {
+            topic_name: "yunos", record: {id: "1", x: 1}
+        }, engine);
+        const [write] = commands;
+        answer(host, remote, write, 0, "", {id: "1", x: 1, y: 2});
+        expect(written).toEqual([{
+            treedb_name: "treedb_test",
+            topic_name: "yunos",
+            record: {id: "1", x: 1, y: 2},
+            created: false,
+            command: "update-node"
+        }]);
+        expect(logged.filter((l) => l.level === "error")).toEqual([]);
+    });
+
+    test("a link: the child's topic, both refs, and the child the store answered", () => {
+        const {remote, host, engine} = build("w2");
+        gobj_send_event(host, "EV_LINK_NODES", {
+            parent_ref: "realms^r1^yunos", child_ref: "yunos^1"
+        }, engine);
+        const [link] = commands;
+        expect(link.command).toBe("link-nodes");
+        answer(host, remote, link, 0, "", {id: "1", realms: ["realms^r1^yunos"]});
+        expect(written).toEqual([{
+            treedb_name: "treedb_test",
+            topic_name: "yunos",
+            record: {id: "1", realms: ["realms^r1^yunos"]},
+            parent_ref: "realms^r1^yunos",
+            child_ref: "yunos^1",
+            created: false,
+            command: "link-nodes"
+        }]);
+    });
+
+    test("the arrangement (__graphs__) is not reported", () => {
+        const {remote, host, engine} = build("w3");
+        save_arrangement(engine, "yunos");
+        answer(host, remote, commands[0], 0, "", {id: "yunos"});
+        expect(written).toEqual([]);
+    });
+});