@yuneta/gobj-ui 7.25.4 → 7.25.6

package/package.json

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

package/src/c_yui_schema_editor.js

@@ -26,8 +26,9 @@
  *      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; the host's EV_REFRESH after a save is
- *      what forgets it.
+ *      wrote and has not saved (the host's EV_REFRESH after a save is
+ *      what forgets it) and what the host says is not saved (EV_DRAFTS,
+ *      replaced whole each time it is sent).
  *
  *      WHAT ELSE IS HERE, and why each is here and not somewhere else:
  *
@@ -69,6 +70,12 @@
  *      `update-node` / `delete-node` on the treedb service, and it may
  *      be a routing adapter two hops away (the agent console's
  *      C_AGENT_TREEDB_LINK) — this view cannot tell, and must not.
+ *      A DROP of it (the host's EV_TRANSPORT_STATE, or a failure that
+ *      arrives while the transport is out of session) ends the load or
+ *      the write it cut, and the model is asked again when the session
+ *      is back. Every request carries its round (`round` for a load,
+ *      `write` for a write) in `__md_command__`, so an answer of what
+ *      was cut is ignored instead of counted in the next one.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
@@ -107,13 +114,14 @@ import {
     clean_name,
     msg_iev_get_stack,
     kw_get_str,
+    kw_get_int,
     kw_get_dict,
     is_object,
     is_array,
     empty_string,
 } from "@yuneta/gobj-js";
 import {yui_tint} from "./bulma_tint.js";
-import {mark_host_drafts} from "./host_drafts.js";
+import {host_draft_ids} from "./host_drafts.js";
 
 import "./c_yui_schema_editor.css";
 
@@ -197,6 +205,7 @@ let PRIVATE_DATA = {
     model:          null,   /*  build_schema_model() of the above  */
     pending:        0,      /*  `nodes` requests still in flight  */
     load_error:     "",
+    load_round:     0,      /*  which load an answer belongs to: echoed as `round`  */
 
     /*  Where the operator is. The url carries it; these mirror it.  */
     treedb_id:      "",
@@ -207,6 +216,8 @@ let PRIVATE_DATA = {
      *  version still has to move.  */
     baseline:       null,   /*  {topic id: topic_version} at load time  */
     written:        null,   /*  {topic id: true}  */
+    host_drafts:    null,   /*  {treedb: [topic names]}, the host's last EV_DRAFTS  */
+    host_ids:       null,   /*  host_drafts resolved on the model, {topic id: true}  */
     order_undo:     null,   /*  {topic id: [{id, order}]} before the first drag  */
 
     /*  Children and overlays  */
@@ -217,7 +228,9 @@ let PRIVATE_DATA = {
     save_queue:     null,
     save_return:    "",
     save_wrote:     false,
+    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  */
 
     /*  A position that arrived while a write was in flight  */
     pending_seg:    null,
@@ -250,6 +263,7 @@ function mt_create(gobj)
     priv.baseline = {};
     priv.written = {};
     priv.host_drafts = {};  /*  what the host says is a draft, {treedb: [topics]} (EV_DRAFTS)  */
+    priv.host_ids = {};     /*  the same, as {topic id: true} of the model  */
     priv.save_queue = [];
 
     build_ui(gobj);
@@ -454,6 +468,7 @@ function request_model(gobj)
     priv.records = {treedbs: [], topics: [], cols: []};
     priv.load_error = "";
     priv.pending = 0;
+    priv.load_round++;
     gobj_change_state(gobj, "ST_LOADING");
     show_notice(gobj, "loading the schemas");
 
@@ -461,7 +476,7 @@ function request_model(gobj)
         if(remote_command(gobj, "nodes", {
             topic_name: topic_name,
             options:    {list_dict: true}
-        }) === 0) {
+        }, {round: priv.load_round}) === 0) {
             priv.pending++;
         }
     }
