@yuneta/gobj-ui 7.25.4 → 7.25.6

package/src/schema_editor_transport.wiring.test.js

@@ -0,0 +1,284 @@
+/***********************************************************************
+ *          schema_editor_transport.wiring.test.js
+ *
+ *      C_YUI_SCHEMA_EDITOR when the transport drops (M-1 of the
+ *      independent review of 7.25.4). A drop used to leave the editor
+ *      where it was: in ST_SAVING with its body busy, or in ST_LOADING
+ *      -- and the reconnect skipped the reload BECAUSE the state was
+ *      ST_LOADING. Only a reload of the page got it out.
+ *
+ *      Driven through the FSM on a document double, with a fake
+ *      transport whose state is the one the library reads
+ *      (`ST_SESSION` or not).
+ *
+ *          Copyright (c) 2026, ArtGins.
+ *          All Rights Reserved.
+ ***********************************************************************/
+import {describe, test, expect, beforeAll, beforeEach, vi} from "vitest";
+import {install_dom_double} from "../test/dom_double.js";
+
+install_dom_double();
+
+/*  What the editor SAYS is asserted on the call.  */
+const shown = [];
+vi.mock("./shell_modals.js", () => ({
+    yui_shell_show_error: (shell, message) => {
+        shown.push(message);
+        return {close() {}};
+    },
+    yui_shell_show_info: () => ({close() {}}),
+    yui_shell_show_modal: () => ({close() {}}),
+    yui_shell_confirm_danger: () => ({close() {}}),
+}));
+
+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, gobj_current_state,
+    set_log_callback,
+} = await import("@yuneta/gobj-js");
+const {register_c_yui_schema_editor} = await import("./c_yui_schema_editor.js");
+
+const logged = [];
+const commands = [];
+
+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"]},
+    ],
+    cols: [
+        {id: "db.users.id", value: "id", order: 1, type: "string",
+         flag: ["persistent", "required"], topics: ["topics^db.users^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
+    );
+    /*  The two states the library reads off a transport.  */
+    gclass_create(
+        "C_TEST_REMOTE",
+        [],
+        [["ST_DISCONNECTED", []], ["ST_SESSION", []]],
+        {mt_command_parser: remote_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);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    commands.length = 0;
+    shown.length = 0;
+});
+
+function take(command)
+{
+    const out = commands.filter((c) => c.command === command);
+    for(const c of out) {
+        commands.splice(commands.indexOf(c), 1);
+    }
+    return out;
+}
+
+/*  The answer, the way a transport gives it: the request's frame on top.  */
+function answer(editor, remote, request, result, data, comment)
+{
+    gobj_send_event(editor, "EV_MT_COMMAND_ANSWER", {
+        result: result,
+        comment: comment || "",
+        data: data,
+        __md_iev__: {command_stack: [{command: request.command, kw: request.kw}]}
+    }, remote);
+}
+
+function answer_the_load(editor, remote)
+{
+    const asked = take("nodes");
+    for(const c of asked) {
+        answer(editor, remote, c, 0, RECORDS[c.kw.topic_name]);
+    }
+    return asked.length;
+}
+
+function drop(editor, remote, host)
+{
+    gobj_change_state(remote, "ST_DISCONNECTED");
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+}
+
+function reconnect(editor, remote, host)
+{
+    gobj_change_state(remote, "ST_SESSION");
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
+}
+
+function build(name, loaded)
+{
+    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);
+    gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: true}, host);
+    if(loaded) {
+        expect(answer_the_load(editor, remote)).toBe(3);
+        gobj_send_event(editor, "EV_SHOW", {subpath: "db/users"}, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+    }
+    return {editor, remote, host};
+}
+
+/*  A write in flight: a new column, saved from its form.  */
+function start_a_write(editor, host)
+{
+    gobj_send_event(editor, "EV_SAVE_COLUMN", {
+        creating: true, topic: "users", values: {value: "name", type: "string"}
+    }, host);
+    expect(gobj_current_state(editor)).toBe("ST_SAVING");
+    const [write] = take("update-node");
+    expect(write).toBeTruthy();
+    return write;
+}
+
+function is_busy(editor)
+{
+    const $c = gobj_read_attr(editor, "$container");
+    return $c.querySelector(".SCHEMA_BODY").classList.contains("SCHEMA_BUSY");
+}
+
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+describe("a drop while LOADING", () => {
+
+    test("the editor leaves ST_LOADING, and the reconnect loads again", () => {
+        const {editor, remote, host} = build("l1", false);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(take("nodes").length).toBe(3);   /*  never answered  */
+
+        drop(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_IDLE");
+
+        reconnect(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_TREEDBS");
+        expect(errors()).toEqual([]);
+    });
+
+    test("an answer of the load the drop abandoned is not counted in the next one", () => {
+        const {editor, remote, host} = build("l2", false);
+        const old = take("nodes");
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        const fresh = take("nodes");
+        expect(fresh.length).toBe(3);
+
+        /*  The three OLD answers arrive late: were they counted, the new
+         *  round would end here with the old data and 3 answers owed.  */
+        for(const c of old) {
+            answer(editor, remote, c, 0, []);
+        }
+        expect(gobj_current_state(editor)).toBe("ST_LOADING");
+        for(const c of fresh) {
+            answer(editor, remote, c, 0, RECORDS[c.kw.topic_name]);
+        }
+        expect(gobj_current_state(editor)).toBe("ST_TREEDBS");
+        expect(editor.priv.model.treedbs.length).toBe(1);
+        expect(errors()).toEqual([]);
+    });
+});
+
+describe("a drop while SAVING", () => {
+
+    test("the write ends, said, the body answers again, and the reconnect reloads", () => {
+        const {editor, remote, host} = build("s1", true);
+        start_a_write(editor, host);
+        expect(is_busy(editor)).toBe(true);
+
+        drop(editor, remote, host);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(is_busy(editor)).toBe(false);
+        expect(shown).toEqual(["the connection dropped during the write"]);
+
+        /*  Whether the write landed is unknown: the model is asked again.  */
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+
+    test("the transport's own failure arriving FIRST is read as the drop it is", () => {
+        /*  A routing adapter settles what it had in flight when its session
+         *  closes, and that answer can reach the editor before the host's
+         *  EV_TRANSPORT_STATE. Read as a refusal, it ended the write and the
+         *  reconnect did not reload a model the write may have changed.  */
+        const {editor, remote, host} = build("s2", true);
+        const write = start_a_write(editor, host);
+
+        gobj_change_state(remote, "ST_DISCONNECTED");
+        answer(editor, remote, write, -1, null, "the connection dropped");
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(shown).toEqual(["the connection dropped during the write"]);
+
+        gobj_send_event(editor, "EV_TRANSPORT_STATE", {connected: false}, host);
+        expect(shown.length).toBe(1);   /*  said once  */
+
+        reconnect(editor, remote, host);
+        expect(answer_the_load(editor, remote)).toBe(3);
+        expect(errors()).toEqual([]);
+    });
+
+    test("the answer of the write the drop ended is not taken for the next one", () => {
+        const {editor, remote, host} = build("s3", true);
+        const write = start_a_write(editor, host);
+        drop(editor, remote, host);
+        reconnect(editor, remote, host);
+        answer_the_load(editor, remote);
+
+        const second = start_a_write(editor, host);
+        /*  The first write's answer, late: it must not end the second.  */
+        answer(editor, remote, write, 0, {id: "db.users.name", value: "name",
+            topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_SAVING");
+
+        answer(editor, remote, second, 0, {id: "db.users.name", value: "name", order: 2,
+            type: "string", topics: ["topics^db.users^cols"]});
+        expect(gobj_current_state(editor)).toBe("ST_COLUMNS");
+        expect(errors()).toEqual([]);
+    });
+});

package/src/schema_version_bump.test.js

@@ -19,17 +19,22 @@ const TOPIC = {id: "device_groups", topic_version: 5};
 
 describe("topic_is_draft", () => {
     it("says nothing about a topic this session never wrote", () => {
-        expect(topic_is_draft({}, TOPIC)).toBe(false);
+        expect(topic_is_draft({written: {}, host_ids: {}}, TOPIC)).toBe(false);
     });
 
     it("a written topic is a draft, whatever its version says", () => {
-        expect(topic_is_draft({device_groups: true}, TOPIC)).toBe(true);
-        expect(topic_is_draft({device_groups: true}, {id: "device_groups", topic_version: 6}))
-            .toBe(true);
+        expect(topic_is_draft({written: {device_groups: true}}, TOPIC)).toBe(true);
+        expect(topic_is_draft({written: {device_groups: true}},
+            {id: "device_groups", topic_version: 6})).toBe(true);
+    });
+
+    it("a topic the host names is a draft too (EV_DRAFTS)", () => {
+        expect(topic_is_draft({written: {}, host_ids: {device_groups: true}}, TOPIC)).toBe(true);
     });
 
     it("answers false rather than throwing on a missing half", () => {
         expect(topic_is_draft(null, TOPIC)).toBe(false);
-        expect(topic_is_draft({device_groups: true}, null)).toBe(false);
+        expect(topic_is_draft({written: {device_groups: true}}, null)).toBe(false);
+        expect(topic_is_draft({}, TOPIC)).toBe(false);
     });
 });

package/src/treedb_topics_transport.wiring.test.js

@@ -0,0 +1,228 @@
+/***********************************************************************
+ *          treedb_topics_transport.wiring.test.js
+ *
+ *      The WIRING of a form's write and the backend going away, driven
+ *      through the real gclasses (C_YUI_SHELL, C_YUI_TREEDB_TOPICS) on a
+ *      document double. The helper (form_writes_in_flight.js) was tested
+ *      and right; what failed was that two hosts never called the action
+ *      that uses it (M8 of the 2026-09-23 review), which no helper test
+ *      can see.
+ *
+ *          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 gobj_js = await import("@yuneta/gobj-js");
+const {
+    SDATA, SDATA_END, data_type_t, event_flag_t,
+    gclass_create,
+    gobj_start_up, gobj_create_yuno, gobj_create, gobj_create_service,
+    gobj_start, gobj_send_event,
+    gobj_change_state,
+    set_log_callback,
+} = gobj_js;
+const {register_c_yui_shell, yui_shell_set_connection_state} = await import("./c_yui_shell.js");
+const {register_c_yui_treedb_topics} = await import("./c_yui_treedb_topics.js");
+
+const logged = [];
+const answers = [];         /*  what the fake forms were told  */
+const commands = [];        /*  what the fake transport was asked  */
+
+/*
+ *  The transport: answers nothing, like a C_IEVENT_CLI whose socket is
+ *  about to drop. Its state is what `is_connected()` reads.
+ */
+function remote_command_parser(gobj, command, kw, src)
+{
+    commands.push({command, kw});
+    return null;
+}
+
+/*
+ *  A topic form, as C_YUI_TREEDB_TOPICS finds it (by gclass name and
+ *  `topic_name`) to answer its write.
+ */
+function ac_form_answer(gobj, event, kw, src)
+{
+    answers.push({topic: gobj.priv_topic, event, form_write: kw.form_write});
+    return 0;
+}
+
+let yuno = null;
+let remote = 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_REMOTE",
+        [],
+        [["ST_SESSION", []], ["ST_DISCONNECTED", []]],
+        {mt_command_parser: remote_command_parser},
+        0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    gclass_create(
+        "C_YUI_TREEDB_TOPIC_WITH_FORM",
+        [["EV_WRITE_DONE", 0], ["EV_WRITE_REFUSED", 0]],
+        [["ST_IDLE", [
+            ["EV_WRITE_DONE",    ac_form_answer, null],
+            ["EV_WRITE_REFUSED", ac_form_answer, null]
+        ]]],
+        {},
+        0,
+        [SDATA(data_type_t.DTP_STRING, "topic_name", 0, "", "topic"), SDATA_END()],
+        {}, 0, 0, 0, 0
+    );
+    /*  The host of the view: it hears what a CHILD view publishes.  */
+    gclass_create(
+        "C_TEST_VIEW_HOST",
+        [["EV_RECORD_WRITTEN", 0], ["EV_TOPIC_SELECTED", 0]],
+        [["ST_IDLE", [
+            ["EV_RECORD_WRITTEN", () => 0, null],
+            ["EV_TOPIC_SELECTED", () => 0, null]
+        ]]],
+        {}, 0, [SDATA_END()], {}, 0, 0, 0, 0
+    );
+    /*  An app that subscribes to EVERY event of its shell and declares
+     *  none of the new ones: wattyzer's and yunovatios' shape.  */
+    gclass_create("C_TEST_APP", [], [["ST_IDLE", []]], {}, 0, [SDATA_END()], {}, 0, 0, 0, 0);
+
+    register_c_yui_shell();
+    register_c_yui_treedb_topics();
+
+    yuno = gobj_create_yuno("wiring_yuno", "C_TEST_HOST", {});
+    gobj_start(yuno);
+});
+
+beforeEach(() => {
+    logged.length = 0;
+    answers.length = 0;
+    commands.length = 0;
+});
+
+function build(name)
+{
+    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);
+
+    remote = gobj_create_service(`${name}_remote`, "C_TEST_REMOTE", {}, yuno);
+    gobj_change_state(remote, "ST_SESSION");
+
+    const host = gobj_create(`${name}_host`, "C_TEST_VIEW_HOST", {}, yuno);
+    const topics = gobj_create_service(`${name}_topics`, "C_YUI_TREEDB_TOPICS", {
+        treedb_name: "treedb_test",
+        gobj_remote_yuno: remote
+    }, host);
+    gobj_start(topics);
+
+    const forms = {};
+    for(const topic of ["users", "roles"]) {
+        forms[topic] = gobj_create(`${name}_form_${topic}`, "C_YUI_TREEDB_TOPIC_WITH_FORM",
+            {topic_name: topic}, topics);
+        forms[topic].priv_topic = topic;
+    }
+    /*  What the start of a shell with no routes says is the fixture's,
+     *  not the behaviour under test: the check starts here.  */
+    logged.length = 0;
+    return {app, shell, topics, forms};
+}
+
+function save(topics, form, form_write)
+{
+    gobj_send_event(topics, "EV_UPDATE_RECORD",
+        {record: {id: "x"}, form_write: form_write}, form);
+}
+
+/*  EVERY error the run logged: the check a deployed page gets too.  */
+function errors()
+{
+    return logged.filter((l) => l.level === "error").map((l) => l.msg);
+}
+
+describe("a Save in flight when the backend drops (M8)", () => {
+
+    test("the shell's connection edge answers every form, with no host forwarding", () => {
+        const {shell, topics, forms} = build("t1");
+        yui_shell_set_connection_state(shell, true);
+
+        /*  Two forms, each at ITS serial 1: two writes, not one.  */
+        save(topics, forms.users, 1);
+        save(topics, forms.roles, 1);
+        expect(commands.filter((c) => c.command === "update-node").length).toBe(2);
+        expect(answers).toEqual([]);
+
+        yui_shell_set_connection_state(shell, false);
+
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_REFUSED", form_write: 1},
+            {topic: "roles", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+        expect(errors()).toEqual([]);
+    });
+
+    test("a host that also forwards EV_TRANSPORT_STATE: each write answered once", () => {
+        const {shell, topics, forms} = build("t2");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+
+        gobj_send_event(topics, "EV_TRANSPORT_STATE", {connected: false}, topics);
+        yui_shell_set_connection_state(shell, false);
+
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+    });
+
+    test("only an EDGE is published: a repeated 'down' answers nothing twice", () => {
+        const {shell, topics, forms} = build("t3");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+        yui_shell_set_connection_state(shell, false);
+        yui_shell_set_connection_state(shell, false);
+        expect(answers.length).toBe(1);
+    });
+
+    test("an app subscribed to every shell event is not sent the new one", () => {
+        /*  C_TEST_APP declares no event at all: were EV_CONNECTION_STATE
+         *  published to it, the FSM would log "Event NOT DEFINED".  */
+        const {shell} = build("t4");
+        yui_shell_set_connection_state(shell, true);
+        yui_shell_set_connection_state(shell, false);
+        expect(errors()).toEqual([]);
+    });
+
+    test("an answer from the backend settles its own form only", () => {
+        const {shell, topics, forms} = build("t5");
+        yui_shell_set_connection_state(shell, true);
+        save(topics, forms.users, 1);
+        save(topics, forms.roles, 1);
+
+        /*  The answer of the users write, the way C_IEVENT_CLI delivers it:
+         *  the request's frame on top of the command_stack.  */
+        const ok = {result: 0, comment: "", data: [{id: "x"}], __md_iev__: {
+            command_stack: [{command: "update-node", kw: {
+                topic_name: "users", treedb_name: "treedb_test", form_write: 1, record: {id: "x"}
+            }}]
+        }};
+        gobj_send_event(topics, "EV_MT_COMMAND_ANSWER", ok, remote);
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_DONE", form_write: 1},
+        ]);
+
+        yui_shell_set_connection_state(shell, false);
+        expect(answers).toEqual([
+            {topic: "users", event: "EV_WRITE_DONE", form_write: 1},
+            {topic: "roles", event: "EV_WRITE_REFUSED", form_write: 1},
+        ]);
+    });
+});

package/src/treedb_write_plan.js

@@ -116,4 +116,35 @@ function col_goes_back_to_treedb(desc, col)
     return topic_pkey2s(d).includes(col.id);
 }
 
-export {plan_treedb_writes, READONLY_FORM_TOOLBAR, col_goes_back_to_treedb};
+/************************************************************
+ *  The INSTANCE an update of `record` is for: its pkey2 values, as the
+ *  record held them when the form was opened, {pkey2: value}.
+ *
+ *  They go back as they WERE, never as the form's widget hands them: a
+ *  `time` pkey2 is an epoch rendered in a `datetime-local`, and a value
+ *  that crossed the widget (seconds dropped, a local wall time read
+ *  back, an hour the autumn change names twice) names ANOTHER instance
+ *  -- or none, and C_NODE falls back to the primary. The pkey2 is an
+ *  address, not a field of the edit.
+ ************************************************************/
+function instance_keys_of(record, desc)
+{
+    const keys = {};
+    if(!record || typeof record !== "object") {
+        return keys;
+    }
+    for(const k of topic_pkey2s(desc || {})) {
+        if(Object.prototype.hasOwnProperty.call(record, k) &&
+                record[k] !== undefined && record[k] !== null) {
+            keys[k] = record[k];
+        }
+    }
+    return keys;
+}
+
+export {
+    plan_treedb_writes,
+    READONLY_FORM_TOOLBAR,
+    col_goes_back_to_treedb,
+    instance_keys_of,
+};

package/src/treedb_write_plan.test.js

@@ -9,7 +9,8 @@
  ***********************************************************************/
 import { describe, test, expect } from "vitest";
 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";
 
 const WRITES = ["edition_mode", "new_button", "delete_button", "paste_button", "in_row_icons"];
@@ -133,3 +134,23 @@ describe("what goes back to treedb from a form", () => {
         expect(col_goes_back_to_treedb(null, COL.yuno_release)).toBe(false);
     });
 });
+
+describe("the instance an update is for", () => {
+    test("the pkey2 values as the record held them", () => {
+        expect(instance_keys_of({id: "a", yuno_release: "1.2.3", yuno_name: "x"}, YUNOS_DESC))
+            .toEqual({yuno_release: "1.2.3"});
+    });
+
+    test("a time pkey2 keeps its seconds: the ORIGINAL epoch, not the widget's", () => {
+        /*  A datetime-local that dropped the seconds, or read a local wall
+         *  time back, named another instance of the node.  */
+        const desc = {pkey: "id", pkey2s: ["tm"]};
+        expect(instance_keys_of({id: "a", tm: 1790000059}, desc)).toEqual({tm: 1790000059});
+    });
+
+    test("a record without the pkey2, or no pkey2s at all: nothing", () => {
+        expect(instance_keys_of({id: "a"}, YUNOS_DESC)).toEqual({});
+        expect(instance_keys_of({id: "a", yuno_release: "1"}, {pkey: "id"})).toEqual({});
+        expect(instance_keys_of(null, YUNOS_DESC)).toEqual({});
+    });
+});