@yuneta/gobj-ui 7.25.4 → 7.25.5

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]
     ];

package/src/form_time_value.js

@@ -6,6 +6,29 @@
  *          them, and they must be each other's inverse: a writable time
  *          column travels back on EVERY save of the record.
  *
+ *          KNOWN LIMIT -- the change of hour. A `datetime-local` holds a
+ *          LOCAL WALL time and no offset, and a wall time is not always
+ *          one instant:
+ *
+ *            - the night the clocks go back (autumn), one hour happens
+ *              twice. "02:30" names two instants an hour apart, and
+ *              `new Date("YYYY-MM-DDT02:30:00")` answers the EARLIER one
+ *              (ECMAScript's "compatible" disambiguation). An epoch in the
+ *              SECOND pass of that hour is shown as 02:30 and comes back
+ *              one hour earlier: saving the record -- any field of it --
+ *              moves a writable time column that holds it by -3600 s.
+ *            - the night the clocks go forward (spring), one hour does not
+ *              exist. No epoch is shown in it, so nothing read comes back
+ *              wrong; a wall time TYPED in it is moved forward by the
+ *              browser.
+ *
+ *          Not fixable here without the offset, which the input cannot
+ *          carry. What is safe: a read-only time column never goes back
+ *          (treedb_write_plan.js, col_goes_back_to_treedb), and a time
+ *          pkey2 goes back as the record had it, never through this
+ *          widget (instance_keys_of). A writable time column edited or
+ *          merely saved inside the repeated hour is the exposed case.
+ *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
  ****************************************************************************/

package/src/form_writes_in_flight.js

@@ -2,18 +2,33 @@
  *          form_writes_in_flight.js
  *
  *          The writes of topic forms a C_YUI_TREEDB_TOPICS view has sent
- *          and not yet answered, by their `form_write` serial. A form that
- *          waits for its answer (form_waits_for_answer) stays open and
- *          busy until the host answers, so the host has to answer EVERY
- *          way a write ends -- and the transport closing under a write in
- *          flight, or a command that never left because there was no
- *          session, are two of them that nobody answered: the form stayed
- *          busy for ever (N8 of the 2026-09-22 review).
+ *          and not yet answered. A form that waits for its answer
+ *          (form_waits_for_answer) stays open and busy until the host
+ *          answers, so the host has to answer EVERY way a write ends --
+ *          and the transport closing under a write in flight, or a
+ *          command that never left because there was no session, are two
+ *          of them that nobody answered: the form stayed busy for ever
+ *          (N8 of the 2026-09-22 review).
+ *
+ *          A write is known by its TOPIC and its `form_write` serial,
+ *          never by the serial alone: each topic has its own form, and
+ *          each form counts its serials from 1. Keyed by the serial, two
+ *          forms with a write in flight at once shared the key "1", the
+ *          first answer settled both, and the transport closing then
+ *          answered only one of them.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
  ***********************************************************************/
 
+/************************************************************
+ *  The key of one write: `<topic>^<serial>`.
+ ************************************************************/
+function form_write_key(topic_name, form_write)
+{
+    return `${topic_name || ""}^${form_write}`;
+}
+
 /************************************************************
  *  A write left: remember whose it is
  ************************************************************/
@@ -22,18 +37,21 @@ function track_form_write(in_flight, form_write, topic_name)
     if(!in_flight || !form_write) {
         return;
     }
-    in_flight[form_write] = topic_name || "";
+    in_flight[form_write_key(topic_name, form_write)] = {
+        form_write: form_write,
+        topic_name: topic_name || ""
+    };
 }
 
 /************************************************************
  *  A write was answered, one way or the other
  ************************************************************/