@@ -483,7 +498,7 @@ function request_model(gobj)
  *  answer says which topic it is about, since the command is
  *  `nodes` for all three.
  ***************************************************************/
-function remote_command(gobj, command, kw)
+function remote_command(gobj, command, kw, tag)
 {
     let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
     let treedb_name = gobj_read_str_attr(gobj, "treedb_name");
@@ -508,11 +523,11 @@ function remote_command(gobj, command, kw)
      *  whichever one is under this view — and `record_id` is here and
      *  NOT at the top level because a delete answers with nothing, and a
      *  parameter the treedb does not know has no business travelling.  */
-    full_kw.__md_command__ = {
+    full_kw.__md_command__ = Object.assign({
         purpose:    PURPOSE,
         topic_name: (kw && kw.topic_name) || "",
         record_id:  (kw && kw.record_id) || ""
-    };
+    }, tag || {});
     delete full_kw.record_id;
 
     let ret = gobj_command(remote, command, full_kw, gobj);
@@ -564,6 +579,7 @@ function start_measuring(gobj)
 
     priv.baseline = {};
     priv.written = {};
+    priv.host_ids = {};
 
     if(!priv.model) {
         return;
@@ -573,29 +589,39 @@ function start_measuring(gobj)
             priv.baseline[topic.id] = topic.topic_version;
         }
     }
-    /*  A draft is a draft after a reload too: what the host said stays
-     *  marked (host_drafts.js) until the host says otherwise.  */
-    mark_host_drafts(priv.written, priv.model, priv.host_drafts);
+    /*  A draft is a draft after a reload too: what the host said last
+     *  is resolved against the new model (host_drafts.js), apart from
+     *  what this session writes, until the host says otherwise.  */
+    priv.host_ids = host_draft_ids(priv.model, priv.host_drafts);
 }
 
 /***************************************************************
- *  "This topic was written in this session and is not saved."
+ *  "This topic holds an edit that is not saved."
  *
  *  An edit is a DRAFT: it moves no version and reaches no treedb
  *  until the host saves it (C_TREEDB's save-schema, which raises the
- *  versions of what changed) -- and the save makes the host send
- *  EV_REFRESH, whose reload is what forgets the drafts.
+ *  versions of what changed). Two sources say a topic is one, and
+ *  they are kept APART because they are forgotten differently:
+ *    - `written`: what THIS session wrote since the model was loaded
+ *      (a reload, the host's EV_REFRESH, forgets it -- the store says
+ *      what is left);
+ *    - `host_ids`: what the host said last (EV_DRAFTS), replaced WHOLE
+ *      by the next EV_DRAFTS. Folded into `written`, a topic the host
+ *      named once stayed a draft after the Save that published it.
  *
  *  ONE predicate, because it is asked in three places -- the topic
  *  list draws a chip with it, the column view a banner, the export
  *  a warning -- and copies of a rule are how they drift.
  ***************************************************************/
