@yuneta/gobj-ui 7.25.14 → 7.25.16

package/src/c_yui_schema_editor.js

@@ -22,11 +22,10 @@
  *      AN EDIT IS A DRAFT. A write here moves no version and reaches no
  *      treedb: the host SAVES it (C_TREEDB's save-schema raises the
  *      topic_version of what changed and the schema_version, once) and
- *      APPLIES it (apply-schema + a restart of the owning yuno). Until
- *      the owner's design of M36 (2026-09-21 review) every write here
- *      raised both versions, so an edit half made was already the
- *      schema of the next start. The topic list marks what this session
- *      wrote and has not saved (EV_REFRESH forgets it: the view's own
+ *      APPLIES it (apply-schema + a restart of the owning yuno). If a
+ *      write here raised both versions, an edit half made would already
+ *      be the schema of the next start. The topic list marks what this
+ *      session wrote and has not saved (EV_REFRESH forgets it: the view's own
  *      Refresh button sends it, and a host may after a save -- the
  *      agent console's does not) and what the host says is not saved
  *      (EV_DRAFTS, replaced whole each time it is sent).
@@ -118,6 +117,7 @@ import {
     kw_get_int,
     kw_get_dict,
     is_object,
+    json_deep_copy,
     is_array,
     empty_string,
 } from "@yuneta/gobj-js";
@@ -188,6 +188,11 @@ const DIAGRAM_SEG = "diagram";
  *  them), and each filters on its own purpose.  */
 const PURPOSE = "schema_editor";
 
+/*  The dialogs that show what they were opened with and send nothing a
+ *  screen declares: a move sent by the host leaves them up (see
+ *  close_dialog_left_behind()).  */
+const DIALOGS_THAT_READ_NOTHING = ["SCHEMA_EXPORT_DIALOG", "SCHEMA_REPORT_DIALOG"];
+
 
 /***************************************************************
  *              Attrs
@@ -230,6 +235,7 @@ let PRIVATE_DATA = {
     diagram_gobj:   null,
     dialog:         null,
     dialog_gen:     0,      /*  the model_gen the open dialog was built on  */
+    dialog_kind:    "",     /*  the logical class of the open dialog  */
 
     /*  A write, or a plan of them, in flight  */
     save_queue:     null,
@@ -241,6 +247,8 @@ let PRIVATE_DATA = {
     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  */
+    refresh_after_write: false, /*  EV_REFRESH heard while writes were in flight: run at their end  */
+    reopen_form:    null,   /*  the form whose Save ran the owed reload: opened again once it lands  */
 
     /*  A position that arrived while a load or a write was in flight  */
     pending_seg:    null,
@@ -460,9 +468,9 @@ function refuse_if_readonly(gobj, event)
  *  dumped by the machine trace).
  *
  *  Refused, and said. A column form sends every field it shows, so
- *  its Save after a reload wrote the OLD record over the newer one
- *  (fourth independent review, probe A3); a form whose column the
- *  reload removed answered "names no column" for ever. end_load()
+ *  its Save after a reload wrote the OLD record over the newer one;
+ *  a form whose column the reload removed answered "names no column"
+ *  for ever. end_load()
  *  closes such a dialog when the load lands; this is the same rule
  *  for whatever arrives anyway -- a stale screen, a confirmation
  *  that was up, a keyboard.
@@ -489,8 +497,7 @@ function built_on_a_replaced_model(gobj, event, kw)
  *  the model shown is kept, and it may be older than the store.
  *  The session is up, so no reconnect will ask for it again -- it
  *  was owed for as long as the session lasted, and a form opened
- *  on that model wrote every field of it over the newer record
- *  (fifth independent review; A3 of the fourth, by another path).
+ *  on that model wrote every field of it over the newer record.
  *
  *  So the operator's NEXT action asks it. An edit -- a form, a
  *  write, a confirmation, what reads the model whole (check,
@@ -518,12 +525,37 @@ function owes_reload(gobj)
         state !== "ST_LOADING" && state !== "ST_SAVING";
 }
 
-function reload_first(gobj, event)
+function reload_first(gobj, event, reopen)
 {
+    let priv = gobj.priv;
+
     if(!owes_reload(gobj)) {
         return false;
     }
-    gobj.priv.reload_on_open = false;
+    priv.reload_on_open = false;
+
+    /*  The Save of a FORM: what the operator typed is not thrown away
+     *  with the model it was typed on. The load that lands closes the
+     *  form (end_load()) and opens it again on the schemas it read,
+     *  with the fields the operator CHANGED put back on top -- only
+     *  those: a field left as it was shows what the store holds now,
+     *  so the next Save does not write the old value over a newer
+     *  one. Closed alone, the form took what was typed with it.  */
+    if(reopen && priv.dialog) {
+        priv.reopen_form = Object.assign(json_deep_copy(reopen), {
+            dialog:    priv.dialog,
+            treedb_id: priv.treedb_id
+        });
+        log_warning(`${gobj_short_name(gobj)}: ${event} refused, the schemas shown ` +
+            `may be out of date: they are read again first, and the form opens again ` +
+            `on them with its changes`);
+        yui_shell_show_error(yui_shell_of(gobj),
+            "the schemas shown may be out of date: they are read again, and the form opens again on them with your changes",
+            {t: t});
+        request_model(gobj, true);
+        return true;
+    }
+
     log_warning(`${gobj_short_name(gobj)}: ${event} refused, the schemas shown ` +
         `may be out of date: they are read again first`);
     yui_shell_show_error(yui_shell_of(gobj),
@@ -533,6 +565,53 @@ function reload_first(gobj, event)
     return true;
 }
 
+/***************************************************************
+ *  The form reload_first() took down, opened again on the model
+ *  the load just made, with the operator's changes on top.
+ *
+ *  Only where it can mean the same thing: on the treedb it was
+ *  opened on, on the screen whose Save it has, and on a record
+ *  that is still there. Otherwise it is not opened, and that is
+ *  said -- a form opened on another treedb, or on nothing, would
+ *  save somewhere the operator never meant.
+ ***************************************************************/
+function reopen_form(gobj, r)
+{
+    let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
+    let treedb = current_treedb(gobj);
+    let topic = null;
+    let col = null;
+    let fits = false;
+
+    if(treedb && r.treedb_id === priv.treedb_id) {
+        if(r.form === "column" && state === "ST_COLUMNS") {
+            topic = find_topic(priv.model, priv.treedb_id, r.topic);
+            col = (topic && !r.creating) ?
+                find_col(priv.model, priv.treedb_id, r.topic, r.col) : null;
+            fits = !!topic && (r.creating || !!col);
+        } else if(r.form === "topic" && state === "ST_TOPICS") {
+            topic = r.creating ? null : find_topic(priv.model, priv.treedb_id, r.topic);
+            fits = r.creating || !!topic;
+        }
+    }
+    if(!fits) {
+        log_warning(`${gobj_short_name(gobj)}: the ${r.form} form was not opened again: ` +
+            `what it edited is not on the schemas the reload read ` +
+            `(${r.treedb_id} ${r.topic}${r.col ? "." + r.col : ""}, now ${state})`);
+        yui_shell_show_error(yui_shell_of(gobj),
+            "the schemas were read again and what the form was editing is not there any more",
+            {t: t});
+        return -1;
+    }
+    if(r.form === "column") {
+        open_column_form(gobj, topic, col, null, r.changed);
+    } else {
+        open_topic_form(gobj, treedb, topic, r.changed);
+    }
+    return 0;
+}
+
 function reload_after_move(gobj)
 {
     if(!owes_reload(gobj)) {
@@ -562,7 +641,7 @@ function reload_after_move(gobj)
  *  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
+ *  ST_LOADING" and was lost. A dialog
  *  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.
@@ -721,7 +800,7 @@ function build_model(gobj)
  *  measurement of "changed since" can be measured against.
  *
  *  `written` is forgotten only by an EV_REFRESH (the view's own
- *  Refresh button, or a host that sends one). Since M36 a write moves no
+ *  Refresh button, or a host that sends one). Since 7.23.196 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
@@ -969,8 +1048,7 @@ function render_toolbar(gobj)
      *  reload that no longer has them keeps the position (it says so,
      *  and Back is the way out). Asked of the MODEL, not of the state:
      *  gated on the state, Diagram, Check, Export, Import and New topic
-     *  stayed up there and each logged "with no treedb open" (fourth
-     *  independent review, probe D2).  */
+     *  stayed up there and each logged "with no treedb open".  */
     let treedb_here = on_a_treedb && !!current_treedb(gobj);
     let topic_here = treedb_here && !!current_topic(gobj);
     /*  Nothing is legal while the model is in the air: every action is
@@ -1745,6 +1823,7 @@ function close_dialog(gobj)
     }
     let dialog = priv.dialog;
     priv.dialog = null;
+    priv.dialog_kind = "";
     priv.export_view = null;
     try {
         dialog.close();
@@ -1759,6 +1838,7 @@ function open_dialog(gobj, $content, title, logical, title_prefix)
 
     close_dialog(gobj);
     priv.dialog_gen = priv.model_gen;
+    priv.dialog_kind = logical;
     priv.dialog = yui_shell_show_modal(yui_shell_of(gobj), $content, {
         dialog:        true,
         title:         title,
@@ -1767,6 +1847,7 @@ function open_dialog(gobj, $content, title, logical, title_prefix)
         t:             t,
         on_close:      () => {
             priv.dialog = null;
+            priv.dialog_kind = "";
             priv.export_view = null;
         }
     });
@@ -1909,6 +1990,75 @@ function read_form($root)
     return out;
 }
 
+/***************************************************************
+ *  A column form as its Save sends it: the fields and the flags.
+ ***************************************************************/
+function column_form_state($form)
+{
+    let values = read_form($form);
+    values.flag = read_flags($form);
+    return values;
+}
+
+/***************************************************************
+ *  The fields the operator CHANGED: those whose value is not the
+ *  one the form was opened with.
+ ***************************************************************/
+function form_changes(initial, values)
+{
+    let changed = {};
+
+    for(let name of Object.keys(values)) {
+        if(JSON.stringify(values[name]) !== JSON.stringify(initial[name])) {
+            changed[name] = values[name];
+        }
+    }
+    return changed;
+}
+
+/***************************************************************
+ *  Put changes back into a form just built (reopen_form()). The
+ *  flags are drawn again for the type the changes leave, holding
+ *  the flags they name, so none of them is hidden by the type.
+ ***************************************************************/
+function apply_form_changes(gobj, $form, changes)
+{
+    for(let name of Object.keys(changes)) {
+        if(name === "flag") {
+            continue;
+        }
+        let $control = $form.querySelector(`[data-name="${name}"]`);
+        if(!$control) {
+            log_warning(`${gobj_short_name(gobj)}: a change of '${name}' has no field ` +
+                `in the form opened again: not put back`);
+            continue;
+        }
+        if($control.type === "checkbox") {
+            $control.checked = !!changes[name];
+        } else {
+            $control.value = changes[name];
+        }
+    }
+
+    let $type = $form.querySelector('[data-name="type"]');
+    if($type && $form.querySelector(".SCHEMA_FLAGS")) {
+        let flags = Array.isArray(changes.flag) ? changes.flag : read_flags($form);
+        redraw_flags(gobj, $form, $type.value, flags);
+    }
+}
+
+/***************************************************************
+ *  Draw the flags of a column form again, for `type`, with
+ *  `current` checked.
+ ***************************************************************/
+function redraw_flags(gobj, $form, type, current)
+{
+    let $holder = $form.querySelector(".SCHEMA_FLAGS");
+    let $new = createElement2(flags_field(gobj, type, current));
+    $holder.parentNode.replaceChild($new, $holder);
+    refresh_language($new, t);
+}
+
 /***************************************************************
  *  The flags of a column, as checkboxes that say what they do.
  *
@@ -1971,7 +2121,7 @@ function read_flags($root)
  *  Offering a field that silently does something else is worse
  *  than not offering it.
  ***************************************************************/
-function open_column_form(gobj, topic, col, prefill)
+function open_column_form(gobj, topic, col, prefill, changes)
 {
     let priv = gobj.priv;
     /*  A DUPLICATE is a creation whose fields start filled: the name must
@@ -2045,11 +2195,7 @@ function open_column_form(gobj, topic, col, prefill)
      *  new type does not use.  */
     let $type = $form.querySelector('[data-name="type"]');
     $type.addEventListener("change", () => {
-        let $holder = $form.querySelector(".SCHEMA_FLAGS");
-        let current = read_flags($form);
-        let $new = createElement2(flags_field(gobj, $type.value, current));
-        $holder.parentNode.replaceChild($new, $holder);
-        refresh_language($new, t);
+        redraw_flags(gobj, $form, $type.value, read_flags($form));
     });
 
     /*  A flag that excludes another is answered here and not on save,
@@ -2069,15 +2215,22 @@ function open_column_form(gobj, topic, col, prefill)
         evt.stopPropagation();
         close_dialog(gobj);
     });
+    /*  What the form showed before the operator touched it: what
+     *  was CHANGED is measured against it (form_changes()).  */
+    let initial = column_form_state($form);
+    if(changes) {
+        apply_form_changes(gobj, $form, changes);
+    }
+
     $form.querySelector(".SCHEMA_COL_FORM_SAVE").addEventListener("click", (evt) => {
         evt.stopPropagation();
-        let values = read_form($form);
-        values.flag = read_flags($form);
+        let values = column_form_state($form);
         gobj_send_event(gobj, "EV_SAVE_COLUMN", {
             topic:     topic.name,
             col:       creating ? "" : col.name,
             creating:  creating,
             values:    values,
+            changed:   creating ? values : form_changes(initial, values),
             model_gen: model_gen
         }, gobj);
     });
@@ -2106,7 +2259,7 @@ function stringify_field(value)
  *  actually has: a pkey naming no column is a topic that does
  *  not open, and it is the first thing the validator looks for.
  ***************************************************************/
-function open_topic_form(gobj, treedb, topic)
+function open_topic_form(gobj, treedb, topic, changes)
 {
     let record = (topic && topic.record) || {};
     let creating = !topic;
@@ -2165,12 +2318,19 @@ function open_topic_form(gobj, treedb, topic)
         evt.stopPropagation();
         close_dialog(gobj);
     });
+    let initial = read_form($form);
+    if(changes) {
+        apply_form_changes(gobj, $form, changes);
+    }
+
     $form.querySelector(".SCHEMA_TOPIC_FORM_SAVE").addEventListener("click", (evt) => {
         evt.stopPropagation();
+        let values = read_form($form);
         gobj_send_event(gobj, "EV_SAVE_TOPIC", {
             topic:     creating ? "" : topic.name,
             creating:  creating,
-            values:    read_form($form),
+            values:    values,
+            changed:   creating ? values : form_changes(initial, values),
             model_gen: model_gen
         }, gobj);
     });
@@ -2674,11 +2834,11 @@ function transport_in_session(gobj)
  *  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.
+ *  meanwhile waits in `pending_seg` (ac_show()). If EV_SHOW moved a
+ *  RELOAD out of ST_LOADING, every answer of it would be "for a load
+ *  that is over": the records it had emptied would stay empty, and
+ *  the next write would patch them into a model with no treedb at
+ *  all.
  ***************************************************************/
 function is_current_load(gobj, md)
 {
@@ -2750,27 +2910,46 @@ function end_load(gobj)
 {
     let priv = gobj.priv;
     let seg = priv.pending_seg;
+    let reopen = priv.reopen_form;
 
     priv.pending_seg = null;
+    priv.reopen_form = null;
     if(priv.dialog && priv.dialog_gen !== priv.model_gen) {
-        log_warning(`${gobj_short_name(gobj)}: a dialog was open on the schemas ` +
-            `the load replaced: closed`);
+        /*  The form whose Save asked for this load is opened again,
+         *  below, once the screen is there (reload_first()). Any other
+         *  dialog is closed, and that is said.  */
+        if(!reopen || reopen.dialog !== priv.dialog) {
+            reopen = null;
+            log_warning(`${gobj_short_name(gobj)}: a dialog was open on the schemas ` +
+                `the load replaced: closed`);
+            yui_shell_show_error(yui_shell_of(gobj),
+                "the schemas were read again: open the dialog again", {t: t});
+        }
         close_dialog(gobj);
-        yui_shell_show_error(yui_shell_of(gobj),
-            "the schemas were read again: open the dialog again", {t: t});
+    } else {
+        /*  Closed meanwhile by the operator, or a load that replaced
+         *  nothing: the form is where it was, or where it was left.  */
+        reopen = null;
     }
+
+    let ret = 0;
     if(priv.model) {
         if(seg !== null) {
-            return apply_seg(gobj, seg);
+            ret = apply_seg(gobj, seg);
+        } else {
+            ret = go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
         }
-        return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+    } else {
+        if(seg !== null) {
+            adopt_seg(gobj, seg);
+        }
+        gobj_change_state(gobj, "ST_IDLE");
+        render(gobj);
     }
-    if(seg !== null) {
-        adopt_seg(gobj, seg);
+    if(reopen) {
+        reopen_form(gobj, reopen);
     }
-    gobj_change_state(gobj, "ST_IDLE");
-    render(gobj);
-    return 0;
+    return ret;
 }
 
 /***************************************************************
@@ -2813,7 +2992,17 @@ function end_writes(gobj, error)
         render(gobj);
         publish_check(gobj);
     }
-    reload_if_owed(gobj);
+    if(priv.refresh_after_write) {
+        /*  The EV_REFRESH heard while the writes were in flight
+         *  (ac_refresh_after_the_writes()), run now that none is. It
+         *  reads the store whole, so it also pays a reload a late
+         *  write owed.  */
+        priv.refresh_after_write = false;
+        priv.reload_after_write = false;
+        request_model(gobj, false);
+    } else {
+        reload_if_owed(gobj);
+    }
     return error ? -1 : 0;
 }
 
@@ -2995,12 +3184,74 @@ function position_seg(gobj)
  *  ...and the same in reverse. A tail naming a treedb or a topic
  *  the store does not have lands one level up rather than on an
  *  empty screen: a shared link outlives the schema it points at.
+ *
+ *  Every position the HOST sends comes through here, at once
+ *  (ac_show()) or when what was in flight ends (end_load(),
+ *  end_writes()). A move to another position closes the dialog of
+ *  the screen the editor left (close_dialog_left_behind()).
  ***************************************************************/
 function apply_seg(gobj, seg)
 {
+    let before = position_seg(gobj);
     let pos = seg_position(seg);
 
-    return go(gobj, pos.treedb_id, pos.topic_name, pos.diagram, false);
+    let ret = go(gobj, pos.treedb_id, pos.topic_name, pos.diagram, false);
+    if(position_seg(gobj) !== before) {
+        close_dialog_left_behind(gobj);
+    }
+    return ret;
+}
+
+/***************************************************************
+ *  The host moved the editor while a dialog was up. C_YUI_SHELL
+ *  keeps the overlays open on a move that changes only the subpath
+ *  (a url typed in, a link), so the dialog outlives its screen.
+ *
+ *  A form, the import and the orphans send events that only the
+ *  screen they were opened from declares, and they name their
+ *  topic under the treedb open at the time. Left up on another
+ *  screen, their Save answered "Event NOT DEFINED" and the edit was
+ *  lost with no word. So the dialog is closed and the operator told.
+ *  The import plan goes with its dialog: it was computed for the
+ *  treedb the editor left.
+ *
+ *  The export and the check stay: they show the texts they were
+ *  opened with, and what they send is legal in every state.
+ ***************************************************************/
+function close_dialog_left_behind(gobj)
+{
+    let priv = gobj.priv;
+
+    if(!priv.dialog || DIALOGS_THAT_READ_NOTHING.includes(priv.dialog_kind)) {
+        return;
+    }
+    log_warning(`${gobj_short_name(gobj)}: the host moved the view while the dialog ` +
+        `${priv.dialog_kind} was open: closed`);
+    close_dialog(gobj);
+    forget_import_plan(gobj);
+    yui_shell_show_error(yui_shell_of(gobj), "the view moved: open the dialog again", {t: t});
+}
+
+/***************************************************************
+ *  A confirmation answered on another screen than the one it was
+ *  asked from. A confirmation is a shell modal, so a move sent by
+ *  the host does not close it. It names its topic and column, and
+ *  the actions look them up under the treedb open NOW: a Yes after
+ *  a move to another treedb deleted the topic or column of the same
+ *  name THERE.
+ *
+ *  Refused, and said. A kw with no `seg` stamp is not a
+ *  confirmation's and is not asked.
+ ***************************************************************/
+function asked_on_another_screen(gobj, event, kw)
+{
+    if(!kw || kw.seg === undefined || kw.seg === position_seg(gobj)) {
+        return false;
+    }
+    log_warning(`${gobj_short_name(gobj)}: ${event} refused, it was asked on ` +
+        `'${kw.seg}' and the view is on '${position_seg(gobj)}'`);
+    yui_shell_show_error(yui_shell_of(gobj), "the view moved: open the dialog again", {t: t});
+    return true;
 }
 
 function seg_position(seg)
@@ -3111,10 +3362,10 @@ function ac_mt_command_answer(gobj, event, kw, src)
              *  slow `nodes`): the model shown is what the store held a
              *  moment ago, and blanking it took the screen and every open
              *  form with it -- a form's Save then answered "Event NOT
-             *  DEFINED in state ST_IDLE" (fourth independent review). It
+             *  DEFINED in state ST_IDLE". It
              *  stays, as it does when the load cannot leave, and the
              *  reload is owed: the operator's next action asks it
-             *  (reload_first(), fifth independent review).  */
+             *  (reload_first()).  */
             if(priv.model) {
                 log_warning(`${gobj_short_name(gobj)}: the schemas could not be read ` +
                     `again (${priv.load_error}): the previous ones stay`);
@@ -3139,13 +3390,13 @@ function ac_mt_command_answer(gobj, event, kw, src)
         /*  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).  */
+         *  and read the store AGAIN.  */
         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).  */
+         *  disabled.  */
         forget_import_plan(gobj);
         build_model(gobj);
         /*  Same reason as order_undo above: this is the LOAD, and the
@@ -3191,7 +3442,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
                  *  silence, a drag of five columns stopped at the first.
                  *  The reload is also the one a late write may have owed
                  *  (reload_after_write): left set, the next write loaded
-                 *  the whole model once more (fourth independent review).  */
+                 *  the whole model once more.  */
                 let not_sent = priv.save_queue.length - 1;
                 log_warning(`${gobj_short_name(gobj)}: '${command}' answered no record` +
                     (not_sent > 0 ? `: ${not_sent} write(s) after it were not sent` : ""));
@@ -3211,7 +3462,11 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 gobj_publish_event(gobj, "EV_RECORD_WRITTEN", {
                     treedb_name: gobj_read_str_attr(gobj, "treedb_name")
                 });
-                request_model(gobj, true);
+                /*  An EV_REFRESH heard during the writes is paid by this
+                 *  load: it forgets the drafts, as the refresh would.  */
+                let refresh = priv.refresh_after_write;
+                priv.refresh_after_write = false;
+                request_model(gobj, !refresh);
                 return 0;
             }
         }
