@yuneta/gobj-ui 7.25.6 → 7.25.8

package/src/c_yui_schema_editor.js

@@ -206,6 +206,7 @@ let PRIVATE_DATA = {
     pending:        0,      /*  `nodes` requests still in flight  */
     load_error:     "",
     load_round:     0,      /*  which load an answer belongs to: echoed as `round`  */
+    load_keeps_written: false,  /*  the load in flight is not the host's: `written` survives it  */
 
     /*  Where the operator is. The url carries it; these mirror it.  */
     treedb_id:      "",
@@ -231,8 +232,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  */
@@ -455,8 +459,25 @@ 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;
     let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
@@ -465,27 +486,41 @@ function request_model(gobj)
         return -1;      /*  not mounted on a transport yet: mt_start retries via EV_TRANSPORT_STATE  */
     }
 
+    let previous = priv.records;
     priv.records = {treedbs: [], topics: [], cols: []};
     priv.load_error = "";
     priv.pending = 0;
     priv.load_round++;
+    priv.load_keeps_written = !!keep_written;
     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: topic_name,
-            options:    {list_dict: true}
-        }, {round: priv.load_round}) === 0) {
-            priv.pending++;
+    set_busy(gobj, false);
+    render(gobj);
+
+    /*  Out of session nothing is asked: each request would come back
+     *  refused and logged as an ERROR, for a drop that is not one.  */
+    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: topic_name,
+                options:    {list_dict: true}
+            }, {round: priv.load_round}) === 0) {
+                left++;
+            }
         }
     }
-    if(priv.pending === 0) {
+    if(left < 3) {
+        priv.records = previous;
+        priv.load_round++;
+        priv.reload_on_open = true;
         priv.load_error = t("cannot reach the treedb");
-        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: t});
+        }
+        end_load(gobj);
         return -1;
     }
+    priv.pending = left;
     return 0;
 }
 
