Argentum objects got parent pointers and safe-n-fast object reattachments

using array;  // this module extends Array with `append` and many other methods
class Node {
    tag = "default-tag";
    children = sys_Array(Node);

    withTag(v str) this { tag := v }
    add(c()@Node) this { children.append(c) }
    parent() Node {
        sys_getParent(this)   // our nodes live in children arrays, so the first getParent returns array
        && sys_getParent(_)   // the second getParent returns array`s parent i.e Node object
        && _~Node             // cast it to Node
        : Node.withTag("no-parent")  // If any parents are absent or it is not a Node, return a temp dummy Node
                                     // Alternatively we can call sys_terminate, though it's not resilient
                                     // Or (preferably) return ?Node, informing the caller code of absence
    }
    getAt(index int) Node { children[index] : Node.withTag("no-child") } // again, there are plenty of ways of handling index OOB here 
}

root = Node.withTag("document")
    .add(Node.withTag("head"))
    .add(Node.withTag("body")
        .add(Node.withTag("div")));
div = root[1][0];

sys_log(div.parent().parent().tag);  // prints "document"

// Example continued
root.children[1] := Node; // Now body does not belong to the root document.
                          // it will be deleted,
                          // but its nested div is still retained with `div` variable.
root.children.spliceAt(1, div); // Now div is inserted in root collection.

// This class definition should be declared before all imperative code
class Pair {
   a = Node;
   b = Node;
}

// Continued example
p = Pair;
head = root[0];
root := Node; // Now all document is deleted, but the head is retained by the local reference.
p.a @= head;  // "Splice it to the field" operator @=

using array;
using string;
const LN = utf32_(0x0a);

fn log(s str) { sys_log("{s}{LN}") }

class Pair {
   a = Node;
   b = Node;
}

class Node {
    tag = "empty";
    children = sys_Array(Node);

    call(v str) this { tag := v }
    add(c()@Node) this { children.append(c) }
    parent() Node {
        sys_getParent(this) && sys_getParent(_) && _~Node : Node("no-parent")
    }
    getAt(index int) Node { children[index] : Node("no-child") } // Again, there are plenty of ways of handling index OOB here.
    dump(title str) {
        log("{title}: ");
        dumpRecur("")
    }
    dumpRecur(prefix str) {
        log("{prefix}{tag}");
        children.each\_.dumpRecur("{prefix}   ")
    }
}

root = Node("document")
    .add(Node("head"))
    .add(Node("body")
        .add(Node("div")));
root.dump("Initial");

div = root[1][0];
div.dump("div-subree");

log("div.parent.parent: {div.parent().parent().tag}");  // prints "document"

root.children[1] := Node;
root.dump("after root.children[1] := Node");

root.children.spliceAt(1, div);
root.dump("root.children.spliceAt(1, div)");

p = Pair;
head = root[0];
root := Node;
p.a @= head;
p.a.dump("head is spliced into a pair");