@yuneta/gobj-ui 7.25.19 → 7.25.20

package/src/c_g6_nodes_tree.js

@@ -494,6 +494,7 @@ let PRIVATE_DATA = {
     _graph_properties:  {},         // topic_name → {nodes: {node_id: {x,y,size,...}}}
     _saved_graph_properties: {},    // the same, as the BACKEND has it: what a Save compares against
     _graphs_writes_owed: {},        // topic_name → true: a __graphs__ write the host said did not land
+    _graphs_load:       0,          // the LOAD a __graphs__ write belongs to: EV_CLEAR_DATA starts another
     yet_showed:         false,
     edit_mode:          false,
     operation_mode:     null,
@@ -3301,7 +3302,10 @@ function save_topic_graph_properties(gobj, topic_name)
             list_dict: true,
             autolink: false,
             create: true
-        }
+        },
+        /*  Echoed back with a refusal (EV_GRAPHS_WRITE_REFUSED), so
+         *  one answered after a reload is told from one of THIS load.  */
+        graphs_load: priv._graphs_load
     };
     gobj_publish_event(gobj, "EV_UPDATE_NODE", kw_update);
 }
@@ -10372,6 +10376,9 @@ function ac_clear_data(gobj, event, kw, src)
      *  reload brings what the backend holds, and that is what the view
      *  will hold.  */
     priv._graphs_writes_owed = {};
+    /*  And a write still on its way belongs to it: its refusal, if
+     *  one comes, is about an arrangement this view no longer holds.  */
+    priv._graphs_load++;
 
     /*  The node counters belong to the data that is going away: a refresh
      *  that kept them would decide the layout on the previous treedb. */
@@ -10537,12 +10544,19 @@ function ac_save_graph(gobj, event, kw, src)
 /************************************************************
  *  The host says a write of `__graphs__` did not land: the
  *  backend refused it, the transport refused it on the way out,
- *  or there was no session to send it on. kw: {topic}
+ *  or there was no session to send it on.
+ *  kw: {topic, graphs_load}
  *
  *  save_topic_graph_properties() recorded it as saved before it
  *  left. Forgotten now, and the Save is lit again: the next Save
  *  writes the topic again. Before, the view believed the backend
  *  held the arrangement, and the next Save had nothing to write.
+ *
+ *  `graphs_load` is the load the write was sent from, echoed by the
+ *  host. A refusal of an EARLIER load is about an arrangement the
+ *  reload replaced with what the backend holds: applied, it lit the
+ *  Save over nothing changed (before gobj-ui 7.25.20). A host that
+ *  echoes no load is taken at its word, as before.
  ************************************************************/
 function ac_graphs_write_refused(gobj, event, kw, src)
 {
@@ -10553,6 +10567,11 @@ function ac_graphs_write_refused(gobj, event, kw, src)
         log_error(`${gobj_short_name(gobj)}: ${event} names no topic`);
         return -1;
     }
+    if(kw.graphs_load !== undefined && kw.graphs_load !== priv._graphs_load) {
+        log_warning(`${gobj_short_name(gobj)}: a refused write of the arrangement ` +
+            `of '${topic_name}' belongs to an earlier load: ignored`);
+        return 0;
+    }
     log_warning(`${gobj_short_name(gobj)}: the arrangement of '${topic_name}' ` +
         `was not saved: the next Save writes it again`);
     forget_refused_graphs_write(priv._saved_graph_properties, topic_name);
@@ -10600,10 +10619,16 @@ function ac_node_created(gobj, event, kw, src)
         return 0;
     }
 
-    // Handle __graphs__ creation: update _graph_properties
+    /*  The first record of a topic's arrangement. Only THAT topic
+     *  moves, as for an update echo: build_graph_properties() took
+     *  every topic's saved copy from the live objects the view edits
+     *  in place, so an unsaved change of another topic counted as
+     *  saved and its Save was lost (before gobj-ui 7.25.20).  */
     if(topic_name === '__graphs__') {
         priv.__graphs__.push(node);
-        build_graph_properties(gobj);
+        apply_graphs_echo(
+            priv._graph_properties, priv._saved_graph_properties, priv.__graphs__, node
+        );
         settle_owed_graphs_write(gobj, node);
         return 0;
     }