@@ -3284,8 +3539,7 @@ function late_write_done(gobj, command, topic_name, data)
  *  The fkey is read with parse_fkey_ref(), because the store answers
  *  in list_dict -- `[{topic_name, id, hook_name}]` -- and not in the
  *  `topics^<topic id>^cols` strings this view writes. Split as a
- *  string, every production answer marked nothing (fourth independent
- *  review, probe C).
+ *  string, every production answer marked nothing.
  ***************************************************************/
 function mark_written_record(gobj, topic_name, record)
 {
@@ -3344,7 +3598,7 @@ function ac_show(gobj, event, kw, src)
     /*  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).  */
+     *  nothing.  */
     apply_seg(gobj, seg);
     return reload_after_move(gobj);
 }
@@ -3368,7 +3622,7 @@ function ac_hide(gobj, event, kw, src)
  *
  *  Nothing else ends a load or a write the drop cut: their answers
  *  will never come, and waiting in ST_LOADING skipped the reload
- *  itself (M-1 of the independent review of 7.25.4).
+ *  itself.
  ***************************************************************/
 function ac_transport_state(gobj, event, kw, src)
 {
@@ -3408,6 +3662,25 @@ function ac_refresh(gobj, event, kw, src)
     return request_model(gobj, false);
 }
 
