@yuneta/gobj-ui 7.25.12 → 7.25.14

package/README.md

@@ -819,6 +819,31 @@ A write is known by its topic AND its serial (`<topic>^<form_write>`): each
 topic's form counts its serials from 1, and keyed by the serial alone two
 forms saving at once shared one entry.
 
+**A drop is followed by a read of every open table** (7.25.13, 7.25.14). A
+refused write reads its topic again at once, so a cell edited in place goes
+back to what the store has. A write that fails while the transport is NOT in
+session is the drop, not a refusal: a routing adapter (gui_agent's
+`C_AGENT_TREEDB_LINK`) settles what it had in flight when its session closes.
+The topic cannot be read then — the transport refuses the read (*"cannot route
+'nodes' -- not in session"*) — so the view logs a warning and waits.
+
+A drop also hides the node events published while it lasts: another writer's
+create, update or delete reaches no table. So the disconnect edge marks the
+view, and the first edge that finds the transport in session again reads
+EVERY open table once — as the schema editor reloads its model on the
+reconnect. An `EV_CONNECTION_STATE` "up" that comes before the view's own
+transport is in session does not read; the read waits for an edge that finds
+the transport in session. An "up" with no drop before it reads nothing. A form
+is answered once, also when the edge answered it before the failure arrived.
+
+```js
+// Session up, tables `users` and `roles` open.
+// Session drops                       -> writes in flight answered refused
+// (another writer creates a user; its EV_TREEDB_NODE_CREATED is lost)
+// EV_TRANSPORT_STATE {connected: true}, transport in session
+//                                     -> `nodes` of users and of roles, once each
+```
+
 **The pkey2 of an update goes back as the record had it** (7.25.5). It names
 the instance the write is for, and a `time` pkey2 that crossed the form's
 `datetime-local` came back without its seconds — another instance, or none.

package/dist/gobj-ui.cjs.js

@@ -23160,11 +23160,17 @@ function track_form_write(in_flight, form_write, topic_name) {
 	};
 }
 /************************************************************
-*  A write was answered, one way or the other
+*  A write was answered, one way or the other. True when it was
+*  still in flight: false when something else answered it already
+*  (the transport closing, abandon_form_writes), so its form must
+*  not be answered twice.
 ************************************************************/
 function settle_form_write(in_flight, form_write, topic_name) {
-	if (!in_flight || !form_write) return;
-	delete in_flight[form_write_key(topic_name, form_write)];
+	if (!in_flight || !form_write) return false;
+	const key = form_write_key(topic_name, form_write);
+	if (!Object.prototype.hasOwnProperty.call(in_flight, key)) return false;
+	delete in_flight[key];
+	return true;
 }
 /************************************************************
 *  Nothing in flight can be answered any more: take them all,
@@ -23751,6 +23757,7 @@ var __gclass__$6 = null;
 ***************************************************************/
 function mt_create$6(gobj) {
 	gobj.priv.form_writes = {};
+	gobj.priv.reread_on_session = false;
 	gobj.priv.conn_shell = null;
 	build_ui$6(gobj);
 	let subscriber = (0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "subscriber");
@@ -25181,9 +25188,15 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 			yui_shell_show_error(yui_shell_of(gobj), comment, { t: i18next.t });
 			if (command === "update-node" || command === "create-node") {
 				let failed_topic = (0, _yuneta_gobj_js.kw_get_str)(gobj, kw_command, "topic_name", "", 0);
-				if (failed_topic) (0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
-				settle_form_write(gobj.priv.form_writes, (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0), failed_topic);
-				answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0), false);
+				let form_write = (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0);
+				if (failed_topic) {
+					if (is_connected$1(gobj)) (0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
+					else {
+						(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: the write of '${failed_topic}' was cut by the drop: the topic is read again when the session is back`);
+						gobj.priv.reread_on_session = true;
+					}
+				}
+				if (settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), form_write, false);
 			}
 		}
 		return 0;
@@ -25381,13 +25394,37 @@ function ac_back_to_topics(gobj, event, kw, src) {
 function ac_transport_state$2(gobj, event, kw, src) {
 	let connected = !!(kw && kw.connected);
 	refresh_toolbar_buttons(gobj, connected);
-	if (!connected) abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
-		(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
-		answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
-	});
+	if (!connected) {
+		gobj.priv.reread_on_session = true;
+		abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
+			(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
+			answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
+		});
+	} else reread_open_topics(gobj);
 	return 0;
 }
 /************************************************************
+*  The session is back after a drop: read every open table again,
+*  as the schema editor reloads its model. A drop cuts the writes
+*  in flight AND the node events published meanwhile, so any
+*  table may be stale, not only the one a cut write left.
+*
+*  Only when the TRANSPORT says so too -- the app's connection
+*  (EV_CONNECTION_STATE) can report "up" before the transport of
+*  this view is in session, and a read asked then is refused. The
+*  read waits for an edge that finds the transport in session, and
+*  is done once, though both edges report the same "up".
+************************************************************/
+function reread_open_topics(gobj) {
+	let priv = gobj.priv;
+	if (!priv.reread_on_session || !is_connected$1(gobj)) return;
+	priv.reread_on_session = false;
+	(0, _yuneta_gobj_js.gobj_match_children)(gobj, { __gclass_name__: "C_YUI_TREEDB_TOPIC_WITH_FORM" }).forEach((form) => {
+		let topic_name = (0, _yuneta_gobj_js.gobj_read_attr)(form, "topic_name");
+		if (topic_name) (0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name }, gobj);
+	});
+}
+/************************************************************
 *   Parent (routing) inform us that we go hidden
 ************************************************************/
 function ac_hide$4(gobj, event, kw, src) {

package/dist/gobj-ui.es.js

@@ -23155,11 +23155,17 @@ function track_form_write(in_flight, form_write, topic_name) {
 	};
 }
 /************************************************************
-*  A write was answered, one way or the other
+*  A write was answered, one way or the other. True when it was
+*  still in flight: false when something else answered it already
+*  (the transport closing, abandon_form_writes), so its form must
+*  not be answered twice.
 ************************************************************/
 function settle_form_write(in_flight, form_write, topic_name) {
-	if (!in_flight || !form_write) return;
-	delete in_flight[form_write_key(topic_name, form_write)];
+	if (!in_flight || !form_write) return false;
+	const key = form_write_key(topic_name, form_write);
+	if (!Object.prototype.hasOwnProperty.call(in_flight, key)) return false;
+	delete in_flight[key];
+	return true;
 }
 /************************************************************
 *  Nothing in flight can be answered any more: take them all,
@@ -23746,6 +23752,7 @@ var __gclass__$6 = null;
 ***************************************************************/
 function mt_create$6(gobj) {
 	gobj.priv.form_writes = {};
+	gobj.priv.reread_on_session = false;
 	gobj.priv.conn_shell = null;
 	build_ui$6(gobj);
 	let subscriber = gobj_read_pointer_attr(gobj, "subscriber");
@@ -25176,9 +25183,15 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 			yui_shell_show_error(yui_shell_of(gobj), comment, { t });
 			if (command === "update-node" || command === "create-node") {
 				let failed_topic = kw_get_str(gobj, kw_command, "topic_name", "", 0);
-				if (failed_topic) gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
-				settle_form_write(gobj.priv.form_writes, kw_get_int(gobj, kw_command, "form_write", 0, 0), failed_topic);
-				answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), kw_get_int(gobj, kw_command, "form_write", 0, 0), false);
+				let form_write = kw_get_int(gobj, kw_command, "form_write", 0, 0);
+				if (failed_topic) {
+					if (is_connected$1(gobj)) gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
+					else {
+						log_warning(`${gobj_short_name(gobj)}: the write of '${failed_topic}' was cut by the drop: the topic is read again when the session is back`);
+						gobj.priv.reread_on_session = true;
+					}
+				}
+				if (settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), form_write, false);
 			}
 		}
 		return 0;
@@ -25376,13 +25389,37 @@ function ac_back_to_topics(gobj, event, kw, src) {
 function ac_transport_state$2(gobj, event, kw, src) {
 	let connected = !!(kw && kw.connected);
 	refresh_toolbar_buttons(gobj, connected);
-	if (!connected) abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
-		log_warning(`${gobj_short_name(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
-		answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
-	});
+	if (!connected) {
+		gobj.priv.reread_on_session = true;
+		abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
+			log_warning(`${gobj_short_name(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
+			answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
+		});
+	} else reread_open_topics(gobj);
 	return 0;
 }
 /************************************************************
+*  The session is back after a drop: read every open table again,
+*  as the schema editor reloads its model. A drop cuts the writes
+*  in flight AND the node events published meanwhile, so any
+*  table may be stale, not only the one a cut write left.
+*
+*  Only when the TRANSPORT says so too -- the app's connection
+*  (EV_CONNECTION_STATE) can report "up" before the transport of
+*  this view is in session, and a read asked then is refused. The
+*  read waits for an edge that finds the transport in session, and
+*  is done once, though both edges report the same "up".
+************************************************************/
+function reread_open_topics(gobj) {
+	let priv = gobj.priv;
+	if (!priv.reread_on_session || !is_connected$1(gobj)) return;
+	priv.reread_on_session = false;
+	gobj_match_children(gobj, { __gclass_name__: "C_YUI_TREEDB_TOPIC_WITH_FORM" }).forEach((form) => {
+		let topic_name = gobj_read_attr(form, "topic_name");
+		if (topic_name) gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name }, gobj);
+	});
+}
+/************************************************************
 *   Parent (routing) inform us that we go hidden
 ************************************************************/
 function ac_hide$4(gobj, event, kw, src) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yuneta/gobj-ui",
-  "version": "7.25.12",
+  "version": "7.25.14",
   "type": "module",
   "main": "dist/gobj-ui.cjs.js",
   "module": "dist/gobj-ui.es.js",

package/src/c_yui_treedb_topics.js

@@ -160,6 +160,11 @@ function mt_create(gobj)
      *  and serial (form_writes_in_flight): answered refused when the
      *  transport closes under them.  */
     gobj.priv.form_writes = {};
+    /*  The session dropped since the tables were read: every open table
+     *  may be stale (a write the drop cut, node events published while
+     *  nobody heard them). Read again when the session is back
+     *  (reread_open_topics), never out of session.  */
+    gobj.priv.reread_on_session = false;
     gobj.priv.conn_shell = null;    /*  the shell whose EV_CONNECTION_STATE we hear  */
 
     build_ui(gobj);
@@ -2092,18 +2097,34 @@ function ac_mt_command_answer(gobj, event, kw, src)
              *  topic back to what the treedb actually has. */
             if(command === "update-node" || command === "create-node") {
                 let failed_topic = kw_get_str(gobj, kw_command, "topic_name", "", 0);
+                let form_write = kw_get_int(gobj, kw_command, "form_write", 0, 0);
                 if(failed_topic) {
-                    gobj_send_event(gobj, "EV_REFRESH_TOPIC",
-                        {topic_name: failed_topic}, gobj);
+                    if(is_connected(gobj)) {
+                        gobj_send_event(gobj, "EV_REFRESH_TOPIC",
+                            {topic_name: failed_topic}, gobj);
+                    } else {
+                        /*  A failure out of session is the DROP, not a
+                         *  refusal: a routing adapter settles what it had
+                         *  in flight when its session closes. The topic
+                         *  cannot be read now -- asked, the transport
+                         *  refuses it ("cannot route 'nodes' -- not in
+                         *  session"). The reconnect reads it.  */
+                        log_warning(`${gobj_short_name(gobj)}: the write of ` +
+                            `'${failed_topic}' was cut by the drop: the topic is ` +
+                            `read again when the session is back`);
+                        gobj.priv.reread_on_session = true;
+                    }
+                }
+                /*  Answered once: the transport closing may have answered
+                 *  this form already (ac_transport_state).  */
+                if(settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) {
+                    answer_form_write(
+                        gobj,
+                        get_gobj_formtable(gobj, failed_topic),
+                        form_write,
+                        false
+                    );
                 }
-                settle_form_write(gobj.priv.form_writes,
-                    kw_get_int(gobj, kw_command, "form_write", 0, 0), failed_topic);
-                answer_form_write(
-                    gobj,
-                    get_gobj_formtable(gobj, failed_topic),
-                    kw_get_int(gobj, kw_command, "form_write", 0, 0),
-                    false
-                );
             }
         }
         return 0;
@@ -2460,6 +2481,10 @@ function ac_transport_state(gobj, event, kw, src)
      *  was typed, and the person saves again when the session is back.
      */
     if(!connected) {
+        /*  What happens in the store while the session is down reaches
+         *  no table: its node events are published to nobody. Every open
+         *  table is read again when the session is back.  */
+        gobj.priv.reread_on_session = true;
         abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
             log_warning(`${gobj_short_name(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
             answer_form_write(
@@ -2469,10 +2494,41 @@ function ac_transport_state(gobj, event, kw, src)
                 false
             );
         });
+    } else {
+        reread_open_topics(gobj);
     }
     return 0;
 }
 
+/************************************************************
+ *  The session is back after a drop: read every open table again,
+ *  as the schema editor reloads its model. A drop cuts the writes
+ *  in flight AND the node events published meanwhile, so any
+ *  table may be stale, not only the one a cut write left.
+ *
+ *  Only when the TRANSPORT says so too -- the app's connection
+ *  (EV_CONNECTION_STATE) can report "up" before the transport of
+ *  this view is in session, and a read asked then is refused. The
+ *  read waits for an edge that finds the transport in session, and
+ *  is done once, though both edges report the same "up".
+ ************************************************************/
+function reread_open_topics(gobj)
+{
+    let priv = gobj.priv;
+    if(!priv.reread_on_session || !is_connected(gobj)) {
+        return;
+    }
+    priv.reread_on_session = false;
+    gobj_match_children(gobj, {
+        __gclass_name__: "C_YUI_TREEDB_TOPIC_WITH_FORM"
+    }).forEach((form) => {
+        let topic_name = gobj_read_attr(form, "topic_name");
+        if(topic_name) {
+            gobj_send_event(gobj, "EV_REFRESH_TOPIC", {topic_name: topic_name}, gobj);
+        }
+    });
+}
+
 /************************************************************
  *   Parent (routing) inform us that we go hidden
  ************************************************************/

package/src/form_writes_in_flight.js

@@ -44,14 +44,22 @@ function track_form_write(in_flight, form_write, topic_name)
 }
 
 /************************************************************
- *  A write was answered, one way or the other
+ *  A write was answered, one way or the other. True when it was
+ *  still in flight: false when something else answered it already
+ *  (the transport closing, abandon_form_writes), so its form must
+ *  not be answered twice.
  ************************************************************/
 function settle_form_write(in_flight, form_write, topic_name)
 {
     if(!in_flight || !form_write) {
-        return;
+        return false;
+    }
+    const key = form_write_key(topic_name, form_write);
+    if(!Object.prototype.hasOwnProperty.call(in_flight, key)) {
+        return false;
     }
-    delete in_flight[form_write_key(topic_name, form_write)];
+    delete in_flight[key];
+    return true;
 }
 
 /************************************************************

package/src/treedb_topics_transport.wiring.test.js

@@ -22,7 +22,7 @@ const {
     gclass_create,
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event,
-    gobj_change_state,
+    gobj_change_state, gobj_current_state,
     set_log_callback,
 } = gobj_js;
 const {register_c_yui_shell, yui_shell_set_connection_state} = await import("./c_yui_shell.js");
@@ -30,15 +30,21 @@ const {register_c_yui_treedb_topics} = await import("./c_yui_treedb_topics.js");
 
 const logged = [];
 const answers = [];         /*  what the fake forms were told  */
+const loaded = [];          /*  the rows each fake form was loaded with  */
 const commands = [];        /*  what the fake transport was asked  */
 
 /*
  *  The transport: answers nothing, like a C_IEVENT_CLI whose socket is
- *  about to drop. Its state is what `is_connected()` reads.
+ *  about to drop. Its state is what `is_connected()` reads. Out of
+ *  session it refuses what it is asked, as gui_agent's routing adapter
+ *  (C_AGENT_TREEDB_LINK) does.
  */
 function remote_command_parser(gobj, command, kw, src)
 {
     commands.push({command, kw});
+    if(gobj_current_state(gobj) !== "ST_SESSION") {
+        return `cannot route '${command}' -- not in session`;
+    }
     return null;
 }
 
@@ -52,6 +58,12 @@ function ac_form_answer(gobj, event, kw, src)
     return 0;
 }
 
+function ac_form_load(gobj, event, kw, src)
+{
+    loaded.push({topic: gobj.priv_topic, rows: kw});
+    return 0;
+}
+
 let yuno = null;
 let remote = null;
 
@@ -71,14 +83,19 @@ beforeAll(() => {
     );
     gclass_create(
         "C_YUI_TREEDB_TOPIC_WITH_FORM",
-        [["EV_WRITE_DONE", 0], ["EV_WRITE_REFUSED", 0]],
+        [["EV_WRITE_DONE", 0], ["EV_WRITE_REFUSED", 0], ["EV_LOAD_NODES", 0]],
         [["ST_IDLE", [
             ["EV_WRITE_DONE",    ac_form_answer, null],
-            ["EV_WRITE_REFUSED", ac_form_answer, null]
+            ["EV_WRITE_REFUSED", ac_form_answer, null],
+            ["EV_LOAD_NODES",    ac_form_load,   null]
         ]]],
         {},
         0,
-        [SDATA(data_type_t.DTP_STRING, "topic_name", 0, "", "topic"), SDATA_END()],
+        [
+            SDATA(data_type_t.DTP_STRING, "topic_name", 0, "", "topic"),
+            SDATA(data_type_t.DTP_BOOLEAN, "with_remote_paging", 0, false, "pulls its pages"),
+            SDATA_END()
+        ],
         {}, 0, 0, 0, 0
     );
     /*  The host of the view: it hears what a CHILD view publishes.  */
@@ -106,6 +123,7 @@ beforeEach(() => {
     logged.length = 0;
     answers.length = 0;
     commands.length = 0;
+    loaded.length = 0;
 });
 
 function build(name)
@@ -127,7 +145,9 @@ function build(name)
 
     const forms = {};
     for(const topic of ["users", "roles"]) {
-        forms[topic] = gobj_create(`${name}_form_${topic}`, "C_YUI_TREEDB_TOPIC_WITH_FORM",
+        /*  Named as the view names its forms: the answer of a `nodes`
+         *  finds its table by that name.  */
+        forms[topic] = gobj_create(`${name}_topics?${topic}`, "C_YUI_TREEDB_TOPIC_WITH_FORM",
             {topic_name: topic}, topics);
         forms[topic].priv_topic = topic;
     }
@@ -226,3 +246,164 @@ describe("a Save in flight when the backend drops (M8)", () => {
         ]);
     });
 });
+
+/*
+ *  The answer the routing adapter gives a write it had in flight when
+ *  its session closed: a failure, settled by the adapter itself.
+ */
+function failed_write(topic_name, form_write)
+{
+    const md = {topic_name: topic_name, treedb_name: "treedb_test", record: {id: "x"}};
+    if(form_write) {
+        md.form_write = form_write;
+    }
+    return {result: -1, comment: "the session closed", data: null, __md_iev__: {
+        command_stack: [{command: "update-node", kw: md}]
+    }};
+}
+
+function nodes_asked()
+{
+    return commands.filter((c) => c.command === "nodes").map((c) => c.kw.topic_name);
+}
+
+describe("a write cut by the drop does not reload out of session", () => {
+
+    test("the failure lands before the edge: no reload now, one on the reconnect", () => {
+        const {shell, topics} = build("t6");
+        yui_shell_set_connection_state(shell, true);
+
+        /*  A cell edited in place: it looks saved until the topic is read again.  */
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "users", id: "x", field: "name", value: "typed"}, topics);
+        expect(commands.filter((c) => c.command === "update-node").length).toBe(1);
+
+        /*  The adapter leaves ST_SESSION and settles what it had in flight.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 0), remote);
+
+        expect(nodes_asked()).toEqual([]);
+        expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
+
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        expect(nodes_asked()).toEqual([]);
+
+        /*  The reconnect reads every open table -- once, though two edges
+         *  report it.  */
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the edge lands first: the form is answered once, the reload waits", () => {
+        const {shell, topics, forms} = build("t7");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        yui_shell_set_connection_state(shell, false);
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 1), remote);
+
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+        expect(nodes_asked()).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an edge that says 'up' before the transport is: the reload still waits", () => {
+        const {shell, topics} = build("t8");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "roles", id: "x", field: "name", value: "typed"}, topics);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("roles", 0), remote);
+        yui_shell_set_connection_state(shell, false);
+
+        /*  The app's connection is back, the view's transport is not yet.  */
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
+        expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
+    });
+
+    test("a write refused IN session reloads its topic at once", () => {
+        const {shell, topics} = build("t9");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "users", id: "x", field: "name", value: "typed"}, topics);
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 0), remote);
+        expect(nodes_asked()).toEqual(["users"]);
+    });
+});
+
+/*
+ *  The answer of a `nodes`, the way C_IEVENT_CLI delivers it.
+ */
+function nodes_answer_of(topic_name, rows)
+{
+    return {result: 0, comment: "", data: rows, __md_iev__: {
+        command_stack: [{command: "nodes", kw: {topic_name: topic_name}}]
+    }};
+}
+
+describe("what the drop hid is read again on the reconnect", () => {
+
+    test("a node created during the drop is in its table after the reconnect", () => {
+        const {shell, topics} = build("t10");
+        yui_shell_set_connection_state(shell, true);
+
+        /*  No write in flight: the session just drops. While it is down,
+         *  another writer creates a user; its EV_TREEDB_NODE_CREATED is
+         *  published to nobody.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        yui_shell_set_connection_state(shell, false);
+        expect(nodes_asked()).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        yui_shell_set_connection_state(shell, true);
+
+        /*  Every open table is read once, though two edges said "up".  */
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
+
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER",
+            nodes_answer_of("users", [{id: "x"}, {id: "created_during_the_drop"}]), remote);
+        expect(loaded).toEqual([
+            {topic: "users", rows: [{id: "x"}, {id: "created_during_the_drop"}]}
+        ]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an 'up' with no drop before it reads nothing", () => {
+        const {shell, topics} = build("t11");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked()).toEqual([]);
+    });
+
+    test("an edge that says 'up' before the transport is in session waits", () => {
+        const {shell, topics} = build("t12");
+        yui_shell_set_connection_state(shell, true);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        yui_shell_set_connection_state(shell, false);
+
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual([]);
+        expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked().sort()).toEqual(["roles", "users"]);
+    });
+});