package/src/c_yui_json.js

@@ -64,6 +64,7 @@ import {
     gclass_create,
     gclass_find_by_name,
     log_error,
+    log_warning,
     gobj_read_pointer_attr,
     gobj_parent,
     gobj_subscribe_event,
@@ -898,8 +899,12 @@ function push_collapsed_row(ctx, value, segments, depth, key, rows)
     children.push(['span', {class: 'JSON_STUB_HINT is-size-7 ml-2',
                             'data-i18n': is_pending ? 'loading' : 'click to load'},
                    is_pending ? 'loading' : 'click to load']);
-    if(err) {
-        children.push(['span', {class: 'JSON_STUB_ERR has-text-danger is-size-7 ml-2'}, String(err)]);
+    if(err && err.is_key) {
+        children.push(['span', {class: 'JSON_STUB_ERR has-text-danger is-size-7 ml-2',
+                                'data-i18n': err.error}, t(err.error)]);
+    } else if(err) {
+        children.push(['span', {class: 'JSON_STUB_ERR has-text-danger is-size-7 ml-2'},
+                       String(err.error)]);
     }
 
     let attrs = {
@@ -1117,17 +1122,35 @@ function ac_subtree_loaded(gobj, event, kw, src)
 }
 
 /************************************************************
- *   EV_SUBTREE_ERROR { path, error } — mark the failed branch
+ *   EV_SUBTREE_ERROR { path, error | i18n, by_design }
+ *   — mark the branch that was not loaded.
+ *
+ *   `error` is text, drawn as it came (a backend's comment).
+ *   `i18n` is a KEY, drawn as t(key) with data-i18n so the stub
+ *   changes language with the app (a text translated by the host
+ *   stays in the language it was sent in). The name is the one a
+ *   locale check scans for (`i18n: "<key>"`), so the key of every
+ *   host stays visible to it.
+ *   `by_design`: the host answers that it CANNOT read a subtree
+ *   (a form holds records, a pasted pad has no backend) -- that is
+ *   not a failure, and it is logged as a warning. Anything else is
+ *   a load that failed, logged as an error.
  ************************************************************/
 function ac_subtree_error(gobj, event, kw, src)
 {
     let priv = gobj.priv;
 
     let path = kw.path || "";
+    let is_key = !!kw.i18n;
+    let error = kw.i18n || kw.error || "error";
     priv.pending.delete(path);
-    priv.errors.set(path, kw.error || "error");
+    priv.errors.set(path, {error: error, is_key: is_key});
 
-    log_error(`${GCLASS_NAME}: subtree load failed at '${path}': ${kw.error || ""}`);
+    if(kw.by_design) {
+        log_warning(`${GCLASS_NAME}: subtree not loaded at '${path}': ${error}`);
+    } else {
+        log_error(`${GCLASS_NAME}: subtree load failed at '${path}': ${error}`);
+    }
 
     render_view(gobj);
     return 0;

package/src/c_yui_json_pad.js

@@ -798,8 +798,9 @@ function ac_hide_diff(gobj, event, kw, src)
 function ac_expand_path(gobj, event, kw, src)
 {
     gobj_send_event(src, "EV_SUBTREE_ERROR", {
-        path: (kw && kw.path) || "",
-        error: t("collapsed in the source")
+        path:      (kw && kw.path) || "",
+        i18n:      "collapsed in the source",
+        by_design: true
     }, gobj);
     return 0;
 }

package/src/c_yui_schema_editor.js

@@ -2820,6 +2820,19 @@ function run_next_write(gobj)
     let command = write_command(write.op);
     let options = write_options(write.op);
 
+    /*  Out of session a write is not sent, and ends here. A direct
+     *  C_IEVENT_CLI answers a command out of session with null -- the
+     *  answer of a request that LEFT -- so without this the editor
+     *  waited in ST_SAVING, inert, for an answer that never comes
+     *  (before gobj-ui 7.25.20). What the queue wrote before is not
+     *  known to the next session: it reads the model again.  */
+    if(!transport_in_session(gobj)) {
+        log_warning(`${gobj_short_name(gobj)}: no session, '${command}' ` +
+            `of '${write.topic_name}' was not sent`);
+        priv.reload_on_open = true;
+        return end_writes(gobj, "cannot reach the treedb");
+    }
+
     priv.write_tag++;
     if(remote_command(gobj, command, {
         topic_name: write.topic_name,
@@ -2827,7 +2840,7 @@ function run_next_write(gobj)
         options:    options,
         record_id:  write.record.id || ""
     }, {write: priv.write_tag}) < 0) {
-        return end_writes(gobj, t("cannot reach the treedb"));
+        return end_writes(gobj, "cannot reach the treedb");  /*  a key: the toast translates it  */
     }
     return 0;
 }

package/src/c_yui_treedb_graph.js

@@ -1325,7 +1325,7 @@ function request_print_tranger(gobj, path)
         let jv = priv.json_gobj;
         if(path && jv && is_gobj(jv) && !gobj_is_destroying(jv)) {
             gobj_send_event(jv, "EV_SUBTREE_ERROR",
-                {path: path, error: t("no session")}, gobj);
+                {path: path, i18n: "no session"}, gobj);
         }
         return;
     }