+/***************************************************************
+ *  EV_REFRESH while writes are in flight: the view's own Refresh
+ *  is busy then, so it is a host's (after a Save, say).
+ *
+ *  Run when the writes END (end_writes()), not now. Run now, the
+ *  load replaced ST_SAVING and what was still queued was never
+ *  sent, with no word: nothing but the end of what is in flight
+ *  moves this view out of ST_LOADING or ST_SAVING.
+ ***************************************************************/
+function ac_refresh_after_the_writes(gobj, event, kw, src)
+{
+    let priv = gobj.priv;
+
+    log_warning(`${gobj_short_name(gobj)}: ${event} while writes are in flight: ` +
+        `the schemas are read again when the writes end`);
+    priv.refresh_after_write = true;
+    return 0;
+}
+
 /***************************************************************
  *  What a DIALOG sends while the model is being read again: the
  *  Save of a form left open when the reload started, a
@@ -3417,12 +3690,11 @@ function ac_refresh(gobj, event, kw, src)
  *  a model the answers in the air are about to replace.
  *
  *  Refused, and SAID. Undeclared, it answered "Event NOT DEFINED
- *  in state ST_LOADING" and the edit was gone with no word (third
- *  independent review).
+ *  in state ST_LOADING" and the edit was gone with no word.
  *
  *  And NOT "try again": the same Save, once the load was in, sent
  *  the form built on the old model -- every field of the old record
- *  over the newer one (fourth independent review). The load that
+ *  over the newer one. The load that
  *  lands closes such a dialog (end_load()); one that fails leaves it
  *  up, on the model it was built on.
  ***************************************************************/
