@yuneta/gobj-ui 7.25.5 → 7.25.6

package/README.md

@@ -2154,6 +2154,20 @@ else.
 - In: `EV_SHOW` (`{subpath}` — the tail it owns is `<treedb>[/<topic>]` or
   `<treedb>/diagram`), `EV_HIDE`, `EV_TRANSPORT_STATE`, `EV_REFRESH`,
   `EV_LANGUAGE_CHANGED`, `EV_MT_COMMAND_ANSWER`.
+- A **drop** of the transport — `EV_TRANSPORT_STATE {connected: false}`, or a
+  failed answer that arrives while the transport is out of `ST_SESSION` — ends
+  the load or the write it cut, and the model is asked again on the next
+  `{connected: true}`. A write cut this way is shown as
+  `the connection dropped during the write` (an i18n key the consumer's
+  locales carry). Each request carries its round in `__md_command__`
+  (`round` / `write`), so an answer of what the drop cut is ignored with a
+  warning.
+
+  ```js
+  // the host forwards its session edges; nothing else is needed
+  gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+  gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
+  ```
 - Out: `EV_POSITION_CHANGED` (`{subpath}` — the host writes the url; this view
   navigates nothing itself), `EV_RECORD_WRITTEN` (whoever owns the Apply needs
   to know the yuno has not re-read its schema yet), `EV_SCHEMA_CHECKED`

package/dist/gobj-ui.cjs.js