@@ -1498,7 +1498,7 @@ function treedb_create_node(gobj, treedb_name, topic_name, record, options)
 /************************************************************
  *  Command to remote service
  ************************************************************/
-function treedb_update_node(gobj, treedb_name, topic_name, record, options)
+function treedb_update_node(gobj, treedb_name, topic_name, record, options, graphs_load)
 {
     let priv = gobj.priv;
 
@@ -1525,6 +1525,11 @@ function treedb_update_node(gobj, treedb_name, topic_name, record, options)
      *  arranges, so that topic has to travel here.  */
     if(topic_name === "__graphs__") {
         kw.__md_command__.graph_topic = graph_topic_of(record);
+        /*  And the engine's LOAD it was sent from: a refusal answered
+         *  after a reload is not about the arrangement shown now.  */
+        if(graphs_load !== undefined) {
+            kw.__md_command__.graphs_load = graphs_load;
+        }
     }
 
     let ret = gobj_command(priv.gobj_remote_yuno,
@@ -2162,7 +2167,8 @@ 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_str(gobj, kw_command, "graph_topic", "", 0));
+                    kw_get_str(gobj, kw_command, "graph_topic", "", 0),
+                    kw_command ? kw_command.graphs_load : undefined);
             }
             if(result >= 0 &&
                 kw_get_str(gobj, kw_command, "topic_name", "", 0) !== "__graphs__") {
@@ -2533,9 +2539,10 @@ function ac_update_node(gobj, event, kw, src)
     let topic_name = kw.topic_name;
     let record = kw.record;
     let options = kw.options || {};
+    let graphs_load = kw.graphs_load;
 
     if(refuse_if_readonly(gobj, event)) {
-        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record), graphs_load);
         return -1;
     }
 
@@ -2545,7 +2552,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, graph_topic_of(record));
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record), graphs_load);
         return -1;
     }
 
@@ -2554,10 +2561,11 @@ function ac_update_node(gobj, event, kw, src)
         treedb_name,
         topic_name,
         record,
-        options
+        options,
+        graphs_load
     );
     if(ret < 0) {
-        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record), graphs_load);
     }
     return ret;
 }