-function topic_is_draft(written, topic)
+function topic_is_draft(priv, topic)
 {
-    if(!topic || !written) {
+    if(!topic || !priv) {
         return false;
     }
-    return written[topic.id]? true: false;
+    if(priv.written && priv.written[topic.id]) {
+        return true;
+    }
+    return (priv.host_ids && priv.host_ids[topic.id])? true: false;
 }
 
 /***************************************************************
@@ -1050,7 +1076,7 @@ function render_topics(gobj, $body)
     let twice = repeated_names(treedb.topics);
     let $rows = [];
     for(let topic of treedb.topics) {
-        let pending = topic_is_draft(priv.written, topic);
+        let pending = topic_is_draft(priv, topic);
         /*  Two topics of one name: the id is what tells them apart, and
          *  it is what the url has to carry — addressing by name would
          *  open the first one whichever row was clicked.  */
@@ -1256,7 +1282,7 @@ function draft_banner(gobj, topic)
 {
     let priv = gobj.priv;
 
-    if(!topic_is_draft(priv.written, topic)) {
+    if(!topic_is_draft(priv, topic)) {
         return null;
     }
     if(is_readonly(gobj)) {
@@ -1997,7 +2023,7 @@ function open_report(gobj, findings, treedb_id)
 function open_export(gobj, treedb)
 {
     let priv = gobj.priv;
-    let drafts = treedb.topics.some((topic) => topic_is_draft(priv.written, topic));
+    let drafts = treedb.topics.some((topic) => topic_is_draft(priv, topic));
     let c_text = schema_to_c(treedb);
     let json_text = JSON.stringify(schema_to_json(treedb), null, 4);
 
@@ -2347,17 +2373,80 @@ function run_next_write(gobj)
     let command = write_command(write.op);
     let options = write_options(write.op);
 
+    priv.write_tag++;
     if(remote_command(gobj, command, {
         topic_name: write.topic_name,
         record:     write.record,
         options:    options,
         record_id:  write.record.id || ""
-    }) < 0) {
+    }, {write: priv.write_tag}) < 0) {
         return end_writes(gobj, t("cannot reach the treedb"));
     }
     return 0;
 }
 
+/***************************************************************
+ *  Does the transport say it is in session? The state the library
+ *  reads off every transport (C_IEVENT_CLI and the routing adapters
+ *  name it the same).
+ ***************************************************************/
+function transport_in_session(gobj)
+{
+    let remote = gobj_read_pointer_attr(gobj, "gobj_remote_yuno");
+
+    return !!remote && gobj_current_state(remote) === "ST_SESSION";
+}
+
+/***************************************************************
+ *  Is this answer of the load in flight, or of the write in
+ *  flight? Each request carries its round in `__md_command__`, and
+ *  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.
+ ***************************************************************/
+function is_current_load(gobj, md)
+{
+    return gobj_current_state(gobj) === "ST_LOADING" &&
+        kw_get_int(gobj, md, "round", 0, 0) === gobj.priv.load_round;
+}
+
+function is_current_write(gobj, md)
+{
+    return gobj_current_state(gobj) === "ST_SAVING" &&
+        kw_get_int(gobj, md, "write", 0, 0) === gobj.priv.write_tag;
+}
+
+/***************************************************************
+ *  The transport dropped under a load or a write: its answers
+ *  will never come. The load goes back to the screen it replaced
+ *  (or to "not connected" when there was none), the write ends
+ *  with the drop said -- whether it landed is unknown -- and both
+ *  mark the model to be asked again when the session is back.
+ *  Bumping the round makes an answer of what was cut stale.
+ ***************************************************************/
+function transport_dropped(gobj)
+{
+    let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
+
+    priv.reload_on_open = true;
+    if(state === "ST_SAVING") {
+        priv.write_tag++;
+        return end_writes(gobj, "the connection dropped during the write");
+    }
+    if(state === "ST_LOADING") {
+        priv.load_round++;
+        priv.pending = 0;
+        priv.load_error = "";
+        if(priv.model) {
+            return go(gobj, priv.treedb_id, priv.topic_name, priv.diagram, false);
+        }
+        gobj_change_state(gobj, "ST_IDLE");
+        render(gobj);
+    }
+    return 0;
+}
+
 /***************************************************************
  *  The queue is done, or gave up. Either way the model is what
  *  the answers made it, so the screen is redrawn from it and the
@@ -2612,8 +2701,28 @@ function ac_mt_command_answer(gobj, event, kw, src)
         return 0;       /*  another panel's answer on a shared transport  */
     }
 
+    /*  A failure while the transport is not in session is the DROP, not a
+     *  refusal: a routing adapter settles what it had in flight when its
+     *  session closes, and that can arrive before the host's
+     *  EV_TRANSPORT_STATE. Read as a refusal, the write it ended looked
+     *  refused, and the reconnect did not reload a model it may have
+     *  changed.  */
+    if(result < 0 && !transport_in_session(gobj) &&
+            (gobj_current_state(gobj) === "ST_LOADING" ||
+             gobj_current_state(gobj) === "ST_SAVING")) {
+        if((command === "nodes" && is_current_load(gobj, md)) ||
+                (command !== "nodes" && is_current_write(gobj, md))) {
+            return transport_dropped(gobj);
+        }
+    }
+
     if(command === "nodes") {
         let topic_name = kw_get_str(gobj, md, "topic_name", "", 0);
+        if(!is_current_load(gobj, md)) {
+            log_warning(`${gobj_short_name(gobj)}: 'nodes' of '${topic_name}' answered ` +
+                `for a load that is over: ignored`);
+            return 0;
+        }
         priv.pending--;
         if(result < 0) {
             priv.load_error = comment || t("cannot load the schemas");
@@ -2647,6 +2756,11 @@ function ac_mt_command_answer(gobj, event, kw, src)
 
     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) {
             return end_writes(gobj, comment || t("the treedb refused the write"));
         }
@@ -2728,16 +2842,31 @@ function ac_hide(gobj, event, kw, src)
 }
 
 /***************************************************************
- *  The session came up or went down. The model stays either way
- *  — a schema does not change under you — but a first load may
- *  have had no transport to run on.
+ *  The session came up or went down. The model stays -- a schema
+ *  does not change under you -- unless the drop cut a load or a
+ *  write (transport_dropped()): then it is asked again on the way
+ *  back, as it is when a first load had no transport to run on.
+ *
+ *  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).
  ***************************************************************/
 function ac_transport_state(gobj, event, kw, src)
 {
     let priv = gobj.priv;
+    let state = gobj_current_state(gobj);
 
     priv.connected = !!(kw && kw.connected);
-    if(priv.connected && !priv.model && gobj_current_state(gobj) !== "ST_LOADING") {
+    if(!priv.connected) {
+        if(state === "ST_LOADING" || state === "ST_SAVING") {
+            return transport_dropped(gobj);
+        }
+        render_toolbar(gobj);
+        return 0;
+    }
+    if((!priv.model || priv.reload_on_open) &&
+            state !== "ST_LOADING" && state !== "ST_SAVING") {
+        priv.reload_on_open = false;
         return request_model(gobj);
     }
     render_toolbar(gobj);
@@ -2762,20 +2891,24 @@ function ac_refresh(gobj, event, kw, src)
 
 /***************************************************************
  *  {drafts: {treedb_name: [topic names]}} -- the host says which
- *  topics hold a draft in __system__ that the file in use does not
- *  have (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 from the file (N13 of the 2026-09-22 review).
- *  Replaces what the host said before; what this session wrote
- *  stays marked.
+ *  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).
+ *
+ *  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
+ *  stays marked: it is kept apart (see topic_is_draft()).
  ***************************************************************/
 function ac_drafts(gobj, event, kw, src)
 {
     let priv = gobj.priv;
 
     priv.host_drafts = (kw && kw.drafts && typeof kw.drafts === "object")? kw.drafts: {};
-    mark_host_drafts(priv.written, priv.model, priv.host_drafts);
+    priv.host_ids = host_draft_ids(priv.model, priv.host_drafts);
     if(priv.model) {
         render(gobj);
     }

package/src/c_yui_shell.js

@@ -43,6 +43,8 @@ import {
     createElement2, empty_string, is_object, is_array, is_string,
     refresh_language,
     is_gobj,
+    gobj_has_event,
+    gobj_is_destroying,
 } from "@yuneta/gobj-js";
 
 import {
@@ -174,6 +176,10 @@ let PRIVATE_DATA = {
      *  backend-connected state.  State is host/event-driven (unlike
      *  the avatar provider it is a setter, not a pull callback). */
     conn_nodes:      [],
+    /*  The last state yui_shell_set_connection_state() was told, null
+     *  while nobody told it anything: EV_CONNECTION_STATE goes out on an
+     *  EDGE, not on every call.  */
+    connected:       null,
     /*  Currently open toolbar dropdown panel, if any.  Tracked here
      *  so a second click on any trigger (or programmatic close) can
      *  tear down the previous one through the same code path. */
@@ -3033,11 +3039,34 @@ function yui_shell_set_submenu(shell_gobj, parent_item_id, items)
 /*---------------------------------------------*
  *          Global methods table
  *---------------------------------------------*/
+/***************************************************************
+ *  EV_CONNECTION_STATE is an OPTIONAL fact: a view that waits for a
+ *  backend answer subscribes to it by name. An app that subscribed
+ *  to EVERY event of its shell with one attr (`subscriber`) did not
+ *  ask for it and does not declare it -- published to it anyway, the
+ *  event would be an FSM error in the app on every connection edge,
+ *  and adding it to the shell a breaking change for every such app.
+ *  So it reaches only the subscribers that declare it. Every other
+ *  event of the shell goes out as before.
+ ***************************************************************/
+function mt_publication_pre_filter(gobj, subs, event, kw)
+{
+    if(event !== "EV_CONNECTION_STATE") {
+        return 1;
+    }
+    let subscriber = subs && subs.subscriber;
+    if(!subscriber || !gobj_has_event(subscriber, event, 0)) {
+        return 0;
+    }
+    return 1;
+}
+
 const gmt = {
-    mt_create:  mt_create,
-    mt_start:   mt_start,
-    mt_stop:    mt_stop,
-    mt_destroy: mt_destroy
+    mt_create:                  mt_create,
+    mt_start:                   mt_start,
+    mt_stop:                    mt_stop,
+    mt_destroy:                 mt_destroy,
+    mt_publication_pre_filter:  mt_publication_pre_filter
 };
 
 function create_gclass(gclass_name)
@@ -3088,6 +3117,13 @@ function create_gclass(gclass_name)
          *  re-renders its own translated parts.  */
         ["EV_LANGUAGE_CHANGED",       event_flag_t.EVF_OUTPUT_EVENT
                                      |event_flag_t.EVF_PUBLIC_EVENT
+                                     |event_flag_t.EVF_NO_WARN_SUBS],
+
+        /*  The app's backend connection went up or down
+         *  (yui_shell_set_connection_state), {connected}. Delivered only
+         *  to the subscribers that declare it: see
+         *  mt_publication_pre_filter().  */
+        ["EV_CONNECTION_STATE",       event_flag_t.EVF_OUTPUT_EVENT
                                      |event_flag_t.EVF_NO_WARN_SUBS]
     ];
 
@@ -3552,14 +3588,31 @@ function yui_shell_language_changed(shell_gobj)
  ************************************************************/
 function yui_shell_set_connection_state(shell_gobj, connected)
 {
+    if(!shell_gobj || !is_gobj(shell_gobj) || gobj_is_destroying(shell_gobj)) {
+        return;
+    }
     let priv = shell_gobj.priv;
-    if(!priv || !is_array(priv.conn_nodes)) {
+    if(!priv) {
         return;
     }
     let on = !!connected;
-    for(let $n of priv.conn_nodes) {
-        $n.classList.toggle("is-connected", on);
-        $n.classList.toggle("is-disconnected", !on);
+    let changed = (priv.connected !== on);
+    priv.connected = on;
+    if(is_array(priv.conn_nodes)) {
+        for(let $n of priv.conn_nodes) {
+            $n.classList.toggle("is-connected", on);
+            $n.classList.toggle("is-disconnected", !on);
+        }
+    }
+    /*  The fact goes out as well, for the views: a write a view sent
+     *  before the backend dropped is never answered, and the view that
+     *  waits for it (a topic form's Save) learns the drop from HERE --
+     *  it holds no subscription of its own to the transport, because
+     *  subscribing to a C_IEVENT_CLI forwards the subscription to the
+     *  backend. Only an EDGE is published: the app calls this on every
+     *  reconnect attempt too.  */
+    if(changed) {
+        gobj_publish_event(shell_gobj, "EV_CONNECTION_STATE", {connected: on});
     }
 }
 

package/src/c_yui_treedb_topic_with_form.js

@@ -99,7 +99,8 @@ import {t} from "i18next";
 import {yui_toolbar_icon} from "./yui_toolbar.js";
 
 import {
-    plan_treedb_writes, READONLY_FORM_TOOLBAR, col_goes_back_to_treedb
+    plan_treedb_writes, READONLY_FORM_TOOLBAR, col_goes_back_to_treedb,
+    instance_keys_of
 } from "./treedb_write_plan.js";
 import {
     yui_file_read, yui_files_manifest, yui_file_id_label, yui_file_size_label
@@ -2395,6 +2396,10 @@ function open_form_dialog(gobj, mode, record)
                  style: 'display:flex; flex-direction:column; height:100%;'}, []]
     );
 
+    /*  The instance this form writes to, kept as the record HAD it: the
+     *  widget is not trusted with an address (instance_keys_of()).  */
+    priv.form_instance = (form_mode === "update")? instance_keys_of(record, desc) : null;
+
     let form_plan = write_plan(gobj);
     let form = gobj_create_pure_child(
         "form_" + clean_name(gobj_name(gobj)),
@@ -2508,6 +2513,7 @@ function teardown_form_child(gobj)
     priv.reading_files = 0;     // a read in flight lands on nobody
     priv.awaiting_write = 0;    // and so does the answer of a write
     priv.form_busy = {busy: false};     // its toolbar goes with it
+    priv.form_instance = null;
     if(priv.form) {
         if(gobj_is_running(priv.form)) {
             gobj_stop(priv.form);
@@ -4313,6 +4319,11 @@ function publish_treedb_write(gobj, mode, record, jn_files, form_write)
         topic_name: gobj_read_str_attr(gobj, "topic_name"),
         record: strip_read_only_cols(gobj, record)
     };
+    if(mode !== "create" && gobj.priv.form_instance) {
+        /*  The pkey2 names the instance: the value the record had, not
+         *  the one that came back through a datetime-local.  */
+        Object.assign(kw_write.record, gobj.priv.form_instance);
+    }
     if(form_write) {
         /*  The serial the host echoes back with the answer  */
         kw_write.form_write = form_write;

package/src/c_yui_treedb_topics.js

@@ -156,10 +156,11 @@ let __gclass__ = null;
  ***************************************************************/
 function mt_create(gobj)
 {
-    /*  The writes of topic forms sent and not yet answered, by serial
-     *  (form_writes_in_flight): answered refused when the transport
-     *  closes under them.  */
+    /*  The writes of topic forms sent and not yet answered, by topic
+     *  and serial (form_writes_in_flight): answered refused when the
+     *  transport closes under them.  */
     gobj.priv.form_writes = {};
+    gobj.priv.conn_shell = null;    /*  the shell whose EV_CONNECTION_STATE we hear  */
 
     build_ui(gobj);
 
@@ -178,6 +179,17 @@ function mt_create(gobj)
  ***************************************************************/
 function mt_start(gobj)
 {
+    /*  The app's backend connection, as the app tells its shell
+     *  (yui_shell_set_connection_state). A write in flight when it drops
+     *  is never answered, and its form waited for ever in every host
+     *  that did not forward EV_TRANSPORT_STATE -- wattyzer and yunovatios
+     *  among them (M8 of the 2026-09-23 review). The transport itself is
+     *  not subscribed to: see ac_transport_state().  */
+    let shell = yui_shell_of(gobj);
+    if(shell) {
+        gobj_subscribe_event(shell, "EV_CONNECTION_STATE", {}, gobj);
+        gobj.priv.conn_shell = shell;
+    }
     request_treedb_descs(gobj);
 }
 
@@ -186,6 +198,14 @@ function mt_start(gobj)
  ***************************************************************/
 function mt_stop(gobj)
 {
+    let priv = gobj.priv;
+    if(priv.conn_shell) {
+        if(!gobj_is_destroying(priv.conn_shell)) {
+            gobj_unsubscribe_event(priv.conn_shell, "EV_CONNECTION_STATE", {}, gobj);
+        }
+        priv.conn_shell = null;
+    }
+
     /*  Retire our site-map sub-routes so a torn-down view leaves no
      *  stale children in the map (ROUTING.md contributor). */
     let shell = yui_shell_of(gobj);
@@ -2077,7 +2097,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
                         {topic_name: failed_topic}, gobj);
                 }
                 settle_form_write(gobj.priv.form_writes,
-                    kw_get_int(gobj, kw_command, "form_write", 0, 0));
+                    kw_get_int(gobj, kw_command, "form_write", 0, 0), failed_topic);
                 answer_form_write(
                     gobj,
                     get_gobj_formtable(gobj, failed_topic),
@@ -2177,7 +2197,8 @@ function ac_mt_command_answer(gobj, event, kw, src)
                 command:     command
             });
             settle_form_write(gobj.priv.form_writes,
-                kw_get_int(gobj, kw_command, "form_write", 0, 0));
+                kw_get_int(gobj, kw_command, "form_write", 0, 0),
+                kw_get_str(gobj, kw_command, "topic_name", "", 0));
             answer_form_write(
                 gobj,
                 get_gobj_formtable(gobj, kw_get_str(gobj, kw_command, "topic_name", "", 0)),
@@ -2413,11 +2434,19 @@ function ac_back_to_topics(gobj, event, kw, src)
 }
 
 /************************************************************
- *  The host (C_TREEDB_VIEW) forwards the backend transport edges here so the
- *  toolbar can disable the JSON viewers the moment the session drops (and
- *  re-enable them on reconnect) — the library view must not subscribe to the
- *  C_IEVENT_CLI itself (that forwards the subscription upstream and breaks
- *  the session).
+ *  A backend transport edge, from either of two places:
+ *    - EV_TRANSPORT_STATE, forwarded by a host that keeps one
+ *      transport per view (gui_treedb's C_TREEDB_VIEW, gui_agent's
+ *      C_AGENT_TREEDB_VIEW);
+ *    - EV_CONNECTION_STATE, published by the SHELL when the app tells
+ *      it its backend went up or down (yui_shell_set_connection_state),
+ *      which is what every single-backend app already does for the
+ *      toolbar dot. No host has to remember anything for this one.
+ *  Both can arrive for one edge; what is done here is idempotent.
+ *  The toolbar disables the JSON viewers the moment the session drops
+ *  (and re-enables them on reconnect). The library view must not
+ *  subscribe to the C_IEVENT_CLI itself: that forwards the subscription
+ *  upstream and breaks the session.
  ************************************************************/
 function ac_transport_state(gobj, event, kw, src)
 {
@@ -3042,6 +3071,7 @@ function create_gclass(gclass_name)
             ["EV_HIDE",                 ac_hide,                    null],
             ["EV_BACK_TO_TOPICS",       ac_back_to_topics,          null],
             ["EV_TRANSPORT_STATE",      ac_transport_state,         null],
+            ["EV_CONNECTION_STATE",     ac_transport_state,         null],
         ]]
     ];
 
@@ -3077,6 +3107,7 @@ function create_gclass(gclass_name)
         ["EV_HIDE",                 0],
         ["EV_BACK_TO_TOPICS",       0],
         ["EV_TRANSPORT_STATE",      0],
+        ["EV_CONNECTION_STATE",     0],
         ["EV_TOPIC_SELECTED",
             event_flag_t.EVF_OUTPUT_EVENT | event_flag_t.EVF_NO_WARN_SUBS]
     ];