@yuneta/gobj-ui 7.25.6 → 7.25.7

package/README.md

@@ -2161,7 +2161,28 @@ else.
   `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.
+  warning. The drop itself is logged ONCE; the failures a routing adapter
+  settles for the same drop are that one event and are not logged again.
+- **Nothing moves the editor out of `ST_LOADING` or `ST_SAVING` but the end of
+  what is in flight** (7.25.7). An `EV_SHOW` that arrives meanwhile waits, the
+  last one wins, and it is applied when the load lands, fails or is cut, or
+  when the write ends. 7.25.6 let it move a RELOAD out of `ST_LOADING`: every
+  answer of that load was then "for a load that is over", and the next write
+  patched the records the reload had emptied into a model with no treedb.
+  With no model and no load, `EV_SHOW` keeps the position and stays in
+  `ST_IDLE`; the next load goes there.
+
+  ```js
+  gobj_send_event(editor, "EV_REFRESH", {}, host);             // ST_LOADING
+  gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);   // waits
+  // ... the three `nodes` answers land -> ST_TOPICS of `db`
+  ```
+- A write this view gave up on (a drop, a deadline) whose answer still says it
+  was DONE makes the editor read the model again (at once, after the write in
+  flight, or on the reconnect). Through a routing adapter that settled the
+  write on its OWN deadline the late answer does not reach the view -- the
+  adapter echoes a node event instead, which this view does not hear -- and
+  Refresh is what reads the store.
 
   ```js
   // the host forwards its session edges; nothing else is needed

package/dist/gobj-ui.cjs.js