@@ -568,17 +603,23 @@ 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) {
@@ -802,12 +843,19 @@ function render_toolbar(gobj)
     let state = gobj_current_state(gobj);
     let readonly = is_readonly(gobj);
     let has_model = !!priv.model;
+    /*  The position can outlive its screen (a load that failed keeps the
+     *  url's; ST_EMPTY has a treedb in the url and none in the model),
+     *  and a button there sends what only a treedb screen declares.  */
+    let on_a_treedb = state !== "ST_IDLE" && state !== "ST_EMPTY";
+    /*  Nothing is legal while the model is in the air: every action is
+     *  computed against it.  */
+    let in_flight = state === "ST_SAVING" || state === "ST_LOADING";
 
     /*----------------------------------------------*
      *  Left: back, then the position as a trail.
      *----------------------------------------------*/
     let $left = [];
-    if(priv.treedb_id) {
+    if(priv.treedb_id && on_a_treedb) {
         $left.push(["button", {class: "SCHEMA_BACK button",
                                type: "button",
                                title: t("back"), "aria-label": t("back"),
@@ -844,7 +892,7 @@ function render_toolbar(gobj)
      *  refused says why when it is pressed.
      *----------------------------------------------*/
     let $right = [];
-    if(priv.treedb_id && has_model) {
+    if(priv.treedb_id && has_model && on_a_treedb) {
         /*  The compass, like every other door to a SCHEMA: the
          *  `hexagon-nodes` it wore is the graph of the DATA.  */
         $right.push(toolbar_button("SCHEMA_DIAGRAM_BTN", "yi-compass-drafting",
@@ -858,7 +906,7 @@ function render_toolbar(gobj)
                 "import", "EV_IMPORT", false));
         }
     }
-    if(priv.topic_name && !readonly && !priv.diagram) {
+    if(priv.topic_name && !readonly && !priv.diagram && on_a_treedb) {
         /*  Only while there IS somewhere to go back to: a drag is a write,
          *  and this is the way back from one. */
         if(undo_order_writes(gobj, current_topic(gobj)).length > 0) {
@@ -868,7 +916,7 @@ function render_toolbar(gobj)
         $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) {
+    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));
     }
@@ -891,7 +939,7 @@ function render_toolbar(gobj)
      *  destroyed.  */
     for(let $button of $bar.querySelectorAll("button")) {
         $button.__gobj__ = gobj;
-        if(state === "ST_SAVING") {
+        if(in_flight) {
             $button.disabled = true;
         }
     }
@@ -915,19 +963,25 @@ function render(gobj)
     }
     render_toolbar(gobj);
 
+    /*  A screen with nothing to draw takes the drawing down too: left
+     *  alive, it was only re-shown on the way back -- into a body that
+     *  no longer held it.  */
     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;
     }
@@ -1468,12 +1522,21 @@ function render_diagram(gobj)
     let $body = $of(gobj, ".SCHEMA_BODY");
     let treedb = current_treedb(gobj);
 
-    if(!$body || !treedb) {
+    if(!$body) {
+        return;
+    }
+    /*  Said on an EMPTY body, as the topics and the columns say it:
+     *  render() clears the body for every screen but this one, and the
+     *  screen before stayed up under the notice, clickable.  */
+    if(!treedb) {
+        destroy_diagram(gobj);
+        clear($body);
         show_notice(gobj, "that treedb is not here any more", priv.treedb_id);
         return;
     }
     if(!gclass_find_by_name("C_YUI_TREEDB_SCHEMA")) {
         log_error(`${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;
     }
@@ -2403,6 +2466,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 +2503,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;
 }
 
@@ -2457,29 +2561,15 @@ function end_writes(gobj, error)
 {
     let priv = gobj.priv;
 
+    let seg = priv.pending_seg;
+
     priv.save_queue = [];
+    priv.pending_seg = null;
     gobj_change_state(gobj, priv.save_return || "ST_TREEDBS");
     priv.save_return = "";
     show_notice(gobj, "");
     set_busy(gobj, false);
 
-    /*  A position that arrived while the write was in flight: applied
-     *  now, so a Back pressed mid-save is not simply lost.  */
-    if(priv.pending_seg !== null) {
-        let seg = priv.pending_seg;
-        priv.pending_seg = null;
-        if(!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;
-        }
-    }
-
     if(error) {
         yui_shell_show_error(yui_shell_of(gobj), error, {t: t});
     }
@@ -2489,11 +2579,42 @@ function end_writes(gobj, error)
         });
     }
     priv.save_wrote = false;
-    render(gobj);
-    publish_check(gobj);
+
+    /*  A position that arrived while the write was in flight: applied
+     *  now, so a Back pressed mid-save is not simply lost -- with an
+     *  error too. The host's url already says it, and a load cut by a
+     *  drop applies it (end_load()): the write kept the old screen, and
+     *  the url and the view disagreed.  */
+    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.
  *
@@ -2595,13 +2716,20 @@ function go(gobj, treedb_id, topic_name, diagram, mirror)
 {
     let priv = gobj.priv;
 
+    /*  Moving IS the answer to a position that waited: one left behind
+     *  sent a later load back to it.  */
+    priv.pending_seg = null;
     priv.treedb_id = treedb_id || "";
     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 +2775,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 +2868,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 +2886,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 +2899,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, data);
         }
         if(result < 0) {
             return end_writes(gobj, comment || t("the treedb refused the write"));
@@ -2776,8 +2933,17 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 /*  The treedb wrote it and did not describe it back: ask
                  *  again rather than draw a model that has drifted.  */
                 log_warning(`${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;
+                gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
+                    treedb_name: gobj_read_str_attr(gobj, "treedb_name")
+                });
+                request_model(gobj, true);
                 return 0;
             }
         }
@@ -2796,6 +2962,81 @@ 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 = 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`);
+    mark_written_record(gobj, topic_name, is_object(data) ? data
+        : (Array.isArray(data) && is_object(data[0]) ? data[0] : null));
+    gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
+        treedb_name: 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.
@@ -2822,10 +3063,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);
 }
@@ -2867,7 +3112,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;
@@ -2886,7 +3131,28 @@ function ac_language_changed(gobj, event, kw, src)
 
 function ac_refresh(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)
+{
+    log_warning(`${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: t});
+    return -1;
 }
 
 /***************************************************************
@@ -3518,7 +3784,14 @@ function create_gclass(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()],