@@ -2578,9 +2586,11 @@ function graph_topic_of(record)
  *  (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.
+ *  the answer's error says what happened to them. `graphs_load` is
+ *  the engine's load the write was sent from, handed back so it can
+ *  tell a refusal of an earlier load from one of the current.
  ************************************************************/
-function graphs_write_refused(gobj, topic_name, topic)
+function graphs_write_refused(gobj, topic_name, topic, graphs_load)
 {
     let priv = gobj.priv;
 
@@ -2594,7 +2604,11 @@ function graphs_write_refused(gobj, topic_name, topic)
     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);
+    let kw = {topic: topic};
+    if(graphs_load !== undefined) {
+        kw.graphs_load = graphs_load;
+    }
+    gobj_send_event(priv.gobj_nodes_tree, "EV_GRAPHS_WRITE_REFUSED", kw, gobj);
 }
 
 /********************************************

package/src/c_yui_treedb_topic_with_form.js

@@ -3711,8 +3711,9 @@ function ac_expand_path(gobj, event, kw, src)
     let path = (kw && kw.path) || "";
 
     gobj_send_event(src, "EV_SUBTREE_ERROR", {
-        path:  path,
-        error: t("this part cannot be loaded here")
+        path:      path,
+        i18n:      "this part cannot be loaded here",
+        by_design: true
     }, gobj);
     return 0;
 }

package/src/c_yui_treedb_topics.js

@@ -1955,7 +1955,7 @@ function request_print_tranger(gobj, path)
         let jv = priv.json_gobj;
         if(path && jv && is_gobj(jv) && !gobj_is_destroying(jv)) {
             gobj_send_event(jv, "EV_SUBTREE_ERROR",
-                {path: path, error: t("no session")}, gobj);
+                {path: path, i18n: "no session"}, gobj);
         }
         return;
     }

package/src/form_json_expand.wiring.test.js

@@ -43,10 +43,12 @@ const {
     SDATA_END, gclass_create,
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event, gobj_current_state,
+    gobj_create_pure_child, gobj_read_attr,
     set_log_callback,
 } = await import("@yuneta/gobj-js");
 const {register_c_yui_shell} = await import("./c_yui_shell.js");
 const {register_c_yui_json} = await import("./c_yui_json.js");
+const {t} = await import("i18next");
 const {register_c_yui_treedb_topic_with_form} = await import("./c_yui_treedb_topic_with_form.js");
 
 const logged = [];
@@ -86,6 +88,11 @@ function errors()
     return logged.filter((l) => l.level === "error").map((l) => l.msg);
 }
 
+function warnings()
+{
+    return logged.filter((l) => l.level === "warning").map((l) => l.msg);
+}
+
 describe("a viewer of the form asks to load a truncated part", () => {
 
     test("the form answers that it cannot, and the stub stops loading", () => {
@@ -112,10 +119,86 @@ describe("a viewer of the form asks to load a truncated part", () => {
         gobj_send_event(viewer, "EV_EXPAND_COLLAPSED", {path: "cols`name", size: 40}, viewer);
 
         expect(viewer.priv.pending.has("cols`name")).toBe(false);
-        expect(viewer.priv.errors.get("cols`name")).toBe("this part cannot be loaded here");
-        /*  The viewer logs what it could not load; nothing else is.  */
+        /*  The KEY travels, not its translation: the stub draws t(key)
+         *  with data-i18n, so it changes language with the app.  */
+        expect(viewer.priv.errors.get("cols`name")).toEqual(
+            {error: "this part cannot be loaded here", is_key: true});
+        /*  A host saying it cannot, by design, is a WARNING: an ERROR
+         *  on every click broke the clean-console check of a deploy and
+         *  reached the backend through the remote log.  */
+        expect(errors()).toEqual([]);
+        expect(warnings()).toEqual([
+            "C_YUI_JSON: subtree not loaded at 'cols`name': this part cannot be loaded here"
+        ]);
+
+    });
+});
+
+describe("the stub of a subtree that was not loaded", () => {
+
+    /*  A host answering with a KEY that it cannot, by design.  */
+    function make_viewer(name, answer)
+    {
+        gclass_create(`C_TEST_JSON_HOST_${name}`, [["EV_EXPAND_PATH", 0]], [
+            ["ST_IDLE", [["EV_EXPAND_PATH", function(gobj, event, kw, src) {
+                gobj_send_event(src, "EV_SUBTREE_ERROR",
+                    Object.assign({path: kw.path}, answer), gobj);
+                return 0;
+            }, null]]]
+        ], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+        const host = gobj_create(`${name}_host`, `C_TEST_JSON_HOST_${name}`, {}, yuno);
+        gobj_start(host);
+        const viewer = gobj_create_pure_child(`${name}_jv`, "C_YUI_JSON", {
+            json_data: {a: {__collapsed__: {size: 3, path: "a"}}}
+        }, host);
+        gobj_start(viewer);
+        return viewer;
+    }
+
+    function stub_error(viewer)
+    {
+        return gobj_read_attr(viewer, "$container").querySelector(".JSON_STUB_ERR");
+    }
+
+    test("a key is drawn translated, carries data-i18n, and follows the language", async () => {
+        const i18next = (await import("i18next")).default;
+        i18next.addResource("es", "translation",
+            "this part cannot be loaded here", "esta parte no se puede cargar aqui");
+
+        const viewer = make_viewer("s1",
+            {i18n: "this part cannot be loaded here", by_design: true});
+        logged.length = 0;
+        gobj_send_event(viewer, "EV_EXPAND_COLLAPSED", {path: "a", size: 3}, viewer);
+
+        let el = stub_error(viewer);
+        expect(el).toBeTruthy();
+        expect(el.getAttribute("data-i18n")).toBe("this part cannot be loaded here");
+        expect(el.textContent).toBe("this part cannot be loaded here");
+        expect(errors()).toEqual([]);
+        expect(warnings()).toEqual([
+            "C_YUI_JSON: subtree not loaded at 'a': this part cannot be loaded here"
+        ]);
+
+        await i18next.changeLanguage("es");
+        try {
+            gobj_send_event(viewer, "EV_LANGUAGE_CHANGED", {}, viewer);
+            expect(stub_error(viewer).textContent).toBe("esta parte no se puede cargar aqui");
+            expect(t("this part cannot be loaded here")).toBe("esta parte no se puede cargar aqui");
+        } finally {
+            await i18next.changeLanguage("en");
+        }
+    });
+
+    test("a failure in free text is drawn as it came, and is an ERROR", () => {
+        const viewer = make_viewer("s2", {error: "print-tranger failed"});
+        logged.length = 0;
+        gobj_send_event(viewer, "EV_EXPAND_COLLAPSED", {path: "a", size: 3}, viewer);
+
+        let el = stub_error(viewer);
+        expect(el.getAttribute("data-i18n")).toBe(null);
+        expect(el.textContent).toBe("print-tranger failed");
         expect(errors()).toEqual([
-            "C_YUI_JSON: subtree load failed at 'cols`name': this part cannot be loaded here"
+            "C_YUI_JSON: subtree load failed at 'a': print-tranger failed"
         ]);
     });
 });

package/src/g6_graphs_write_owed.wiring.test.js

@@ -235,3 +235,80 @@ describe("a refused __graphs__ write keeps the Save lit", () => {
         expect(errors()).toEqual([]);
     });
 });