@@ -3025,6 +3025,14 @@ function maybe_apply_translator($node, opts) {
 *      Non-blocking, auto-dismiss after `opts.timeout` ms (default
 *      5000).  `opts.timeout = 0` disables auto-dismiss.
 *      Returns `{ close() }` so callers can dismiss programmatically.
+*
+*      ONE toast per message on screen: a string message of the same
+*      kind as a toast still showing is not stacked under it -- that
+*      toast is kept, its time starts again, and its handle is
+*      returned. One close of a transport settles every request it
+*      cut, each view shows its failure, and the operator got a
+*      column of identical "the connection dropped". A message built
+*      of nodes is never merged: its text is not a key.
 ***************************************************************/
 function show_notification(shell, kind, message, opts) {
 	let $layer = notification_layer(shell);
@@ -3032,6 +3040,13 @@ function show_notification(shell, kind, message, opts) {
 		(0, _yuneta_gobj_js.log_warning)("yui_shell_show_*: shell has no notification layer");
 		return { close: () => {} };
 	}
+	let key = typeof message === "string" ? `${kind}\u0000${message}` : null;
+	if (key !== null) {
+		for (let $shown of Array.from($layer.children)) if ($shown.__toast_key__ === key && $shown.__toast__) {
+			$shown.__toast__.restart();
+			return $shown.__toast__.handle;
+		}
+	}
 	let p_attrs = typeof message === "string" ? { i18n: message } : {};
 	let $note = (0, _yuneta_gobj_js.createElement2)([
 		"div",
@@ -3068,8 +3083,21 @@ function show_notification(shell, kind, message, opts) {
 	let $del = $note.querySelector(".delete");
 	if ($del) $del.addEventListener("click", close);
 	let timeout = opts && opts.timeout != null ? opts.timeout : 5e3;
-	if (timeout > 0) timeout_id = setTimeout(close, timeout);
-	return { close };
+	let restart = function() {
+		if (timeout_id) {
+			clearTimeout(timeout_id);
+			timeout_id = null;
+		}
+		if (timeout > 0) timeout_id = setTimeout(close, timeout);
+	};
+	restart();
+	let handle = { close };
+	$note.__toast_key__ = key;
+	$note.__toast__ = {
+		handle,
+		restart
+	};
+	return handle;
 }
 function yui_shell_show_info(shell, message, opts) {
 	return show_notification(shell, "info", message, opts);
@@ -72156,6 +72184,9 @@ var PRIVATE_DATA$1 = {
 	write_tag: 0,
 	connected: false,
 	reload_on_open: false,
+	dropped_round: 0,
+	dropped_write: 0,
+	reload_after_write: false,
 	pending_seg: null,
 	import_plan: null,
 	import_pane: null,
@@ -74624,6 +74655,15 @@ function transport_in_session(gobj) {
 *  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.
+*
+*  The state is part of the question, and that is only true
+*  because NOTHING moves the editor out of ST_LOADING or ST_SAVING
+*  but the end of what is in flight: a position the host sends
+*  meanwhile waits in `pending_seg` (ac_show()). 7.25.6 let EV_SHOW
+*  move a RELOAD out of ST_LOADING, and every answer of it was then
+*  "for a load that is over": the records it had emptied stayed
+*  empty, and the next write patched them into a model with no
+*  treedb at all.
 ***************************************************************/
 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;
@@ -74644,17 +74684,39 @@ function transport_dropped(gobj) {
 	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
 	priv.reload_on_open = true;
 	if (state === "ST_SAVING") {
+		(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: the transport dropped during a write: the model is read again on the reconnect`);
+		priv.dropped_write = priv.write_tag;
 		priv.write_tag++;
 		return end_writes(gobj, "the connection dropped during the write");
 	}
 	if (state === "ST_LOADING") {
+		(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: the transport dropped during the load: the model is read again on the reconnect`);
+		priv.dropped_round = priv.load_round;
 		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 end_load(gobj);
+	}
+	return 0;
+}
+/***************************************************************
+*  A load is over -- landed, failed or cut -- and the editor goes
+*  where the operator is: the position the host sent while it was
+*  in flight (ac_show() kept it), or the one it had. Without a
+*  model there is no screen to go to: the position is kept for the
+*  next load, and the editor says why it is empty.
+***************************************************************/
+function end_load(gobj) {
+	let priv = gobj.priv;
+	let seg = priv.pending_seg;
+	priv.pending_seg = null;
+	if (priv.model) {
+		if (seg !== null) return apply_seg(gobj, seg);
+		return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
 	}
+	if (seg !== null) adopt_seg(gobj, seg);
+	(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
+	render(gobj);
 	return 0;
 }
 /***************************************************************
@@ -74677,7 +74739,7 @@ function end_writes(gobj, error) {
 			apply_seg(gobj, seg);
 			if (priv.save_wrote) (0, _yuneta_gobj_js.gobj_publish_event)(gobj, "EV_RECORD_WRITTEN", { treedb_name: (0, _yuneta_gobj_js.gobj_read_str_attr)(gobj, "treedb_name") });
 			priv.save_wrote = false;
-			return 0;
+			return reload_if_owed(gobj);
 		}
 	}
 	if (error) yui_shell_show_error(yui_shell_of(gobj), error, { t: i18next.t });
@@ -74685,9 +74747,25 @@ function end_writes(gobj, error) {
 	priv.save_wrote = false;
 	render(gobj);
 	publish_check(gobj);
+	reload_if_owed(gobj);
 	return error ? -1 : 0;
 }
 /***************************************************************
+*  A write given up earlier turned out DONE while another one was
+*  in flight (see ac_mt_command_answer()): the model is read again
+*  now that nothing is.
+***************************************************************/
+function reload_if_owed(gobj) {
+	let priv = gobj.priv;
+	if (!priv.reload_after_write) return 0;
+	priv.reload_after_write = false;
+	if (!transport_in_session(gobj)) {
+		priv.reload_on_open = true;
+		return 0;
+	}
+	return request_model(gobj);
+}
+/***************************************************************
 *  The record a column form produces.
 *
 *  Everything the store needs and the operator did not type is
@@ -74755,7 +74833,7 @@ function go(gobj, treedb_id, topic_name, diagram, mirror) {
 	priv.topic_name = topic_name || "";
 	priv.diagram = !!diagram;
 	let state = "ST_TREEDBS";
-	if (!priv.model) state = "ST_LOADING";
+	if (!priv.model) state = "ST_IDLE";
 	else if (priv.model.treedbs.length === 0) state = "ST_EMPTY";
 	else if (priv.treedb_id && priv.diagram) state = "ST_DIAGRAM";
 	else if (priv.treedb_id && priv.topic_name) state = "ST_COLUMNS";
@@ -74782,12 +74860,39 @@ function position_seg(gobj) {
 *  empty screen: a shared link outlives the schema it points at.
 ***************************************************************/
 function apply_seg(gobj, seg) {
+	let pos = seg_position(seg);
+	return go(gobj, pos.treedb_id, pos.topic_name, pos.diagram, false);
+}
+function seg_position(seg) {
 	let parts = String(seg || "").split("/").filter((x) => x.length > 0);
 	let treedb_id = parts[0] || "";
 	let tail = parts[1] || "";
-	if (!treedb_id) return go(gobj, "", "", false, false);
-	if (tail === DIAGRAM_SEG) return go(gobj, treedb_id, "", true, false);
-	return go(gobj, treedb_id, tail, false, false);
+	if (!treedb_id) return {
+		treedb_id: "",
+		topic_name: "",
+		diagram: false
+	};
+	if (tail === DIAGRAM_SEG) return {
+		treedb_id,
+		topic_name: "",
+		diagram: true
+	};
+	return {
+		treedb_id,
+		topic_name: tail,
+		diagram: false
+	};
+}
+/***************************************************************
+*  Where the operator is, taken WITHOUT a screen: there is no model
+*  to draw it on yet, and the load that brings one goes there.
+***************************************************************/
+function adopt_seg(gobj, seg) {
+	let priv = gobj.priv;
+	let pos = seg_position(seg);
+	priv.treedb_id = pos.treedb_id;
+	priv.topic_name = pos.topic_name;
+	priv.diagram = pos.diagram;
 }
 /***************************
 *      Actions
@@ -74815,6 +74920,7 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	if (command === "nodes") {
 		let topic_name = (0, _yuneta_gobj_js.kw_get_str)(gobj, md, "topic_name", "", 0);
 		if (!is_current_load(gobj, md)) {
+			if (result < 0 && (0, _yuneta_gobj_js.kw_get_int)(gobj, md, "round", 0, 0) === priv.dropped_round) return 0;
 			(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;
 		}
@@ -74824,20 +74930,22 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 		if (priv.pending > 0) return 0;
 		if (priv.load_error) {
 			priv.model = null;
-			(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
-			render(gobj);
-			return 0;
+			return end_load(gobj);
 		}
 		priv.order_undo = {};
 		build_model(gobj);
 		start_measuring(gobj);
-		return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+		return end_load(gobj);
 	}
 	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 && (0, _yuneta_gobj_js.kw_get_int)(gobj, md, "write", 0, 0) === priv.dropped_write) return 0;
+			if (result < 0) {
+				(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;
+			}
+			return late_write_done(gobj, command, topic_name);
 		}
 		if (result < 0) return end_writes(gobj, comment || (0, i18next.t)("the treedb refused the write"));
 		priv.save_wrote = true;
@@ -74863,6 +74971,35 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	return 0;
 }
 /***************************************************************
+*  A write this view gave up on (a drop, a deadline) answers that
+*  it was DONE: the store holds a change the model does not show.
+*  The model is read again -- now, or when what is in flight ends,
+*  or on the reconnect. A load in flight needs nothing: it was
+*  asked after the write, on the same transport, and reads it.
+*
+*  Only when the answer reaches this view. A routing adapter that
+*  settled the write on its own deadline (gui_agent's
+*  C_AGENT_TREEDB_LINK) does not deliver its late answer again --
+*  the view was answered once, as failed -- and echoes the node
+*  event instead, which this view does not hear: there, Refresh is
+*  what reads the store.
+***************************************************************/
+function late_write_done(gobj, command, topic_name) {
+	let priv = gobj.priv;
+	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
+	(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: '${command}' of '${topic_name}' was given up, and it was DONE: the model is read again`);
+	if (state === "ST_LOADING") return 0;
+	if (state === "ST_SAVING") {
+		priv.reload_after_write = true;
+		return 0;
+	}
+	if (!transport_in_session(gobj)) {
+		priv.reload_on_open = true;
+		return 0;
+	}
+	return request_model(gobj);
+}
+/***************************************************************
 *  Remember which topic this write belongs to, which is what
 *  "its version still has to move" is asked about.
 ***************************************************************/
@@ -74882,7 +75019,8 @@ function mark_written(gobj, topic_name, record) {
 function ac_show(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	let seg = kw && kw.subpath || "";
-	if ((0, _yuneta_gobj_js.gobj_current_state)(gobj) === "ST_SAVING") {
+	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
+	if (state === "ST_SAVING" || state === "ST_LOADING") {
 		priv.pending_seg = seg;
 		return 0;
 	}

package/dist/gobj-ui.es.js

@@ -3020,6 +3020,14 @@ function maybe_apply_translator($node, opts) {
 *      Non-blocking, auto-dismiss after `opts.timeout` ms (default
 *      5000).  `opts.timeout = 0` disables auto-dismiss.
 *      Returns `{ close() }` so callers can dismiss programmatically.
+*
+*      ONE toast per message on screen: a string message of the same
+*      kind as a toast still showing is not stacked under it -- that
+*      toast is kept, its time starts again, and its handle is
+*      returned. One close of a transport settles every request it
+*      cut, each view shows its failure, and the operator got a
+*      column of identical "the connection dropped". A message built
+*      of nodes is never merged: its text is not a key.
 ***************************************************************/
 function show_notification(shell, kind, message, opts) {
 	let $layer = notification_layer(shell);
@@ -3027,6 +3035,13 @@ function show_notification(shell, kind, message, opts) {
 		log_warning("yui_shell_show_*: shell has no notification layer");
 		return { close: () => {} };
 	}
+	let key = typeof message === "string" ? `${kind}\u0000${message}` : null;
+	if (key !== null) {
+		for (let $shown of Array.from($layer.children)) if ($shown.__toast_key__ === key && $shown.__toast__) {
+			$shown.__toast__.restart();
+			return $shown.__toast__.handle;
+		}
+	}
 	let p_attrs = typeof message === "string" ? { i18n: message } : {};
 	let $note = createElement2([
 		"div",
@@ -3063,8 +3078,21 @@ function show_notification(shell, kind, message, opts) {
 	let $del = $note.querySelector(".delete");
 	if ($del) $del.addEventListener("click", close);
 	let timeout = opts && opts.timeout != null ? opts.timeout : 5e3;
-	if (timeout > 0) timeout_id = setTimeout(close, timeout);
-	return { close };
+	let restart = function() {
+		if (timeout_id) {
+			clearTimeout(timeout_id);
+			timeout_id = null;
+		}
+		if (timeout > 0) timeout_id = setTimeout(close, timeout);
+	};
+	restart();
+	let handle = { close };
+	$note.__toast_key__ = key;
+	$note.__toast__ = {
+		handle,
+		restart
+	};
+	return handle;
 }
 function yui_shell_show_info(shell, message, opts) {
 	return show_notification(shell, "info", message, opts);
@@ -72151,6 +72179,9 @@ var PRIVATE_DATA$1 = {
 	write_tag: 0,
 	connected: false,
 	reload_on_open: false,
+	dropped_round: 0,
+	dropped_write: 0,
+	reload_after_write: false,
 	pending_seg: null,
 	import_plan: null,
 	import_pane: null,
@@ -74619,6 +74650,15 @@ function transport_in_session(gobj) {
 *  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.
+*
+*  The state is part of the question, and that is only true
+*  because NOTHING moves the editor out of ST_LOADING or ST_SAVING
+*  but the end of what is in flight: a position the host sends
+*  meanwhile waits in `pending_seg` (ac_show()). 7.25.6 let EV_SHOW
+*  move a RELOAD out of ST_LOADING, and every answer of it was then
+*  "for a load that is over": the records it had emptied stayed
+*  empty, and the next write patched them into a model with no
+*  treedb at all.
 ***************************************************************/
 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;
@@ -74639,17 +74679,39 @@ function transport_dropped(gobj) {
 	let state = gobj_current_state(gobj);
 	priv.reload_on_open = true;
 	if (state === "ST_SAVING") {
+		log_warning(`${gobj_short_name(gobj)}: the transport dropped during a write: the model is read again on the reconnect`);
+		priv.dropped_write = priv.write_tag;
 		priv.write_tag++;
 		return end_writes(gobj, "the connection dropped during the write");
 	}
 	if (state === "ST_LOADING") {
+		log_warning(`${gobj_short_name(gobj)}: the transport dropped during the load: the model is read again on the reconnect`);
+		priv.dropped_round = priv.load_round;
 		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 end_load(gobj);
+	}
+	return 0;
+}
+/***************************************************************
+*  A load is over -- landed, failed or cut -- and the editor goes
+*  where the operator is: the position the host sent while it was
+*  in flight (ac_show() kept it), or the one it had. Without a
+*  model there is no screen to go to: the position is kept for the
+*  next load, and the editor says why it is empty.
+***************************************************************/
+function end_load(gobj) {
+	let priv = gobj.priv;
+	let seg = priv.pending_seg;
+	priv.pending_seg = null;
+	if (priv.model) {
+		if (seg !== null) return apply_seg(gobj, seg);
+		return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
 	}
+	if (seg !== null) adopt_seg(gobj, seg);
+	gobj_change_state(gobj, "ST_IDLE");
+	render(gobj);
 	return 0;
 }
 /***************************************************************
@@ -74672,7 +74734,7 @@ function end_writes(gobj, error) {
 			apply_seg(gobj, seg);
 			if (priv.save_wrote) gobj_publish_event(gobj, "EV_RECORD_WRITTEN", { treedb_name: gobj_read_str_attr(gobj, "treedb_name") });
 			priv.save_wrote = false;
-			return 0;
+			return reload_if_owed(gobj);
 		}
 	}
 	if (error) yui_shell_show_error(yui_shell_of(gobj), error, { t });
@@ -74680,9 +74742,25 @@ function end_writes(gobj, error) {
 	priv.save_wrote = false;
 	render(gobj);
 	publish_check(gobj);
+	reload_if_owed(gobj);
 	return error ? -1 : 0;
 }
 /***************************************************************
+*  A write given up earlier turned out DONE while another one was
+*  in flight (see ac_mt_command_answer()): the model is read again
+*  now that nothing is.
+***************************************************************/
+function reload_if_owed(gobj) {
+	let priv = gobj.priv;
+	if (!priv.reload_after_write) return 0;
+	priv.reload_after_write = false;
+	if (!transport_in_session(gobj)) {
+		priv.reload_on_open = true;
+		return 0;
+	}
+	return request_model(gobj);
+}
+/***************************************************************
 *  The record a column form produces.
 *
 *  Everything the store needs and the operator did not type is
@@ -74750,7 +74828,7 @@ function go(gobj, treedb_id, topic_name, diagram, mirror) {
 	priv.topic_name = topic_name || "";
 	priv.diagram = !!diagram;
 	let state = "ST_TREEDBS";
-	if (!priv.model) state = "ST_LOADING";
+	if (!priv.model) state = "ST_IDLE";
 	else if (priv.model.treedbs.length === 0) state = "ST_EMPTY";
 	else if (priv.treedb_id && priv.diagram) state = "ST_DIAGRAM";
 	else if (priv.treedb_id && priv.topic_name) state = "ST_COLUMNS";
@@ -74777,12 +74855,39 @@ function position_seg(gobj) {
 *  empty screen: a shared link outlives the schema it points at.
 ***************************************************************/
 function apply_seg(gobj, seg) {
+	let pos = seg_position(seg);
+	return go(gobj, pos.treedb_id, pos.topic_name, pos.diagram, false);
+}
+function seg_position(seg) {
 	let parts = String(seg || "").split("/").filter((x) => x.length > 0);
 	let treedb_id = parts[0] || "";
 	let tail = parts[1] || "";
-	if (!treedb_id) return go(gobj, "", "", false, false);
-	if (tail === DIAGRAM_SEG) return go(gobj, treedb_id, "", true, false);
-	return go(gobj, treedb_id, tail, false, false);
+	if (!treedb_id) return {
+		treedb_id: "",
+		topic_name: "",
+		diagram: false
+	};
+	if (tail === DIAGRAM_SEG) return {
+		treedb_id,
+		topic_name: "",
+		diagram: true
+	};
+	return {
+		treedb_id,
+		topic_name: tail,
+		diagram: false
+	};
+}
+/***************************************************************
+*  Where the operator is, taken WITHOUT a screen: there is no model
+*  to draw it on yet, and the load that brings one goes there.
+***************************************************************/
+function adopt_seg(gobj, seg) {
+	let priv = gobj.priv;
+	let pos = seg_position(seg);
+	priv.treedb_id = pos.treedb_id;
+	priv.topic_name = pos.topic_name;
+	priv.diagram = pos.diagram;
 }
 /***************************
 *      Actions
@@ -74810,6 +74915,7 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	if (command === "nodes") {
 		let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
 		if (!is_current_load(gobj, md)) {
+			if (result < 0 && kw_get_int(gobj, md, "round", 0, 0) === priv.dropped_round) return 0;
 			log_warning(`${gobj_short_name(gobj)}: 'nodes' of '${topic_name}' answered for a load that is over: ignored`);
 			return 0;
 		}
@@ -74819,20 +74925,22 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 		if (priv.pending > 0) return 0;
 		if (priv.load_error) {
 			priv.model = null;
-			gobj_change_state(gobj, "ST_IDLE");
-			render(gobj);
-			return 0;
+			return end_load(gobj);
 		}
 		priv.order_undo = {};
 		build_model(gobj);
 		start_measuring(gobj);
-		return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+		return end_load(gobj);
 	}
 	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 && kw_get_int(gobj, md, "write", 0, 0) === priv.dropped_write) return 0;
+			if (result < 0) {
+				log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' answered for a write that is over (result ${result}): ignored`);
+				return 0;
+			}
+			return late_write_done(gobj, command, topic_name);
 		}
 		if (result < 0) return end_writes(gobj, comment || t("the treedb refused the write"));
 		priv.save_wrote = true;
@@ -74858,6 +74966,35 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 	return 0;
 }
 /***************************************************************
+*  A write this view gave up on (a drop, a deadline) answers that
+*  it was DONE: the store holds a change the model does not show.
+*  The model is read again -- now, or when what is in flight ends,
+*  or on the reconnect. A load in flight needs nothing: it was
+*  asked after the write, on the same transport, and reads it.
+*
+*  Only when the answer reaches this view. A routing adapter that
+*  settled the write on its own deadline (gui_agent's
+*  C_AGENT_TREEDB_LINK) does not deliver its late answer again --
+*  the view was answered once, as failed -- and echoes the node
+*  event instead, which this view does not hear: there, Refresh is
+*  what reads the store.
+***************************************************************/
+function late_write_done(gobj, command, topic_name) {
+	let priv = gobj.priv;
+	let state = gobj_current_state(gobj);
+	log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' was given up, and it was DONE: the model is read again`);
+	if (state === "ST_LOADING") return 0;
+	if (state === "ST_SAVING") {
+		priv.reload_after_write = true;
+		return 0;
+	}
+	if (!transport_in_session(gobj)) {
+		priv.reload_on_open = true;
+		return 0;
+	}
+	return request_model(gobj);
+}
+/***************************************************************
 *  Remember which topic this write belongs to, which is what
 *  "its version still has to move" is asked about.
 ***************************************************************/
@@ -74877,7 +75014,8 @@ function mark_written(gobj, topic_name, record) {
 function ac_show(gobj, event, kw, src) {
 	let priv = gobj.priv;
 	let seg = kw && kw.subpath || "";
-	if (gobj_current_state(gobj) === "ST_SAVING") {
+	let state = gobj_current_state(gobj);
+	if (state === "ST_SAVING" || state === "ST_LOADING") {
 		priv.pending_seg = seg;
 		return 0;
 	}

package/package.json

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

package/src/c_yui_schema_editor.js

@@ -231,8 +231,11 @@ let PRIVATE_DATA = {
     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  */
+    dropped_round:  0,      /*  the load a drop ended: its failures are the drop, said once  */
+    dropped_write:  0,      /*  the same for the write a drop ended  */
+    reload_after_write: false,  /*  a write given up turned out DONE while another was in flight  */
 
-    /*  A position that arrived while a write was in flight  */
+    /*  A position that arrived while a load or a write was in flight  */
     pending_seg:    null,
 
     /*  The import dialog's plan and the two nodes it draws into  */
@@ -2403,6 +2406,15 @@ function transport_in_session(gobj)
  *  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.
+ *
+ *  The state is part of the question, and that is only true
+ *  because NOTHING moves the editor out of ST_LOADING or ST_SAVING
+ *  but the end of what is in flight: a position the host sends
+ *  meanwhile waits in `pending_seg` (ac_show()). 7.25.6 let EV_SHOW
+ *  move a RELOAD out of ST_LOADING, and every answer of it was then
+ *  "for a load that is over": the records it had emptied stayed
+ *  empty, and the next write patched them into a model with no
+ *  treedb at all.
  ***************************************************************/
 function is_current_load(gobj, md)
 {
@@ -2431,19 +2443,51 @@ function transport_dropped(gobj)
 
     priv.reload_on_open = true;
     if(state === "ST_SAVING") {
+        log_warning(`${gobj_short_name(gobj)}: the transport dropped during a write: ` +
+            `the model is read again on the reconnect`);
+        priv.dropped_write = priv.write_tag;
         priv.write_tag++;
         return end_writes(gobj, "the connection dropped during the write");
     }
     if(state === "ST_LOADING") {
+        /*  Said HERE, once: the transport settles every request the drop
+         *  cut, and those failures are this one event (see
+         *  ac_mt_command_answer()).  */
+        log_warning(`${gobj_short_name(gobj)}: the transport dropped during the load: ` +
+            `the model is read again on the reconnect`);
+        priv.dropped_round = priv.load_round;
         priv.load_round++;
         priv.pending = 0;
         priv.load_error = "";
-        if(priv.model) {
-            return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+        return end_load(gobj);
+    }
+    return 0;
+}
+
+/***************************************************************
+ *  A load is over -- landed, failed or cut -- and the editor goes
+ *  where the operator is: the position the host sent while it was
+ *  in flight (ac_show() kept it), or the one it had. Without a
+ *  model there is no screen to go to: the position is kept for the
+ *  next load, and the editor says why it is empty.
+ ***************************************************************/
+function end_load(gobj)
+{
+    let priv = gobj.priv;
+    let seg = priv.pending_seg;
+
+    priv.pending_seg = null;
+    if(priv.model) {
+        if(seg !== null) {
+            return apply_seg(gobj, seg);
         }
-        gobj_change_state(gobj, "ST_IDLE");
-        render(gobj);
+        return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+    }
+    if(seg !== null) {
+        adopt_seg(gobj, seg);
     }
+    gobj_change_state(gobj, "ST_IDLE");
+    render(gobj);
     return 0;
 }
 
@@ -2476,7 +2520,7 @@ function end_writes(gobj, error)
                 });
             }
             priv.save_wrote = false;
-            return 0;
+            return reload_if_owed(gobj);
         }
     }
 
@@ -2491,9 +2535,30 @@ function end_writes(gobj, error)
     priv.save_wrote = false;
     render(gobj);
     publish_check(gobj);
+    reload_if_owed(gobj);
     return error ? -1 : 0;
 }
 
+/***************************************************************
+ *  A write given up earlier turned out DONE while another one was
+ *  in flight (see ac_mt_command_answer()): the model is read again
+ *  now that nothing is.
+ ***************************************************************/
+function reload_if_owed(gobj)
+{
+    let priv = gobj.priv;
+
+    if(!priv.reload_after_write) {
+        return 0;
+    }
+    priv.reload_after_write = false;
+    if(!transport_in_session(gobj)) {
+        priv.reload_on_open = true;
+        return 0;
+    }
+    return request_model(gobj);
+}
+
 /***************************************************************
  *  The record a column form produces.
  *
@@ -2599,9 +2664,13 @@ function go(gobj, treedb_id, topic_name, diagram, mirror)
     priv.topic_name = topic_name || "";
     priv.diagram = !!diagram;
 
+    /*  No model and no load (a load in flight never gets here: ac_show()
+     *  keeps the position for it): nothing to draw, and ST_LOADING would
+     *  claim a load that nobody asked for -- the reconnect skipped the one
+     *  it owed BECAUSE the state said a load was running.  */
     let state = "ST_TREEDBS";
     if(!priv.model) {
-        state = "ST_LOADING";
+        state = "ST_IDLE";
     } else if(priv.model.treedbs.length === 0) {
         state = "ST_EMPTY";
     } else if(priv.treedb_id && priv.diagram) {
@@ -2647,18 +2716,39 @@ function position_seg(gobj)
  *  empty screen: a shared link outlives the schema it points at.
  ***************************************************************/
 function apply_seg(gobj, seg)
+{
+    let pos = seg_position(seg);
+
+    return go(gobj, pos.treedb_id, pos.topic_name, pos.diagram, false);
+}
+
+function seg_position(seg)
 {
     let parts = String(seg || "").split("/").filter(x => x.length > 0);
     let treedb_id = parts[0] || "";
     let tail = parts[1] || "";
 
     if(!treedb_id) {
-        return go(gobj, "", "", false, false);
+        return {treedb_id: "", topic_name: "", diagram: false};
     }
     if(tail === DIAGRAM_SEG) {
-        return go(gobj, treedb_id, "", true, false);
+        return {treedb_id: treedb_id, topic_name: "", diagram: true};
     }
-    return go(gobj, treedb_id, tail, false, false);
+    return {treedb_id: treedb_id, topic_name: tail, diagram: false};
+}
+
+/***************************************************************
+ *  Where the operator is, taken WITHOUT a screen: there is no model
+ *  to draw it on yet, and the load that brings one goes there.
+ ***************************************************************/
+function adopt_seg(gobj, seg)
+{
+    let priv = gobj.priv;
+    let pos = seg_position(seg);
+
+    priv.treedb_id = pos.treedb_id;
+    priv.topic_name = pos.topic_name;
+    priv.diagram = pos.diagram;
 }
 
 
@@ -2719,6 +2809,9 @@ function ac_mt_command_answer(gobj, event, kw, src)
     if(command === "nodes") {
         let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
         if(!is_current_load(gobj, md)) {
+            if(result < 0 && kw_get_int(gobj, md, "round", 0, 0) === priv.dropped_round) {
+                return 0;   /*  the drop that ended this load failed it: said once, in transport_dropped()  */
+            }
             log_warning(`${gobj_short_name(gobj)}: 'nodes' of '${topic_name}' answered ` +
                 `for a load that is over: ignored`);
             return 0;
@@ -2734,9 +2827,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
         }
         if(priv.load_error) {
             priv.model = null;
-            gobj_change_state(gobj, "ST_IDLE");
-            render(gobj);
-            return 0;
+            return end_load(gobj);
         }
         /*  Records straight from the store: what an undo would name is the
          *  order that was ON SCREEN, and this is the stored one arriving.
@@ -2749,17 +2840,24 @@ function ac_mt_command_answer(gobj, event, kw, src)
          *  against. Taken on the write patches instead, it measured every
          *  version against itself.  */
         start_measuring(gobj);
-        /*  Back to where the operator was: the load may be a refresh, or
-         *  the answer to a deep link that arrived before the model.  */
-        return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+        /*  Back to where the operator was, or went while it loaded: the
+         *  load may be a refresh, or the answer to a deep link that
+         *  arrived before the model.  */
+        return end_load(gobj);
     }
 
     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 && kw_get_int(gobj, md, "write", 0, 0) === priv.dropped_write) {
+                return 0;   /*  the drop that ended this write failed it: said once, in transport_dropped()  */
+            }
+            if(result < 0) {
+                log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' answered ` +
+                    `for a write that is over (result ${result}): ignored`);
+                return 0;
+            }
+            return late_write_done(gobj, command, topic_name);
         }
         if(result < 0) {
             return end_writes(gobj, comment || t("the treedb refused the write"));
@@ -2796,6 +2894,41 @@ function ac_mt_command_answer(gobj, event, kw, src)
     return 0;
 }
 
+/***************************************************************
+ *  A write this view gave up on (a drop, a deadline) answers that
+ *  it was DONE: the store holds a change the model does not show.
+ *  The model is read again -- now, or when what is in flight ends,
+ *  or on the reconnect. A load in flight needs nothing: it was
+ *  asked after the write, on the same transport, and reads it.
+ *
+ *  Only when the answer reaches this view. A routing adapter that
+ *  settled the write on its own deadline (gui_agent's
+ *  C_AGENT_TREEDB_LINK) does not deliver its late answer again --
+ *  the view was answered once, as failed -- and echoes the node
+ *  event instead, which this view does not hear: there, Refresh is
+ *  what reads the store.
+ ***************************************************************/
+function late_write_done(gobj, command, topic_name)
+{
+    let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
+
+    log_warning(`${gobj_short_name(gobj)}: '${command}' of '${topic_name}' was given up, ` +
+        `and it was DONE: the model is read again`);
+    if(state === "ST_LOADING") {
+        return 0;
+    }
+    if(state === "ST_SAVING") {
+        priv.reload_after_write = true;
+        return 0;
+    }
+    if(!transport_in_session(gobj)) {
+        priv.reload_on_open = true;
+        return 0;
+    }
+    return request_model(gobj);
+}
+
 /***************************************************************
  *  Remember which topic this write belongs to, which is what
  *  "its version still has to move" is asked about.
@@ -2822,10 +2955,14 @@ function ac_show(gobj, event, kw, src)
 {
     let priv = gobj.priv;
     let seg = (kw && kw.subpath) || "";
+    let state = gobj_current_state(gobj);
 
-    if(gobj_current_state(gobj) === "ST_SAVING") {
+    /*  Nothing but the end of what is in flight moves the editor out of
+     *  these two (see is_current_load()): the position waits, and the
+     *  last one sent wins.  */
+    if(state === "ST_SAVING" || state === "ST_LOADING") {
         priv.pending_seg = seg;
-        return 0;       /*  applied when the write lands (end_writes)  */
+        return 0;       /*  applied when the write lands (end_writes) or the load (end_load)  */
     }
     return apply_seg(gobj, seg);
 }

package/src/schema_editor_transport.wiring.test.js

@@ -56,8 +56,13 @@ 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.  */
 function remote_command_parser(gobj, command, kw, src)
 {
+    if(gobj_current_state(gobj) !== "ST_SESSION") {
+        return `${command}: not in session`;
+    }
     commands.push({command, kw, src});
     return null;
 }
@@ -123,7 +128,10 @@ 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]);
+        /*  A copy, as a transport hands it: the editor patches what it is
+         *  given, and a shared fixture would carry one test's write into
+         *  the next.  */
+        answer(editor, remote, c, 0, JSON.parse(JSON.stringify(RECORDS[c.kw.topic_name])));
     }
     return asked.length;
 }
