@yuneta/gobj-ui 7.25.18 → 7.25.20

package/src/g6_graphs_write_owed.wiring.test.js

@@ -188,6 +188,43 @@ describe("a refused __graphs__ write keeps the Save lit", () => {
         expect(errors()).toEqual([]);
     });
 
+    /*  Before gobj-ui 7.25.19 only a Save that planned the topic paid
+     *  what was owed. Save #1 and Save #2 both write `users`, #1 is
+     *  refused and its answer lands after #2's echo: the echo made the
+     *  topic saved, so no Save planned it again, and the button stayed
+     *  lit over nothing to write until a reload.  */
+    test("an echo of the topic pays what was owed: the Save goes dark", () => {
+        const g = build("edition");
+        g.tree.priv.descs = {};
+        g.tree.priv.__graphs__ = [];
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+        expect(g.lit()).toBe(true);
+
+        gobj_send_event(g.tree, "EV_NODE_UPDATED", {
+            topic_name: "__graphs__",
+            node: {id: "users", topic: "users", active: true,
+                properties: {nodes: {u1: {x: 30, y: 40}}}}
+        }, g.tree);
+        expect(g.lit()).toBe(false);
+
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        expect(published.filter((p) => p.event === "EV_UPDATE_NODE")).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an echo of ANOTHER topic leaves it owed", () => {
+        const g = build("edition");
+        g.tree.priv.descs = {};
+        g.tree.priv.__graphs__ = [];
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED", {topic: "users"}, g.tree);
+        gobj_send_event(g.tree, "EV_NODE_UPDATED", {
+            topic_name: "__graphs__",
+            node: {id: "roles", topic: "roles", active: true, properties: {nodes: {}}}
+        }, g.tree);
+        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);
@@ -198,3 +235,80 @@ describe("a refused __graphs__ write keeps the Save lit", () => {
         expect(errors()).toEqual([]);
     });
 });
+
+/*  A refusal is about the LOAD its write was sent from. Before gobj-ui
+ *  7.25.20 it carried only the topic: Save, then Refresh, then the
+ *  refusal landed and was applied to the FRESH load -- the Save lit
+ *  over nothing changed, and pressing it wrote a record identical to
+ *  what the backend holds.  */
+describe("a refusal of an earlier load is not applied to the current one", () => {
+
+    test("the write carries its load, and a refusal of it counts", () => {
+        const g = build("edition");
+        g.tree.priv._graph_properties.users.nodes.u1.x = 99;
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const [write] = published.filter((p) => p.event === "EV_UPDATE_NODE");
+        expect(typeof write.kw.graphs_load).toBe("number");
+
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED",
+            {topic: "users", graphs_load: write.kw.graphs_load}, g.tree);
+        expect(g.lit()).toBe(true);
+        expect(g.tree.priv._saved_graph_properties.users).toBe(undefined);
+        expect(errors()).toEqual([]);
+    });
+
+    test("Save, reload, then the refusal: ignored, and said", () => {
+        const g = build("edition");
+        g.tree.priv._graph_properties.users.nodes.u1.x = 99;
+        gobj_send_event(g.tree, "EV_SAVE_GRAPH", {}, g.tree);
+        const [write] = published.filter((p) => p.event === "EV_UPDATE_NODE");
+
+        gobj_send_event(g.tree, "EV_CLEAR_DATA", {}, g.tree);
+        /*  The reload brings what the backend holds.  */
+        g.tree.priv._graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+        g.tree.priv._saved_graph_properties = {users: {nodes: {u1: {x: 10, y: 20}}}};
+        gobj_send_event(g.tree, "EV_SET_OPERATION_MODE", {operation_mode: "edition"}, g.tree);
+        logged.length = 0;
+
+        gobj_send_event(g.tree, "EV_GRAPHS_WRITE_REFUSED",
+            {topic: "users", graphs_load: write.kw.graphs_load}, g.tree);
+        expect(g.lit()).toBe(false);
+        expect(g.tree.priv._saved_graph_properties.users).toEqual({nodes: {u1: {x: 10, y: 20}}});
+        expect(logged.map((l) => [l.level, l.msg.replace(/^\S+: /, "")])).toEqual([
+            ["warning", "a refused write of the arrangement of 'users' belongs to an earlier load: ignored"]
+        ]);
+    });
+});
+
+/*  The FIRST record of a topic's arrangement arrives as a CREATE echo
+ *  (from this browser or another). Before gobj-ui 7.25.20 it rebuilt
+ *  every topic's saved copy from the live objects the view edits in
+ *  place, so an unsaved change of ANOTHER topic counted as saved and
+ *  the next Save did not write it.  */
+describe("a __graphs__ create echo moves only its own topic", () => {
+
+    test("an unsaved change of another topic stays unsaved", () => {
+        const g = build("edition");
+        g.tree.priv.descs = {};
+        g.tree.priv.__graphs__ = [
+            {id: "users", topic: "users", active: true,
+                properties: g.tree.priv._graph_properties.users}
+        ];
+        /*  Edited in place, not saved.  */
+        g.tree.priv._graph_properties.users.nodes.u1.x = 77;
+
+        gobj_send_event(g.tree, "EV_NODE_CREATED", {
+            topic_name: "__graphs__",
+            node: {id: "roles", topic: "roles", active: true,
+                properties: {nodes: {r1: {x: 1, y: 2}}}}
+        }, g.tree);
+
+        expect(g.tree.priv._saved_graph_properties.users).toEqual({nodes: {u1: {x: 10, y: 20}}});
+        expect(g.tree.priv._saved_graph_properties.roles).toEqual({nodes: {r1: {x: 1, y: 2}}});
+
+        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(errors()).toEqual([]);
+    });
+});

