FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/alien-signals/cjs/index.cjs

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchDepth = void 0;
+exports.getCurrentSub = getCurrentSub;
+exports.setCurrentSub = setCurrentSub;
+exports.getCurrentScope = getCurrentScope;
+exports.setCurrentScope = setCurrentScope;
+exports.startBatch = startBatch;
+exports.endBatch = endBatch;
+exports.pauseTracking = pauseTracking;
+exports.resumeTracking = resumeTracking;
+exports.signal = signal;
+exports.computed = computed;
+exports.effect = effect;
+exports.effectScope = effectScope;
+__exportStar(require("./system.cjs"), exports);
+const system_js_1 = require("./system.cjs");
+const pauseStack = [];
+const queuedEffects = [];
+const { link, unlink, propagate, checkDirty, endTracking, startTracking, shallowPropagate, } = (0, system_js_1.createReactiveSystem)({
+    update(signal) {
+        if ('getter' in signal) {
+            return updateComputed(signal);
+        }
+        else {
+            return updateSignal(signal, signal.value);
+        }
+    },
+    notify,
+    unwatched(node) {
+        if ('getter' in node) {
+            let toRemove = node.deps;
+            if (toRemove !== undefined) {
+                node.flags = 17;
+                do {
+                    toRemove = unlink(toRemove, node);
+                } while (toRemove !== undefined);
+            }
+        }
+        else if (!('previousValue' in node)) {
+            effectOper.call(node);
+        }
+    },
+});
+exports.batchDepth = 0;
+let notifyIndex = 0;
+let queuedEffectsLength = 0;
+let activeSub;
+let activeScope;
+function getCurrentSub() {
+    return activeSub;
+}
+function setCurrentSub(sub) {
+    const prevSub = activeSub;
+    activeSub = sub;
+    return prevSub;
+}
+function getCurrentScope() {
+    return activeScope;
+}
+function setCurrentScope(scope) {
+    const prevScope = activeScope;
+    activeScope = scope;
+    return prevScope;
+}
+function startBatch() {
+    ++exports.batchDepth;
+}
+function endBatch() {
+    if (!--exports.batchDepth) {
+        flush();
+    }
+}
+function pauseTracking() {
+    pauseStack.push(setCurrentSub(undefined));
+}
+function resumeTracking() {
+    setCurrentSub(pauseStack.pop());
+}
+function signal(initialValue) {
+    return signalOper.bind({
+        previousValue: initialValue,
+        value: initialValue,
+        subs: undefined,
+        subsTail: undefined,
+        flags: 1,
+    });
+}
+function computed(getter) {
+    return computedOper.bind({
+        value: undefined,
+        subs: undefined,
+        subsTail: undefined,
+        deps: undefined,
+        depsTail: undefined,
+        flags: 17,
+        getter: getter,
+    });
+}
+function effect(fn) {
+    const e = {
+        fn,
+        subs: undefined,
+        subsTail: undefined,
+        deps: undefined,
+        depsTail: undefined,
+        flags: 2,
+    };
+    if (activeSub !== undefined) {
+        link(e, activeSub);
+    }
+    else if (activeScope !== undefined) {
+        link(e, activeScope);
+    }
+    const prev = setCurrentSub(e);
+    try {
+        e.fn();
+    }
+    finally {
+        setCurrentSub(prev);
+    }
+    return effectOper.bind(e);
+}
+function effectScope(fn) {
+    const e = {
+        deps: undefined,
+        depsTail: undefined,
+        subs: undefined,
+        subsTail: undefined,
+        flags: 0,
+    };
+    if (activeScope !== undefined) {
+        link(e, activeScope);
+    }
+    const prevSub = setCurrentSub(undefined);
+    const prevScope = setCurrentScope(e);
+    try {
+        fn();
+    }
+    finally {
+        setCurrentScope(prevScope);
+        setCurrentSub(prevSub);
+    }
+    return effectOper.bind(e);
+}
+function updateComputed(c) {
+    const prevSub = setCurrentSub(c);
+    startTracking(c);
+    try {
+        const oldValue = c.value;
+        return oldValue !== (c.value = c.getter(oldValue));
+    }
+    finally {
+        setCurrentSub(prevSub);
+        endTracking(c);
+    }
+}
+function updateSignal(s, value) {
+    s.flags = 1;
+    return s.previousValue !== (s.previousValue = value);
+}
+function notify(e) {
+    const flags = e.flags;
+    if (!(flags & 64)) {
+        e.flags = flags | 64;
+        const subs = e.subs;
+        if (subs !== undefined) {
+            notify(subs.sub);
+        }
+        else {
+            queuedEffects[queuedEffectsLength++] = e;
+        }
+    }
+}
+function run(e, flags) {
+    if (flags & 16
+        || (flags & 32 && checkDirty(e.deps, e))) {
+        const prev = setCurrentSub(e);
+        startTracking(e);
+        try {
+            e.fn();
+        }
+        finally {
+            setCurrentSub(prev);
+            endTracking(e);
+        }
+        return;
+    }
+    else if (flags & 32) {
+        e.flags = flags & ~32;
+    }
+    let link = e.deps;
+    while (link !== undefined) {
+        const dep = link.dep;
+        const depFlags = dep.flags;
+        if (depFlags & 64) {
+            run(dep, dep.flags = depFlags & ~64);
+        }
+        link = link.nextDep;
+    }
+}
+function flush() {
+    while (notifyIndex < queuedEffectsLength) {
+        const effect = queuedEffects[notifyIndex];
+        queuedEffects[notifyIndex++] = undefined;
+        run(effect, effect.flags &= ~64);
+    }
+    notifyIndex = 0;
+    queuedEffectsLength = 0;
+}
+function computedOper() {
+    const flags = this.flags;
+    if (flags & 16
+        || (flags & 32 && checkDirty(this.deps, this))) {
+        if (updateComputed(this)) {
+            const subs = this.subs;
+            if (subs !== undefined) {
+                shallowPropagate(subs);
+            }
+        }
+    }
+    else if (flags & 32) {
+        this.flags = flags & ~32;
+    }
+    if (activeSub !== undefined) {
+        link(this, activeSub);
+    }
+    else if (activeScope !== undefined) {
+        link(this, activeScope);
+    }
+    return this.value;
+}
+function signalOper(...value) {
+    if (value.length) {
+        const newValue = value[0];
+        if (this.value !== (this.value = newValue)) {
+            this.flags = 17;
+            const subs = this.subs;
+            if (subs !== undefined) {
+                propagate(subs);
+                if (!exports.batchDepth) {
+                    flush();
+                }
+            }
+        }
+    }
+    else {
+        const value = this.value;
+        if (this.flags & 16) {
+            if (updateSignal(this, value)) {
+                const subs = this.subs;
+                if (subs !== undefined) {
+                    shallowPropagate(subs);
+                }
+            }
+        }
+        if (activeSub !== undefined) {
+            link(this, activeSub);
+        }
+        return value;
+    }
+}
+function effectOper() {
+    let dep = this.deps;
+    while (dep !== undefined) {
+        dep = unlink(dep, this);
+    }
+    const sub = this.subs;
+    if (sub !== undefined) {
+        unlink(sub);
+    }
+    this.flags = 0;
+}