+
+/*  A refusal is about the LOAD its write was sent from. Before gobj-ui
+ *  7.25.20 it carried only the topic: Save, then Refresh, then the
+ *  refusal landed and was applied to the FRESH load -- the Save lit
+ *  over nothing changed, and pressing it wrote a record identical to
+ *  what the backend holds.  */
+describe("a refusal of an earlier load is not applied to the current one", () => {
+
+    test("the write carries its load, and a refusal of it counts", () => {
+        const g = build("edition");
+        g.tree.priv._graph_properties.users.nodes.u1.x = 99;
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const [write] = published.filter((p) => p.event === "EV_UPDATE_NODE");
+        expect(typeof write.kw.graphs_load).toBe("number");
+
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED",
+            {topic: "users", graphs_load: write.kw.graphs_load}, g.tree);
+        expect(g.lit()).toBe(true);
+        expect(g.tree.priv._saved_graph_properties.users).toBe(undefined);
+        expect(errors()).toEqual([]);
+    });
+
+    test("Save, reload, then the refusal: ignored, and said", () => {
+        const g = build("edition");
+        g.tree.priv._graph_properties.users.nodes.u1.x = 99;
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const [write] = published.filter((p) => p.event === "EV_UPDATE_NODE");
+
+        gobj_send_event(g.tree, "EV_CLEAR_DATA", {}, g.tree);
+        /*  The reload brings what the backend holds.  */
+        g.tree.priv._graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+        g.tree.priv._saved_graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        logged.length = 0;
+
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED",
+            {topic: "users", graphs_load: write.kw.graphs_load}, g.tree);
+        expect(g.lit()).toBe(false);
+        expect(g.tree.priv._saved_graph_properties.users).toEqual({nodes: {u1: {x: 10, y: 20}}});
+        expect(logged.map((l) => [l.level, l.msg.replace(/^\S+: /, "")])).toEqual([
+            ["warning", "a refused write of the arrangement of 'users' belongs to an earlier load: ignored"]
+        ]);
+    });
+});
+
+/*  The FIRST record of a topic's arrangement arrives as a CREATE echo
+ *  (from this browser or another). Before gobj-ui 7.25.20 it rebuilt
+ *  every topic's saved copy from the live objects the view edits in
+ *  place, so an unsaved change of ANOTHER topic counted as saved and
+ *  the next Save did not write it.  */
+describe("a __graphs__ create echo moves only its own topic", () => {
+
+    test("an unsaved change of another topic stays unsaved", () => {
+        const g = build("edition");
+        g.tree.priv.descs = {};
+        g.tree.priv.__graphs__ = [
+            {id: "users", topic: "users", active: true,
+                properties: g.tree.priv._graph_properties.users}
+        ];
+        /*  Edited in place, not saved.  */
+        g.tree.priv._graph_properties.users.nodes.u1.x = 77;
+
+        gobj_send_event(g.tree, "EV_NODE_CREATED", {
+            topic_name: "__graphs__",
+            node: {id: "roles", topic: "roles", active: true,
+                properties: {nodes: {r1: {x: 1, y: 2}}}}
+        }, g.tree);
+
+        expect(g.tree.priv._saved_graph_properties.users).toEqual({nodes: {u1: {x: 10, y: 20}}});
+        expect(g.tree.priv._saved_graph_properties.roles).toEqual({nodes: {r1: {x: 1, y: 2}}});
+
+        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(errors()).toEqual([]);
+    });
+});

