@colyseus/schema 4.0.20 → 5.0.1

package/src/encoder/MapJournal.ts

@@ -0,0 +1,124 @@
+/**
+ * MapJournal — owns the change-tracking and wire-protocol identity for a MapSchema.
+ *
+ * Replaces three parallel structures that previously lived on MapSchema:
+ *   - `$indexes: Map<number, K>`        →  `keyByIndex`
+ *   - `_collectionIndexes: { [key]: number }` (+ counter)  →  `indexByKey` + `nextIndex`
+ *   - `deletedItems: { [index]: V }`    →  `snapshots`
+ *
+ * The journal is the single source of truth for:
+ *   - assigning wire-protocol indexes to keys (server side)
+ *   - looking up keys from wire indexes (server + client)
+ *   - holding snapshots of removed values (for view-filter visibility checks)
+ *
+ * The journal does NOT track per-index operation types or maintain enqueue
+ * order — those remain on `ChangeTree` for now. A future iteration may pull
+ * them in too, but this version is intentionally scoped to the data-model
+ * cleanup so we can validate the abstraction before going deeper.
+ */
+export class MapJournal<K = any> {
+    /** index → key (was MapSchema.$indexes). Used by encoder and decoder. */
+    keyByIndex: Map<number, K> = new Map();
+
+    /**
+     * key → index (was MapSchema._collectionIndexes — forward direction).
+     * Server-only. Plain object so MapSchema can expose it via a getter
+     * for backwards-compatible `_collectionIndexes?.[key]` access from
+     * ChangeTree.forEachChild and similar polymorphic call sites.
+     */
+    indexByKey: { [key: string]: number } = {};
+
+    /** Monotonic counter for assigning new indexes. Server-only. */
+    private nextIndex: number = 0;
+
+    /**
+     * Snapshot of values at the moment they were deleted. Lazy — only
+     * allocated on first delete, since most maps are pure-grow and never
+     * touch this. Used by `MapSchema[$filter]` to check view visibility
+     * of a value that's already been removed from `$items` but whose
+     * DELETE op is still in the encode queue.
+     */
+    snapshots?: Map<number, any>;
+
+    // ──────────────────────────────────────────────────────────────────
+    // Server-side: recording mutations
+    // ──────────────────────────────────────────────────────────────────
+
+    /** Get the index assigned to a key, or undefined if never assigned. */
+    indexOf(key: K): number | undefined {
+        const idx = this.indexByKey[key as unknown as string];
+        return idx === undefined ? undefined : idx;
+    }
+
+    /** Assign and return a new wire index for an unseen key. */
+    assign(key: K): number {
+        const index = this.nextIndex++;
+        this.indexByKey[key as unknown as string] = index;
+        this.keyByIndex.set(index, key);
+        return index;
+    }
+
+    /** Stash a value at the moment it's deleted (for filter visibility checks). */
+    snapshot(index: number, value: any): void {
+        (this.snapshots ??= new Map()).set(index, value);
+    }
+
+    /** Discard a snapshot — called when a deleted slot is being re-set. */
+    forgetSnapshot(index: number): void {
+        this.snapshots?.delete(index);
+    }
+
+    /** Look up a snapshot. Returns undefined if no DELETE is pending for this index. */
+    snapshotAt(index: number): any {
+        return this.snapshots?.get(index);
+    }
+
+    // ──────────────────────────────────────────────────────────────────
+    // Client-side (decoder): index↔key sync from the wire
+    // ──────────────────────────────────────────────────────────────────
+
+    /** Decoder calls this when it sees an ADD/DELETE_AND_ADD on the wire. */
+    setIndex(index: number, key: K): void {
+        this.keyByIndex.set(index, key);
+        // Forward direction maintained for symmetry, even though decoder
+        // rarely needs it. Cheap insert; keeps invariants aligned.
+        this.indexByKey[key as unknown as string] = index;
+    }
+
+    // ──────────────────────────────────────────────────────────────────
+    // Lookups (both sides)
+    // ──────────────────────────────────────────────────────────────────
+
+    /** Reverse lookup: wire index → key. */
+    keyOf(index: number): K | undefined {
+        return this.keyByIndex.get(index);
+    }
+
+    // ──────────────────────────────────────────────────────────────────
+    // Lifecycle
+    // ──────────────────────────────────────────────────────────────────
+
+    /**
+     * Called from MapSchema's $onEncodeEnd hook.
+     * Cleans up index/key mappings for entries that were deleted in this tick.
+     */
+    cleanupAfterEncode(): void {
+        if (this.snapshots === undefined) return;
+        for (const [index] of this.snapshots) {
+            const key = this.keyByIndex.get(index);
+            if (key !== undefined) {
+                delete this.indexByKey[key as unknown as string];
+                this.keyByIndex.delete(index);
+            }
+        }
+        this.snapshots.clear();
+    }
+
+    /** Reset everything (called on .clear()). */
+    reset(): void {
+        this.indexByKey = {};
+        this.keyByIndex.clear();
+        this.snapshots?.clear();
+        this.nextIndex = 0;
+    }
+}