package/src/node_nav_events.wiring.test.js

@@ -0,0 +1,150 @@
+/***********************************************************************
+ *          node_nav_events.wiring.test.js
+ *
+ *      C_YUI_NODE hosts C_YUI_NAV as a pure CHILD, so it hears every
+ *      event the nav publishes -- and it declared only EV_NAV_CLICKED.
+ *      EV_NAV_ITEM_CLOSE (the ✕ of a closable item) and
+ *      EV_DRAWER_CLOSE_REQUESTED (the backdrop of a drawer projection,
+ *      a layout a node may declare) answered "Event NOT DEFINED in
+ *      state" -- and the drawer stayed open, because the shell that
+ *      closes drawers knows only its own navs. A zone projection also
+ *      outlives the path (it is stopped only in mt_stop), so the clicks
+ *      of a root that is off the path landed on ST_OFF, which declared
+ *      none of the three.
+ *
+ *      Driven through the real gclasses (C_YUI_SHELL, C_YUI_NODE,
+ *      C_YUI_NAV) on a document double: each event is published by the
+ *      real nav the node created.
+ *
+ *          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_pure_child,
+    gobj_start, gobj_send_event, gobj_publish_event, gobj_read_attr,
+    gobj_current_state, gobj_change_state,
+    set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_shell} = await import("./c_yui_shell.js");
+const {register_c_yui_nav} = await import("./c_yui_nav.js");
+const {register_c_yui_node} = await import("./c_yui_node.js");
+
+const logged = [];
+const closed = [];          /*  the EV_NAV_ITEM_CLOSE the app heard  */
+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);
+    /*  An app that uses closable items: it declares what the shell
+     *  re-publishes.  */
+    gclass_create(
+        "C_TEST_APP",
+        [["EV_NAV_ITEM_CLOSE", 0]],
+        [["ST_IDLE", [
+            ["EV_NAV_ITEM_CLOSE", (gobj, event, kw) => {
+                closed.push(kw);
+                return 0;
+            }, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    register_c_yui_shell();
+    register_c_yui_nav();
+    register_c_yui_node();
+    yuno = gobj_create_yuno("node_nav_yuno", "C_TEST_HOST", {});
+    gobj_start(yuno);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    closed.length = 0;
+});
+
+let seq = 0;
+
+/*  A tree under a shell, on the path, projecting its children with
+ *  `layout`. Returns the tree and the nav it created.  */
+function build(layout)
+{
+    const name = `n${++seq}`;
+    const app = gobj_create(`${name}_app`, "C_TEST_APP", {}, yuno);
+    gobj_start(app);
+    const shell = gobj_create(`${name}_shell`, "C_YUI_SHELL",
+        {config: {shell: {}}, default_route: "/home", subscriber: app}, app);
+    gobj_start(shell);
+    const tree = gobj_create_pure_child(`${name}_tree`, "C_YUI_NODE", {
+        node_id: "root",
+        base_route: "/tree",
+        projection: {index: {layout: layout}},
+        children: [{id: "a", label: "A"}, {id: "b", label: "B"}]
+    }, shell);
+    gobj_start(tree);
+    gobj_send_event(tree, "EV_ROUTE_CHANGED", {base: "/tree", subpath: ""}, shell);
+    expect(gobj_current_state(tree)).toBe("ST_SELF");
+    const nav = tree.priv.navs[0];
+    expect(nav).toBeTruthy();
+    expect(gobj_read_attr(nav, "layout")).toBe(layout);
+    logged.length = 0;
+    return {app, shell, tree, nav};
+}
+
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+describe("the events of a C_YUI_NAV reach its C_YUI_NODE", () => {
+
+    test("EV_NAV_ITEM_CLOSE is handed to the shell, and the app hears it", () => {
+        const {nav} = build("tabs");
+        gobj_publish_event(nav, "EV_NAV_ITEM_CLOSE", {
+            item_id: "a", route: "/tree/a", menu_id: "node./tree", zone: ""
+        });
+        expect(errors()).toEqual([]);
+        expect(closed).toEqual([{
+            item_id: "a", route: "/tree/a", menu_id: "node./tree", zone: ""
+        }]);
+    });
+
+    test("EV_DRAWER_CLOSE_REQUESTED closes the node's own drawer", () => {
+        const {nav} = build("drawer");
+        const $drawer = gobj_read_attr(nav, "$container");
+        $drawer.classList.add("is-active");
+
+        gobj_publish_event(nav, "EV_DRAWER_CLOSE_REQUESTED", {
+            menu_id: gobj_read_attr(nav, "menu_id")
+        });
+        expect(errors()).toEqual([]);
+        expect($drawer.classList.contains("is-active")).toBe(false);
+    });
+
+    test("a drawer of another menu is left open", () => {
+        const {nav} = build("drawer");
+        const $drawer = gobj_read_attr(nav, "$container");
+        $drawer.classList.add("is-active");
+        gobj_publish_event(nav, "EV_DRAWER_CLOSE_REQUESTED", {menu_id: "other"});
+        expect(errors()).toEqual([]);
+        expect($drawer.classList.contains("is-active")).toBe(true);
+    });
+
+    test("off the path, a nav that is still there is heard too", () => {
+        const {tree, nav} = build("tabs");
+        /*  What a zone nav is: alive while its root is off the path.  */
+        gobj_change_state(tree, "ST_OFF");
+        gobj_publish_event(nav, "EV_NAV_ITEM_CLOSE", {item_id: "b"});
+        gobj_publish_event(nav, "EV_DRAWER_CLOSE_REQUESTED", {menu_id: "x"});
+        gobj_publish_event(nav, "EV_NAV_CLICKED", {route: "/tree/a", item_id: "a"});
+        expect(errors()).toEqual([]);
+        expect(closed.map((c) => c.item_id)).toEqual(["b"]);
+    });
+});

package/src/schema_editor_reload.wiring.test.js

@@ -481,6 +481,43 @@ describe("the drawing of a treedb that is not there", () => {
     });
 });
 
+/*
+ *  Since gobj-ui 7.25.17 the notice translated its detail, and three
+ *  callers pass a NAME there: a topic called `nodes` that is gone was
+ *  shown as "Nodos" in an app whose locale has that key, and followed
+ *  every change of language.
+ */
+describe("the name in a notice is a name", () => {
+
+    test("a topic that is gone is named as it is, with no i18n key", async () => {
+        const i18next = (await import("i18next")).default;
+        await i18next.init({lng: "es", resources: {es: {translation: {nodes: "Nodos", db: "BD"}}}});
+        try {
+            const {editor} = build("nn1", "db/nodes");
+            expect($in(editor, ".SCHEMA_NOTICE_TEXT").getAttribute("data-i18n"))
+                .toBe("that topic is not here any more");
+            const $detail = $in(editor, ".SCHEMA_NOTICE_DETAIL");
+            expect($detail.textContent).toBe("nodes");
+            expect($detail.getAttribute("data-i18n")).toBe(null);
+        } finally {
+            await i18next.init({lng: "en", resources: {}});
+        }
+    });
+
+    test("a treedb that is gone is named as it is, with no i18n key", async () => {
+        const i18next = (await import("i18next")).default;
+        await i18next.init({lng: "es", resources: {es: {translation: {nodes: "Nodos"}}}});
+        try {
+            const {editor} = build("nn2", "nodes");
+            const $detail = $in(editor, ".SCHEMA_NOTICE_DETAIL");
+            expect($detail.textContent).toBe("nodes");
+            expect($detail.getAttribute("data-i18n")).toBe(null);
+        } finally {
+            await i18next.init({lng: "en", resources: {}});
+        }
+    });
+});
+
 describe("a write given up that was DONE", () => {
 
     test("the host is told, and the reload keeps what this session wrote", () => {

package/src/schema_editor_transport.wiring.test.js

@@ -37,7 +37,7 @@ const {
     gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
     gobj_start, gobj_send_event, gobj_read_attr,
     gobj_change_state, gobj_current_state,
-    set_log_callback,
+    set_log_callback, log_error,
 } = await import("@yuneta/gobj-js");
 const {register_c_yui_schema_editor} = await import("./c_yui_schema_editor.js");
 
@@ -56,13 +56,33 @@ const RECORDS = {
     ],
 };
 
-/*  A transport out of session refuses in the RETURN, as C_IEVENT_CLI and
- *  the routing adapters do: a request that did not leave is not waited for.  */
+/*  A transport out of session refuses in the RETURN, as the routing
+ *  adapters do (gui_agent's C_AGENT_TREEDB_LINK): a request that did not
+ *  leave is not waited for. `refuse_on_the_way` makes it refuse IN
+ *  session too, as a transport that cannot send.  */
+let refuse_on_the_way = false;
+
 function remote_command_parser(gobj, command, kw, src)
 {
     if(gobj_current_state(gobj) !== "ST_SESSION") {
         return `${command}: not in session`;
     }
+    if(refuse_on_the_way) {
+        return `${command}: cannot send`;
+    }
+    commands.push({command, kw, src});
+    return null;
+}
+
+/*  A DIRECT C_IEVENT_CLI, as its mt_command does it: out of session it
+ *  logs "Not in session" and answers NULL -- the same answer as a request
+ *  that left. The README allows `gobj_remote_yuno` to be one.  */
+function ievent_cli_command_parser(gobj, command, kw, src)
+{
+    if(gobj_current_state(gobj) !== "ST_SESSION") {
+        log_error(`Not in session`);
+        return null;
+    }
     commands.push({command, kw, src});
     return null;
 }
@@ -93,6 +113,13 @@ beforeAll(() => {
         {mt_command_parser: remote_command_parser},
         0, [SDATA_END()], {}, 0, 0, 0, 0
     );
+    gclass_create(
+        "C_TEST_IEVENT_CLI",
+        [],
+        [["ST_DISCONNECTED", []], ["ST_SESSION", []]],
+        {mt_command_parser: ievent_cli_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
     register_c_yui_schema_editor();
     yuno = gobj_create_yuno("transport_yuno", "C_TEST_HOST", {});
     gobj_start(yuno);
@@ -102,6 +129,7 @@ beforeEach(() => {
     logged.length = 0;
     commands.length = 0;
     shown.length = 0;
+    refuse_on_the_way = false;
 });
 
 function take(command)
@@ -148,9 +176,10 @@ function reconnect(editor, remote, host)
     gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
 }
 
-function build(name, loaded)
+function build(name, loaded, remote_gclass)
 {
-    const remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
+    const remote = gobj_create_service(`${name}_remote`,
+        remote_gclass || "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", {
@@ -455,3 +484,58 @@ describe("a write answered after it was given up", () => {
         expect(errors()).toEqual([]);
     });
 });
+
+/*  Before gobj-ui 7.25.20 a write never asked whether the transport was
+ *  in session. A direct C_IEVENT_CLI answers null out of session, which
+ *  remote_command() took for "sent": the editor sat in ST_SAVING, busy
+ *  and inert, until another drop.  */
+describe("a write with the transport out of session", () => {
+
+    test("a direct C_IEVENT_CLI: the write ends, said, and the next session reads again", () => {
+        const {editor, remote, host} = build("x1", true, "C_TEST_IEVENT_CLI");
+        /*  Gone, and the host's edge has not arrived yet.  */
+        gobj_change_state(remote, "ST_DISCONNECTED");
+
+        gobj_send_event(editor, "EV_SAVE_COLUMN", {
+            creating: true, topic: "users", values: {value: "name", type: "string"}
+        }, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(is_busy(editor)).toBe(false);
+        expect(take("update-node")).toEqual([]);
+        expect(shown).toEqual(["cannot reach the treedb"]);
+        expect(errors()).toEqual([]);
+        expect(warnings()).toEqual([
+            "C_YUI_SCHEMA_EDITOR^x1_editor: no session, 'update-node' of 'cols' was not sent"
+        ]);
+
+        gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+
+    /*  The toast is handed the KEY (yui_shell_show_error translates it
+     *  and keeps it for a change of language). This path passed
+     *  t("cannot reach the treedb"), a text that cannot re-translate.  */
+    test("a transport that refuses in session: the toast gets the key", async () => {
+        const i18next = (await import("i18next")).default;
+        if(!i18next.isInitialized) {
+            await i18next.init({lng: "en", resources: {}});
+        }
+        i18next.addResource(i18next.language || "en", "translation",
+            "cannot reach the treedb", "TRANSLATED: cannot reach the treedb");
+        try {
+            const {editor, remote, host} = build("x2", true);
+            refuse_on_the_way = true;
+            gobj_send_event(editor, "EV_SAVE_COLUMN", {
+                creating: true, topic: "users", values: {value: "name", type: "string"}
+            }, host);
+            expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+            expect(shown).toEqual(["cannot reach the treedb"]);
+            expect(errors()).toEqual(["update-node: cannot send"]);
+        } finally {
+            i18next.removeResourceBundle(i18next.language || "en", "translation");
+        }
+    });
+});

package/src/treedb_graph_writes.wiring.test.js

@@ -156,15 +156,20 @@ function build(name)
     return {remote, host, engine};
 }
 
-/*  What the engine publishes on a Save of one topic's arrangement.  */
-function save_arrangement(engine, topic)
+/*  What the engine publishes on a Save of one topic's arrangement,
+ *  from its load number `graphs_load`.  */
+function save_arrangement(engine, topic, graphs_load)
 {
-    gobj_publish_event(engine, "EV_UPDATE_NODE", {
+    let kw = {
         treedb_name: "treedb_test",
         topic_name: "__graphs__",
         record: {id: topic, topic: topic, active: true, properties: {nodes: {}}},
         options: {list_dict: true, autolink: false, create: true}
-    });
+    };
+    if(graphs_load !== undefined) {
+        kw.graphs_load = graphs_load;
+    }
+    gobj_publish_event(engine, "EV_UPDATE_NODE", kw);
 }
 
 /*  The answer as the real transports build it: the command frame
@@ -188,6 +193,11 @@ function refused()
     return told.filter((t) => t.event === "EV_GRAPHS_WRITE_REFUSED").map((t) => t.kw.topic);
 }
 
+function refused_kw()
+{
+    return told.filter((t) => t.event === "EV_GRAPHS_WRITE_REFUSED").map((t) => t.kw);
+}
+
 describe("a __graphs__ write that does not land is said to the engine", () => {
 
     test("refused by the backend", () => {
@@ -222,6 +232,30 @@ describe("a __graphs__ write that does not land is said to the engine", () => {
         expect(refused()).toEqual(["binaries"]);
     });
 
+    /*  Before gobj-ui 7.25.20 the refusal carried only the topic, and
+     *  the engine applied one answered after a reload to the fresh
+     *  load. The engine's load number now travels in __md_command__
+     *  and comes back with the refusal, on every path.  */
+    test("the engine's load comes back with the refusal, on every path", () => {
+        const {remote, host, engine} = build("g6");
+        save_arrangement(engine, "yunos", 7);
+        expect(commands[0].kw.__md_command__.graphs_load).toBe(7);
+        answer(host, remote, commands[0], -1, "not authorized");
+
+        refuse_on_the_way = true;
+        save_arrangement(engine, "binaries", 7);
+        refuse_on_the_way = false;
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        save_arrangement(engine, "realms", 8);
+
+        expect(refused_kw()).toEqual([
+            {topic: "yunos", graphs_load: 7},
+            {topic: "binaries", graphs_load: 7},
+            {topic: "realms", graphs_load: 8}
+        ]);
+    });
+
     test("a refused write of another topic says nothing to the engine", () => {
         const {remote, host, engine} = build("g5");
         gobj_send_event(host, "EV_UPDATE_NODE", {

package/src/treedb_topics_transport.wiring.test.js

@@ -262,6 +262,95 @@ describe("a Save in flight when the backend drops", () => {
     });
 });
 
+/*
+ *  The success answer of a request, the way C_IEVENT_CLI delivers it: the
+ *  request's `__md_command__` as the frame, and nothing else of it.
+ */
+function answer_ok(request, data)
+{
+    return {result: 0, comment: "", data: data, __md_iev__: {
+        command_stack: [{command: request.command, kw: request.kw.__md_command__}]
+    }};
+}
+
+/*
+ *  Before gobj-ui 7.25.19 a delete answered published nothing (the case
+ *  was an empty `break`), and `created` compared the command with
+ *  "create-node" -- which the view never sends: its +New goes out as an
+ *  update-node with `create_only`, so `created` was always false.
+ */
+describe("EV_RECORD_WRITTEN of a create and of a delete", () => {
+
+    test("a +New answered says created: true", () => {
+        const {shell, topics, forms} = build("tc1");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_CREATE_RECORD",
+            {record: {id: "n1"}, form_write: 1}, forms.users);
+
+        const request = commands.find((c) => c.command === "update-node");
+        expect(request.kw.options.create_only).toBe(true);
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER",
+            answer_ok(request, [{id: "n1", name: "new"}]), remote);
+
+        expect(written).toEqual([{
+            treedb_name: "treedb_test",
+            topic_name: "users",
+            record: {id: "n1", name: "new"},
+            created: true,
+            command: "update-node"
+        }]);
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_DONE", form_write: 1},
+        ]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an edit answered says created: false", () => {
+        const {shell, topics, forms} = build("tc2");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+        const request = commands.find((c) => c.command === "update-node");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER",
+            answer_ok(request, [{id: "x"}]), remote);
+        expect(written.map((w) => w.created)).toEqual([false]);
+    });
+
+    test("a delete answered is published with the node deleted", () => {
+        const {shell, topics, forms} = build("tc3");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_DELETE_RECORD", {record: {id: "x"}}, forms.roles);
+
+        const request = commands.find((c) => c.command === "delete-node");
+        expect(request).toBeTruthy();
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER",
+            answer_ok(request, [{id: "x", name: "gone"}]), remote);
+
+        expect(written).toEqual([{
+            treedb_name: "treedb_test",
+            topic_name: "roles",
+            record: {id: "x", name: "gone"},
+            created: false,
+            command: "delete-node"
+        }]);
+        /*  A delete has no form waiting for its answer.  */
+        expect(answers).toEqual([]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a delete refused publishes nothing", () => {
+        const {shell, topics, forms} = build("tc4");
+        yui_shell_set_connection_state(shell, true);
+        gobj_send_event(topics, "EV_DELETE_RECORD", {record: {id: "x"}}, forms.roles);
+        const request = commands.find((c) => c.command === "delete-node");
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", {
+            result: -1, comment: "linked", data: null, __md_iev__: {
+                command_stack: [{command: "delete-node", kw: request.kw.__md_command__}]
+            }
+        }, remote);
+        expect(written).toEqual([]);
+    });
+});
+
 /*
  *  The answer the routing adapter gives a write it had in flight when
  *  its session closed: a failure, settled by the adapter itself.