package/src/schema_editor_transport.wiring.test.js

@@ -37,7 +37,7 @@ const {
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event, gobj_read_attr,
     gobj_change_state, gobj_current_state,
-    set_log_callback,
+    set_log_callback, log_error,
 } = await import("@yuneta/gobj-js");
 const {register_c_yui_schema_editor} = await import("./c_yui_schema_editor.js");
 
@@ -56,13 +56,33 @@ const RECORDS = {
     ],
 };
 
-/*  A transport out of session refuses in the RETURN, as C_IEVENT_CLI and
- *  the routing adapters do: a request that did not leave is not waited for.  */
+/*  A transport out of session refuses in the RETURN, as the routing
+ *  adapters do (gui_agent's C_AGENT_TREEDB_LINK): a request that did not
+ *  leave is not waited for. `refuse_on_the_way` makes it refuse IN
+ *  session too, as a transport that cannot send.  */
+let refuse_on_the_way = false;
+
 function remote_command_parser(gobj, command, kw, src)
 {
     if(gobj_current_state(gobj) !== "ST_SESSION") {
         return `${command}: not in session`;
     }
+    if(refuse_on_the_way) {
+        return `${command}: cannot send`;
+    }
+    commands.push({command, kw, src});
+    return null;
+}
+
+/*  A DIRECT C_IEVENT_CLI, as its mt_command does it: out of session it
+ *  logs "Not in session" and answers NULL -- the same answer as a request
+ *  that left. The README allows `gobj_remote_yuno` to be one.  */
+function ievent_cli_command_parser(gobj, command, kw, src)
+{
+    if(gobj_current_state(gobj) !== "ST_SESSION") {
+        log_error(`Not in session`);
+        return null;
+    }
     commands.push({command, kw, src});
     return null;
 }
