@yuneta/gobj-ui 7.25.6 → 7.25.8

package/dist/gobj-ui.cjs.js

@@ -3025,6 +3025,22 @@ 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. 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.
+*
+*      A repeat is still a CALLER of its own: it gets its own handle
+*      and its own time, and the toast stays while any caller holds
+*      it -- until every handle is closed or has timed out. Handed the
+*      first caller's handle and timer, a repeat asking `timeout: 0`
+*      was dismissed on the first one's timer, and closing one
+*      caller's handle closed a toast another was still showing
+*      (third independent review). The operator's ✕ closes it for
+*      everybody.
 ***************************************************************/
 function show_notification(shell, kind, message, opts) {
 	let $layer = notification_layer(shell);
@@ -3032,6 +3048,11 @@ function show_notification(shell, kind, message, opts) {
 		(0, _yuneta_gobj_js.log_warning)("yui_shell_show_*: shell has no notification layer");
 		return { close: () => {} };
 	}
+	let timeout = opts && opts.timeout != null ? opts.timeout : 5e3;
+	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__) return $shown.__toast__.hold(timeout);
+	}
 	let p_attrs = typeof message === "string" ? { i18n: message } : {};
 	let $note = (0, _yuneta_gobj_js.createElement2)([
 		"div",
@@ -3054,22 +3075,38 @@ function show_notification(shell, kind, message, opts) {
 	]);
 	$layer.appendChild($note);
 	maybe_apply_translator($note, opts);
-	let timeout_id = null;
+	let holders = /* @__PURE__ */ new Set();
 	let closed = false;
-	let close = function() {
+	let close_toast = function() {
 		if (closed) return;
 		closed = true;
-		if (timeout_id) {
-			clearTimeout(timeout_id);
-			timeout_id = null;
+		for (let holder of holders) if (holder.timeout_id) {
+			clearTimeout(holder.timeout_id);
+			holder.timeout_id = null;
 		}
+		holders.clear();
 		if ($note.parentNode) $note.parentNode.removeChild($note);
 	};
+	let hold = function(ms) {
+		let holder = { timeout_id: null };
+		let release = function() {
+			if (!holders.has(holder)) return;
+			if (holder.timeout_id) {
+				clearTimeout(holder.timeout_id);
+				holder.timeout_id = null;
+			}
+			holders.delete(holder);
+			if (holders.size === 0) close_toast();
+		};
+		holders.add(holder);
+		if (ms > 0) holder.timeout_id = setTimeout(release, ms);
+		return { close: release };
+	};
 	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 };
+	if ($del) $del.addEventListener("click", close_toast);
+	$note.__toast_key__ = key;
+	$note.__toast__ = { hold };
+	return hold(timeout);
 }
 function yui_shell_show_info(shell, message, opts) {
 	return show_notification(shell, "info", message, opts);
@@ -72140,6 +72177,7 @@ var PRIVATE_DATA$1 = {
 	pending: 0,
 	load_error: "",
 	load_round: 0,
+	load_keeps_written: false,
 	treedb_id: "",
 	topic_name: "",
 	diagram: false,
@@ -72156,6 +72194,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,
@@ -72315,10 +72356,28 @@ function refuse_if_readonly(gobj, event) {
 *  schema set of the yuno is here: everything below — the
 *  drawing, the validation, the export — is computed from these
 *  and asks the backend nothing more.
+*
+*  THE LOADING SCREEN IS DRAWN, not assumed. ST_LOADING declares
+*  none of the actions of a screen, so the screen it replaces goes
+*  and the toolbar stops answering: left up, a click on a card, on
+*  Back or on the drawing answered "Event NOT DEFINED in state
+*  ST_LOADING" and was lost (third independent review). A dialog
+*  left open is answered in ST_LOADING instead (ac_wait_for_the_load).
+*
+*  `keep_written`: a load the host did not ask for -- the reconnect,
+*  a write that turned out done -- keeps what this session wrote.
+*  Only the host's EV_REFRESH (a Save sends it) forgets it.
+*
+*  A load that cannot leave WHOLE did not happen (out of session it
+*  is not even asked): the records the model was built on are put
+*  back (emptied, the next write patched them into a model with no
+*  treedb), the round is spent so a request that did leave is
+*  stale, and the session back asks again.
 ***************************************************************/
-function request_model(gobj) {
+function request_model(gobj, keep_written) {
 	let priv = gobj.priv;
 	if (!(0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "gobj_remote_yuno")) return -1;
+	let previous = priv.records;
 	priv.records = {
 		treedbs: [],
 		topics: [],
@@ -72327,22 +72386,31 @@ function request_model(gobj) {
 	priv.load_error = "";
 	priv.pending = 0;
 	priv.load_round++;
+	priv.load_keeps_written = !!keep_written;
 	(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_LOADING");
-	show_notice(gobj, "loading the schemas");
-	for (let topic_name of [
-		T_TREEDBS,
-		T_TOPICS,
-		T_COLS
-	]) if (remote_command(gobj, "nodes", {
-		topic_name,
-		options: { list_dict: true }
-	}, { round: priv.load_round }) === 0) priv.pending++;
-	if (priv.pending === 0) {
+	set_busy(gobj, false);
+	render(gobj);
+	let left = 0;
+	if (transport_in_session(gobj)) {
+		for (let topic_name of [
+			T_TREEDBS,
+			T_TOPICS,
+			T_COLS
+		]) if (remote_command(gobj, "nodes", {
+			topic_name,
+			options: { list_dict: true }
+		}, { round: priv.load_round }) === 0) left++;
+	}
+	if (left < 3) {
+		priv.records = previous;
+		priv.load_round++;
+		priv.reload_on_open = true;
 		priv.load_error = (0, i18next.t)("cannot reach the treedb");
-		(0, _yuneta_gobj_js.gobj_change_state)(gobj, "ST_IDLE");
-		show_notice(gobj, "cannot reach the treedb");
+		if (priv.model) yui_shell_show_error(yui_shell_of(gobj), "cannot reach the treedb", { t: i18next.t });
+		end_load(gobj);
 		return -1;
 	}
+	priv.pending = left;
 	return 0;
 }
 /***************************************************************
@@ -72405,15 +72473,19 @@ function build_model(gobj) {
 *  From here on, "did this session change it?" has an answer.
 *
 *  Called ONLY when records arrive from the store: that is what a
-*  measurement of "changed since" can be measured against. Both
-*  halves reset together -- a baseline without its `written` is
-*  the same false positive from the other side, since every
-*  version equals a baseline just taken.
+*  measurement of "changed since" can be measured against.
+*
+*  `written` is forgotten only by a load the HOST asked for (its
+*  EV_REFRESH, which a Save sends). Since M36 a write moves no
+*  version, so `written` is the draft chip of what this session
+*  wrote and no longer half of a version measurement: a reload of
+*  the reconnect, or of a write that turned out done, forgot the
+*  chips of writes the host had not been told about.
 ***************************************************************/
 function start_measuring(gobj) {
 	let priv = gobj.priv;
 	priv.baseline = {};
-	priv.written = {};
+	if (!priv.load_keeps_written) priv.written = {};
 	priv.host_ids = {};
 	if (!priv.model) return;
 	for (let treedb of priv.model.treedbs) for (let topic of treedb.topics) priv.baseline[topic.id] = topic.topic_version;
@@ -72595,8 +72667,10 @@ function render_toolbar(gobj) {
 	let state = (0, _yuneta_gobj_js.gobj_current_state)(gobj);
 	let readonly = is_readonly(gobj);
 	let has_model = !!priv.model;
+	let on_a_treedb = state !== "ST_IDLE" && state !== "ST_EMPTY";
+	let in_flight = state === "ST_SAVING" || state === "ST_LOADING";
 	let $left = [];
-	if (priv.treedb_id) $left.push([
+	if (priv.treedb_id && on_a_treedb) $left.push([
 		"button",
 		{
 			class: "SCHEMA_BACK button",
@@ -72669,17 +72743,17 @@ function render_toolbar(gobj) {
 		$trail
 	]);
 	let $right = [];
-	if (priv.treedb_id && has_model) {
+	if (priv.treedb_id && has_model && on_a_treedb) {
 		$right.push(toolbar_button("SCHEMA_DIAGRAM_BTN", "yi-compass-drafting", priv.diagram ? "topics" : "diagram", "EV_TOGGLE_DIAGRAM", false));
 		$right.push(toolbar_button("SCHEMA_VALIDATE_BTN", "yi-square-check", "check", "EV_VALIDATE", false));
 		$right.push(toolbar_button("SCHEMA_EXPORT_BTN", "yi-download", "export", "EV_EXPORT", false));
 		if (!readonly) $right.push(toolbar_button("SCHEMA_IMPORT_BTN", "yi-upload", "import", "EV_IMPORT", false));
 	}
-	if (priv.topic_name && !readonly && !priv.diagram) {
+	if (priv.topic_name && !readonly && !priv.diagram && on_a_treedb) {
 		if (undo_order_writes(gobj, current_topic(gobj)).length > 0) $right.push(toolbar_button("SCHEMA_UNDO_ORDER_BTN", "yi-arrow-rotate-left", "undo the order", "EV_UNDO_ORDER", false));
 		$right.push(toolbar_button("SCHEMA_ADD_COL_BTN", "yi-plus", "new column", "EV_ADD_COLUMN", false));
 	}
-	if (priv.treedb_id && !priv.topic_name && !readonly && !priv.diagram) $right.push(toolbar_button("SCHEMA_ADD_TOPIC_BTN", "yi-plus", "new topic", "EV_ADD_TOPIC", false));
+	if (priv.treedb_id && !priv.topic_name && !readonly && !priv.diagram && on_a_treedb) $right.push(toolbar_button("SCHEMA_ADD_TOPIC_BTN", "yi-plus", "new topic", "EV_ADD_TOPIC", false));
 	$right.push(toolbar_button("SCHEMA_REFRESH_BTN", "yi-arrows-rotate", "refresh", "EV_REFRESH", state === "ST_LOADING"));
 	let $bar = (0, _yuneta_gobj_js.createElement2)([
 		"div",
@@ -72705,7 +72779,7 @@ function render_toolbar(gobj) {
 	]);
 	for (let $button of $bar.querySelectorAll("button")) {
 		$button.__gobj__ = gobj;
-		if (state === "ST_SAVING") $button.disabled = true;
+		if (in_flight) $button.disabled = true;
 	}
 	$toolbar.appendChild($bar);
 	(0, _yuneta_gobj_js.refresh_language)($toolbar, i18next.t);
@@ -72723,16 +72797,19 @@ function render(gobj) {
 	render_toolbar(gobj);
 	if (state === "ST_LOADING") {
 		show_notice(gobj, "loading the schemas");
+		destroy_diagram(gobj);
 		clear($body);
 		return;
 	}
 	if (state === "ST_IDLE") {
 		show_notice(gobj, priv.load_error ? "cannot load the schemas" : "not connected", priv.load_error);
+		destroy_diagram(gobj);
 		clear($body);
 		return;
 	}
 	if (state === "ST_EMPTY") {
 		show_notice(gobj, "this yuno stores no schema");
+		destroy_diagram(gobj);
 		clear($body);
 		return;
 	}
@@ -73421,12 +73498,16 @@ function render_diagram(gobj) {
 	let priv = gobj.priv;
 	let $body = $of(gobj, ".SCHEMA_BODY");
 	let treedb = current_treedb(gobj);
-	if (!$body || !treedb) {
+	if (!$body) return;
+	if (!treedb) {
+		destroy_diagram(gobj);
+		clear($body);
 		show_notice(gobj, "that treedb is not here any more", priv.treedb_id);
 		return;
 	}
 	if (!(0, _yuneta_gobj_js.gclass_find_by_name)("C_YUI_TREEDB_SCHEMA")) {
 		(0, _yuneta_gobj_js.log_error)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: C_YUI_TREEDB_SCHEMA not registered by the app`);
+		clear($body);
 		show_notice(gobj, "the schema drawing is not available");
 		return;
 	}
@@ -74624,6 +74705,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,20 +74734,42 @@ 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;
+}
+/***************************************************************
 *  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
 *  host is told once — the tab above owns the pending flag and
@@ -74665,29 +74777,40 @@ function transport_dropped(gobj) {
 ***************************************************************/
 function end_writes(gobj, error) {
 	let priv = gobj.priv;
+	let seg = priv.pending_seg;
 	priv.save_queue = [];
+	priv.pending_seg = null;
 	(0, _yuneta_gobj_js.gobj_change_state)(gobj, priv.save_return || "ST_TREEDBS");
 	priv.save_return = "";
 	show_notice(gobj, "");
 	set_busy(gobj, false);
-	if (priv.pending_seg !== null) {
-		let seg = priv.pending_seg;
-		priv.pending_seg = null;
-		if (!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;
-		}
-	}
 	if (error) yui_shell_show_error(yui_shell_of(gobj), error, { t: i18next.t });
 	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;
-	render(gobj);
-	publish_check(gobj);
+	if (seg !== null) apply_seg(gobj, seg);
+	else {
+		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, true);
+}
+/***************************************************************
 *  The record a column form produces.
 *
 *  Everything the store needs and the operator did not type is
@@ -74751,11 +74874,12 @@ function topic_record(gobj, treedb, topic, values) {
 ***************************************************************/
 function go(gobj, treedb_id, topic_name, diagram, mirror) {
 	let priv = gobj.priv;
+	priv.pending_seg = null;
 	priv.treedb_id = treedb_id || "";
 	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 +74906,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 +74966,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 +74976,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, data);
 		}
 		if (result < 0) return end_writes(gobj, comment || (0, i18next.t)("the treedb refused the write"));
 		priv.save_wrote = true;
@@ -74847,8 +75001,15 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 			if (record) patch_record(gobj, topic_name, record);
 			else {
 				(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: '${command}' answered no record`);
+				if (topic_name === T_TOPICS || topic_name === T_COLS) {
+					let write = priv.save_queue[0];
+					mark_written(gobj, topic_name, write ? write.record : null);
+				}
 				priv.save_queue = [];
-				request_model(gobj);
+				priv.save_return = "";
+				priv.save_wrote = false;
+				(0, _yuneta_gobj_js.gobj_publish_event)(gobj, "EV_RECORD_WRITTEN", { treedb_name: (0, _yuneta_gobj_js.gobj_read_str_attr)(gobj, "treedb_name") });
+				request_model(gobj, true);
 				return 0;
 			}
 		}
@@ -74863,6 +75024,62 @@ 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.
+*
+*  It is a WRITE like any other for the host (EV_RECORD_WRITTEN):
+*  the host was told nothing when it was given up, and it owns the
+*  Save that publishes it. The reload keeps what this session wrote
+*  (request_model()), and the record it answered marks its topic.
+***************************************************************/
+function late_write_done(gobj, command, topic_name, data) {
+	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`);
+	mark_written_record(gobj, topic_name, (0, _yuneta_gobj_js.is_object)(data) ? data : Array.isArray(data) && (0, _yuneta_gobj_js.is_object)(data[0]) ? data[0] : null);
+	(0, _yuneta_gobj_js.gobj_publish_event)(gobj, "EV_RECORD_WRITTEN", { treedb_name: (0, _yuneta_gobj_js.gobj_read_str_attr)(gobj, "treedb_name") });
+	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, true);
+}
+/***************************************************************
+*  The topic a record written belongs to, read off the RECORD and
+*  not off the screen: a write answered late may be about a topic
+*  the operator has left. A column names its topic in its fkey
+*  (`topics^<topic id>^cols`); a topic is its own id.
+***************************************************************/
+function mark_written_record(gobj, topic_name, record) {
+	let priv = gobj.priv;
+	if (!record) return;
+	if (topic_name === T_TOPICS && typeof record.id === "string" && record.id) {
+		priv.written[record.id] = true;
+		return;
+	}
+	if (topic_name !== T_COLS) return;
+	let refs = Array.isArray(record.topics) ? record.topics : typeof record.topics === "string" ? [record.topics] : [];
+	for (let ref of refs) {
+		let parts = String(ref).split("^");
+		if (parts.length >= 2 && parts[1]) priv.written[parts[1]] = true;
+	}
+}
+/***************************************************************
 *  Remember which topic this write belongs to, which is what
 *  "its version still has to move" is asked about.
 ***************************************************************/
@@ -74882,7 +75099,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;
 	}
@@ -74918,7 +75136,7 @@ function ac_transport_state(gobj, event, kw, src) {
 	}
 	if ((!priv.model || priv.reload_on_open) && state !== "ST_LOADING" && state !== "ST_SAVING") {
 		priv.reload_on_open = false;
-		return request_model(gobj);
+		return request_model(gobj, true);
 	}
 	render_toolbar(gobj);
 	return 0;
@@ -74933,7 +75151,25 @@ function ac_language_changed$1(gobj, event, kw, src) {
 	return 0;
 }
 function ac_refresh$1(gobj, event, kw, src) {
-	return request_model(gobj);
+	return request_model(gobj, false);
+}
+/***************************************************************
+*  What a DIALOG sends while the model is being read again: the
+*  Save of a form left open when the reload started, a
+*  confirmation, an import. The loading screen took the rest of
+*  the view away (request_model()); a dialog is the one thing the
+*  operator can still reach, and what it asks is computed against
+*  a model the answers in the air are about to replace.
+*
+*  Refused, and SAID -- and the dialog stays open with what was
+*  typed, so the same Save works once the load is in. Undeclared,
+*  it answered "Event NOT DEFINED in state ST_LOADING" and the
+*  edit was gone with no word (third independent review).
+***************************************************************/
+function ac_wait_for_the_load(gobj, event, kw, src) {
+	(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: ${event} refused, the schemas are loading`);
+	yui_shell_show_error(yui_shell_of(gobj), "the schemas are loading: try again when they are in", { t: i18next.t });
+	return -1;
 }
 /***************************************************************
 *  {drafts: {treedb_name: [topic names]}} -- the host says which
@@ -75481,7 +75717,38 @@ function create_gclass$1(gclass_name) {
 	];
 	const states = [
 		["ST_IDLE", COMMON.slice()],
-		["ST_LOADING", COMMON.slice()],
+		["ST_LOADING", COMMON.concat([
+			[
+				"EV_SAVE_COLUMN",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_SAVE_TOPIC",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_DELETE_ORPHAN",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_PREVIEW_IMPORT",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_APPLY_IMPORT",
+				ac_wait_for_the_load,
+				null
+			],
+			[
+				"EV_CONFIRMED",
+				ac_wait_for_the_load,
+				null
+			]
+		])],
 		["ST_EMPTY", COMMON.slice()],
 		["ST_TREEDBS", COMMON.concat([
 			[