@yuneta/gobj-ui 7.25.15 → 7.25.17

package/src/c_yui_treedb_graph.js

@@ -1520,6 +1520,12 @@ function treedb_update_node(gobj, treedb_name, topic_name, record, options)
     kw.__md_command__ = { // Data to be returned
         topic_name: topic_name,
     };
+    /*  The answer carries this echo and nothing else of the request: a
+     *  refused `__graphs__` write is told to the engine by the topic it
+     *  arranges, so that topic has to travel here.  */
+    if(topic_name === "__graphs__") {
+        kw.__md_command__.graph_topic = graph_topic_of(record);
+    }
 
     let ret = gobj_command(priv.gobj_remote_yuno,
         command,
@@ -2118,7 +2124,7 @@ function ac_mt_command_answer(gobj, event, kw, src)
             if(result < 0 && command === "update-node") {
                 graphs_write_refused(gobj,
                     kw_get_str(gobj, kw_command, "topic_name", "", 0),
-                    kw_get_dict(gobj, kw_command, "record", {}, 0));
+                    kw_get_str(gobj, kw_command, "graph_topic", "", 0));
             }
             if(result >= 0 &&
                 kw_get_str(gobj, kw_command, "topic_name", "", 0) !== "__graphs__") {
@@ -2486,7 +2492,7 @@ function ac_update_node(gobj, event, kw, src)
     let options = kw.options || {};
 
     if(refuse_if_readonly(gobj, event)) {
-        graphs_write_refused(gobj, topic_name, record);
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
         return -1;
     }
 
@@ -2496,7 +2502,7 @@ function ac_update_node(gobj, event, kw, src)
     if(topic_name === "__graphs__" && !is_connected(gobj)) {
         log_warning(`${gobj_short_name(gobj)}: no session, the arrangement ` +
             `was not sent`);
-        graphs_write_refused(gobj, topic_name, record);
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
         return -1;
     }
 
@@ -2508,11 +2514,22 @@ function ac_update_node(gobj, event, kw, src)
         options
     );
     if(ret < 0) {
-        graphs_write_refused(gobj, topic_name, record);
+        graphs_write_refused(gobj, topic_name, graph_topic_of(record));
     }
     return ret;
 }
 
+/************************************************************
+ *  The topic a `__graphs__` record arranges.
+ ************************************************************/
+function graph_topic_of(record)
+{
+    if(!record || typeof record !== "object") {
+        return "";
+    }
+    return record.topic || record.id || "";
+}
+
 /************************************************************
  *  A write of `__graphs__` did not land. The engine
  *  (C_G6_NODES_TREE) took it for granted when it left -- nothing
@@ -2520,14 +2537,13 @@ function ac_update_node(gobj, event, kw, src)
  *  writes the topic again. Other topics are the operator's data:
  *  the answer's error says what happened to them.
  ************************************************************/
