diff --git a/src/plugins/qmldesigner/libs/designercore/model/modelnode.cpp b/src/plugins/qmldesigner/libs/designercore/model/modelnode.cpp
index b7a968fae92..59dd00bd925 100644
--- a/src/plugins/qmldesigner/libs/designercore/model/modelnode.cpp
+++ b/src/plugins/qmldesigner/libs/designercore/model/modelnode.cpp
@@ -71,7 +71,8 @@ QString ModelNode::id(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node id",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->id;
@@ -84,7 +85,8 @@ void ModelNode::ensureIdExists(SL sl) const
 
     NanotraceHR::Tracer tracer{"model node ensure id exists",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 }
 
@@ -92,7 +94,8 @@ QString ModelNode::validId(SL sl) const
 {
     NanotraceHR::Tracer tracer{"model node valid id",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     ensureIdExists(sl);
@@ -140,7 +143,8 @@ bool ModelNode::hasId(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has id",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return !m_internalNode->id.isEmpty();
@@ -154,7 +158,8 @@ void ModelNode::setIdWithRefactoring(const QString &id, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set id with refactoring",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (model()->rewriterView() && !id.isEmpty()
@@ -174,7 +179,8 @@ void ModelNode::setIdWithoutRefactoring(const QString &id, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set id without refactoring",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (!isValidId(id))
@@ -200,7 +206,8 @@ TypeName ModelNode::type(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->typeName;
@@ -217,7 +224,8 @@ int ModelNode::minorVersion(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node minor version",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->minorVersion;
@@ -234,7 +242,8 @@ int ModelNode::majorVersion(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node major version",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->majorVersion;
@@ -249,7 +258,8 @@ QString ModelNode::simplifiedTypeName(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node simplified type name",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return QString::fromUtf8(type().split('.').constLast());
@@ -259,7 +269,8 @@ QString ModelNode::displayName(SL sl) const
 {
     NanotraceHR::Tracer tracer{"model node display name",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasId() ? id() : simplifiedTypeName();
@@ -292,7 +303,8 @@ bool ModelNode::isInHierarchy(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node is in hierarchy",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (isRootNode())
@@ -319,7 +331,8 @@ NodeAbstractProperty ModelNode::parentProperty(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node parent property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (!m_internalNode->parentProperty())
@@ -357,7 +370,8 @@ void ModelNode::setParentProperty(NodeAbstractProperty parent, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set parent property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (!parent.parentModelNode().isValid())
@@ -380,7 +394,8 @@ void ModelNode::changeType(const TypeName &typeName, int majorVersion, int minor
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node change type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     model()->d->changeNodeType(m_internalNode, typeName, majorVersion, minorVersion);
@@ -390,7 +405,8 @@ void ModelNode::setParentProperty(const ModelNode &newParentNode, const Property
 {
     NanotraceHR::Tracer tracer{"model node set parent property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     setParentProperty(newParentNode.nodeAbstractProperty(propertyName), sl);
@@ -408,7 +424,8 @@ bool ModelNode::hasParentProperty(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has parent property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (!m_internalNode->parentProperty())
@@ -434,7 +451,8 @@ BindingProperty ModelNode::bindingProperty(PropertyNameView name, SL sl) const
 
     NanotraceHR::Tracer tracer{"model node binding property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return BindingProperty(name, m_internalNode, model(), view());
@@ -448,7 +466,8 @@ SignalHandlerProperty ModelNode::signalHandlerProperty(PropertyNameView name, SL
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node signal handler property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return SignalHandlerProperty(name, m_internalNode, model(), view());
@@ -462,7 +481,8 @@ SignalDeclarationProperty ModelNode::signalDeclarationProperty(PropertyNameView
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node signal declaration property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return SignalDeclarationProperty(name, m_internalNode, model(), view());
@@ -486,7 +506,8 @@ NodeProperty ModelNode::nodeProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node node property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return NodeProperty(name, m_internalNode, model(), view());
@@ -510,7 +531,8 @@ NodeListProperty ModelNode::nodeListProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node node list property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return NodeListProperty(name, m_internalNode, model(), view());
@@ -524,7 +546,8 @@ NodeAbstractProperty ModelNode::nodeAbstractProperty(PropertyNameView name, SL s
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node node abstract property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return NodeAbstractProperty(name, m_internalNode, model(), view());
@@ -534,7 +557,8 @@ NodeAbstractProperty ModelNode::defaultNodeAbstractProperty(SL sl) const
 {
     NanotraceHR::Tracer tracer{"model node default node abstract property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return nodeAbstractProperty(metaInfo().defaultPropertyName());
@@ -544,7 +568,8 @@ NodeListProperty ModelNode::defaultNodeListProperty(SL sl) const
 {
     NanotraceHR::Tracer tracer{"model node default node list property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return nodeListProperty(metaInfo().defaultPropertyName());
@@ -554,7 +579,8 @@ NodeProperty ModelNode::defaultNodeProperty(SL sl) const
 {
     NanotraceHR::Tracer tracer{"model node default node property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return nodeProperty(metaInfo().defaultPropertyName());
@@ -577,7 +603,8 @@ VariantProperty ModelNode::variantProperty(PropertyNameView name, SL sl) const
 
     NanotraceHR::Tracer tracer{"model node variant property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return VariantProperty(name, m_internalNode, model(), view());
@@ -591,7 +618,8 @@ AbstractProperty ModelNode::property(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return AbstractProperty(name, m_internalNode, model(), view());
@@ -620,7 +648,8 @@ QList<AbstractProperty> ModelNode::properties(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node properties",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     QList<AbstractProperty> propertyList;
@@ -645,7 +674,8 @@ QList<VariantProperty> ModelNode::variantProperties(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node variant property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return properties<VariantProperty>(PropertyType::Variant);
@@ -656,7 +686,8 @@ QList<NodeAbstractProperty> ModelNode::nodeAbstractProperties(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node node abstract property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return properties<NodeAbstractProperty>(PropertyType::Node, PropertyType::NodeList);
@@ -667,7 +698,8 @@ QList<NodeProperty> ModelNode::nodeProperties(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node node property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return properties<NodeProperty>(PropertyType::Node);
@@ -678,7 +710,8 @@ QList<NodeListProperty> ModelNode::nodeListProperties(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node node list property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return properties<NodeListProperty>(PropertyType::NodeList);
@@ -695,7 +728,8 @@ QList<BindingProperty> ModelNode::bindingProperties(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node binding property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return properties<BindingProperty>(PropertyType::Binding);
@@ -706,7 +740,8 @@ QList<SignalHandlerProperty> ModelNode::signalProperties(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node signal handler property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return properties<SignalHandlerProperty>(PropertyType::SignalHandler);
@@ -720,7 +755,8 @@ QList<AbstractProperty> ModelNode::dynamicProperties(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node dynamic property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     QList<AbstractProperty> properties;
@@ -751,7 +787,8 @@ void ModelNode::removeProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node remove property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (!model()->d->propertyNameIsValid(name))
@@ -798,7 +835,8 @@ void ModelNode::destroy(SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node destroy",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (isRootNode())
@@ -843,7 +881,8 @@ QList<ModelNode> ModelNode::directSubModelNodes(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node direct sub model nodes",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return toModelNodeList(m_internalNode->allDirectSubNodes(), model(), view());
@@ -854,7 +893,8 @@ QList<ModelNode> ModelNode::directSubModelNodesOfType(const NodeMetaInfo &type,
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node direct sub model nodes of type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return Utils::filtered(directSubModelNodes(), [&](const ModelNode &node) {
@@ -867,7 +907,8 @@ QList<ModelNode> ModelNode::subModelNodesOfType(const NodeMetaInfo &type, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node sub model nodes of type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return Utils::filtered(allSubModelNodes(), [&](const ModelNode &node) {
@@ -890,7 +931,8 @@ QList<ModelNode> ModelNode::allSubModelNodes(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node all sub model nodes",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return toModelNodeList(internalNode()->allSubNodes(), model(), view());
@@ -901,7 +943,8 @@ QList<ModelNode> ModelNode::allSubModelNodesAndThisNode(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node all sub model nodes and this node",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     QList<ModelNode> modelNodeList;
@@ -922,7 +965,8 @@ bool ModelNode::hasAnySubModelNodes(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has any sub model nodes",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return !nodeAbstractProperties().isEmpty();
@@ -937,7 +981,8 @@ NodeMetaInfo ModelNode::metaInfo([[maybe_unused]] SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node meta info",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return NodeMetaInfo(m_internalNode->typeId, m_model->projectStorage());
@@ -957,7 +1002,8 @@ bool ModelNode::hasMetaInfo(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has meta info",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return model()->hasNodeMetaInfo(type(), majorVersion(), minorVersion());
@@ -974,7 +1020,8 @@ bool ModelNode::isSelected(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node is selected",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return model()->d->selectedNodes().contains(internalNode());
@@ -991,7 +1038,8 @@ bool ModelNode::isRootNode(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node is root node",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_model->d->rootNode() == m_internalNode;
@@ -1012,7 +1060,8 @@ PropertyNameList ModelNode::propertyNames(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node property names",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->propertyNameList();
@@ -1048,7 +1097,8 @@ bool ModelNode::hasProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return isValid() && m_internalNode->property(name);
@@ -1059,7 +1109,8 @@ bool ModelNode::hasVariantProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has variant property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasProperty(name, PropertyType::Variant);
@@ -1070,7 +1121,8 @@ bool ModelNode::hasBindingProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has binding property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasProperty(name, PropertyType::Binding);
@@ -1081,7 +1133,8 @@ bool ModelNode::hasSignalHandlerProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has signal handler property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasProperty(name, PropertyType::SignalHandler);
@@ -1095,7 +1148,8 @@ bool ModelNode::hasNodeAbstractProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has node abstract property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (auto property = m_internalNode->property(name))
@@ -1109,7 +1163,8 @@ bool ModelNode::hasDefaultNodeAbstractProperty(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has default node abstract property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     auto defaultPropertyName = metaInfo().defaultPropertyName();
@@ -1121,7 +1176,8 @@ bool ModelNode::hasDefaultNodeListProperty(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has default node list property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     auto defaultPropertyName = metaInfo().defaultPropertyName();
@@ -1133,7 +1189,8 @@ bool ModelNode::hasDefaultNodeProperty(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has default node property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     auto defaultPropertyName = metaInfo().defaultPropertyName();
@@ -1145,7 +1202,8 @@ bool ModelNode::hasNodeProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has node property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasProperty(name, PropertyType::Node);
@@ -1156,7 +1214,8 @@ bool ModelNode::hasNodeListProperty(PropertyNameView name, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has node list property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasProperty(name, PropertyType::NodeList);
@@ -1170,7 +1229,8 @@ bool ModelNode::hasProperty(PropertyNameView name, PropertyType propertyType, SL
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has property",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (auto property = m_internalNode->property(name))
@@ -1198,7 +1258,8 @@ bool ModelNode::isAncestorOf(const ModelNode &node, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node is ancestor of",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return recursiveAncestor(*this, node);
@@ -1237,7 +1298,8 @@ void ModelNode::selectNode(SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node select node",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     QList<ModelNode> selectedNodeList;
@@ -1254,7 +1316,8 @@ void ModelNode::deselectNode(SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node deselect node",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     auto selectedNodes = model()->d->selectedNodes();
@@ -1272,7 +1335,8 @@ QVariant ModelNode::toVariant(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node to variant",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return QVariant::fromValue(*this);
@@ -1286,7 +1350,8 @@ std::optional<QVariant> ModelNode::auxiliaryData(AuxiliaryDataKeyView key, SL sl
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node auxiliary data",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->auxiliaryData(key);
@@ -1302,7 +1367,8 @@ std::optional<QVariant> ModelNode::auxiliaryData(AuxiliaryDataType type,
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node auxiliary data with name",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return auxiliaryData({type, name});
@@ -1318,7 +1384,8 @@ QVariant ModelNode::auxiliaryDataWithDefault(AuxiliaryDataType type,
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node auxiliary data with default 1",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return auxiliaryDataWithDefault({type, name});
@@ -1332,7 +1399,8 @@ QVariant ModelNode::auxiliaryDataWithDefault(AuxiliaryDataKeyView key, SL sl) co
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node auxiliary data with default 2",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     auto data = m_internalNode->auxiliaryData(key);
@@ -1351,7 +1419,8 @@ QVariant ModelNode::auxiliaryDataWithDefault(AuxiliaryDataKeyDefaultValue key, S
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node auxiliary data with default 3",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     auto data = m_internalNode->auxiliaryData(key);
@@ -1370,7 +1439,8 @@ void ModelNode::setAuxiliaryData(AuxiliaryDataType type,
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set auxiliary data with type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     setAuxiliaryData({type, name}, data);
@@ -1384,7 +1454,8 @@ void ModelNode::setAuxiliaryData(AuxiliaryDataKeyView key, const QVariant &data,
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set auxiliary data with key",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (key.type == AuxiliaryDataType::Persistent)
@@ -1401,7 +1472,8 @@ void ModelNode::setAuxiliaryDataWithoutLock(AuxiliaryDataKeyView key, const QVar
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set auxiliary data without lock with key",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (key.type == AuxiliaryDataType::Persistent)
@@ -1421,7 +1493,8 @@ void ModelNode::setAuxiliaryDataWithoutLock(AuxiliaryDataType type,
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set auxiliary data without lock with type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (type == AuxiliaryDataType::Persistent)
@@ -1438,7 +1511,8 @@ void ModelNode::removeAuxiliaryData(AuxiliaryDataKeyView key, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node remove auxiliary data with key",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (key.type == AuxiliaryDataType::Persistent)
@@ -1453,7 +1527,8 @@ void ModelNode::removeAuxiliaryData(AuxiliaryDataType type, Utils::SmallStringVi
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node remove auxiliary data with type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     removeAuxiliaryData({type, name});
@@ -1467,7 +1542,8 @@ bool ModelNode::hasAuxiliaryData(AuxiliaryDataKeyView key, SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has auxiliary data with key",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->hasAuxiliaryData(key);
@@ -1478,7 +1554,8 @@ bool ModelNode::hasAuxiliaryData(AuxiliaryDataType type, Utils::SmallStringView
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has auxiliary data with type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasAuxiliaryData({type, name});
@@ -1492,7 +1569,7 @@ bool ModelNode::hasAuxiliaryData(AuxiliaryDataType type) const
     // using NanotraceHR::keyValue;
     // NanotraceHR::Tracer tracer{"model node has auxiliary data with type",
     //                            category(),
-    //                            keyValue("type id", m_internalNode->typeId),
+    //                            keyValue("node id", reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
     //                            keyValue("caller location", sl)};
 
     return m_internalNode->hasAuxiliaryData(type);
@@ -1506,7 +1583,8 @@ AuxiliaryDatasForType ModelNode::auxiliaryData(AuxiliaryDataType type, SL sl) co
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node auxiliary data with type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->auxiliaryData(type);
@@ -1520,7 +1598,8 @@ AuxiliaryDatasView ModelNode::auxiliaryData(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node auxiliary data with sl",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->auxiliaryData();
@@ -1533,7 +1612,8 @@ QString ModelNode::customId(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node custom id",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (data)
@@ -1547,7 +1627,8 @@ bool ModelNode::hasCustomId(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has custom id",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasAuxiliaryData(customIdProperty);
@@ -1558,7 +1639,8 @@ void ModelNode::setCustomId(const QString &str, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set custom id",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     setAuxiliaryData(customIdProperty, QVariant::fromValue(str));
@@ -1569,7 +1651,8 @@ void ModelNode::removeCustomId(SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node remove custom id",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     removeAuxiliaryData(customIdProperty);
@@ -1580,7 +1663,8 @@ QVector<Comment> ModelNode::comments(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node comments",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return annotation().comments();
@@ -1591,7 +1675,8 @@ bool ModelNode::hasComments(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has comments",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return annotation().hasComments();
@@ -1602,7 +1687,8 @@ void ModelNode::setComments(const QVector<Comment> &coms, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set comments",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     Annotation anno = annotation();
@@ -1616,7 +1702,8 @@ void ModelNode::addComment(const Comment &com, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node add comment",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     Annotation anno = annotation();
@@ -1630,7 +1717,8 @@ bool ModelNode::updateComment(const Comment &com, int position, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node update comment",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     bool result = false;
@@ -1651,7 +1739,8 @@ Annotation ModelNode::annotation(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node annotation",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     auto data = auxiliaryData(annotationProperty);
@@ -1667,7 +1756,8 @@ bool ModelNode::hasAnnotation(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has annotation",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasAuxiliaryData(annotationProperty);
@@ -1678,7 +1768,8 @@ void ModelNode::setAnnotation(const Annotation &annotation, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set annotation",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     setAuxiliaryData(annotationProperty, QVariant::fromValue(annotation.toQString()));
@@ -1689,7 +1780,8 @@ void ModelNode::removeAnnotation(SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node remove annotation",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     removeAuxiliaryData(annotationProperty);
@@ -1700,7 +1792,8 @@ Annotation ModelNode::globalAnnotation(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node global annotation",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     Annotation result;
@@ -1719,7 +1812,8 @@ bool ModelNode::hasGlobalAnnotation(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has global annotation",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_model->rootModelNode().hasAuxiliaryData(globalAnnotationProperty);
@@ -1730,7 +1824,8 @@ void ModelNode::setGlobalAnnotation(const Annotation &annotation, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set global annotation",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
     m_model->rootModelNode().setAuxiliaryData(globalAnnotationProperty,
                                               QVariant::fromValue(annotation.toQString()));
@@ -1741,7 +1836,8 @@ void ModelNode::removeGlobalAnnotation(SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node remove global annotation",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     m_model->rootModelNode().removeAuxiliaryData(globalAnnotationProperty);
@@ -1752,7 +1848,8 @@ GlobalAnnotationStatus ModelNode::globalStatus(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node global status",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     GlobalAnnotationStatus result;
@@ -1771,7 +1868,8 @@ bool ModelNode::hasGlobalStatus(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has global status",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_model->rootModelNode().hasAuxiliaryData(globalAnnotationStatus);
@@ -1782,7 +1880,8 @@ void ModelNode::setGlobalStatus(const GlobalAnnotationStatus &status, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set global status",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     m_model->rootModelNode().setAuxiliaryData(globalAnnotationStatus,
@@ -1794,7 +1893,8 @@ void ModelNode::removeGlobalStatus(SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node remove global status",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (hasGlobalStatus()) {
@@ -1807,7 +1907,8 @@ bool ModelNode::locked(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node locked",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     auto data = auxiliaryData(lockedProperty);
@@ -1823,7 +1924,8 @@ bool ModelNode::hasLocked(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node has locked",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return hasAuxiliaryData(lockedProperty, sl);
@@ -1834,7 +1936,8 @@ void ModelNode::setLocked(bool value, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set locked",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (value) {
@@ -1858,7 +1961,8 @@ void ModelNode::setScriptFunctions(const QStringList &scriptFunctionList, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set script functions",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     model()->d->setScriptFunctions(m_internalNode, scriptFunctionList);
@@ -1872,7 +1976,8 @@ QStringList ModelNode::scriptFunctions(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node script functions",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->scriptFunctions;
@@ -1886,7 +1991,8 @@ qint32 ModelNode::internalId(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node internal id",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->internalId;
@@ -1902,7 +2008,8 @@ void ModelNode::setNodeSource(const QString &newNodeSource, SL sl)
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set node source",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (m_internalNode->nodeSource == newNodeSource)
@@ -1921,7 +2028,8 @@ void ModelNode::setNodeSource(const QString &newNodeSource, NodeSourceType type,
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node set node source with type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (m_internalNode->nodeSourceType == type && m_internalNode->nodeSource == newNodeSource)
@@ -1939,7 +2047,8 @@ QString ModelNode::nodeSource(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node node source",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->nodeSource;
@@ -1953,7 +2062,8 @@ QString ModelNode::convertTypeToImportAlias(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node convert type to import alias",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (model()->rewriterView())
@@ -1970,7 +2080,8 @@ ModelNode::NodeSourceType ModelNode::nodeSourceType(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node node source type",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return static_cast<ModelNode::NodeSourceType>(m_internalNode->nodeSourceType);
@@ -1984,7 +2095,8 @@ bool ModelNode::isComponent(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node is component",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (!metaInfo().isValid())
@@ -2047,7 +2159,8 @@ QIcon ModelNode::typeIcon([[maybe_unused]] SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node type icon",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     if (auto iconPath = metaInfo().iconPath(); iconPath.size())
@@ -2079,7 +2192,8 @@ QString ModelNode::behaviorPropertyName(SL sl) const
     using NanotraceHR::keyValue;
     NanotraceHR::Tracer tracer{"model node behavior property name",
                                category(),
-                               keyValue("type id", m_internalNode->typeId),
+                               keyValue("node id",
+                                        reinterpret_cast<std::uintptr_t>(m_internalNode.get())),
                                keyValue("caller location", sl)};
 
     return m_internalNode->behaviorPropertyName;