@@ -72101,6 +72101,12 @@ function write_options(op) {
 *      `update-node` / `delete-node` on the treedb service, and it may
 *      be a routing adapter two hops away (the agent console's
 *      C_AGENT_TREEDB_LINK) — this view cannot tell, and must not.
+*      A DROP of it (the host's EV_TRANSPORT_STATE, or a failure that
+*      arrives while the transport is out of session) ends the load or
+*      the write it cut, and the model is asked again when the session
+*      is back. Every request carries its round (`round` for a load,
+*      `write` for a write) in `__md_command__`, so an answer of what
+*      was cut is ignored instead of counted in the next one.
 *
 *          Copyright (c) 2026, ArtGins.
 *          All Rights Reserved.
@@ -72133,6 +72139,7 @@ var PRIVATE_DATA$1 = {
 	model: null,
 	pending: 0,
 	load_error: "",
+	load_round: 0,
 	treedb_id: "",
 	topic_name: "",
 	diagram: false,
@@ -72146,7 +72153,9 @@ var PRIVATE_DATA$1 = {
 	save_queue: null,
 	save_return: "",
 	save_wrote: false,
+	write_tag: 0,
 	connected: false,
+	reload_on_open: false,
 	pending_seg: null,
 	import_plan: null,
 	import_pane: null,
@@ -72317,6 +72326,7 @@ function request_model(gobj) {
 	};
 	priv.load_error = "";
 	priv.pending = 0;
+	priv.load_round++;
 	(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_LOADING");
 	show_notice(gobj, "loading the schemas");
 	for (let topic_name of [
@@ -72326,7 +72336,7 @@ function request_model(gobj) {
 	]) if (remote_command(gobj, "nodes", {
 		topic_name,
 		options: { list_dict: true }
-	}) === 0) priv.pending++;
+	}, { round: priv.load_round }) === 0) priv.pending++;
 	if (priv.pending === 0) {
 		priv.load_error = (0, i18next.t)("cannot reach the treedb");
 		(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
@@ -72344,7 +72354,7 @@ function request_model(gobj) {
 *  answer says which topic it is about, since the command is
 *  `nodes` for all three.
 ***************************************************************/
-function remote_command(gobj, command, kw) {
+function remote_command(gobj, command, kw, tag) {
 	let remote = (0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "gobj_remote_yuno");
 	let treedb_name = (0, _yuneta_gobj_js.gobj_read_str_attr)(gobj, "treedb_name");
 	if (!remote) {
@@ -72355,11 +72365,11 @@ function remote_command(gobj, command, kw) {
 		service: treedb_name,
 		treedb_name
 	}, kw || {});
-	full_kw.__md_command__ = {
+	full_kw.__md_command__ = Object.assign({
 		purpose: PURPOSE,
 		topic_name: kw && kw.topic_name || "",
 		record_id: kw && kw.record_id || ""
-	};
+	}, tag || {});
 	delete full_kw.record_id;
 	let ret = (0, _yuneta_gobj_js.gobj_command)(remote, command, full_kw, gobj);
 	if (ret) {
@@ -74590,12 +74600,61 @@ function run_next_write(gobj) {
 	let write = priv.save_queue[0];
 	let command = write_command(write.op);
 	let options = write_options(write.op);
+	priv.write_tag++;
 	if (remote_command(gobj, command, {
 		topic_name: write.topic_name,
 		record: write.record,
 		options,
 		record_id: write.record.id || ""
-	}) < 0) return end_writes(gobj, (0, i18next.t)("cannot reach the treedb"));
+	}, { write: priv.write_tag }) < 0) return end_writes(gobj, (0, i18next.t)("cannot reach the treedb"));
+	return 0;
+}
+/***************************************************************
+*  Does the transport say it is in session? The state the library
+*  reads off every transport (C_IEVENT_CLI and the routing adapters
+*  name it the same).
+***************************************************************/
+function transport_in_session(gobj) {
+	let remote = (0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "gobj_remote_yuno");
+	return !!remote && (0, _yuneta_gobj_js.gobj_current_state)(remote) === "ST_SESSION";
+}
+/***************************************************************
+*  Is this answer of the load in flight, or of the write in
+*  flight? Each request carries its round in `__md_command__`, and
+*  one the drop abandoned (or a deadline settled) can still come
+*  back: counted, it ended the next load with the old data or
+*  moved the next write's queue.
+***************************************************************/
+function is_current_load(gobj, md) {
+	return (0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_LOADING" && (0, _yuneta_gobj_js.kw_get_int)(gobj, md, "round", 0, 0) === gobj.priv.load_round;
+}
+function is_current_write(gobj, md) {
+	return (0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_SAVING" && (0, _yuneta_gobj_js.kw_get_int)(gobj, md, "write", 0, 0) === gobj.priv.write_tag;
+}
+/***************************************************************
+*  The transport dropped under a load or a write: its answers
+*  will never come. The load goes back to the screen it replaced
+*  (or to "not connected" when there was none), the write ends
+*  with the drop said -- whether it landed is unknown -- and both
+*  mark the model to be asked again when the session is back.
+*  Bumping the round makes an answer of what was cut stale.
+***************************************************************/
+function transport_dropped(gobj) {
+	let priv = gobj.priv;
+	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
+	priv.reload_on_open = true;
+	if (state === "ST_SAVING") {
+		priv.write_tag++;
+		return end_writes(gobj, "the connection dropped during the write");
+	}
+	if (state === "ST_LOADING") {
+		priv.load_round++;
+		priv.pending = 0;
+		priv.load_error = "";
+		if (priv.model) return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+		(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
+		render(gobj);
+	}
 	return 0;
 }
 /***************************************************************
@@ -74750,8 +74809,15 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	let kw_command = (0, _yuneta_gobj_js.kw_get_dict)(gobj, __command__, "kw", {}, 0);
 	let md = (0, _yuneta_gobj_js.is_object)(kw_command.__md_command__) ? kw_command.__md_command__ : kw_command;
 	if ((0, _yuneta_gobj_js.kw_get_str)(gobj, md, "purpose", "", 0) !== PURPOSE) return 0;
+	if (result < 0 && !transport_in_session(gobj) && ((0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_LOADING" || (0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_SAVING")) {
+		if (command === "nodes" && is_current_load(gobj, md) || command !== "nodes" && is_current_write(gobj, md)) return transport_dropped(gobj);
+	}
 	if (command === "nodes") {
 		let topic_name = (0, _yuneta_gobj_js.kw_get_str)(gobj, md, "topic_name", "", 0);
+		if (!is_current_load(gobj, md)) {
+			(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: 'nodes' of '${topic_name}' answered for a load that is over: ignored`);
+			return 0;
+		}
 		priv.pending--;
 		if (result < 0) priv.load_error = comment || (0, i18next.t)("cannot load the schemas");
 		else if (priv.records && Array.isArray(priv.records[topic_name])) priv.records[topic_name] = Array.isArray(data) ? data : [];
@@ -74769,6 +74835,10 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	}
 	if (command === "update-node" || command === "delete-node") {
 		let topic_name = (0, _yuneta_gobj_js.kw_get_str)(gobj, md, "topic_name", "", 0);
+		if (!is_current_write(gobj, md)) {
+			(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: '${command}' of '${topic_name}' answered for a write that is over (result ${result}): ignored`);
+			return 0;
+		}
 		if (result < 0) return end_writes(gobj, comment || (0, i18next.t)("the treedb refused the write"));
 		priv.save_wrote = true;
 		if (command === "delete-node") forget_record(gobj, topic_name, (0, _yuneta_gobj_js.kw_get_str)(gobj, md, "record_id", "", 0));
@@ -74828,14 +74898,28 @@ function ac_hide(gobj, event, kw, src) {
 	return 0;
 }
 /***************************************************************
-*  The session came up or went down. The model stays either way
-*  — a schema does not change under you — but a first load may
-*  have had no transport to run on.
+*  The session came up or went down. The model stays -- a schema
+*  does not change under you -- unless the drop cut a load or a
+*  write (transport_dropped()): then it is asked again on the way
+*  back, as it is when a first load had no transport to run on.
+*
+*  Nothing else ends a load or a write the drop cut: their answers
+*  will never come, and waiting in ST_LOADING skipped the reload
+*  itself (M-1 of the independent review of 7.25.4).
 ***************************************************************/
 function ac_transport_state(gobj, event, kw, src) {
 	let priv = gobj.priv;
+	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
 	priv.connected = !!(kw && kw.connected);
-	if (priv.connected && !priv.model && (0, _yuneta_gobj_js.gobj_current_state)(gobj) !== "ST_LOADING") return request_model(gobj);
+	if (!priv.connected) {
+		if (state === "ST_LOADING" || state === "ST_SAVING") return transport_dropped(gobj);
+		render_toolbar(gobj);
+		return 0;
+	}
+	if ((!priv.model || priv.reload_on_open) && state !== "ST_LOADING" && state !== "ST_SAVING") {
+		priv.reload_on_open = false;
+		return request_model(gobj);
+	}
 	render_toolbar(gobj);
 	return 0;
 }

package/dist/gobj-ui.es.js

@@ -72096,6 +72096,12 @@ function write_options(op) {
 *      `update-node` / `delete-node` on the treedb service, and it may
 *      be a routing adapter two hops away (the agent console's
 *      C_AGENT_TREEDB_LINK) — this view cannot tell, and must not.
+*      A DROP of it (the host's EV_TRANSPORT_STATE, or a failure that
+*      arrives while the transport is out of session) ends the load or
+*      the write it cut, and the model is asked again when the session
+*      is back. Every request carries its round (`round` for a load,
+*      `write` for a write) in `__md_command__`, so an answer of what
+*      was cut is ignored instead of counted in the next one.
 *
 *          Copyright (c) 2026, ArtGins.
 *          All Rights Reserved.
@@ -72128,6 +72134,7 @@ var PRIVATE_DATA$1 = {
 	model: null,
 	pending: 0,
 	load_error: "",
+	load_round: 0,
 	treedb_id: "",
 	topic_name: "",
 	diagram: false,
@@ -72141,7 +72148,9 @@ var PRIVATE_DATA$1 = {
 	save_queue: null,
 	save_return: "",
 	save_wrote: false,
+	write_tag: 0,
 	connected: false,
+	reload_on_open: false,
 	pending_seg: null,
 	import_plan: null,
 	import_pane: null,
@@ -72312,6 +72321,7 @@ function request_model(gobj) {
 	};
 	priv.load_error = "";
 	priv.pending = 0;
+	priv.load_round++;
 	gobj_change_state(gobj, "ST_LOADING");
 	show_notice(gobj, "loading the schemas");
 	for (let topic_name of [
@@ -72321,7 +72331,7 @@ function request_model(gobj) {
 	]) if (remote_command(gobj, "nodes", {
 		topic_name,
 		options: { list_dict: true }
-	}) === 0) priv.pending++;
+	}, { round: priv.load_round }) === 0) priv.pending++;
 	if (priv.pending === 0) {
 		priv.load_error = t("cannot reach the treedb");
 		gobj_change_state(gobj, "ST_IDLE");
@@ -72339,7 +72349,7 @@ function request_model(gobj) {
 *  answer says which topic it is about, since the command is
 *  `nodes` for all three.
 ***************************************************************/
-function remote_command(gobj, command, kw) {
+function remote_command(gobj, command, kw, tag) {
 	let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
 	let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
 	if (!remote) {
@@ -72350,11 +72360,11 @@ function remote_command(gobj, command, kw) {
 		service: treedb_name,
 		treedb_name
 	}, kw || {});
-	full_kw.__md_command__ = {
+	full_kw.__md_command__ = Object.assign({
 		purpose: PURPOSE,
 		topic_name: kw && kw.topic_name || "",
 		record_id: kw && kw.record_id || ""
-	};
+	}, tag || {});
 	delete full_kw.record_id;
 	let ret = gobj_command(remote, command, full_kw, gobj);
 	if (ret) {
@@ -74585,12 +74595,61 @@ function run_next_write(gobj) {
 	let write = priv.save_queue[0];
 	let command = write_command(write.op);
 	let options = write_options(write.op);
+	priv.write_tag++;
 	if (remote_command(gobj, command, {
 		topic_name: write.topic_name,
 		record: write.record,
 		options,
 		record_id: write.record.id || ""
-	}) < 0) return end_writes(gobj, t("cannot reach the treedb"));
+	}, { write: priv.write_tag }) < 0) return end_writes(gobj, t("cannot reach the treedb"));
+	return 0;
+}
+/***************************************************************
+*  Does the transport say it is in session? The state the library
+*  reads off every transport (C_IEVENT_CLI and the routing adapters
+*  name it the same).
+***************************************************************/
+function transport_in_session(gobj) {
+	let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
+	return !!remote && gobj_current_state(remote) === "ST_SESSION";
+}
+/***************************************************************
+*  Is this answer of the load in flight, or of the write in
+*  flight? Each request carries its round in `__md_command__`, and
+*  one the drop abandoned (or a deadline settled) can still come
+*  back: counted, it ended the next load with the old data or
+*  moved the next write's queue.
+***************************************************************/
+function is_current_load(gobj, md) {
+	return gobj_current_state(gobj) === "ST_LOADING" && kw_get_int(gobj, md, "round", 0, 0) === gobj.priv.load_round;
+}
+function is_current_write(gobj, md) {
+	return gobj_current_state(gobj) === "ST_SAVING" && kw_get_int(gobj, md, "write", 0, 0) === gobj.priv.write_tag;
+}
+/***************************************************************
+*  The transport dropped under a load or a write: its answers
+*  will never come. The load goes back to the screen it replaced
+*  (or to "not connected" when there was none), the write ends
+*  with the drop said -- whether it landed is unknown -- and both
+*  mark the model to be asked again when the session is back.
+*  Bumping the round makes an answer of what was cut stale.
+***************************************************************/
+function transport_dropped(gobj) {
+	let priv = gobj.priv;
+	let state = gobj_current_state(gobj);
+	priv.reload_on_open = true;
+	if (state === "ST_SAVING") {
+		priv.write_tag++;
+		return end_writes(gobj, "the connection dropped during the write");
+	}
+	if (state === "ST_LOADING") {
+		priv.load_round++;
+		priv.pending = 0;
+		priv.load_error = "";
+		if (priv.model) return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+		gobj_change_state(gobj, "ST_IDLE");
+		render(gobj);
+	}
 	return 0;
 }
 /***************************************************************
@@ -74745,8 +74804,15 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	let kw_command = kw_get_dict(gobj, __command__, "kw", {}, 0);
 	let md = is_object(kw_command.__md_command__) ? kw_command.__md_command__ : kw_command;
 	if (kw_get_str(gobj, md, "purpose", "", 0) !== PURPOSE) return 0;
+	if (result < 0 && !transport_in_session(gobj) && (gobj_current_state(gobj) === "ST_LOADING" || gobj_current_state(gobj) === "ST_SAVING")) {
+		if (command === "nodes" && is_current_load(gobj, md) || command !== "nodes" && is_current_write(gobj, md)) return transport_dropped(gobj);
+	}
 	if (command === "nodes") {
 		let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
+		if (!is_current_load(gobj, md)) {
+			log_warning(`${gobj_short_name(gobj)}: 'nodes' of '${topic_name}' answered for a load that is over: ignored`);
+			return 0;
+		}
 		priv.pending--;
 		if (result < 0) priv.load_error = comment || t("cannot load the schemas");
 		else if (priv.records && Array.isArray(priv.records[topic_name])) priv.records[topic_name] = Array.isArray(data) ? data : [];
@@ -74764,6 +74830,10 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	}
 	if (command === "update-node" || command === "delete-node") {
 		let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
+		if (!is_current_write(gobj, md)) {
+			log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' answered for a write that is over (result ${result}): ignored`);
+			return 0;
+		}
 		if (result < 0) return end_writes(gobj, comment || t("the treedb refused the write"));
 		priv.save_wrote = true;
 		if (command === "delete-node") forget_record(gobj, topic_name, kw_get_str(gobj, md, "record_id", "", 0));
@@ -74823,14 +74893,28 @@ function ac_hide(gobj, event, kw, src) {
 	return 0;
 }
 /***************************************************************
-*  The session came up or went down. The model stays either way
-*  — a schema does not change under you — but a first load may
-*  have had no transport to run on.
+*  The session came up or went down. The model stays -- a schema
+*  does not change under you -- unless the drop cut a load or a
+*  write (transport_dropped()): then it is asked again on the way
+*  back, as it is when a first load had no transport to run on.
+*
+*  Nothing else ends a load or a write the drop cut: their answers
+*  will never come, and waiting in ST_LOADING skipped the reload
+*  itself (M-1 of the independent review of 7.25.4).
 ***************************************************************/
 function ac_transport_state(gobj, event, kw, src) {
 	let priv = gobj.priv;
+	let state = gobj_current_state(gobj);
 	priv.connected = !!(kw && kw.connected);
-	if (priv.connected && !priv.model && gobj_current_state(gobj) !== "ST_LOADING") return request_model(gobj);
+	if (!priv.connected) {
+		if (state === "ST_LOADING" || state === "ST_SAVING") return transport_dropped(gobj);
+		render_toolbar(gobj);
+		return 0;
+	}
+	if ((!priv.model || priv.reload_on_open) && state !== "ST_LOADING" && state !== "ST_SAVING") {
+		priv.reload_on_open = false;
+		return request_model(gobj);
+	}
 	render_toolbar(gobj);
 	return 0;
 }

package/package.json

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

package/src/c_yui_schema_editor.js

@@ -70,6 +70,12 @@
  *      `update-node` / `delete-node` on the treedb service, and it may
  *      be a routing adapter two hops away (the agent console's
  *      C_AGENT_TREEDB_LINK) — this view cannot tell, and must not.
+ *      A DROP of it (the host's EV_TRANSPORT_STATE, or a failure that
+ *      arrives while the transport is out of session) ends the load or
+ *      the write it cut, and the model is asked again when the session
+ *      is back. Every request carries its round (`round` for a load,
+ *      `write` for a write) in `__md_command__`, so an answer of what
+ *      was cut is ignored instead of counted in the next one.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
@@ -108,6 +114,7 @@ import {
     clean_name,
     msg_iev_get_stack,
     kw_get_str,
+    kw_get_int,
     kw_get_dict,
     is_object,
     is_array,
@@ -198,6 +205,7 @@ let PRIVATE_DATA = {
     model:          null,   /*  build_schema_model() of the above  */
     pending:        0,      /*  `nodes` requests still in flight  */
     load_error:     "",
+    load_round:     0,      /*  which load an answer belongs to: echoed as `round`  */
 
     /*  Where the operator is. The url carries it; these mirror it.  */
     treedb_id:      "",
@@ -220,7 +228,9 @@ let PRIVATE_DATA = {
     save_queue:     null,
     save_return:    "",
     save_wrote:     false,
+    write_tag:      0,      /*  which write an answer belongs to: echoed as `write`  */
     connected:      false,
+    reload_on_open: false,  /*  a drop cut a load or a write: ask the model again  */
 
     /*  A position that arrived while a write was in flight  */
     pending_seg:    null,
@@ -458,6 +468,7 @@ function request_model(gobj)
     priv.records = {treedbs: [], topics: [], cols: []};
     priv.load_error = "";
     priv.pending = 0;
+    priv.load_round++;
     gobj_change_state(gobj, "ST_LOADING");
     show_notice(gobj, "loading the schemas");
 
@@ -465,7 +476,7 @@ function request_model(gobj)
         if(remote_command(gobj, "nodes", {
             topic_name: topic_name,
             options:    {list_dict: true}
-        }) === 0) {
+        }, {round: priv.load_round}) === 0) {
             priv.pending++;
         }
     }
@@ -487,7 +498,7 @@ function request_model(gobj)
  *  answer says which topic it is about, since the command is
  *  `nodes` for all three.
  ***************************************************************/
-function remote_command(gobj, command, kw)
+function remote_command(gobj, command, kw, tag)
 {
     let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
     let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
@@ -512,11 +523,11 @@ function remote_command(gobj, command, kw)
      *  whichever one is under this view — and `record_id` is here and
      *  NOT at the top level because a delete answers with nothing, and a
      *  parameter the treedb does not know has no business travelling.  */
-    full_kw.__md_command__ = {
+    full_kw.__md_command__ = Object.assign({
         purpose:    PURPOSE,
         topic_name: (kw && kw.topic_name) || "",
         record_id:  (kw && kw.record_id) || ""
-    };
+    }, tag || {});
     delete full_kw.record_id;
 
     let ret = gobj_command(remote, command, full_kw, gobj);
@@ -2362,17 +2373,80 @@ function run_next_write(gobj)
     let command = write_command(write.op);
     let options = write_options(write.op);
 
+    priv.write_tag++;
     if(remote_command(gobj, command, {
         topic_name: write.topic_name,
         record:     write.record,
         options:    options,
         record_id:  write.record.id || ""
-    }) < 0) {
+    }, {write: priv.write_tag}) < 0) {
         return end_writes(gobj, t("cannot reach the treedb"));
     }
     return 0;
 }
 
+/***************************************************************
+ *  Does the transport say it is in session? The state the library
+ *  reads off every transport (C_IEVENT_CLI and the routing adapters
+ *  name it the same).
+ ***************************************************************/
+function transport_in_session(gobj)
+{
+    let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
+
+    return !!remote && gobj_current_state(remote) === "ST_SESSION";
+}
+
+/***************************************************************
+ *  Is this answer of the load in flight, or of the write in
+ *  flight? Each request carries its round in `__md_command__`, and
+ *  one the drop abandoned (or a deadline settled) can still come
+ *  back: counted, it ended the next load with the old data or
+ *  moved the next write's queue.
+ ***************************************************************/
+function is_current_load(gobj, md)
+{
+    return gobj_current_state(gobj) === "ST_LOADING" &&
+        kw_get_int(gobj, md, "round", 0, 0) === gobj.priv.load_round;
+}
+
+function is_current_write(gobj, md)
+{
+    return gobj_current_state(gobj) === "ST_SAVING" &&
+        kw_get_int(gobj, md, "write", 0, 0) === gobj.priv.write_tag;
+}
+
+/***************************************************************
+ *  The transport dropped under a load or a write: its answers
+ *  will never come. The load goes back to the screen it replaced
+ *  (or to "not connected" when there was none), the write ends
+ *  with the drop said -- whether it landed is unknown -- and both
+ *  mark the model to be asked again when the session is back.
+ *  Bumping the round makes an answer of what was cut stale.
+ ***************************************************************/
+function transport_dropped(gobj)
+{
+    let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
+
+    priv.reload_on_open = true;
+    if(state === "ST_SAVING") {
+        priv.write_tag++;
+        return end_writes(gobj, "the connection dropped during the write");
+    }
+    if(state === "ST_LOADING") {
+        priv.load_round++;
+        priv.pending = 0;
+        priv.load_error = "";
+        if(priv.model) {
+            return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+        }
+        gobj_change_state(gobj, "ST_IDLE");
+        render(gobj);
+    }
+    return 0;
+}
+
 /***************************************************************
  *  The queue is done, or gave up. Either way the model is what
  *  the answers made it, so the screen is redrawn from it and the
@@ -2627,8 +2701,28 @@ function ac_mt_command_answer(gobj, event, kw, src)
         return 0;       /*  another panel's answer on a shared transport  */
     }
 
+    /*  A failure while the transport is not in session is the DROP, not a
+     *  refusal: a routing adapter settles what it had in flight when its
+     *  session closes, and that can arrive before the host's
+     *  EV_TRANSPORT_STATE. Read as a refusal, the write it ended looked
+     *  refused, and the reconnect did not reload a model it may have
+     *  changed.  */
+    if(result < 0 && !transport_in_session(gobj) &&
+            (gobj_current_state(gobj) === "ST_LOADING" ||
+             gobj_current_state(gobj) === "ST_SAVING")) {
+        if((command === "nodes" && is_current_load(gobj, md)) ||
+                (command !== "nodes" && is_current_write(gobj, md))) {
+            return transport_dropped(gobj);
+        }
+    }
+
     if(command === "nodes") {
         let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
+        if(!is_current_load(gobj, md)) {
+            log_warning(`${gobj_short_name(gobj)}: 'nodes' of '${topic_name}' answered ` +
+                `for a load that is over: ignored`);
+            return 0;
+        }
         priv.pending--;
         if(result < 0) {
             priv.load_error = comment || t("cannot load the schemas");
@@ -2662,6 +2756,11 @@ function ac_mt_command_answer(gobj, event, kw, src)
 
     if(command === "update-node" || command === "delete-node") {
         let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
+        if(!is_current_write(gobj, md)) {
+            log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' answered ` +
+                `for a write that is over (result ${result}): ignored`);
+            return 0;
+        }
         if(result < 0) {
             return end_writes(gobj, comment || t("the treedb refused the write"));
         }
@@ -2743,16 +2842,31 @@ function ac_hide(gobj, event, kw, src)
 }
 
 /***************************************************************
- *  The session came up or went down. The model stays either way
- *  — a schema does not change under you — but a first load may
- *  have had no transport to run on.
+ *  The session came up or went down. The model stays -- a schema
+ *  does not change under you -- unless the drop cut a load or a
+ *  write (transport_dropped()): then it is asked again on the way
+ *  back, as it is when a first load had no transport to run on.
+ *
+ *  Nothing else ends a load or a write the drop cut: their answers
+ *  will never come, and waiting in ST_LOADING skipped the reload
+ *  itself (M-1 of the independent review of 7.25.4).
  ***************************************************************/
 function ac_transport_state(gobj, event, kw, src)
 {
     let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
 
     priv.connected = !!(kw && kw.connected);
-    if(priv.connected && !priv.model && gobj_current_state(gobj) !== "ST_LOADING") {
+    if(!priv.connected) {
+        if(state === "ST_LOADING" || state === "ST_SAVING") {
+            return transport_dropped(gobj);
+        }
+        render_toolbar(gobj);
+        return 0;
+    }
+    if((!priv.model || priv.reload_on_open) &&
+            state !== "ST_LOADING" && state !== "ST_SAVING") {
+        priv.reload_on_open = false;
         return request_model(gobj);
     }
     render_toolbar(gobj);

package/src/schema_editor_transport.wiring.test.js

@@ -0,0 +1,284 @@
+/***********************************************************************
+ *          schema_editor_transport.wiring.test.js
+ *
+ *      C_YUI_SCHEMA_EDITOR when the transport drops (M-1 of the
+ *      independent review of 7.25.4). A drop used to leave the editor
+ *      where it was: in ST_SAVING with its body busy, or in ST_LOADING
+ *      -- and the reconnect skipped the reload BECAUSE the state was
+ *      ST_LOADING. Only a reload of the page got it out.
+ *
+ *      Driven through the FSM on a document double, with a fake
+ *      transport whose state is the one the library reads
+ *      (`ST_SESSION` or not).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach, vi} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+/*  What the editor SAYS is asserted on the call.  */
+const shown = [];
+vi.mock("./shell_modals.js", () => ({
+    yui_shell_show_error: (shell, message) => {
+        shown.push(message);
+        return {close() {}};
+    },
+    yui_shell_show_info: () => ({close() {}}),
+    yui_shell_show_modal: () => ({close() {}}),
+    yui_shell_confirm_danger: () => ({close() {}}),
+}));
+
+const {
+    SDATA_END,
+    gclass_create,
+    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,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_schema_editor} = await import("./c_yui_schema_editor.js");
+
+const logged = [];
+const commands = [];
+
+const RECORDS = {
+    treedbs: [{id: "db", schema_version: 4}],
+    topics: [
+        {id: "db.users", value: "users", order: 1, pkey: "id", topic_version: 2,
+         treedbs: ["treedbs^db^topics"]},
+    ],
+    cols: [
+        {id: "db.users.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.users^cols"]},
+    ],
+};
+
+function remote_command_parser(gobj, command, kw, src)
+{
+    commands.push({command, kw, src});
+    return null;
+}
+
+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)});
+    });
+    gclass_create("C_TEST_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    gclass_create(
+        "C_TEST_EDITOR_HOST",
+        [["EV_POSITION_CHANGED", 0], ["EV_RECORD_WRITTEN", 0], ["EV_SCHEMA_CHECKED", 0]],
+        [["ST_IDLE", [
+            ["EV_POSITION_CHANGED", () => 0, null],
+            ["EV_RECORD_WRITTEN",   () => 0, null],
+            ["EV_SCHEMA_CHECKED",   () => 0, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    /*  The two states the library reads off a transport.  */
+    gclass_create(
+        "C_TEST_REMOTE",
+        [],
+        [["ST_DISCONNECTED", []], ["ST_SESSION", []]],
+        {mt_command_parser: remote_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);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    commands.length = 0;
+    shown.length = 0;
+});
+
+function take(command)
+{
+    const out = commands.filter((c) => c.command === command);
+    for(const c of out) {
+        commands.splice(commands.indexOf(c), 1);
+    }
+    return out;
+}
+
+/*  The answer, the way a transport gives it: the request's frame on top.  */
+function answer(editor, remote, request, result, data, comment)
+{
+    gobj_send_event(editor, "EV_MT_COMMAND_ANSWER", {
+        result: result,
+        comment: comment || "",
+        data: data,
+        __md_iev__: {command_stack: [{command: request.command, kw: request.kw}]}
+    }, remote);
+}
+
+function answer_the_load(editor, remote)
+{
+    const asked = take("nodes");
+    for(const c of asked) {
+        answer(editor, remote, c, 0, RECORDS[c.kw.topic_name]);
+    }
+    return asked.length;
+}
+
+function drop(editor, remote, host)
+{
+    gobj_change_state(remote, "ST_DISCONNECTED");
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+}
+
+function reconnect(editor, remote, host)
+{
+    gobj_change_state(remote, "ST_SESSION");
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
+}
+
+function build(name, loaded)
+{
+    const remote = gobj_create_service(`${name}_remote`, "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", {
+        gobj_remote_yuno: remote,
+        treedb_name: "treedb_system_schema",
+        base_route: "/schemas"
+    }, host);
+    gobj_start(editor);
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
+    if(loaded) {
+        expect(answer_the_load(editor, remote)).toBe(3);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db/users"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+    }
+    return {editor, remote, host};
+}
+
+/*  A write in flight: a new column, saved from its form.  */
+function start_a_write(editor, host)
+{
+    gobj_send_event(editor, "EV_SAVE_COLUMN", {
+        creating: true, topic: "users", values: {value: "name", type: "string"}
+    }, host);
+    expect(gobj_current_state(editor)).toBe("ST_SAVING");
+    const [write] = take("update-node");
+    expect(write).toBeTruthy();
+    return write;
+}
+
+function is_busy(editor)
+{
+    const $c = gobj_read_attr(editor, "$container");
+    return $c.querySelector(".SCHEMA_BODY").classList.contains("SCHEMA_BUSY");
+}
+
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+describe("a drop while LOADING", () => {
+
+    test("the editor leaves ST_LOADING, and the reconnect loads again", () => {
+        const {editor, remote, host} = build("l1", false);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(take("nodes").length).toBe(3);   /*  never answered  */
+
+        drop(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+
+        reconnect(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TREEDBS");
+        expect(errors()).toEqual([]);
+    });
+
+    test("an answer of the load the drop abandoned is not counted in the next one", () => {
+        const {editor, remote, host} = build("l2", false);
+        const old = take("nodes");
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        const fresh = take("nodes");
+        expect(fresh.length).toBe(3);
+
+        /*  The three OLD answers arrive late: were they counted, the new
+         *  round would end here with the old data and 3 answers owed.  */
+        for(const c of old) {
+            answer(editor, remote, c, 0, []);
+        }
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        for(const c of fresh) {
+            answer(editor, remote, c, 0, RECORDS[c.kw.topic_name]);
+        }
+        expect(gobj_current_state(editor)).toBe("ST_TREEDBS");
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a drop while SAVING", () => {
+
+    test("the write ends, said, the body answers again, and the reconnect reloads", () => {
+        const {editor, remote, host} = build("s1", true);
+        start_a_write(editor, host);
+        expect(is_busy(editor)).toBe(true);
+
+        drop(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(is_busy(editor)).toBe(false);
+        expect(shown).toEqual(["the connection dropped during the write"]);
+
+        /*  Whether the write landed is unknown: the model is asked again.  */
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+
+    test("the transport's own failure arriving FIRST is read as the drop it is", () => {
+        /*  A routing adapter settles what it had in flight when its session
+         *  closes, and that answer can reach the editor before the host's
+         *  EV_TRANSPORT_STATE. Read as a refusal, it ended the write and the
+         *  reconnect did not reload a model the write may have changed.  */
+        const {editor, remote, host} = build("s2", true);
+        const write = start_a_write(editor, host);
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        answer(editor, remote, write, -1, null, "the connection dropped");
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(shown).toEqual(["the connection dropped during the write"]);
+
+        gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+        expect(shown.length).toBe(1);   /*  said once  */
+
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the answer of the write the drop ended is not taken for the next one", () => {
+        const {editor, remote, host} = build("s3", true);
+        const write = start_a_write(editor, host);
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+
+        const second = start_a_write(editor, host);
+        /*  The first write's answer, late: it must not end the second.  */
+        answer(editor, remote, write, 0, {id: "db.users.name", value: "name",
+            topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+
+        answer(editor, remote, second, 0, {id: "db.users.name", value: "name", order: 2,
+            type: "string", topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+});