@@ -3439,8 +3711,7 @@ function ac_wait_for_the_load(gobj, event, kw, src)
  *  reload landed on zero treedbs while it was up) or ST_IDLE (no
  *  model). A confirmation is a shell modal, not this view's dialog,
  *  so the load that lands does not close it, and its Yes arrives
- *  anyway. Undeclared, it answered "Event NOT DEFINED" (fifth
- *  independent review).
+ *  anyway. Undeclared, it answered "Event NOT DEFINED".
  *
  *  Refused with the stamp's own words: whatever it was decided on
  *  is not on screen any more.
@@ -3461,13 +3732,12 @@ function ac_confirmed_on_nothing(gobj, event, kw, src)
  *  topics hold a draft in __system__ that is not saved (C_TREEDB's
  *  saved-schema, `draft_changed`). The mark of a write lived in this
  *  session's memory only, so a reload of the page, a reconnect or a
- *  refresh showed no draft while __system__ still differed (N13 of
- *  the 2026-09-22 review).
+ *  refresh showed no draft while __system__ still differed.
  *
  *  REPLACES what the host said before -- the host is the truth after
  *  a reload, and a Save is exactly the host saying "none any more".
  *  It only ever added, and a topic stayed a draft after the Save that
- *  published it (M1 of the 2026-09-23 review). What this session wrote
+ *  published it. What this session wrote
  *  stays marked: it is kept apart (see topic_is_draft()).
  ***************************************************************/
 function ac_drafts(gobj, event, kw, src)