package/src/encoder/RefIdAllocator.ts

@@ -0,0 +1,68 @@
+/**
+ * Allocates monotonically-increasing refIds with a reuse pool.
+ *
+ * `acquire()` pops from the free pool when available, otherwise bumps a
+ * counter. `release()` queues a refId for reuse; the id doesn't become
+ * acquirable until `flushReleases()` runs — the one-tick defer is what
+ * lets the encoder guarantee a DELETE for the old instance reaches the
+ * wire before the refId is handed to a new one.
+ *
+ * `reclaim()` handles "resurrection": a ref that was released but whose
+ * JS instance is still alive can be re-added to the tree, in which case
+ * the encoder must pull the refId back out of the pool before it's
+ * handed to an unrelated instance.
+ */
+export class RefIdAllocator {
+    protected nextUniqueId: number;
+
+    private _free: number[] = [];
+    private _pending: number[] = [];
+    private _pooled: Set<number> = new Set();
+
+    constructor(startRefId: number = 0) {
+        this.nextUniqueId = startRefId;
+    }
+
+    acquire(): number {
+        if (this._free.length > 0) {
+            const id = this._free.pop()!;
+            this._pooled.delete(id);
+            return id;
+        }
+        return this.nextUniqueId++;
+    }
+
+    release(refId: number): void {
+        this._pending.push(refId);
+        this._pooled.add(refId);
+    }
+
+    isPooled(refId: number): boolean {
+        return this._pooled.has(refId);
+    }
+
+    /**
+     * Remove a refId from the pool. Called when a ref whose refId was
+     * released is being resurrected. O(n) scan of the relevant array,
+     * but resurrection is rare.
+     */
+    reclaim(refId: number): void {
+        if (!this._pooled.delete(refId)) return;
+        let i = this._free.indexOf(refId);
+        if (i !== -1) { this._free.splice(i, 1); return; }
+        i = this._pending.indexOf(refId);
+        if (i !== -1) { this._pending.splice(i, 1); }
+    }
+
+    /**
+     * Promote this tick's releases into the acquirable set. Called from
+     * `Encoder.discardChanges()` — never mid-encode.
+     */
+    flushReleases(): void {
+        const pending = this._pending;
+        if (pending.length === 0) return;
+        const free = this._free;
+        for (let i = 0; i < pending.length; i++) free.push(pending[i]);
+        pending.length = 0;
+    }
+}

package/src/encoder/Root.ts

@@ -1,35 +1,152 @@
 import { OPERATION } from "../encoding/spec.js";
 import { TypeContext } from "../types/TypeContext.js";
-import { ChangeTree, setOperationAtIndex, ChangeTreeList, createChangeTreeList, ChangeSetName, type ChangeTreeNode } from "./ChangeTree.js";
+import { ChangeTree, ChangeTreeList, createChangeTreeList, type ChangeTreeNode } from "./ChangeTree.js";
 import { $changes, $refId } from "../types/symbols.js";