-function graphs_write_refused(gobj, topic_name, record)
+function graphs_write_refused(gobj, topic_name, topic)
 {
     let priv = gobj.priv;
 
     if(topic_name !== "__graphs__") {
         return;
     }
-    let topic = (record && typeof record === "object") ? (record.topic || record.id) : "";
     if(!topic) {
         log_error(`${gobj_short_name(gobj)}: a refused __graphs__ write names no topic`);
         return;

package/src/form_busy.test.js

@@ -53,7 +53,7 @@ describe("set_toolbar_busy", () => {
         expect(tb.save.classList.contains("is-loading")).toBe(false);
     });
 
-    it("busy twice then free: Save and Cancel come back (N9)", () => {
+    it("busy twice then free: Save and Cancel come back", () => {
         /*  A record with a picked file went busy for the read and busy
          *  again for the write; the second pass recorded the buttons the
          *  first had disabled as disabled on their own, and the free of a

package/src/form_writes_in_flight.test.js

@@ -30,7 +30,7 @@ describe("form writes in flight", () => {
         ]);
     });
 
-    it("the transport closes: every write in flight is abandoned, once (N8)", () => {
+    it("the transport closes: every write in flight is abandoned, once", () => {
         /*  The form of each one is answered EV_WRITE_REFUSED by the host
          *  and stays open on what was typed; before, it stayed busy for
          *  ever, because nobody answered a write whose answer was lost.  */

package/src/g6_graphs_write_owed.wiring.test.js

@@ -0,0 +1,200 @@
+/***********************************************************************
+ *          g6_graphs_write_owed.wiring.test.js
+ *
+ *      A `__graphs__` write that did not land is OWED, and the Save
+ *      button says so until a Save writes it again.
+ *
+ *      EV_GRAPHS_WRITE_REFUSED lit the Save (in edition only), and
+ *      the next repaint of the history buttons put it out again:
+ *      update_history_buttons() decides the Save from
+ *      `history.canUndo()` alone, and it runs on every history
+ *      change, every change of mode and every redraw of the theme.
+ *      A refusal heard in reading was never shown at all.
+ *
+ *      The real C_G6_NODES_TREE, on a fake G6 graph: only the history
+ *      plugin and the Save button are what is looked at.
+ *
+ *          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, SDATA_END, data_type_t,
+    gclass_create, gobj_start_up, gobj_create_yuno, gobj_create_pure_child,
+    gobj_send_event, register_c_timer, set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_g6_nodes_tree} = await import("./c_g6_nodes_tree.js");
+
+const logged = [];
+const published = [];
+
+/*  G6, as far as these paths ask it: plugins by key, and nothing on
+ *  screen. Any other method answers undefined.  */
+function fake_graph(history)
+{
+    let plugins = [];
+    const known = {
+        rendered: true,
+        getPlugins: () => plugins,
+        setPlugins: (fn) => {
+            plugins = (typeof fn === "function") ? fn(plugins) : fn;
+        },
+        getPluginInstance: (key) => (key === "history") ? history : {on() {}, off() {}},
+        updatePlugin: () => {},
+        getBehaviors: () => [],
+        setBehaviors: () => {},
+        getData: () => ({nodes: [], edges: [], combos: []}),
+        getZoom: () => 1,
+    };
+    return new Proxy(known, {
+        get: (t, k) => (k in t) ? t[k] : (() => undefined)
+    });
+}
+
+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)});
+    });
+    register_c_timer();
+    register_c_g6_nodes_tree();
+    /*  The host: what the tree publishes lands here.  */
+    const host_events = ["EV_UPDATE_NODE"];
+    gclass_create(
+        "C_TEST_GRAPH_HOST",
+        host_events.map((e) => [e, 0]),
+        [["ST_IDLE", host_events.map((e) => [e, (gobj, ev, kw) => {
+            published.push({event: ev, kw: kw});
+            return 0;
+        }, null])]],
+        {}, 0,
+        [SDATA(data_type_t.DTP_STRING, "node_uuid", 0, "test-node-uuid", ""), SDATA_END()],
+        {}, 0, 0, 0, 0
+    );
+    yuno = gobj_create_yuno("owed_yuno", "C_TEST_GRAPH_HOST", {});
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    published.length = 0;
+});
+
+let seq = 0;
+
+/*  A tree whose `users` arrangement the backend holds, in `mode`,
+ *  with a Save button in its container and a history that has
+ *  nothing to undo.  */
+function build(mode)
+{
+    const $container = document.createElement("div");
+    const tree = gobj_create_pure_child(`tree_${++seq}`, "C_G6_NODES_TREE",
+        {$container: $container}, yuno);
+    const listeners = [];
+    const history = {
+        undo: false,
+        canUndo() {
+            return this.undo;
+        },
+        canRedo: () => false,
+        on: (ev, fn) => {
+            listeners.push(fn);
+        },
+        clear() {
+            this.undo = false;
+        }
+    };
+    tree.priv.graph = fake_graph(history);
+    tree.priv.graph_rendered = true;
+    tree.priv.treedb_name = "treedb_x";
+    tree.priv._graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+    tree.priv._saved_graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+
+    const $save = document.createElement("div");
+    $save.className = "EV_SAVE_GRAPH";
+    $save.setAttribute("disabled", "");
+    $container.appendChild($save);
+
+    gobj_send_event(tree, "EV_SET_OPERATION_MODE", {operation_mode: mode}, tree);
+    return {
+        tree,
+        lit: () => !$save.hasAttribute("disabled"),
+        history_changed: () => {
+            for(const fn of listeners) {
+                fn();
+            }
+        }
+    };
+}
+
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+describe("a refused __graphs__ write keeps the Save lit", () => {
+
+    test("in edition: a history change does not put it out", () => {
+        const g = build("edition");
+        expect(g.lit()).toBe(false);
+
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+        expect(g.lit()).toBe(true);
+
+        g.history_changed();                /*  nothing to undo  */
+        expect(g.lit()).toBe(true);
+
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        expect(g.lit()).toBe(true);
+        expect(errors()).toEqual([]);
+    });
+
+    test("heard in reading, it is shown on entering edition", () => {
+        const g = build("reading");
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        expect(g.lit()).toBe(true);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the Save writes it again, and then the Save goes dark", () => {
+        const g = build("edition");
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const writes = published.filter((p) => p.event === "EV_UPDATE_NODE");
+        expect(writes.map((w) => w.kw.record.id)).toEqual(["users"]);
+        expect(g.lit()).toBe(false);
+
+        g.history_changed();
+        expect(g.lit()).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("refused again after that Save: lit again", () => {
+        const g = build("edition");
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+
+        g.history_changed();
+        expect(g.lit()).toBe(true);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a reload forgets it: the view holds what the backend holds", () => {
+        const g = build("edition");
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+        gobj_send_event(g.tree, "EV_CLEAR_DATA", {}, g.tree);
+        /*  What the load does once the data is in again.  */
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        expect(g.lit()).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+});

package/src/host_drafts.test.js

@@ -15,7 +15,7 @@ const model = {
 
 describe("mark_host_drafts", () => {
 
-    it("marks the topics the host names, by treedb (N13)", () => {
+    it("marks the topics the host names, by treedb", () => {
         /*  The mark lived in the memory of one session: after a reload the
          *  editor showed no draft while __system__ still differed from the
          *  file in use. Rebuilt from the host's data.  */
@@ -68,7 +68,7 @@ describe("host_draft_ids", () => {
             .toEqual({"treedb_a^users": true, "treedb_b^users": true});
     });
 
-    it("is a fresh map every time: what the host stopped naming is gone (M1)", () => {
+    it("is a fresh map every time: what the host stopped naming is gone", () => {
         /*  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.  */

package/src/schema_editor_drafts.wiring.test.js

@@ -138,7 +138,7 @@ describe("EV_DRAFTS: the host is the truth", () => {
         expect(drafts_on_screen(editor)).toBe(1);
     });
 
-    test("the host names none any more (a Save): the mark goes (M1)", () => {
+    test("the host names none any more (a Save): the mark goes", () => {
         /*  It only ever ADDED: after the Save the editor still said
          *  "unsaved schema changes".  */
         const {editor, host} = build("d2");

package/src/schema_editor_reload.wiring.test.js

@@ -316,6 +316,8 @@ const WAIT = "the schemas are loading: wait for them";
 const STALE = "the schemas were read again: open the dialog again";
 const KEPT = "cannot read the schemas again: the ones shown may be out of date, your next change reads them first";
 const OWED = "the schemas shown may be out of date: they are read again, try again when they are in";
+const OWED_FORM = "the schemas shown may be out of date: they are read again, and the form opens again on them with your changes";
+const GONE = "the schemas were read again and what the form was editing is not there any more";
 const NOT_SENT = "the treedb did not describe a write back: the writes after it were not sent";
 
 describe("the screen of a reload", () => {
@@ -618,6 +620,7 @@ describe("a load that fails IN session", () => {
         const {editor, remote, host} = build("b1", "db/users");
         gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
         const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="header"]').value = "Identifier";
         gobj_send_event(editor, "EV_REFRESH", {}, host);
         const asked = take("nodes");
         answer(editor, remote, asked[0], -1, null, "deadline");
@@ -634,16 +637,28 @@ describe("a load that fails IN session", () => {
 
         /*  The form was built on a model that may be older than the
          *  store: its Save would write every field of it. It runs the
-         *  reload owed instead, and the load that lands
-         *  closes the form.  */
+         *  reload owed instead. The load that lands closes the form,
+         *  and opens it again ON THE SCHEMAS JUST READ with what the
+         *  operator changed: closed alone, what was typed was lost.  */
         form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
         expect(not_defined()).toEqual([]);
         expect(take("update-node")).toEqual([]);
-        expect(shown).toEqual([KEPT, OWED]);
+        expect(shown).toEqual([KEPT, OWED_FORM]);
+        const before = modals.length;
         expect(answer_the_load(editor, remote)).toBe(3);
         expect(form.closed).toBe(true);
-        expect(shown).toEqual([KEPT, OWED, STALE]);
+        expect(modals.length).toBe(before + 1);
+        const again = modals[modals.length - 1];
+        expect(again.closed).toBe(false);
+        expect(again.$content.querySelector('[data-name="header"]').value).toBe("Identifier");
+        expect(shown).toEqual([KEPT, OWED_FORM]);
         expect(editor.priv.reload_on_open).toBe(false);
+
+        /*  Its Save writes, on the record just read.  */
+        again.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        const [write] = take("update-node");
+        expect(write.kw.record.id).toBe("db.users.id");
+        expect(write.kw.record.header).toBe("Identifier");
         expect(errors()).toEqual([]);
     });
 
@@ -1353,3 +1368,297 @@ describe("a move sent by the host while a dialog is up", () => {
         expect(shown).toEqual([]);
     });
 });
+
+describe("the form opened again after the owed reload", () => {
+
+    function owing(name, subpath)
+    {
+        const built = build(name, subpath);
+        built.editor.priv.reload_on_open = true;    /*  as a load refused in session leaves it  */
+        return built;
+    }
+
+    test("only what was CHANGED is carried: a field the store changed meanwhile shows the store's", () => {
+        const {editor, remote, host} = build("ro6", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="header"]').value = "Identifier";
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols[0].description = "written by somebody else";
+        }));
+        const again = modals[modals.length - 1];
+        expect(again.$content.querySelector('[data-name="header"]').value).toBe("Identifier");
+        expect(again.$content.querySelector('[data-name="description"]').value)
+            .toBe("written by somebody else");
+        again.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        const [write] = take("update-node");
+        expect(write.kw.record.description).toBe("written by somebody else");
+        expect(write.kw.record.header).toBe("Identifier");
+        expect(errors()).toEqual([]);
+    });
+
+    test("a NEW column comes back whole: its name, its type and its flags", () => {
+        const {editor, remote, host} = owing("ro2", "db/users");
+        /*  The owed reload runs on the form's opening too: open it on a
+         *  model that is current, then owe the reload.  */
+        editor.priv.reload_on_open = false;
+        gobj_send_event(editor, "EV_ADD_COLUMN", {}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="value"]').value = "email";
+        form.$content.querySelector('[data-name="header"]').value = "Email";
+        for(const $box of form.$content.querySelectorAll(".SCHEMA_FLAG_BOX")) {
+            if($box.dataset.flag === "required") {
+                $box.checked = true;
+            }
+        }
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        expect(shown).toEqual([OWED_FORM]);
+        answer_the_load(editor, remote);
+        const again = modals[modals.length - 1];
+        expect(again).not.toBe(form);
+        expect(again.$content.querySelector('[data-name="value"]').value).toBe("email");
+        expect(again.$content.querySelector('[data-name="header"]').value).toBe("Email");
+        const on = [...again.$content.querySelectorAll(".SCHEMA_FLAG_BOX")]
+            .filter(($b) => $b.checked).map(($b) => $b.dataset.flag);
+        expect(on).toContain("required");
+        expect(errors()).toEqual([]);
+    });
+
+    test("a topic form comes back the same way", () => {
+        const {editor, remote, host} = build("ro3", "db");
+        gobj_send_event(editor, "EV_EDIT_TOPIC", {topic: "users"}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector('[data-name="tkey"]').value = "tm";
+        form.$content.querySelector(".SCHEMA_TOPIC_FORM_SAVE").click();
+        expect(shown).toEqual([OWED_FORM]);
+        answer_the_load(editor, remote);
+        const again = modals[modals.length - 1];
+        expect(again).not.toBe(form);
+        expect(again.$content.querySelector('[data-name="tkey"]').value).toBe("tm");
+        expect(errors()).toEqual([]);
+    });
+
+    test("what the form edited is gone after the reload: not opened again, and SAID", () => {
+        const {editor, remote, host} = build("ro4", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        const before = modals.length;
+        answer_the_load_with(editor, remote, records_with((r) => {
+            r.cols = [];
+        }));
+        expect(form.closed).toBe(true);
+        expect(modals.length).toBe(before);
+        expect(shown).toEqual([OWED_FORM, GONE]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a form closed by the operator while the reload ran is not opened again", () => {
+        const {editor, remote, host} = build("ro5", "db/users");
+        gobj_send_event(editor, "EV_EDIT_COLUMN", {col: "id"}, host);
+        editor.priv.reload_on_open = true;
+        const form = modals[modals.length - 1];
+        form.$content.querySelector(".SCHEMA_COL_FORM_SAVE").click();
+        form.$content.querySelector(".SCHEMA_COL_FORM_CANCEL").click();
+        const before = modals.length;
+        answer_the_load(editor, remote);
+        expect(modals.length).toBe(before);
+        expect(shown).toEqual([OWED_FORM]);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("EV_REFRESH while a write is in flight", () => {
+
+    test("waits for the end of the writes: the queue is written whole, then the schemas are read", () => {
+        const {editor, remote, host} = build("rq1", "db");
+        gobj_send_event(editor, "EV_CONFIRMED", {what: "topic", topic: "users",
+            model_gen: editor.priv.model_gen}, editor);
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+        const [first] = take("delete-node");
+        expect(first.kw.topic_name).toBe("cols");
+
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+        expect(take("nodes")).toEqual([]);
+        expect(logged.some((l) => l.level === "warning" &&
+            /EV_REFRESH.*when the writes end/.test(l.msg))).toBe(true);
+
+        answer(editor, remote, first, 0, {});
+        const [second] = take("delete-node");
+        expect(second.kw.topic_name).toBe("topics");
+        answer(editor, remote, second, 0, {});
+
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(editor.priv.written).toEqual({});
+        expect(errors()).toEqual([]);
+        expect(not_defined()).toEqual([]);
+    });
+});
+
+describe("the body while a write is in flight", () => {
+
+    /*  pointer-events stops the mouse and nothing else: the shell's
+     *  focus trap puts the focus back on the row control that had it,
+     *  and Delete or Enter there sent an action ST_SAVING does not
+     *  declare. `inert` takes the body out of the keyboard's reach too.  */
+    test("is inert, and answers again when the write ends", () => {
+        const {editor, remote, host} = build("r16k1", "db/users");
+        const $body = $in(editor, ".SCHEMA_BODY");
+        expect($body.hasAttribute("inert")).toBe(false);
+
+        const write = start_a_write(editor, host, "name");
+        expect($body.hasAttribute("inert")).toBe(true);
+
+        answer(editor, remote, write, 0, write.kw.record);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect($in(editor, ".SCHEMA_BODY").hasAttribute("inert")).toBe(false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a drop that ends the write gives the body back too", () => {
+        const {editor, remote, host} = build("r16k2", "db/users");
+        start_a_write(editor, host, "name");
+        drop(editor, remote, host);
+        expect($in(editor, ".SCHEMA_BODY").hasAttribute("inert")).toBe(false);
+    });
+});
+
+describe("the writes of an import mark the topic they write", () => {
+
+    /*  An import that adds a topic, `roles`.  */
+    const IMPORT = JSON.stringify({id: "db", topics: [
+        {id: "users", pkey: "id", cols: [
+            {id: "id", type: "string", flag: ["persistent", "required"]}
+        ]},
+        {id: "roles", pkey: "id", cols: [
+            {id: "id", type: "string", flag: ["persistent", "required"]}
+        ]}
+    ]});
+
+    /*  The record as the store answers it: with the id it gave a new
+     *  one, and its fkeys in list_dict.  */
+    function as_the_store_answers(write)
+    {
+        const record = JSON.parse(JSON.stringify(write.kw.record));
+        const to_dict = (refs) => refs.map((ref) => {
+            const [topic_name, id, hook_name] = ref.split("^");
+            return {topic_name, id, hook_name};
+        });
+        if(write.kw.topic_name === "topics") {
+            record.id = record.id || `db.${record.value}`;
+            record.treedbs = to_dict(record.treedbs || []);
+        }
+        if(write.kw.topic_name === "cols") {
+            record.id = record.id || `${record.topics[0].split("^")[1]}.${record.value}`;
+            record.topics = to_dict(record.topics || []);
+        }
+        return record;
+    }
+
+    function run_the_import(editor, host)
+    {
+        gobj_send_event(editor, "EV_IMPORT", {}, host);
+        gobj_send_event(editor, "EV_PREVIEW_IMPORT", {prune: false, text: IMPORT,
+            model_gen: editor.priv.model_gen}, editor);
+        expect(editor.priv.import_plan.writes.length).toBeGreaterThan(0);
+        gobj_send_event(editor, "EV_APPLY_IMPORT", {model_gen: editor.priv.model_gen}, editor);
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+    }
+
+    function answer_every_write(editor, remote)
+    {
+        for(let i = 0; i < 10; i++) {
+            const [write] = take("update-node");
+            if(!write) {
+                break;
+            }
+            answer(editor, remote, write, 0, as_the_store_answers(write));
+        }
+    }
+
+    test("from another topic's screen: the topic it wrote, not the one on screen", () => {
+        const {editor, remote, host} = build("r16m1", "db/users");
+        run_the_import(editor, host);
+        answer_every_write(editor, remote);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(editor.priv.written).toEqual({"db.roles": true});
+        expect(errors()).toEqual([]);
+    });
+
+    test("from the topics screen, where no topic is on screen", () => {
+        const {editor, remote, host} = build("r16m2", "db");
+        run_the_import(editor, host);
+        answer_every_write(editor, remote);
+        expect(gobj_current_state(editor)).toBe("ST_TOPICS");
+        expect(editor.priv.written).toEqual({"db.roles": true});
+        expect(errors()).toEqual([]);
+    });
+
+    test("a column answered with no record: the record it queued says the topic", () => {
+        const {editor, remote, host} = build("r16m3", "db/users");
+        run_the_import(editor, host);
+        const [topic] = take("update-node");
+        expect(topic.kw.topic_name).toBe("topics");
+        answer(editor, remote, topic, 0, as_the_store_answers(topic));
+        const [col] = take("update-node");
+        expect(col.kw.topic_name).toBe("cols");
+        answer(editor, remote, col, 0, null);
+        expect(editor.priv.written).toEqual({"db.roles": true});
+    });
+});
+
+describe("the reason a load failed", () => {
+
+    test("is a key the notice translates, not a string frozen in one language", () => {
+        const remote = gobj_create_service("r16e1_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_SESSION");
+        const host = gobj_create("r16e1_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("r16e1_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        for(const c of take("nodes")) {
+            answer(editor, remote, c, -1, null, "");
+        }
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+        expect(editor.priv.load_error).toBe("cannot load the schemas");
+        /*  The notice already says it: no detail repeating the title.  */
+        expect($in(editor, ".SCHEMA_NOTICE_DETAIL")).toBe(null);
+    });
+
+    test("the backend's own words travel as its key", () => {
+        const remote = gobj_create_service("r16e2_remote", "C_TEST_REMOTE", {}, yuno);
+        gobj_change_state(remote, "ST_SESSION");
+        const host = gobj_create("r16e2_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("r16e2_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        for(const c of take("nodes")) {
+            answer(editor, remote, c, -1, null, "treedb not found");
+        }
+        const $detail = $in(editor, ".SCHEMA_NOTICE_DETAIL");
+        expect($detail.getAttribute("data-i18n")).toBe("treedb not found");
+    });
+
+    test("a load that cannot leave keeps its key", () => {
+        const remote = gobj_create_service("r16e3_remote", "C_TEST_REMOTE", {}, yuno);
+        const host = gobj_create("r16e3_host", "C_TEST_EDITOR_HOST", {}, yuno);
+        const editor = gobj_create("r16e3_editor", "C_YUI_SCHEMA_EDITOR", {
+            gobj_remote_yuno: remote, treedb_name: "treedb_system_schema"
+        }, host);
+        gobj_start(editor);
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        gobj_send_event(editor, "EV_REFRESH", {}, host);
+        expect(editor.priv.load_error).toBe("cannot reach the treedb");
+        const $detail = $in(editor, ".SCHEMA_NOTICE_DETAIL");
+        expect($detail.getAttribute("data-i18n")).toBe("cannot reach the treedb");
+    });
+});