@@ -3552,7 +3822,7 @@ function ac_show_orphans(gobj, event, kw, src)
  ***************************************************************/
 function confirm_then(gobj, message, detail, kw)
 {
-    kw = Object.assign({model_gen: gobj.priv.model_gen}, kw);
+    kw = Object.assign({model_gen: gobj.priv.model_gen, seg: position_seg(gobj)}, kw);
     /*  The answers are i18n KEYS: shell_modals names each button by its
      *  label, and its defaults ("Delete", "Cancel") are not lower-case, so
      *  no validated locale holds them -- they read English in every
@@ -3653,7 +3923,8 @@ function ac_save_column(gobj, event, kw, src)
     if(refuse_if_readonly(gobj, event)) {
         return -1;
     }
-    if(reload_first(gobj, event)) {
+    if(reload_first(gobj, event, {form: "column", topic: kw.topic, col: kw.col,
+                                  creating: !!kw.creating, changed: kw.changed || {}})) {
         return -1;
     }
     if(built_on_a_replaced_model(gobj, event, kw)) {
@@ -3828,7 +4099,8 @@ function ac_save_topic(gobj, event, kw, src)
     if(refuse_if_readonly(gobj, event)) {
         return -1;
     }
-    if(reload_first(gobj, event)) {
+    if(reload_first(gobj, event, {form: "topic", topic: kw.topic, col: "",
+                                  creating: !!kw.creating, changed: kw.changed || {}})) {
         return -1;
     }
     if(built_on_a_replaced_model(gobj, event, kw)) {
@@ -4092,6 +4364,9 @@ function ac_confirmed(gobj, event, kw, src)
     if(built_on_a_replaced_model(gobj, event, kw)) {
         return -1;
     }
+    if(asked_on_another_screen(gobj, event, kw)) {
+        return -1;
+    }
     if(kw.what === "import") {
         return run_import(gobj);
     }
@@ -4239,7 +4514,9 @@ function create_gclass(gclass_name)
          *  the host are heard: every other action would be computed
          *  against a model the answer still in the air is about to
          *  change.  */
-        ["ST_SAVING", COMMON.slice()]
+        ["ST_SAVING", COMMON.filter((a) => a[0] !== "EV_REFRESH").concat([
+            ["EV_REFRESH",          ac_refresh_after_the_writes, null]
+        ])]
     ];
 
     /*---------------------------------------------*