@@ -93,6 +113,13 @@ beforeAll(() => {
         {mt_command_parser: remote_command_parser},
         0, [SDATA_END()], {}, 0, 0, 0, 0
     );
+    gclass_create(
+        "C_TEST_IEVENT_CLI",
+        [],
+        [["ST_DISCONNECTED", []], ["ST_SESSION", []]],
+        {mt_command_parser: ievent_cli_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
     register_c_yui_schema_editor();
     yuno = gobj_create_yuno("transport_yuno", "C_TEST_HOST", {});
     gobj_start(yuno);
@@ -102,6 +129,7 @@ beforeEach(() => {
     logged.length = 0;
     commands.length = 0;
     shown.length = 0;
+    refuse_on_the_way = false;
 });
 
 function take(command)
@@ -148,9 +176,10 @@ function reconnect(editor, remote, host)
     gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
 }
 
-function build(name, loaded)
+function build(name, loaded, remote_gclass)
 {
-    const remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
+    const remote = gobj_create_service(`${name}_remote`,
+        remote_gclass || "C_TEST_REMOTE", {}, yuno);
     gobj_change_state(remote, "ST_SESSION");
     const host = gobj_create(`${name}_host`, "C_TEST_EDITOR_HOST", {}, yuno);
     const editor = gobj_create(`${name}_editor`, "C_YUI_SCHEMA_EDITOR", {
@@ -455,3 +484,58 @@ describe("a write answered after it was given up", () => {
         expect(errors()).toEqual([]);
     });
 });
+
+/*  Before gobj-ui 7.25.20 a write never asked whether the transport was
+ *  in session. A direct C_IEVENT_CLI answers null out of session, which
+ *  remote_command() took for "sent": the editor sat in ST_SAVING, busy
+ *  and inert, until another drop.  */
+describe("a write with the transport out of session", () => {
+
+    test("a direct C_IEVENT_CLI: the write ends, said, and the next session reads again", () => {
+        const {editor, remote, host} = build("x1", true, "C_TEST_IEVENT_CLI");
+        /*  Gone, and the host's edge has not arrived yet.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+
+        gobj_send_event(editor, "EV_SAVE_COLUMN", {
+            creating: true, topic: "users", values: {value: "name", type: "string"}
+        }, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(is_busy(editor)).toBe(false);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual(["cannot reach the treedb"]);
+        expect(errors()).toEqual([]);
+        expect(warnings()).toEqual([
+            "C_YUI_SCHEMA_EDITOR^x1_editor: no session, 'update-node' of 'cols' was not sent"
+        ]);
+
+        gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+
+    /*  The toast is handed the KEY (yui_shell_show_error translates it
+     *  and keeps it for a change of language). This path passed
+     *  t("cannot reach the treedb"), a text that cannot re-translate.  */
+    test("a transport that refuses in session: the toast gets the key", async () => {
+        const i18next = (await import("i18next")).default;
+        if(!i18next.isInitialized) {
+            await i18next.init({lng: "en", resources: {}});
+        }
+        i18next.addResource(i18next.language || "en", "translation",
+            "cannot reach the treedb", "TRANSLATED: cannot reach the treedb");
+        try {
+            const {editor, remote, host} = build("x2", true);
+            refuse_on_the_way = true;
+            gobj_send_event(editor, "EV_SAVE_COLUMN", {
+                creating: true, topic: "users", values: {value: "name", type: "string"}
+            }, host);
+            expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+            expect(shown).toEqual(["cannot reach the treedb"]);
+            expect(errors()).toEqual(["update-node: cannot send"]);
+        } finally {
+            i18next.removeResourceBundle(i18next.language || "en", "translation");
+        }
+    });
+});