@@ -183,6 +191,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 drop while LOADING", () => {
 
     test("the editor leaves ST_LOADING, and the reconnect loads again", () => {
@@ -276,9 +289,169 @@ describe("a drop while SAVING", () => {
             topics: ["topics^db.users^cols"]});
         expect(gobj_current_state(editor)).toBe("ST_SAVING");
 
+        /*  ...and it says the first one was DONE, so once the second ends
+         *  the model is read again (late_write_done()).  */
         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_LOADING");
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+});
+
+/*
+ *  The regression of 7.25.6: a navigation DURING a reload. The load was
+ *  matched by its round AND by the state being ST_LOADING, and EV_SHOW
+ *  moved the editor out of ST_LOADING while its three `nodes` were in
+ *  flight. Every answer was then "for a load that is over", the reload
+ *  never landed, and request_model() had already emptied the records: the
+ *  next write patched an empty store and the model lost every treedb.
+ */
+describe("a navigation DURING a reload", () => {
+
+    test("refresh, move, write: the model keeps every treedb", () => {
+        const {editor, remote, host} = build("n1", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db/users"}, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.pending).toBe(0);
+
+        const write = start_a_write(editor, host);
+        answer(editor, remote, write, 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(editor.priv.model.treedbs.length).toBe(1);
+        expect(editor.priv.model.treedbs[0].topics[0].cols.length).toBe(2);
+        expect(warnings()).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the editor stays in ST_LOADING, and lands where the host said last", () => {
+        const {editor, remote, host} = build("n2", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.treedb_id).toBe("db");
+        expect(editor.priv.topic_name).toBe("");
+        expect(warnings()).toEqual([]);
+    });
+
+    test("the reload of a reconnect, with a move in the middle", () => {
+        const {editor, remote, host} = build("n3", true);
+        start_a_write(editor, host);
+        drop(editor, remote, host);             /*  the reconnect will reload  */
+        shown.length = 0;
+        reconnect(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.pending).toBe(0);
+        expect(editor.priv.records.cols.length).toBe(1);
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a drop after the move: the move is applied on the model kept, and the reconnect reloads", () => {
+        const {editor, remote, host} = build("n4", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        take("nodes");                          /*  never answered  */
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+
+        drop(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a position with no model and no load", () => {
+
+    test("does not claim a load, and the session loads it", () => {
+        const remote = gobj_create_service("p1_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        const host = gobj_create("p1_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("p1_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote,
+            treedb_name: "treedb_system_schema",
+            base_route: "/schemas"
+        }, host);
+        gobj_start(editor);                     /*  its load cannot leave  */
+        logged.length = 0;
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db/users"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
         expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
         expect(errors()).toEqual([]);
     });
 });
+
+describe("the drop is settled ONCE", () => {
+
+    test("a load cut by the drop: the transport's three failures are one event", () => {
+        const {editor, remote, host} = build("o1", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const cut = take("nodes");
+        expect(cut.length).toBe(3);
+
+        /*  A routing adapter settles all three when its session closes,
+         *  before (or after) the host's edge.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        for(const c of cut) {
+            answer(editor, remote, c, -1, null, "the connection dropped");
+        }
+        gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(warnings().length).toBe(1);
+        expect(warnings()[0]).toMatch(/dropped during the load/);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the host's edge first: the failures that follow are not said again", () => {
+        const {editor, remote, host} = build("o2", true);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const cut = take("nodes");
+
+        drop(editor, remote, host);
+        for(const c of cut) {
+            answer(editor, remote, c, -1, null, "the connection dropped");
+        }
+        expect(warnings().length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a write answered after it was given up", () => {
+
+    test("it was DONE: the model is read again", () => {
+        const {editor, remote, host} = build("w1", true);
+        const write = start_a_write(editor, host);
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+
+        /*  The treedb says it wrote it, after all.  */
+        answer(editor, remote, write, 0, {id: "db.users.name", value: "name",
+            topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(take("nodes").length).toBe(3);
+        expect(errors()).toEqual([]);
+    });
+});

package/src/shell_modals.js

@@ -111,6 +111,14 @@ function maybe_apply_translator($node, opts)
  *      Non-blocking, auto-dismiss after `opts.timeout` ms (default
  *      5000).  `opts.timeout = 0` disables auto-dismiss.
  *      Returns `{ close() }` so callers can dismiss programmatically.
+ *
+ *      ONE toast per message on screen: a string message of the same
+ *      kind as a toast still showing is not stacked under it -- that
+ *      toast is kept, its time starts again, and its handle is
+ *      returned. One close of a transport settles every request it
+ *      cut, each view shows its failure, and the operator got a
+ *      column of identical "the connection dropped". A message built
+ *      of nodes is never merged: its text is not a key.
  ***************************************************************/
 function show_notification(shell, kind, message, opts)
 {
@@ -120,6 +128,16 @@ function show_notification(shell, kind, message, opts)
         return { close: () => {} };
     }
 
+    let key = (typeof message === "string") ? `${kind}\u0000${message}` : null;
+    if(key !== null) {
+        for(let $shown of Array.from($layer.children)) {
+            if($shown.__toast_key__ === key && $shown.__toast__) {
+                $shown.__toast__.restart();
+                return $shown.__toast__.handle;
+            }
+        }
+    }
+
     let p_attrs = (typeof message === "string")
         ? {i18n: message}
         : {};
@@ -158,11 +176,21 @@ function show_notification(shell, kind, message, opts)
     }
 
     let timeout = (opts && opts.timeout != null) ? opts.timeout : 5000;
-    if(timeout > 0) {
-        timeout_id = setTimeout(close, timeout);
-    }
+    let restart = function() {
+        if(timeout_id) {
+            clearTimeout(timeout_id);
+            timeout_id = null;
+        }
+        if(timeout > 0) {
+            timeout_id = setTimeout(close, timeout);
+        }
+    };
+    restart();
 
-    return { close };
+    let handle = { close };
+    $note.__toast_key__ = key;
+    $note.__toast__ = {handle: handle, restart: restart};
+    return handle;
 }
 
 

package/src/shell_toast_once.test.js

@@ -0,0 +1,64 @@
+/***********************************************************************
+ *          shell_toast_once.test.js
+ *
+ *      A toast that says what one already on screen says is not
+ *      stacked under it: one close of the transport settles every
+ *      request it cut, each view that asked shows its failure, and
+ *      the operator got a column of identical "the connection
+ *      dropped" (low of the independent review of the 2nd round).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeEach} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+const {
+    yui_shell_show_error,
+    yui_shell_show_info,
+} = await import("./shell_modals.js");
+
+let shell = null;
+
+function toasts()
+{
+    return shell.priv.layers.notification.children;
+}
+
+beforeEach(() => {
+    shell = {priv: {layers: {notification: document.createElement("div")}}};
+});
+
+describe("one toast per message on screen", () => {
+
+    test("the same error twice is ONE toast", () => {
+        yui_shell_show_error(shell, "the connection dropped");
+        yui_shell_show_error(shell, "the connection dropped");
+        yui_shell_show_error(shell, "the connection dropped");
+        expect(toasts().length).toBe(1);
+    });
+
+    test("different messages, or kinds, still stack", () => {
+        yui_shell_show_error(shell, "the connection dropped");
+        yui_shell_show_error(shell, "the connection dropped during the write");
+        yui_shell_show_info(shell, "the connection dropped");
+        expect(toasts().length).toBe(3);
+    });
+
+    test("closing the one on screen: the next one is shown", () => {
+        const first = yui_shell_show_error(shell, "the connection dropped");
+        first.close();
+        expect(toasts().length).toBe(0);
+        yui_shell_show_error(shell, "the connection dropped");
+        expect(toasts().length).toBe(1);
+    });
+
+    test("the handle of the repeat closes the toast on screen", () => {
+        yui_shell_show_error(shell, "the connection dropped");
+        const again = yui_shell_show_error(shell, "the connection dropped");
+        again.close();
+        expect(toasts().length).toBe(0);
+    });
+});