+import { RefIdAllocator } from "./RefIdAllocator.js";
+import type { StateView } from "./StateView.js";
+import type { StreamSchema } from "../types/custom/StreamSchema.js";
+import type { StreamableState } from "./streaming.js";
+
+/**
+ * Minimal shape the encoder needs from a streamable collection. Both
+ * `StreamSchema` and `.stream()`-decorated `MapSchema`/`SetSchema` etc.
+ * satisfy this via a single lazily-allocated `_stream` slot — the
+ * per-view / broadcast bookkeeping lives on that object, not directly
+ * on the collection, so non-streaming instances pay zero Map/Set
+ * allocation cost.
+ */
+export interface Streamable {
+    [$refId]?: number;
+    [$changes]: ChangeTree;
+    _stream?: StreamableState;
+    _dropView(viewId: number): void;
+    _unregister(): void;
+}
 
 export class Root {
-    protected nextUniqueId: number = 0;
+    /**
+     * Allocates and recycles refIds. See `RefIdAllocator` for the reuse
+     * pool semantics (one-tick defer + resurrection).
+     */
+    public readonly refIds: RefIdAllocator;
 
     refCount: {[id: number]: number} = {};
     changeTrees: {[refId: number]: ChangeTree} = {};
 
-    // all changes
-    allChanges: ChangeTreeList = createChangeTreeList();
-    allFilteredChanges: ChangeTreeList = createChangeTreeList();// TODO: do not initialize it if filters are not used
-
-    // pending changes to be encoded
+    /**
+     * Queue of all ChangeTrees with reliable dirty state. Per-tick encode()
+     * walks this queue; per-view encodeView() walks it too (filtering at
+     * emission time via tree.isFiltered + per-field @view tag).
+     */
     changes: ChangeTreeList = createChangeTreeList();
-    filteredChanges: ChangeTreeList = createChangeTreeList();// TODO: do not initialize it if filters are not used
 
-    constructor(public types: TypeContext) { }
+    /**
+     * Queue of all ChangeTrees with unreliable dirty state. Walked by
+     * `Encoder.encodeUnreliable` / `encodeUnreliableView`. A tree may live
+     * in both queues when the Schema has both reliable and unreliable
+     * fields dirty at the same time.
+     */
+    unreliableChanges: ChangeTreeList = createChangeTreeList();
+
+    /**
+     * Free-list of ChangeTreeNode objects. Both queues share this pool —
+     * a node carries no queue affinity, only `{ changeTree, prev, next, position }`.
+     * Reusing nodes turns ~1,250 per-tick allocations (in bench) into 0.
+     */
+    private _nodePool: ChangeTreeNode[] = [];
+
+    /**
+     * View ID allocator for StateView visibility bitmaps on ChangeTree.
+     * Each new StateView claims the lowest free ID; releaseViewId() puts
+     * the ID back. Avoids unbounded bitmap growth across long-running rooms
+     * with view churn (clients joining/leaving).
+     */
+    private _nextViewId: number = 0;
+    private _freeViewIds: number[] = [];
+
+    /** Allocate a fresh view ID (lowest available). */
+    public acquireViewId(): number {
+        return this._freeViewIds.length > 0
+            ? this._freeViewIds.pop()!
+            : this._nextViewId++;
+    }
+
+    /** Return a view ID to the freelist for reuse. */
+    public releaseViewId(id: number): void {
+        this._freeViewIds.push(id);
+    }
+
+    /**
+     * Currently-bound StateViews, keyed by view ID and held via `WeakRef`
+     * so the FinalizationRegistry backstop in StateView still works when
+     * the user forgets `dispose()`. Callers must iterate via
+     * `forEachActiveView`, which prunes dead entries.
+     */
+    public activeViews: Map<number, WeakRef<StateView>> = new Map();
+
+    /**
+     * Streamable collections attached under this Root — `StreamSchema`
+     * plus any collection opted into streaming via `.stream()` on the
+     * builder. Encoder.encodeView / broadcast pass iterates this set to
+     * dispatch per-view / per-tick budget gates.
+     */
+    public streamTrees: Set<Streamable> = new Set();
+
+    public registerView(view: StateView): void {
+        this.activeViews.set(view.id, new WeakRef(view));
+    }
+
+    public unregisterView(view: StateView): void {
+        this.activeViews.delete(view.id);
+        // Clear per-view state on every registered stream so dispose()ing
+        // a view doesn't leak its `_pendingByView` / `_sentByView` entries
+        // indefinitely. O(streams) on dispose, acceptable since dispose is
+        // rare (once per client disconnect).
+        const id = view.id;
+        for (const stream of this.streamTrees) {
+            stream._dropView(id);
+        }
+    }
+
+    /**
+     * Iterate all live StateViews bound to this Root. Prunes entries
+     * whose underlying view has been garbage collected without an
+     * explicit `dispose()`.
+     */
+    public forEachActiveView(cb: (view: StateView) => void): void {
+        for (const [id, ref] of this.activeViews) {
+            const view = ref.deref();
+            if (view === undefined) {
+                this.activeViews.delete(id);
+                for (const stream of this.streamTrees) stream._dropView(id);
+                continue;
+            }
+            cb(view);
+        }
+    }
+
+    public registerStream(stream: Streamable): void {
+        this.streamTrees.add(stream);
+    }
+
+    public unregisterStream(stream: Streamable): void {
+        this.streamTrees.delete(stream);
+    }
 
-    getNextUniqueId() {
-        return this.nextUniqueId++;
+    constructor(public types: TypeContext, startRefId: number = 0) {
+        this.refIds = new RefIdAllocator(startRefId);
     }
 
     add(changeTree: ChangeTree) {
         const ref = changeTree.ref;
 
         // Assign unique `refId` to ref if it doesn't have one yet.
+        // $refId is a Symbol but assert.deepStrictEqual still walks
+        // *enumerable* own Symbols, so we keep defineProperty(enumerable:false)
+        // to keep $refId hidden from deep-equal comparisons in tests.
         if (ref[$refId] === undefined) {
             Object.defineProperty(ref, $refId, {
-                value: this.getNextUniqueId(),
+                value: this.refIds.acquire(),
                 enumerable: false,
                 writable: true
             });
@@ -40,24 +157,32 @@ export class Root {
         const isNewChangeTree = (this.changeTrees[refId] === undefined);
         if (isNewChangeTree) { this.changeTrees[refId] = changeTree; }
 
+        // Resurrection path: a ref whose refId is still queued for reuse
+        // is being re-added. Pull the refId out of the pool before it gets
+        // handed out to someone else.
+        if (this.refIds.isPooled(refId)) {
+            this.refIds.reclaim(refId);
+        }
+
         const previousRefCount = this.refCount[refId];
         if (previousRefCount === 0) {
             //
-            // When a ChangeTree is re-added, it means that it was previously removed.
-            // We need to re-add all changes to the `changes` map.
+            // When a ChangeTree is re-added, it means that it was previously
+            // removed. Re-stage every currently-populated non-transient index
+            // as a fresh ADD in the matching dirty bucket so the next encode
+            // re-emits it on the correct channel.
             //
-            const ops = changeTree.allChanges.operations;
-            let len = ops.length;
-            while (len--) {
-                changeTree.indexedOperations[ops[len]] = OPERATION.ADD;
-                setOperationAtIndex(changeTree.changes, len);
-            }
+            changeTree.forEachLive((fieldIndex) => {
+                if (changeTree.isFieldUnreliable(fieldIndex)) {
+                    changeTree.ensureUnreliableRecorder().record(fieldIndex, OPERATION.ADD);
+                } else {
+                    changeTree.record(fieldIndex, OPERATION.ADD);
+                }
+            });
         }
 
         this.refCount[refId] = (previousRefCount || 0) + 1;
 
-        // console.log("ADD", { refId, ref: ref.constructor.name, refCount: this.refCount[refId], isNewChangeTree });
-
         return isNewChangeTree;
     }
 
@@ -65,8 +190,6 @@ export class Root {
         const refId = changeTree.ref[$refId];
         const refCount = (this.refCount[refId]) - 1;
 
-        // console.log("REMOVE", { refId, ref: changeTree.ref.constructor.name, refCount, needRemove: refCount <= 0 });
-
         if (refCount <= 0) {
             //
             // Only remove "root" reference if it's the last reference
@@ -74,25 +197,39 @@ export class Root {
             changeTree.root = undefined;
             delete this.changeTrees[refId];
 
-            this.removeChangeFromChangeSet("allChanges", changeTree);
-            this.removeChangeFromChangeSet("changes", changeTree);
-
-            if (changeTree.filteredChanges) {
-                this.removeChangeFromChangeSet("allFilteredChanges", changeTree);
-                this.removeChangeFromChangeSet("filteredChanges", changeTree);
+            // Streamable-collection detach (StreamSchema + any `.stream()`
+            // collection). Tree flag is cheaper than the class-level
+            // brand and covers both cases uniformly.
+            if (changeTree.isStreamCollection) {
+                const streamable = changeTree.ref as unknown as Streamable;
+                streamable._unregister?.();
+                this.unregisterStream(streamable);
             }
 
+            this.removeFromQueue(changeTree);
+            this.removeFromUnreliableQueue(changeTree);
+
             this.refCount[refId] = 0;
 
+            // Return refId to the reuse pool (deferred to end-of-tick via
+            // the allocator's pending set). Stream collections are excluded
+            // because their per-view delivery bookkeeping is harder to
+            // audit for reuse safety and the savings there are negligible.
+            // If the ref is later resurrected, `add()` evicts the refId
+            // from the pool before it's handed to another instance.
+            if (!changeTree.isStreamCollection) {
+                this.refIds.release(refId);
+            }
+
             changeTree.forEachChild((child, _) => {
                 if (child.removeParent(changeTree.ref)) {
                     if ((
-                        child.parentChain === undefined || // no parent, remove it
-                        (child.parentChain && this.refCount[child.ref[$refId]] > 0) // parent is still in use, but has more than one reference, remove it
+                        child.parentRef === undefined || // no parent, remove it
+                        (child.parentRef && this.refCount[child.ref[$refId]] > 0) // parent is still in use, but has more than one reference, remove it
                     )) {
                         this.remove(child);
 
-                    } else if (child.parentChain) {
+                    } else if (child.parentRef) {
                         // re-assigning a child of the same root, move it next to parent
                         this.moveNextToParent(child);
                     }
@@ -122,37 +259,34 @@ export class Root {
         changeTree.forEachChild((child, _) => this.recursivelyMoveNextToParent(child));
     }
 
-    moveNextToParent(changeTree: ChangeTree) {
-        if (changeTree.filteredChanges) {
-            this.moveNextToParentInChangeTreeList("filteredChanges", changeTree);
-            this.moveNextToParentInChangeTreeList("allFilteredChanges", changeTree);
-        } else {
-            this.moveNextToParentInChangeTreeList("changes", changeTree);
-            this.moveNextToParentInChangeTreeList("allChanges", changeTree);
+    moveNextToParent(changeTree: ChangeTree): void {
+        if (changeTree.changesNode) {
+            this._moveNextToParentInList(this.changes, changeTree, changeTree.changesNode, "changesNode");
+        }
+        if (changeTree.unreliableChangesNode) {
+            this._moveNextToParentInList(this.unreliableChanges, changeTree, changeTree.unreliableChangesNode, "unreliableChangesNode");
         }
     }
 
-    moveNextToParentInChangeTreeList(changeSetName: ChangeSetName, changeTree: ChangeTree): void {
-        const changeSet = this[changeSetName];
-        const node = changeTree[changeSetName].queueRootNode;
-        if (!node) return;
-
-        // Find the parent in the linked list
+    private _moveNextToParentInList(
+        changeSet: ChangeTreeList,
+        changeTree: ChangeTree,
+        node: ChangeTreeNode,
+        nodeField: "changesNode" | "unreliableChangesNode",
+    ): void {
         const parent = changeTree.parent;
         if (!parent || !parent[$changes]) return;
 
-        const parentNode = parent[$changes][changeSetName]?.queueRootNode;
+        const parentNode = parent[$changes][nodeField];
         if (!parentNode || parentNode === node) return;
 
-        // Use cached positions - no iteration needed!
-        const parentPosition = parentNode.position;
-        const childPosition = node.position;
-
-        // If child is already after parent, no need to move
-        if (childPosition > parentPosition) return;
-
-        // Child is before parent, so we need to move it after parent
-        // This maintains decoding order (parent before child)
+        // Check if child is already after parent by walking from parent
+        let cursor = parentNode.next;
+        while (cursor) {
+            if (cursor === node) return; // already after parent
+            cursor = cursor.next;
+        }
+        // If we reach here, node is before parent — need to move
 
         // Remove node from current position
         if (node.prev) {
@@ -178,31 +312,36 @@ export class Root {
         }
 
         parentNode.next = node;
-
-        // Update positions after the move
-        this.updatePositionsAfterMove(changeSet, node, parentPosition + 1);
     }
 
     public enqueueChangeTree(
         changeTree: ChangeTree,
-        changeSet: 'changes' | 'filteredChanges' | 'allFilteredChanges' | 'allChanges',
-        queueRootNode = changeTree[changeSet].queueRootNode
+        existingNode = changeTree.changesNode
     ) {
-        // skip
-        if (queueRootNode) { return; }
-
-        // Add to linked list if not already present
-        changeTree[changeSet].queueRootNode = this.addToChangeTreeList(this[changeSet], changeTree);
+        if (existingNode) { return; }
+        changeTree.changesNode = this._appendToList(this.changes, changeTree);
     }
 
-    protected addToChangeTreeList(list: ChangeTreeList, changeTree: ChangeTree): ChangeTreeNode {
-        const node: ChangeTreeNode = {
-            changeTree,
-            next: undefined,
-            prev: undefined,
-            position: list.tail ? list.tail.position + 1 : 0
-        };
+    public enqueueUnreliable(
+        changeTree: ChangeTree,
+        existingNode = changeTree.unreliableChangesNode
+    ) {
+        if (existingNode) { return; }
+        changeTree.unreliableChangesNode = this._appendToList(this.unreliableChanges, changeTree);
+    }
 
+    private _appendToList(list: ChangeTreeList, changeTree: ChangeTree): ChangeTreeNode {
+        const pool = this._nodePool;
+        let node: ChangeTreeNode;
+        if (pool.length > 0) {
+            node = pool.pop()!;
+            node.changeTree = changeTree;
+            node.next = undefined;
+            node.prev = undefined;
+            node.position = 0;
+        } else {
+            node = { changeTree, next: undefined, prev: undefined, position: 0 };
+        }
         if (!list.next) {
             list.next = node;
             list.tail = node;
@@ -211,64 +350,52 @@ export class Root {
             list.tail!.next = node;
             list.tail = node;
         }
-
         return node;
     }
 
-    protected updatePositionsAfterRemoval(list: ChangeTreeList, removedPosition: number) {
-        // Update positions for all nodes after the removed position
-        let current = list.next;
-        let position = 0;
-
-        while (current) {
-            if (position >= removedPosition) {
-                current.position = position;
-            }
-            current = current.next;
-            position++;
-        }
+    /**
+     * Release a detached node back to the free-list. Caller must have
+     * already unlinked it from any list and cleared the changeTree's
+     * pointer to it. Clears `changeTree`/`prev`/`next` so the pool
+     * doesn't retain references through the GC root.
+     */
+    public releaseNode(node: ChangeTreeNode): void {
+        node.changeTree = undefined!;
+        node.prev = undefined;
+        node.next = undefined;
+        this._nodePool.push(node);
     }
 
-    protected updatePositionsAfterMove(list: ChangeTreeList, node: ChangeTreeNode, newPosition: number) {
-        // Recalculate all positions - this is more reliable than trying to be clever
-        let current = list.next;
-        let position = 0;
-
-        while (current) {
-            current.position = position;
-            current = current.next;
-            position++;
-        }
+    public removeFromQueue(changeTree: ChangeTree): boolean {
+        return this._removeNode(this.changes, changeTree, changeTree.changesNode, "changesNode");
     }
 
-    public removeChangeFromChangeSet(changeSetName: ChangeSetName, changeTree: ChangeTree) {
-        const changeSet = this[changeSetName];
-        const node = changeTree[changeSetName].queueRootNode;
-
-        if (node && node.changeTree === changeTree) {
-            const removedPosition = node.position;
-
-            // Remove the node from the linked list
-            if (node.prev) {
-                node.prev.next = node.next;
-            } else {
-                changeSet.next = node.next;
-            }
+    public removeFromUnreliableQueue(changeTree: ChangeTree): boolean {
+        return this._removeNode(this.unreliableChanges, changeTree, changeTree.unreliableChangesNode, "unreliableChangesNode");
+    }
 
-            if (node.next) {
-                node.next.prev = node.prev;
-            } else {
-                changeSet.tail = node.prev;
-            }
+    private _removeNode(
+        changeSet: ChangeTreeList,
+        changeTree: ChangeTree,
+        node: ChangeTreeNode | undefined,
+        nodeField: "changesNode" | "unreliableChangesNode",
+    ): boolean {
+        if (!node || node.changeTree !== changeTree) return false;
 
-            // Update positions for nodes that came after the removed node
-            this.updatePositionsAfterRemoval(changeSet, removedPosition);
+        if (node.prev) {
+            node.prev.next = node.next;
+        } else {
+            changeSet.next = node.next;
+        }
 
-            // Clear ChangeTree reference
-            changeTree[changeSetName].queueRootNode = undefined;
-            return true;
+        if (node.next) {
+            node.next.prev = node.prev;
+        } else {
+            changeSet.tail = node.prev;
         }
 
-        return false;
+        changeTree[nodeField] = undefined;
+        this.releaseNode(node);
+        return true;
     }
 }