@yuneta/gobj-ui 7.25.11 → 7.25.13

package/README.md

@@ -819,6 +819,26 @@ A write is known by its topic AND its serial (`<topic>^<form_write>`): each
 topic's form counts its serials from 1, and keyed by the serial alone two
 forms saving at once shared one entry.
 
+**A write cut by the drop is not a refusal** (7.25.13). A refused write
+reads its topic again at once, so a cell edited in place goes back to what the
+store has. A write that fails while the transport is NOT in session is the
+drop: a routing adapter (gui_agent's `C_AGENT_TREEDB_LINK`) settles what it
+had in flight when its session closes. The topic cannot be read then — the
+transport refuses the read (*"cannot route 'nodes' -- not in session"*) — so
+the view logs a warning and owes the read. Writes in flight on the
+disconnect edge are owed the same way. The first edge that finds the
+transport in session again pays it: each owed topic whose table is open is
+read once. An `EV_CONNECTION_STATE` "up" that comes before the view's own
+transport is in session leaves the read owed. A form is answered once, also
+when the edge answered it before the failure arrived.
+
+```js
+// Session up: a cell edit goes out as update-node.
+// Session drops; the adapter answers it {result: -1}   -> no read, a warning
+// EV_TRANSPORT_STATE {connected: true}, transport in session
+//                                                      -> `nodes` of that topic, once
+```
+
 **The pkey2 of an update goes back as the record had it** (7.25.5). It names
 the instance the write is for, and a `time` pkey2 that crossed the form's
 `datetime-local` came back without its seconds — another instance, or none.
@@ -2134,6 +2154,11 @@ And what the toolbar offers, each answering a question the storage could not:
   answer. Escaping crosses two layers and the second is not JSON's:
   `helper_quote2doublequote()` rewrites *every* single quote before the parse,
   so a quote inside a value can only survive as `\u0027`.
+  Its C / JSON switch is two named buttons, and a click on one is an event,
+  `EV_EXPORT_VIEW` (`{pane: "c" | "json"}`), answered in every state: the
+  texts were composed when the dialog opened, and the dialog outlives the
+  screen and the loads under it (7.25.12; before, the switch ran in the DOM
+  handler and the `machine` trace did not show it).
 - **import** — the writes that make the stored schema equal a pasted one, shown
   as a **plan** before it runs. Import is the one operation here that can delete
   a column, so what is confirmed is what runs.
@@ -2201,8 +2226,10 @@ else.
   column form sends every field it shows, so its Save after a reload wrote
   the OLD record over the newer one -- 7.25.8 told the operator to "try
   again", which did exactly that. The import plan is forgotten when a load
-  LEAVES (7.25.10: one that could not be sent keeps it), and a Yes that finds
-  it gone is said (`the import plan is gone: preview it again`). A load that
+  LANDS, with the model it was computed on (7.25.12; from 7.25.9 to 7.25.11
+  it went when the load LEFT, so a load that then failed left the dialog up
+  with no plan and Import disabled). A load that fails or never leaves keeps
+  it, and Import stays enabled. A Yes that finds it gone is said (`the import plan is gone: preview it again`). A load that
   failed or never left replaced nothing, and the dialog stays with what was
   typed. A confirmation is a shell modal and outlives a load: its Yes in
   `ST_EMPTY` or `ST_IDLE` is refused with the same words, not *"NOT
@@ -2225,7 +2252,12 @@ else.
   orphans -- is refused with
   `the schemas shown may be out of date: they are read again, try again when they are in`
   and the model is read again (keeping the draft chips); a move goes where it
-  was going and reads there. Not at once and not on a timer: a load refused
+  was going and reads there -- the editor's own moves, and since 7.25.12 the
+  host's too (`EV_SHOW` from a url or the browser's Back). **Any load that
+  lands pays it** (7.25.12): the operator's Refresh, a late write's reload,
+  the reconnect. Before, only the reload the editor asked for itself cleared
+  it, so after a Refresh that landed the next edit was refused and read the
+  store again. Not at once and not on a timer: a load refused
   on a deadline asked again at once is refused the same way, and one asked
   on a clock is polling. A Refresh asked while a load is in flight keeps the
   records of the model shown (7.25.10), not the half the first load got.
@@ -2235,7 +2267,9 @@ else.
   // the load failed in session: model kept, reload owed
   gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);   // refused, said; ST_LOADING
   // ... the load lands: the same click now opens the form
-  ``` A write answered with no record reloads the model and
+  ```
+
+  A write answered with no record reloads the model and
   says what it did not send after it
   (`the treedb did not describe a write back: the writes after it were not sent`).
 - The toolbar offers Diagram, Check, Export, Import, New topic and New column

package/dist/gobj-ui.cjs.js