-function settle_form_write(in_flight, form_write)
+function settle_form_write(in_flight, form_write, topic_name)
 {
     if(!in_flight || !form_write) {
         return;
     }
-    delete in_flight[form_write];
+    delete in_flight[form_write_key(topic_name, form_write)];
 }
 
 /************************************************************
@@ -46,9 +64,10 @@ function abandon_form_writes(in_flight)
     if(!in_flight) {
         return abandoned;
     }
-    Object.keys(in_flight).forEach((serial) => {
-        abandoned.push({form_write: Number(serial), topic_name: in_flight[serial]});
-        delete in_flight[serial];
+    Object.keys(in_flight).forEach((key) => {
+        const w = in_flight[key];
+        abandoned.push({form_write: Number(w.form_write), topic_name: w.topic_name});
+        delete in_flight[key];
     });
     return abandoned;
 }

package/src/form_writes_in_flight.test.js

@@ -11,8 +11,23 @@ describe("form writes in flight", () => {
         const in_flight = {};
         track_form_write(in_flight, 1, "users");
         track_form_write(in_flight, 2, "roles");
-        settle_form_write(in_flight, 1);
-        expect(Object.keys(in_flight)).toEqual(["2"]);
+        settle_form_write(in_flight, 1, "users");
+        expect(abandon_form_writes(in_flight)).toEqual([
+            {form_write: 2, topic_name: "roles"},
+        ]);
+    });
+
+    it("two forms, each at its serial 1: two writes, not one", () => {
+        /*  Each topic's form counts its serials from 1. Keyed by the serial
+         *  alone, the answer of one form settled the other's write, and a
+         *  transport closing then left that one busy for ever.  */
+        const in_flight = {};
+        track_form_write(in_flight, 1, "users");
+        track_form_write(in_flight, 1, "roles");
+        settle_form_write(in_flight, 1, "users");
+        expect(abandon_form_writes(in_flight)).toEqual([
+            {form_write: 1, topic_name: "roles"},
+        ]);
     });
 
     it("the transport closes: every write in flight is abandoned, once (N8)", () => {
@@ -39,7 +54,7 @@ describe("form writes in flight", () => {
 
     it("no map: nothing to do", () => {
         expect(() => track_form_write(null, 1, "x")).not.toThrow();
-        expect(() => settle_form_write(null, 1)).not.toThrow();
+        expect(() => settle_form_write(null, 1, "x")).not.toThrow();
         expect(abandon_form_writes(null)).toEqual([]);
     });
 });

package/src/host_drafts.js

@@ -10,17 +10,42 @@
  *          __system__ still differed from the file in use (N13 of the
  *          2026-09-22 review). The host reads that difference from
  *          C_TREEDB's `saved-schema` (`draft_changed`, by treedb) and
- *          hands it here; the editor applies it to its model.
+ *          hands it here; the editor applies it to its model, in place
+ *          of what the host said before.
+ *
+ *          What `draft_changed` measures depends on the node: the draft
+ *          against the SAVED schema on a node newer than yunetas 7.25.3,
+ *          and against the file IN USE on a 7.25.3 node -- where a topic saved and
+ *          not yet applied is still named, and the editor, which cannot
+ *          tell the two apart, shows it as a draft until the Apply.
  *
  *          Copyright (c) 2026, ArtGins.
  *          All Rights Reserved.
  ***********************************************************************/
 
+/************************************************************
+ *  The topics of `model` the host names as drafts, as
+ *  {topic id: true}: `drafts` is {treedb_name: [topic names]}. A
+ *  treedb or a topic the model does not hold is ignored.
+ *
+ *  What the editor keeps is THIS, apart from what its own session
+ *  wrote, and replaced whole on every EV_DRAFTS: the host is the
+ *  truth after a reload. Folded into the session's marks, a topic the
+ *  host once named stayed a draft after the save that published it.
+ ************************************************************/
+function host_draft_ids(model, drafts)
+{
+    const ids = {};
+    mark_host_drafts(ids, model, drafts);
+    return ids;
+}
+
 /************************************************************
  *  Mark in `written` the topics of `model` the host names as
  *  drafts: `drafts` is {treedb_name: [topic names]}. A treedb or a
  *  topic the model does not hold is ignored. Returns how many were
- *  marked.
+ *  marked. It only ADDS: a caller that must forget what the host
+ *  no longer names starts from an empty map (host_draft_ids()).
  ************************************************************/
 function mark_host_drafts(written, model, drafts)
 {
@@ -63,6 +88,7 @@ function drafts_of_saved_answer(rows, into)
 }
 
 export {
+    host_draft_ids,
     mark_host_drafts,
     drafts_of_saved_answer,
 };

package/src/host_drafts.test.js

@@ -1,5 +1,5 @@
 import {describe, it, expect} from "vitest";
-import {mark_host_drafts, drafts_of_saved_answer} from "./host_drafts.js";
+import {host_draft_ids, mark_host_drafts, drafts_of_saved_answer} from "./host_drafts.js";
 
 const model = {
     treedbs: [
@@ -60,3 +60,26 @@ describe("drafts_of_saved_answer", () => {
         expect(drafts_of_saved_answer(null)).toEqual({});
     });
 });
+
+describe("host_draft_ids", () => {
+
+    it("resolves the host's names on the model, as topic ids", () => {
+        expect(host_draft_ids(model, {treedb_a: ["users"], treedb_b: ["users"]}))
+            .toEqual({"treedb_a^users": true, "treedb_b^users": true});
+    });
+
+    it("is a fresh map every time: what the host stopped naming is gone (M1)", () => {
+        /*  mark_host_drafts() only ADDS, and the editor fed it the same map
+         *  every time: a topic the host named before the Save stayed a
+         *  draft after it.  */
+        const before = host_draft_ids(model, {treedb_a: ["users", "roles"]});
+        const after = host_draft_ids(model, {treedb_a: []});
+        expect(before).toEqual({"treedb_a^users": true, "treedb_a^roles": true});
+        expect(after).toEqual({});
+    });
+
+    it("no model, no drafts: empty", () => {
+        expect(host_draft_ids(null, {treedb_a: ["users"]})).toEqual({});
+        expect(host_draft_ids(model, null)).toEqual({});
+    });
+});

package/src/schema_editor_drafts.wiring.test.js

@@ -0,0 +1,176 @@
+/***********************************************************************
+ *          schema_editor_drafts.wiring.test.js
+ *
+ *      EV_DRAFTS driven through a real C_YUI_SCHEMA_EDITOR on a document
+ *      double. The helper was right and tested; the ACTION folded the
+ *      host's marks into the session's, so a topic the host named before
+ *      a Save stayed a draft after it (M1 of the 2026-09-23 review).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+const {
+    SDATA_END,
+    gclass_create,
+    gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
+    gobj_start, gobj_send_event, gobj_read_attr,
+    gobj_change_state,
+    set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_schema_editor, topic_is_draft} = await import("./c_yui_schema_editor.js");
+
+const logged = [];
+const commands = [];
+
+/*  The yuno's system schema: one treedb, two topics.  */
+const RECORDS = {
+    treedbs: [{id: "db", schema_version: 4}],
+    topics: [
+        {id: "db.users", value: "users", order: 1, pkey: "id", topic_version: 2,
+         treedbs: ["treedbs^db^topics"]},
+        {id: "db.roles", value: "roles", order: 2, pkey: "id", topic_version: 1,
+         treedbs: ["treedbs^db^topics"]},
+    ],
+    cols: [
+        {id: "db.users.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.users^cols"]},
+        {id: "db.roles.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.roles^cols"]},
+    ],
+};
+
+function remote_command_parser(gobj, command, kw, src)
+{
+    commands.push({command, kw, src});
+    return null;
+}
+
+let yuno = null;
+
+beforeAll(() => {
+    gobj_start_up(null, null, null, null, null, null, null);
+    set_log_callback((level, msg) => {
+        logged.push({level: String(level), msg: String(msg)});
+    });
+    gclass_create("C_TEST_HOST", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+    gclass_create(
+        "C_TEST_EDITOR_HOST",
+        [["EV_POSITION_CHANGED", 0], ["EV_RECORD_WRITTEN", 0], ["EV_SCHEMA_CHECKED", 0]],
+        [["ST_IDLE", [
+            ["EV_POSITION_CHANGED", () => 0, null],
+            ["EV_RECORD_WRITTEN",   () => 0, null],
+            ["EV_SCHEMA_CHECKED",   () => 0, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    gclass_create(
+        "C_TEST_REMOTE",
+        [],
+        [["ST_SESSION", []]],
+        {mt_command_parser: remote_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    register_c_yui_schema_editor();
+    yuno = gobj_create_yuno("drafts_yuno", "C_TEST_HOST", {});
+    gobj_start(yuno);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    commands.length = 0;
+});
+
+/*  Answer every `nodes` the editor asked, the way a transport does: the
+ *  request's frame on top of the command_stack.  */
+function answer_the_load(editor, remote)
+{
+    const asked = commands.filter((c) => c.command === "nodes");
+    commands.length = 0;
+    for(const c of asked) {
+        gobj_send_event(editor, "EV_MT_COMMAND_ANSWER", {
+            result: 0,
+            data: RECORDS[c.kw.topic_name],
+            __md_iev__: {command_stack: [{command: "nodes", kw: c.kw}]}
+        }, remote);
+    }
+    return asked.length;
+}
+
+function build(name)
+{
+    const remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
+    gobj_change_state(remote, "ST_SESSION");
+    const host = gobj_create(`${name}_host`, "C_TEST_EDITOR_HOST", {}, yuno);
+    const editor = gobj_create(`${name}_editor`, "C_YUI_SCHEMA_EDITOR", {
+        gobj_remote_yuno: remote,
+        treedb_name: "treedb_system_schema",
+        base_route: "/schemas"
+    }, host);
+    gobj_start(editor);
+    expect(answer_the_load(editor, remote)).toBe(3);
+    gobj_send_event(editor, "EV_SHOW", {subpath: "db"}, host);
+    return {editor, remote, host};
+}
+
+function drafts_on_screen(editor)
+{
+    const $c = gobj_read_attr(editor, "$container");
+    return $c.querySelectorAll(".SCHEMA_TOPIC_VERSION .is-warning").length;
+}
+
+function is_draft(editor, topic_id)
+{
+    return topic_is_draft(editor.priv, {id: topic_id});
+}
+
+describe("EV_DRAFTS: the host is the truth", () => {
+
+    test("the host names a topic: it is a draft, on screen too", () => {
+        const {editor, host} = build("d1");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users"]}}, host);
+        expect(is_draft(editor, "db.users")).toBe(true);
+        expect(is_draft(editor, "db.roles")).toBe(false);
+        expect(drafts_on_screen(editor)).toBe(1);
+    });
+
+    test("the host names none any more (a Save): the mark goes (M1)", () => {
+        /*  It only ever ADDED: after the Save the editor still said
+         *  "unsaved schema changes".  */
+        const {editor, host} = build("d2");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users", "roles"]}}, host);
+        expect(drafts_on_screen(editor)).toBe(2);
+
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: []}}, host);
+        expect(is_draft(editor, "db.users")).toBe(false);
+        expect(is_draft(editor, "db.roles")).toBe(false);
+        expect(drafts_on_screen(editor)).toBe(0);
+    });
+
+    test("a reload keeps what the host said last, and only that", () => {
+        const {editor, remote, host} = build("d3");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["roles"]}}, host);
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(is_draft(editor, "db.roles")).toBe(true);
+        expect(is_draft(editor, "db.users")).toBe(false);
+    });
+
+    test("what this session wrote is not cleared by the host's answer", () => {
+        const {editor, host} = build("d4");
+        editor.priv.written["db.users"] = true;     /*  a write of this session  */
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {}}, host);
+        expect(is_draft(editor, "db.users")).toBe(true);
+    });
+
+    test("no error logged on the way", () => {
+        const {editor, host} = build("d5");
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {db: ["users"]}}, host);
+        gobj_send_event(editor, "EV_DRAFTS", {drafts: {}}, host);
+        expect(logged.filter((l) => l.level === "error").map((l) => l.msg)).toEqual([]);
+    });
+});