@keenmate/svelte-treeview 4.8.0 → 5.0.0-rc02

package/dist/ltree/ltree.svelte.js

@@ -5,7 +5,11 @@ import { getLevel, getParentPath, getPathSegments, getRelativePath } from '../he
 import { createSearchIndex } from './flex.js';
 import { Indexer } from './indexer.js';
 import { perfStart, perfEnd, perfSummary } from '../perf-logger.js';
-export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMember, _hasChildrenMember, _isExpandedMember, _isSelectableMember, _isDraggableMember, _isDropAllowedMember, _allowedDropPositionsMember, _displayValueMember, _getDisplayValueCallback, _searchValueMember, _getSearchValueCallback, _getAllowedDropPositionsCallback, _orderMember, _treeId, _treePathSeparator, _expandLevel, _shouldUseInternalSearchIndex, _initializeIndexCallback, _indexerBatchSize, _indexerTimeout, opts) {
+/** Helper to safely access a property on a generic data item using a string member name */
+function getField(item, member) {
+    return item[member];
+}
+export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMember, _hasChildrenMember, _isExpandedMember, _isSelectableMember, _isDraggableMember, _getIsDraggableCallback, _isDropAllowedMember, _allowedDropPositionsMember, _displayValueMember, _getDisplayValueCallback, _searchValueMember, _getSearchValueCallback, _getAllowedDropPositionsCallback, _isCollapsibleMember, _getIsCollapsibleCallback, _orderMember, _treeId, _treePathSeparator, _expandLevel, _shouldUseInternalSearchIndex, _initializeIndexCallback, _indexerBatchSize, _indexerTimeout, opts) {
     let shouldCalculateParentPath = isEmptyString(_parentPathMember);
     let shouldCalculateLevel = isEmptyString(_levelMember);
     let shouldCalculateHasChildren = isEmptyString(_hasChildrenMember);
@@ -14,6 +18,7 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
     let shouldCalculateIsDraggable = isEmptyString(_isDraggableMember);
     let shouldCalculateIsDropAllowed = isEmptyString(_isDropAllowedMember);
     let shouldCalculateAllowedDropPositions = isEmptyString(_allowedDropPositionsMember);
+    let shouldCalculateIsCollapsible = isEmptyString(_isCollapsibleMember);
     let shouldCalculateDisplayValue = isEmptyString(_displayValueMember);
     let shouldCalculateSearchValue = isEmptyString(_searchValueMember);
     // this is absolutely crucial to keep order of sorted items. Segments are just numbers and numbers as properties are always sorted
@@ -41,33 +46,13 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
     if (_shouldUseInternalSearchIndex && searchIndex) {
         indexer = new Indexer(_treeId || 'unknown', searchIndex, shouldCalculateSearchValue, _searchValueMember, _getSearchValueCallback, _indexerBatchSize || 25, // batch size with fallback
         _indexerTimeout || 50, // timeout with fallback
-        opts.shouldDisplayDebugInformation);
-    }
-    // Per-node reactive signals for O(1) fine-grained updates.
-    // Each NodeSignal is an independent $state — bumping one only notifies
-    // the single Node component that reads it. Stored in a plain Map
-    // (not $state) to avoid proxy overhead.
-    class NodeSignal {
-        value = $state(0);
-        bump() { this.value++; }
-    }
-    let nodeSignals = new Map();
-    function _bumpRev(node) {
-        node._rev = (node._rev || 0) + 1;
-    }
-    function _bumpNodeRev(node) {
-        // Signal only — do NOT bump _rev. _rev is part of the {#each} key,
-        // so bumping it would cause {#each} to detect a key change and
-        // destroy/recreate the component (O(n) diffing). We only want the
-        // per-node signal to fire, which is O(1).
-        const signal = nodeSignals.get(String(node.id));
-        if (signal)
-            signal.bump();
+        opts?.shouldDisplayDebugInformation ?? false);
     }
     return {
         // Properties
         treePathSeparator: _treePathSeparator || '.',
         root,
+        filteredRoot,
         get changeTracker() {
             return changeTracker;
         },
@@ -78,6 +63,7 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
         isExpandedMember: _isExpandedMember,
         isSelectableMember: _isSelectableMember,
         isDraggableMember: _isDraggableMember,
+        getIsDraggableCallback: _getIsDraggableCallback,
         isDropAllowedMember: _isDropAllowedMember,
         allowedDropPositionsMember: _allowedDropPositionsMember,
         hasChildrenMember: _hasChildrenMember,
@@ -86,8 +72,11 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
         searchValueMember: _searchValueMember,
         getSearchValueCallback: _getSearchValueCallback,
         getAllowedDropPositionsCallback: _getAllowedDropPositionsCallback,
+        isCollapsibleMember: _isCollapsibleMember,
+        getIsCollapsibleCallback: _getIsCollapsibleCallback,
         orderMember: _orderMember,
-        isSorted: opts?.isSorted ?? false,
+        isSorted: false,
+        shouldDisplayDebugInformation: opts?.shouldDisplayDebugInformation ?? false,
         // Properties for filtering
         filteredTree,
         isFiltered,
@@ -128,7 +117,8 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             const result = [];
             const self = this;
             function traverse(node) {
-                // Get children in natural tree key order (same as recursive mode)
+                // Get children in natural tree key order (same as recursive mode).
+                // Sorting was already applied at insertion time in insertArray().
                 const children = Object.values(node.children);
                 for (const child of children) {
                     result.push(child);
@@ -157,12 +147,6 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
         },
         insertArray: function (data, noEmitChanges = false) {
             data = data || [];
-            // Create per-node signals for O(1) reactive updates
-            nodeSignals = new Map();
-            for (let i = 0; i < data.length; i++) {
-                const id = _idMember ? data[i][_idMember] : i;
-                nodeSignals.set(String(id), new NodeSignal());
-            }
             // Clear any pending indexing from previous calls
             indexer?.clearQueue();
             flatTreeNodes = [];
@@ -171,38 +155,56 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             nodeCount = 0;
             maxLevel = 0;
             perfStart(`[${_treeId}] insertArray:conversion`);
+            const conversionFailures = [];
             let mappedData = data.map((row, index) => {
                 const node = createLTreeNode();
-                node.treeId = _treeId;
-                node.id = _idMember ? row[_idMember] : undefined;
-                node.path = _pathMember ? row[_pathMember] : undefined;
+                node.treeId = _treeId || '';
+                node.id = _idMember ? getField(row, _idMember) : undefined;
+                const rawPath = _pathMember ? getField(row, _pathMember) : undefined;
+                // Validate path - must be a non-empty string
+                if (rawPath == null || rawPath === '' || typeof rawPath !== 'string') {
+                    node.path = '';
+                    node.data = row;
+                    const pathDesc = rawPath === '' ? 'empty string'
+                        : rawPath == null ? 'undefined/null'
+                            : `non-string (${typeof rawPath})`;
+                    conversionFailures.push({
+                        node,
+                        originalData: row,
+                        error: `Item at index ${index} has invalid path (${pathDesc}). Check that pathMember="${_pathMember}" matches your data. First item keys: ${index === 0 ? JSON.stringify(Object.keys(row)) : '(see index 0)'}`
+                    });
+                    return null;
+                }
+                node.path = rawPath;
                 if (shouldCalculateParentPath) {
                     node.parentPath = getParentPath(node.path, this.treePathSeparator);
                 }
                 else
-                    node.parentPath = row[_parentPathMember];
-                node.pathSegment = getPathSegments(getRelativePath(node.path, node.parentPath, this.treePathSeparator), 0, 1, this.treePathSeparator);
+                    node.parentPath = getField(row, _parentPathMember);
+                node.pathSegment = getPathSegments(getRelativePath(node.path, node.parentPath ?? '', this.treePathSeparator), 0, 1, this.treePathSeparator);
                 if (!shouldCalculateLevel)
-                    node.level = row[_levelMember];
+                    node.level = getField(row, _levelMember);
                 else
                     node.level = getLevel(node.path, this.treePathSeparator);
                 if (!shouldCalculateIsExpanded)
-                    node.isExpanded = row[_isExpandedMember];
+                    node.isExpanded = getField(row, _isExpandedMember);
                 else if (_expandLevel)
-                    node.isExpanded = node.level <= _expandLevel;
+                    node.isExpanded = (node.level ?? 0) <= _expandLevel;
                 if (!shouldCalculateIsSelectable)
-                    node.isSelectable = row[_isSelectableMember];
+                    node.isSelectable = getField(row, _isSelectableMember);
                 if (!shouldCalculateIsDraggable)
-                    node.isDraggable = row[_isDraggableMember];
+                    node.isDraggable = getField(row, _isDraggableMember);
+                if (!shouldCalculateIsCollapsible)
+                    node.isCollapsible = getField(row, _isCollapsibleMember);
                 if (!shouldCalculateIsDropAllowed)
-                    node.isDropAllowed = row[_isDropAllowedMember];
+                    node.isDropAllowed = getField(row, _isDropAllowedMember);
                 if (!shouldCalculateAllowedDropPositions)
-                    node.allowedDropPositions = row[_allowedDropPositionsMember];
+                    node.allowedDropPositions = getField(row, _allowedDropPositionsMember);
                 if (!shouldCalculateHasChildren)
-                    node.hasChildren = row[_hasChildrenMember];
+                    node.hasChildren = getField(row, _hasChildrenMember);
                 node.data = row;
                 return node;
-            });
+            }).filter((node) => node !== null);
             const conversionTime = perfEnd(`[${_treeId}] insertArray:conversion`, data.length);
             perfStart(`[${_treeId}] insertArray:sort`);
             if (!this.isSorted) {
@@ -213,7 +215,12 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             }
             const sortTime = perfEnd(`[${_treeId}] insertArray:sort`, data.length);
             perfStart(`[${_treeId}] insertArray:insert`);
-            const failedNodes = [];
+            const failedNodes = [...conversionFailures];
+            // Warn early about data mapping issues (most common user error)
+            if (conversionFailures.length > 0) {
+                console.warn(`[Tree ${_treeId}] ${conversionFailures.length} of ${data.length} items have invalid paths (pathMember="${_pathMember}"). These items will be skipped.\n` +
+                    `First failure: ${conversionFailures[0].error}`);
+            }
             const itemsToIndex = [];
             let realIndex = 0; // this is used to avoid scenario, when node cannot found a parent
             let successfulCount = 0;
@@ -230,7 +237,7 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 }
             }
             mappedData.forEach((node, index) => {
-                const result = this.insertTreeNode(node.parentPath, node, true);
+                const result = this.insertTreeNode(node.parentPath ?? '', node, true);
                 if (result) {
                     failedNodes.push({
                         node: node,
@@ -276,7 +283,7 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             }
             const insertTime = perfEnd(`[${_treeId}] insertArray:insert`, data.length);
             // Log performance summary
-            perfSummary(_treeId, {
+            perfSummary(_treeId || 'unknown', {
                 'Conversion': conversionTime,
                 'Sort': sortTime,
                 'Insert': insertTime
@@ -411,27 +418,44 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
         },
         expandAll(nodePath) {
             perfStart(`[${_treeId}] expandAll`);
-            if (isEmptyString(nodePath))
-                flatTreeNodes.forEach((row) => {
-                    if (!row.isExpanded) {
-                        row.isExpanded = true;
-                        _bumpRev(row);
-                    }
-                });
+            function setExpandedRecursive(node, value) {
+                node.isExpanded = value;
+                for (const key in node.children) {
+                    setExpandedRecursive(node.children[key], value);
+                }
+            }
+            if (isEmptyString(nodePath)) {
+                setExpandedRecursive(root, true);
+            }
+            else {
+                const target = this.getNodeByPath(nodePath);
+                if (target)
+                    setExpandedRecursive(target, true);
+            }
             this._emitTreeChanged();
-            perfEnd(`[${_treeId}] expandAll`, flatTreeNodes.length);
+            perfEnd(`[${_treeId}] expandAll`);
         },
         collapseAll(nodePath) {
             perfStart(`[${_treeId}] collapseAll`);
-            if (isEmptyString(nodePath))
-                flatTreeNodes.forEach((row) => {
-                    if (row.isExpanded) {
-                        row.isExpanded = false;
-                        _bumpRev(row);
-                    }
-                });
+            const self = this;
+            function collapseRecursive(node) {
+                if (node.isExpanded && self.getNodeIsCollapsible(node)) {
+                    node.isExpanded = false;
+                }
+                for (const key in node.children) {
+                    collapseRecursive(node.children[key]);
+                }
+            }
+            if (isEmptyString(nodePath)) {
+                collapseRecursive(root);
+            }
+            else {
+                const target = this.getNodeByPath(nodePath);
+                if (target)
+                    collapseRecursive(target);
+            }
             this._emitTreeChanged();
-            perfEnd(`[${_treeId}] collapseAll`, flatTreeNodes.length);
+            perfEnd(`[${_treeId}] collapseAll`);
         },
         insert: function (path, data, noEmitChanges = false) {
             let node = this.root;
@@ -465,7 +489,6 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                     // Only mark as changed if actually changing from collapsed to expanded
                     if (!node.isExpanded) {
                         node.isExpanded = true;
-                        _bumpRev(node);
                         hasChanges = true;
                     }
                 }
@@ -485,14 +508,13 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 const segment = segmentPrefix + segments[i];
                 if (node.children.hasOwnProperty(segment)) {
                     node = node.children[segment];
-                    // Only mark as changed if actually changing from expanded to collapsed
-                    if (node.isExpanded) {
-                        node.isExpanded = false;
-                        _bumpRev(node);
-                        hasChanges = true;
-                    }
                 }
             }
+            // Only collapse the target node, not ancestors
+            if (node.isExpanded) {
+                node.isExpanded = false;
+                hasChanges = true;
+            }
             // Only emit changes if something actually changed
             if (!noEmitChanges && hasChanges) {
                 this._emitTreeChanged();
@@ -515,15 +537,15 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             return node;
         },
         getNodeDisplayValue(node) {
-            if (!shouldCalculateDisplayValue)
-                return node.data[_displayValueMember];
+            if (!shouldCalculateDisplayValue && node.data)
+                return getField(node.data, _displayValueMember);
             if (this.getDisplayValueCallback)
                 return this.getDisplayValueCallback(node);
             return '[N/A]';
         },
         getNodeSearchValue(node) {
-            if (!shouldCalculateSearchValue)
-                return node.data[_searchValueMember];
+            if (!shouldCalculateSearchValue && node.data)
+                return getField(node.data, _searchValueMember);
             if (this.getSearchValueCallback)
                 return this.getSearchValueCallback(node);
             return '[N/A]';
@@ -534,18 +556,26 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 return this.getAllowedDropPositionsCallback(node);
             }
             if (!shouldCalculateAllowedDropPositions && node.data) {
-                return node.data[_allowedDropPositionsMember];
+                return getField(node.data, _allowedDropPositionsMember);
             }
             return node.allowedDropPositions;
         },
-        refresh() {
-            this._emitTreeChanged();
+        getNodeIsDraggable(node) {
+            if (this.getIsDraggableCallback)
+                return this.getIsDraggableCallback(node);
+            if (!shouldCalculateIsDraggable && node.data)
+                return getField(node.data, _isDraggableMember);
+            return node.isDraggable;
         },
-        getNodeSignal(id) {
-            return nodeSignals.get(id);
+        getNodeIsCollapsible(node) {
+            if (this.getIsCollapsibleCallback)
+                return this.getIsCollapsibleCallback(node);
+            if (!shouldCalculateIsCollapsible && node.data)
+                return getField(node.data, _isCollapsibleMember);
+            return node.isCollapsible;
         },
-        bumpNodeRev(node) {
-            _bumpNodeRev(node);
+        refresh() {
+            this._emitTreeChanged();
         },
         /**
          * Get direct children of a node at the given path
@@ -553,8 +583,10 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
          * @returns Array of child nodes
          */
         getChildren(parentPath) {
+            // Read changeTracker to create reactive dependency for custom recursive renderers
+            const _tracker = changeTracker;
             const parent = this.getNodeByPath(parentPath);
-            if (!parent)
+            if (!parent || !_tracker)
                 return [];
             return Object.values(parent.children);
         },
@@ -564,8 +596,10 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
          * @returns Array of sibling nodes (nodes with same parent)
          */
         getSiblings(path) {
+            // Read changeTracker to create reactive dependency for custom recursive renderers
+            const _tracker = changeTracker;
             const node = this.getNodeByPath(path);
-            if (!node)
+            if (!node || !_tracker)
                 return [];
             // Get parent and return all its children
             const parentPath = node.parentPath || '';
@@ -594,8 +628,8 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 sorted = [...children].sort((a, b) => {
                     // If orderMember is provided, use it
                     if (this.orderMember && a.data && b.data) {
-                        const aOrder = a.data[this.orderMember] ?? 0;
-                        const bOrder = b.data[this.orderMember] ?? 0;
+                        const aOrder = getField(a.data, this.orderMember) ?? 0;
+                        const bOrder = getField(b.data, this.orderMember) ?? 0;
                         if (aOrder !== bOrder) {
                             return aOrder - bOrder;
                         }
@@ -611,7 +645,6 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 newChildren[segment] = child;
             });
             parent.children = newChildren;
-            _bumpRev(parent);
             this._emitTreeChanged();
         },
         /**
@@ -620,16 +653,15 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
          * @param path - Path to the node to refresh
          */
         refreshNode(path) {
-            const node = this.getNodeByPath(path);
-            if (node) {
-                _bumpNodeRev(node);
-            }
+            // For now, just trigger a tree change
+            // Future optimization: only re-render the specific subtree
+            this._emitTreeChanged();
         },
         /**
          * Move a node to a new location in the tree
          * @param sourcePath - Path of the node to move
          * @param targetPath - Path of the target node
-         * @param position - Where to place relative to target: 'above', 'below', or 'child'
+         * @param position - Where to place relative to target: 'before', 'after', or 'child'
          * @returns Object with success status and optional error message
          */
         moveNode(sourcePath, targetPath, position) {
@@ -656,7 +688,6 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             // Remove source from current parent
             const sourceSegment = segmentPrefix + sourceNode.pathSegment;
             delete sourceParent.children[sourceSegment];
-            _bumpRev(sourceParent);
             // Update source parent's hasChildren
             if (Object.keys(sourceParent.children).length === 0) {
                 sourceParent.hasChildren = false;
@@ -670,7 +701,7 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 newParent = targetNode;
             }
             else {
-                // Insert as sibling (above or below)
+                // Insert as sibling (before or after)
                 newParentPath = targetNode.parentPath || '';
                 newParent = newParentPath ? this.getNodeByPath(newParentPath) : root;
             }
@@ -695,7 +726,8 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             // Update source node's path and parentPath
             sourceNode.path = newPath;
             sourceNode.pathSegment = newSegment;
-            sourceNode.parentPath = newParentPath || null;
+            // Keep '' for root nodes (matching insertArray's getParentPath convention)
+            sourceNode.parentPath = newParentPath;
             sourceNode.level = getLevel(newPath, this.treePathSeparator);
             // Update the data object's path if pathMember is defined
             if (this.pathMember && sourceNode.data) {
@@ -703,52 +735,37 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             }
             // Update all descendants' paths recursively
             this._updateDescendantPaths(sourceNode, oldPath, newPath);
-            _bumpRev(sourceNode);
             // Insert into new parent
             newParent.children[segmentPrefix + newSegment] = sourceNode;
             newParent.hasChildren = true;
-            // If orderMember is defined and position is above/below, calculate order
+            // If orderMember is defined and position is before/after, calculate order
             if (this.orderMember && position !== 'child' && sourceNode.data) {
+                const om = this.orderMember;
                 const siblings = Object.values(newParent.children);
-                const targetOrder = targetNode.data?.[this.orderMember] ?? 0;
-                if (position === 'above') {
-                    // Find order value just below target
+                const targetOrder = (targetNode.data ? getField(targetNode.data, om) : 0) ?? 0;
+                if (position === 'before') {
+                    // Find order value just before target
                     const siblingOrders = siblings
-                        .filter(s => s !== sourceNode && s.data?.[this.orderMember] !== undefined)
-                        .map(s => s.data[this.orderMember])
+                        .filter(s => s !== sourceNode && s.data && getField(s.data, om) !== undefined)
+                        .map(s => getField(s.data, om))
                         .filter(o => o < targetOrder)
                         .sort((a, b) => b - a);
-                    const belowOrder = siblingOrders[0] ?? targetOrder - 20;
-                    const newOrder = Math.floor((belowOrder + targetOrder) / 2);
-                    console.log(`[moveNode] position=above, targetOrder=${targetOrder}, belowOrder=${belowOrder}, newOrder=${newOrder}, siblingOrders=`, siblings.map(s => ({ path: s.path, order: s.data?.[this.orderMember] })));
-                    sourceNode.data[this.orderMember] = newOrder;
+                    const prevOrder = siblingOrders[0] ?? targetOrder - 20;
+                    sourceNode.data[om] = Math.floor((prevOrder + targetOrder) / 2);
                 }
                 else {
-                    // Find order value just above target
+                    // Find order value just after target
                     const siblingOrders = siblings
-                        .filter(s => s !== sourceNode && s.data?.[this.orderMember] !== undefined)
-                        .map(s => s.data[this.orderMember])
+                        .filter(s => s !== sourceNode && s.data && getField(s.data, om) !== undefined)
+                        .map(s => getField(s.data, om))
                         .filter(o => o > targetOrder)
                         .sort((a, b) => a - b);
-                    const aboveOrder = siblingOrders[0] ?? targetOrder + 20;
-                    const newOrder = Math.floor((targetOrder + aboveOrder) / 2);
-                    console.log(`[moveNode] position=below, targetOrder=${targetOrder}, aboveOrder=${aboveOrder}, newOrder=${newOrder}, siblingOrders=`, siblings.map(s => ({ path: s.path, order: s.data?.[this.orderMember] })));
-                    sourceNode.data[this.orderMember] = newOrder;
+                    const nextOrder = siblingOrders[0] ?? targetOrder + 20;
+                    sourceNode.data[om] = Math.floor((targetOrder + nextOrder) / 2);
                 }
             }
-            else if (position !== 'child') {
-                console.log(`[moveNode] position=${position}, but orderMember=${this.orderMember}, sourceNode.data=${!!sourceNode.data} — order NOT calculated`);
-            }
             // Re-sort siblings if needed
             this.refreshSiblings(newParentPath);
-            // Log final sibling order after refresh
-            {
-                const parent = newParentPath ? this.getNodeByPath(newParentPath) : root;
-                if (parent) {
-                    const finalOrder = Object.values(parent.children).map((s) => ({ path: s.path, order: s.data?.[this.orderMember] }));
-                    console.log(`[moveNode] Final sibling order after refreshSiblings:`, finalOrder);
-                }
-            }
             return { success: true };
         },
         /**
@@ -792,7 +809,6 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             // Remove from parent
             const segment = segmentPrefix + node.pathSegment;
             delete parent.children[segment];
-            _bumpRev(parent);
             // Update parent's hasChildren
             if (Object.keys(parent.children).length === 0) {
                 parent.hasChildren = false;
@@ -832,19 +848,22 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 const id = _idMember && data ? data[_idMember] : undefined;
                 pathSegment = id?.toString() || `new_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
             }
+            // At this point pathSegment is guaranteed to be a string
+            const segment = pathSegment;
             // Calculate full path
-            const newPath = parentPath ? `${parentPath}${this.treePathSeparator}${pathSegment}` : pathSegment;
+            const newPath = parentPath ? `${parentPath}${this.treePathSeparator}${segment}` : segment;
             // Check if path already exists
             if (this.getNodeByPath(newPath)) {
                 return { success: false, error: `Node already exists at path: ${newPath}` };
             }
             // Create the node
             const newNode = createLTreeNode();
-            newNode.treeId = _treeId;
+            newNode.treeId = _treeId || '';
             newNode.id = _idMember && data ? data[_idMember] : undefined;
             newNode.path = newPath;
-            newNode.pathSegment = pathSegment;
-            newNode.parentPath = parentPath || null;
+            newNode.pathSegment = segment;
+            // Keep '' for root nodes (matching insertArray's getParentPath convention)
+            newNode.parentPath = parentPath;
             newNode.level = getLevel(newPath, this.treePathSeparator);
             newNode.data = data;
             newNode.isExpanded = _expandLevel ? newNode.level <= _expandLevel : false;
@@ -853,10 +872,6 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             if (_pathMember && data) {
                 data[_pathMember] = newPath;
             }
-            // Create per-node signal for O(1) reactive updates
-            if (newNode.id !== undefined) {
-                nodeSignals.set(String(newNode.id), new NodeSignal());
-            }
             // Add to parent
             const targetParent = parent || root;
             targetParent.children[segmentPrefix + pathSegment] = newNode;
@@ -889,6 +904,7 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             const orderMemberUpdated = this.orderMember && this.orderMember in dataUpdates;
             // Merge updates into existing data
             node.data = { ...node.data, ...dataUpdates };
+            node._rev = (node._rev || 0) + 1;
             // Re-index for search if needed
             if (indexer && _shouldUseInternalSearchIndex) {
                 const flatIndex = flatTreeNodes.indexOf(node);
@@ -896,14 +912,11 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                     indexer.addItem({ node, index: flatIndex });
                 }
             }
-            // Re-sort siblings if order was updated (structural change)
+            // Re-sort siblings if order was updated
             if (orderMemberUpdated) {
-                _bumpRev(node);
                 this.refreshSiblings(node.parentPath || '');
-                return { success: true, node };
             }
-            // Data-only change — signal only, skip _emitTreeChanged for O(1) update
-            _bumpNodeRev(node);
+            this._emitTreeChanged();
             return { success: true, node };
         },
         /**
@@ -975,7 +988,7 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
          * @param targetParentPath - Path where to insert the copy (empty string for root)
          * @param transformData - Function to transform each node's data (e.g., assign new IDs)
          * @param siblingPath - Optional path of sibling to position relative to
-         * @param position - Optional position relative to sibling ('above' or 'below')
+         * @param position - Optional position relative to sibling ('before' or 'after')
          * @returns Object with success status, the created root node, and count of nodes created
          */
         copyNodeWithDescendants(sourceNode, targetParentPath, transformData, siblingPath, position) {
@@ -1015,53 +1028,37 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             // Handle positioning relative to sibling if specified
             if (siblingPath && position && rootNode.data) {
                 const siblingNode = this.getNodeByPath(siblingPath);
-                console.log(`[copyNodeWithDescendants] Positioning: siblingPath=${siblingPath}, position=${position}, siblingFound=${!!siblingNode}, orderMember=${this.orderMember}`);
                 if (siblingNode && this.orderMember) {
                     // Get the parent to access siblings
                     const parent = targetParentPath ? this.getNodeByPath(targetParentPath) : root;
                     if (parent) {
                         const siblings = Object.values(parent.children);
-                        const siblingOrder = siblingNode.data?.[this.orderMember] ?? 0;
-                        if (position === 'above') {
-                            // Find order value just below sibling
+                        const oKey = this.orderMember;
+                        const siblingOrder = siblingNode.data?.[oKey] ?? 0;
+                        if (position === 'before') {
+                            // Find order value just before sibling
                             const siblingOrders = siblings
-                                .filter(s => s !== rootNode && s.data?.[this.orderMember] !== undefined)
-                                .map(s => s.data[this.orderMember])
+                                .filter(s => s !== rootNode && s.data?.[oKey] !== undefined)
+                                .map(s => s.data[oKey])
                                 .filter(o => o < siblingOrder)
                                 .sort((a, b) => b - a);
-                            const belowOrder = siblingOrders[0] ?? siblingOrder - 20;
-                            const newOrder = Math.floor((belowOrder + siblingOrder) / 2);
-                            console.log(`[copyNodeWithDescendants] position=above, siblingOrder=${siblingOrder}, belowOrder=${belowOrder}, newOrder=${newOrder}`);
-                            rootNode.data[this.orderMember] = newOrder;
+                            const prevOrder = siblingOrders[0] ?? siblingOrder - 20;
+                            rootNode.data[oKey] = Math.floor((prevOrder + siblingOrder) / 2);
                         }
                         else {
-                            // Find order value just above sibling
+                            // Find order value just after sibling
                             const siblingOrders = siblings
-                                .filter(s => s !== rootNode && s.data?.[this.orderMember] !== undefined)
-                                .map(s => s.data[this.orderMember])
+                                .filter(s => s !== rootNode && s.data?.[oKey] !== undefined)
+                                .map(s => s.data[oKey])
                                 .filter(o => o > siblingOrder)
                                 .sort((a, b) => a - b);
-                            const aboveOrder = siblingOrders[0] ?? siblingOrder + 20;
-                            const newOrder = Math.floor((siblingOrder + aboveOrder) / 2);
-                            console.log(`[copyNodeWithDescendants] position=below, siblingOrder=${siblingOrder}, aboveOrder=${aboveOrder}, newOrder=${newOrder}`);
-                            rootNode.data[this.orderMember] = newOrder;
+                            const nextOrder = siblingOrders[0] ?? siblingOrder + 20;
+                            rootNode.data[oKey] = Math.floor((siblingOrder + nextOrder) / 2);
                         }
                         // Re-sort siblings
                         this.refreshSiblings(targetParentPath);
-                        // Log final order
-                        const finalOrder = Object.values(parent.children).map((s) => ({ path: s.path, order: s.data?.[this.orderMember] }));
-                        console.log(`[copyNodeWithDescendants] Final sibling order:`, finalOrder);
                     }
                 }
-                else if (!siblingNode) {
-                    console.warn(`[copyNodeWithDescendants] Sibling not found at path: ${siblingPath}`);
-                }
-                else if (!this.orderMember) {
-                    console.warn(`[copyNodeWithDescendants] No orderMember set — cannot position`);
-                }
-            }
-            else {
-                console.log(`[copyNodeWithDescendants] No positioning: siblingPath=${siblingPath}, position=${position}, hasData=${!!rootNode.data}`);
             }
             return { success: true, rootNode, count: totalCount };
         },
@@ -1092,11 +1089,7 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
             const pathSet = new Set(paths);
             const traverse = (node) => {
                 if (node.path) {
-                    const shouldExpand = pathSet.has(node.path);
-                    if (node.isExpanded !== shouldExpand) {
-                        node.isExpanded = shouldExpand;
-                        _bumpRev(node);
-                    }
+                    node.isExpanded = pathSet.has(node.path);
                 }
                 for (const child of Object.values(node.children)) {
                     traverse(child);
@@ -1133,9 +1126,9 @@ export function createLTree(_idMember, _pathMember, _parentPathMember, _levelMem
                 }
                 // Then sort by parent path
                 if (a.parentPath !== b.parentPath) {
-                    if (a.parentPath === '')
+                    if (!a.parentPath)
                         return -1;
-                    if (b.parentPath === '')
+                    if (!b.parentPath)
                         return 1;
                     return a.parentPath.localeCompare(b.parentPath);
                 }