@@ -23160,11 +23160,17 @@ function track_form_write(in_flight, form_write, topic_name) {
 	};
 }
 /************************************************************
-*  A write was answered, one way or the other
+*  A write was answered, one way or the other. True when it was
+*  still in flight: false when something else answered it already
+*  (the transport closing, abandon_form_writes), so its form must
+*  not be answered twice.
 ************************************************************/
 function settle_form_write(in_flight, form_write, topic_name) {
-	if (!in_flight || !form_write) return;
-	delete in_flight[form_write_key(topic_name, form_write)];
+	if (!in_flight || !form_write) return false;
+	const key = form_write_key(topic_name, form_write);
+	if (!Object.prototype.hasOwnProperty.call(in_flight, key)) return false;
+	delete in_flight[key];
+	return true;
 }
 /************************************************************
 *  Nothing in flight can be answered any more: take them all,
@@ -23751,6 +23757,7 @@ var __gclass__$6 = null;
 ***************************************************************/
 function mt_create$6(gobj) {
 	gobj.priv.form_writes = {};
+	gobj.priv.reload_on_session = {};
 	gobj.priv.conn_shell = null;
 	build_ui$6(gobj);
 	let subscriber = (0, _yuneta_gobj_js.gobj_read_pointer_attr)(gobj, "subscriber");
@@ -25181,9 +25188,15 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 			yui_shell_show_error(yui_shell_of(gobj), comment, { t: i18next.t });
 			if (command === "update-node" || command === "create-node") {
 				let failed_topic = (0, _yuneta_gobj_js.kw_get_str)(gobj, kw_command, "topic_name", "", 0);
-				if (failed_topic) (0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
-				settle_form_write(gobj.priv.form_writes, (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0), failed_topic);
-				answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0), false);
+				let form_write = (0, _yuneta_gobj_js.kw_get_int)(gobj, kw_command, "form_write", 0, 0);
+				if (failed_topic) {
+					if (is_connected$1(gobj)) (0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
+					else {
+						(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: the write of '${failed_topic}' was cut by the drop: the topic is read again when the session is back`);
+						gobj.priv.reload_on_session[failed_topic] = true;
+					}
+				}
+				if (settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), form_write, false);
 			}
 		}
 		return 0;
@@ -25383,11 +25396,31 @@ function ac_transport_state$2(gobj, event, kw, src) {
 	refresh_toolbar_buttons(gobj, connected);
 	if (!connected) abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
 		(0, _yuneta_gobj_js.log_warning)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
+		if (w.topic_name) gobj.priv.reload_on_session[w.topic_name] = true;
 		answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
 	});
+	else reload_owed_topics(gobj);
 	return 0;
 }
 /************************************************************
+*  The session is back: read again the topics a drop left
+*  unknown. Only when the TRANSPORT says so too -- the app's
+*  connection (EV_CONNECTION_STATE) can report "up" before the
+*  transport of this view is in session, and a read asked then is
+*  refused. What is owed stays owed until an edge finds the
+*  transport in session; each topic is read once.
+************************************************************/
+function reload_owed_topics(gobj) {
+	let priv = gobj.priv;
+	if (!is_connected$1(gobj)) return;
+	let topics = Object.keys(priv.reload_on_session);
+	priv.reload_on_session = {};
+	topics.forEach((topic_name) => {
+		if (!get_gobj_formtable(gobj, topic_name)) return;
+		(0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_REFRESH_TOPIC", { topic_name }, gobj);
+	});
+}
+/************************************************************
 *   Parent (routing) inform us that we go hidden
 ************************************************************/
 function ac_hide$4(gobj, event, kw, src) {
@@ -72220,7 +72253,8 @@ var PRIVATE_DATA$1 = {
 	pending_seg: null,
 	import_plan: null,
 	import_pane: null,
-	import_run: null
+	import_run: null,
+	export_view: null
 };
 var __gclass__$1 = null;
 /******************************
@@ -72405,7 +72439,12 @@ function built_on_a_replaced_model(gobj, event, kw) {
 *  export) -- is refused and said: it would be computed on what
 *  the store may no longer hold, and the load that lands closes a
 *  dialog built on the old model anyway (end_load()). A move is
-*  not refused (reload_after_move()): it goes, and reads there.
+*  not refused (reload_after_move()): it goes, and reads there --
+*  the editor's own moves and the host's alike (ac_show(): a url,
+*  the browser's Back).
+*
+*  Paid by ANY load that lands, whoever asked it
+*  (ac_mt_command_answer()): the store has just been read whole.
 *
 *  Not on a timer, and not at once: a load refused on a deadline
 *  asked again at once is refused the same way, and one asked on a
@@ -72447,9 +72486,10 @@ function reload_after_move(gobj) {
 *  left open is answered in ST_LOADING instead (ac_wait_for_the_load),
 *  and a load that LANDS closes it (end_load()): it was built on the
 *  model the load replaced, and its Save sends every field it shows.
-*  An import plan is forgotten here for the same reason: it is a list
-*  of writes computed against the model going away -- once the load
-*  has LEFT (one that could not be sent replaces nothing).
+*  An import plan is forgotten for the same reason, and at the same
+*  moment: when the load LANDS and the model it was computed on goes
+*  (ac_mt_command_answer()). A load that cannot leave, or that fails,
+*  replaces nothing, and the plan stays with the dialog showing it.
 *
 *  `keep_written`: a load nobody ASKED for -- the reconnect, a write
 *  that turned out done, the reload a refused load owed -- keeps what
@@ -72503,7 +72543,6 @@ function request_model(gobj, keep_written) {
 		end_load(gobj);
 		return -1;
 	}
-	forget_import_plan(gobj);
 	priv.pending = left;
 	return 0;
 }
@@ -73663,6 +73702,7 @@ function close_dialog(gobj) {
 	if (!priv.dialog) return;
 	let dialog = priv.dialog;
 	priv.dialog = null;
+	priv.export_view = null;
 	try {
 		dialog.close();
 	} catch (e) {
@@ -73681,6 +73721,7 @@ function open_dialog(gobj, $content, title, logical, title_prefix) {
 		t: i18next.t,
 		on_close: () => {
 			priv.dialog = null;
+			priv.export_view = null;
 		}
 	});
 	(0, _yuneta_gobj_js.refresh_language)($content, i18next.t);
@@ -74409,17 +74450,43 @@ function open_export(gobj, treedb) {
 	let $text = $content.querySelector(".SCHEMA_EXPORT_TEXT");
 	for (let $tab of $content.querySelectorAll(".SCHEMA_EXPORT_TAB")) $tab.addEventListener("click", (evt) => {
 		evt.stopPropagation();
-		for (let $other of $content.querySelectorAll(".SCHEMA_EXPORT_TAB")) {
-			$other.classList.toggle("selected_state", $other === $tab);
-			$other.setAttribute("aria-pressed", $other === $tab ? "true" : "false");
-		}
-		$text.value = $tab.dataset.pane === "c" ? c_text : json_text;
+		(0, _yuneta_gobj_js.gobj_send_event)(gobj, "EV_EXPORT_VIEW", { pane: $tab.dataset.pane }, gobj);
 	});
 	$content.querySelector(".SCHEMA_EXPORT_COPY").addEventListener("click", (evt) => {
 		evt.stopPropagation();
 		copy_text(gobj, $text);
 	});
 	open_dialog(gobj, $content, "export", "SCHEMA_EXPORT_DIALOG", treedb.id);
+	priv.export_view = {
+		$content,
+		texts: {
+			c: c_text,
+			json: json_text
+		}
+	};
+}
+/***************************************************************
+*  Show one of the export's two texts, and say which one is shown
+*  (`selected_state` + aria-pressed). Reached only through
+*  EV_EXPORT_VIEW: a click is an action like any other.
+***************************************************************/
+function show_export_view(gobj, pane) {
+	let view = gobj.priv.export_view;
+	if (!view) {
+		(0, _yuneta_gobj_js.log_error)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: export view '${pane}' asked with no export open`);
+		return -1;
+	}
+	if (!Object.prototype.hasOwnProperty.call(view.texts, pane)) {
+		(0, _yuneta_gobj_js.log_error)(`${(0, _yuneta_gobj_js.gobj_short_name)(gobj)}: the export has no view '${pane}'`);
+		return -1;
+	}
+	for (let $tab of view.$content.querySelectorAll(".SCHEMA_EXPORT_TAB")) {
+		let shown = $tab.dataset.pane === pane;
+		$tab.classList.toggle("selected_state", shown);
+		$tab.setAttribute("aria-pressed", shown ? "true" : "false");
+	}
+	view.$content.querySelector(".SCHEMA_EXPORT_TEXT").value = view.texts[pane];
+	return 0;
 }
 /***************************************************************
 *  Copy through the clipboard when the page is allowed one, and
@@ -74574,9 +74641,9 @@ function open_import(gobj, treedb) {
 }
 /***************************************************************
 *  The plan is a list of writes computed against the model shown:
-*  a load replaces the model, so the plan goes with it and the
-*  dialog, if it stays up (a load that failed keeps the model),
-*  asks for a Preview again.
+*  a load that LANDS replaces the model, so the plan goes with it
+*  (and end_load() closes the dialog built on that model). A load
+*  that fails or never leaves keeps the model, and the plan.
 ***************************************************************/
 function forget_import_plan(gobj) {
 	let priv = gobj.priv;
@@ -75143,6 +75210,8 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 		priv.order_undo = {};
 		priv.records_before = null;
 		priv.model_gen++;
+		priv.reload_on_open = false;
+		forget_import_plan(gobj);
 		build_model(gobj);
 		start_measuring(gobj);
 		return end_load(gobj);
@@ -75273,7 +75342,8 @@ function ac_show(gobj, event, kw, src) {
 		priv.pending_seg = seg;
 		return 0;
 	}
-	return apply_seg(gobj, seg);
+	apply_seg(gobj, seg);
+	return reload_after_move(gobj);
 }
 /***************************************************************
 *  Hidden by the host: drop the overlays. A dialog outlives the
@@ -75712,6 +75782,15 @@ function ac_export(gobj, event, kw, src) {
 	open_export(gobj, treedb);
 	return 0;
 }
+/***************************************************************
+*  The export dialog's C / JSON switch. Its texts were composed
+*  when it opened, so it reads nothing of the model and is
+*  answered in every state: the dialog stays up through a load
+*  that fails and through a move sent by the host.
+***************************************************************/
+function ac_export_view(gobj, event, kw, src) {
+	return show_export_view(gobj, kw && kw.pane);
+}
 function ac_import(gobj, event, kw, src) {
 	let treedb = current_treedb(gobj);
 	if (refuse_if_readonly(gobj, event)) return -1;
@@ -75895,6 +75974,11 @@ function create_gclass$1(gclass_name) {
 			"EV_DRAFTS",
 			ac_drafts,
 			null
+		],
+		[
+			"EV_EXPORT_VIEW",
+			ac_export_view,
+			null
 		]
 	];
 	const TREEDB_WIDE = [
@@ -76102,6 +76186,7 @@ function create_gclass$1(gclass_name) {
 		["EV_UNDO_ORDER", 0],
 		["EV_VALIDATE", 0],
 		["EV_EXPORT", 0],
+		["EV_EXPORT_VIEW", 0],
 		["EV_IMPORT", 0],
 		["EV_PREVIEW_IMPORT", 0],
 		["EV_APPLY_IMPORT", 0],

package/dist/gobj-ui.es.js

@@ -23155,11 +23155,17 @@ function track_form_write(in_flight, form_write, topic_name) {
 	};
 }
 /************************************************************
-*  A write was answered, one way or the other
+*  A write was answered, one way or the other. True when it was
+*  still in flight: false when something else answered it already
+*  (the transport closing, abandon_form_writes), so its form must
+*  not be answered twice.
 ************************************************************/
 function settle_form_write(in_flight, form_write, topic_name) {
-	if (!in_flight || !form_write) return;
-	delete in_flight[form_write_key(topic_name, form_write)];
+	if (!in_flight || !form_write) return false;
+	const key = form_write_key(topic_name, form_write);
+	if (!Object.prototype.hasOwnProperty.call(in_flight, key)) return false;
+	delete in_flight[key];
+	return true;
 }
 /************************************************************
 *  Nothing in flight can be answered any more: take them all,
@@ -23746,6 +23752,7 @@ var __gclass__$6 = null;
 ***************************************************************/
 function mt_create$6(gobj) {
 	gobj.priv.form_writes = {};
+	gobj.priv.reload_on_session = {};
 	gobj.priv.conn_shell = null;
 	build_ui$6(gobj);
 	let subscriber = gobj_read_pointer_attr(gobj, "subscriber");
@@ -25176,9 +25183,15 @@ function ac_mt_command_answer$2(gobj, event, kw, src) {
 			yui_shell_show_error(yui_shell_of(gobj), comment, { t });
 			if (command === "update-node" || command === "create-node") {
 				let failed_topic = kw_get_str(gobj, kw_command, "topic_name", "", 0);
-				if (failed_topic) gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
-				settle_form_write(gobj.priv.form_writes, kw_get_int(gobj, kw_command, "form_write", 0, 0), failed_topic);
-				answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), kw_get_int(gobj, kw_command, "form_write", 0, 0), false);
+				let form_write = kw_get_int(gobj, kw_command, "form_write", 0, 0);
+				if (failed_topic) {
+					if (is_connected$1(gobj)) gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name: failed_topic }, gobj);
+					else {
+						log_warning(`${gobj_short_name(gobj)}: the write of '${failed_topic}' was cut by the drop: the topic is read again when the session is back`);
+						gobj.priv.reload_on_session[failed_topic] = true;
+					}
+				}
+				if (settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) answer_form_write(gobj, get_gobj_formtable(gobj, failed_topic), form_write, false);
 			}
 		}
 		return 0;