node_modules/alien-signals/cjs/system.cjs

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReactiveFlags = void 0;
+exports.createReactiveSystem = createReactiveSystem;
+var ReactiveFlags;
+(function (ReactiveFlags) {
+    ReactiveFlags[ReactiveFlags["None"] = 0] = "None";
+    ReactiveFlags[ReactiveFlags["Mutable"] = 1] = "Mutable";
+    ReactiveFlags[ReactiveFlags["Watching"] = 2] = "Watching";
+    ReactiveFlags[ReactiveFlags["RecursedCheck"] = 4] = "RecursedCheck";
+    ReactiveFlags[ReactiveFlags["Recursed"] = 8] = "Recursed";
+    ReactiveFlags[ReactiveFlags["Dirty"] = 16] = "Dirty";
+    ReactiveFlags[ReactiveFlags["Pending"] = 32] = "Pending";
+})(ReactiveFlags || (exports.ReactiveFlags = ReactiveFlags = {}));
+function createReactiveSystem({ update, notify, unwatched, }) {
+    let version = 0;
+    return {
+        link,
+        unlink,
+        propagate,
+        checkDirty,
+        endTracking,
+        startTracking,
+        shallowPropagate,
+    };
+    function link(dep, sub) {
+        const prevDep = sub.depsTail;
+        if (prevDep !== undefined && prevDep.dep === dep) {
+            return;
+        }
+        let nextDep;
+        if (sub.flags & 4) {
+            nextDep = prevDep !== undefined ? prevDep.nextDep : sub.deps;
+            if (nextDep !== undefined && nextDep.dep === dep) {
+                nextDep.version = version;
+                sub.depsTail = nextDep;
+                return;
+            }
+        }
+        const prevSub = dep.subsTail;
+        if (prevSub !== undefined && prevSub.version === version && prevSub.sub === sub) {
+            return;
+        }
+        const newLink = sub.depsTail
+            = dep.subsTail
+                = {
+                    version,
+                    dep,
+                    sub,
+                    prevDep,
+                    nextDep,
+                    prevSub,
+                    nextSub: undefined,
+                };
+        if (nextDep !== undefined) {
+            nextDep.prevDep = newLink;
+        }
+        if (prevDep !== undefined) {
+            prevDep.nextDep = newLink;
+        }
+        else {
+            sub.deps = newLink;
+        }
+        if (prevSub !== undefined) {
+            prevSub.nextSub = newLink;
+        }
+        else {
+            dep.subs = newLink;
+        }
+    }
+    function unlink(link, sub = link.sub) {
+        const dep = link.dep;
+        const prevDep = link.prevDep;
+        const nextDep = link.nextDep;
+        const nextSub = link.nextSub;
+        const prevSub = link.prevSub;
+        if (nextDep !== undefined) {
+            nextDep.prevDep = prevDep;
+        }
+        else {
+            sub.depsTail = prevDep;
+        }
+        if (prevDep !== undefined) {
+            prevDep.nextDep = nextDep;
+        }
+        else {
+            sub.deps = nextDep;
+        }
+        if (nextSub !== undefined) {
+            nextSub.prevSub = prevSub;
+        }
+        else {
+            dep.subsTail = prevSub;
+        }
+        if (prevSub !== undefined) {
+            prevSub.nextSub = nextSub;
+        }
+        else if ((dep.subs = nextSub) === undefined) {
+            unwatched(dep);
+        }
+        return nextDep;
+    }
+    function propagate(link) {
+        let next = link.nextSub;
+        let stack;
+        top: do {
+            const sub = link.sub;
+            let flags = sub.flags;
+            if (flags & 3) {
+                if (!(flags & 60)) {
+                    sub.flags = flags | 32;
+                }
+                else if (!(flags & 12)) {
+                    flags = 0;
+                }
+                else if (!(flags & 4)) {
+                    sub.flags = (flags & ~8) | 32;
+                }
+                else if (!(flags & 48) && isValidLink(link, sub)) {
+                    sub.flags = flags | 40;
+                    flags &= 1;
+                }
+                else {
+                    flags = 0;
+                }
+                if (flags & 2) {
+                    notify(sub);
+                }
+                if (flags & 1) {
+                    const subSubs = sub.subs;
+                    if (subSubs !== undefined) {
+                        link = subSubs;
+                        if (subSubs.nextSub !== undefined) {
+                            stack = { value: next, prev: stack };
+                            next = link.nextSub;
+                        }
+                        continue;
+                    }
+                }
+            }
+            if ((link = next) !== undefined) {
+                next = link.nextSub;
+                continue;
+            }
+            while (stack !== undefined) {
+                link = stack.value;
+                stack = stack.prev;
+                if (link !== undefined) {
+                    next = link.nextSub;
+                    continue top;
+                }
+            }
+            break;
+        } while (true);
+    }
+    function startTracking(sub) {
+        ++version;
+        sub.depsTail = undefined;
+        sub.flags = (sub.flags & ~56) | 4;
+    }
+    function endTracking(sub) {
+        const depsTail = sub.depsTail;
+        let toRemove = depsTail !== undefined ? depsTail.nextDep : sub.deps;
+        while (toRemove !== undefined) {
+            toRemove = unlink(toRemove, sub);
+        }
+        sub.flags &= ~4;
+    }
+    function checkDirty(link, sub) {
+        let stack;
+        let checkDepth = 0;
+        top: do {
+            const dep = link.dep;
+            const depFlags = dep.flags;
+            let dirty = false;
+            if (sub.flags & 16) {
+                dirty = true;
+            }
+            else if ((depFlags & 17) === 17) {
+                if (update(dep)) {
+                    const subs = dep.subs;
+                    if (subs.nextSub !== undefined) {
+                        shallowPropagate(subs);
+                    }
+                    dirty = true;
+                }
+            }
+            else if ((depFlags & 33) === 33) {
+                if (link.nextSub !== undefined || link.prevSub !== undefined) {
+                    stack = { value: link, prev: stack };
+                }
+                link = dep.deps;
+                sub = dep;
+                ++checkDepth;
+                continue;
+            }
+            if (!dirty && link.nextDep !== undefined) {
+                link = link.nextDep;
+                continue;
+            }
+            while (checkDepth) {
+                --checkDepth;
+                const firstSub = sub.subs;
+                const hasMultipleSubs = firstSub.nextSub !== undefined;
+                if (hasMultipleSubs) {
+                    link = stack.value;
+                    stack = stack.prev;
+                }
+                else {
+                    link = firstSub;
+                }
+                if (dirty) {
+                    if (update(sub)) {
+                        if (hasMultipleSubs) {
+                            shallowPropagate(firstSub);
+                        }
+                        sub = link.sub;
+                        continue;
+                    }
+                }
+                else {
+                    sub.flags &= ~32;
+                }
+                sub = link.sub;
+                if (link.nextDep !== undefined) {
+                    link = link.nextDep;
+                    continue top;
+                }
+                dirty = false;
+            }
+            return dirty;
+        } while (true);
+    }
+    function shallowPropagate(link) {
+        do {
+            const sub = link.sub;
+            const nextSub = link.nextSub;
+            const subFlags = sub.flags;
+            if ((subFlags & 48) === 32) {
+                sub.flags = subFlags | 16;
+                if (subFlags & 2) {
+                    notify(sub);
+                }
+            }
+            link = nextSub;
+        } while (link !== undefined);
+    }
+    function isValidLink(checkLink, sub) {
+        const depsTail = sub.depsTail;
+        if (depsTail !== undefined) {
+            let link = sub.deps;
+            do {
+                if (link === checkLink) {
+                    return true;
+                }
+                if (link === depsTail) {
+                    break;
+                }
+                link = link.nextDep;
+            } while (link !== undefined);
+        }
+        return false;
+    }
+}