@@ -25378,11 +25391,31 @@ function ac_transport_state$2(gobj, event, kw, src) {
 	refresh_toolbar_buttons(gobj, connected);
 	if (!connected) abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
 		log_warning(`${gobj_short_name(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
+		if (w.topic_name) gobj.priv.reload_on_session[w.topic_name] = true;
 		answer_form_write(gobj, get_gobj_formtable(gobj, w.topic_name), w.form_write, false);
 	});
+	else reload_owed_topics(gobj);
 	return 0;
 }
 /************************************************************
+*  The session is back: read again the topics a drop left
+*  unknown. Only when the TRANSPORT says so too -- the app's
+*  connection (EV_CONNECTION_STATE) can report "up" before the
+*  transport of this view is in session, and a read asked then is
+*  refused. What is owed stays owed until an edge finds the
+*  transport in session; each topic is read once.
+************************************************************/
+function reload_owed_topics(gobj) {
+	let priv = gobj.priv;
+	if (!is_connected$1(gobj)) return;
+	let topics = Object.keys(priv.reload_on_session);
+	priv.reload_on_session = {};
+	topics.forEach((topic_name) => {
+		if (!get_gobj_formtable(gobj, topic_name)) return;
+		gobj_send_event(gobj, "EV_REFRESH_TOPIC", { topic_name }, gobj);
+	});
+}
+/************************************************************
 *   Parent (routing) inform us that we go hidden
 ************************************************************/
 function ac_hide$4(gobj, event, kw, src) {
@@ -72215,7 +72248,8 @@ var PRIVATE_DATA$1 = {
 	pending_seg: null,
 	import_plan: null,
 	import_pane: null,
-	import_run: null
+	import_run: null,
+	export_view: null
 };
 var __gclass__$1 = null;
 /******************************
@@ -72400,7 +72434,12 @@ function built_on_a_replaced_model(gobj, event, kw) {
 *  export) -- is refused and said: it would be computed on what
 *  the store may no longer hold, and the load that lands closes a
 *  dialog built on the old model anyway (end_load()). A move is
-*  not refused (reload_after_move()): it goes, and reads there.
+*  not refused (reload_after_move()): it goes, and reads there --
+*  the editor's own moves and the host's alike (ac_show(): a url,
+*  the browser's Back).
+*
+*  Paid by ANY load that lands, whoever asked it
+*  (ac_mt_command_answer()): the store has just been read whole.
 *
 *  Not on a timer, and not at once: a load refused on a deadline
 *  asked again at once is refused the same way, and one asked on a
@@ -72442,9 +72481,10 @@ function reload_after_move(gobj) {
 *  left open is answered in ST_LOADING instead (ac_wait_for_the_load),
 *  and a load that LANDS closes it (end_load()): it was built on the
 *  model the load replaced, and its Save sends every field it shows.
-*  An import plan is forgotten here for the same reason: it is a list
-*  of writes computed against the model going away -- once the load
-*  has LEFT (one that could not be sent replaces nothing).
+*  An import plan is forgotten for the same reason, and at the same
+*  moment: when the load LANDS and the model it was computed on goes
+*  (ac_mt_command_answer()). A load that cannot leave, or that fails,
+*  replaces nothing, and the plan stays with the dialog showing it.
 *
 *  `keep_written`: a load nobody ASKED for -- the reconnect, a write
 *  that turned out done, the reload a refused load owed -- keeps what
@@ -72498,7 +72538,6 @@ function request_model(gobj, keep_written) {
 		end_load(gobj);
 		return -1;
 	}
-	forget_import_plan(gobj);
 	priv.pending = left;
 	return 0;
 }
@@ -73658,6 +73697,7 @@ function close_dialog(gobj) {
 	if (!priv.dialog) return;
 	let dialog = priv.dialog;
 	priv.dialog = null;
+	priv.export_view = null;
 	try {
 		dialog.close();
 	} catch (e) {
@@ -73676,6 +73716,7 @@ function open_dialog(gobj, $content, title, logical, title_prefix) {
 		t,
 		on_close: () => {
 			priv.dialog = null;
+			priv.export_view = null;
 		}
 	});
 	refresh_language($content, t);
@@ -74404,17 +74445,43 @@ function open_export(gobj, treedb) {
 	let $text = $content.querySelector(".SCHEMA_EXPORT_TEXT");
 	for (let $tab of $content.querySelectorAll(".SCHEMA_EXPORT_TAB")) $tab.addEventListener("click", (evt) => {
 		evt.stopPropagation();
-		for (let $other of $content.querySelectorAll(".SCHEMA_EXPORT_TAB")) {
-			$other.classList.toggle("selected_state", $other === $tab);
-			$other.setAttribute("aria-pressed", $other === $tab ? "true" : "false");
-		}
-		$text.value = $tab.dataset.pane === "c" ? c_text : json_text;
+		gobj_send_event(gobj, "EV_EXPORT_VIEW", { pane: $tab.dataset.pane }, gobj);
 	});
 	$content.querySelector(".SCHEMA_EXPORT_COPY").addEventListener("click", (evt) => {
 		evt.stopPropagation();
 		copy_text(gobj, $text);
 	});
 	open_dialog(gobj, $content, "export", "SCHEMA_EXPORT_DIALOG", treedb.id);
+	priv.export_view = {
+		$content,
+		texts: {
+			c: c_text,
+			json: json_text
+		}
+	};
+}
+/***************************************************************
+*  Show one of the export's two texts, and say which one is shown
+*  (`selected_state` + aria-pressed). Reached only through
+*  EV_EXPORT_VIEW: a click is an action like any other.
+***************************************************************/
+function show_export_view(gobj, pane) {
+	let view = gobj.priv.export_view;
+	if (!view) {
+		log_error(`${gobj_short_name(gobj)}: export view '${pane}' asked with no export open`);
+		return -1;
+	}
+	if (!Object.prototype.hasOwnProperty.call(view.texts, pane)) {
+		log_error(`${gobj_short_name(gobj)}: the export has no view '${pane}'`);
+		return -1;
+	}
+	for (let $tab of view.$content.querySelectorAll(".SCHEMA_EXPORT_TAB")) {
+		let shown = $tab.dataset.pane === pane;
+		$tab.classList.toggle("selected_state", shown);
+		$tab.setAttribute("aria-pressed", shown ? "true" : "false");
+	}
+	view.$content.querySelector(".SCHEMA_EXPORT_TEXT").value = view.texts[pane];
+	return 0;
 }
 /***************************************************************
 *  Copy through the clipboard when the page is allowed one, and
@@ -74569,9 +74636,9 @@ function open_import(gobj, treedb) {
 }
 /***************************************************************
 *  The plan is a list of writes computed against the model shown:
-*  a load replaces the model, so the plan goes with it and the
-*  dialog, if it stays up (a load that failed keeps the model),
-*  asks for a Preview again.
+*  a load that LANDS replaces the model, so the plan goes with it
+*  (and end_load() closes the dialog built on that model). A load
+*  that fails or never leaves keeps the model, and the plan.
 ***************************************************************/
 function forget_import_plan(gobj) {
 	let priv = gobj.priv;
@@ -75138,6 +75205,8 @@ function ac_mt_command_answer(gobj, event, kw, src) {
 		priv.order_undo = {};
 		priv.records_before = null;
 		priv.model_gen++;
+		priv.reload_on_open = false;
+		forget_import_plan(gobj);
 		build_model(gobj);
 		start_measuring(gobj);
 		return end_load(gobj);
@@ -75268,7 +75337,8 @@ function ac_show(gobj, event, kw, src) {
 		priv.pending_seg = seg;
 		return 0;
 	}
-	return apply_seg(gobj, seg);
+	apply_seg(gobj, seg);
+	return reload_after_move(gobj);
 }
 /***************************************************************
 *  Hidden by the host: drop the overlays. A dialog outlives the
@@ -75707,6 +75777,15 @@ function ac_export(gobj, event, kw, src) {
 	open_export(gobj, treedb);
 	return 0;
 }
+/***************************************************************
+*  The export dialog's C / JSON switch. Its texts were composed
+*  when it opened, so it reads nothing of the model and is
+*  answered in every state: the dialog stays up through a load
+*  that fails and through a move sent by the host.
+***************************************************************/
+function ac_export_view(gobj, event, kw, src) {
+	return show_export_view(gobj, kw && kw.pane);
+}
 function ac_import(gobj, event, kw, src) {
 	let treedb = current_treedb(gobj);
 	if (refuse_if_readonly(gobj, event)) return -1;
@@ -75890,6 +75969,11 @@ function create_gclass$1(gclass_name) {
 			"EV_DRAFTS",
 			ac_drafts,
 			null
+		],
+		[
+			"EV_EXPORT_VIEW",
+			ac_export_view,
+			null
 		]
 	];
 	const TREEDB_WIDE = [
@@ -76097,6 +76181,7 @@ function create_gclass$1(gclass_name) {
 		["EV_UNDO_ORDER", 0],
 		["EV_VALIDATE", 0],
 		["EV_EXPORT", 0],
+		["EV_EXPORT_VIEW", 0],
 		["EV_IMPORT", 0],
 		["EV_PREVIEW_IMPORT", 0],
 		["EV_APPLY_IMPORT", 0],

package/package.json

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

package/src/c_yui_schema_editor.js

@@ -249,6 +249,9 @@ let PRIVATE_DATA = {
     import_plan:    null,
     import_pane:    null,
     import_run:     null,
+
+    /*  The export dialog while it is up: its content and its two texts  */
+    export_view:    null,
 };
 
 let __gclass__ = null;
@@ -494,7 +497,12 @@ function built_on_a_replaced_model(gobj, event, kw)
  *  export) -- is refused and said: it would be computed on what
  *  the store may no longer hold, and the load that lands closes a
  *  dialog built on the old model anyway (end_load()). A move is
- *  not refused (reload_after_move()): it goes, and reads there.
+ *  not refused (reload_after_move()): it goes, and reads there --
+ *  the editor's own moves and the host's alike (ac_show(): a url,
+ *  the browser's Back).
+ *
+ *  Paid by ANY load that lands, whoever asked it
+ *  (ac_mt_command_answer()): the store has just been read whole.
  *
  *  Not on a timer, and not at once: a load refused on a deadline
  *  asked again at once is refused the same way, and one asked on a
@@ -558,9 +566,10 @@ function reload_after_move(gobj)
  *  left open is answered in ST_LOADING instead (ac_wait_for_the_load),
  *  and a load that LANDS closes it (end_load()): it was built on the
  *  model the load replaced, and its Save sends every field it shows.
- *  An import plan is forgotten here for the same reason: it is a list
- *  of writes computed against the model going away -- once the load
- *  has LEFT (one that could not be sent replaces nothing).
+ *  An import plan is forgotten for the same reason, and at the same
+ *  moment: when the load LANDS and the model it was computed on goes
+ *  (ac_mt_command_answer()). A load that cannot leave, or that fails,
+ *  replaces nothing, and the plan stays with the dialog showing it.
  *
  *  `keep_written`: a load nobody ASKED for -- the reconnect, a write
  *  that turned out done, the reload a refused load owed -- keeps what
@@ -626,9 +635,6 @@ function request_model(gobj, keep_written)
         end_load(gobj);
         return -1;
     }
-    /*  Only a load that LEFT replaces the model the plan was computed
-     *  on; one that could not be sent keeps it, and the plan with it.  */
-    forget_import_plan(gobj);
     priv.pending = left;
     return 0;
 }
@@ -1739,6 +1745,7 @@ function close_dialog(gobj)
     }
     let dialog = priv.dialog;
     priv.dialog = null;
+    priv.export_view = null;
     try {
         dialog.close();
     } catch(e) {
@@ -1760,6 +1767,7 @@ function open_dialog(gobj, $content, title, logical, title_prefix)
         t:             t,
         on_close:      () => {
             priv.dialog = null;
+            priv.export_view = null;
         }
     });
     refresh_language($content, t);
@@ -2279,11 +2287,7 @@ function open_export(gobj, treedb)
     for(let $tab of $content.querySelectorAll(".SCHEMA_EXPORT_TAB")) {
         $tab.addEventListener("click", (evt) => {
             evt.stopPropagation();
-            for(let $other of $content.querySelectorAll(".SCHEMA_EXPORT_TAB")) {
-                $other.classList.toggle("selected_state", $other === $tab);
-                $other.setAttribute("aria-pressed", ($other === $tab)? "true": "false");
-            }
-            $text.value = ($tab.dataset.pane === "c") ? c_text : json_text;
+            gobj_send_event(gobj, "EV_EXPORT_VIEW", {pane: $tab.dataset.pane}, gobj);
         });
     }
     $content.querySelector(".SCHEMA_EXPORT_COPY").addEventListener("click", (evt) => {
@@ -2292,6 +2296,35 @@ function open_export(gobj, treedb)
     });
 
     open_dialog(gobj, $content, "export", "SCHEMA_EXPORT_DIALOG", treedb.id);
+    /*  After open_dialog(): it closes the dialog before, and that forgets
+     *  the view of the one it closes.  */
+    priv.export_view = {$content: $content, texts: {c: c_text, json: json_text}};
+}
+
+/***************************************************************
+ *  Show one of the export's two texts, and say which one is shown
+ *  (`selected_state` + aria-pressed). Reached only through
+ *  EV_EXPORT_VIEW: a click is an action like any other.
+ ***************************************************************/
+function show_export_view(gobj, pane)
+{
+    let view = gobj.priv.export_view;
+
+    if(!view) {
+        log_error(`${gobj_short_name(gobj)}: export view '${pane}' asked with no export open`);
+        return -1;
+    }
+    if(!Object.prototype.hasOwnProperty.call(view.texts, pane)) {
+        log_error(`${gobj_short_name(gobj)}: the export has no view '${pane}'`);
+        return -1;
+    }
+    for(let $tab of view.$content.querySelectorAll(".SCHEMA_EXPORT_TAB")) {
+        let shown = ($tab.dataset.pane === pane);
+        $tab.classList.toggle("selected_state", shown);
+        $tab.setAttribute("aria-pressed", shown ? "true" : "false");
+    }
+    view.$content.querySelector(".SCHEMA_EXPORT_TEXT").value = view.texts[pane];
+    return 0;
 }
 
 /***************************************************************
@@ -2384,9 +2417,9 @@ function open_import(gobj, treedb)
 
 /***************************************************************
  *  The plan is a list of writes computed against the model shown:
- *  a load replaces the model, so the plan goes with it and the
- *  dialog, if it stays up (a load that failed keeps the model),
- *  asks for a Preview again.
+ *  a load that LANDS replaces the model, so the plan goes with it
+ *  (and end_load() closes the dialog built on that model). A load
+ *  that fails or never leaves keeps the model, and the plan.
  ***************************************************************/
 function forget_import_plan(gobj)
 {
@@ -3103,6 +3136,17 @@ function ac_mt_command_answer(gobj, event, kw, src)
         priv.order_undo = {};
         priv.records_before = null;
         priv.model_gen++;
+        /*  The store was read whole: whatever reload was owed is paid,
+         *  whoever asked for this one -- the operator's Refresh, a late
+         *  write, the reconnect. Left owed, the next edit was refused
+         *  and read the store AGAIN (sixth independent review).  */
+        priv.reload_on_open = false;
+        /*  The plan was a list of writes computed on the model this load
+         *  replaces. Forgotten HERE, where the model goes, and not when
+         *  the requests leave: a load that fails replaces nothing, and
+         *  forgetting early left its dialog up with no plan and Import
+         *  disabled (sixth independent review).  */
+        forget_import_plan(gobj);
         build_model(gobj);
         /*  Same reason as order_undo above: this is the LOAD, and the
          *  baseline is what a later "the version did not move" is measured
@@ -3297,7 +3341,12 @@ function ac_show(gobj, event, kw, src)
         priv.pending_seg = seg;
         return 0;       /*  applied when the write lands (end_writes) or the load (end_load)  */
     }
-    return apply_seg(gobj, seg);
+    /*  A move like the editor's own (ac_back() and the rest): it goes,
+     *  and pays the reload a refused load owes there. Without it a url
+     *  or the browser's Back left it owed on a screen that asked for
+     *  nothing (sixth independent review).  */
+    apply_seg(gobj, seg);
+    return reload_after_move(gobj);
 }
 
 /***************************************************************
@@ -3903,6 +3952,17 @@ function ac_export(gobj, event, kw, src)
     return 0;
 }
 
+/***************************************************************
+ *  The export dialog's C / JSON switch. Its texts were composed
+ *  when it opened, so it reads nothing of the model and is
+ *  answered in every state: the dialog stays up through a load
+ *  that fails and through a move sent by the host.
+ ***************************************************************/
+function ac_export_view(gobj, event, kw, src)
+{
+    return show_export_view(gobj, kw && kw.pane);
+}
+
 function ac_import(gobj, event, kw, src)
 {
     let treedb = current_treedb(gobj);
@@ -3994,8 +4054,9 @@ function run_import(gobj)
     let priv = gobj.priv;
     let plan = priv.import_plan;
 
-    /*  Not an ERROR: a load that left forgets the plan (request_model()),
-     *  and the confirmation of it may still be up. The operator's Yes
+    /*  Not an ERROR: a load that lands forgets the plan
+     *  (ac_mt_command_answer()), and the confirmation of it may still be
+     *  up. The operator's Yes
      *  is answered, not lost in the log.  */
     if(!plan) {
         log_warning(`${gobj_short_name(gobj)}: the import plan is gone`);
@@ -4099,7 +4160,9 @@ function create_gclass(gclass_name)
         ["EV_TRANSPORT_STATE",      ac_transport_state,     null],
         ["EV_LANGUAGE_CHANGED",     ac_language_changed,    null],
         ["EV_REFRESH",              ac_refresh,             null],
-        ["EV_DRAFTS",               ac_drafts,              null]
+        ["EV_DRAFTS",               ac_drafts,              null],
+        /*  The export dialog outlives the screen it was opened from.  */
+        ["EV_EXPORT_VIEW",          ac_export_view,         null]
     ];
 
     /*  What a treedb is open for: reading it whole, and writing it
@@ -4215,6 +4278,7 @@ function create_gclass(gclass_name)
         ["EV_UNDO_ORDER",           0],
         ["EV_VALIDATE",             0],
         ["EV_EXPORT",               0],
+        ["EV_EXPORT_VIEW",          0],
         ["EV_IMPORT",               0],
         ["EV_PREVIEW_IMPORT",       0],
         ["EV_APPLY_IMPORT",         0],

package/src/c_yui_treedb_topics.js

@@ -160,6 +160,10 @@ function mt_create(gobj)
      *  and serial (form_writes_in_flight): answered refused when the
      *  transport closes under them.  */
     gobj.priv.form_writes = {};
+    /*  The topics a write cut by a DROP left unknown: the table may show
+     *  what was typed and the store what it had. Read again when the
+     *  session is back (reload_owed_topics), never out of session.  */
+    gobj.priv.reload_on_session = {};
     gobj.priv.conn_shell = null;    /*  the shell whose EV_CONNECTION_STATE we hear  */
 
     build_ui(gobj);
@@ -2092,18 +2096,34 @@ function ac_mt_command_answer(gobj, event, kw, src)
              *  topic back to what the treedb actually has. */
             if(command === "update-node" || command === "create-node") {
                 let failed_topic = kw_get_str(gobj, kw_command, "topic_name", "", 0);
+                let form_write = kw_get_int(gobj, kw_command, "form_write", 0, 0);
                 if(failed_topic) {
-                    gobj_send_event(gobj, "EV_REFRESH_TOPIC",
-                        {topic_name: failed_topic}, gobj);
+                    if(is_connected(gobj)) {
+                        gobj_send_event(gobj, "EV_REFRESH_TOPIC",
+                            {topic_name: failed_topic}, gobj);
+                    } else {
+                        /*  A failure out of session is the DROP, not a
+                         *  refusal: a routing adapter settles what it had
+                         *  in flight when its session closes. The topic
+                         *  cannot be read now -- asked, the transport
+                         *  refuses it ("cannot route 'nodes' -- not in
+                         *  session"). The reconnect reads it.  */
+                        log_warning(`${gobj_short_name(gobj)}: the write of ` +
+                            `'${failed_topic}' was cut by the drop: the topic is ` +
+                            `read again when the session is back`);
+                        gobj.priv.reload_on_session[failed_topic] = true;
+                    }
+                }
+                /*  Answered once: the transport closing may have answered
+                 *  this form already (ac_transport_state).  */
+                if(settle_form_write(gobj.priv.form_writes, form_write, failed_topic)) {
+                    answer_form_write(
+                        gobj,
+                        get_gobj_formtable(gobj, failed_topic),
+                        form_write,
+                        false
+                    );
                 }
-                settle_form_write(gobj.priv.form_writes,
-                    kw_get_int(gobj, kw_command, "form_write", 0, 0), failed_topic);
-                answer_form_write(
-                    gobj,
-                    get_gobj_formtable(gobj, failed_topic),
-                    kw_get_int(gobj, kw_command, "form_write", 0, 0),
-                    false
-                );
             }
         }
         return 0;
@@ -2462,6 +2482,11 @@ function ac_transport_state(gobj, event, kw, src)
     if(!connected) {
         abandon_form_writes(gobj.priv.form_writes).forEach((w) => {
             log_warning(`${gobj_short_name(gobj)}: transport closed, the write ${w.form_write} of '${w.topic_name}' is lost`);
+            /*  Whether it reached the store is unknown: read it again
+             *  when the session is back.  */
+            if(w.topic_name) {
+                gobj.priv.reload_on_session[w.topic_name] = true;
+            }
             answer_form_write(
                 gobj,
                 get_gobj_formtable(gobj, w.topic_name),
@@ -2469,10 +2494,36 @@ function ac_transport_state(gobj, event, kw, src)
                 false
             );
         });
+    } else {
+        reload_owed_topics(gobj);
     }
     return 0;
 }
 
+/************************************************************
+ *  The session is back: read again the topics a drop left
+ *  unknown. Only when the TRANSPORT says so too -- the app's
+ *  connection (EV_CONNECTION_STATE) can report "up" before the
+ *  transport of this view is in session, and a read asked then is
+ *  refused. What is owed stays owed until an edge finds the
+ *  transport in session; each topic is read once.
+ ************************************************************/
+function reload_owed_topics(gobj)
+{
+    let priv = gobj.priv;
+    if(!is_connected(gobj)) {
+        return;
+    }
+    let topics = Object.keys(priv.reload_on_session);
+    priv.reload_on_session = {};
+    topics.forEach((topic_name) => {
+        if(!get_gobj_formtable(gobj, topic_name)) {
+            return;     /*  its table is closed: opening it reads it  */
+        }
+        gobj_send_event(gobj, "EV_REFRESH_TOPIC", {topic_name: topic_name}, gobj);
+    });
+}
+
 /************************************************************
  *   Parent (routing) inform us that we go hidden
  ************************************************************/

package/src/form_writes_in_flight.js

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

package/src/schema_editor_reload.wiring.test.js

@@ -25,6 +25,14 @@
  *      silence, and a toolbar gated on the state instead of on the
  *      treedb being there.
  *
+ *      The sixth independent review (same day) found where the owed
+ *      reload still lingered: a load that LANDED by another road (the
+ *      operator's Refresh, a late write) left it owed, so the next
+ *      edit was refused and read the store again; a move sent by the
+ *      host did not run it; a load that failed forgot the import plan
+ *      of a dialog it left up; and the export's two views switched in
+ *      a DOM handler, out of the machine.
+ *
  *      Driven through the FSM on a document double, with a fake
  *      transport whose state is the one the library reads.
  *
@@ -68,6 +76,7 @@ const {
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event, gobj_read_attr,
     gobj_change_state, gobj_current_state,
+    gobj_set_gobj_trace,
     set_log_callback,
 } = await import("@yuneta/gobj-js");
 const {register_c_yui_schema_editor} = await import("./c_yui_schema_editor.js");
@@ -575,11 +584,12 @@ describe("a dialog built on the model a reload replaced (fourth review)", () =>
         expect(editor.priv.import_plan.writes.length).toBeGreaterThan(0);
 
         gobj_send_event(editor, "EV_REFRESH", {}, host);
-        expect(editor.priv.import_plan).toBe(null);
         answer_the_load_with(editor, remote, records_with((r) => {
             r.cols.push({id: "db.users.email", value: "email", order: 2, type: "integer",
                          topics: ["topics^db.users^cols"]});
         }));
+        /*  Forgotten when the load LANDS, not when it leaves (sixth review).  */
+        expect(editor.priv.import_plan).toBe(null);
         expect(dialog.closed).toBe(true);
 
         dialog.$content.querySelector(".SCHEMA_IMPORT_RUN").disabled = false;
@@ -1035,3 +1045,179 @@ describe("the answers of the editor's confirmations are i18n keys (fifth review,
             .toEqual(["delete", "cancel"]);
     });
 });
+
+describe("the owed reload, settled wherever a load lands (sixth review)", () => {
+
+    function refused_load(name, subpath)
+    {
+        const built = build(name, subpath);
+        gobj_send_event(built.editor, "EV_REFRESH", {}, built.host);
+        const asked = take("nodes");
+        answer(built.editor, built.remote, asked[0], -1, null, "deadline");
+        answer(built.editor, built.remote, asked[1], 0, RECORDS[asked[1].kw.topic_name]);
+        answer(built.editor, built.remote, asked[2], 0, RECORDS[asked[2].kw.topic_name]);
+        expect(built.editor.priv.reload_on_open).toBe(true);
+        expect(shown).toEqual([KEPT]);
+        return built;
+    }
+
+    test("the operator's Refresh that lands pays it: the next edit opens its form", () => {
+        const {editor, remote, host} = refused_load("q1", "db/users");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.reload_on_open).toBe(false);
+
+        const before = modals.length;
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        expect(modals.length).toBe(before + 1);
+        expect(take("nodes")).toEqual([]);
+        expect(shown).toEqual([KEPT]);
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test("the reload of a late write that lands pays it too", () => {
+        const {editor, remote, host} = build("q2", "db/users");
+        const w = start_a_write(editor, host, "name");
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const asked = take("nodes");
+        answer(editor, remote, asked[0], -1, null, "deadline");
+        answer(editor, remote, asked[1], 0, RECORDS[asked[1].kw.topic_name]);
+        answer(editor, remote, asked[2], 0, RECORDS[asked[2].kw.topic_name]);
+        expect(editor.priv.reload_on_open).toBe(true);
+
+        /*  The write given up answers DONE: the model is read again.  */
+        answer(editor, remote, w, 0, {id: "db.users.name", value: "name", type: "string",
+            order: 2, topics: [{id: "db.users", topic_name: "topics", hook_name: "cols"}]});
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(editor.priv.reload_on_open).toBe(false);
+
+        const before = modals.length;
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        expect(modals.length).toBe(before + 1);
+        expect(take("nodes")).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a move sent by the HOST (a url, the browser's Back) runs it, as the editor's own moves do", () => {
+        const {editor, remote, host} = refused_load("q3", "db/users");
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(editor.priv.reload_on_open).toBe(false);
+        expect(shown).toEqual([KEPT]);      /*  a move is not refused  */
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test("a host EV_SHOW with nothing owed asks for nothing", () => {
+        const {editor, remote, host} = build("q4", "db/users");
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(take("nodes")).toEqual([]);
+    });
+});
+
+describe("the import plan outlives a load that fails (sixth review)", () => {
+
+    const IMPORT = JSON.stringify({id: "db", topics: [{id: "users", pkey: "id", cols: [
+        {id: "id", type: "string", flag: ["persistent", "required"]},
+        {id: "email", type: "string"}
+    ]}]});
+
+    test("a load that LEFT and failed replaced nothing: the plan and its Import stay", () => {
+        const {editor, remote, host} = build("m1", "db");
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        const dialog = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_PREVIEW_IMPORT", {prune: false, text: IMPORT,
+            model_gen: editor.priv.model_gen}, editor);
+        const plan = editor.priv.import_plan;
+        expect(plan.writes.length).toBeGreaterThan(0);
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        const asked = take("nodes");
+        answer(editor, remote, asked[0], -1, null, "deadline");
+        answer(editor, remote, asked[1], 0, RECORDS[asked[1].kw.topic_name]);
+        answer(editor, remote, asked[2], 0, RECORDS[asked[2].kw.topic_name]);
+
+        expect(dialog.closed).toBe(false);
+        expect(editor.priv.import_plan).toBe(plan);
+        expect(dialog.$content.querySelector(".SCHEMA_IMPORT_RUN").disabled).toBe(false);
+        expect(dialog.$content.querySelector(".SCHEMA_IMPORT_PLAN").childNodes.length)
+            .toBeGreaterThan(0);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a load that LANDS forgets it, and closes the dialog it was shown in", () => {
+        const {editor, remote, host} = build("m2", "db");
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        const dialog = modals[modals.length - 1];
+        gobj_send_event(editor, "EV_PREVIEW_IMPORT", {prune: false, text: IMPORT,
+            model_gen: editor.priv.model_gen}, editor);
+        expect(editor.priv.import_plan).toBeTruthy();
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(editor.priv.import_plan).toBeTruthy();   /*  in the air: nothing replaced yet  */
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(editor.priv.import_plan).toBe(null);
+        expect(dialog.closed).toBe(true);
+        expect(shown).toEqual([STALE]);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("the export's two views go through the machine (sixth review)", () => {
+
+    test("a click on a view is an event, and the action switches the text", () => {
+        const {editor, remote, host} = build("y1", "db");
+        gobj_send_event(editor, "EV_EXPORT", {}, host);
+        const $content = modals[modals.length - 1].$content;
+        const $tabs = [...$content.querySelectorAll(".SCHEMA_EXPORT_TAB")];
+        const $text = $content.querySelector(".SCHEMA_EXPORT_TEXT");
+
+        gobj_set_gobj_trace(editor, "machine", true);
+        try {
+            $tabs[1].click();
+        } finally {
+            gobj_set_gobj_trace(editor, "machine", false);
+        }
+        expect(logged.some((l) => /EV_EXPORT_VIEW/.test(l.msg))).toBe(true);
+        expect($text.value.trim().startsWith("{")).toBe(true);
+        expect($tabs.map(($b) => $b.getAttribute("aria-pressed"))).toEqual(["false", "true"]);
+        expect($tabs.map(($b) => $b.classList.contains("selected_state"))).toEqual([false, true]);
+
+        gobj_send_event(editor, "EV_EXPORT_VIEW", {pane: "c"}, editor);
+        expect($text.value.trim().startsWith("{")).toBe(false);
+        expect($tabs.map(($b) => $b.getAttribute("aria-pressed"))).toEqual(["true", "false"]);
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+
+    test("answered while a load is in the air, where the dialog is still up", () => {
+        const {editor, remote, host} = build("y2", "db");
+        gobj_send_event(editor, "EV_EXPORT", {}, host);
+        const $content = modals[modals.length - 1].$content;
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        $content.querySelectorAll(".SCHEMA_EXPORT_TAB")[1].click();
+        expect($content.querySelector(".SCHEMA_EXPORT_TEXT").value.trim().startsWith("{")).toBe(true);
+        expect(not_defined()).toEqual([]);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a view that is not one, or no export open, is an ERROR, not a guess", () => {
+        const {editor, remote, host} = build("y3", "db");
+        gobj_send_event(editor, "EV_EXPORT_VIEW", {pane: "c"}, editor);
+        gobj_send_event(editor, "EV_EXPORT", {}, host);
+        gobj_send_event(editor, "EV_EXPORT_VIEW", {pane: "yaml"}, editor);
+        expect(errors().length).toBe(2);
+    });
+});

package/src/treedb_topics_transport.wiring.test.js

@@ -22,7 +22,7 @@ const {
     gclass_create,
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event,
-    gobj_change_state,
+    gobj_change_state, gobj_current_state,
     set_log_callback,
 } = gobj_js;
 const {register_c_yui_shell, yui_shell_set_connection_state} = await import("./c_yui_shell.js");
@@ -34,11 +34,16 @@ const commands = [];        /*  what the fake transport was asked  */
 
 /*
  *  The transport: answers nothing, like a C_IEVENT_CLI whose socket is
- *  about to drop. Its state is what `is_connected()` reads.
+ *  about to drop. Its state is what `is_connected()` reads. Out of
+ *  session it refuses what it is asked, as gui_agent's routing adapter
+ *  (C_AGENT_TREEDB_LINK) does.
  */
 function remote_command_parser(gobj, command, kw, src)
 {
     commands.push({command, kw});
+    if(gobj_current_state(gobj) !== "ST_SESSION") {
+        return `cannot route '${command}' -- not in session`;
+    }
     return null;
 }
 
@@ -78,7 +83,11 @@ beforeAll(() => {
         ]]],
         {},
         0,
-        [SDATA(data_type_t.DTP_STRING, "topic_name", 0, "", "topic"), SDATA_END()],
+        [
+            SDATA(data_type_t.DTP_STRING, "topic_name", 0, "", "topic"),
+            SDATA(data_type_t.DTP_BOOLEAN, "with_remote_paging", 0, false, "pulls its pages"),
+            SDATA_END()
+        ],
         {}, 0, 0, 0, 0
     );
     /*  The host of the view: it hears what a CHILD view publishes.  */
@@ -226,3 +235,107 @@ describe("a Save in flight when the backend drops (M8)", () => {
         ]);
     });
 });
+
+/*
+ *  The answer the routing adapter gives a write it had in flight when
+ *  its session closed: a failure, settled by the adapter itself.
+ */
+function failed_write(topic_name, form_write)
+{
+    const md = {topic_name: topic_name, treedb_name: "treedb_test", record: {id: "x"}};
+    if(form_write) {
+        md.form_write = form_write;
+    }
+    return {result: -1, comment: "the session closed", data: null, __md_iev__: {
+        command_stack: [{command: "update-node", kw: md}]
+    }};
+}
+
+function nodes_asked()
+{
+    return commands.filter((c) => c.command === "nodes").map((c) => c.kw.topic_name);
+}
+
+describe("a write cut by the drop does not reload out of session", () => {
+
+    test("the failure lands before the edge: no reload now, one on the reconnect", () => {
+        const {shell, topics} = build("t6");
+        yui_shell_set_connection_state(shell, true);
+
+        /*  A cell edited in place: it looks saved until the topic is read again.  */
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "users", id: "x", field: "name", value: "typed"}, topics);
+        expect(commands.filter((c) => c.command === "update-node").length).toBe(1);
+
+        /*  The adapter leaves ST_SESSION and settles what it had in flight.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 0), remote);
+
+        expect(nodes_asked()).toEqual([]);
+        expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
+
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        expect(nodes_asked()).toEqual([]);
+
+        /*  The reconnect reloads what the drop left unknown -- once, though
+         *  two edges report it.  */
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        yui_shell_set_connection_state(shell, false);
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual(["users"]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the edge lands first: the form is answered once, the reload waits", () => {
+        const {shell, topics, forms} = build("t7");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        yui_shell_set_connection_state(shell, false);
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 1), remote);
+
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+        expect(nodes_asked()).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual(["users"]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an edge that says 'up' before the transport is: the reload still waits", () => {
+        const {shell, topics} = build("t8");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "roles", id: "x", field: "name", value: "typed"}, topics);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("roles", 0), remote);
+        yui_shell_set_connection_state(shell, false);
+
+        /*  The app's connection is back, the view's transport is not yet.  */
+        yui_shell_set_connection_state(shell, true);
+        expect(nodes_asked()).toEqual([]);
+
+        gobj_change_state(remote, "ST_SESSION");
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked()).toEqual(["roles"]);
+        expect(errors().filter((m) => m.includes("not in session"))).toEqual([]);
+    });
+
+    test("a write refused IN session reloads its topic at once, and only then", () => {
+        const {shell, topics} = build("t9");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_UPDATE_FIELD",
+            {topic_name: "users", id: "x", field: "name", value: "typed"}, topics);
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", failed_write("users", 0), remote);
+        expect(nodes_asked()).toEqual(["users"]);
+
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: true}, topics);
+        expect(nodes_asked()).toEqual(["users"]);
+    });
+});