diff --git a/rollup.config.mjs b/rollup.config.mjs
index fa3c42e9d..4ddfa30d4 100644
--- a/rollup.config.mjs
+++ b/rollup.config.mjs
@@ -9,7 +9,7 @@ import json from '@rollup/plugin-json';
 
 export default {
     //input: "./_src/worker/index.ts",
-    input: "./_src/worker/store.ts",
+    input: "./src/worker/store.ts",
     output: {
         name: 'cryptpad-worker',
         file: "./_build/worker.bundle.js",
diff --git a/scripts/tests/roster.js b/scripts/tests/roster.js
index b751d5c5e..6e00bcdc9 100644
--- a/scripts/tests/roster.js
+++ b/scripts/tests/roster.js
@@ -2,6 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-module.exports = require("../../www/common/outer/roster.js");
+module.exports = require("../../src/worker/components/roster.js");
 
 
diff --git a/src/common/cache-store.js b/src/common/cache-store.js
new file mode 100644
index 000000000..38ed12bb3
--- /dev/null
+++ b/src/common/cache-store.js
@@ -0,0 +1,210 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Util, localForage) => {
+    let window = globalThis;
+    let self = globalThis;
+    var S = window.CryptPad_Cache = {};
+    var onReady = Util.mkEvent(true);
+
+    // Check if indexedDB is allowed
+    var allowed = false;
+    var disabled = false;
+    var supported = false;
+
+    try {
+        var request = window.indexedDB.open('test_db', 1);
+        request.onsuccess = function () {
+            supported = true;
+            allowed = supported && !disabled;
+            onReady.fire();
+        };
+        request.onerror = function () {
+            onReady.fire();
+        };
+    } catch (e) {
+        onReady.fire();
+    }
+
+    S.enable = function () {
+        disabled = false;
+        allowed = supported && !disabled;
+    };
+    S.disable = function () {
+        disabled = true;
+        allowed = supported && !disabled;
+    };
+
+    var cache = localForage.createInstance({
+        driver: localForage.INDEXEDDB,
+        name: "cp_cache"
+    });
+
+    S.getBlobCache = function (id, cb) {
+        cb = Util.once(Util.mkAsync(cb || function () {}));
+
+        onReady.reg(function () {
+            if (!allowed) { return void cb('NOCACHE'); }
+            cache.getItem(id, function (err, obj) {
+                if (err || !obj || !obj.c) {
+                    return void cb(Util.serializeError(err || 'EINVAL'));
+                }
+                cb(null, obj.c);
+                obj.t = +new Date();
+                cache.setItem(id, obj, function (err) {
+                    if (!err) { return; }
+                    console.error(err);
+                });
+            });
+        });
+    };
+    S.setBlobCache = function (id, u8, cb) {
+        cb = Util.once(Util.mkAsync(cb || function () {}));
+
+        onReady.reg(function () {
+            if (!allowed) { return void cb('NOCACHE'); }
+            if (!u8) { return void cb('EINVAL'); }
+            cache.setItem(id, {
+                c: u8,
+                t: (+new Date()) // 't' represent the "lastAccess" of this cache (get or set)
+            }, function (err) {
+                cb(Util.serializeError(err));
+            });
+        });
+    };
+
+    // id: channel ID or blob ID
+    // returns array of messages
+    S.getChannelCache = function (id, cb) {
+        cb = Util.once(Util.mkAsync(cb || function () {}));
+
+        onReady.reg(function () {
+            if (!allowed) { return void cb('NOCACHE'); }
+            cache.getItem(id, function (err, obj) {
+                if (err || !obj || !Array.isArray(obj.c)) {
+                    return void cb(Util.serializeError(err || 'EINVAL'));
+                }
+                cb(null, obj);
+                obj.t = +new Date();
+                cache.setItem(id, obj, function (err) {
+                    if (!err) { return; }
+                    console.error(err);
+                });
+            });
+        });
+    };
+
+    // Keep the last two checkpoint + any checkpoint that may exist in the last 100 messages
+    // FIXME: duplicate system with sliceCpIndex from lib/hk-util.js
+    var checkCheckpoints = function (array) {
+        if (!Array.isArray(array)) { return; }
+        // Keep the last 100 messages
+        if (array.length > 100) { // FIXME this behaviour is only valid for chainpad-style documents
+            array.splice(0, array.length - 100);
+        }
+        // Remove every message before the first checkpoint
+        var firstCpIdx;
+        array.some(function (el, i) {
+            if (!el.isCheckpoint) { return; }
+            firstCpIdx = i;
+            return true;
+        });
+        array.splice(0, firstCpIdx);
+    };
+
+    var t = {};
+    S.storeCache = function (id, validateKey, val, onError) {
+        onError = Util.once(Util.mkAsync(onError || function () {}));
+
+        onReady.reg(function () {
+
+            // Make a throttle or use the existing one to avoid calling
+            // storeCache with the same array multiple times
+            t[id] = t[id] || Util.throttle(function (validateKey, val, onError) {
+                if (!allowed) { return void onError('NOCACHE'); }
+                if (!Array.isArray(val) || !validateKey) { return void onError('EINVAL'); }
+                checkCheckpoints(val);
+                cache.setItem(id, {
+                    k: validateKey,
+                    c: val,
+                    t: (+new Date()) // 't' represent the "lastAccess" of this cache (get or set)
+                }, function (err) {
+                    if (err) { onError(Util.serializeError(err)); }
+                });
+
+            }, 50);
+            t[id](validateKey, val, onError);
+
+        });
+    };
+
+    S.leaveChannel = function (id) {
+        delete t[id];
+    };
+
+    S.clearChannel = function (id, cb) {
+        cb = Util.once(Util.mkAsync(cb || function () {}));
+
+        onReady.reg(function () {
+            if (!allowed) { return void cb('NOCACHE'); }
+            cache.removeItem(id, function () {
+                cb();
+            });
+        });
+    };
+
+    S.clear = function (cb) {
+        cb = Util.once(Util.mkAsync(cb || function () {}));
+
+        onReady.reg(function () {
+            if (!allowed) { return void cb('NOCACHE'); }
+            cache.clear(cb);
+        });
+    };
+
+    S.getKeys = function (cb) {
+        cb = Util.once(Util.mkAsync(cb || function () {}));
+        onReady.reg(function () {
+            if (!allowed) { return void cb('NOCACHE'); }
+            cache.keys().then(function (keys) {
+                cb(null, keys);
+            }).catch(function (err) {
+                cb(err);
+            });
+        });
+    };
+    S.getTime = function (id, cb) {
+        cb = Util.once(Util.mkAsync(cb || function () {}));
+        onReady.reg(function () {
+            if (!allowed) { return void cb('NOCACHE'); }
+            cache.getItem(id, function (err, obj) {
+                if (err || !obj || !obj.c) {
+                    return void cb(Util.serializeError(err || 'EINVAL'));
+                }
+                cb(null, obj.t);
+            });
+        });
+    };
+
+    self.CryptPad_clearIndexedDB = S.clear;
+
+    return S;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        require('./common-util'),
+        require('localforage'),
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-util.js',
+        '/components/localforage/dist/localforage.min.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/common-constants.js b/src/common/common-constants.js
new file mode 100644
index 000000000..7f224a080
--- /dev/null
+++ b/src/common/common-constants.js
@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = function (AppConfig = {}) {
+    return {
+        setCustomize: data => {
+            AppConfig = data.AppConfig;
+        },
+
+        // localStorage
+        userHashKey: 'User_hash',
+        userNameKey: 'User_name',
+        blockHashKey: 'Block_hash',
+        fileHashKey: 'FS_hash',
+        sessionJWT: 'Session_JWT',
+        ssoSeed: 'SSO_seed',
+
+        // Store
+        displayNameKey: 'cryptpad.username',
+        oldStorageKey: 'CryptPad_RECENTPADS',
+        storageKey: 'filesData',
+        tokenKey: 'loginToken',
+        prefersDriveRedirectKey: 'prefersDriveRedirect',
+        isPremiumKey: 'isPremiumUser',
+        displayPadCreationScreen: 'displayPadCreationScreen',
+        deprecatedKey: 'deprecated',
+        MAX_TEAMS_SLOTS: AppConfig.maxTeamsSlots || 5,
+        MAX_TEAMS_OWNED: AppConfig.maxOwnedTeams || 5,
+        MAX_PREMIUM_TEAMS_SLOTS: Math.max(AppConfig.maxTeamsSlots || 0, AppConfig.maxPremiumTeamsSlots || 0) || 5,
+        MAX_PREMIUM_TEAMS_OWNED: Math.max(AppConfig.maxTeamsOwned || 0, AppConfig.maxPremiumTeamsOwned || 0) || 5,
+        // Apps
+        criticalApps: ['profile', 'settings', 'debug', 'admin', 'support', 'notifications', 'calendar', 'moderation', 'oldadmin'], // XXX oldadmin
+        earlyAccessApps: ['doc', 'presentation']
+    };
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(undefined);
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define(['/customize/application_config.js'], factory);
+} else {
+    // unsupported initialization
+}
+})();
+
diff --git a/src/common/common-credential.js b/src/common/common-credential.js
new file mode 100644
index 000000000..151a1ced4
--- /dev/null
+++ b/src/common/common-credential.js
@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(function () {
+var factory = function (AppConfig = {}, Scrypt) {
+    var Cred = {};
+
+    Cred.setCustomize = data => {
+        AppConfig = data.AppConfig;
+    };
+
+    Cred.MINIMUM_PASSWORD_LENGTH = typeof(AppConfig.minimumPasswordLength) === 'number'?
+        AppConfig.minimumPasswordLength: 8; // TODO 14 or higher is a decent default for 2023
+
+    Cred.MINIMUM_NAME_LENGTH = 1;
+    Cred.MAXIMUM_NAME_LENGTH = 64;
+
+    // https://stackoverflow.com/questions/46155/how-to-validate-an-email-address-in-javascript
+    Cred.isEmail = function (email) {
+        var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+        return re.test(String(email).toLowerCase());
+    };
+
+    Cred.isLongEnoughPassword = function (passwd) {
+        return passwd.length >= Cred.MINIMUM_PASSWORD_LENGTH;
+    };
+
+    var isString = Cred.isString = function (x) {
+        return typeof(x) === 'string';
+    };
+
+    // Maximum username length is enforced at registration time
+    // rather than in this function
+    // in order to maintain backwards compatibility with accounts
+    // that might have already registered with a longer name.
+    Cred.isValidUsername = function (name) {
+        return !!(isString(name) && name.length >= Cred.MINIMUM_NAME_LENGTH);
+    };
+
+    Cred.isValidPassword = function (passwd) {
+        return !!(passwd && isString(passwd));
+    };
+
+    Cred.passwordsMatch = function (a, b) {
+        return isString(a) && isString(b) && a === b;
+    };
+
+    Cred.customSalt = function () {
+        return typeof(AppConfig.loginSalt) === 'string'?
+            AppConfig.loginSalt: '';
+    };
+
+    Cred.deriveFromPassphrase = function (username, password, len, cb) {
+        Scrypt(password,
+            username + Cred.customSalt(), // salt
+            8, // memoryCost (n)
+            1024, // block size parameter (r)
+            len || 128, // dkLen
+            200, // interruptStep
+            cb,
+            undefined); // format, could be 'base64'
+    };
+
+    Cred.dispenser = function (bytes) {
+        var entropy = {
+            used: 0,
+        };
+
+        // crypto hygeine
+        var consume = function (n) {
+            // explode if you run out of bytes
+            if (entropy.used + n > bytes.length) {
+                throw new Error('exceeded available entropy');
+            }
+            if (typeof(n) !== 'number') { throw new Error('expected a number'); }
+            if (n <= 0) {
+                throw new Error('expected to consume a positive number of bytes');
+            }
+
+            // grab an unused slice of the entropy
+            // Note: Internet Explorer doesn't support .slice on Uint8Array
+            var A;
+            if (bytes.slice) {
+                A = bytes.slice(entropy.used, entropy.used + n);
+            } else {
+                A = bytes.subarray(entropy.used, entropy.used + n);
+            }
+
+            // account for the bytes you used so you don't reuse bytes
+            entropy.used += n;
+
+            //console.info("%s bytes of entropy remaining", bytes.length - entropy.used);
+            return A;
+        };
+
+        return consume;
+    };
+
+    return Cred;
+};
+
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = factory(
+            undefined, //require("../../customize.dist/application_config.js"),
+            require("scrypt-async")
+        );
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        define([
+            '/customize/application_config.js',
+            '/components/scrypt-async/scrypt-async.min.js',
+        ], function (AppConfig) {
+            return factory(AppConfig, window.scrypt);
+        });
+    }
+}());
diff --git a/src/common/common-feedback.js b/src/common/common-feedback.js
new file mode 100644
index 000000000..e4ab25a14
--- /dev/null
+++ b/src/common/common-feedback.js
@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (AppConfig = {}, Messages= {}) => {
+    var Feedback = {};
+
+    Feedback.setCustomize = data => {
+        Messages = data.Messages;
+        AppConfig = data.AppConfig;
+    };
+
+    Feedback.init = function (state) {
+        Feedback.state = state;
+    };
+
+    var randomToken = function () {
+        return Math.random().toString(16).replace(/0./, '');
+    };
+    var ajax = function (url, cb) {
+        var http = new XMLHttpRequest();
+        http.open('HEAD', url);
+        http.onreadystatechange = function() {
+            if (this.readyState === this.DONE) {
+                if (cb) { cb(); }
+            }
+        };
+        http.send();
+    };
+    Feedback.send = function (action, force, cb) {
+        if (typeof(cb) !== 'function') { cb = function () {}; }
+        if (AppConfig.disableFeedback) { return void cb(); }
+        if (!action) { return void cb(); }
+        if (force !== true) {
+            if (!Feedback.state) { return void cb(); }
+        }
+
+        var href = '/common/feedback.html?' + action + '=' + randomToken();
+        ajax(href, cb);
+    };
+
+    Feedback.reportAppUsage = function () {
+        var pattern = window.location.pathname.split('/')
+            .filter(function (x) { return x; }).join('.');
+        if (/^#\/1\/view\//.test(window.location.hash)) {
+            Feedback.send(pattern + '_VIEW');
+        } else {
+            Feedback.send(pattern);
+        }
+    };
+
+    Feedback.reportScreenDimensions = function () {
+        var h = window.innerHeight;
+        var w = window.innerWidth;
+        Feedback.send('DIMENSIONS:' + h + 'x' + w);
+    };
+    Feedback.reportLanguage = function () {
+        if (!Messages) { return; }
+        Feedback.send('LANG_' + Messages._languageUsed);
+    };
+
+
+    return Feedback;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(undefined, undefined);
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/customize/application_config.js',
+        '/customize/messages.js'
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/common-hash.js b/src/common/common-hash.js
new file mode 100644
index 000000000..f36faec82
--- /dev/null
+++ b/src/common/common-hash.js
@@ -0,0 +1,766 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(function (window) {
+var factory = function (Util, Crypto, Keys, Nacl) {
+    var Hash = window.CryptPad_Hash = {};
+
+    var uint8ArrayToHex = Util.uint8ArrayToHex;
+    var hexToBase64 = Util.hexToBase64;
+    var base64ToHex = Util.base64ToHex;
+    Hash.encodeBase64 = Nacl.util.encodeBase64;
+    Hash.decodeBase64 = Nacl.util.decodeBase64;
+
+    // This implementation must match that on the server
+    // it's used for a checksum
+    Hash.hashChannelList = function (list) {
+        return Nacl.util.encodeBase64(Nacl.hash(Nacl.util
+            .decodeUTF8(JSON.stringify(list))));
+    };
+
+    Hash.generateSignPair = function () {
+        var ed = Nacl.sign.keyPair();
+        var makeSafe = function (key) {
+            return Crypto.b64RemoveSlashes(key).replace(/=+$/g, '');
+        };
+        return {
+            validateKey: Hash.encodeBase64(ed.publicKey),
+            signKey: Hash.encodeBase64(ed.secretKey),
+            safeValidateKey: makeSafe(Hash.encodeBase64(ed.publicKey)),
+            safeSignKey: makeSafe(Hash.encodeBase64(ed.secretKey)),
+        };
+    };
+
+    Hash.getSignPublicFromPrivate = function (edPrivateSafeStr) {
+        var edPrivateStr = Crypto.b64AddSlashes(edPrivateSafeStr);
+        var privateKey = Nacl.util.decodeBase64(edPrivateStr);
+        var keyPair = Nacl.sign.keyPair.fromSecretKey(privateKey);
+        return Nacl.util.encodeBase64(keyPair.publicKey);
+    };
+    Hash.getCurvePublicFromPrivate = function (curvePrivateSafeStr) {
+        var curvePrivateStr = Crypto.b64AddSlashes(curvePrivateSafeStr);
+        var privateKey = Nacl.util.decodeBase64(curvePrivateStr);
+        var keyPair = Nacl.box.keyPair.fromSecretKey(privateKey);
+        return Nacl.util.encodeBase64(keyPair.publicKey);
+    };
+
+    var getEditHashFromKeys = Hash.getEditHashFromKeys = function (secret) {
+        var version = secret.version;
+        var data = secret.keys;
+        if (version === 0) {
+            return secret.channel + secret.key;
+        }
+        if (version === 1) {
+            if (!data.editKeyStr) { return; }
+            return '/1/edit/' + hexToBase64(secret.channel) +
+                   '/' + Crypto.b64RemoveSlashes(data.editKeyStr) + '/';
+        }
+        if (version === 2) {
+            if (!data.editKeyStr) { return; }
+            var pass = secret.password ? 'p/' : '';
+            return '/2/' + secret.type + '/edit/' + Crypto.b64RemoveSlashes(data.editKeyStr) + '/' + pass;
+        }
+    };
+    var getViewHashFromKeys = Hash.getViewHashFromKeys = function (secret) {
+        var version = secret.version;
+        var data = secret.keys;
+        if (version === 0) { return; }
+        if (version === 1) {
+            if (!data.viewKeyStr) { return; }
+            return '/1/view/' + hexToBase64(secret.channel) +
+                   '/'+Crypto.b64RemoveSlashes(data.viewKeyStr)+'/';
+        }
+        if (version === 2) {
+            if (!data.viewKeyStr) { return; }
+            var pass = secret.password ? 'p/' : '';
+            return '/2/' + secret.type + '/view/' + Crypto.b64RemoveSlashes(data.viewKeyStr) + '/' + pass;
+        }
+    };
+
+    Hash.getHiddenHashFromKeys = function (type, secret, opts) {
+        opts = opts || {};
+        var canEdit = (secret.keys && secret.keys.editKeyStr) || secret.key;
+        var mode = (!opts.view && canEdit) ? 'edit/' : 'view/';
+        var pass = secret.password ? 'p/' : '';
+
+        if (secret.keys && secret.keys.fileKeyStr) { mode = ''; }
+
+        var hash =  '/3/' + type + '/' + mode + secret.channel + '/' + pass;
+        var hashData = Hash.parseTypeHash(type, hash);
+        if (hashData && hashData.getHash) {
+            return hashData.getHash(opts || {});
+        }
+        return hash;
+    };
+
+    var getFileHashFromKeys = Hash.getFileHashFromKeys = function (secret) {
+        var version = secret.version;
+        var data = secret.keys;
+        if (version === 0) { return; }
+        if (version === 1) {
+            return '/1/' + hexToBase64(secret.channel) + '/' +
+                   Crypto.b64RemoveSlashes(data.fileKeyStr) + '/';
+        }
+        if (version === 2) {
+            if (!data.fileKeyStr) { return; }
+            var pass = secret.password ? 'p/' : '';
+            return '/2/' + secret.type + '/' + Crypto.b64RemoveSlashes(data.fileKeyStr) + '/' + pass;
+        }
+    };
+
+    Hash.getPublicSigningKeyString = Keys.serialize;
+
+    var fixDuplicateSlashes = function (s) {
+        return s.replace(/\/+/g, '/');
+    };
+
+    Hash.ephemeralChannelLength = 34;
+    Hash.createChannelId = function (ephemeral) {
+        var id = uint8ArrayToHex(Crypto.Nacl.randomBytes(ephemeral? 17: 16));
+        if ([32, 34].indexOf(id.length) === -1 || /[^a-f0-9]/.test(id)) {
+            throw new Error('channel ids must consist of 32 hex characters');
+        }
+        return id;
+    };
+
+    /*  Given a base64-encoded public key, deterministically derive a channel id
+        Used for support mailboxes
+    */
+    Hash.getChannelIdFromKey = function (publicKey) {
+        if (!publicKey) { return; }
+        return uint8ArrayToHex(Hash.decodeBase64(publicKey).subarray(0,16));
+    };
+
+    /*  Given a base64-encoded asymmetric private key
+        derive the corresponding public key
+    */
+    Hash.getBoxPublicFromSecret = function (priv) {
+        if (!priv) { return; }
+        var u8_priv = Hash.decodeBase64(priv);
+        var pair = Nacl.box.keyPair.fromSecretKey(u8_priv);
+        return Hash.encodeBase64(pair.publicKey);
+    };
+
+    /*  Given a base64-encoded private key and public key
+        check that the keys are part of a valid keypair
+    */
+    Hash.checkBoxKeyPair = function (priv, pub) {
+        if (!pub || !priv) { return false; }
+        var u8_priv = Hash.decodeBase64(priv);
+        var pair = Nacl.box.keyPair.fromSecretKey(u8_priv);
+        return pub === Hash.encodeBase64(pair.publicKey);
+    };
+
+    Hash.createRandomHash = function (type, password) {
+        var cryptor;
+        if (type === 'file') {
+            cryptor = Crypto.createFileCryptor2(void 0, password);
+            return getFileHashFromKeys({
+                password: Boolean(password),
+                version: 2,
+                type: type,
+                keys: cryptor
+            });
+        }
+        cryptor = Crypto.createEditCryptor2(void 0, void 0, password);
+        return getEditHashFromKeys({
+            password: Boolean(password),
+            version: 2,
+            type: type,
+            keys: cryptor
+        });
+    };
+
+/*
+Version 0
+    /pad/#67b8385b07352be53e40746d2be6ccd7XAYSuJYYqa9NfmInyHci7LNy
+Version 1: Add support for read-only access
+    /code/#/1/edit/3Ujt4F2Sjnjbis6CoYWpoQ/usn4+9CqVja8Q7RZOGTfRgqI
+Version 2: Add support for password-protection
+    /code/#/2/code/edit/u5ACvxAYmhvG0FtrNn9FJQcf/p/
+Version 3: Safe links
+    /code/#/3/code/edit/f0d8055aa640a97e7fd25020ca4e93b3/
+Version 4: Data URL when not a realtime link yet (new pad or "static" app)
+    /login/#/4/login/newpad=eyJocmVmIjoiaHR0cDovL2xvY2FsaG9zdDozMDAwL2NvZGUvIy8yL2NvZGUvZWRpdC91NUFDdnhBWW1odkcwRnRyTm45RklRY2YvIn0%3D/
+    /drive/#/4/drive/login=e30%3D/
+*/
+
+    var getLoginOpts = function (hashArr) {
+        var k;
+        // Check if we have a ownerKey for this pad
+        hashArr.some(function (data) {
+            if (/^login=/.test(data)) {
+                k = data.slice(6);
+                return true;
+            }
+        });
+        return k || '';
+    };
+    var getNewPadOpts = function (hashArr) {
+        var k;
+        // Check if we have a ownerKey for this pad
+        hashArr.some(function (data) {
+            if (/^newpad=/.test(data)) {
+                k = data.slice(7);
+                return true;
+            }
+        });
+        return k || '';
+    };
+    var getVersionHash = function (hashArr) {
+        var k;
+        // Check if we have a ownerKey for this pad
+        hashArr.some(function (data) {
+            if (/^hash=/.test(data)) {
+                k = data.slice(5);
+                return true;
+            }
+        });
+        return k ? Crypto.b64AddSlashes(k) : '';
+    };
+    var getAuditorKey = function (hashArr) {
+        var k;
+        // Check if we have a ownerKey for this pad
+        hashArr.some(function (data) {
+            if (/^auditor=/.test(data)) {
+                k = data.slice(8);
+                return true;
+            }
+        });
+        return k ? Crypto.b64AddSlashes(k) : '';
+    };
+    var getOwnerKey = function (hashArr) {
+        var k;
+        // Check if we have a ownerKey for this pad
+        hashArr.some(function (data) {
+            if (data.length === 86) {
+                k = data;
+                return true;
+            }
+        });
+        return k;
+    };
+    var parseTypeHash = Hash.parseTypeHash = function (type, hash) {
+        if (!hash) { return; }
+        var options = [];
+        var parsed = {};
+        var hashArr = fixDuplicateSlashes(hash).split('/');
+
+        var addOptions = function () {
+            parsed.password = options.indexOf('p') !== -1;
+            parsed.present = options.indexOf('present') !== -1;
+            parsed.embed = options.indexOf('embed') !== -1;
+            parsed.versionHash = getVersionHash(options);
+            parsed.auditorKey = getAuditorKey(options);
+            parsed.newPadOpts = getNewPadOpts(options);
+            parsed.loginOpts = getLoginOpts(options);
+            parsed.ownerKey = getOwnerKey(options);
+        };
+
+        // Version 4: only login or newpad options, same for all the apps
+        if (hashArr[1] && hashArr[1] === '4') {
+            parsed.getHash = function (opts) {
+                if (!opts || !Object.keys(opts).length) { return ''; }
+                var hash = '/4/' + type + '/';
+                if (opts.newPadOpts) { hash += 'newpad=' + opts.newPadOpts + '/'; }
+                if (opts.loginOpts) { hash += 'login=' + opts.loginOpts + '/'; }
+                return hash;
+            };
+            parsed.getOptions = function () {
+                var options = {};
+                if (parsed.newPadOpts) { options.newPadOpts = parsed.newPadOpts; }
+                if (parsed.loginOpts) { options.loginOpts = parsed.loginOpts; }
+                return options;
+            };
+
+            parsed.version = 4;
+            parsed.app = hashArr[2];
+            options = hashArr.slice(3);
+            addOptions();
+
+            return parsed;
+        }
+
+        // The other versions depends on the type
+        if (['media', 'file', 'user', 'invite'].indexOf(type) === -1) {
+            parsed.type = 'pad';
+            parsed.getHash = function () {
+                return hash;
+            };
+            parsed.getOptions = function () {
+                return {
+                    embed: parsed.embed,
+                    present: parsed.present,
+                    ownerKey: parsed.ownerKey,
+                    versionHash: parsed.versionHash,
+                    auditorKey: parsed.auditorKey,
+                    newPadOpts: parsed.newPadOpts,
+                    loginOpts: parsed.loginOpts,
+                    password: parsed.password
+                };
+            };
+
+            if (hash.slice(0,1) !== '/' && hash.length >= 56) { // Version 0
+                // Old hash
+                parsed.channel = hash.slice(0, 32);
+                parsed.key = hash.slice(32, 56);
+                parsed.version = 0;
+                return parsed;
+            }
+
+            // Version >= 1: more hash options
+            parsed.getHash = function (opts) {
+                var hash = hashArr.slice(0, 5).join('/') + '/';
+                var owner = typeof(opts.ownerKey) !== "undefined" ? opts.ownerKey : parsed.ownerKey;
+                if (owner) { hash += owner + '/'; }
+                if (parsed.password || opts.password) { hash += 'p/'; }
+                if (opts.embed) { hash += 'embed/'; }
+                if (opts.present) { hash += 'present/'; }
+                var versionHash = typeof(opts.versionHash) !== "undefined" ? opts.versionHash : parsed.versionHash;
+                if (versionHash) {
+                    hash += 'hash=' + Crypto.b64RemoveSlashes(versionHash) + '/';
+                }
+                var auditorKey = typeof(opts.auditorKey) !== "undefined" ? opts.auditorKey : parsed.auditorKey;
+                if (auditorKey) {
+                    hash += 'auditor=' + Crypto.b64RemoveSlashes(auditorKey) + '/';
+                }
+                if (opts.newPadOpts) { hash += 'newpad=' + opts.newPadOpts + '/'; }
+                if (opts.loginOpts) { hash += 'login=' + opts.loginOpts + '/'; }
+                return hash;
+            };
+
+            if (hashArr[1] && hashArr[1] === '1') { // Version 1
+                parsed.version = 1;
+                parsed.mode = hashArr[2];
+                parsed.channel = hashArr[3];
+                parsed.key = Crypto.b64AddSlashes(hashArr[4]);
+
+                options = hashArr.slice(5);
+                addOptions();
+
+                return parsed;
+            }
+            if (hashArr[1] && hashArr[1] === '2') { // Version 2
+                parsed.version = 2;
+                parsed.app = hashArr[2];
+                parsed.mode = hashArr[3];
+                parsed.key = hashArr[4];
+
+                options = hashArr.slice(5);
+                addOptions();
+
+                return parsed;
+            }
+            if (hashArr[1] && hashArr[1] === '3') { // Version 3: hidden hash
+                parsed.version = 3;
+                parsed.app = hashArr[2];
+                parsed.mode = hashArr[3];
+                parsed.channel = hashArr[4];
+
+                options = hashArr.slice(5);
+                addOptions();
+
+                return parsed;
+            }
+            return parsed;
+        }
+        parsed.getHash = function () { return hashArr.join('/'); };
+        if (['media', 'file'].indexOf(type) !== -1) {
+            parsed.type = 'file';
+
+            parsed.getOptions = function () {
+                return {
+                    embed: parsed.embed,
+                    present: parsed.present,
+                    ownerKey: parsed.ownerKey,
+                    newPadOpts: parsed.newPadOpts,
+                    loginOpts: parsed.loginOpts,
+                    password: parsed.password
+                };
+            };
+
+            parsed.getHash = function (opts) {
+                var hash = hashArr.slice(0, 4).join('/') + '/';
+                var owner = typeof(opts.ownerKey) !== "undefined" ? opts.ownerKey : parsed.ownerKey;
+                if (owner) { hash += owner + '/'; }
+                if (parsed.password || opts.password) { hash += 'p/'; }
+                if (opts.embed) { hash += 'embed/'; }
+                if (opts.present) { hash += 'present/'; }
+                if (opts.newPadOpts) { hash += 'newpad=' + opts.newPadOpts + '/'; }
+                if (opts.loginOpts) { hash += 'login=' + opts.loginOpts + '/'; }
+                return hash;
+            };
+
+            if (hashArr[1] && hashArr[1] === '1') {
+                parsed.version = 1;
+                parsed.channel = hashArr[2].replace(/-/g, '/');
+                parsed.key = hashArr[3].replace(/-/g, '/');
+                options = hashArr.slice(4);
+                addOptions();
+                return parsed;
+            }
+
+            if (hashArr[1] && hashArr[1] === '2') { // Version 2
+                parsed.version = 2;
+                parsed.app = hashArr[2];
+                parsed.key = hashArr[3];
+
+                options = hashArr.slice(4);
+                addOptions();
+
+                return parsed;
+            }
+
+            if (hashArr[1] && hashArr[1] === '3') { // Version 3: hidden hash
+                parsed.version = 3;
+                parsed.app = hashArr[2];
+                parsed.channel = hashArr[3];
+
+                options = hashArr.slice(4);
+                addOptions();
+
+                return parsed;
+            }
+            return parsed;
+        }
+        if (['user'].indexOf(type) !== -1) {
+            parsed.type = 'user';
+            if (hashArr[1] && hashArr[1] === '1') {
+                parsed.version = 1;
+                parsed.user = hashArr[2];
+                parsed.pubkey = hashArr[3].replace(/-/g, '/');
+                return parsed;
+            }
+            return parsed;
+        }
+        if (['invite'].indexOf(type) !== -1) {
+            parsed.type = 'invite';
+            if (hashArr[1] && hashArr[1] === '2') {
+                parsed.version = 2;
+                parsed.app = hashArr[2];
+                parsed.mode = hashArr[3];
+                parsed.key = hashArr[4];
+
+                options = hashArr.slice(5);
+                parsed.password = options.indexOf('p') !== -1;
+                return parsed;
+            }
+            return parsed;
+        }
+        return;
+    };
+    var parsePadUrl = Hash.parsePadUrl = function (href) {
+        var patt = /^https*:\/\/([^\/]*)\/(.*?)\//i;
+
+        var ret = {};
+
+        if (!href) { return ret; }
+        if (href.slice(-1) !== '/' && href.slice(-1) !== '#') { href += '/'; }
+        href = href.replace(/\/\?[^#]+#/, '/#');
+
+        var idx;
+
+        // When we start without a hash, use version 4 links to add login or newpad options
+        var getHash = function (opts) {
+            if (!opts || !Object.keys(opts).length) { return ''; }
+            var hash = '/4/' + ret.type + '/';
+            if (opts.newPadOpts) { hash += 'newpad=' + opts.newPadOpts + '/'; }
+            if (opts.loginOpts) { hash += 'login=' + opts.loginOpts + '/'; }
+            return hash;
+        };
+        ret.getUrl = function (options) {
+            options = options || {};
+            var url = '/';
+            if (!ret.type) { return url; }
+            url += ret.type + '/';
+            // New pad with options: append the options to the hash
+            if (!ret.hashData && options && Object.keys(options).length) {
+                return url + '#' + getHash(options);
+            }
+            if (!ret.hashData) { return url; }
+            //if (ret.hashData.version === 0) { return url + '#' + ret.hash; }
+            //if (ret.hashData.type !== 'pad') { return url + '#' + ret.hash; }
+            var hash = ret.hashData.getHash(options);
+            url += '#' + hash;
+            return url;
+        };
+        ret.getOptions = function () {
+            if (!ret.hashData || !ret.hashData.getOptions) { return {}; }
+            return ret.hashData.getOptions();
+        };
+
+        if (!/^https*:\/\//.test(href)) {
+            // If it doesn't start with http(s), it should be a relative href
+            if (!/^\/($|[^\/])/.test(href)) { return ret; }
+            idx = href.indexOf('/#');
+            ret.type = href.slice(1, idx);
+            if (idx === -1) { return ret; }
+            ret.hash = href.slice(idx + 2);
+            ret.hashData = parseTypeHash(ret.type, ret.hash);
+            return ret;
+        }
+
+        href.replace(patt, function (a, domain, type) {
+            ret.domain = domain;
+            ret.type = type;
+            return '';
+        });
+        idx = href.indexOf('/#');
+        if (idx === -1) { return ret; }
+        ret.hash = href.slice(idx + 2);
+        ret.hashData = parseTypeHash(ret.type, ret.hash);
+        return ret;
+    };
+
+    Hash.hashToHref = function (hash, type) {
+        return '/' + type + '/#' + hash;
+    };
+    Hash.hrefToHash = function (href) {
+        var parsed = Hash.parsePadUrl(href);
+        return parsed.hash;
+    };
+
+    Hash.getRelativeHref = function (href) {
+        if (!href) { return; }
+        if (href.indexOf('#') === -1) { return; }
+        var parsed = parsePadUrl(href);
+        return '/' + parsed.type + '/#' + parsed.hash;
+    };
+
+    /*
+     * Returns all needed keys for a realtime channel
+     * - no argument: use the URL hash or create one if it doesn't exist
+     * - secretHash provided: use secretHash to find the keys
+     */
+    Hash.getSecrets = function (type, secretHash, password) {
+        var secret = {};
+        var generate = function () {
+            secret.keys = Crypto.createEditCryptor2(void 0, void 0, password);
+            secret.channel = base64ToHex(secret.keys.chanId);
+            secret.version = 2;
+            secret.type = type;
+        };
+        if (!secretHash) {
+            generate();
+            return secret;
+        } else {
+            var parsed;
+            var hash;
+            if (secretHash) {
+                if (!type) { throw new Error("getSecrets with a hash requires a type parameter"); }
+                parsed = parseTypeHash(type, secretHash);
+                hash = secretHash;
+            }
+            if (hash.length === 0) {
+                generate();
+                return secret;
+            }
+            // old hash system : #{hexChanKey}{cryptKey}
+            // new hash system : #/{hashVersion}/{b64ChanKey}/{cryptKey}
+            if (parsed.version === 0) {
+                // Old hash
+                secret.channel = parsed.channel;
+                secret.key = parsed.key;
+                secret.version = 0;
+            } else if (parsed.version === 1) {
+                // New hash
+                secret.version = 1;
+                if (parsed.type === "pad") {
+                    secret.channel = base64ToHex(parsed.channel);
+                    if (parsed.mode === 'edit') {
+                        secret.keys = Crypto.createEditCryptor(parsed.key);
+                        secret.key = secret.keys.editKeyStr;
+                        if (secret.channel.length !== 32 || secret.key.length !== 24) {
+                            throw new Error("The channel key and/or the encryption key is invalid");
+                        }
+                    }
+                    else if (parsed.mode === 'view') {
+                        secret.keys = Crypto.createViewCryptor(parsed.key);
+                        if (secret.channel.length !== 32) {
+                            throw new Error("The channel key is invalid");
+                        }
+                    }
+                } else if (parsed.type === "file") {
+                    secret.channel = base64ToHex(parsed.channel);
+                    secret.keys = {
+                        fileKeyStr: parsed.key,
+                        cryptKey: Nacl.util.decodeBase64(parsed.key)
+                    };
+                } else if (parsed.type === "user") {
+                    throw new Error("User hashes can't be opened (yet)");
+                }
+            } else if (parsed.version === 2) {
+                // New hash
+                secret.version = 2;
+                secret.type = type;
+                secret.password = password;
+                if (parsed.type === "pad") {
+                    if (parsed.mode === 'edit') {
+                        secret.keys = Crypto.createEditCryptor2(parsed.key, void 0, password);
+                        secret.channel = base64ToHex(secret.keys.chanId);
+                        secret.key = secret.keys.editKeyStr;
+                        if (secret.channel.length !== 32 || secret.key.length !== 24) {
+                            throw new Error("The channel key and/or the encryption key is invalid");
+                        }
+                    }
+                    else if (parsed.mode === 'view') {
+                        secret.keys = Crypto.createViewCryptor2(parsed.key, password);
+                        secret.channel = base64ToHex(secret.keys.chanId);
+                        if (secret.channel.length !== 32) {
+                            throw new Error("The channel key is invalid");
+                        }
+                    }
+                } else if (parsed.type === "file") {
+                    secret.keys = Crypto.createFileCryptor2(parsed.key, password);
+                    secret.channel = base64ToHex(secret.keys.chanId);
+                    secret.key = secret.keys.fileKeyStr;
+                    if (secret.channel.length !== 48 || secret.key.length !== 24) {
+                        throw new Error("The channel key and/or the encryption key is invalid");
+                    }
+                } else if (parsed.type === "user") {
+                    throw new Error("User hashes can't be opened (yet)");
+                }
+            }
+        }
+        return secret;
+    };
+
+    Hash.getHashes = function (secret) {
+        var hashes = {};
+        secret = JSON.parse(JSON.stringify(secret));
+
+        if (!secret.keys && !secret.key) {
+            return hashes;
+        } else if (!secret.keys) {
+            secret.keys = {};
+        }
+
+        if (secret.keys.editKeyStr || (secret.version === 0 && secret.key)) {
+            hashes.editHash = getEditHashFromKeys(secret);
+        }
+        if (secret.keys.viewKeyStr) {
+            hashes.viewHash = getViewHashFromKeys(secret);
+        }
+        if (secret.keys.fileKeyStr) {
+            hashes.fileHash = getFileHashFromKeys(secret);
+        }
+        return hashes;
+    };
+
+    Hash.getFormData = function (secret, hash, password) {
+        secret = secret || Hash.getSecrets('form', hash, password);
+        var keys = secret && secret.keys;
+        var secondary = keys && keys.secondaryKey;
+        if (!secondary) { return; }
+        var curvePair = Nacl.box.keyPair.fromSecretKey(Nacl.util.decodeUTF8(secondary).slice(0,32));
+        var ret = {};
+        ret.form_public = Nacl.util.encodeBase64(curvePair.publicKey);
+        var privateKey = ret.form_private = Nacl.util.encodeBase64(curvePair.secretKey);
+
+        var auditorHash = Hash.getViewHashFromKeys({
+            version: 1,
+            channel: secret.channel,
+            keys: { viewKeyStr: Nacl.util.encodeBase64(keys.cryptKey) }
+        });
+        var _parsed = Hash.parseTypeHash('pad', auditorHash);
+        ret.form_auditorHash = _parsed.getHash({auditorKey: privateKey});
+
+        return ret;
+    };
+
+    // STORAGE
+    Hash.hrefToHexChannelId = function (href, password) {
+        var parsed = Hash.parsePadUrl(href);
+        if (!parsed || !parsed.hash) { return; }
+        var secret = Hash.getSecrets(parsed.type, parsed.hash, password);
+        return secret.channel;
+    };
+
+    Hash.getBlobPathFromHex = function (id) {
+        return '/blob/' + id.slice(0,2) + '/' + id;
+    };
+
+    Hash.serializeHash = function (hash) {
+        if (hash && hash.slice(-1) !== "/") { hash += "/"; }
+        return hash;
+    };
+
+    Hash.createInviteUrl = function (curvePublic, channel) {
+        channel = channel || Hash.createChannelId();
+        return window.location.origin + '/invite/#/1/' + channel +
+            '/' + curvePublic.replace(/\//g, '-') + '/';
+    };
+
+    Hash.isValidChannel = function (channelId) {
+        return /^[a-zA-Z0-9]{32,48}$/.test(channelId);
+    };
+
+    Hash.isValidHref = function (href) {
+        // Non-empty href?
+        if (!href) { return; }
+        var parsed = Hash.parsePadUrl(href);
+        // Can be parsed?
+        if (!parsed) { return; }
+        // Link to a CryptPad app?
+        if (!parsed.type) { return; }
+        // Valid hash?
+        if (parsed.hash) {
+            if (!parsed.hashData) { return; }
+            // Version should be a number
+            if (typeof(parsed.hashData.version) === "undefined") { return; }
+            // pads and files should have a base64 (or hex) key
+            if (parsed.hashData.type === 'pad' || parsed.hashData.type === 'file') {
+                if (!parsed.hashData.key && !parsed.hashData.channel) { return; }
+                if (parsed.hashData.key && !/^[a-zA-Z0-9+-/=]+$/.test(parsed.hashData.key)) { return; }
+            }
+        }
+        return parsed;
+    };
+
+    Hash.decodeDataOptions = function (opts) {
+        var b64 = decodeURIComponent(opts);
+        var str = Nacl.util.encodeUTF8(Nacl.util.decodeBase64(b64));
+        return Util.tryParse(str) || {};
+    };
+    Hash.encodeDataOptions = function (opts) {
+        var str = JSON.stringify(opts);
+        var b64 = Nacl.util.encodeBase64(Nacl.util.decodeUTF8(str));
+        return encodeURIComponent(b64);
+    };
+    Hash.getNewPadURL = function (href, opts) {
+        var parsed = Hash.parsePadUrl(href);
+        var options = parsed.getOptions();
+        options.newPadOpts = Hash.encodeDataOptions(opts);
+        return parsed.getUrl(options);
+    };
+    Hash.getLoginURL = function (href, opts) {
+        var parsed = Hash.parsePadUrl(href);
+        var options = parsed.getOptions();
+        options.loginOpts = Hash.encodeDataOptions(opts);
+        return parsed.getUrl(options);
+    };
+
+    return Hash;
+};
+
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = factory(
+            require("./common-util"),
+            require("chainpad-crypto"),
+            require("./common-signing-keys"),
+            require("tweetnacl/nacl-fast")
+        );
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        define([
+            '/common/common-util.js',
+            '/components/chainpad-crypto/crypto.js',
+            '/common/common-signing-keys.js',
+            '/components/tweetnacl/nacl-fast.min.js'
+        ], function (Util, Crypto, Keys) {
+            return factory(Util, Crypto, Keys, window.nacl);
+        });
+    } else {
+        // unsupported initialization
+    }
+}(typeof(window) !== 'undefined'? window : {}));
diff --git a/src/common/common-messaging.js b/src/common/common-messaging.js
new file mode 100644
index 000000000..f9b7fde24
--- /dev/null
+++ b/src/common/common-messaging.js
@@ -0,0 +1,161 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Crypto, Hash, Util, Constants, Realtime) => {
+    var Msg = {};
+
+    var createData = Msg.createData = function (proxy, hash) {
+        var data = {
+            channel: hash || Hash.createChannelId(),
+            displayName: proxy['cryptpad.username'],
+            profile: proxy.profile && proxy.profile.view,
+            edPublic: proxy.edPublic,
+            curvePublic: proxy.curvePublic,
+            notifications: Util.find(proxy, ['mailboxes', 'notifications', 'channel']),
+            avatar: proxy.profile && proxy.profile.avatar,
+            uid: proxy.uid,
+        };
+        if (hash === false) { delete data.channel; }
+        return data;
+    };
+
+    var getFriend = Msg.getFriend = function (proxy, pubkey) {
+        if (!pubkey) { return; }
+        if (pubkey === proxy.curvePublic) {
+            var data = createData(proxy);
+            delete data.channel;
+            return data;
+        }
+        return proxy.friends ? proxy.friends[pubkey] : undefined;
+    };
+
+    var getFriendList = Msg.getFriendList = function (proxy) {
+        if (!proxy.friends) { proxy.friends = {}; }
+        return proxy.friends;
+    };
+
+    var eachFriend = function (friends, cb) {
+        Object.keys(friends).forEach(function (id) {
+            if (id === 'me') { return; }
+            cb(friends[id], id, friends);
+        });
+    };
+
+    Msg.getFriendChannelsList = function (proxy) {
+        var list = [];
+        eachFriend(proxy.friends, function (friend) {
+            list.push(friend.channel);
+        });
+        return list;
+    };
+
+    Msg.declineFriendRequest = function (store, data, cb) {
+        store.mailbox.sendTo('DECLINE_FRIEND_REQUEST', {}, {
+            channel: data.notifications,
+            curvePublic: data.curvePublic
+        }, function (obj) {
+            cb(obj);
+        });
+    };
+    Msg.acceptFriendRequest = function (store, data, cb) {
+        var friend = getFriend(store.proxy, data.curvePublic) || {};
+        var myData = createData(store.proxy, friend.channel || data.channel);
+        store.mailbox.sendTo('ACCEPT_FRIEND_REQUEST', { user: myData }, {
+            channel: data.notifications,
+            curvePublic: data.curvePublic
+        }, function (obj) {
+            cb(obj);
+        });
+    };
+    Msg.addToFriendList = function (cfg, data, cb) {
+        var proxy = cfg.proxy;
+        var friends = getFriendList(proxy);
+        var pubKey = data.curvePublic; // todo validata data
+
+        if (pubKey === proxy.curvePublic) { return void cb("E_MYKEY"); }
+
+        friends[pubKey] = data;
+
+        Realtime.whenRealtimeSyncs(cfg.realtime, function () {
+            cb();
+            cfg.pinPads([data.channel], function (res) {
+                if (res.error) { console.error(res.error); }
+            });
+        });
+    };
+
+    Msg.updateMyData = function (store, curve) {
+        var myData = createData(store.proxy, false);
+        if (store.proxy.friends) {
+            store.proxy.friends.me = Util.clone(myData);
+            delete store.proxy.friends.me.channel;
+        }
+        if (store.modules['team']) {
+            store.modules['team'].updateMyData(myData);
+        }
+        var todo = function (friend) {
+            if (!friend || !friend.notifications) { return; }
+            delete friend.user;
+            myData.channel = friend.channel;
+            store.mailbox.sendTo('UPDATE_DATA', myData, {
+                channel: friend.notifications,
+                curvePublic: friend.curvePublic
+            }, function (obj) {
+                if (obj && obj.error) { console.error(obj); }
+            });
+        };
+        if (curve) {
+            var friend = getFriend(store.proxy, curve);
+            return void todo(friend);
+        }
+        eachFriend(store.proxy.friends || {}, todo);
+    };
+
+    Msg.removeFriend = function (store, curvePublic, cb) {
+        var proxy = store.proxy;
+        var friend = proxy.friends[curvePublic];
+        if (!friend) { return void cb({error: 'ENOENT'}); }
+        if (!friend.notifications) { return void cb({error: 'EINVAL'}); }
+
+        store.mailbox.sendTo('UNFRIEND', {
+            curvePublic: proxy.curvePublic
+        }, {
+            channel: friend.notifications,
+            curvePublic: friend.curvePublic
+        }, function (obj) {
+            if (obj && obj.error) {
+                return void cb(obj);
+            }
+            store.messenger.onFriendRemoved(curvePublic, friend.channel);
+            delete proxy.friends[curvePublic];
+            Realtime.whenRealtimeSyncs(store.realtime, function () {
+                cb(obj);
+            });
+        });
+    };
+
+    return Msg;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        require('chainpad-crypto'),
+        require('./common-hash'),
+        require('./common-util'),
+        require('./common-constants'),
+        require('./common-realtime')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/components/chainpad-crypto/crypto.js',
+        '/common/common-hash.js',
+        '/common/common-util.js',
+        '/common/common-constants.js',
+        '/common/common-realtime.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+})();
diff --git a/src/common/common-realtime.js b/src/common/common-realtime.js
new file mode 100644
index 000000000..cdf942609
--- /dev/null
+++ b/src/common/common-realtime.js
@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = () => {
+    var common = {};
+
+    /*
+        TODO make this not blow up when disconnected or lagging...
+    */
+    common.whenRealtimeSyncs = function (realtime, cb) {
+        if (typeof(realtime.getAuthDoc) !== 'function') {
+            return void console.error('improper use of this function');
+        }
+        setTimeout(function () {
+            if (realtime.getAuthDoc() === realtime.getUserDoc()) {
+                return void cb();
+            } else {
+                realtime.onSettle(cb);
+            }
+        }, 0);
+    };
+
+    return common;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory();
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/common-signing-keys.js b/src/common/common-signing-keys.js
new file mode 100644
index 000000000..1d1132c34
--- /dev/null
+++ b/src/common/common-signing-keys.js
@@ -0,0 +1,110 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(function () {
+var factory = function () {
+    var Keys = {};
+
+    var unescape = function (s) {
+        return s.replace(/-/g, '/');
+    };
+
+/*  Parse the new format of "Signing Public Keys".
+    If anything about the input is found to be invalid, return;
+    this will fall back to the old parsing method
+
+
+*/
+    var parseNewUser = function (userString) {
+        if (!/^\[.*?@.*\]$/.test(userString)) { return; }
+        var temp = userString.slice(1, -1);
+        var domain, username, pubkey;
+
+        temp = temp
+        .replace(/\/([a-zA-Z0-9+-]{43}=)$/, function (all, k) {
+            pubkey = unescape(k);
+            return '';
+        });
+        if (!pubkey) { return; }
+
+        var index = temp.lastIndexOf('@');
+        if (index < 1) { return; }
+
+        domain = temp.slice(index + 1);
+        username = temp.slice(0, index);
+
+        return {
+            domain: domain,
+            user: username,
+            pubkey: pubkey
+        };
+    };
+
+    var isValidUser = function (parsed) {
+        if (!parsed) { return; }
+        if (!(parsed.domain && parsed.user && parsed.pubkey)) { return; }
+        return true;
+    };
+
+    Keys.parseUser = function (user) {
+        var parsed = parseNewUser(user);
+        if (isValidUser(parsed)) { return parsed; }
+
+        var domain, username, pubkey;
+        user.replace(/^https*:\/\/([^\/]+)\/user\/#\/1\/([^\/]+)\/([a-zA-Z0-9+-]{43}=)$/,
+                        function (a, d, u, k) {
+            domain = d;
+            username = u;
+            pubkey = unescape(k);
+            return '';
+        });
+        if (!domain) { throw new Error("Could not parse user id [" + user + "]"); }
+        return {
+            domain: domain,
+            user: username,
+            pubkey: pubkey
+        };
+    };
+
+/*
+
+0. usernames may contain spaces or many other wacky characters, so enclose the whole thing in square braces so we know its boundaries. If the formatted string does not include these we know it is either a _v1 public key string_ or _an incomplete string_. Start parsing by removing them.
+1. public keys should have a fixed length, so slice them off of the end of the string.
+2. domains cannot include `@`, so find the last occurence of it in the signing key and slice everything thereafter.
+3. the username is everything before the `@`.
+
+*/
+    Keys.serialize = function (origin, username, pubkey) {
+        return '[' +
+            username +
+            '@' +
+            origin.replace(/https*:\/\//, '') +
+            '/' +
+            pubkey.replace(/\//g, '-') +
+        ']';
+        // return origin + '/user/#/1/' + username + '/' + pubkey.replace(/\//g, '-');
+    };
+
+    Keys.canonicalize = function (input) {
+        if (typeof(input) !== 'string') { return; }
+        // key is already in simple form. ensure that it is an 'unsafeKey'
+        if (input.length === 44) {
+            return unescape(input);
+        }
+        try {
+            return Keys.parseUser(input).pubkey;
+        } catch (err) {
+            return;
+        }
+    };
+
+    return Keys;
+};
+
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = factory();
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        define([], factory);
+    }
+}());
diff --git a/src/common/common-util.js b/src/common/common-util.js
new file mode 100644
index 000000000..5faa9171e
--- /dev/null
+++ b/src/common/common-util.js
@@ -0,0 +1,775 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(function (window) {
+    var Util = {};
+
+    // polyfill for atob in case you're using this from node...
+    window.atob = window.atob || function (str) { return Buffer.from(str, 'base64').toString('binary'); };
+    window.btoa = window.btoa || function (str) { return Buffer.from(str, 'binary').toString('base64'); };
+
+    Util.slice = function (A, start, end) {
+        return Array.prototype.slice.call(A, start, end);
+    };
+
+    Util.shuffleArray = function (a) {
+        for (var i = a.length - 1; i > 0; i--) {
+            var j = Math.floor(Math.random() * (i + 1));
+            var tmp = a[i];
+            a[i] = a[j];
+            a[j] = tmp;
+        }
+    };
+
+    Util.bake = function (f, args) {
+        if (typeof(args) === 'undefined') { args = []; }
+        if (!Array.isArray(args)) { args = [args]; }
+        return function () {
+            return f.apply(null, args);
+        };
+    };
+
+    Util.both = function (pre, post) {
+        if (typeof(pre) !== 'function') { throw new Error('INVALID_USAGE'); }
+        if (typeof(post) !== 'function') { post = function (x) { return x; }; }
+        return function () {
+            pre.apply(null, arguments);
+            return post.apply(null, arguments);
+        };
+    };
+
+    Util.clone = function (o) {
+        if (o === undefined || o === null) { return o; }
+        return JSON.parse(JSON.stringify(o));
+    };
+
+    Util.serializeError = function (err) {
+        if (!(err instanceof Error)) { return err; }
+        var ser = {};
+        Object.getOwnPropertyNames(err).forEach(function (key) {
+            ser[key] = err[key];
+        });
+        return ser;
+    };
+
+    Util.tryParse = function (s) {
+        try { return JSON.parse(s); } catch (e) { return;}
+    };
+
+    Util.mkAsync = function (f, ms) {
+        if (typeof(f) !== 'function') {
+            throw new Error('EXPECTED_FUNCTION');
+        }
+        return function () {
+            var args = Array.prototype.slice.call(arguments);
+            setTimeout(function () {
+                f.apply(null, args);
+            }, ms);
+        };
+    };
+
+    // If once is true, after the event has been fired, any further handlers which are
+    // registered will fire immediately, and this type of event cannot be fired twice.
+    Util.mkEvent = function (once) {
+        var handlers = [];
+        var fired = false;
+        return {
+            reg: function (cb) {
+                if (once && fired) { return void setTimeout(cb); }
+                handlers.push(cb);
+            },
+            unreg: function (cb) {
+                if (handlers.indexOf(cb) === -1) {
+                    return void console.log("event handler was already unregistered");
+                }
+                handlers.splice(handlers.indexOf(cb), 1);
+            },
+            fire: function () {
+                if (once && fired) { return; }
+                fired = true;
+                var args = Array.prototype.slice.call(arguments);
+                handlers.forEach(function (h) { h.apply(null, args); });
+            }
+        };
+    };
+
+    Util.mkTimeout = function (_f, ms) {
+        ms = ms || 0;
+        var f = Util.once(_f);
+
+        var timeout = setTimeout(function () {
+            f('TIMEOUT');
+        }, ms);
+
+        return Util.both(f, function () {
+            clearTimeout(timeout);
+        });
+    };
+
+    Util.onClickEnter = function ($element, handler, cfg) {
+        $element.on('click keydown', function (e) {
+            var isClick = e.type === 'click';
+            var isEnter = e.type === 'keydown' && e.which === 13;
+            var isSpace = e.type === 'keydown' && e.which === 32 && cfg && cfg.space;
+            if (!isClick && !isEnter && !isSpace) { return; }
+
+            // "enter" on a button triggers a click, disable it
+            if (e.type === 'keydown') { e.preventDefault(); }
+
+            handler(e);
+        });
+    };
+
+    Util.response = function (errorHandler) {
+        var pending = {};
+        var timeouts = {};
+
+        if (typeof(errorHandler) !== 'function') {
+            errorHandler = function (label) {
+                throw new Error(label);
+            };
+        }
+
+        var clear = function (id) {
+            clearTimeout(timeouts[id]);
+            delete timeouts[id];
+            delete pending[id];
+        };
+
+        var expect = function (id, fn, ms) {
+            if (typeof(id) !== 'string') { errorHandler('EXPECTED_STRING'); }
+            if (typeof(fn) !== 'function') { errorHandler('EXPECTED_CALLBACK'); }
+            pending[id] = fn;
+            if (typeof(ms) === 'number' && ms) {
+                timeouts[id] = setTimeout(function () {
+                    if (typeof(pending[id]) === 'function') { pending[id]('TIMEOUT'); }
+                    clear(id);
+                }, ms);
+            }
+        };
+
+        var handle = function (id, args) {
+            var fn = pending[id];
+            if (typeof(fn) !== 'function') {
+                return void errorHandler("MISSING_CALLBACK", {
+                    id: id,
+                    args: args,
+                });
+            }
+            try {
+                fn.apply(null, Array.isArray(args)? args : [args]);
+            } catch (err) {
+                errorHandler('HANDLER_ERROR', {
+                    error: err,
+                    id: id,
+                    args: args,
+                });
+            }
+            clear(id);
+        };
+
+        return {
+            clear: clear,
+            expected: function (id) {
+                return Boolean(pending[id]);
+            },
+            expectation: function (id) {
+                return pending[id];
+            },
+            expect: expect,
+            handle: handle,
+            _pending: pending,
+        };
+    };
+
+    Util.inc = function (map, key, val) {
+        map[key] = (map[key] || 0) + (typeof(val) === 'number'? val: 1);
+    };
+
+    Util.values = function (obj) {
+        return Object.keys(obj).map(function (k) {
+            return obj[k];
+        });
+    };
+
+    Util.find = function (map, path) {
+        var l = path.length;
+        for (var i = 0; i < l; i++) {
+            if (typeof(map[path[i]]) === 'undefined') { return; }
+            map = map[path[i]];
+        }
+        return map;
+    };
+
+    Util.uid = function () {
+        return Number(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER))
+            .toString(32).replace(/\./g, '');
+    };
+
+    Util.guid = function (map) {
+        var id = Util.uid();
+        // the guid (globally unique id) is valid if it does already exist in the map
+        if (typeof(map[id]) === 'undefined') { return id; }
+        // otherwise try again
+        return Util.guid(map);
+    };
+
+    Util.fixHTML = function (str) {
+        if (!str) { return ''; }
+        return str.replace(/[<>&"']/g, function (x) {
+            return ({ "<": "&lt;", ">": "&gt", "&": "&amp;", '"': "&#34;", "'": "&#39;" })[x];
+        });
+    };
+
+    Util.hexToBase64 = function (hex) {
+        var hexArray = hex
+            .replace(/\r|\n/g, "")
+            .replace(/([\da-fA-F]{2}) ?/g, "0x$1 ")
+            .replace(/ +$/, "")
+            .split(" ");
+        var byteString = String.fromCharCode.apply(null, hexArray);
+        return window.btoa(byteString).replace(/\//g, '-').replace(/=+$/, '');
+    };
+
+    Util.base64ToHex = function (b64String) {
+        var hexArray = [];
+        window.atob(b64String.replace(/-/g, '/')).split("").forEach(function(e){
+            var h = e.charCodeAt(0).toString(16);
+            if (h.length === 1) { h = "0"+h; }
+            hexArray.push(h);
+        });
+        return hexArray.join("");
+    };
+
+    Util.uint8ArrayToHex = function (bytes) {
+        var hexString = '';
+        for (var i = 0; i < bytes.length; i++) {
+            if (bytes[i] < 16) { hexString += '0'; }
+            hexString += bytes[i].toString(16);
+        }
+        return hexString;
+    };
+
+    Util.hexToUint8Array = function (hexString) {
+        var bytes = new Uint8Array(Math.ceil(hexString.length / 2));
+        for (var i = 0; i < bytes.length; i++) {
+            bytes[i] = parseInt(hexString.substr(i * 2, 2), 16);
+        }
+        return bytes;
+    };
+
+    // given an array of Uint8Arrays, return a new Array with all their values
+    Util.uint8ArrayJoin = function (AA) {
+        var l = 0;
+        var i = 0;
+        for (; i < AA.length; i++) { l += AA[i].length; }
+        var C = new Uint8Array(l);
+
+        i = 0;
+        for (var offset = 0; i < AA.length; i++) {
+            C.set(AA[i], offset);
+            offset += AA[i].length;
+        }
+        return C;
+    };
+
+    Util.escapeKeyCharacters = function (key) {
+        return key && key.replace && key.replace(/\//g, '-');
+    };
+
+    Util.unescapeKeyCharacters = function (key) {
+        return key.replace(/\-/g, '/');
+    };
+
+    Util.deduplicateString = function (array) {
+        var a = array.slice();
+        for(var i=0; i<a.length; i++) {
+            for(var j=i+1; j<a.length; j++) {
+                if(a[i] === a[j]) { a.splice(j--, 1); }
+            }
+        }
+        return a;
+    };
+
+    /*
+     *  Saving files
+     */
+    Util.fixFileName = function (filename) {
+        return filename.replace(/ /g, '-').replace(/[\/\?]/g, '_')
+            .replace(/_+/g, '_');
+    };
+
+    var oneKilobyte = 1024;
+    var oneMegabyte = 1024 * oneKilobyte;
+    var oneGigabyte = 1024 * oneMegabyte;
+
+    Util.bytesToGigabytes = function (bytes) {
+        return Math.ceil(bytes / oneGigabyte * 100) / 100;
+    };
+
+    Util.bytesToMegabytes = function (bytes) {
+        return Math.ceil(bytes / oneMegabyte * 100) / 100;
+    };
+
+    Util.bytesToKilobytes = function (bytes) {
+        return Math.ceil(bytes / oneKilobyte * 100) / 100;
+    };
+
+    Util.magnitudeOfBytes = function (bytes) {
+        if (bytes >= oneGigabyte) { return 'GB'; }
+        else if (bytes >= oneMegabyte) { return 'MB'; }
+        else { return 'KB'; }
+    };
+
+    // given a path, asynchronously return an arraybuffer
+    var getCacheKey = function (src) {
+        var _src = src.replace(/(\/)*$/, ''); // Remove trailing slashes
+        var idx = _src.lastIndexOf('/');
+        var cacheKey = _src.slice(idx+1);
+        if (!/^[a-f0-9]{48}$/.test(cacheKey)) { cacheKey = undefined; }
+        return cacheKey;
+    };
+
+
+    Util.getBlock = function (src, opt, cb) {
+        var CB = Util.once(Util.mkAsync(cb));
+
+        var headers = {};
+
+        if (typeof(opt.bearer) === 'string' && opt.bearer) {
+            headers.authorization = `Bearer ${opt.bearer}`;
+        }
+
+
+        fetch(src, {
+            method: 'GET',
+            credentials: 'include',
+            headers: headers,
+        }).then(response => {
+            if (response.ok) {
+                // TODO this should probably be returned as an arraybuffer or something rather than a promise
+                // this is resulting in some code duplication
+                return void CB(void 0, response);
+            }
+            if (response.status === 401 || response.status === 404) {
+                response.json().then((data) => {
+                    CB(response.status, data);
+                }).catch(() => {
+                    CB(response.status);
+                });
+
+                return;
+            }
+            CB(response.status, response);
+        }).catch(error => {
+            CB(error);
+        });
+    };
+
+
+    Util.fetch = function (src, cb, progress, cache) {
+        var CB = Util.once(Util.mkAsync(cb));
+
+        var cacheKey = getCacheKey(src);
+        var getBlobCache = function (id, cb) {
+            if (!cache || typeof(cache.getBlobCache) !== "function") { return void cb('EINVAL'); }
+            cache.getBlobCache(id, cb);
+        };
+        var setBlobCache = function (id, u8, cb) {
+            if (!cache || typeof(cache.setBlobCache) !== "function") { return void cb('EINVAL'); }
+            cache.setBlobCache(id, u8, cb);
+        };
+
+        var xhr;
+
+        var fetch = function () {
+            xhr = new XMLHttpRequest();
+            xhr.open("GET", src, true);
+            if (progress) {
+                xhr.addEventListener("progress", function (evt) {
+                    if (evt.lengthComputable) {
+                        var percentComplete = evt.loaded / evt.total;
+                        progress(percentComplete);
+                    }
+                }, false);
+            }
+            xhr.responseType = "arraybuffer";
+            xhr.onerror = function (err) { CB(err); };
+            xhr.onload = function () {
+                if (/^4/.test(''+this.status)) {
+                    return CB('XHR_ERROR');
+                }
+
+                var arrayBuffer = xhr.response;
+                if (arrayBuffer) {
+                    var u8 = new Uint8Array(arrayBuffer);
+                    if (cacheKey) {
+                        return void setBlobCache(cacheKey, u8, function () {
+                            CB(null, u8);
+                        });
+                    }
+                    return void CB(void 0, u8);
+                }
+                CB('ENOENT');
+            };
+            xhr.send(null);
+        };
+
+        if (!cacheKey) { return void fetch(); }
+
+        getBlobCache(cacheKey, function (err, u8) {
+            if (err || !u8) { return void fetch(); }
+            CB(void 0, u8);
+        });
+
+        return {
+            cancel: function () {
+                if (xhr && xhr.abort) { xhr.abort(); }
+            }
+        };
+    };
+
+    Util.dataURIToBlob = function (dataURI) {
+        var byteString = atob(dataURI.split(',')[1]);
+        var mimeString = dataURI.split(',')[0].split(':')[1].split(';')[0];
+
+        // write the bytes of the string to an ArrayBuffer
+        var ab = new ArrayBuffer(byteString.length);
+        var ia = new Uint8Array(ab);
+        for (var i = 0; i < byteString.length; i++) {
+            ia[i] = byteString.charCodeAt(i);
+        }
+
+        // write the ArrayBuffer to a blob, and you're done
+        var bb = new Blob([ab], {type: mimeString});
+        return bb;
+    };
+
+    Util.throttle = function (f, ms) {
+        var last = 0;
+        var to;
+        var args;
+
+        var defer = function (delay) {
+            // no timeout: run function `f` in `ms` milliseconds
+            // unless `g` is called again in the meantime
+            to = setTimeout(function () {
+                // wipe the current timeout handler
+                to = undefined;
+
+                // take the current time
+                var now = +new Date();
+                // compute time passed since `last`
+                var diff = now - last;
+                if (diff < ms) {
+                    // don't run `f` if `g` was called since this timeout was set
+                    // instead calculate how much further in the future your next
+                    // timeout should be scheduled
+                    return void defer(ms - diff);
+                }
+
+                // else run `f` with the most recently supplied arguments
+                f.apply(null, args);
+            }, delay);
+        };
+
+        var g = function () {
+            // every time you call this function store the time
+            last = +new Date();
+            // remember what arguments were passed
+            args = Util.slice(arguments);
+            // if there is a pending timeout then do nothing
+            if (to) { return; }
+            defer(ms);
+        };
+
+        g.clear = function () {
+            clearTimeout(to);
+            to = undefined;
+        };
+        return g;
+    };
+
+    /*  takes a function (f) and a time (t) in ms. returns a function wrapper
+        which prevents the internal function from being called more than once
+        every t ms. if the function is prevented, returns time til next valid
+        execution, else null.
+    */
+    Util.notAgainForAnother = function (f, t) {
+        if (typeof(f) !== 'function' || typeof(t) !== 'number') {
+            throw new Error("invalid inputs");
+        }
+        var last = null;
+        return function () {
+            var now = +new Date();
+            if (last && now <= last + t) { return t - (now - last); }
+            last = now;
+            f.apply(null, Util.slice(arguments));
+            return null;
+        };
+    };
+
+    Util.createRandomInteger = function () {
+        return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+    };
+
+    Util.noop = function () {};
+
+    /* for wrapping async functions such that they can only be called once */
+    Util.once = function (f, g) {
+        return function () {
+            if (!f) { return; }
+            f.apply(this, Array.prototype.slice.call(arguments));
+            f = g;
+        };
+    };
+
+    Util.blobToImage = function (blob, cb) {
+        var reader = new FileReader();
+        reader.onloadend = function() {
+            cb(reader.result);
+        };
+        reader.readAsDataURL(blob);
+    };
+    Util.blobURLToImage = function (url, cb) {
+        var xhr = new XMLHttpRequest();
+        xhr.onload = function() {
+            var reader = new FileReader();
+            reader.onloadend = function() {
+                cb(reader.result);
+            };
+            reader.readAsDataURL(xhr.response);
+        };
+        xhr.open('GET', url);
+        xhr.responseType = 'blob';
+        xhr.send();
+    };
+
+    // Check if an element is a plain object
+    Util.isObject = function (o) {
+        return typeof (o) === "object" &&
+               Object.prototype.toString.call(o) === '[object Object]';
+    };
+
+    Util.isCircular = function (o) {
+        try {
+            JSON.stringify(o);
+            return false;
+        } catch (e) { return true; }
+    };
+
+    /*  recursively adds the properties of an object 'b' to 'a'
+        arrays are only shallow copies, so references to the original
+        might still be present. Be mindful if you will modify 'a' in the future */
+    Util.extend = function (a, b) {
+        if (!Util.isObject(a) || !Util.isObject(b)) {
+            return void console.log("Extend only works with 2 objects");
+        }
+        if (Util.isCircular(b)) {
+            return void console.log("Extend doesn't accept circular objects");
+        }
+        for (var k in b) {
+            if (Util.isObject(b[k])) {
+                a[k] = Util.isObject(a[k]) ? a[k] : {};
+                Util.extend(a[k], b[k]);
+                continue;
+            }
+            if (Array.isArray(b[k])) {
+                a[k] = b[k].slice();
+                continue;
+            }
+            a[k] = b[k];
+        }
+    };
+
+    Util.isChecked = function (el) {
+        // could be nothing...
+        if (!el) { return false; }
+        // check if it's a dom element
+        if (typeof(el.tagName) !== 'undefined') {
+            return Boolean(el.checked);
+        }
+        // sketchy test to see if it's jquery
+        if (typeof(el.prop) === 'function') {
+            return Boolean(el.prop('checked'));
+        }
+        // else just say it's not checked
+        return false;
+    };
+
+    Util.hexToRGB = function (hex) {
+        var h = hex.replace(/^#/, '');
+        return [
+            parseInt(h.slice(0,2), 16),
+            parseInt(h.slice(2,4), 16),
+            parseInt(h.slice(4,6), 16),
+        ];
+    };
+    Util.rgbToHex = function (rgb) {
+        return `#${rgb.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/).slice(1).map(n => parseInt(n, 10).toString(16).padStart(2, '0')).join('')}`;
+    };
+
+    Util.isSmallScreen = function () {
+        return window.innerHeight < 800 || window.innerWidth < 800;
+    };
+
+    Util.stripTags = function (text) {
+        var div = document.createElement("div");
+        div.innerHTML = text;
+        return div.innerText;
+    };
+
+    // return an object containing {name, ext}
+    // or {} if the name could not be parsed
+    Util.parseFilename = function (filename) {
+        if (!filename || !filename.trim()) { return {}; }
+        var parsedName =  /^(\.?.+?)(\.[^.]+)?$/.exec(filename) || [];
+        return {
+            name: parsedName[1],
+            ext: parsedName[2],
+        };
+    };
+
+    // Tell if a file is plain text from its metadata={title, fileType}
+    Util.isPlainTextFile = function (type, name) {
+        // does its type begins with "text/"
+        if (type && type.indexOf("text/") === 0) { return true; }
+        // no type and no file extension -> let's guess it's plain text
+        var parsedName = Util.parseFilename(name);
+        if (!type && name && !parsedName.ext) { return true; }
+        // other exceptions
+        if (type === 'application/x-javascript') { return true; }
+        if (type === 'application/xml') { return true; }
+        return false;
+    };
+
+    // Tell if a file is spreadsheet from its metadata={title, fileType}
+    Util.isSpreadsheet = function (type, name) {
+        return (type &&
+                    (type === 'application/vnd.oasis.opendocument.spreadsheet' ||
+                    type === 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'))
+                || (name && (name.endsWith('.xlsx') || name.endsWith('.ods')));
+    };
+    Util.isOfficeDoc = function (type, name) {
+        return (type &&
+                    (type === 'application/vnd.oasis.opendocument.text' ||
+                    type === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'))
+                || (name && (name.endsWith('.docx') || name.endsWith('.odt')));
+    };
+    Util.isPresentation = function (type, name) {
+        return (type &&
+                    (type === 'application/vnd.oasis.opendocument.presentation' ||
+                    type === 'application/vnd.openxmlformats-officedocument.presentationml.presentation'))
+                || (name && (name.endsWith('.pptx') || name.endsWith('.odp')));
+    };
+
+    Util.isValidURL = function (str) {
+        var pattern = new RegExp('^(https?:\\/\\/)'+ // protocol
+            '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|'+ // domain name
+            '((\\d{1,3}\\.){3}\\d{1,3}))'+ // OR ip (v4) address
+            '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*'+ // port and path
+            '(\\?[;&a-z\\d%_.~+=-]*)?'); // query string
+            //'(\\#[-a-z\\d_]*)?$','i'); // fragment locator
+        return !!pattern.test(str);
+    };
+
+    var emoji_patt = /([\uD800-\uDBFF][\uDC00-\uDFFF])/;
+    var isEmoji = function (str) {
+      return emoji_patt.test(str);
+    };
+    var emojiStringToArray = function (str) {
+      var split = str.split(emoji_patt);
+      var arr = [];
+      for (var i=0; i<split.length; i++) {
+        var char = split[i];
+        if (char !== "") {
+          arr.push(char);
+        }
+      }
+      return arr;
+    };
+    Util.getFirstCharacter = function (str) {
+      if (!str || !str.trim()) { return '?'; }
+      var emojis = emojiStringToArray(str);
+      return isEmoji(emojis[0])? emojis[0]: str[0];
+    };
+
+    Util.getRandomColor = function (light) {
+        var getColor = function () {
+            if (light) {
+                return Math.floor(Math.random() * 156) + 70;
+            }
+            return Math.floor(Math.random() * 200) + 25;
+        };
+        return '#' + getColor().toString(16) +
+                     getColor().toString(16) +
+                     getColor().toString(16);
+    };
+
+    Util.checkRestrictedApp = function (app, AppConfig, earlyTypes, plan, loggedIn) {
+        // If this is an early access app, make sure this instance allows them
+        if (Array.isArray(earlyTypes) && earlyTypes.includes(app) && !AppConfig.enableEarlyAccess) {
+            return -2;
+        }
+
+        var premiumTypes = AppConfig.premiumTypes;
+        // If this is not a premium app, don't disable it
+        if (!Array.isArray(premiumTypes) || !premiumTypes.includes(app)) { return 2; }
+        // This is a premium app
+        // if you're not logged in, disable it
+        if (!loggedIn) { return -1; }
+        // if you're logged in, enable it only if you're a premium user
+        return plan ? 1 : 0;
+
+    };
+
+    /*  Chrome 92 dropped support for SharedArrayBuffer in cross-origin contexts
+        where window.crossOriginIsolated is false.
+
+        Their blog (https://blog.chromium.org/2021/02/restriction-on-sharedarraybuffers.html)
+        isn't clear about why they're doing this, but since it's related to site-isolation
+        it seems they're trying to do vague security things.
+
+        In any case, there seems to be a workaround where you can still create them
+        by using `new WebAssembly.Memory({shared: true, ...})` instead of `new SharedArrayBuffer`.
+
+        This seems unreliable, but it's better than not being able to export, since
+        we actively rely on postMessage between iframes and therefore can't afford
+        to opt for full isolation.
+    */
+    var supportsSharedArrayBuffers = function () {
+        try {
+            return Object.prototype.toString.call(new window.WebAssembly.Memory({shared: true, initial: 0, maximum: 0}).buffer) === '[object SharedArrayBuffer]';
+        } catch (err) {
+            console.error(err);
+        }
+        return false;
+    };
+    Util.supportsWasm = function () {
+        return !(typeof(Atomics) === "undefined" || !supportsSharedArrayBuffers() || typeof(WebAssembly) === 'undefined');
+    };
+
+    //Returns an array of integers in range 0 to (length-1)
+    Util.getKeysArray = function (length) {
+        return [...Array(length).keys()];
+    };
+
+    Util.getVersionFromUrlArgs = urlArgs => {
+        let arr = /ver=([0-9.]+)(-[0-9]*)?/.exec(urlArgs);
+        let ver = Array.isArray(arr) && arr[1];
+        return ver || undefined;
+    };
+
+
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = Util;
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        define([], function () {
+            window.CryptPad_Util = Util;
+            return Util;
+        });
+    } else {
+        window.CryptPad_Util = Util;
+    }
+}(typeof(self) !== 'undefined'? self: this));
diff --git a/src/common/cryptget.js b/src/common/cryptget.js
new file mode 100644
index 000000000..df3453225
--- /dev/null
+++ b/src/common/cryptget.js
@@ -0,0 +1,238 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Crypto, CPNetflux, Netflux, Util,
+            Hash, Realtime, NetConfig, Cache, Pinpad, nThen) => {
+    var finish = function (S, err, doc) {
+        if (S.done) { return; }
+        S.cb((err && err.error), doc, err);
+        S.done = true;
+
+        if (!S.hasNetwork) {
+            var disconnect = Util.find(S, ['network', 'disconnect']);
+            if (typeof(disconnect) === 'function') { disconnect(); }
+        }
+        if (S.realtime && S.realtime.stop) {
+            try {
+                S.realtime.stop();
+            } catch (e) { console.error(e); }
+        }
+        var abort = Util.find(S, ['session', 'realtime', 'abort']);
+        if (typeof(abort) === 'function') {
+            S.session.realtime.sync();
+            abort();
+        }
+    };
+
+    var makeNetwork = function (cb) {
+        var wsUrl = NetConfig.getWebsocketURL();
+        Netflux.connect(wsUrl).then(function (network) {
+            cb(null, network);
+        }, function (err) {
+            cb(err);
+        });
+    };
+
+    var start = function (Session, config) {
+        // Create a network and authenticate with all our keys if necessary,
+        // then start chainpad-netflux
+        nThen(function (waitFor) {
+            if (Session.hasNetwork) { return; }
+            makeNetwork(waitFor(function (err, network) {
+                if (err) { return; }
+                config.network = network;
+            }));
+        }).nThen(function () {
+            Session.realtime = CPNetflux.start(config);
+        });
+    };
+
+    var onRejected = function (config, Session, data, cb) {
+        // Check if we can authenticate
+        if (!Array.isArray(data) || !data.length || data[0].length !== 16) {
+            return void cb(true);
+        }
+        if (!Array.isArray(Session.accessKeys)) { return void cb(true); }
+
+        // Authenticate
+        config.network.historyKeeper = data[0];
+        nThen(function (waitFor) {
+            Session.accessKeys.forEach(function (obj) {
+                Pinpad.create(config.network, obj, waitFor(function (e) {
+                    console.log('done', obj);
+                    if (e) { console.error(e); }
+                }));
+            });
+        }).nThen(function () {
+            cb();
+        });
+    };
+
+    var makeConfig = function (hash, opt) {
+        var secret;
+        if (typeof(hash) === 'string') {
+        // We can't use cryptget with a file or a user so we can use 'pad' as hash type
+            secret = Hash.getSecrets('pad', hash, opt.password);
+        } else if (typeof(hash) === 'object') {
+            // we may want to just supply options directly
+            // and this is the easiest place to do it
+            secret = hash;
+        }
+        if (!secret.keys) { secret.keys = secret.key; } // support old hashses
+        var config = {
+            websocketURL: NetConfig.getWebsocketURL(opt.origin),
+            channel: secret.channel,
+            validateKey: secret.keys.validateKey || undefined,
+            crypto: Crypto.createEncryptor(secret.keys),
+            logLevel: 0,
+            initialState: opt.initialState,
+            Cache: Cache
+        };
+        return config;
+    };
+
+    var isObject = function (o) {
+        return typeof(o) === 'object';
+    };
+
+    var overwrite = function (a, b) {
+        if (!(isObject(a) && isObject(b))) { return; }
+        Object.keys(b).forEach(function (k) { a[k] = b[k]; });
+    };
+
+    var get = function (hash, cb, opt, progress) {
+        if (typeof(cb) !== 'function') {
+            throw new Error('Cryptget expects a callback');
+        }
+        opt = opt || {};
+        progress = progress || function () {};
+
+        var config = makeConfig(hash, opt);
+        var Session = {
+            cb: cb,
+            accessKeys: opt.accessKeys,
+            hasNetwork: Boolean(opt.network)
+        };
+
+        config.onRejected = function (data, cb) {
+            onRejected(config, Session, data, cb);
+        };
+
+        config.onReady = function (info) {
+            var rt = Session.session = info.realtime;
+            Session.network = info.network;
+            progress(1);
+            finish(Session, void 0, rt.getUserDoc());
+        };
+
+        config.onError = function (info) {
+            console.warn(info);
+            finish(Session, info);
+        };
+        config.onChannelError = function (info) {
+            console.error(info);
+            finish(Session, info);
+        };
+
+        config.onCacheReady = opt.onCacheReady;
+
+        // We use the new onMessage handler to compute the progress:
+        // we should receive 2 checkpoints max, so 100 messages max
+        // We're going to consider that 1 message = 1%, and we'll send 100%
+        // at the end
+        var i = 0;
+        config.onMessage = function () {
+            i++;
+            progress(Math.min(0.99, i/100));
+        };
+
+        overwrite(config, opt);
+
+        start(Session, config);
+    };
+
+    var put = function (hash, doc, cb, opt) {
+        if (typeof(cb) !== 'function') {
+            throw new Error('Cryptput expects a callback');
+        }
+        opt = opt || {};
+
+        var config = makeConfig(hash, opt);
+        var Session = {
+            cb: cb,
+            accessKeys: opt.accessKeys,
+            hasNetwork: Boolean(opt.network)
+        };
+
+        config.onRejected = function (data, cb) {
+            onRejected(config, Session, data, cb);
+        };
+
+        config.onReady = function (info) {
+            var realtime = Session.session = info.realtime;
+            Session.network = info.network;
+
+            realtime.contentUpdate(doc);
+
+            var to = setTimeout(function () {
+                cb(new Error("Timeout"));
+            }, 15000);
+
+            Realtime.whenRealtimeSyncs(realtime, function () {
+                clearTimeout(to);
+                var doc = realtime.getAuthDoc();
+                realtime.abort();
+                finish(Session, void 0, doc);
+            });
+        };
+
+        config.onChannelError = function (info) {
+            finish(Session, info);
+        };
+
+        overwrite(config, opt);
+
+        start(Session, config);
+    };
+
+    return {
+        get: get,
+        put: put,
+    };
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        require('chainpad-crypto'),
+        require('chainpad-netflux'),
+        require('netflux-websocket'),
+        require('./common-util'),
+        require('./common-hash'),
+        require('./common-realtime'),
+        require('./network-config'),
+        require('./cache-store'),
+        require('./pinpad'),
+        require('nthen'),
+        require('chainpad')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/components/chainpad-crypto/crypto.js',
+        'chainpad-netflux',
+        'netflux-client',
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/common-realtime.js',
+        '/common/outer/network-config.js',
+        '/common/outer/cache-store.js',
+        '/common/pinpad.js',
+        '/components/nthen/index.js',
+        '/components/chainpad/chainpad.dist.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+})();
+
diff --git a/src/common/http-command.js b/src/common/http-command.js
new file mode 100644
index 000000000..5f64de6d3
--- /dev/null
+++ b/src/common/http-command.js
@@ -0,0 +1,130 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (nThen, Util, ApiConfig = {}, Nacl) => {
+
+    const getApiOrigin = function () {
+        if (!Object.keys(ApiConfig).length) { return; }
+        var url;
+        var unsafeOriginURL = new URL(ApiConfig.httpUnsafeOrigin);
+        try {
+            url = new URL(ApiConfig.websocketPath, ApiConfig.httpUnsafeOrigin);
+            url.protocol = unsafeOriginURL.protocol;
+            return url.origin;
+        } catch (err) {
+            console.error(err);
+            return ApiConfig.httpUnsafeOrigin;
+        }
+    };
+    var API_ORIGIN = getApiOrigin();
+
+    const setCustomize = data => {
+        ApiConfig = data.ApiConfig;
+        API_ORIGIN = getApiOrigin();
+    };
+
+    var clone = o => JSON.parse(JSON.stringify(o));
+    var randomToken = () => Nacl.util.encodeBase64(Nacl.randomBytes(24));
+    var postData = function (url, data, cb) {
+        var CB = Util.once(Util.mkAsync(cb));
+        fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        }).then(response => {
+            if (response.ok) {
+
+                return void response.text().then(result => { CB(void 0, Util.tryParse(result)); }); // checkup error when using .json()
+                //return void response.json().then(result => { CB(void 0, result); });
+            }
+
+            response.json().then().then(result => {
+                CB(response.status, result);
+            });
+            //CB(response.status, response);
+        }).catch(error => {
+            CB(error);
+        });
+    };
+
+    var serverCommand = function (keypair, my_data, cb) {
+        var obj = clone(my_data);
+        obj.publicKey = Nacl.util.encodeBase64(keypair.publicKey);
+        obj.nonce = randomToken();
+        var href = new URL('/api/auth/', API_ORIGIN);
+        var txid, date;
+        nThen(function (w) {
+            // Tell the server we want to do some action
+            postData(href, obj, w((err, data) => {
+                if (err) {
+                    w.abort();
+                    console.error(err);
+                    // there might be more info here
+                    if (data) { console.error(data); }
+                    return void cb(err);
+                }
+
+                // if the requested action is valid, it responds with a txid and a nonce
+                // bundle all that up into an object, stringify it, and sign it.
+                // respond with an object: {sig, txid}
+                if (!data.date || !data.txid) {
+                    w.abort();
+                    return void cb('REQUEST_REJECTED');
+                }
+                txid = data.txid;
+                date = data.date;
+            }));
+        }).nThen(function (w) {
+            var copy = clone(obj);
+            copy.txid = txid;
+            copy.date = date;
+            var toSign = Nacl.util.decodeUTF8(JSON.stringify(copy));
+            var sig = Nacl.sign.detached(toSign, keypair.secretKey);
+            var encoded = Nacl.util.encodeBase64(sig);
+            var obj2 = {
+                sig: encoded,
+                txid: txid,
+            };
+            postData(href, obj2, w((err, data) => {
+                if (err) {
+                    w.abort();
+                    console.error(err);
+                    // there might be more info here
+                    if (data) { console.error(data); }
+                    return void cb("RESPONSE_REJECTED", data);
+                }
+                cb(void 0, data);
+            }));
+        });
+    };
+
+    serverCommand.setCustomize = setCustomize;
+
+    return serverCommand;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        require('nthen'),
+        require('./common-util'),
+        undefined,
+        require('tweetnacl/nacl-fast')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/components/nthen/index.js',
+        '/common/common-util.js',
+        '/api/config',
+        '/components/tweetnacl/nacl-fast.min.js',
+    ], (nThen, Util, ApiConfig) => {
+        factory(nThen, Util, ApiConfig, window.nacl);
+    });
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/login-block.js b/src/common/login-block.js
new file mode 100644
index 000000000..dff0efb14
--- /dev/null
+++ b/src/common/login-block.js
@@ -0,0 +1,245 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Util, ApiConfig = {}, ServerCommand, Nacl) => {
+
+    var Block = {};
+
+    Block.setCustomize = data => {
+        ApiConfig = data.ApiConfig;
+        ServerCommand.setCustomize(data);
+    };
+
+    Block.join = Util.uint8ArrayJoin;
+
+    // publickey <base64 string>
+
+    // signature <base64 string>
+
+    // block <base64 string>
+
+    // [b64_public, b64_sig, b64_block [version, nonce, content]]
+
+    Block.seed = function () {
+        return Nacl.hash(Nacl.util.decodeUTF8('pewpewpew'));
+    };
+
+    // should be deterministic from a seed...
+    Block.genkeys = function (seed) {
+        if (!(seed instanceof Uint8Array)) {
+            throw new Error('INVALID_SEED_FORMAT');
+        }
+        if (!seed || typeof(seed.length) !== 'number' || seed.length < 64) {
+            throw new Error('INVALID_SEED_LENGTH');
+        }
+
+        var signSeed = seed.subarray(0, Nacl.sign.seedLength);
+        var symmetric = seed.subarray(Nacl.sign.seedLength,
+            Nacl.sign.seedLength + Nacl.secretbox.keyLength);
+
+        return {
+            sign: Nacl.sign.keyPair.fromSeed(signSeed), // 32 bytes
+            symmetric: symmetric, // 32 bytes ...
+        };
+    };
+
+    Block.keysToRPCFormat = function (keys) {
+        try {
+            var sign = keys.sign;
+            return {
+                edPrivate: Nacl.util.encodeBase64(sign.secretKey),
+                edPublic: Nacl.util.encodeBase64(sign.publicKey),
+            };
+        } catch (err) {
+            console.error(err);
+            return;
+        }
+    };
+
+    // (UTF8 content, keys object) => Uint8Array block
+    Block.encrypt = function (version, content, keys) {
+        var u8 = Nacl.util.decodeUTF8(content);
+        var nonce = Nacl.randomBytes(Nacl.secretbox.nonceLength);
+        return Block.join([
+            [0],
+            nonce,
+            Nacl.secretbox(u8, nonce, keys.symmetric)
+        ]);
+    };
+
+    // (uint8Array block) => payload object
+    Block.decrypt = function (u8_content, keys) {
+        // version is currently ignored since there is only one
+        var nonce = u8_content.subarray(1, 1 + Nacl.secretbox.nonceLength);
+        var box = u8_content.subarray(1 + Nacl.secretbox.nonceLength);
+
+        var plaintext = Nacl.secretbox.open(box, nonce, keys.symmetric);
+        try {
+            return JSON.parse(Nacl.util.encodeUTF8(plaintext));
+        } catch (e) {
+            console.error(e);
+            return;
+        }
+    };
+
+    // (Uint8Array block) => signature
+    Block.sign = function (ciphertext, keys) {
+        return Nacl.sign.detached(Nacl.hash(ciphertext), keys.sign.secretKey);
+    };
+
+    Block.serialize = function (content, keys) {
+        // encrypt the content
+        var ciphertext = Block.encrypt(0, content, keys);
+
+        // generate a detached signature
+        var sig = Block.sign(ciphertext, keys);
+
+        // serialize {publickey, sig, ciphertext}
+        return {
+            publicKey: Nacl.util.encodeBase64(keys.sign.publicKey),
+            signature: Nacl.util.encodeBase64(sig),
+            ciphertext: Nacl.util.encodeBase64(ciphertext),
+        };
+    };
+
+    Block.proveAncestor = function (O /* oldBlockKeys, N, newBlockKeys */) {
+        var u8_pub = Util.find(O, ['sign', 'publicKey']);
+        var u8_secret = Util.find(O, ['sign', 'secretKey']);
+        try {
+        // sign your old publicKey with your old privateKey
+            var u8_sig = Nacl.sign.detached(u8_pub, u8_secret);
+        // return an array with the sig and the pubkey
+            return JSON.stringify([u8_pub, u8_sig].map(Nacl.util.encodeBase64));
+        } catch (err) {
+            return void console.error(err);
+        }
+    };
+
+    var urlSafeB64 = function (u8) {
+        return Nacl.util.encodeBase64(u8).replace(/\//g, '-');
+    };
+
+    Block.getBlockUrl = function (keys) {
+        var publicKey = urlSafeB64(keys.sign.publicKey);
+        // 'block/' here is hardcoded because it's hardcoded on the server
+        // if we want to make CryptPad work in server subfolders, we'll need
+        // to update this path derivation
+        return (ApiConfig.fileHost || ApiConfig.httpUnsafeOrigin || window.location.origin)
+            + '/block/' + publicKey.slice(0, 2) + '/' +  publicKey;
+    };
+
+    Block.getBlockHash = function (keys) {
+        var absolute = Block.getBlockUrl(keys);
+        var symmetric = urlSafeB64(keys.symmetric);
+        return absolute + '#' + symmetric;
+    };
+
+    var decodeSafeB64 = function (b64) {
+        try {
+            return Nacl.util.decodeBase64(b64.replace(/\-/g, '/'));
+        } catch (e) {
+            console.error(e);
+            return;
+        }
+    };
+
+    Block.parseBlockHash = function (hash) {
+        if (typeof(hash) !== 'string') { return; }
+        var parts = hash.split('#');
+        if (parts.length !== 2) { return; }
+
+        try {
+            return {
+                href: parts[0],
+                keys: {
+                    symmetric: decodeSafeB64(parts[1]),
+                }
+            };
+        } catch (e) {
+            console.error(e);
+            return;
+        }
+    };
+
+    Block.checkRights = function (data, _cb) {
+        const cb = Util.mkAsync(_cb);
+        const { blockKeys, auth } = data;
+
+        var command = 'MFA_CHECK';
+        if (auth && auth.type) { command = `${auth.type.toUpperCase()}_` + command; }
+
+        ServerCommand(blockKeys.sign, {
+            command: command,
+            auth: auth && auth.data
+        }, cb);
+    };
+    Block.writeLoginBlock = function (data, cb) {
+        const { content, blockKeys, oldBlockKeys, auth, pw, session, token, userData } = data;
+
+        var command = 'WRITE_BLOCK';
+        if (auth && auth.type) { command = `${auth.type.toUpperCase()}_` + command; }
+
+        var block = Block.serialize(JSON.stringify(content), blockKeys);
+        block.auth = auth && auth.data;
+        block.hasPassword = pw;
+        block.registrationProof = oldBlockKeys && Block.proveAncestor(oldBlockKeys);
+        if (token) { block.inviteToken = token; }
+        if (userData) { block.userData = userData; }
+
+        ServerCommand(blockKeys.sign, {
+            command: command,
+            content: block,
+            session: session // sso session
+        }, cb);
+    };
+    Block.removeLoginBlock = function (data, cb) {
+        const { reason, blockKeys, auth, edPublic } = data;
+
+        var command = 'REMOVE_BLOCK';
+        if (auth && auth.type) { command = `${auth.type.toUpperCase()}_` + command; }
+
+        ServerCommand(blockKeys.sign, {
+            command: command,
+            auth: auth && auth.data,
+            edPublic: edPublic,
+            reason: reason
+        }, cb);
+    };
+
+    Block.updateSSOBlock = function (data, cb) {
+        const { blockKeys, oldBlockKeys } = data;
+        var oldProof = oldBlockKeys && Block.proveAncestor(oldBlockKeys);
+
+        ServerCommand(blockKeys.sign, {
+            command: 'SSO_UPDATE_BLOCK',
+            ancestorProof: oldProof
+        }, cb);
+
+    };
+
+    return Block;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        require('./common-util'),
+        undefined,
+        require('./http-command'),
+        require('tweetnacl/nacl-fast')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-util.js',
+        '/api/config',
+        '/common/outer/http-command.js',
+        '/components/tweetnacl/nacl-fast.min.js',
+    ], (Util, ApiConfig, ServerCommand) => {
+        factory(Util, ApiConfig, ServerCommand, window.nacl);
+    });
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/network-config.js b/src/common/network-config.js
new file mode 100644
index 000000000..f74697170
--- /dev/null
+++ b/src/common/network-config.js
@@ -0,0 +1,42 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (ApiConfig = {}) => {
+    var Config = {};
+
+    Config.setCustomize = data => {
+        ApiConfig = data.ApiConfig;
+    };
+
+    Config.getWebsocketURL = function (origin) {
+        var path = ApiConfig.websocketPath || '/cryptpad_websocket';
+        if (/^ws{1,2}:\/\//.test(path)) { return path; }
+
+        var l = window.location;
+        if (origin && window && window.document) {
+            l = document.createElement("a");
+            l.href = origin;
+        }
+        var protocol = l.protocol.replace(/http/, 'ws');
+        var host = l.host;
+        var url = protocol + '//' + host + path;
+
+        return url;
+    };
+
+    return Config;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory();
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/api/config'
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/notify.js b/src/common/notify.js
new file mode 100644
index 000000000..35ff04d65
--- /dev/null
+++ b/src/common/notify.js
@@ -0,0 +1,201 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/* eslint compat/compat: "off" */
+
+(() => {
+const factory = (ApiConfig = {}) => {
+    let window = globalThis;
+    var Module = {};
+
+    ApiConfig.requireConf = ApiConfig.requireConf || {};
+
+    Module.setCustomize = data => {
+        ApiConfig = data.ApiConfig;
+    };
+
+    var apps = ['code', 'slide', 'pad', 'kanban', 'whiteboard', 'diagram', 'sheet', 'poll', 'teams', 'form', 'doc', 'presentation'];
+    var app = window.location && window.location.pathname.slice(1, -1); // remove "/" at the beginnin and the end
+    var suffix = apps.indexOf(app) !== -1 ? '-'+app : '';
+
+    var DEFAULT_MAIN = '/customize/favicon/main-favicon' + suffix + '.png?' + ApiConfig.requireConf.urlArgs;
+    var DEFAULT_ALT = '/customize/favicon/alt-favicon' + suffix + '.png?' + ApiConfig.requireConf.urlArgs;
+    var DEFAULT_MAIN_ICO = '/customize/favicon/main-favicon' + suffix + '.ico?' + ApiConfig.requireConf.urlArgs;
+    var DEFAULT_ALT_ICO = '/customize/favicon/alt-favicon' + suffix + '.ico?' + ApiConfig.requireConf.urlArgs;
+
+    var document = window.document;
+
+    var isSupported = Module.isSupported = function () {
+        return typeof(window.Notification) === 'function' && window.isSecureContext;
+    };
+
+    var hasPermission = Module.hasPermission = function () {
+        return Notification.permission === 'granted';
+    };
+
+    var getPermission = Module.getPermission = function (f) {
+        f = f || function () {};
+        // "Notification.requestPermission is not a function" on Firefox 68.11.0esr
+        if (!Notification || typeof(Notification.requestPermission) !== 'function') { return void f(false); }
+        Notification.requestPermission(function (permission) {
+            if (permission === "granted") { f(true); }
+            else { f(false); }
+        });
+    };
+
+    var create = Module.create = function (msg, title, icon) {
+        if (document && !icon) {
+            var favicon = document.getElementById('favicon');
+            icon = favicon.getAttribute('data-main-favicon') || DEFAULT_ALT;
+        } else if (!icon) {
+            icon = DEFAULT_ALT;
+        }
+
+        var n = new Notification(title,{
+            icon: icon,
+            body: msg,
+        });
+        n.onclick = function () {
+            if (!document) { return; }
+            try {
+                parent.focus();
+                window.focus(); //just in case, older browsers
+                this.close();
+            } catch (e) {}
+        };
+        return n;
+    };
+
+    Module.system = function (msg, title, icon) {
+        // Let's check if the browser supports notifications
+        if (!isSupported()) { return; /*console.log("Notifications are not supported");*/ }
+
+        // Let's check whether notification permissions have already been granted
+        else if (hasPermission()) {
+            // If it's okay let's create a notification
+            return create(msg, title, icon);
+        }
+
+        // Otherwise, we need to ask the user for permission
+        else if (Notification.permission !== 'denied') {
+            getPermission(function (state) {
+                if (state) { create(msg, title, icon); }
+            });
+        }
+    };
+
+    var createFavicon = function () {
+        if (!document) {
+            return void console.error('document is not available in this context');
+        }
+        console.debug("creating favicon");
+        var attrs = {
+            id: 'favicon',
+            type: 'image/png',
+            rel: 'icon',
+            'data-main-favicon': DEFAULT_MAIN,
+            'data-alt-favicon': DEFAULT_ALT,
+            href: DEFAULT_MAIN,
+        };
+        if(!document.getElementById("favicon")) {
+            var fav = document.createElement('link');
+            Object.keys(attrs).forEach(function (k) {
+                fav.setAttribute(k, attrs[k]);
+            });
+            document.head.appendChild(fav);
+        }
+
+        if(!document.getElementById("favicon-ico")) {
+            var faviconLink = document.createElement('link');
+            attrs.href = attrs.href.replace(/\.png/g, ".ico");
+            attrs.id = 'favicon-ico';
+            attrs.type = 'image/x-icon';
+
+            Object.keys(attrs).forEach(function (k) {
+                faviconLink.setAttribute(k, attrs[k]);
+            });
+
+            document.head.appendChild(faviconLink);
+        }
+    };
+
+    if (document && !document.getElementById('favicon')) { createFavicon(); }
+
+    Module.tab = function (frequency, count) {
+        if (!document) {
+            return void console.error('document is not available in this context');
+        }
+        var key = '_pendingTabNotification';
+
+        var favicon = document.getElementById('favicon');
+        var faviconIco = document.getElementById('favicon-ico');
+
+        var main = DEFAULT_MAIN;
+        var alt = DEFAULT_ALT;
+        var mainIco = DEFAULT_MAIN_ICO;
+        var altIco = DEFAULT_ALT_ICO;
+
+        if (favicon) {
+            main = favicon.getAttribute('data-main-favicon') || DEFAULT_MAIN;
+            alt = favicon.getAttribute('data-alt-favicon') || DEFAULT_ALT;
+            favicon.setAttribute('href', main);
+        }
+        if (faviconIco) {
+            mainIco = faviconIco.getAttribute('data-main-favicon') || DEFAULT_MAIN_ICO;
+            altIco = faviconIco.getAttribute('data-alt-favicon') || DEFAULT_ALT_ICO;
+            faviconIco.setAttribute('href', mainIco);
+        }
+
+        var cancel = function (pending) {
+            // only run one tab notification at a time
+            if (Module[key]) {
+                window.clearInterval(Module[key]);
+                if (favicon) {
+                    favicon.setAttribute('href', pending? alt : main);
+                }
+                if (faviconIco) {
+                    faviconIco.setAttribute('href', pending? altIco : mainIco);
+                }
+
+                return true;
+            }
+            return false;
+        };
+
+        cancel();
+
+        var step = function () {
+            if (favicon) {
+                favicon.setAttribute('href', favicon.getAttribute('href') === main? alt : main);
+            }
+            if (faviconIco) {
+                faviconIco.setAttribute('href', faviconIco.getAttribute('href') === mainIco? altIco : mainIco);
+            }
+            --count;
+        };
+
+        Module[key] = window.setInterval(function () {
+            if (count > 0) { return step(); }
+            cancel(true);
+
+        }, frequency);
+        step();
+
+        return {
+            cancel: cancel,
+        };
+    };
+
+    return Module;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(undefined);
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define(['/api/config'], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/onlyoffice/current-version.js b/src/common/onlyoffice/current-version.js
new file mode 100644
index 000000000..59c468850
--- /dev/null
+++ b/src/common/onlyoffice/current-version.js
@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = () => {
+    return {
+        currentVersion: 'v7'
+    };
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory();
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([], factory);
+}
+})();
diff --git a/src/common/pad-types.js b/src/common/pad-types.js
new file mode 100644
index 000000000..25837944f
--- /dev/null
+++ b/src/common/pad-types.js
@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (AppConfig = {}, ApiConfig = {},
+                    OOCurrentVersion) => {
+
+    let availablePadTypes = [];
+    const OO_APPS = ["sheet", "doc", "presentation"];
+
+    const setCustomize = data => {
+        AppConfig = data.AppConfig;
+        ApiConfig = data.ApiConfig;
+
+        const ooEnabled = ApiConfig.onlyOffice &&
+                ApiConfig.onlyOffice.availableVersions.includes(
+            OOCurrentVersion.currentVersion
+        );
+        availablePadTypes = AppConfig.availablePadTypes.filter(
+            (t) => ooEnabled || !OO_APPS.includes(t)
+        );
+    };
+
+
+    const Types = { setCustomize };
+
+    Types.__defineGetter__("availableTypes", function () {
+        if (ApiConfig.appsToDisable) {
+            return availablePadTypes.filter(value => {
+                return !ApiConfig.appsToDisable.includes(value);
+            });
+        }
+        return availablePadTypes;
+    });
+    Types.__defineGetter__("appsToSelect", function () {
+        return availablePadTypes.filter(value => !['drive', 'teams', 'file', 'contacts', 'convert'].includes(value));
+    });
+    Types.isAvailable = type => {
+        return Array.isArray(Types.availableTypes) &&
+                Types.availableTypes.includes(type);
+    };
+
+    return Types;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        undefined,
+        undefined,
+        require('./onlyoffice/current-version')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/customize/application_config.js',
+        "/api/config",
+        "/common/onlyoffice/current-version.js",
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/pinpad.js b/src/common/pinpad.js
new file mode 100644
index 000000000..c7b6f74e2
--- /dev/null
+++ b/src/common/pinpad.js
@@ -0,0 +1,235 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(function () {
+var factory = function (Util, Rpc) {
+    var create = function (network, proxy, _cb, Cache) {
+        if (typeof(_cb) !== 'function') { throw new Error("Expected callback"); }
+        var cb = Util.once(Util.mkAsync(_cb));
+
+        if (!network) { return void cb('INVALID_NETWORK'); }
+        if (!proxy) { return void cb('INVALID_PROXY'); }
+
+        var edPrivate = proxy.edPrivate;
+        var edPublic = proxy.edPublic;
+
+        if (!(edPrivate && edPublic)) { return void cb('INVALID_KEYS'); }
+
+        Rpc.create(network, edPrivate, edPublic, function (e, rpc) {
+            if (e) { return void cb(e); }
+
+            var exp = {};
+
+            exp.destroy = rpc.destroy;
+
+            // expose the supplied publicKey as an identifier
+            exp.publicKey = edPublic;
+
+            // expose the RPC module's raw 'send' command
+            exp.send = rpc.send;
+
+            // you can ask the server to pin a particular channel for you
+            exp.pin = function (channels, _cb) {
+                var cb = Util.once(Util.mkAsync(_cb));
+                if (!Array.isArray(channels)) {
+                    return void cb('[TypeError] pin expects an array');
+                }
+                rpc.send('PIN', channels, cb);
+            };
+
+            // you can also ask to unpin a particular channel
+            exp.unpin = function (channels, _cb) {
+                var cb = Util.once(Util.mkAsync(_cb));
+                if (!Array.isArray(channels)) {
+                    return void cb('[TypeError] pin expects an array');
+                }
+                rpc.send('UNPIN', channels, cb);
+            };
+
+            // Get data for the admin panel
+            exp.adminRpc = function (obj, cb) {
+                if (!obj.cmd) {
+                    setTimeout(function () {
+                        cb('[TypeError] admin rpc expects a command');
+                    });
+                    return;
+                }
+                var params = [obj.cmd, obj.data];
+                rpc.send('ADMIN', params, cb);
+            };
+
+            // ask the server what it thinks your hash is
+            exp.getServerHash = function (cb) {
+                rpc.send('GET_HASH', edPublic, function (e, hash) {
+                    if (!(hash && hash[0])) {
+                        return void cb('NO_HASH_RETURNED');
+                    }
+                    cb(e, Array.isArray(hash) && hash[0] || undefined);
+                });
+            };
+
+            // if local and remote hashes don't match, send a reset
+            exp.reset = function (channels, _cb) {
+                var cb = Util.once(Util.mkAsync(_cb));
+                if (!Array.isArray(channels)) {
+                    return void cb('[TypeError] pin expects an array');
+                }
+                rpc.send('RESET', channels, cb);
+            };
+
+            // get the combined size of all channels (in bytes) for all the
+            // channels which the server has pinned for your publicKey
+            exp.getFileListSize = function (cb) {
+                rpc.send('GET_TOTAL_SIZE', undefined, function (e, response) {
+                    if (e) { return void cb(e); }
+                    if (response && response.length && typeof(response[0]) === 'number') {
+                        cb(void 0, response[0]);
+                    } else {
+                        cb('INVALID_RESPONSE');
+                    }
+                });
+            };
+
+            // Update the limit value for all the users and return the limit for your publicKey
+            exp.updatePinLimits = function (cb) {
+                rpc.send('UPDATE_LIMITS', undefined, function (e, response) {
+                    if (e) { return void cb(e); }
+                    if (response && response.length && typeof(response[0]) === "number") {
+                        cb (void 0, response[0], response[1], response[2]);
+                    } else {
+                        cb('INVALID_RESPONSE');
+                    }
+                });
+            };
+            // Get the storage limit associated with your publicKey
+            exp.getLimit = function (cb) {
+                rpc.send('GET_LIMIT', undefined, function (e, response) {
+                    if (e) { return void cb(e); }
+                    if (response && response.length && typeof(response[0]) === "number") {
+                        cb (void 0, response[0], response[1], response[2]);
+                    } else {
+                        cb('INVALID_RESPONSE');
+                    }
+                });
+            };
+
+            exp.trimHistory = function (data, _cb) {
+                var cb = Util.once(Util.mkAsync(_cb));
+                if (typeof(data) !== 'object' || !data.channel || !data.hash) {
+                    return void cb('INVALID_ARGUMENTS');
+                }
+                rpc.send('TRIM_HISTORY', data, function (e) {
+                    if (e) { return cb(e); }
+                    cb();
+                });
+            };
+
+            exp.clearOwnedChannel = function (channel, cb) {
+                if (typeof(channel) !== 'string' || channel.length !== 32) {
+                    return void cb('INVALID_ARGUMENTS');
+                }
+                rpc.send('CLEAR_OWNED_CHANNEL', channel, function (e) {
+                    if (e) { return cb(e); }
+                    cb();
+                });
+            };
+
+            exp.removeOwnedChannel = function (channel, cb, reason) {
+                if (typeof(channel) !== 'string' || [32,48].indexOf(channel.length) === -1) {
+                    console.error('invalid channel to remove', channel);
+                    return void cb('INVALID_ARGUMENTS');
+                }
+                rpc.send('REMOVE_OWNED_CHANNEL', {
+                    channel: channel,
+                    reason: reason
+                }, function (e, response) {
+                    if (e) { return void cb(e); }
+                    if (response && response.length && response[0] === "OK") {
+                        cb();
+                        if (Cache && Cache.clearChannel) {
+                            Cache.clearChannel(channel);
+                        }
+                    } else {
+                        cb('INVALID_RESPONSE');
+                    }
+                });
+            };
+
+            exp.removePins = function (cb) {
+                rpc.send('REMOVE_PINS', undefined, function (e, response) {
+                    if (e) { return void cb(e); }
+                    if (response && response.length && response[0] === "OK") {
+                        cb();
+                    } else {
+                        cb('INVALID_RESPONSE');
+                    }
+                });
+            };
+
+            exp.uploadComplete = function (id, cb) {
+                rpc.send('UPLOAD_COMPLETE', id, function (e, res) {
+                    if (e) { return void cb(e); }
+                    var id = res[0];
+                    if (typeof(id) !== 'string') {
+                        return void cb('INVALID_ID');
+                    }
+                    cb(void 0, id);
+                });
+            };
+
+            exp.ownedUploadComplete = function (id, cb) {
+                rpc.send('OWNED_UPLOAD_COMPLETE', id, function (e, res) {
+                    if (e) { return void cb(e); }
+                    var id = res[0];
+                    if (typeof(id) !== 'string') {
+                        return void cb('INVALID_ID');
+                    }
+                    cb(void 0, id);
+                });
+            };
+
+            exp.uploadStatus = function (size, cb) {
+                if (typeof(size) !== 'number') {
+                    return void setTimeout(function () {
+                        cb('INVALID_SIZE');
+                    });
+                }
+                rpc.send('UPLOAD_STATUS', size, function (e, res) {
+                    if (e) { return void cb(e); }
+                    var pending = res[0];
+                    if (typeof(pending) !== 'boolean') {
+                        return void cb('INVALID_RESPONSE');
+                    }
+                    cb(void 0, pending);
+                });
+            };
+
+            exp.uploadCancel = function (size, cb) {
+                rpc.send('UPLOAD_CANCEL', size, function (e) {
+                    if (e) { return void cb(e); }
+                    cb();
+                });
+            };
+
+            // Get data for the admin panel
+            exp.setMetadata = function (obj, cb) {
+                rpc.send('SET_METADATA', {
+                    channel: obj.channel,
+                    command: obj.command,
+                    value: obj.value
+                }, cb);
+            };
+
+            cb(e, exp);
+        });
+    };
+
+    return { create: create };
+};
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = factory(require('./common-util'), require("./rpc"));
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        define([ '/common/common-util.js', '/common/rpc.js', ], function (Util, Rpc) { return factory(Util, Rpc); });
+    }
+}());
diff --git a/src/common/proxy-manager.js b/src/common/proxy-manager.js
new file mode 100644
index 000000000..fee14db0d
--- /dev/null
+++ b/src/common/proxy-manager.js
@@ -0,0 +1,1813 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (UserObject, Util, Hash,
+                SF, Messages = {}, Feedback, nThen) => {
+
+    let setCustomize = data => {
+        Messages = data.Messages;
+        UserObject.setCustomize(data);
+    };
+
+    var getConfig = function (Env) {
+        var cfg = {};
+        for (var k in Env.cfg) { cfg[k] = Env.cfg[k]; }
+        return cfg;
+    };
+
+    // Add a shared folder to the list
+    var addProxy = function (Env, id, lm, leave, editKey, force) {
+        if (Env.folders[id] && !force && !Env.folders[id].restricted) {
+            // Shared folder already added to the proxy-manager, probably
+            // a cached version
+            if (Env.folders[id].offline && !lm.cache) {
+                Env.folders[id].offline = false;
+                if (Env.folders[id].userObject.fixFiles) { Env.folders[id].userObject.fixFiles(); }
+                Env.Store.refreshDriveUI();
+            }
+            return;
+        }
+        var cfg = getConfig(Env);
+        cfg.sharedFolder = true;
+        cfg.id = id;
+        cfg.editKey = editKey;
+        cfg.rt = lm.realtime;
+        cfg.readOnly = Boolean(!editKey);
+        var userObject = UserObject.init(lm.proxy, cfg);
+        if (userObject.fixFiles) {
+            // Only in outer
+            userObject.fixFiles();
+        }
+        var proxy = lm.proxy;
+        if (proxy.metadata && proxy.metadata.title) {
+            var sf = Env.user.proxy[UserObject.SHARED_FOLDERS][id];
+            if (sf) {
+                sf.lastTitle = proxy.metadata.title;
+            }
+        }
+        Env.folders[id] = {
+            proxy: lm.proxy,
+            userObject: userObject,
+            leave: leave,
+            restricted: proxy.restricted,
+            offline: Boolean(lm.cache)
+        };
+        if (proxy.on) {
+            proxy.on('disconnect', function () {
+                Env.folders[id].offline = true;
+            });
+            proxy.on('reconnect', function () {
+                Env.folders[id].offline = false;
+            });
+        }
+        return userObject;
+    };
+
+    var removeProxy = function (Env, id) {
+        var f = Env.folders[id];
+        if (!f) { return; }
+        f.leave();
+        delete Env.folders[id];
+    };
+
+    var sendNotification = (Env, sfId, title) => {
+        var mailbox = Env.store.mailbox;
+        if (!mailbox) { return; }
+        var team = Env.cfg.teamId;
+        var box;
+        if (team) {
+            let teams = Env.store.modules['team'].getTeamsData();
+            box = teams[team];
+        } else {
+            let md = Env.Store.getMetadata(null, null, () => {});
+            box = md.user;
+        }
+        mailbox.sendTo('SF_DELETED', {
+            sfId: sfId,
+            team: team,
+            title: title
+        }, {
+            curvePublic: box.curvePublic,
+            channel: box.notifications
+        }, (err) => {
+                console.error(err);
+        });
+    };
+
+    // Password may have changed
+    var deprecateProxy = function (Env, id, channel, reason) {
+        if (Env.folders[id] && Env.folders[id].deleting) {
+            // Folder is being deleted by its owner, don't deprecate it
+            return;
+        }
+        if (Env.user.userObject.readOnly) {
+            // In a read-only team, we can't deprecate a shared folder
+            // Use a empty object with a deprecated flag...
+            var lm = { proxy: { deprecated: true } };
+            removeProxy(Env, id);
+            addProxy(Env, id, lm, function () {});
+            return void Env.Store.refreshDriveUI();
+        }
+        if (channel) { Env.unpinPads([channel], function () {}); }
+
+        // If it's explicitely a deletion, no need to deprecate, just delete
+        if (reason && reason !== "PASSWORD_CHANGE") {
+            let temp = Util.find(Env, ['user', 'proxy', UserObject.SHARED_FOLDERS]);
+            let title = temp[id] && temp[id].lastTitle;
+            if (title) { sendNotification(Env, id, title); }
+
+            delete temp[id];
+
+            if (Env.Store && Env.Store.refreshDriveUI) { Env.Store.refreshDriveUI(); }
+            return;
+        }
+
+        // It's explicitely a password change, better message in drive: provide the "reason" to the UI
+        Env.user.userObject.deprecateSharedFolder(id, reason);
+        removeProxy(Env, id);
+        if (Env.Store && Env.Store.refreshDriveUI) { Env.Store.refreshDriveUI(); }
+    };
+
+    var restrictedProxy = function (Env, id) {
+        var lm = { proxy: { restricted: true, root: {}, filesData: {} } };
+        removeProxy(Env, id);
+        addProxy(Env, id, lm, function () {});
+        return void Env.Store.refreshDriveUI();
+    };
+
+    /*
+        Tools
+    */
+    var _ownedByMe = function (Env, owners) {
+        return Array.isArray(owners) && owners.indexOf(Env.edPublic) !== -1;
+    };
+    var _ownedByOther = function (Env, owners) {
+        return Array.isArray(owners) && owners.length &&
+                (!Env.edPublic || owners.indexOf(Env.edPublic) === -1);
+    };
+
+    var _getUserObjects = function (Env) {
+        var userObjects = [Env.user.userObject];
+        var foldersUO = Object.keys(Env.folders).map(function (k) {
+            return Env.folders[k].userObject;
+        });
+        Array.prototype.push.apply(userObjects, foldersUO);
+        return userObjects;
+    };
+
+    var _getUserObjectFromId = function (Env, id) {
+        var userObjects = _getUserObjects(Env);
+        var userObject = Env.user.userObject;
+        userObjects.some(function (uo) {
+            if (Object.keys(uo.getFileData(id)).length) {
+                userObject = uo;
+                return true;
+            }
+        });
+        return userObject;
+    };
+
+    var _getUserObjectPath = function (Env, uo) {
+        var fId = Number(uo.id);
+        if (!fId) { return; }
+        var fPath = Env.user.userObject.findFile(fId)[0];
+        return fPath;
+    };
+
+    // Return files data objects associated to a channel for setPadTitle
+    // All occurences are returned, in drive or shared folders
+    // If "editable" is true, the data returned is a proxy, otherwise
+    // it's a cloned object (NOTE: href should never be edited directly)
+    var findChannel = function (Env, channel, editable) {
+        var ret = [];
+        Env.user.userObject.findChannels([channel], true).forEach(function (id) {
+            // Check in shared folders, then clone if needed
+            var data = Env.user.proxy[UserObject.SHARED_FOLDERS][id];
+            if (data && !editable) { data = JSON.parse(JSON.stringify(data)); }
+            // If it's not a shared folder, check the pads
+            if (!data) { data = Env.user.userObject.getFileData(id, editable); }
+            ret.push({
+                id: id,
+                data: data,
+                userObject: Env.user.userObject
+            });
+        });
+        Object.keys(Env.folders).forEach(function (fId) {
+            Env.folders[fId].userObject.findChannels([channel]).forEach(function (id) {
+                ret.push({
+                    id: id,
+                    fId: fId,
+                    data: Env.folders[fId].userObject.getFileData(id, editable),
+                    userObject: Env.folders[fId].userObject
+                });
+            });
+        });
+        return ret;
+    };
+    // Return files data objects associated to a given href for setPadAttribute...
+    // If "editable" is true, the data returned is a proxy, otherwise
+    // it's a cloned object (NOTE: href should never be edited directly)
+    var findHref = function (Env, href) {
+        var ret = [];
+        var id = Env.user.userObject.getIdFromHref(href);
+        if (id) {
+            ret.push({
+                data: Env.user.userObject.getFileData(id),
+                userObject: Env.user.userObject
+            });
+        }
+        Object.keys(Env.folders).forEach(function (fId) {
+            var id = Env.folders[fId].userObject.getIdFromHref(href);
+            if (!id) { return; }
+            ret.push({
+                fId: fId,
+                data: Env.folders[fId].userObject.getFileData(id),
+                userObject: Env.folders[fId].userObject
+            });
+        });
+        return ret;
+    };
+    // Return paths linked to a file ID
+    var findFile = function (Env, id) {
+        var ret = [];
+        var userObjects = _getUserObjects(Env);
+        userObjects.forEach(function (uo) {
+            var fPath = _getUserObjectPath(Env, uo);
+            var results = uo.findFile(id);
+            if (fPath) {
+                // This is a shared folder, we have to fix the paths in the results
+                results.forEach(function (p) {
+                    Array.prototype.unshift.apply(p, fPath);
+                });
+            }
+            // Push the results from this proxy
+            Array.prototype.push.apply(ret, results);
+        });
+        return ret;
+    };
+
+    // Returns file IDs corresponding to the provided channels
+    var _findChannels = function (Env, channels, onlyMain) {
+        if (onlyMain) {
+            return Env.user.userObject.findChannels(channels);
+        }
+        var ret = [];
+        var userObjects = _getUserObjects(Env);
+        userObjects.forEach(function (uo) {
+            var results = uo.findChannels(channels);
+            Array.prototype.push.apply(ret, results);
+        });
+        ret = Util.deduplicateString(ret);
+        return ret;
+    };
+
+    var _getFileData = function (Env, id, editable) {
+        var userObjects = _getUserObjects(Env);
+        var data = {};
+        userObjects.some(function (uo) {
+            data = uo.getFileData(id, editable);
+            if (data && Object.keys(data).length) { return true; }
+        });
+        return data;
+    };
+
+    var getSharedFolderData = function (Env, id) {
+        var inHistory;
+        if (Env.isHistoryMode && !Env.folders[id]) { inHistory = true; }
+        else if (!Env.folders[id]) { return {}; }
+        var proxy = inHistory? {}: Env.folders[id].proxy;
+
+        // Clean deprecated values
+        if (Object.keys(proxy.metadata || {}).length > 1) {
+            proxy.metadata = { title: proxy.metadata.title };
+        }
+
+        var obj = Util.clone(proxy.metadata || {});
+
+        for (var k in Env.user.proxy[UserObject.SHARED_FOLDERS][id] || {}) {
+            if (typeof(Env.user.proxy[UserObject.SHARED_FOLDERS][id][k]) === "undefined") { // TODO "deleted folder" for restricted shared folders when viewer in a team
+                continue;
+            }
+            var data = Util.clone(Env.user.proxy[UserObject.SHARED_FOLDERS][id][k]);
+            if (k === "href" && data.indexOf('#') === -1) {
+                try {
+                    data = Env.user.userObject.cryptor.decrypt(data);
+                } catch (e) {}
+            }
+            if (k === "href" && data.indexOf('#') === -1) { data = undefined; }
+            obj[k] = data;
+        }
+        return obj;
+    };
+
+
+    // Transform an absolute path into a path relative to the correct shared folder
+    var _resolvePath = function (Env, path) {
+        var res = {
+            id: null,
+            userObject: Env.user.userObject,
+            path: path
+        };
+        if (!Array.isArray(path) || path.length <= 1) {
+            return res;
+        }
+        var current;
+        var uo = Env.user.userObject;
+        // We don't need to check the last element of the path because we only need to split it
+        // when the path contains an element inside the shared folder
+        for (var i=2; i<path.length; i++) {
+            current = uo.find(path.slice(0,i));
+            if (uo.isSharedFolder(current)) {
+                res = {
+                    id: current,
+                    userObject: Env.folders[current].userObject,
+                    path: path.slice(i)
+                };
+                break;
+            }
+        }
+        return res;
+    };
+    var _resolvePaths = function (Env, paths) {
+        var main = [];
+        var folders = {};
+        paths.forEach(function (path) {
+            var r = _resolvePath(Env, path);
+            if (r.id) {
+                if (!folders[r.id]) {
+                    folders[r.id] = [r.path];
+                } else {
+                    folders[r.id].push(r.path);
+                }
+            } else {
+                main.push(r.path);
+            }
+        });
+        return {
+            main: main,
+            folders: folders
+        };
+    };
+
+    // Check if a given path is resolved to a shared folder or to the main drive
+    var _isInSharedFolder = function (Env, path) {
+        var resolved = _resolvePath(Env, path);
+        return typeof resolved.id === "number" ? resolved.id : false;
+    };
+
+    // Get the owned files in the main drive that are also duplicated in shared folders
+    var _isDuplicateOwned = function (Env, path, id) {
+        if (path && _isInSharedFolder(Env, path)) { return; }
+        var data = _getFileData(Env, id || Env.user.userObject.find(path));
+        if (!data) { return; }
+        if (!_ownedByMe(Env, data.owners)) { return; }
+        var channel = data.channel;
+        if (!channel) { return; }
+        var foldersUO = Object.keys(Env.folders).map(function (k) {
+            return Env.folders[k].userObject;
+        });
+        return foldersUO.some(function (uo) {
+            return uo.findChannels([channel]).length;
+        });
+    };
+
+    // Get a copy of the elements located in the given paths, with their files data
+    // Note: This function is only called to move files from a proxy to another
+    var _getCopyFromPaths = function (Env, paths, userObject) {
+        var data = [];
+        var toNotRemove = [];
+        paths.forEach(function (path, idx) {
+            var el = userObject.find(path);
+            var files = [];
+            var key = path[path.length - 1];
+
+            // Get the files ID from the current path (file or folder)
+            if (userObject.isFile(el)) {
+                files.push(el);
+            } else if (userObject.isSharedFolder(el)) {
+                files.push(el);
+                var obj = Env.folders[el].proxy.metadata || {};
+                if (obj) { key = obj.title; }
+            } else {
+                try {
+                    el = JSON.parse(JSON.stringify(el));
+                } catch (e) { return undefined; }
+                userObject.getFilesRecursively(el, files);
+            }
+
+            // If the element is a folder and it contains a shared folder, abort!
+            // We don't want nested shared folders!
+            if (files.some(function (f) { return userObject.isSharedFolder(f); })) {
+                if (Env.cfg && Env.cfg.log) {
+                    Env.cfg.log(Messages._getKey('fm_moveNestedSF', [key]));
+                }
+                toNotRemove.unshift(idx);
+                return;
+            }
+
+            // Deduplicate
+            files = Util.deduplicateString(files);
+
+            // Get the files data associated to these files
+            var filesData = {};
+            files.forEach(function (f) {
+                filesData[f] = userObject.getFileData(f);
+            });
+
+            data.push({
+                el: el,
+                data: filesData,
+                key: key
+            });
+        });
+
+        // Remove from the "paths" array the elements that we don't want to move
+        toNotRemove.forEach(function (idx) {
+            paths.splice(idx, 1);
+        });
+
+        return data;
+    };
+
+    var getEditHash = function (Env, channel) {
+        var res = findChannel(Env, channel);
+        var stronger;
+        res.some(function (obj) {
+            if (!obj || !obj.data || !obj.data.href) { return; }
+            var parsed = Hash.parsePadUrl(obj.data.href);
+            var parsedHash = parsed.hashData;
+            if (!parsedHash || parsedHash.mode === 'view') { return; }
+            // We've found an edit hash!
+            stronger = parsed.hash;
+            return true;
+        });
+        return stronger;
+    };
+
+    /*
+        Drive RPC
+    */
+
+    // Move files or folders in the drive
+    var _move = function (Env, data, cb) {
+        var resolved = _resolvePaths(Env, data.paths);
+        var newResolved = _resolvePath(Env, data.newPath);
+
+        // NOTE: we can only copy when moving from one drive to another. We don't want
+        // duplicates in the same drive
+        var copy = data.copy;
+
+        if (!newResolved.userObject.isFolder(newResolved.path)) { return void cb(); }
+
+        nThen(function (waitFor) {
+            if (resolved.main.length) {
+                // Move from the main drive
+                if (!newResolved.id) {
+                    // Move from the main drive to the main drive
+                    Env.user.userObject.move(resolved.main, newResolved.path, waitFor());
+                } else {
+                    // Move from the main drive to a shared folder
+
+                    // Copy the elements to the new location
+                    var toCopy = _getCopyFromPaths(Env, resolved.main, Env.user.userObject);
+                    var newUserObject = newResolved.userObject;
+                    toCopy.forEach(function (obj) {
+                        newUserObject.copyFromOtherDrive(newResolved.path, obj.el, obj.data, obj.key);
+                    });
+
+                    if (copy) { return; }
+
+                    if (resolved.main.length) {
+                        // Remove the elements from the old location (without unpinning)
+                        Env.user.userObject.delete(resolved.main, waitFor()); // FIXME waitFor() is called synchronously
+                    }
+                }
+            }
+            var folderIds = Object.keys(resolved.folders);
+            if (folderIds.length) {
+                // Move from a shared folder
+                folderIds.forEach(function (fIdStr) {
+                    var fId = Number(fIdStr);
+                    var paths = resolved.folders[fId];
+                    if (newResolved.id === fId) {
+                        // Move to the same shared folder
+                        newResolved.userObject.move(paths, newResolved.path, waitFor());
+                    } else {
+                        // Move to a different shared folder or to main drive
+                        var uoFrom = Env.folders[fId].userObject;
+                        var uoTo = newResolved.userObject;
+
+                        // Copy the elements to the new location
+                        var toCopy = _getCopyFromPaths(Env, paths, uoFrom);
+                        toCopy.forEach(function (obj) {
+                            uoTo.copyFromOtherDrive(newResolved.path, obj.el, obj.data, obj.key);
+                        });
+
+                        if (copy) { return; }
+
+                        // Remove the elements from the old location (without unpinning)
+                        uoFrom.delete(paths, waitFor()); // FIXME waitFor() is called synchronously
+                    }
+                });
+            }
+        }).nThen(function () {
+            cb();
+        });
+    };
+    // Restore from the trash (main drive only)
+    var _restore = function (Env, data, cb) {
+        var userObject = Env.user.userObject;
+        data = data || {};
+        userObject.restore(data.path, cb);
+    };
+    // Add a folder/subfolder
+    var _addFolder = function (Env, data, cb) {
+        data = data || {};
+        var resolved = _resolvePath(Env, data.path);
+        if (!resolved || !resolved.userObject) { return void cb({error: 'E_NOTFOUND'}); }
+        resolved.userObject.addFolder(resolved.path, data.name, function (obj) {
+            // The result is the relative path of the new folder. We have to make it absolute.
+            if (obj.newPath && resolved.id) {
+                var fPath = _getUserObjectPath(Env, resolved.userObject);
+                if (fPath) {
+                    // This is a shared folder, we have to fix the paths in the search results
+                    Array.prototype.unshift.apply(obj.newPath, fPath);
+                }
+            }
+            cb(obj);
+        });
+    };
+    // Add a shared folder
+    var _addSharedFolder = function (Env, data, cb) {
+        data = data || {};
+        var resolved = _resolvePath(Env, data.path);
+        if (!resolved || !resolved.userObject) { return void cb({error: 'E_NOTFOUND'}); }
+        if (resolved.id) { return void cb({error: 'EINVAL'}); }
+        if (!Env.pinPads) { return void cb({error: 'EAUTH'}); }
+
+        var folderData = data.folderData || {};
+
+        var id;
+        nThen(function () {
+            // Check if it is an imported folder or a folder creation
+            if (data.folderData) { return; }
+
+            // Folder creation
+            var hash = Hash.createRandomHash('drive', data.password);
+            var secret = Hash.getSecrets('drive', hash, data.password);
+            var hashes = Hash.getHashes(secret);
+            folderData = {
+                href: '/drive/#' + hashes.editHash,
+                roHref: '/drive/#' + hashes.viewHash,
+                channel: secret.channel,
+                lastTitle: data.name,
+                ctime: +new Date(),
+            };
+            if (data.password) { folderData.password = data.password; }
+            if (data.owned) { folderData.owners = [Env.edPublic]; }
+        }).nThen(function (waitFor) {
+            Env.Store.getPadMetadata(null, {
+                channel: folderData.channel
+            }, waitFor(function (obj) {
+                if (obj && (obj.error || obj.rejected)) {
+                    waitFor.abort();
+                    return void cb({
+                        error: obj.error || 'ERESTRICTED'
+                    });
+                }
+            }));
+        }).nThen(function (waitFor) {
+            Env.pinPads([folderData.channel], waitFor());
+        }).nThen(function (waitFor) {
+            // 1. add the shared folder to our list of shared folders
+            // NOTE: pushSharedFolder will encrypt the href directly in the object if needed
+            Env.user.userObject.pushSharedFolder(folderData, waitFor(function (err, folderId) {
+                if (err === "EEXISTS" && folderData.href && folderId) { // Check upgrade
+                    var parsed = Hash.parsePadUrl(folderData.href);
+                    var secret = Hash.getSecrets('drive', parsed.hash, folderData.password);
+                    SF.upgrade(secret.channel, secret);
+                    Env.folders[folderId].userObject.setReadOnly(false, secret.keys.secondaryKey);
+                    waitFor.abort();
+                    return void cb(folderId);
+                }
+                if (err === "EEXISTS" && folderId) { // Exists but no upgrade, return folderId
+                    waitFor.abort();
+                    return void cb(folderId);
+                }
+                if (err) {
+                    waitFor.abort();
+                    return void cb(err);
+                }
+                id = folderId;
+            }));
+        }).nThen(function (waitFor) {
+            // 2a. add the shared folder to the path in our drive
+            Env.user.userObject.add(id, resolved.path);
+
+            // 2b. load the proxy
+            Env.loadSharedFolder(id, folderData, waitFor(function (rt) {
+                if (!rt) {
+                    waitFor.abort();
+                    return void cb({ error: 'EDELETED' });
+                }
+
+                if (!rt.proxy.metadata) { // Creating a new shared folder
+                    rt.proxy.metadata = { title: data.name || Messages.fm_newFolder };
+                }
+                if (data.folderData) {
+                    // If we're importing a folder, check its serverside metadata
+                    Env.Store.getPadMetadata(null, { channel: folderData.channel }, function (md) {
+                        var fData = Env.user.proxy[UserObject.SHARED_FOLDERS][id];
+                        if (md.owners) { fData.owners = md.owners; }
+                        if (md.expire) { fData.expire = +md.expire; }
+                    });
+                }
+            }), !Boolean(data.folderData));
+        }).nThen(function () {
+            Env.onSync(function () {
+                cb(id);
+            });
+        });
+    };
+    // Add a link
+    var _addLink = function (Env, data, cb) {
+        data = data || {};
+        var resolved = _resolvePath(Env, data.path);
+        if (!resolved || !resolved.userObject) { return void cb({error: 'E_NOTFOUND'}); }
+        var uo = resolved.userObject;
+        var now = +new Date();
+        uo.pushLink({
+            name: data.name,
+            href: data.href,
+            atime: now,
+            ctime: now
+        }, function (e, id) {
+            if (e) { return void cb({error: e}); }
+            uo.add(id, resolved.path);
+            Env.onSync(cb);
+        });
+    };
+
+    var _restoreSharedFolder = function (Env, _data, cb) {
+        var fId = _data.id;
+        var newPassword = _data.password;
+        var temp = Util.find(Env, ['user', 'proxy', UserObject.SHARED_FOLDERS_TEMP]);
+        var data = temp && temp[fId];
+        if (!data) { return void cb({ error: 'EINVAL' }); }
+        if (!Env.Store) { return void cb({ error: 'ESTORE' }); }
+        var href = Env.user.userObject.getHref ? Env.user.userObject.getHref(data) : data.href;
+        var isNew = false;
+        nThen(function (waitFor) {
+            Env.Store.isNewChannel(null, {
+                href: href,
+                password: newPassword
+            }, waitFor(function (obj) {
+                if (!obj || obj.error) {
+                    isNew = false;
+                    return;
+                }
+                isNew = obj.isNew;
+            }));
+        }).nThen(function () {
+            if (isNew) {
+                return void cb({ error: 'ENOTFOUND' });
+            }
+            var newData = Util.clone(data);
+            var parsed = Hash.parsePadUrl(href);
+            var secret = Hash.getSecrets(parsed.type, parsed.hash, newPassword);
+            newData.password = newPassword;
+            newData.channel = secret.channel;
+            if (secret.keys.editKeyStr) {
+                newData.href = '/drive/#'+Hash.getEditHashFromKeys(secret);
+            }
+            newData.roHref = '/drive/#'+Hash.getViewHashFromKeys(secret);
+            delete newData.legacy;
+            _addSharedFolder(Env, {
+                path: ['root'],
+                folderData: newData,
+            }, function () {
+                delete temp[fId];
+                Env.onSync(cb);
+            });
+        });
+
+    };
+
+    // convert a folder to a Shared Folder
+    var _convertFolderToSharedFolder = function (Env, data, cb) {
+        var path = data.path;
+        var folderElement = Env.user.userObject.find(path);
+        // don't try to convert top-level elements (trash, root, etc) to shared-folders
+        if (path.length <= 1 || path[0] !== UserObject.ROOT) {
+            return void cb({
+                error: 'E_INVAL_PATH',
+            });
+        }
+        if (_isInSharedFolder(Env, path)) {
+            return void cb({
+                error: 'E_INVAL_NESTING',
+            });
+        }
+        if (Env.user.userObject.hasSubSharedFolder(folderElement)) {
+            return void cb({
+                error: 'E_INVAL_NESTING',
+            });
+        }
+        var parentPath = path.slice(0, -1);
+        var parentFolder = Env.user.userObject.find(parentPath);
+        var folderName = path[path.length - 1];
+        var SFId;
+        nThen(function (waitFor) {
+            // create shared folder
+            _addSharedFolder(Env, {
+                path: parentPath,
+                name: folderName,
+                owned: data.owned,
+                password: data.password || '',
+            }, waitFor(function (id) {
+                // _addSharedFolder can be an id or an error
+                if (typeof(id) === 'object' && id && id.error) {
+                    waitFor.abort();
+                    return void cb(id);
+                } else {
+                    SFId = id;
+                }
+            }));
+        }).nThen(function (waitFor) {
+            // move everything from folder to SF
+            if (!SFId) {
+                waitFor.abort();
+                return void cb({
+                    error: 'E_NO_ID'
+                });
+            }
+            var paths = [];
+            for (var el in folderElement) {
+                if (Env.user.userObject.isFolder(folderElement[el]) || Env.user.userObject.isFile(folderElement[el])) {
+                    paths.push(path.concat(el));
+                }
+            }
+            var SFKey;
+            // this is basically Array.find, except it works in IE
+            Object.keys(parentFolder).some(function (el) {
+                if (parentFolder[el] === SFId) {
+                    SFKey = el;
+                    return true;
+                }
+            });
+
+            if (!SFKey) {
+                waitFor.abort();
+                return void cb({
+                    error: 'E_NO_KEY'
+                });
+            }
+            var newPath = parentPath.concat(SFKey).concat(UserObject.ROOT);
+            _move(Env, {
+                paths: paths,
+                newPath: newPath,
+                copy: false,
+            }, waitFor());
+        }).nThen(function (waitFor) {
+            // Move the owned pads from the old folder to root
+            var paths = [];
+            Object.keys(folderElement).forEach(function (el) {
+                if (!Env.user.userObject.isFile(folderElement[el])) { return; }
+                var data = Env.user.userObject.getFileData(folderElement[el]);
+                if (!data || !_ownedByMe(Env, data.owners)) { return; }
+                // This is an owned pad: move it to ROOT before deleting the initial folder
+                paths.push(path.concat(el));
+            });
+            _move(Env, {
+                paths: paths,
+                newPath: [UserObject.ROOT],
+                copy: false,
+            }, waitFor());
+        }).nThen(function () {
+            // migrate metadata
+            var sharedFolderElement = Env.user.proxy[UserObject.SHARED_FOLDERS][SFId];
+            var metadata = Env.user.userObject.getFolderData(folderElement);
+            for (var key in metadata) {
+                // it shouldn't be possible to have nested metadata
+                // but this is a reasonable sanity check
+                if (key === "metadata") { continue; }
+                // copy the metadata from the original folder to the new shared folder
+                sharedFolderElement[key] = metadata[key];
+            }
+
+            // remove folder
+            Env.user.userObject.delete([path], function () {
+                cb({
+                    fId: SFId
+                });
+            });
+        });
+    };
+
+    var _delete = function (Env, data, cb) {
+        data = data || {};
+        var resolved = data.resolved || _resolvePaths(Env, data.paths);
+        if (!resolved.main.length && !Object.keys(resolved.folders).length) {
+            return void cb({error: 'E_NOTFOUND'});
+        }
+
+        // Deleted or password changed for a shared folder
+        if (data.paths && data.paths.length === 1 &&
+            data.paths[0][0] === UserObject.SHARED_FOLDERS_TEMP) {
+            var temp = Util.find(Env, ['user', 'proxy', UserObject.SHARED_FOLDERS_TEMP]);
+            delete temp[data.paths[0][1]];
+            return void Env.onSync(cb);
+        }
+
+        var toUnpin = [];
+        nThen(function (waitFor)  {
+            // Delete paths from the main drive and get the list of pads to unpin
+            // We also get the list of owned pads that were removed
+            if (resolved.main.length) {
+                var uo = Env.user.userObject;
+                if (Util.find(Env.settings, ['drive', 'hideDuplicate'])) {
+                    // If we hide duplicate owned pads in our drive, we have
+                    // to make sure we're not deleting a hidden own file
+                    // from inside a folder we're trying to delete
+                    resolved.main.forEach(function (p) {
+                        var el = uo.find(p);
+                        if (p[0] === UserObject.FILES_DATA) { return; }
+                        if (uo.isFile(el) || uo.isSharedFolder(el)) { return; }
+                        var arr = [];
+                        uo.getFilesRecursively(el, arr);
+                        arr.forEach(function (id) {
+                            if (_isDuplicateOwned(Env, null, id)) {
+                                Env.user.userObject.add(Number(id), [UserObject.ROOT]);
+                            }
+                        });
+                    });
+                }
+                uo.delete(resolved.main, waitFor(function (err, _toUnpin/*, _ownedRemoved*/) {
+                    //ownedRemoved = _ownedRemoved;
+                    if (!Env.unpinPads || !_toUnpin) { return; }
+                    Array.prototype.push.apply(toUnpin, _toUnpin);
+                }));
+            }
+        }).nThen(function (waitFor) {
+            // Check if removed owned pads are duplicated in some shared folders
+            // If that's the case, we have to remove them from the shared folders too
+            // We can do that by adding their paths to the list of pads to remove from shared folders
+            /*if (ownedRemoved) {
+                var ids = _findChannels(Env, ownedRemoved);
+                ids.forEach(function (id) {
+                    var paths = findFile(Env, id);
+                    var _resolved = _resolvePaths(Env, paths);
+                    Object.keys(_resolved.folders).forEach(function (fId) {
+                        if (resolved.folders[fId]) {
+                            Array.prototype.push.apply(resolved.folders[fId], _resolved.folders[fId]);
+                        } else {
+                            resolved.folders[fId] = _resolved.folders[fId];
+                        }
+                    });
+                });
+            }*/
+            // Delete paths from the shared folders
+            Object.keys(resolved.folders).forEach(function (id) {
+                Env.folders[id].userObject.delete(resolved.folders[id], waitFor(function (err, _toUnpin) {
+                    if (!Env.unpinPads || !_toUnpin) { return; }
+                    Array.prototype.push.apply(toUnpin, _toUnpin);
+                }));
+            });
+        }).nThen(function (waitFor) {
+            if (!Env.unpinPads) { return; }
+
+            // Deleted channels
+            toUnpin = Util.deduplicateString(toUnpin);
+            // Deleted channels that are still in another proxy
+            var toKeep = [];
+            _findChannels(Env, toUnpin).forEach(function (id) {
+                var data = _getFileData(Env, id);
+                var arr = [data.channel];
+                if (data.answersChannel) { arr.push(data.answersChannel); }
+                if (data.rtChannel) { arr.push(data.rtChannel); }
+                if (data.lastVersion) { arr.push(Hash.hrefToHexChannelId(data.lastVersion)); }
+                Array.prototype.push.apply(toKeep, arr);
+            });
+            // Compute the unpin list and unpin
+            var unpinList = [];
+            toUnpin.forEach(function (chan) {
+                if (toKeep.indexOf(chan) === -1) {
+                    unpinList.push(chan);
+
+                    // Check if need need to restore a full hash (hidden hash deleted from drive)
+                    Env.Store.checkDeletedPad(chan);
+                }
+            });
+
+            Env.unpinPads(unpinList, waitFor(function (response) {
+                if (response && response.error) { return console.error(response.error); }
+            }));
+        }).nThen(function () {
+            cb();
+        });
+    };
+    // Delete permanently some pads or folders
+    var _deleteOwned = function (Env, data, cb) {
+        data = data || {};
+        var resolved = _resolvePaths(Env, data.paths || []);
+        if (!data.channel && !resolved.main.length && !Object.keys(resolved.folders).length) {
+            return void cb({error: 'E_NOTFOUND'});
+        }
+        var toDelete = {
+            main: [],
+            folders: {}
+        };
+        var todo = function (channel, uo, p, _cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            var chan = channel;
+            if (!chan && uo) {
+                var el = uo.find(p);
+                if (!uo.isFile(el) && !uo.isSharedFolder(el)) { return; }
+                var data = uo.isFile(el) ? uo.getFileData(el) : getSharedFolderData(Env, el);
+                chan = data.channel;
+            }
+            // If the pad was a shared folder, delete it too and leave it
+            var fId;
+            Object.keys(Env.user.proxy[UserObject.SHARED_FOLDERS] || {}).some(function (id) {
+                var sfData = Env.user.proxy[UserObject.SHARED_FOLDERS][id] || {};
+                if (sfData.channel === chan) {
+                    fId = Number(id);
+                    Env.folders[id].deleting = true;
+                    return true;
+                }
+            });
+            Env.removeOwnedChannel(chan, function (obj) {
+                // If the error is that the file is already removed, nothing to
+                // report, it's a normal behavior (pad expired probably)
+                if (obj && obj.error && obj.error !== "ENOENT") {
+                    // RPC may not be responding
+                    // Send a report that can be handled manually
+                    if (fId && Env.folders[fId] && Env.folders[fId].deleting) {
+                        delete Env.folders[fId].deleting;
+                    }
+                    Feedback.send('ERROR_DELETING_OWNED_PAD=' + chan + '|' + obj.error, true);
+                    return void cb();
+                }
+
+                // No error: delete the pad and all its copies from our drive and shared folders
+                var ids = _findChannels(Env, [chan]);
+
+                // If the pad was a shared folder, delete it too and leave it
+                if (fId) {
+                    ids.push(fId);
+                }
+
+                if (!ids.length) {
+                    toDelete = undefined;
+                    return void cb();
+                }
+
+                ids.forEach(function (id) {
+                    var paths = findFile(Env, id);
+                    var _resolved = _resolvePaths(Env, paths);
+
+                    Array.prototype.push.apply(toDelete.main, _resolved.main);
+                    Object.keys(_resolved.folders).forEach(function (fId) {
+                        if (toDelete.folders[fId]) {
+                            Array.prototype.push.apply(toDelete.folders[fId], _resolved.folders[fId]);
+                        } else {
+                            toDelete.folders[fId] = _resolved.folders[fId];
+                        }
+                    });
+                });
+                cb();
+            });
+        };
+        nThen(function (w) {
+            // Delete owned pads from the server
+            if (data.channel) {
+                todo(data.channel, null, null, w());
+            }
+            resolved.main.forEach(function (p) {
+                todo(null, Env.user.userObject, p, w());
+            });
+            Object.keys(resolved.folders).forEach(function (id) {
+                var uo = Env.folders[id].userObject;
+                resolved.folders[id].forEach(function (p) {
+                    todo(null, uo, p, w());
+                });
+            });
+        }).nThen(function () {
+            if (!toDelete) {
+                // Nothing to delete
+                cb();
+            } else {
+                // Remove deleted pads from the drive
+                _delete(Env, { resolved: toDelete }, cb);
+            }
+            // If we were using the access modal, send a refresh command
+            if (data.channel) {
+                Env.Store.refreshDriveUI();
+            }
+        });
+    };
+
+    // Empty the trash (main drive only)
+    var _emptyTrash = function (Env, data, cb) {
+        nThen(function (waitFor) {
+            if (data && data.deleteOwned) {
+                // Delete owned pads in the trash from the server
+                var owned = Env.user.userObject.ownedInTrash(function (owners) {
+                    return _ownedByMe(Env, owners);
+                });
+                var n = nThen;
+                owned.forEach(function (chan) {
+                    n = n(function (w) {
+                        Env.removeOwnedChannel(chan, w(function (obj) {
+                            setTimeout(w(), 50);
+                            // If the error is that the file is already removed, nothing to
+                            // report, it's a normal behavior (pad expired probably)
+                            if (obj && obj.error && obj.error !== "ENOENT") {
+                                // RPC may not be responding
+                                // Send a report that can be handled manually
+                                console.error(obj.error, chan);
+                                Feedback.send('ERROR_EMPTYTRASH_OWNED=' + chan + '|' + obj.error, true);
+                            }
+                            console.warn('DELETED', chan);
+                        }));
+                    }).nThen;
+                });
+                n(waitFor());
+            }
+
+            // Empty the trash
+            Env.user.userObject.emptyTrash(waitFor(function (err, toClean) {
+                var nn = nThen;
+                // Don't block nThen for the lower-priority tasks
+                setTimeout(waitFor(function () {
+                    // Unpin deleted pads if needed
+                    // Check if we need to restore a full hash (hidden hash deleted from drive)
+                    if (!Array.isArray(toClean)) { return; }
+                    var done = waitFor();
+                    var toCheck = Util.deduplicateString(toClean);
+                    var toUnpin = [];
+                    toCheck.forEach(function (channel) {
+                        // Check unpin
+                        nn = nn(function (w) {
+                            var data = findChannel(Env, channel, true);
+                            if (!data.length) { toUnpin.push(channel); }
+                            // Check hidden hash, one at a time, asynchronously
+                            Env.Store.checkDeletedPad(channel, w());
+                        }).nThen;
+                    });
+                    nn(function () {
+                        Env.unpinPads(toUnpin, function () {
+                            done();
+                        });
+                    });
+                }));
+            }));
+        }).nThen(cb);
+    };
+    // Rename files or folders
+    var _rename = function (Env, data, cb) {
+        data = data || {};
+        var resolved = _resolvePath(Env, data.path);
+        if (!resolved || !resolved.userObject) { return void cb({error: 'E_NOTFOUND'}); }
+        if (!resolved.id) {
+            var el = Env.user.userObject.find(resolved.path);
+            if (Env.user.userObject.isSharedFolder(el) && Env.folders[el]) {
+                Env.folders[el].proxy.metadata.title = data.newName || Messages.fm_folder;
+                Env.user.proxy[UserObject.SHARED_FOLDERS][el].lastTitle = data.newName || Messages.fm_folder;
+                return void cb();
+            }
+        }
+        resolved.userObject.rename(resolved.path, data.newName, cb);
+    };
+    var _setFolderData = function (Env, data, cb) {
+        data = data || {};
+        var resolved = _resolvePath(Env, data.path);
+        if (!resolved || !resolved.userObject) { return void cb({error: 'E_NOTFOUND'}); }
+        if (!resolved.id) {
+            var el = Env.user.userObject.find(resolved.path);
+            if (Env.user.userObject.isSharedFolder(el) && Env.folders[el]) {
+                Env.user.proxy[UserObject.SHARED_FOLDERS][el][data.key] = data.value;
+                return void Env.onSync(cb);
+            }
+        }
+        resolved.userObject.setFolderData(resolved.path, data.key, data.value, function () {
+            Env.onSync(cb);
+        });
+
+    };
+
+    var _updateStaticAccess = function (Env, id, cb) {
+        var uo = _getUserObjectFromId(Env, id);
+        var sd = uo.getFileData(id, true);
+        sd.atime = +new Date();
+        Env.onSync(cb);
+    };
+
+    var COMMANDS = {
+        move: _move,
+        restore: _restore,
+        addFolder: _addFolder,
+        addSharedFolder: _addSharedFolder,
+        addLink: _addLink,
+        restoreSharedFolder: _restoreSharedFolder,
+        convertFolderToSharedFolder: _convertFolderToSharedFolder,
+        delete: _delete,
+        deleteOwned: _deleteOwned,
+        emptyTrash: _emptyTrash,
+        rename: _rename,
+        setFolderData: _setFolderData,
+        updateStaticAccess: _updateStaticAccess,
+    };
+
+    var onCommand = function (Env, cmdData, cb) {
+        var cmd = cmdData.cmd;
+        var data = cmdData.data || {};
+        var method = COMMANDS[cmd];
+
+        if (typeof(method) === 'function') {
+            return void method(Env, data, cb);
+        }
+        // if the command was not handled then call back
+        cb();
+    };
+
+    // Set the value everywhere the given pad is stored (main and shared folders)
+    var setPadAttribute = function (Env, data, cb) {
+        cb = cb || function () {};
+        if (!data.attr || !data.attr.trim()) { return void cb("E_INVAL_ATTR"); }
+        var sfId = Env.user.userObject.getSFIdFromHref(data.href);
+        if (sfId) {
+            if (data.attr === "href") {
+                data.value = Env.user.userObject.cryptor.encrypt(data.value);
+            }
+            Env.user.proxy[UserObject.SHARED_FOLDERS][sfId][data.attr] = data.value;
+        }
+        var datas = findHref(Env, data.href);
+        var nt = nThen;
+        datas.forEach(function (d) {
+            nt = nt(function (waitFor) {
+                d.userObject.setPadAttribute(data.href, data.attr, data.value, waitFor());
+            }).nThen;
+        });
+        nt(function () { cb(); });
+    };
+    // Get pad attribute must return only one value, even if the pad is stored in multiple places
+    // (main or shared folders)
+    // We're going to return the value with the most recent atime. The attributes may have been
+    // updated in a shared folder by another user, so the most recent one is more likely to be the
+    // correct one.
+    // NOTE: we also return the atime, so that we can also check with each team manager
+    var getPadAttribute = function (Env, data, cb) {
+        cb = cb || function () {};
+        var sfId = Env.user.userObject.getSFIdFromHref(data.href);
+        if (sfId) {
+            var sfData = getSharedFolderData(Env, sfId);
+            var sfValue = data.attr ? sfData[data.attr] : JSON.parse(JSON.stringify(sfData));
+            setTimeout(function () {
+                cb(null, {
+                    value: sfValue,
+                    atime: 1
+                });
+            });
+            return;
+        }
+        var datas = findHref(Env, data.href);
+        var res = {};
+        datas.forEach(function (d) {
+            var atime = d.data.atime;
+
+            var value = data.attr ? d.data[data.attr] : JSON.parse(JSON.stringify(d.data));
+            if (!res.value || res.atime < atime) {
+                res.atime = atime;
+                res.value = value;
+            }
+        });
+        setTimeout(function () {
+            cb(null, res);
+        });
+    };
+
+    var getTagsList = function (Env) {
+        var list = {};
+        var userObjects = _getUserObjects(Env);
+        userObjects.forEach(function (uo) {
+            var l = uo.getTagsList();
+            Object.keys(l).forEach(function (t) {
+                list[t] = list[t] ? (list[t] + l[t]) : l[t];
+            });
+        });
+        return list;
+    };
+
+    var getSecureFilesList = function (Env, where) {
+        var userObjects = _getUserObjects(Env);
+        var list = [];
+        var channels = [];
+        userObjects.forEach(function (uo) {
+            var toPush = uo.getFiles(where).map(function (id) {
+                return {
+                    id: id,
+                    data: uo.getFileData(id)
+                };
+            }).filter(function (d) {
+                if (channels.indexOf(d.data.channel || d.id) === -1) {
+                    channels.push(d.data.channel || d.id);
+                    return true;
+                }
+            });
+            Array.prototype.push.apply(list, toPush);
+        });
+        return list;
+    };
+
+
+    /*
+        Store
+    */
+
+    var excludeInvalidIdentifiers = function (result) {
+        return result.filter(function (channel) {
+            if (typeof(channel) !== 'string') { return; }
+            return [32, 48].indexOf(channel.length) !== -1;
+        });
+    };
+
+    // Get the list of channels filtered by a type (expirable channels, owned channels, pin list)
+    var getChannelsList = function (Env, type) {
+        var result = [];
+        var addChannel = function (userObject) {
+            if (type === 'expirable') {
+                return function (fileId) {
+                    var data = userObject.getFileData(fileId);
+                    if (!data) { return; }
+                    // Don't push duplicates
+                    if (result.indexOf(data.channel) !== -1) { return; }
+                    // Return pads owned by someone else or expired by time
+                    if (_ownedByOther(Env, data.owners) || (data.expire && data.expire < (+new Date()))) {
+                        result.push(data.channel);
+                    }
+                };
+            }
+            if (type === 'owned') {
+                return function (fileId) {
+                    var data = userObject.getFileData(fileId);
+                    if (!data) { return; }
+                    // Don't push duplicates
+                    if (result.indexOf(data.channel) !== -1) { return; }
+                    // Return owned pads
+                    if (_ownedByMe(Env, data.owners)) {
+                        result.push(data.channel);
+                    }
+                };
+            }
+            if (type === "pin") {
+                return function (fileId) {
+                    var data = userObject.getFileData(fileId);
+                    if (!data) { return; }
+                    // Don't pin pads owned by someone else
+                    //if (_ownedByOther(Env, data.owners)) { return; }
+                    // Pin onlyoffice checkpoints
+                    if (data.lastVersion) {
+                        var otherChan = Hash.hrefToHexChannelId(data.lastVersion);
+                        if (result.indexOf(otherChan) === -1) {
+                            result.push(otherChan);
+                        }
+                    }
+                    // Pin form answers channels
+                    if (data.answersChannel && result.indexOf(data.answersChannel) === -1) {
+                        result.push(data.answersChannel);
+                    }
+                    // Pin onlyoffice realtime patches
+                    if (data.rtChannel && result.indexOf(data.rtChannel) === -1) {
+                        result.push(data.rtChannel);
+                    }
+                    // Pin onlyoffice images
+                    if (data.ooImages && Array.isArray(data.ooImages)) {
+                        Array.prototype.push.apply(result, data.ooImages);
+                    }
+                    // Pin the pad
+                    if (result.indexOf(data.channel) === -1) {
+                        result.push(data.channel);
+                    }
+                };
+            }
+        };
+
+        if (type === 'owned' && !Env.edPublic) { return excludeInvalidIdentifiers(result); }
+        if (type === 'pin' && !Env.edPublic) { return excludeInvalidIdentifiers(result); }
+
+        // Get the list of user objects
+        var userObjects = _getUserObjects(Env);
+
+        userObjects.forEach(function (uo) {
+            var files = uo.getFiles([UserObject.FILES_DATA]);
+            files.forEach(addChannel(uo));
+        });
+
+        // NOTE: expirable shared folder should be added here if we ever decide to enable them
+        if (type === "owned") {
+            var sfOwned = Object.keys(Env.user.proxy[UserObject.SHARED_FOLDERS]).filter(function (fId) {
+                var owners = Env.user.proxy[UserObject.SHARED_FOLDERS][fId].owners;
+                if (_ownedByMe(Env, owners)) { return true; }
+            }).map(function (fId) {
+                return Env.user.proxy[UserObject.SHARED_FOLDERS][fId].channel;
+            });
+            Array.prototype.push.apply(result, sfOwned);
+        }
+        if (type === "pin") {
+            var sfChannels = Object.keys(Env.folders).map(function (fId) {
+                try {
+                    return Env.user.proxy[UserObject.SHARED_FOLDERS][fId].channel;
+                } catch (err) {
+                    console.error(err);
+                }
+            }).filter(Boolean);
+            Array.prototype.push.apply(result, sfChannels);
+        }
+
+        return excludeInvalidIdentifiers(result);
+    };
+
+    var addPad = function (Env, path, pad, cb) {
+        var uo = Env.user.userObject;
+        var p = ['root'];
+        if (path) {
+            var resolved = _resolvePath(Env, path);
+            uo = resolved.userObject;
+            p = resolved.path;
+        }
+        var todo = function () {
+            var error;
+            nThen(function (waitFor) {
+                uo.pushData(pad, waitFor(function (e, id) {
+                    if (e) { error = e; return; }
+                    uo.add(id, p);
+                }));
+            }).nThen(function () {
+                cb(error);
+            });
+        };
+        if (!Env.pinPads) { return void todo(); }
+        Env.pinPads([pad.channel], function (obj) {
+            if (obj && obj.error) { return void cb(obj.error); }
+            todo();
+        });
+    };
+
+    var create = function (proxy, data, uoConfig) {
+        var Env = {
+            pinPads: data.pin,
+            unpinPads: data.unpin,
+            onSync: data.onSync,
+            Store: data.Store,
+            store: data.store,
+            removeOwnedChannel: data.removeOwnedChannel,
+            loadSharedFolder: data.loadSharedFolder,
+            cfg: uoConfig,
+            edPublic: data.edPublic,
+            settings: data.settings,
+            user: {
+                proxy: proxy,
+            },
+            folders: {}
+        };
+
+        uoConfig.removeProxy = function (id) {
+            removeProxy(Env, id);
+        };
+        Env.user.userObject = UserObject.init(proxy, uoConfig);
+
+        var callWithEnv = function (f) {
+            return function () {
+                [].unshift.call(arguments, Env);
+                return f.apply(null, arguments);
+            };
+        };
+
+        var addPin = function (pin, unpin) {
+            Env.pinPads = pin;
+            Env.unpinPads = unpin;
+        };
+        var removePin = function () {
+            delete Env.pinPads;
+            delete Env.unpinPads;
+        };
+
+        return {
+            // Manager
+            addProxy: callWithEnv(addProxy),
+            removeProxy: callWithEnv(removeProxy),
+            deprecateProxy: callWithEnv(deprecateProxy),
+            restrictedProxy: callWithEnv(restrictedProxy),
+            addSharedFolder: callWithEnv(_addSharedFolder),
+            addPin: addPin,
+            removePin: removePin,
+            // Drive
+            command: callWithEnv(onCommand),
+            getPadAttribute: callWithEnv(getPadAttribute),
+            setPadAttribute: callWithEnv(setPadAttribute),
+            getTagsList: callWithEnv(getTagsList),
+            getSecureFilesList: callWithEnv(getSecureFilesList),
+            getSharedFolderData: callWithEnv(getSharedFolderData),
+            // Store
+            getChannelsList: callWithEnv(getChannelsList),
+            addPad: callWithEnv(addPad),
+            delete: callWithEnv(_delete),
+            deleteOwned: callWithEnv(_deleteOwned),
+            // Tools
+            findChannel: callWithEnv(findChannel),
+            findHref: callWithEnv(findHref),
+            findFile: callWithEnv(findFile),
+            getEditHash: callWithEnv(getEditHash),
+            user: Env.user,
+            folders: Env.folders
+        };
+    };
+
+    /* =============================================================================
+     * =============================================================================
+     *                                  Inner only
+     * =============================================================================
+     * ============================================================================= */
+
+    var renameInner = function (Env, path, newName, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "rename",
+            data: {
+                path: path,
+                newName: newName
+            }
+        }, cb);
+    };
+    var moveInner = function (Env, paths, newPath, cb, copy) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "move",
+            data: {
+                paths: paths,
+                newPath: newPath,
+                copy: copy
+            }
+        }, cb);
+    };
+    var emptyTrashInner = function (Env, deleteOwned, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "emptyTrash",
+            data: {
+                deleteOwned: deleteOwned
+            }
+        }, cb);
+    };
+    var addFolderInner = function (Env, path, name, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "addFolder",
+            data: {
+                path: path,
+                name: name
+            }
+        }, cb);
+    };
+    var addSharedFolderInner = function (Env, path, data, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "addSharedFolder",
+            data: {
+                path: path,
+                name: data.name,
+                owned: data.owned,
+                password: data.password
+            }
+        }, cb);
+    };
+    var addLinkInner = function (Env, path, data, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "addLink",
+            data: {
+                path: path,
+                name: data.name,
+                href: data.url
+            }
+        }, cb);
+    };
+    var restoreSharedFolderInner = function (Env, fId, password, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "restoreSharedFolder",
+            data: {
+                id: fId,
+                password: password
+            }
+        }, cb);
+    };
+    var convertFolderToSharedFolderInner = function (Env, path, owned, password, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "convertFolderToSharedFolder",
+            data: {
+                path: path,
+                owned: owned,
+                password: password
+            }
+        }, cb);
+    };
+    var deleteInner = function (Env, paths, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "delete",
+            data: {
+                paths: paths,
+            }
+        }, cb);
+    };
+    var deleteOwnedInner = function (Env, paths, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "deleteOwned",
+            data: {
+                paths: paths,
+            }
+        }, cb);
+    };
+    var restoreInner = function (Env, path, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "restore",
+            data: {
+                path: path
+            }
+        }, cb);
+    };
+    var setFolderDataInner = function (Env, data, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "setFolderData",
+            data: data
+        }, cb);
+    };
+
+    var updateStaticAccessInner = function (Env, id, cb) {
+        return void Env.sframeChan.query("Q_DRIVE_USEROBJECT", {
+            cmd: "updateStaticAccess",
+            data: id
+        }, cb);
+
+    };
+
+    /* Tools */
+
+    var findChannels = _findChannels;
+    var getFileData = _getFileData;
+    var getUserObjectPath = _getUserObjectPath;
+
+    var find = function (Env, path, fId) {
+        if (fId) { return Env.folders[fId].userObject.find(path); }
+        var resolved = _resolvePath(Env, path);
+        return resolved.userObject.find(resolved.path);
+    };
+
+    var getTitle = function (Env, id, type) {
+        var uo = _getUserObjectFromId(Env, id);
+        return String(uo.getTitle(id, type));
+    };
+
+    var isStaticFile = function (Env, id) {
+        var uo = _getUserObjectFromId(Env, id);
+        return uo.isStaticFile(id);
+    };
+
+    var isReadOnlyFile = function (Env, id) {
+        var uo = _getUserObjectFromId(Env, id);
+        return uo.isReadOnlyFile(id);
+    };
+
+    var getFiles = function (Env, categories) {
+        var files = [];
+        var userObjects = _getUserObjects(Env);
+        userObjects.forEach(function (uo) {
+            Array.prototype.push.apply(files, uo.getFiles(categories));
+        });
+        files = Util.deduplicateString(files);
+        return files;
+    };
+
+    var search = function (Env, value) {
+        var ret = [];
+        var userObjects = _getUserObjects(Env);
+        userObjects.forEach(function (uo) {
+            var fPath = _getUserObjectPath(Env, uo);
+            var results = uo.search(value);
+            if (!results.length) { return; }
+            if (fPath) {
+                // This is a shared folder, we have to fix the paths in the search results
+                results.forEach(function (r) {
+                    r.inSharedFolder = true;
+                    r.paths.forEach(function (p) {
+                        Array.prototype.unshift.apply(p, fPath);
+                    });
+                });
+            }
+            // Push the results from this proxy
+            Array.prototype.push.apply(ret, results);
+        });
+        return ret;
+    };
+
+    var getRecentPads = function (Env) {
+        var files = [];
+        var userObjects = _getUserObjects(Env);
+        userObjects.forEach(function (uo) {
+            var data = uo.getFiles([UserObject.FILES_DATA, UserObject.STATIC_DATA]).map(function (id) {
+                return [Number(id), uo.getFileData(id)];
+            });
+            Array.prototype.push.apply(files, data);
+        });
+        var sorted = files.filter(function (a) { return a[1].atime; })
+            .sort(function (a,b) {
+                return b[1].atime - a[1].atime;
+            });
+        return sorted;
+        //return Env.user.userObject.getRecentPads();
+    };
+    var getOwnedPads = function (Env) {
+        return Env.user.userObject.getOwnedPads(Env.edPublic);
+    };
+
+    var setHistoryMode = function (Env, flag) {
+        Env.isHistoryMode = Boolean(flag);
+    };
+
+    var getFolderData = function (Env, path) {
+        var resolved = _resolvePath(Env, path);
+        if (!resolved || !resolved.userObject) { return {}; }
+        if (!resolved.id) {
+            var el = Env.user.userObject.find(resolved.path);
+            if (Env.user.userObject.isSharedFolder(el)) {
+                return getSharedFolderData(Env, el);
+            }
+        }
+        var folder = resolved.userObject.find(resolved.path);
+        return resolved.userObject.getFolderData(folder);
+    };
+
+    var isInSharedFolder = _isInSharedFolder;
+
+    /* Generic: doesn't need access to a proxy */
+    var isValidDrive = function (Env, obj) {
+        return Env.user.userObject.isValidDrive(obj);
+    };
+    var isFile = function (Env, el, allowStr) {
+        return Env.user.userObject.isFile(el, allowStr);
+    };
+    var isFolder = function (Env, el) {
+        return Env.user.userObject.isFolder(el);
+    };
+    var isSharedFolder = function (Env, el) {
+        return Env.user.userObject.isSharedFolder(el);
+    };
+    var isFolderEmpty = function (Env, el) {
+        if (Env.folders[el]) {
+            var uo = Env.folders[el].userObject;
+            return uo.isFolderEmpty(uo.find[uo.ROOT]);
+        }
+        return Env.user.userObject.isFolderEmpty(el);
+    };
+    var isPathIn = function (Env, path, categories) {
+        return Env.user.userObject.isPathIn(path, categories);
+    };
+    var isSubpath = function (Env, path, parentPath) {
+        return Env.user.userObject.isSubpath(path, parentPath);
+    };
+    var isInTrashRoot = function (Env, path) {
+        return Env.user.userObject.isInTrashRoot(path);
+    };
+    var comparePath = function (Env, a, b) {
+        return Env.user.userObject.comparePath(a, b);
+    };
+    var hasSubfolder = function (Env, el, trashRoot) {
+        if (Env.folders[el]) {
+            var uo = Env.folders[el].userObject;
+            return uo.hasSubfolder(uo.find[uo.ROOT]);
+        }
+        return Env.user.userObject.hasSubfolder(el, trashRoot);
+    };
+    var hasSubSharedFolder = function (Env, el) {
+        return Env.user.userObject.hasSubSharedFolder(el);
+    };
+    var hasFile = function (Env, el, trashRoot) {
+        if (Env.folders[el]) {
+            var uo = Env.folders[el].userObject;
+            return uo.hasFile(uo.find[uo.ROOT]);
+        }
+        return Env.user.userObject.hasFile(el, trashRoot);
+    };
+    var ownedInTrash = function (Env) {
+        return Env.user.userObject.ownedInTrash(function (owners) {
+            return _ownedByMe(Env, owners);
+        });
+    };
+
+    var isDuplicateOwned = _isDuplicateOwned;
+
+    var createInner = function (proxy, sframeChan, edPublic, uoConfig) {
+        var Env = {
+            cfg: uoConfig,
+            sframeChan: sframeChan,
+            edPublic: edPublic,
+            user: {
+                proxy: proxy,
+                userObject: UserObject.init(proxy, uoConfig)
+            },
+            folders: {}
+        };
+
+        var callWithEnv = function (f) {
+            return function () {
+                [].unshift.call(arguments, Env);
+                return f.apply(null, arguments);
+            };
+        };
+
+        return {
+            // Manager
+            addProxy: callWithEnv(addProxy),
+            removeProxy: callWithEnv(removeProxy),
+            setHistoryMode: callWithEnv(setHistoryMode),
+            // Drive RPC commands
+            rename: callWithEnv(renameInner),
+            move: callWithEnv(moveInner),
+            emptyTrash: callWithEnv(emptyTrashInner),
+            addFolder: callWithEnv(addFolderInner),
+            addSharedFolder: callWithEnv(addSharedFolderInner),
+            addLink: callWithEnv(addLinkInner),
+            restoreSharedFolder: callWithEnv(restoreSharedFolderInner),
+            convertFolderToSharedFolder: callWithEnv(convertFolderToSharedFolderInner),
+            delete: callWithEnv(deleteInner),
+            deleteOwned: callWithEnv(deleteOwnedInner),
+            restore: callWithEnv(restoreInner),
+            setFolderData: callWithEnv(setFolderDataInner),
+            updateStaticAccess: callWithEnv(updateStaticAccessInner),
+            // Tools
+            getFileData: callWithEnv(getFileData),
+            find: callWithEnv(find),
+            getTitle: callWithEnv(getTitle),
+            isReadOnlyFile: callWithEnv(isReadOnlyFile),
+            isStaticFile: callWithEnv(isStaticFile),
+            getFiles: callWithEnv(getFiles),
+            search: callWithEnv(search),
+            getRecentPads: callWithEnv(getRecentPads),
+            getOwnedPads: callWithEnv(getOwnedPads),
+            getTagsList: callWithEnv(getTagsList),
+            findFile: callWithEnv(findFile),
+            findChannels: callWithEnv(findChannels),
+            getSharedFolderData: callWithEnv(getSharedFolderData),
+            getFolderData: callWithEnv(getFolderData),
+            isInSharedFolder: callWithEnv(isInSharedFolder),
+            getUserObjectPath: callWithEnv(getUserObjectPath),
+            isDuplicateOwned: callWithEnv(isDuplicateOwned),
+            ownedInTrash: callWithEnv(ownedInTrash),
+            // Generic
+            isValidDrive: callWithEnv(isValidDrive),
+            isFile: callWithEnv(isFile),
+            isFolder: callWithEnv(isFolder),
+            isSharedFolder: callWithEnv(isSharedFolder),
+            isFolderEmpty: callWithEnv(isFolderEmpty),
+            isPathIn: callWithEnv(isPathIn),
+            isSubpath: callWithEnv(isSubpath),
+            isInTrashRoot: callWithEnv(isInTrashRoot),
+            comparePath: callWithEnv(comparePath),
+            hasSubfolder: callWithEnv(hasSubfolder),
+            hasSubSharedFolder: callWithEnv(hasSubSharedFolder),
+            hasFile: callWithEnv(hasFile),
+            // Data
+            user: Env.user,
+            folders: Env.folders
+        };
+    };
+
+    return {
+        setCustomize,
+        create: create,
+        createInner: createInner
+    };
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // We don't need Messages in worker or node
+    module.exports = factory(
+        require('./user-object'),
+        require('./common-util'),
+        require('./common-hash'),
+        require('../worker/components/sharedfolder'),
+        undefined,
+        require('./common-feedback'),
+        require('nthen')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/user-object.js',
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/outer/sharedfolder.js',
+        '/customize/messages.js',
+        '/common/common-feedback.js',
+        '/components/nthen/index.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/rpc.js b/src/common/rpc.js
new file mode 100644
index 000000000..9c3ccc7cb
--- /dev/null
+++ b/src/common/rpc.js
@@ -0,0 +1,422 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(function () {
+var factory = function (Util, Nacl) {
+    // we will send messages with a unique id for each RPC
+    // that id is returned with each response, indicating which call it was in response to
+    var uid = Util.uid;
+
+    // safely parse json messages, because they might cause parse errors
+    var tryParse = Util.tryParse;
+
+    // we will sign various message with our edPrivate keys
+    // this handles that in a generic way
+    var signMsg = function (data, signKey) {
+        var buffer = Nacl.util.decodeUTF8(JSON.stringify(data));
+        return Nacl.util.encodeBase64(Nacl.sign.detached(buffer, signKey));
+    };
+
+    // sendMsg takes a pre-formed message, does a little validation
+    // adds a transaction id to the message and stores its callback
+    // and finally sends it off to the historyKeeper, which delegates its
+    // processing to the RPC submodule
+    var sendMsg = function (ctx, data, cb) {
+        if (typeof(cb) !== 'function') { throw new Error('expected callback'); }
+
+        var network = ctx.network;
+        var hkn = network.historyKeeper;
+        if (typeof(hkn) !== 'string') { return void cb("NO_HISTORY_KEEPER"); }
+
+        var txid = uid();
+
+        var pending = ctx.pending[txid] = function (err, response) {
+            cb(err, response);
+        };
+        pending.data = data;
+        pending.called = 0;
+
+        return network.sendto(hkn, JSON.stringify([txid, data]));
+    };
+
+    var matchesAnon = function (ctx, txid) {
+        if (!ctx.anon) { return false; }
+        if (typeof(ctx.anon.pending[txid]) !== 'function') { return false; }
+        return true;
+    };
+
+    var handleAnon = function (ctx /* anon_ctx */, txid, body /* parsed messages without txid */) {
+        // if anon is handling it we know there's a pending callback
+        var pending = ctx.pending[txid];
+        if (body[0] === 'ERROR') { pending(body[1]); }
+        else { pending(void 0, body.slice(1)); }
+        delete ctx.pending[txid];
+    };
+
+    var onMsg = function (ctx /* network context */, msg /* string message */) {
+        if (typeof(msg) !== 'string') {
+            console.error("received non-string message [%s]", msg);
+        }
+
+        var parsed = tryParse(msg);
+        if (!parsed) {
+            return void console.error(new Error('could not parse message: %s', msg));
+        }
+
+        // RPC messages are always arrays.
+        if (!Array.isArray(parsed)) { return; }
+        // ignore FULL_HISTORY messages
+        if (/(FULL_HISTORY|HISTORY_RANGE)/.test(parsed[0])) { return; }
+
+        var txid = parsed[0];
+
+        // txid must be a string, or this message is not meant for us
+        if (typeof(txid) !== 'string') { return; }
+
+        if (matchesAnon(ctx, txid)) {
+            return void handleAnon(ctx.anon, txid, parsed.slice(1));
+        }
+
+        // iterate over authenticated rpc contexts and check if they are expecting
+        // a message with this txid
+        if (ctx.authenticated.some(function (rpc_ctx) {
+            var pending = rpc_ctx.pending[txid];
+            // not meant for you
+            if (typeof(pending) !== 'function') { return false; }
+
+            // if you're here, the message is for you...
+
+            if (parsed[1] !== 'ERROR') {
+                // if the server sent you a new cookie, replace the old one
+                if (/\|/.test(parsed[1]) && rpc_ctx.cookie !== parsed[1]) {
+                    rpc_ctx.cookie = parsed[1];
+                }
+                pending(void 0, parsed.slice(2));
+
+                // if successful, delete the callback...
+                delete rpc_ctx.pending[txid];
+                // prevent further iteration
+                return true;
+            }
+
+            // NO_COOKIE errors mean you failed to authenticate.
+            // request a new cookie and resend the query
+            if (parsed[2] === 'NO_COOKIE') {
+                rpc_ctx.send('COOKIE', "", function (e) {
+                    if (e) {
+                        console.error(e);
+                        return void pending(e);
+                    }
+
+                    // resend the same command again
+                    // give up if you've already tried resending
+                    if (rpc_ctx.resend(txid)) { delete rpc_ctx.pending[txid]; }
+                });
+                // prevent further iteration
+                return true;
+            }
+
+            // if you're here then your RPC passed authentication but had some other error
+            // call back with the error message
+            pending(parsed[2]);
+            // and delete the pending callback
+            delete rpc_ctx.pending[txid];
+
+            // prevent further iteration
+            return true;
+        })) {
+            // the message was handled, so stop here
+            return;
+        }
+
+        console.error("UNHANDLED RPC MESSAGE", msg);
+    };
+
+    var networks = [];
+    var contexts = [];
+
+    var initNetworkContext = function (network) {
+        var ctx = {
+            network: network,
+            connected: true,
+            anon: undefined,
+            authenticated: [],
+        };
+        networks.push(network);
+        contexts.push(ctx);
+
+        // add listeners...
+        network.on('message', function (msg, sender) {
+            if (sender !== network.historyKeeper) { return; }
+            onMsg(ctx, msg);
+        });
+
+        network.on('disconnect', function () {
+            ctx.connected = false;
+            if (ctx.anon) { ctx.anon.connected = false; }
+            ctx.authenticated.forEach(function (ctx) {
+                ctx.connected = false;
+            });
+        });
+
+        network.on('reconnect', function () {
+            if (ctx.anon) { ctx.anon.connected = true; }
+            ctx.authenticated.forEach(function (ctx) {
+                ctx.connected = true;
+            });
+        });
+        return ctx;
+    };
+
+    var getNetworkContext = function (network) {
+        var i;
+        networks.some(function (current, j) {
+            if (network !== current) { return false; }
+            i = j;
+            return true;
+        });
+
+        if (contexts[i]) { return contexts[i]; }
+        return initNetworkContext(network);
+    };
+
+    var initAuthenticatedRpc = function (networkContext, keys) {
+        var ctx = {
+            network: networkContext.network,
+            publicKey: keys.publicKeyString,
+            timeouts: {},
+            pending: {},
+            cookie: null,
+            connected: true,
+        };
+
+        var send = ctx.send = function (type, msg, _cb) {
+            var cb = Util.mkAsync(_cb);
+
+            if (!ctx.connected && type !== 'COOKIE') {
+                return void cb("DISCONNECTED");
+            }
+
+            // construct a signed message...
+
+            var data = [type, msg];
+            if (ctx.cookie && ctx.cookie.join) {
+                data.unshift(ctx.cookie.join('|'));
+            } else {
+                data.unshift(ctx.cookie);
+            }
+
+            var sig = signMsg(data, keys.signKey);
+
+            data.unshift(keys.publicKeyString);
+            data.unshift(sig);
+
+            // [sig, edPublicKey, cookie, type, msg]
+            return sendMsg(ctx, data, cb);
+        };
+
+        ctx.resend = function (txid) {
+            var pending = ctx.pending[txid];
+            if (pending.called) {
+                console.error("[%s] called too many times", txid);
+                return true;
+            }
+            pending.called++;
+
+            // update the cookie and signature...
+            pending.data[2] = ctx.cookie;
+            pending.data[0] = signMsg(pending.data.slice(2), keys.signKey);
+
+            // store the callback with a new txid
+            var new_txid = uid();
+            ctx.pending[new_txid] = pending;
+            // and delete the old one
+            delete ctx.pending[txid];
+
+            try {
+                return ctx.network.sendto(ctx.network.historyKeeper,
+                    JSON.stringify([new_txid, pending.data]));
+            } catch (e) {
+                console.log("failed to resend");
+                console.error(e);
+            }
+        };
+
+        send.unauthenticated = function (type, msg, _cb) {
+            var cb = Util.mkAsync(_cb);
+            if (!ctx.connected) { return void cb('DISCONNECTED'); }
+
+            // construct an unsigned message
+            var data = [null, keys.publicKeyString, null, type, msg];
+            if (ctx.cookie && ctx.cookie.join) {
+                data[2] = ctx.cookie.join('|');
+            } else {
+                data[2] = ctx.cookie;
+            }
+
+            return sendMsg(ctx, data, cb);
+        };
+
+        ctx.destroy = function () {
+            // clear all pending timeouts
+            Object.keys(ctx.timeouts).forEach(function (to) {
+                clearTimeout(to);
+            });
+
+            // remove the ctx from the network's stack
+            var idx = networkContext.authenticated.indexOf(ctx);
+            if (idx === -1) { return; }
+            networkContext.authenticated.splice(idx, 1);
+        };
+
+        networkContext.authenticated.push(ctx);
+        return ctx;
+    };
+
+    var getAuthenticatedContext = function (networkContext, keys) {
+        if (!networkContext) { throw new Error('expected network context'); }
+
+        var publicKey = keys.publicKeyString;
+
+        var i;
+        networkContext.authenticated.some(function (ctx, j) {
+            if (ctx.publicKey !== publicKey) { return false; }
+            i = j;
+            return true;
+        });
+
+        if (networkContext.authenticated[i]) { return networkContext.authenticated[i]; }
+
+        return initAuthenticatedRpc(networkContext, keys);
+    };
+
+    var create = function (network, edPrivateKey, edPublicKey, _cb) {
+        if (typeof(_cb) !== 'function') { throw new Error("expected callback"); }
+
+        var cb = Util.mkAsync(_cb);
+
+        var signKey;
+
+        try {
+            signKey = Nacl.util.decodeBase64(edPrivateKey);
+            if (signKey.length !== 64) {
+                throw new Error('private key did not match expected length of 64');
+            }
+        } catch (err) {
+            return void cb(err);
+        }
+
+        try {
+            if (Nacl.util.decodeBase64(edPublicKey).length !== 32) {
+                return void cb('expected public key to be 32 uint');
+            }
+        } catch (err) { return void cb(err); }
+
+        if (!network) { return void cb('NO_NETWORK'); }
+
+        // get or create a context for the provided network
+        var net_ctx = getNetworkContext(network);
+
+        var rpc_ctx = getAuthenticatedContext(net_ctx, {
+            publicKeyString: edPublicKey,
+            signKey: signKey,
+        });
+
+        rpc_ctx.send('COOKIE', "", function (e) {
+            if (e) { return void cb(e); }
+            // callback to provide 'send' method to whatever needs it
+            cb(void 0, {
+                send: rpc_ctx.send,
+                destroy: rpc_ctx.destroy,
+            });
+        });
+    };
+
+    var initAnonRpc = function (networkContext) {
+        var ctx = {
+            network: networkContext.network,
+            timeouts: {},
+            pending: {},
+            connected: true,
+        };
+
+        // any particular network will only ever need one anonymous rpc
+        networkContext.anon = ctx;
+
+        ctx.send = function (type, msg, _cb) {
+            var cb = Util.mkAsync(_cb);
+            if (!ctx.connected) { return void cb('DISCONNECTED'); }
+
+            // construct an unsigned message...
+            var data = [type, msg];
+
+            // [type, msg]
+            return sendMsg(ctx, data, cb);
+        };
+
+        ctx.resend = function (txid) {
+            var pending = ctx.pending[txid];
+            if (pending.called) {
+                console.error("[%s] called too many times", txid);
+                return true;
+            }
+            pending.called++;
+
+            try {
+                return ctx.network.sendto(ctx.network.historyKeeper,
+                    JSON.stringify([txid, pending.data]));
+            } catch (e) {
+                console.log("failed to resend");
+                console.error(e);
+            }
+        };
+
+        ctx.destroy = function () {
+            // clear all pending timeouts
+            Object.keys(ctx.timeouts).forEach(function (to) {
+                clearTimeout(to);
+            });
+
+            networkContext.anon = undefined;
+        };
+
+        return ctx;
+    };
+
+    var getAnonContext = function (networkContext) {
+        return networkContext.anon || initAnonRpc(networkContext);
+    };
+
+    var createAnonymous = function (network, _cb) {
+        // enforce asynchrony
+        var cb = Util.mkAsync(_cb);
+
+        if (typeof(cb) !== 'function') { throw new Error("expected callback"); }
+        if (!network) { return void cb('NO_NETWORK'); }
+
+        // get or create a context for the provided network
+        var ctx = getAnonContext(getNetworkContext(network));
+
+        cb(void 0, {
+            send: ctx.send,
+            destroy: ctx.destroy,
+        });
+    };
+
+    return { create: create, createAnonymous: createAnonymous };
+};
+
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = factory(require("./common-util"), require("tweetnacl/nacl-fast"));
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        define([
+            '/common/common-util.js',
+            '/components/tweetnacl/nacl-fast.min.js',
+        ], function (Util) {
+            return factory(Util, window.nacl);
+        });
+    } else {
+        // I'm not gonna bother supporting any other kind of instanciation
+    }
+}());
diff --git a/src/common/user-object-setter.js b/src/common/user-object-setter.js
new file mode 100644
index 000000000..b1bd870e8
--- /dev/null
+++ b/src/common/user-object-setter.js
@@ -0,0 +1,1006 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (AppConfig = {}, Util, Hash,
+                Realtime, Messages = {}) => {
+    let window = globalThis;
+    var module = {};
+
+    module.setCustomize = (data) => {
+        Messages = data.Messages;
+        AppConfig = data.AppConfig;
+    };
+
+    var clone = function (o) {
+        try { return JSON.parse(JSON.stringify(o)); }
+        catch (e) { return undefined; }
+    };
+
+    module.init = function (config, exp, files) {
+        var loggedIn = config.loggedIn;
+        var sharedFolder = config.sharedFolder;
+
+        var readOnly = config.readOnly;
+
+        var Messages = config.Messages || {};
+        var ROOT = exp.ROOT;
+        var FILES_DATA = exp.FILES_DATA;
+        var STATIC_DATA = exp.STATIC_DATA;
+        var OLD_FILES_DATA = exp.OLD_FILES_DATA;
+        var UNSORTED = exp.UNSORTED;
+        var TRASH = exp.TRASH;
+        var TEMPLATE = exp.TEMPLATE;
+        var SHARED_FOLDERS = exp.SHARED_FOLDERS;
+        var SHARED_FOLDERS_TEMP = exp.SHARED_FOLDERS_TEMP;
+
+        var debug = exp.debug;
+
+        exp._setReadOnly = function (state) {
+            readOnly = state;
+            if (!readOnly) { exp.fixFiles(); }
+        };
+
+        exp.setHref = function (channel, id, href) {
+            if (!id && !channel) { return; }
+            if (readOnly) { return; }
+            var ids = id ? [id] : exp.findChannels([channel]);
+            ids.forEach(function (i) {
+                var data = exp.getFileData(i, true);
+                var oldHref = exp.getHref(data);
+                if (oldHref === href) { return; }
+                data.href = exp.cryptor.encrypt(href);
+            });
+        };
+
+        exp.setPadAttribute = function (href, attr, value, cb) {
+            cb = cb || function () {};
+            if (readOnly) { return void cb('EFORBIDDEN'); }
+            var id = exp.getIdFromHref(href);
+            if (!id) { return void cb("E_INVAL_HREF"); }
+            if (!attr || !attr.trim()) { return void cb("E_INVAL_ATTR"); }
+            var data = exp.getFileData(id, true);
+            if (attr === "href") {
+                exp.setHref(null, id, value);
+            } else {
+                data[attr] = clone(value);
+            }
+            cb(null);
+        };
+        exp.getPadAttribute = function (href, attr, cb) {
+            cb = cb || function () {};
+            var id = exp.getIdFromHref(href);
+            if (!id) { return void cb(null, undefined); }
+            var data = exp.getFileData(id);
+            cb(null, clone(data[attr]));
+        };
+
+        exp.pushData = function (_data, cb) {
+            if (typeof cb !== "function") { cb = function () {}; }
+            if (readOnly) { return void cb('EFORBIDDEN'); }
+            var id = Util.createRandomInteger();
+            var data = clone(_data);
+            // If we were given an edit link, encrypt its value if needed
+            if (data.href && data.href.indexOf('#') !== -1) { data.href = exp.cryptor.encrypt(data.href); }
+            files[FILES_DATA][id] = data;
+            cb(null, id);
+        };
+        exp.pushLink = function (_data, cb) {
+            if (typeof cb !== "function") { cb = function () {}; }
+            if (readOnly) { return void cb('EFORBIDDEN'); }
+            var id = Util.createRandomInteger();
+            var data = clone(_data);
+            files[STATIC_DATA][id] = data;
+            cb(null, id);
+        };
+
+        exp.pushSharedFolder = function (_data, cb) {
+            if (typeof cb !== "function") { cb = function () {}; }
+            if (readOnly) { return void cb('EFORBIDDEN'); }
+            var data = clone(_data);
+
+            // Check if we already have this shared folder in our drive
+            var exists;
+            if (Object.keys(files[SHARED_FOLDERS]).some(function (k) {
+                if (files[SHARED_FOLDERS][k].channel === data.channel) {
+                    // We already know this shared folder. Check if we can get better access rights
+                    if (data.href && !files[SHARED_FOLDERS][k].href) {
+                        files[SHARED_FOLDERS][k].href = data.href;
+                    }
+                    exists = k;
+                    return true;
+                }
+            })) {
+                return void cb ('EEXISTS', exists);
+            }
+
+            // Add the folder
+            if (!loggedIn || config.testMode) {
+                return void cb("EAUTH");
+            }
+            var id = Util.createRandomInteger();
+            if (data.href && data.href.indexOf('#') !== -1) { data.href = exp.cryptor.encrypt(data.href); }
+            files[SHARED_FOLDERS][id] = data;
+            cb(null, id);
+        };
+
+        exp.deprecateSharedFolder = function (id, reason) {
+            if (readOnly) { return; }
+            var data = files[SHARED_FOLDERS][id];
+            if (!data) { return; }
+            var ro = !data.href || exp.cryptor.decrypt(data.href).indexOf('#') === -1;
+            if (!ro) {
+                var obj = files[SHARED_FOLDERS_TEMP][id] = JSON.parse(JSON.stringify(data));
+                obj.legacy = reason !== "PASSWORD_CHANGE";
+            }
+            var paths = exp.findFile(Number(id));
+            exp.delete(paths, null, true);
+            delete files[SHARED_FOLDERS][id];
+        };
+
+        // FILES DATA
+        var spliceFileData = function (id) {
+            if (readOnly) { return; }
+            delete files[FILES_DATA][id];
+        };
+
+        // Find files in FILES_DATA that are not anymore in the drive, and remove them from
+        // FILES_DATA.
+        exp.checkDeletedFiles = function (cb) {
+            if (!loggedIn && !config.testMode) { return void cb(); }
+            if (readOnly) { return void cb('EFORBIDDEN'); }
+
+            var filesList = exp.getFiles([ROOT, 'hrefArray', TRASH]);
+            var toClean = [];
+            exp.getFiles([FILES_DATA, SHARED_FOLDERS, STATIC_DATA]).forEach(function (id) {
+                if (filesList.indexOf(id) === -1) {
+                    var fd = exp.isSharedFolder(id) ? files[SHARED_FOLDERS][id] : exp.getFileData(id);
+                    var channelId = fd.channel;
+                    if (fd.lastVersion) { toClean.push(Hash.hrefToHexChannelId(fd.lastVersion)); }
+                    if (fd.rtChannel) { toClean.push(fd.rtChannel); }
+                    if (channelId) { toClean.push(channelId); }
+                    if (exp.isSharedFolder(id)) {
+                        delete files[SHARED_FOLDERS][id];
+                        if (config.removeProxy) { config.removeProxy(id); }
+                    } else if (files[STATIC_DATA][id]) {
+                        delete files[STATIC_DATA][id];
+                    } else {
+                        spliceFileData(id);
+                    }
+                }
+            });
+            if (!toClean.length) { return void cb(); }
+            cb(null, toClean);
+        };
+        var deleteHrefs = function (ids) {
+            if (readOnly) { return; }
+            ids.forEach(function (obj) {
+                var idx = files[obj.root].indexOf(obj.id);
+                files[obj.root].splice(idx, 1);
+            });
+        };
+        var deleteMultipleTrashRoot = function (roots) {
+            if (readOnly) { return; }
+            roots.forEach(function (obj) {
+                var idx = files[TRASH][obj.name].indexOf(obj.el);
+                files[TRASH][obj.name].splice(idx, 1);
+            });
+        };
+        exp.deleteMultiplePermanently = function (paths, nocheck, cb) {
+            if (readOnly) { return void cb('EFORBIDDEN'); }
+
+            var allFilesPaths = paths.filter(function(x) { return exp.isPathIn(x, [FILES_DATA]); });
+
+            if (!loggedIn && !config.testMode) {
+                allFilesPaths.forEach(function (path) {
+                    var id = path[1];
+                    if (!id) { return; }
+                    spliceFileData(id);
+                });
+                return void cb();
+            }
+
+            var hrefPaths = paths.filter(function(x) { return exp.isPathIn(x, ['hrefArray']); });
+            var rootPaths = paths.filter(function(x) { return exp.isPathIn(x, [ROOT]); });
+            var trashPaths = paths.filter(function(x) { return exp.isPathIn(x, [TRASH]); });
+
+            var ids = [];
+            hrefPaths.forEach(function (path) {
+                var id = exp.find(path);
+                ids.push({
+                    root: path[0],
+                    id: id
+                });
+            });
+            deleteHrefs(ids);
+
+            rootPaths.forEach(function (path) {
+                var parentPath = path.slice();
+                var key = parentPath.pop();
+                var parentEl = exp.find(parentPath);
+                delete parentEl[key];
+            });
+
+            var trashRoot = [];
+            trashPaths.forEach(function (path) {
+                var parentPath = path.slice();
+                var key = parentPath.pop();
+                var parentEl = exp.find(parentPath);
+                // Trash root: we have array here, we can't just splice with the path otherwise we might break the path
+                // of another element in the loop
+                if (path.length === 4) {
+                    trashRoot.push({
+                        name: path[1],
+                        el: parentEl
+                    });
+                    return;
+                }
+                // Trash but not root: it's just a tree so remove the key
+                delete parentEl[key];
+            });
+            deleteMultipleTrashRoot(trashRoot);
+
+            // In some cases, we want to remove pads from a location without removing them from
+            // FILES_DATA (replaceHref)
+            if (!nocheck) { exp.checkDeletedFiles(cb); }
+            else { cb(); }
+        };
+
+        // Move
+
+        // From another drive
+        exp.copyFromOtherDrive = function (path, element, data, key) {
+            if (readOnly) { return; }
+            // Copy files data
+            // We have to remove pads that are already in the current proxy to make sure
+            // we won't create duplicates
+
+            var toRemove = [];
+            Object.keys(data).forEach(function (id) {
+                id = Number(id);
+                // Find and maybe update existing pads with the same channel id
+                var d = data[id];
+                // If we were given a static link, copy to STATIC_DATA
+                if (d.static) {
+                    delete d.static;
+                    files[STATIC_DATA][id] = d;
+                    return;
+                }
+                // If we were given an edit link, encrypt its value if needed
+                if (d.href) { d.href = exp.cryptor.encrypt(d.href); }
+                var found = false;
+                for (var i in files[FILES_DATA]) {
+                    if (files[FILES_DATA][i].channel === d.channel) {
+                        // Update href?
+                        if (!files[FILES_DATA][i].href) {
+                            files[FILES_DATA][i].href = d.href;
+                        }
+                        found = true;
+                        break;
+                    }
+                }
+                if (found) {
+                    toRemove.push(id);
+                    return;
+                }
+                files[FILES_DATA][id] = d;
+            });
+
+            // Remove existing pads from the "element" variable
+            if (exp.isFile(element) && toRemove.indexOf(element) !== -1) {
+                exp.log(Messages.sharedFolders_duplicate);
+                return;
+            } else if (exp.isFolder(element)) {
+                var _removeExisting = function (root) {
+                    for (var k in root) {
+                        if (exp.isFile(root[k])) {
+                            if (toRemove.indexOf(root[k]) !== -1) {
+                                exp.log(Messages.sharedFolders_duplicate);
+                                delete root[k];
+                            }
+                        } else if (exp.isFolder(root[k])) {
+                            _removeExisting(root[k]);
+                        }
+                    }
+                };
+                _removeExisting(element);
+            }
+
+
+            // Copy file or folder
+            var newParent = exp.find(path);
+            var tempName = exp.isFile(element) ? Hash.createChannelId() : key;
+            var newName = exp.getAvailableName(newParent, tempName);
+            if (Array.isArray(newParent)) {
+                newParent.push(element);
+                return;
+            }
+            newParent[newName] = element;
+        };
+
+        // From the same drive
+        var pushToTrash = function (name, element, path) {
+            if (readOnly) { return; }
+
+            var trash = files[TRASH];
+            if (typeof(trash[name]) === "undefined") { trash[name] = []; }
+            var trashArray = trash[name];
+            var trashElement = {
+                element: element,
+                path: path
+            };
+            trashArray.push(trashElement);
+        };
+        exp.copyElement = function (elementPath, newParentPath) {
+            if (readOnly) { return; }
+            if (exp.comparePath(elementPath, newParentPath)) { return; } // Nothing to do...
+            var element = exp.find(elementPath);
+            var newParent = exp.find(newParentPath);
+
+            // Move to Trash
+            if (exp.isPathIn(newParentPath, [TRASH])) {
+                if (!elementPath || elementPath.length < 2 || elementPath[0] === TRASH) {
+                    debug("Can't move an element from the trash to the trash: ", elementPath);
+                    return;
+                }
+                var key = elementPath[elementPath.length - 1];
+                var elName = exp.isPathIn(elementPath, ['hrefArray']) ? exp.getTitle(element) : key;
+                var parentPath = elementPath.slice();
+                parentPath.pop();
+                pushToTrash(elName, element, parentPath);
+                return true;
+            }
+            // Move to hrefArray
+            if (exp.isPathIn(newParentPath, ['hrefArray'])) {
+                if (exp.isFolder(element)) {
+                    exp.log(Messages.fo_moveUnsortedError);
+                    return;
+                } else {
+                    if (elementPath[0] === newParentPath[0]) { return; }
+                    var fileRoot = newParentPath[0];
+                    if (files[fileRoot].indexOf(element) === -1) {
+                        files[fileRoot].push(element);
+                    }
+                    return true;
+                }
+            }
+            // Move to root
+            var newName = exp.isFile(element) ?
+                            exp.getAvailableName(newParent, Hash.createChannelId()) :
+                            exp.isInTrashRoot(elementPath) ?
+                              elementPath[1] : elementPath.pop();
+
+            if (typeof(newParent[newName]) !== "undefined") {
+                exp.log(Messages.fo_unavailableName);
+                return;
+            }
+            newParent[newName] = element;
+            return true;
+        };
+
+        // FORGET (move with href not path)
+        exp.forget = function (href) {
+            if (readOnly) { return; }
+
+            var id = exp.getIdFromHref(href);
+            if (!id) { return; }
+            if (!loggedIn && !config.testMode) {
+                // delete permanently
+                spliceFileData(id);
+                return true;
+            }
+            var paths = exp.findFile(id);
+            exp.move(paths, [TRASH]);
+            return true;
+        };
+
+        // REPLACE
+        // If all the occurences of an href are in the trash, remove them and add the file in root.
+        // This is use with setPadTitle when we open a stronger version of a deleted pad
+        exp.restoreHref = function (href) {
+            if (readOnly) { return; }
+
+            var idO = exp.getIdFromHref(href);
+
+            if (!idO || !exp.isFile(idO)) { return; }
+
+            var paths = exp.findFile(idO);
+
+            // Remove all the occurences in the trash
+            // If all the occurences are in the trash or no occurence, add the pad to root
+            var allInTrash = true;
+            paths.forEach(function (p) {
+                if (p[0] === TRASH) {
+                    exp.delete(p, null, true); // 3rd parameter means skip "checkDeletedFiles"
+                    return;
+                }
+                allInTrash = false;
+            });
+            if (allInTrash) {
+                exp.add(idO);
+            }
+        };
+
+        exp.add = function (id, path) {
+            if (readOnly) { return; }
+
+            if (!loggedIn && !config.testMode) { return; }
+            id = Number(id);
+            var data = files[FILES_DATA][id] || files[STATIC_DATA][id] || files[SHARED_FOLDERS][id];
+            if (!data || typeof(data) !== "object") { return; }
+            var newPath = path, parentEl;
+            if (path && !Array.isArray(path)) {
+                newPath = decodeURIComponent(path).split(',');
+            }
+            // Add to href array
+            if (path && exp.isPathIn(newPath, ['hrefArray'])) {
+                parentEl = exp.find(newPath);
+                parentEl.push(id);
+                return;
+            }
+            // Add to root if no path
+            var filesList = exp.getFiles([ROOT, TRASH, 'hrefArray']);
+            if (filesList.indexOf(id) === -1 && !newPath) {
+                newPath = [ROOT];
+            }
+            // Add to root
+            if (path && exp.isPathIn(newPath, [ROOT])) {
+                parentEl = exp.find(newPath);
+                if (parentEl) {
+                    var newName = exp.getAvailableName(parentEl, Hash.createChannelId());
+                    parentEl[newName] = id;
+                    return;
+                } else {
+                    parentEl = exp.find([ROOT]);
+                    newPath.slice(1).forEach(function (folderName) {
+                        parentEl = parentEl[folderName] = parentEl[folderName] || {};
+                    });
+                    parentEl[Hash.createChannelId()] = id;
+                }
+            }
+        };
+
+        exp.setFolderData = function (path, key, value, cb) {
+            if (readOnly) { return; }
+
+            var folder = exp.find(path);
+            if (!exp.isFolder(folder) || exp.isSharedFolder(folder)) { return; }
+            if (!exp.hasFolderData(folder)) {
+                var hashKey = "000" + Hash.createChannelId().slice(0, -3);
+                folder[hashKey] = {
+                    metadata: true
+                };
+            }
+            exp.getFolderData(folder)[key] = value;
+            cb();
+        };
+
+        /**
+         * INTEGRITY CHECK
+         */
+
+        var onSync = function (next) {
+            if (exp.rt) {
+                exp.rt.sync();
+                Realtime.whenRealtimeSyncs(exp.rt, next);
+            } else {
+                window.setTimeout(next, 1000);
+            }
+        };
+
+        exp.migrateReadOnly = function (cb) {
+            if (readOnly || !config.editKey) { return void cb({error: 'EFORBIDDEN'}); }
+            if (files.version >= 2) { return void cb(); } // Already migrated, nothing to do
+            files.migrateRo = 1;
+            var next = function () {
+                var copy = JSON.parse(JSON.stringify(files));
+                exp.reencrypt(config.editKey, config.editKey, copy);
+                setTimeout(function () {
+                    if (files.version >= 2) {
+                        // Already migrated by another user while we were re-encrypting
+                        return void cb();
+                    }
+                    Object.keys(copy).forEach(function (k) {
+                        files[k] = copy[k];
+                    });
+                    files.version = 2;
+                    delete files.migrateRo;
+
+                    onSync(cb);
+                }, 1000);
+            };
+            onSync(next);
+        };
+
+        exp.migrate = function (cb) {
+            if (readOnly) { return void cb(); }
+            // Make sure unsorted doesn't exist anymore
+            // Note: Unsorted only works with the old structure where pads are href
+            // It should be called before the migration code
+            var fixUnsorted = function () {
+                if (!files[UNSORTED] || !files[OLD_FILES_DATA]) { return; }
+                debug("UNSORTED still exists in the object, removing it...");
+                var us = files[UNSORTED];
+                if (us.length === 0) {
+                    delete files[UNSORTED];
+                    return;
+                }
+                us.forEach(function (el) {
+                    if (typeof el !== "string") {
+                        return;
+                    }
+                    var data = files[OLD_FILES_DATA].filter(function (x) {
+                        return x.href === el;
+                    });
+                    if (data.length === 0) {
+                        files[OLD_FILES_DATA].push({
+                            href: el
+                        });
+                    }
+                    return;
+                });
+                delete files[UNSORTED];
+            };
+            // mergeDrive...
+            var migrateToNewFormat = function (todo) {
+                if (!files[OLD_FILES_DATA]) {
+                    return void todo();
+                }
+                try {
+                    debug("Migrating file system...");
+                    files.migrate = 1;
+                    var next = function () {
+                        var oldData = files[OLD_FILES_DATA].slice();
+                        if (!files[FILES_DATA]) {
+                            files[FILES_DATA] = {};
+                        }
+                        var newData = files[FILES_DATA];
+                        //var oldFiles = oldData.map(function (o) { return o.href; });
+                        oldData.forEach(function (obj) {
+                            if (!obj || !obj.href) { return; }
+                            var href = obj.href;
+                            var id = Util.createRandomInteger();
+                            var paths = exp.findFile(href);
+                            var data = obj;
+                            var key = Hash.createChannelId();
+                            if (data) {
+                                newData[id] = data;
+                            } else {
+                                newData[id] = {href: href};
+                            }
+                            paths.forEach(function (p) {
+                                var parentPath = p.slice();
+                                var okey = parentPath.pop(); // get the parent
+                                var parent = exp.find(parentPath);
+                                if (exp.isInTrashRoot(p)) {
+                                    parent.element = id;
+                                    newData[id].filename = p[1];
+                                    return;
+                                }
+                                if (exp.isPathIn(p, ['hrefArray'])) {
+                                    parent[okey] = id;
+                                    return;
+                                }
+                                // else root or trash (not trashroot)
+                                parent[key] = id;
+                                newData[id].filename = okey;
+                                delete parent[okey];
+                            });
+                        });
+                        delete files[OLD_FILES_DATA];
+                        delete files.migrate;
+                        todo();
+                    };
+                    onSync(next);
+                } catch(e) {
+                    console.error(e);
+                    todo();
+                }
+            };
+
+            fixUnsorted();
+            migrateToNewFormat(cb);
+        };
+
+        exp.fixFiles = function (silent) {
+            // Explore the tree and check that everything is correct:
+            //  * 'root', 'trash', 'unsorted' and 'filesData' exist and are objects
+            //  * ROOT: Folders are objects, files are href
+            //  * TRASH: Trash root contains only arrays, each element of the array is an object {element:.., path:..}
+            //  * OLD_FILES_DATA: - Data (title, cdate, adte) are stored in filesData. filesData contains only href keys linking to object with title, cdate, adate.
+            //                - Dates (adate, cdate) can be parsed/formatted
+            //                - All files in filesData should be either in 'root', 'trash' or 'unsorted'. If that's not the case, copy the fily to 'unsorted'
+            //  * TEMPLATE: Contains only files (href), and does not contains files that are in ROOT
+
+            // We can't fix anything in read-only mode: abort
+            if (readOnly) { return; }
+
+            if (silent) { debug = function () {}; }
+
+            var t0 = +new Date();
+            debug("Cleaning file system...");
+
+            var before = JSON.stringify(files);
+
+            var fixRoot = function (elem) {
+                if (typeof(files[ROOT]) !== "object") { debug("ROOT was not an object"); files[ROOT] = {}; }
+                var element = elem || files[ROOT];
+                if (!element) { return console.error("Invalid element in root"); }
+                var nbMetadataFolders = 0;
+                // caching this variables saves a lot of hashmap lookups in this loop
+                var static_data = files[STATIC_DATA];
+                var files_data = files[FILES_DATA];
+                var element_el;
+                for (var el in element) {
+                    element_el = element[el];
+                    if (element_el === null) {
+                        console.error('element[%s] is null', el);
+                        delete element[el];
+                        continue;
+                    }
+                    if (exp.isFolderData(element_el)) {
+                        if (nbMetadataFolders !== 0) {
+                            debug("Multiple metadata files in folder");
+                            delete element[el];
+                        }
+                        nbMetadataFolders++;
+                        continue;
+                    }
+                    if (!exp.isFile(element_el, true) && !exp.isFolder(element_el)) {
+                        debug("An element in ROOT was not a folder nor a file. ", element_el);
+                        delete element[el];
+                        continue;
+                    }
+                    if (exp.isFolder(element_el)) {
+                        fixRoot(element_el);
+                        continue;
+                    }
+                    if (typeof element_el === "string") {
+                        // We have an old file (href) which is not in filesData: add it
+                        var id = Util.createRandomInteger();
+                        var key = Hash.createChannelId();
+                        files_data[id] = {
+                            href: exp.cryptor.encrypt(element_el),
+                            filename: el
+                        };
+                        element[key] = id;
+                        delete element[el];
+                    }
+                    if (typeof element_el === "number") {
+                        var data = files_data[element_el] || static_data[element_el];
+                        if (!data) {
+                            debug("An element in ROOT doesn't have associated data", element_el, el);
+                            delete element[el];
+                        }
+                    }
+                }
+            };
+            var fixTrashRoot = function () {
+                if (sharedFolder) { return; }
+                if (typeof(files[TRASH]) !== "object") { debug("TRASH was not an object"); files[TRASH] = {}; }
+                var tr = files[TRASH];
+                var toClean;
+                var addToClean = function (obj, idx, el) {
+                    if (typeof(obj) !== "object") { toClean.push(idx); return; }
+
+                    // shared folders have their own userObject
+                    if (exp.isSharedFolder(obj.element)) { return; }
+
+                    if (!exp.isFile(obj.element, true) &&
+                        !exp.isFolder(obj.element)) { toClean.push(idx); return; }
+                    if (!Array.isArray(obj.path)) { toClean.push(idx); return; }
+                    if (typeof obj.element === "string") {
+                        // We have an old file (href) which is not in filesData: add it
+                        var id = Util.createRandomInteger();
+                        files[FILES_DATA][id] = {
+                            href: exp.cryptor.encrypt(obj.element),
+                            filename: el
+                        };
+                        obj.element = id;
+                    }
+                    if (exp.isFolder(obj.element)) { fixRoot(obj.element); }
+                    if (typeof obj.element === "number") {
+                        var data = files[FILES_DATA][obj.element];
+                        if (!data) {
+                            debug("An element in TRASH doesn't have associated data", obj.element, el);
+                            toClean.push(idx);
+                        }
+                    }
+
+                };
+                for (var el in tr) {
+                    if (!Array.isArray(tr[el])) {
+                        debug("An element in TRASH root is not an array. ", tr[el]);
+                        delete tr[el];
+                    } else if (tr[el].length === 0) {
+                        debug("Empty array in TRASH root. ", tr[el]);
+                        delete tr[el];
+                    } else {
+                        toClean = [];
+                        for (var j=0; j<tr[el].length; j++) {
+                            addToClean(tr[el][j], j, el);
+                        }
+                        for (var i = toClean.length-1; i>=0; i--) {
+                            tr[el].splice(toClean[i], 1);
+                        }
+                    }
+                }
+            };
+            var fixTemplate = function () {
+                if (sharedFolder) { return; }
+                if (!Array.isArray(files[TEMPLATE])) { debug("TEMPLATE was not an array"); files[TEMPLATE] = []; }
+                var dedup = Util.deduplicateString(files[TEMPLATE]);
+                if (dedup.length !== files[TEMPLATE].length) {
+                    files[TEMPLATE] = dedup;
+                }
+                var us = files[TEMPLATE];
+                var rootFiles = exp.getFiles([ROOT]);
+                var toClean = [];
+                us.forEach(function (el, idx) {
+                    if (!exp.isFile(el, true) || rootFiles.indexOf(el) !== -1) {
+                        toClean.push(el);
+                        return;
+                    }
+                    if (typeof el === "string") {
+                        // We have an old file (href) which is not in filesData: add it
+                        var id = Util.createRandomInteger();
+                        files[FILES_DATA][id] = {
+                            href: exp.cryptor.encrypt(el)
+                        };
+                        us[idx] = id;
+                        return;
+                    }
+                    if (typeof el === "number") {
+                        var data = files[FILES_DATA][el];
+                        if (!data) {
+                            debug("An element in TEMPLATE doesn't have associated data", el);
+                            toClean.push(el);
+                        }
+                    }
+                });
+                toClean.forEach(function (el) {
+                    var idx = us.indexOf(el);
+                    if (idx !== -1) {
+                        us.splice(idx, 1);
+                    }
+                });
+            };
+            var fixFilesData = function () {
+                if (typeof files[FILES_DATA] !== "object") { debug("FILES_DATA was not an object"); files[FILES_DATA] = {}; }
+                var fd = files[FILES_DATA];
+                var rootFiles = exp.getFiles([ROOT, TRASH, 'hrefArray']);
+                var root = exp.find([ROOT]);
+                var toClean = [];
+                for (var id in fd) {
+                    if (String(id) !== String(Number(id))) {
+                        debug("Invalid file ID in filesData.", id);
+                        toClean.push(id);
+                        continue;
+                    }
+                    id = Number(id);
+                    var el = fd[id];
+
+                    // Clean corrupted data
+                    if (!el || typeof(el) !== "object") {
+                        debug("An element in filesData was not an object.", el);
+                        toClean.push(id);
+                        continue;
+                    }
+                    // Clean missing href
+                    if (!el.href && !el.roHref) {
+                        debug("Removing an element in filesData with a missing href.", el);
+                        toClean.push(id);
+                        continue;
+                    }
+
+                    var decryptedHref;
+                    try {
+                        decryptedHref = el.href && ((el.href.indexOf('#') !== -1) ? el.href : exp.cryptor.decrypt(el.href));
+                    } catch (e) {}
+
+                    if (decryptedHref && decryptedHref.indexOf('#') === -1) {
+                        // If we can't decrypt the href, it means we don't have the correct secondaryKey and we're in readOnly mode:
+                        // abort now, we won't be able to fix anything anyway
+                        continue;
+                    }
+
+                    var parsed = Hash.parsePadUrl(decryptedHref || el.roHref);
+                    var secret;
+
+                    // Clean invalid hash
+                    if (!parsed.hash) {
+                        debug("Removing an element in filesData with a invalid href.", el);
+                        toClean.push(id);
+                        continue;
+                    }
+                    // Clean invalid type
+                    if (!parsed.type) {
+                        debug("Removing an element in filesData with a invalid type.", el);
+                        toClean.push(id);
+                        continue;
+                    }
+
+                    // If we have an edit link, check the view link
+                    if (decryptedHref && parsed.hashData.type === "pad" && parsed.hashData.version) {
+                        if (parsed.hashData.mode === "view") {
+                            el.roHref = decryptedHref;
+                            delete el.href;
+                        } else if (!el.roHref) {
+                            secret = Hash.getSecrets(parsed.type, parsed.hash, el.password);
+                            el.roHref = '/' + parsed.type + '/#' + Hash.getViewHashFromKeys(secret);
+                        } else {
+                            var parsed2 = Hash.parsePadUrl(el.roHref);
+                            if (!parsed2.hash || !parsed2.type) {
+                                secret = Hash.getSecrets(parsed.type, parsed.hash, el.password);
+                                el.roHref = '/' + parsed.type + '/#' + Hash.getViewHashFromKeys(secret);
+                            }
+                        }
+                    }
+                    // v0 hashes don't support read-only
+                    if (parsed.hashData.version === 0) {
+                        delete el.roHref;
+                    }
+
+                    // Fix href
+                    if (decryptedHref && decryptedHref.slice(0,1) !== '/') {
+                        el.href = exp.cryptor.encrypt(Hash.getRelativeHref(decryptedHref));
+                    }
+                    // Fix creation time
+                    if (!el.ctime) { el.ctime = el.atime; }
+                    // Fix title
+                    if (!el.title) { el.title = exp.getDefaultName(parsed); }
+                    // Fix channel
+                    if (!el.channel) {
+                        try {
+                            if (!secret) {
+                                secret = Hash.getSecrets(parsed.type, parsed.hash, el.password);
+                            }
+                            el.channel = secret.channel;
+                            console.log(el);
+                            debug('Adding missing channel in filesData ', el.channel);
+                        } catch (e) {
+                            console.error(e);
+                        }
+                    }
+                    if (!Hash.isValidChannel(el.channel)) {
+                        // FIXME delete channel? replace with parsed.channel?
+                        console.error('Remove invalid channel', el.channel, el);
+                        // toClean.push(id);
+                    }
+
+                    if ((loggedIn || config.testMode) && rootFiles.indexOf(id) === -1) {
+                        debug("An element in filesData was not in ROOT, TEMPLATE or TRASH.", id, el);
+                        var newName = Hash.createChannelId();
+                        root[newName] = id;
+                        continue;
+                    }
+                }
+                toClean.forEach(function (id) {
+                    spliceFileData(id);
+                });
+                // make sure that links are displayed at least once in your drive if you are going to keep them
+                var sd = files[STATIC_DATA];
+                var toCleanSD = [];
+                for (var id2 in sd) {
+                    id2 = Number(id2);
+                    var el2 = sd[id2];
+                    if (!el2 || typeof(el2) !== "object" || !el2.href) {
+                        toCleanSD.push(id2);
+                        continue;
+                    }
+                    if ((loggedIn || config.testMode) && rootFiles.indexOf(id2) === -1) {
+                        toCleanSD.push(id2);
+                        continue;
+                    }
+                }
+                var spliceSD = function (id) {
+                    if (readOnly) { return; }
+                    delete files[STATIC_DATA][id];
+                };
+                toCleanSD.forEach(spliceSD);
+            };
+            var fixSharedFolders = function () {
+                if (sharedFolder) { return; }
+                if (typeof(files[SHARED_FOLDERS]) !== "object") { debug("SHARED_FOLDER was not an object"); files[SHARED_FOLDERS] = {}; }
+                var sf = files[SHARED_FOLDERS];
+                var rootFiles = exp.getFiles([ROOT, TRASH]);
+                var root = exp.find([ROOT]);
+                var parsed /*, secret */, el;
+                for (var id in sf) {
+                    el = sf[id];
+                    id = Number(id);
+
+                    var href;
+                    try {
+                        href = el.href && ((el.href.indexOf('#') !== -1) ? el.href : exp.cryptor.decrypt(el.href));
+                    } catch (e) {}
+
+                    // Fix undefined hash
+                    parsed = Hash.parsePadUrl(href || el.roHref);
+                    if (!parsed || !parsed.hash || parsed.hash === "undefined") {
+                        delete sf[id];
+                        continue;
+                    }
+
+                    // Fix shared folder not displayed in root
+                    if (rootFiles.indexOf(id) === -1) {
+                        console.log('missing' + id);
+                        var newName = Hash.createChannelId();
+                        root[newName] = id;
+                    }
+                }
+            };
+            var fixSharedFoldersTemp = function () {
+                if (sharedFolder) { return; }
+                if (typeof(files[SHARED_FOLDERS_TEMP]) !== "object") {
+                    debug("SHARED_FOLDER_TEMP was not an object");
+                    files[SHARED_FOLDERS_TEMP] = {};
+                }
+                // Remove deprecated shared folder if they were already added back
+                var sft = files[SHARED_FOLDERS_TEMP];
+                var sf = files[SHARED_FOLDERS];
+                for (var id in sft) {
+                    if (sf[id]) {
+                        delete sft[id];
+                    }
+                }
+            };
+            var fixStaticData = function () {
+                if (!Util.isObject(files[STATIC_DATA])) {
+                    debug("STATIC_DATA was not an object");
+                    files[STATIC_DATA] = {};
+                }
+            };
+
+
+            var fixDrive = function () {
+                Object.keys(files).forEach(function (key) {
+                    if (key.slice(0,1) === '/') { delete files[key]; }
+                });
+            };
+
+            fixStaticData();
+            fixRoot();
+            fixTrashRoot();
+            fixTemplate();
+            fixFilesData();
+            fixDrive();
+            fixSharedFolders();
+            fixSharedFoldersTemp();
+
+            var ms = (+new Date() - t0) + 'ms';
+            if (JSON.stringify(files) !== before) {
+                debug("Your file system was corrupted. It has been cleaned so that the pads you visit can be stored safely.", ms);
+                return;
+            }
+            debug("File system was clean.", ms);
+        };
+
+        return exp;
+    };
+
+    return module;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        undefined,
+        require('./common-util'),
+        require('./common-hash'),
+        require('./common-realtime'),
+        undefined
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/customize/application_config.js',
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/common-realtime.js',
+        '/customize/messages.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/common/user-object.js b/src/common/user-object.js
new file mode 100644
index 000000000..ee7abc477
--- /dev/null
+++ b/src/common/user-object.js
@@ -0,0 +1,997 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (AppConfig = {}, Util, Hash,
+                Constants, UOSetter, Crypto, Messages = {}) => {
+    let window = globalThis;
+    var module = {};
+
+    module.setCustomize = (data) => {
+        Messages = data.Messages;
+        AppConfig = data.AppConfig;
+        UOSetter.setCustomize(data);
+    };
+
+    var ROOT = module.ROOT = "root";
+    var UNSORTED = module.UNSORTED = "unsorted";
+    var TRASH = module.TRASH = "trash";
+    var TEMPLATE = module.TEMPLATE = "template";
+    var SHARED_FOLDERS = module.SHARED_FOLDERS = "sharedFolders";
+    var SHARED_FOLDERS_TEMP = module.SHARED_FOLDERS_TEMP = "sharedFoldersTemp"; // Maybe deleted or new password
+    var FILES_DATA = module.FILES_DATA = Constants.storageKey;
+    var OLD_FILES_DATA = module.OLD_FILES_DATA = Constants.oldStorageKey;
+    var STATIC_DATA = module.STATIC_DATA = 'static';
+
+    // Create untitled documents when no name is given
+    var getLocaleDate = function () {
+        if (window.Intl && window.Intl.DateTimeFormat) {
+            var options = {weekday: "short", year: "numeric", month: "long", day: "numeric"};
+            return new window.Intl.DateTimeFormat(undefined, options).format(new Date());
+        }
+        return new Date().toString().split(' ').slice(0,4).join(' ');
+    };
+    module.getDefaultName = function (parsed) {
+        var type = parsed.type;
+        var name = (Messages.type)[type] + ' - ' + getLocaleDate();
+        return name;
+    };
+
+    var createCryptor = module.createCryptor = function (key) {
+        var cryptor = {};
+        if (!key) {
+            cryptor.encrypt = function (x) { return x; };
+            cryptor.decrypt = function (x) { return x; };
+            return cryptor;
+        }
+        try {
+            var c = Crypto.createEncryptor(key);
+            cryptor.encrypt = function (href) {
+                // Never encrypt blob href, they are always read-only
+                try {
+                    if (href.slice(0,7) === '/file/#') { return href; }
+                    return c.encrypt(href);
+                } catch (e) {
+                    return;
+                }
+            };
+            cryptor.decrypt = function (msg) {
+                try {
+                    return c.decrypt(msg);
+                } catch (e) {
+                    return;
+                }
+            };
+        } catch (e) {
+            console.error(e);
+        }
+        return cryptor;
+    };
+    module.getHref = function (pad, cryptor) {
+        if (pad.href && pad.href.indexOf('#') !== -1) {
+            // Href exists and is not encrypted: return href
+            return pad.href;
+        }
+        if (pad.href) {
+            // Href exists and is encrypted
+            var d = cryptor.decrypt(pad.href);
+            // If we can decrypt, return the decrypted value, otherwise continue and return roHref
+            if (d && d.indexOf('#') !== -1) {
+                return d;
+            }
+        }
+        return pad.roHref;
+    };
+
+    module.reencrypt = function (oldKey, newKey, obj) {
+        if (!obj) { return void console.error("Nothing to reencrypt"); }
+        var oldCryptor = createCryptor(oldKey);
+        var newCryptor = createCryptor(newKey);
+        Object.keys(obj[FILES_DATA]).forEach(function (id) {
+            var data = obj[FILES_DATA][id] || {};
+            // If this pad has a visible href, encrypt it
+            // "&& data.roHref" is here to make sure this is not a "file"
+            if (data.href && data.roHref && !data.fileType) {
+                var _href = (data.href && data.href.indexOf('#') === -1) ? oldCryptor.decrypt(data.href) : data.href;
+                if (!_href) { return; }
+                data.href = newCryptor.encrypt(_href);
+            }
+        });
+        Object.keys(obj[SHARED_FOLDERS] || {}).forEach(function (id) {
+            var data = obj[SHARED_FOLDERS][id] || {};
+            // If this folder has a visible href, encrypt it
+            if (data.href) {
+                var _href = (data.href && data.href.indexOf('#') === -1) ? oldCryptor.decrypt(data.href) : data.href;
+                if (!_href) { return; }
+                data.href = newCryptor.encrypt(_href);
+            }
+        });
+        Object.keys(obj[SHARED_FOLDERS_TEMP] || {}).forEach(function (id) {
+            var data = obj[SHARED_FOLDERS_TEMP][id] || {};
+            // If this folder has a visible href, encrypt it
+            if (data.href) {
+                var _href = (data.href && data.href.indexOf('#') === -1) ? oldCryptor.decrypt(data.href) : data.href;
+                if (!_href) { return; }
+                data.href = newCryptor.encrypt(_href);
+            }
+        });
+    };
+
+    module.init = function (files, config) {
+        var exp = {};
+
+        exp.cryptor = createCryptor(config.editKey);
+
+        exp.setReadOnly = function (state, key) {
+            config.editKey = key;
+            exp.cryptor = createCryptor(key);
+            exp.cryptor.k = Math.random();
+            exp.readOnly = state;
+            if (exp._setReadOnly) {
+                // Change outer
+                exp._setReadOnly(state);
+            }
+        };
+        exp.readOnly = config.readOnly;
+        exp.reencrypt = module.reencrypt;
+
+        exp.getDefaultName = module.getDefaultName;
+
+        var sframeChan = config.sframeChan;
+
+        var NEW_FOLDER_NAME = Messages.fm_newFolder || 'New folder';
+        var NEW_FILE_NAME = Messages.fm_newFile || 'New file';
+
+        exp.ROOT = ROOT;
+        exp.STATIC_DATA = STATIC_DATA;
+        exp.UNSORTED = UNSORTED;
+        exp.TRASH = TRASH;
+        exp.TEMPLATE = TEMPLATE;
+        exp.SHARED_FOLDERS = SHARED_FOLDERS;
+        exp.SHARED_FOLDERS_TEMP = SHARED_FOLDERS_TEMP;
+        exp.FILES_DATA = FILES_DATA;
+        exp.OLD_FILES_DATA = OLD_FILES_DATA;
+
+        var sharedFolder = exp.sharedFolder = config.sharedFolder;
+        exp.id = config.id;
+
+        // Logging
+        var logging = function () {
+            console.debug.apply(console, arguments);
+        };
+        var log = exp.log = config.log || logging;
+        var logError = config.logError || logging;
+        var debug = exp.debug = config.debug || logging;
+
+        exp.fixFiles = function () {}; // Overriden by UOSetter
+
+        var error = exp.error = function() {
+            if (sframeChan) {
+                return void sframeChan.query("Q_DRIVE_USEROBJECT", {
+                    cmd: "fixFiles",
+                    data: {}
+                }, function () {});
+            } else if (typeof (exp.fixFiles) === "function") {
+                exp.fixFiles();
+            }
+            console.error.apply(console, arguments);
+            exp.fixFiles();
+        };
+
+        if (config.outer) {
+            // Extend "exp" with methods used only outside of the iframe (requires access to store)
+            UOSetter.init(config, exp, files);
+        }
+
+
+        /*
+         * UTILS
+         */
+
+        exp.getStructure = function () {
+            var a = {};
+            a[ROOT] = {};
+            a[TRASH] = {};
+            a[FILES_DATA] = {};
+            a[TEMPLATE] = [];
+            a[SHARED_FOLDERS] = {};
+            return a;
+        };
+
+        var getHref = exp.getHref = function (pad) {
+            return module.getHref(pad, exp.cryptor);
+        };
+
+        var type = function (dat) {
+            return dat === null?  'null': Array.isArray(dat)?'array': typeof(dat);
+        };
+        exp.isValidDrive = function (obj) {
+            var base = exp.getStructure();
+            return typeof (obj) === "object" &&
+                    Object.keys(base).every(function (key) {
+                        return obj[key] && type(base[key]) === type(obj[key]);
+                    });
+        };
+
+        var getHrefArray = function () {
+            return [TEMPLATE];
+        };
+
+
+        var compareFiles = function (fileA, fileB) { return fileA === fileB; };
+
+        var isSharedFolder = exp.isSharedFolder = function (element) {
+            if (sharedFolder) { return false; } // No recursive shared folders
+            return Boolean(files[SHARED_FOLDERS] && files[SHARED_FOLDERS][element]);
+        };
+        var isFile = exp.isFile = function (element, allowStr) {
+            if (isSharedFolder(element)) { return false; }
+            return typeof(element) === "number" ||
+                    ((typeof(files[OLD_FILES_DATA]) !== "undefined" || allowStr)
+                        &&  typeof(element) === "string");
+        };
+        var isFolderData = exp.isFolderData = function (element) {
+            return typeof(element) === "object" && element.metadata === true;
+        };
+
+        exp.isReadOnlyFile = function (element) {
+            if (!isFile(element)) { return false; }
+            var data = exp.getFileData(element);
+            // undefined means this pad doesn't support read-only
+            if (!data.roHref) { return; }
+            return Boolean(data.roHref && !data.href);
+        };
+
+        exp.isStaticFile = function (element) {
+            return Boolean(files[STATIC_DATA] && files[STATIC_DATA][element]);
+        };
+
+        var isFolder = exp.isFolder = function (element) {
+            if (isFolderData(element)) { return false; }
+            return typeof(element) === "object" || isSharedFolder(element);
+        };
+        exp.isFolderEmpty = function (element) {
+            if (!isFolder(element)) { return false; }
+            // if the folder contains nothing, it's empty
+            if (Object.keys(element).length === 0) { return true; }
+            // or if it contains one thing and that thing is metadata
+            if (Object.keys(element).length === 1 && isFolderData(element[Object.keys(element)[0]])) { return true; }
+            return false;
+        };
+
+        exp.hasSubfolder = function (element, trashRoot) {
+            if (!isFolder(element)) { return false; }
+            var subfolder = 0;
+            var addSubfolder = function (el) {
+                subfolder += isFolder(el.element) ? 1 : 0;
+            };
+            for (var f in element) {
+                if (trashRoot) {
+                    if (Array.isArray(element[f])) {
+                        element[f].forEach(addSubfolder);
+                    }
+                } else {
+                    subfolder += isFolder(element[f]) ? 1 : 0;
+                }
+            }
+            return subfolder;
+        };
+
+        exp.hasFile = function (element, trashRoot) {
+            if (!isFolder(element)) { return false; }
+            var file = 0;
+            var addFile = function (el) {
+                file += isFile(el.element) ? 1 : 0;
+            };
+            for (var f in element) {
+                if (trashRoot) {
+                    if (Array.isArray(element[f])) {
+                        element[f].forEach(addFile);
+                    }
+                } else {
+                    file += isFile(element[f]) ? 1 : 0;
+                }
+            }
+            return file;
+        };
+
+        exp.hasFolderData = function (folder) {
+            for (var el in folder) {
+                if(isFolderData(folder[el])) {
+                    return true;
+                }
+            }
+        };
+
+        var hasSubSharedFolder = exp.hasSubSharedFolder = function (folder) {
+            for (var el in folder) {
+                if (isSharedFolder(folder[el])) {
+                    return true;
+                }
+                else if (isFolder(folder[el])) {
+                    if (hasSubSharedFolder(folder[el])) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+
+        // Get data from AllFiles (Cryptpad_RECENTPADS)
+        var getFileData = exp.getFileData = function (file, editable) {
+            if (!file) { return; }
+            var link;
+            try {
+                link = (files[STATIC_DATA] || {})[file];
+            } catch (err) {
+                console.error(err);
+            }
+            if (link) {
+                var _link = editable ? link : Util.clone(link);
+                if (!editable) { _link.static = true; }
+                return _link;
+            }
+            var data;
+            try {
+                data = files[FILES_DATA][file] || {};
+            } catch (err) {
+                console.error(err);
+                data = {};
+            }
+            if (!editable) {
+                data = JSON.parse(JSON.stringify(data));
+                if (data.href && data.href.indexOf('#') === -1) {
+                    // Encrypted href: decrypt it if we can, otherwise remove it
+                    if (config.editKey) {
+                        try {
+                            data.href = exp.cryptor.decrypt(data.href);
+                        } catch (e) {
+                            delete data.href;
+                        }
+                    } else {
+                        delete data.href;
+                    }
+                }
+            }
+            return data;
+        };
+
+        exp.getFolderData = function (folder) {
+            for (var el in folder) {
+                if(isFolderData(folder[el])) {
+                    return folder[el];
+                }
+            }
+            return {};
+        };
+
+        // Data from filesData
+        var getTitle = exp.getTitle = function (file, type) {
+            if (isSharedFolder(file)) {
+                return '??';
+            }
+            var data = getFileData(file);
+            if (!data) {
+                error("unable to retrieve data about the requested file: ", file, data);
+                return;
+            }
+            // handle links
+            if (data.static) { return data.name; }
+            if (!file || !(data.href || data.roHref)) {
+                error("getTitle called with a non-existing file id: ", file, data);
+                return;
+            }
+            if (type === 'title') { return data.title; }
+            if (type === 'name') { return data.filename; }
+            return data.filename || data.title || NEW_FILE_NAME;
+        };
+
+        // PATHS
+
+        var comparePath = exp.comparePath = function (a, b) {
+            if (!a || !b || !Array.isArray(a) || !Array.isArray(b)) { return false; }
+            if (a.length !== b.length) { return false; }
+            var result = true;
+            var i = a.length - 1;
+            while (result && i >= 0) {
+                result = a[i] === b[i];
+                i--;
+            }
+            return result;
+        };
+
+        var isSubpath = exp.isSubpath = function (path, parentPath) {
+            var pathA = parentPath.slice();
+            var pathB = path.slice(0, pathA.length);
+            return comparePath(pathA, pathB);
+        };
+
+        var isPathIn = exp.isPathIn = function (path, categories) {
+            if (!categories) { return; }
+            var idx = categories.indexOf('hrefArray');
+            if (idx !== -1) {
+                categories.splice(idx, 1);
+                categories = categories.concat(getHrefArray());
+            }
+            return categories.some(function (c) {
+                return Array.isArray(path) && path[0] === c;
+            });
+        };
+
+        var isInTrashRoot = exp.isInTrashRoot = function (path) {
+            return path[0] === TRASH && path.length === 4;
+        };
+
+
+        // FIND
+
+        var findElement = function (root, pathInput) {
+            if (!pathInput) {
+                error("Invalid path:\n", pathInput, "\nin root\n", root);
+                return;
+            }
+            if (pathInput.length === 0) { return root; }
+            var path = pathInput.slice();
+            var key = path.shift();
+            if (typeof root[key] === "undefined") {
+                debug("Unable to find the key '" + key + "' in the root object provided:", root);
+                return;
+            }
+            return findElement(root[key], path);
+        };
+
+        var find = exp.find = function (path) {
+            return findElement(files, path);
+        };
+
+
+        // GET FILES
+
+        var getFilesRecursively = exp.getFilesRecursively = function (root, arr) {
+            arr = arr || [];
+            for (var e in root) {
+                if (isFile(root[e]) || isSharedFolder(root[e])) {
+                    if(arr.indexOf(root[e]) === -1) { arr.push(root[e]); }
+                } else if (!isFolderData(root[e])) {
+                    getFilesRecursively(root[e], arr);
+                }
+            }
+            return arr;
+        };
+        var _getFiles = {};
+        _getFiles['array'] = function (cat) {
+            if (!files[cat]) { files[cat] = []; }
+            return files[cat].slice();
+        };
+        getHrefArray().forEach(function (c) {
+            _getFiles[c] = function () { return _getFiles['array'](c); };
+        });
+        _getFiles['hrefArray'] = function () {
+            var ret = [];
+            if (sharedFolder) { return ret; }
+            getHrefArray().forEach(function (c) {
+                ret = ret.concat(_getFiles[c]());
+            });
+            return Util.deduplicateString(ret);
+        };
+        _getFiles[ROOT] = function () {
+            var ret = [];
+            getFilesRecursively(files[ROOT], ret);
+            return ret;
+        };
+        _getFiles[TRASH] = function () {
+            var root = files[TRASH];
+            var ret = [];
+            var addFiles = function (el) {
+                if (isFile(el.element) || isSharedFolder(el.element)) {
+                    if(ret.indexOf(el.element) === -1) { ret.push(el.element); }
+                } else {
+                    getFilesRecursively(el.element, ret);
+                }
+            };
+            for (var e in root) {
+                if (!Array.isArray(root[e])) {
+                    error("Trash contains a non-array element");
+                    return;
+                }
+                root[e].forEach(addFiles);
+            }
+            return ret;
+        };
+        _getFiles[OLD_FILES_DATA] = function () {
+            var ret = [];
+            if (!files[OLD_FILES_DATA]) { return ret; }
+            files[OLD_FILES_DATA].forEach(function (el) {
+                if (el.href && ret.indexOf(el.href) === -1) {
+                    ret.push(el.href);
+                }
+            });
+            return ret;
+        };
+        _getFiles[STATIC_DATA] = function () {
+            var ret = [];
+            if (!files[STATIC_DATA]) { return ret; }
+            return Object.keys(files[STATIC_DATA]).map(Number).filter(Boolean);
+        };
+        _getFiles[FILES_DATA] = function () {
+            var ret = [];
+            if (!files[FILES_DATA]) { return ret; }
+            return Object.keys(files[FILES_DATA]).map(Number).filter(Boolean);
+        };
+        _getFiles[SHARED_FOLDERS] = function () {
+            var ret = [];
+            if (!files[SHARED_FOLDERS]) { return ret; }
+            return Object.keys(files[SHARED_FOLDERS]).map(Number).filter(Boolean);
+        };
+        var getFiles = exp.getFiles = function (categories) {
+            var ret = [];
+            if (!categories || !categories.length) {
+                categories = [ROOT, 'hrefArray', TRASH, OLD_FILES_DATA, FILES_DATA, SHARED_FOLDERS];
+            }
+            categories.forEach(function (c) {
+                if (typeof _getFiles[c] === "function") {
+                    ret = ret.concat(_getFiles[c]());
+                }
+            });
+            return Util.deduplicateString(ret);
+        };
+
+        var getIdFromHref = exp.getIdFromHref = function (_href) {
+            var result;
+            var noPassword = function (str) {
+                if (!str) { return; }
+                var parsed = Hash.parsePadUrl(str);
+                return parsed.getUrl().replace(/\/p\/?/, '/');
+            };
+            var href = noPassword(_href);
+            getFiles([FILES_DATA]).some(function (id) {
+                if (noPassword(getHref(files[FILES_DATA][id])) === href ||
+                    noPassword(files[FILES_DATA][id].roHref) === href) {
+                    result = id;
+                    return true;
+                }
+            });
+            return result;
+        };
+
+        exp.getSFIdFromHref = function (_href) {
+            var result;
+            var noPassword = function (str) {
+                if (!str) { return; }
+                var parsed = Hash.parsePadUrl(str);
+                return parsed.getUrl().replace(/\/p\/?/, '/');
+            };
+            var href = noPassword(_href);
+            getFiles([SHARED_FOLDERS]).some(function (id) {
+                if (noPassword(getHref(files[SHARED_FOLDERS][id])) === href ||
+                    noPassword(files[SHARED_FOLDERS][id].roHref) === href) {
+                    result = id;
+                    return true;
+                }
+            });
+            return result;
+        };
+
+        // SEARCH
+        var _findFileInRoot = function (path, file) {
+            if (!isPathIn(path, [ROOT, TRASH])) { return []; }
+            var paths = [];
+            var root = find(path);
+            var addPaths = function (p) {
+                if (paths.indexOf(p) === -1) {
+                    paths.push(p);
+                }
+            };
+
+            if (isFile(root) || isSharedFolder(root)) {
+                if (compareFiles(file, root)) {
+                    if (paths.indexOf(path) === -1) {
+                        paths.push(path);
+                    }
+                }
+                return paths;
+            }
+            if (isFolder(root)) {
+                for (var e in root) {
+                    var nPath = path.slice();
+                    nPath.push(e);
+                    _findFileInRoot(nPath, file).forEach(addPaths);
+                }
+            }
+
+            return paths;
+        };
+        exp.findFileInRoot = function (file) {
+            return _findFileInRoot([ROOT], file);
+        };
+        var _findFileInHrefArray = function (rootName, file) {
+            if (sharedFolder) { return []; }
+            if (!files[rootName]) { return []; }
+            var unsorted = files[rootName].slice();
+            var ret = [];
+            var i = -1;
+            while ((i = unsorted.indexOf(file, i+1)) !== -1){
+                ret.push([rootName, i]);
+            }
+            return ret;
+        };
+        var _findFileInTrash = function (path, file) {
+            if (sharedFolder) { return []; }
+            var root = find(path);
+            var paths = [];
+            var addPaths = function (p) {
+                if (paths.indexOf(p) === -1) {
+                    paths.push(p);
+                }
+            };
+            if (path.length === 1 && typeof(root) === 'object') {
+                Object.keys(root).forEach(function (key) {
+                    var arr = root[key];
+                    if (!Array.isArray(arr)) { return; }
+                    var nPath = path.slice();
+                    nPath.push(key);
+                    _findFileInTrash(nPath, file).forEach(addPaths);
+                });
+            }
+            if (path.length === 2) {
+                if (!Array.isArray(root)) { return []; }
+                root.forEach(function (el, i) {
+                    var nPath = path.slice();
+                    nPath.push(i);
+                    nPath.push('element');
+                    if (isFile(el.element)) {
+                        if (compareFiles(file, el.element)) {
+                            addPaths(nPath);
+                        }
+                        return;
+                    }
+                    _findFileInTrash(nPath, file).forEach(addPaths);
+                });
+            }
+            if (path.length >= 4) {
+                _findFileInRoot(path, file).forEach(addPaths);
+            }
+            return paths;
+        };
+        var findFile = exp.findFile = function (file) {
+            var rootpaths = _findFileInRoot([ROOT], file);
+            var templatepaths = _findFileInHrefArray(TEMPLATE, file);
+            var trashpaths = _findFileInTrash([TRASH], file);
+            return rootpaths.concat(templatepaths, trashpaths);
+        };
+
+        // Get drive ids of files from their channel ids
+        exp.findChannels = function (channels, includeSharedFolders) {
+            var allFilesList = files[FILES_DATA];
+            var sfList = files[SHARED_FOLDERS];
+            var paths = [FILES_DATA];
+            if (includeSharedFolders) { paths.push(SHARED_FOLDERS); }
+            return getFiles(paths).filter(function (k) {
+                var data = allFilesList[k] || sfList[k] || {};
+                return channels.indexOf(data.channel) !== -1;
+            });
+        };
+
+        exp.search = function (value) {
+            if (typeof(value) !== "string") { return []; }
+            value = value.trim();
+            var res = [];
+            // Search title
+            var allFilesList = files[FILES_DATA];
+            var allSFList = files[SHARED_FOLDERS];
+            var lValue = value.toLowerCase();
+
+            // parse the search string into tags
+            var tags;
+            if (/^#/.test(lValue)) {
+                tags = [lValue.slice(1).trim()];
+            }
+
+            /* returns true if an entry's tags are at least a partial match for
+                one of the specified tags */
+            var containsSearchedTag = function (T) {
+                if (!tags) { return false; }
+                if (!T.length) { return false; }
+                T = T.map(function (t) { return t.toLowerCase(); });
+                return tags.some(function (tag) {
+                    return T.some(function (t) {
+                        return t === tag;
+                    });
+                });
+            };
+
+            getFiles([FILES_DATA, SHARED_FOLDERS]).forEach(function (id) {
+                var data = allFilesList[id] || allSFList[id];
+                if (!data) { return; }
+                if (Array.isArray(data.tags) && containsSearchedTag(data.tags)) {
+                    return void res.push(id);
+                }
+                var title = data.title || data.lastTitle;
+                if ((title && title.toLowerCase().indexOf(lValue) !== -1) ||
+                    (data.filename && data.filename.toLowerCase().indexOf(lValue) !== -1)) {
+                    res.push(id);
+                }
+            });
+
+            // Search Href
+            var href = Hash.getRelativeHref(value);
+            if (href) {
+                var id = getIdFromHref(href);
+                if (id) { res.push(id); }
+            }
+
+            res = Util.deduplicateString(res);
+
+            var ret = [];
+            res.forEach(function (l) {
+                //var paths = findFile(l);
+                ret.push({
+                    id: l,
+                    paths: findFile(l),
+                    data: exp.getFileData(l)
+                });
+            });
+
+            // find folders
+            var resFolders = [];
+            var findFoldersRec = function (folder, path) {
+                for (var key in folder) {
+                    if (isFolder(folder[key]) && !isSharedFolder(folder[key])) {
+                        if (key.toLowerCase().indexOf(lValue) !== -1) {
+                            resFolders.push({
+                                id: null,
+                                paths: [path.concat(key)],
+                                data: {
+                                    title: key
+                                }
+                            });
+                        }
+                        findFoldersRec(folder[key], path.concat(key));
+                    }
+                }
+            };
+            findFoldersRec(files[ROOT], [ROOT]);
+            resFolders = resFolders.sort(function (a, b) {
+                return a.data.title.toLowerCase() > b.data.title.toLowerCase();
+            });
+            ret = resFolders.concat(ret);
+
+            return ret;
+        };
+        exp.getRecentPads = function () {
+            var allFiles = files[FILES_DATA];
+            var sorted = Object.keys(allFiles).filter(function (a) { return allFiles[a]; })
+                .sort(function (a,b) {
+                    return allFiles[b].atime - allFiles[a].atime;
+                })
+                .map(function (str) { return Number(str); });
+            return sorted;
+        };
+        exp.getOwnedPads = function (edPub) {
+            var allFiles = files[FILES_DATA];
+            return Object.keys(allFiles).filter(function (id) {
+                return allFiles[id].owners && allFiles[id].owners.indexOf(edPub) !== -1;
+            }).map(function (k) { return Number(k); });
+        };
+
+        /**
+         * OPERATIONS
+         */
+
+        var getAvailableName = exp.getAvailableName = function (parentEl, name) {
+            if (typeof(parentEl[name]) === "undefined") { return name; }
+            var newName = name;
+            var i = 1;
+            while (typeof(parentEl[newName]) !== "undefined") {
+                newName = name + "_" + i;
+                i++;
+            }
+            return newName;
+        };
+
+        // MOVE
+        var move = exp.move = function (paths, newPath, cb) {
+            if (sframeChan) {
+                return void sframeChan.query("Q_DRIVE_USEROBJECT", {
+                    cmd: "move",
+                    data: {
+                        paths: paths,
+                        newPath: newPath
+                    }
+                }, cb);
+            }
+            // Copy the elements to their new location
+            var toRemove = [];
+            paths.forEach(function (p) {
+                var parentPath = p.slice();
+                parentPath.pop();
+                if (comparePath(parentPath, newPath)) { return; }
+                if (isSubpath(newPath, p)) {
+                    log(Messages.fo_moveFolderToChildError);
+                    return;
+                }
+                // Try to copy, and if success, remove the element from the old location
+                if (exp.copyElement(p.slice(), newPath)) {
+                    toRemove.push(p);
+                }
+            });
+            exp.delete(toRemove, cb);
+        };
+        exp.restore = function (path, cb) {
+            if (sframeChan) {
+                return void sframeChan.query("Q_DRIVE_USEROBJECT", {
+                    cmd: "restore",
+                    data: {
+                        path: path
+                    }
+                }, cb);
+            }
+            if (!isInTrashRoot(path)) { return; }
+            var parentPath = path.slice();
+            parentPath.pop();
+            var oldPath = find(parentPath).path;
+            move([path], oldPath, cb);
+        };
+
+
+        // ADD
+        exp.addFolder = function (folderPath, name, cb) {
+            if (sframeChan) {
+                return void sframeChan.query("Q_DRIVE_USEROBJECT", {
+                    cmd: "addFolder",
+                    data: {
+                        path: folderPath,
+                        name: name
+                    }
+                }, cb);
+            }
+            var parentEl = find(folderPath);
+            var folderName = getAvailableName(parentEl, name || NEW_FOLDER_NAME);
+            parentEl[folderName] = {};
+            var newPath = folderPath.slice();
+            newPath.push(folderName);
+            cb({
+                newPath: newPath
+            });
+        };
+
+        // DELETE
+        // Permanently delete multiple files at once using a list of paths
+        // NOTE: We have to be careful when removing elements from arrays (trash root, unsorted or template)
+        exp.delete = function (paths, cb, nocheck) {
+            if (sframeChan) {
+                return void sframeChan.query("Q_DRIVE_USEROBJECT", {
+                    cmd: "delete",
+                    data: {
+                        paths: paths,
+                        nocheck: nocheck,
+                    }
+                }, cb);
+            }
+            cb = cb || function () {};
+            exp.deleteMultiplePermanently(paths, nocheck, cb);
+            //if (typeof cb === "function") { cb(); }
+        };
+        exp.emptyTrash = function (cb) {
+            cb = cb || function () {};
+            if (sframeChan) {
+                return void sframeChan.query("Q_DRIVE_USEROBJECT", {
+                    cmd: "emptyTrash"
+                }, cb);
+            }
+            files[TRASH] = {};
+            exp.checkDeletedFiles(cb);
+        };
+        exp.ownedInTrash = function (isOwned) {
+            return getFiles([TRASH]).map(function (id) {
+                var data = isSharedFolder(id) ? files[SHARED_FOLDERS][id] : exp.getFileData(id);
+                if (!data) { return; }
+                return isOwned(data.owners) ? data.channel : undefined;
+            }).filter(Boolean);
+        };
+
+        // RENAME
+        exp.rename = function (path, newName, cb) {
+            cb = cb || function () {};
+            if (sframeChan) {
+                return void sframeChan.query("Q_DRIVE_USEROBJECT", {
+                    cmd: "rename",
+                    data: {
+                        path: path,
+                        newName: newName
+                    }
+                }, cb);
+            }
+            if (path.length <= 1) {
+                logError('Renaming `root` is forbidden');
+                return;
+            }
+            // Copy the element path and remove the last value to have the parent path and the old name
+            var element = find(path);
+
+            // Folders
+            if (isFolder(element) && !isSharedFolder(element)) {
+                var parentPath = path.slice();
+                var oldName = parentPath.pop();
+                if (!newName || !newName.trim() || oldName === newName) { return; }
+                var parentEl = find(parentPath);
+                if (typeof(parentEl[newName]) !== "undefined") {
+                    log(Messages.fo_existingNameError);
+                    return;
+                }
+                parentEl[newName] = element;
+                delete parentEl[oldName];
+                if (typeof cb === "function") { cb(); }
+                return;
+            }
+
+            // Files or Shared folder
+            var data;
+            if (isSharedFolder(element)) {
+                data = files[SHARED_FOLDERS][element];
+            } else {
+                data = files[FILES_DATA][element] || files[STATIC_DATA][element];
+            }
+            if (!data) { return; }
+            if (files[STATIC_DATA][element]) {
+                if (!newName || !newName.trim()) { return void cb(); }
+                data.name = newName;
+                cb();
+                return;
+            }
+            if (!newName || newName.trim() === "") {
+                delete data.filename;
+                if (typeof cb === "function") { cb(); }
+                return;
+            }
+            if (getTitle(element, 'name') === newName) { return; }
+            data.filename = newName;
+            if (typeof cb === "function") { cb(); }
+        };
+
+        // Tags
+        exp.getTagsList = function () {
+            var tags = {};
+            var data;
+            var pushTag = function (tag) {
+                tags[tag] = tags[tag] ? ++tags[tag] : 1;
+            };
+            for (var id in files[FILES_DATA]) {
+                data = files[FILES_DATA][id];
+                if (!data.tags || !Array.isArray(data.tags)) { continue; }
+                data.tags.forEach(pushTag);
+            }
+            return tags;
+        };
+
+        return exp;
+    };
+    return module;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        undefined,
+        require('./common-util'),
+        require('./common-hash'),
+        require('./common-constants'),
+        require('./user-object-setter'),
+        require('chainpad-crypto'),
+        undefined
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/customize/application_config.js',
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/common-constants.js',
+        '/common/user-object-setter.js',
+        '/components/chainpad-crypto/crypto.js',
+        '/customize/messages.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/messages.js b/src/messages.js
new file mode 100644
index 000000000..b4edd4a3c
--- /dev/null
+++ b/src/messages.js
@@ -0,0 +1,15 @@
+(() => {
+const factory = (Messages) => {
+    Messages = Messages || {};
+    Messages._getKey = k => { return Messages[k]; };
+    return Messages;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    var Msg = require('../www/common/translations/messages.json');
+    module.exports = factory(Msg);
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([], factory);
+}
+})();
+
diff --git a/src/worker/components/invitation.js b/src/worker/components/invitation.js
new file mode 100644
index 000000000..ad9601e4e
--- /dev/null
+++ b/src/worker/components/invitation.js
@@ -0,0 +1,122 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(function () {
+var factory = function (Util, Cred, Nacl, Crypto) {
+    var Invite = {};
+
+    var encode64 = Nacl.util.encodeBase64;
+    var decode64 = Nacl.util.decodeBase64;
+
+    // ed and curve keys can be random...
+    Invite.generateKeys = function () {
+        var ed = Nacl.sign.keyPair();
+        var curve = Nacl.box.keyPair();
+        return {
+            edPublic: encode64(ed.publicKey),
+            edPrivate: encode64(ed.secretKey),
+            curvePublic: encode64(curve.publicKey),
+            curvePrivate: encode64(curve.secretKey),
+        };
+    };
+
+    Invite.generateSignPair = function () {
+        var ed = Nacl.sign.keyPair();
+        return {
+            validateKey: encode64(ed.publicKey),
+            signKey: encode64(ed.secretKey),
+        };
+    };
+
+    var b64ToChannelKeys = function (b64) {
+        var dispense = Cred.dispenser(decode64(b64));
+        return {
+            channel: Util.uint8ArrayToHex(dispense(16)),
+            cryptKey: dispense(Nacl.secretbox.keyLength),
+        };
+    };
+
+    // the secret invite values (cryptkey and channel) can be derived
+    // from the link seed and (optional) password
+    Invite.deriveInviteKeys = b64ToChannelKeys;
+
+    // the preview values (cryptkey and channel) are less sensitive than the invite values
+    // as they cannot be leveraged to access any further content on their own
+    // unless the message contains secrets.
+    // derived from the link seed alone.
+    Invite.derivePreviewKeys = b64ToChannelKeys;
+
+    Invite.createRosterEntry = function (roster, data, cb) {
+        var toInvite = {};
+        toInvite[data.curvePublic] = data.content;
+        roster.invite(toInvite, cb);
+    };
+
+    // Invite links should only be visible to members or above, so
+    // we store them in the roster encrypted with a string only available
+    // to users with edit rights
+    var decodeUTF8 = Nacl.util.decodeUTF8;
+    Invite.encryptHash = function (data, seedStr) {
+        var array = decodeUTF8(seedStr);
+        var bytes = Nacl.hash(array);
+        var cryptKey = bytes.subarray(0, 32);
+        return Crypto.encrypt(data, cryptKey);
+    };
+    Invite.decryptHash = function (encryptedStr, seedStr) {
+        var array = decodeUTF8(seedStr);
+        var bytes = Nacl.hash(array);
+        var cryptKey = bytes.subarray(0, 32);
+        return Crypto.decrypt(encryptedStr, cryptKey);
+    };
+
+
+/*  INPUTS
+
+    * password (for scrypt)
+    * message (personal note)
+    * link hash
+    * bytes64 (scrypt output)
+    * preview_hash
+
+*/
+
+/*  IO / FUNCTIONALITY
+
+    * creator
+      * generate a random signKey (prevent writes to preview channel)
+      * encrypt and upload the preview content
+        * via CryptGet
+        * owned by:
+          * the ephemeral edPublic
+          * the invite creator
+      * create a roster entry for the invitation
+        * with encrypted notes for the creator
+    * redeemer
+      * get the preview content
+      * redeem the invite
+        * add yourself to the roster
+        * add the team to your proxy-manager
+
+*/
+
+    return Invite;
+};
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = factory(
+            require("../../common/common-util"),
+            require("../../common/common-credential"),
+            require("tweetnacl/nacl-fast"),
+            require("chainpad-crypto")
+        );
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        define([
+            '/common/common-util.js',
+            '/common/common-credential.js',
+            '/components/chainpad-crypto/crypto.js',
+            '/components/tweetnacl/nacl-fast.min.js',
+        ], function (Util, Cred, Crypto) {
+            return factory(Util, Cred, window.nacl, Crypto);
+        });
+    }
+}());
diff --git a/src/worker/components/mailbox-handlers.js b/src/worker/components/mailbox-handlers.js
new file mode 100644
index 000000000..3f918e519
--- /dev/null
+++ b/src/worker/components/mailbox-handlers.js
@@ -0,0 +1,1006 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Messaging, Hash, Util, Crypto, Block) => {
+
+    // Random timeout between 10 and 30 times your sync time (lag + chainpad sync)
+    var getRandomTimeout = function (ctx) {
+        var lag = ctx.store.realtime.getLag().lag || 0;
+        return (Math.max(0, lag) + 300) * 20 * (0.5 +  Math.random());
+    };
+
+    var handlers = {};
+    var removeHandlers = {};
+
+    var isMuted = function (ctx, data) {
+        var muted = ctx.store.proxy.mutedUsers || {};
+        var curvePublic = Util.find(data, ['msg', 'author']);
+        if (!curvePublic) { return false; }
+        return Boolean(muted[curvePublic]);
+    };
+    var isChannelMuted = function (ctx, channel) {
+        var muted = ctx.store.proxy.mutedChannels || [];
+        return muted.includes(channel);
+    };
+
+    // Store the friend request displayed to avoid duplicates
+    var friendRequest = {};
+    handlers['FRIEND_REQUEST'] = function (ctx, box, data, cb) {
+        // Old format: data was stored directly in "content"
+        var userData = data.msg.content.user || data.msg.content;
+
+        if (isMuted(ctx, data)) { return void cb(true); }
+
+        // Don't show duplicate friend request: if we already have a friend request
+        // in memory from the same user, dismiss the new one
+        if (friendRequest[data.msg.author]) { return void cb(true); }
+
+        friendRequest[data.msg.author] = {
+            type: box.type,
+            hash: data.hash
+        };
+
+        // If the user is already in our friend list, automatically accept the request
+        if (Messaging.getFriend(ctx.store.proxy, data.msg.author) ||
+            ctx.store.proxy.friends_pending[data.msg.author]) {
+
+            delete ctx.store.proxy.friends_pending[data.msg.author];
+
+            Messaging.acceptFriendRequest(ctx.store, userData, function (obj) {
+                if (obj && obj.error) {
+                    return void cb();
+                }
+                Messaging.addToFriendList({
+                    proxy: ctx.store.proxy,
+                    realtime: ctx.store.realtime,
+                    pinPads: ctx.pinPads
+                }, userData, function (err) {
+                    if (err) {
+                        console.error(err);
+                        return void cb(true);
+                    }
+                    if (ctx.store.messenger) {
+                        ctx.store.messenger.onFriendAdded(userData);
+                    }
+                    ctx.updateMetadata();
+                    cb(true);
+                });
+            });
+            return;
+        }
+
+        cb();
+    };
+    removeHandlers['FRIEND_REQUEST'] = function (ctx, box, data) {
+        var userData = data.content.user || data.content;
+        if (friendRequest[userData.curvePublic]) {
+            delete friendRequest[userData.curvePublic];
+        }
+    };
+
+    // The DECLINE and ACCEPT messages act on the contacts data
+    // They are processed with a random timeout to avoid having
+    // multiple workers trying to add or remove the contacts at
+    // the same time. Once processed, they are dismissed.
+    // We must dismiss them and send another message to our own
+    // mailbox for the UI part otherwise it would automatically
+    // accept or decline future requests from the same user
+    // until the message is manually dismissed.
+
+    var friendRequestDeclined = {};
+    var friendRequestAccepted = {};
+    handlers['DECLINE_FRIEND_REQUEST'] = function (ctx, box, data, cb) {
+        // Old format: data was stored directly in "content"
+        var userData = data.msg.content.user || data.msg.content;
+        if (!userData.curvePublic) { userData.curvePublic = data.msg.author; }
+
+        // Our friend request was declined.
+        setTimeout(function () {
+            // Only dismissed once in the timeout to make sure we won't lose
+            // the data if we close the worker before adding the friend
+            cb(true);
+
+            // Make sure we really sent it
+            if (!ctx.store.proxy.friends_pending[data.msg.author]) { return; }
+            // Remove the pending message and display the "declined" state in the UI
+            delete ctx.store.proxy.friends_pending[data.msg.author];
+
+            ctx.updateMetadata();
+            if (friendRequestDeclined[data.msg.author]) { return; }
+            box.sendMessage({
+                type: 'FRIEND_REQUEST_DECLINED',
+                content: { user: userData }
+            }, function (hash) {
+                friendRequestDeclined[data.msg.author] = {
+                    type: box.type,
+                    hash: hash
+                };
+            });
+        }, getRandomTimeout(ctx));
+    };
+    // UI for declined friend request
+    handlers['FRIEND_REQUEST_DECLINED'] = function (ctx, box, data, cb) {
+        ctx.updateMetadata();
+        var curve = data.msg.content.user.curvePublic || data.msg.content.user;
+        var toRemove = friendRequestAccepted[curve];
+        delete friendRequestAccepted[curve];
+        if (friendRequestDeclined[curve]) { return void cb(true, toRemove); }
+        friendRequestDeclined[curve] = {
+            type: box.type,
+            hash: data.hash
+        };
+        cb(false, toRemove);
+    };
+    removeHandlers['FRIEND_REQUEST_DECLINED'] = function (ctx, box, data) {
+        var curve = data.content.user.curvePublic || data.content.user;
+        if (friendRequestDeclined[curve]) { delete friendRequestDeclined[curve]; }
+    };
+
+    handlers['ACCEPT_FRIEND_REQUEST'] = function (ctx, box, data, cb) {
+        // Old format: data was stored directly in "content"
+        var userData = data.msg.content.user || data.msg.content;
+
+        // Our friend request was accepted.
+        setTimeout(function () {
+            // Only dismissed once in the timeout to make sure we won't lose
+            // the data if we close the worker before adding the friend
+            cb(true);
+
+            // Make sure we really sent it
+            if (!ctx.store.proxy.friends_pending[data.msg.author]) { return; }
+            // Remove the pending state. It will also us to send a new request in case of error
+            delete ctx.store.proxy.friends_pending[data.msg.author];
+
+            // And add the friend
+            Messaging.addToFriendList({
+                proxy: ctx.store.proxy,
+                realtime: ctx.store.realtime,
+                pinPads: ctx.pinPads
+            }, userData, function (err) {
+                if (err) { return void console.error(err); }
+                // Load the chat if contacts app loaded
+                if (ctx.store.messenger) { ctx.store.messenger.onFriendAdded(userData); }
+                // Update the userlist
+                ctx.updateMetadata();
+                // If you have a profile page open, update it
+                if (ctx.store.modules['profile']) { ctx.store.modules['profile'].update(); }
+                // Display the "accepted" state in the UI
+                if (friendRequestAccepted[data.msg.author]) { return; }
+                box.sendMessage({
+                    type: 'FRIEND_REQUEST_ACCEPTED',
+                    content: { user: userData }
+                }, function (hash) {
+                    friendRequestAccepted[data.msg.author] = {
+                        type: box.type,
+                        hash: hash
+                    };
+                });
+            });
+        }, getRandomTimeout(ctx));
+    };
+    // UI for accepted friend request
+    handlers['FRIEND_REQUEST_ACCEPTED'] = function (ctx, box, data, cb) {
+        ctx.updateMetadata();
+        var curve = data.msg.content.user.curvePublic || data.msg.content.user;
+        var toRemove = friendRequestDeclined[curve];
+        delete friendRequestDeclined[curve];
+        if (friendRequestAccepted[curve]) { return void cb(true, toRemove); }
+        friendRequestAccepted[curve] = {
+            type: box.type,
+            hash: data.hash
+        };
+        cb(false, toRemove);
+    };
+    removeHandlers['FRIEND_REQUEST_ACCEPTED'] = function (ctx, box, data) {
+        var curve = data.content.user.curvePublic || data.content.user;
+        if (friendRequestAccepted[curve]) { delete friendRequestAccepted[curve]; }
+    };
+
+    handlers['CANCEL_FRIEND_REQUEST'] = function (ctx, box, data, cb) {
+        var f = friendRequest[data.msg.author];
+        if (!f) { return void cb(true); }
+        cb(true, f);
+    };
+
+    handlers['UNFRIEND'] = function (ctx, box, data, cb) {
+        var curve = data.msg.author;
+        var friend = Messaging.getFriend(ctx.store.proxy, curve);
+        if (!friend) { return void cb(true); }
+        delete ctx.store.proxy.friends[curve];
+        delete ctx.store.proxy.friends_pending[curve];
+        if (ctx.store.messenger) {
+            ctx.store.messenger.onFriendRemoved(curve, friend.channel);
+        }
+        ctx.updateMetadata();
+        cb(true);
+    };
+
+    handlers['UPDATE_DATA'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var curve = msg.author;
+        var friend = ctx.store.proxy.friends && ctx.store.proxy.friends[curve];
+        if (!friend || typeof msg.content !== "object") { return void cb(true); }
+        Object.keys(msg.content).forEach(function (key) {
+            friend[key] = msg.content[key];
+        });
+        if (ctx.store.messenger) {
+            ctx.store.messenger.onFriendUpdate(curve);
+        }
+        ctx.updateMetadata();
+        cb(true);
+    };
+
+    // Encrypt the password under the right key before sending it via URL hash
+    var encryptPassword = function(ctx, password) {
+        let uHash = ctx.store.data.blockHash;
+        let uSecret = Block.parseBlockHash(uHash);
+        let key = uSecret.keys.symmetric;
+        return Crypto.encrypt(password, key);
+    };
+
+    // Hide duplicates when receiving a SHARE_PAD notification:
+    // Keep only one notification per channel: the stronger and more recent one
+    var channels = {};
+    handlers['SHARE_PAD'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var hash = data.hash;
+        var content = msg.content;
+        // content.name, content.title, content.href, content.password
+
+        if (isMuted(ctx, data)) { return void cb(true); }
+        // if the shared content is a 'link' then we can't use the channel to deduplicate notifications
+        // use href instead.
+        var channel = content.isStatic ? content.href : Hash.hrefToHexChannelId(content.href, content.password);
+        var parsed = Hash.parsePadUrl(content.href);
+        var mode = parsed.hashData && parsed.hashData.mode || 'n/a';
+
+        var old = channels[channel];
+        var toRemove;
+        if (old) {
+            // New hash is weaker, ignore
+            if (old.mode === 'edit' && mode === 'view') {
+                return void cb(true);
+            }
+            // New hash is not weaker, clear the old one
+            toRemove = old.data;
+        }
+
+        if (content.password) {
+            content.password = encryptPassword(ctx, content.password);
+        }
+
+        // Update the data
+        channels[channel] = {
+            mode: mode,
+            data: {
+                type: box.type,
+                hash: hash
+            }
+        };
+
+        cb(false, toRemove);
+    };
+    removeHandlers['SHARE_PAD'] = function (ctx, box, data, hash) {
+        var content = data.content;
+        var channel = Hash.hrefToHexChannelId(content.href, content.password);
+        var old = channels[channel];
+        if (old && old.data && old.data.hash === hash) {
+            delete channels[channel];
+        }
+    };
+
+    // Hide duplicates when receiving a SUPPORT_MESSAGE notification
+    var supportMessage = false;
+    handlers['SUPPORT_MESSAGE'] = function (ctx, box, data, cb) {
+        if (supportMessage) { return void cb(true); }
+        supportMessage = true;
+        cb();
+    };
+    removeHandlers['SUPPORT_MESSAGE'] = function () {
+        supportMessage = false;
+    };
+
+    // Incoming edit rights request: add data before sending it to inner
+    handlers['REQUEST_PAD_ACCESS'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        if (isMuted(ctx, data)) { return void cb(true); }
+
+        var channel = content.channel;
+        var res = ctx.store.manager.findChannel(channel);
+
+        if (!res.length) { return void cb(true); }
+
+        var edPublic = ctx.store.proxy.edPublic;
+        var title, href;
+        if (!res.some(function (obj) {
+            if (obj.data &&
+                Array.isArray(obj.data.owners) && obj.data.owners.indexOf(edPublic) !== -1 &&
+                obj.data.href) {
+                    href = obj.data.href;
+                    title = obj.data.filename || obj.data.title;
+                    return true;
+            }
+        })) { return void cb(true); }
+
+        content.title = title;
+        content.href = href;
+        cb(false);
+    };
+
+    handlers['GIVE_PAD_ACCESS'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        var channel = content.channel;
+        var res = ctx.store.manager.findChannel(channel, true);
+
+        var title;
+        res.forEach(function (obj) {
+            if (obj.data && !obj.data.href) {
+                if (!title) { title = obj.data.filename || obj.data.title; }
+                obj.userObject.setHref(channel, null, content.href);
+            }
+        });
+
+        content.title = title || content.title;
+        cb(false);
+    };
+
+    handlers['ADD_TO_ACCESS_LIST'] = function(ctx, common, data, cb) {
+
+        var msg = data.msg;
+        var content = msg.content;
+        var channel = content.channel;
+
+        ctx.Store.getAllStores().forEach(function (store) {
+            var res = store.manager.findChannel(channel);
+            if (!res.length) { return; }
+            
+            var data = res[0].data;
+            var id = res[0].id;
+            var teamId = store.id;
+            ctx.Store.loadSharedFolder(teamId, id, data, function () {
+
+            }, false);
+        });
+        cb(true);
+    };
+
+    // Hide duplicates when receiving an ADD_OWNER notification:
+    var addOwners = {};
+    handlers['ADD_OWNER'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        if (isMuted(ctx, data)) { return void cb(true); }
+
+        if (!content.teamChannel && !(content.href && content.title && content.channel)) {
+            console.log('Remove invalid notification');
+            return void cb(true);
+        }
+
+        var channel = content.channel || content.teamChannel;
+
+        if (content.password) {
+            content.pw = content.password;
+            content.password = encryptPassword(ctx, content.password);
+        }
+
+        if (addOwners[channel]) { return void cb(true); }
+        addOwners[channel] = {
+            type: box.type,
+            hash: data.hash
+        };
+
+        cb(false);
+    };
+    removeHandlers['ADD_OWNER'] = function (ctx, box, data) {
+        var channel = data.content.channel || data.content.teamChannel;
+        if (addOwners[channel]) {
+            delete addOwners[channel];
+        }
+    };
+
+    handlers['RM_OWNER'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        if (!content.channel && !content.teamChannel) {
+            console.log('Remove invalid notification');
+            return void cb(true);
+        }
+
+        var channel = content.channel || content.teamChannel;
+
+        // If our ownership rights for a team have been removed, update the owner flag
+        if (content.teamChannel) {
+            var teams = ctx.store.proxy.teams || {};
+            Object.keys(teams).some(function (id) {
+                if (teams[id].channel === channel) {
+                    teams[id].owner = false;
+                    return true;
+                }
+            });
+        }
+
+        if (addOwners[channel] && content.pending) {
+            return void cb(false, addOwners[channel]);
+        }
+        cb(false);
+    };
+
+    var invitedTo = {};
+    handlers['INVITE_TO_TEAM'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        if (isMuted(ctx, data)) { return void cb(true); }
+
+        if (!content.team) {
+            console.log('Remove invalid notification');
+            return void cb(true);
+        }
+
+        var invited = invitedTo[content.team.channel];
+        if (invited) {
+            console.log('removing old invitation');
+            cb(false, invited);
+            invitedTo[content.team.channel] = {
+                type: box.type,
+                hash: data.hash
+            };
+            return;
+        }
+
+        var myTeams = Util.find(ctx, ['store', 'proxy', 'teams']) || {};
+        var alreadyMember = Object.keys(myTeams).some(function (k) {
+            var team = myTeams[k];
+            return team.channel === content.team.channel;
+        });
+        if (alreadyMember) { return void cb(true); }
+
+        invitedTo[content.team.channel] = {
+            type: box.type,
+            hash: data.hash
+        };
+
+        cb(false);
+    };
+    removeHandlers['INVITE_TO_TEAM'] = function (ctx, box, data) {
+        var channel = Util.find(data, ['content', 'team', 'channel']);
+        delete invitedTo[channel];
+    };
+
+    handlers['KICKED_FROM_TEAM'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        if (!content.teamChannel) {
+            console.log('Remove invalid notification');
+            return void cb(true);
+        }
+
+        if (invitedTo[content.teamChannel] && content.pending) {
+            return void cb(true, invitedTo[content.teamChannel]);
+        }
+
+        cb(false);
+    };
+
+    handlers['INVITE_TO_TEAM_ANSWER'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        if (!content.teamChannel) {
+            console.log('Remove invalid notification');
+            return void cb(true);
+        }
+
+        var myTeams = Util.find(ctx, ['store', 'proxy', 'teams']) || {};
+        var teamId;
+        var team;
+        Object.keys(myTeams).some(function (k) {
+            var _team = myTeams[k];
+            if (_team.channel === content.teamChannel) {
+                teamId = k;
+                team = _team;
+                return true;
+            }
+        });
+        if (!teamId) { return void cb(true); }
+
+        content.team = team;
+
+        if (!content.answer) {
+            // If they declined the invitation, remove them from the roster (as a pending member)
+            try {
+                var module = ctx.store.modules['team'];
+                module.removeFromTeam(teamId, msg.author, true);
+            } catch (e) { console.error(e); }
+        }
+
+        var userData = content.user || content;
+        box.sendMessage({
+            type: 'INVITE_TO_TEAM_ANSWERED',
+            content: {
+                user: userData,
+                team: team,
+                answer: content.answer
+            }
+        }, function () {});
+
+        cb(true);
+    };
+
+    handlers['TEAM_EDIT_RIGHTS'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        if (!content.teamData) {
+            console.log('Remove invalid notification');
+            return void cb(true);
+        }
+
+        // Make sure we are a member of this team
+        var myTeams = Util.find(ctx, ['store', 'proxy', 'teams']) || {};
+        var teamId;
+        Object.keys(myTeams).some(function (k) {
+            var _team = myTeams[k];
+            if (_team.channel === content.teamData.channel) {
+                teamId = k;
+                return true;
+            }
+        });
+        if (!teamId) { return void cb(true); }
+
+        try {
+            var module = ctx.store.modules['team'];
+            // changeMyRights returns true if we can't change our rights
+            module.changeMyRights(teamId, content.state, content.teamData, function (done) {
+                if (!done) { console.error("Can't update team rights"); }
+                cb(true);
+            });
+        } catch (e) { console.error(e); }
+    };
+
+    handlers['OWNED_PAD_REMOVED'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        if (!content.channel) {
+            console.log('Remove invalid notification');
+            return void cb(true);
+        }
+
+        var channel = content.channel;
+        var res = ctx.store.manager.findChannel(channel);
+
+        res.forEach(function (obj) {
+            var paths = ctx.store.manager.findFile(obj.id);
+            ctx.store.manager.delete({
+                paths: paths
+            }, function () {
+                ctx.updateDrive();
+            });
+        });
+
+        cb(true);
+    };
+
+    // Make sure "todo migration" notifications are from yourself
+    handlers['MOVE_TODO'] = function (ctx, box, data, cb) {
+        var curve = ctx.store.proxy.curvePublic;
+        if (data.msg.author !== curve) { return void cb(true); }
+        cb();
+    };
+
+    handlers["SAFE_LINKS_DEFAULT"] = function (ctx, box, data, cb) {
+        var curve = ctx.store.proxy.curvePublic;
+        if (data.msg.author !== curve) { return void cb(true); }
+        cb();
+    };
+
+    // Hide duplicates when receiving a form notification:
+    // Keep only one notification per channel
+    var formNotifs = {};
+    handlers['FORM_RESPONSE'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var hash = data.hash;
+        var content = msg.content;
+
+        var channel = content.channel;
+        if (!channel) { return void cb(true); }
+
+        if (isChannelMuted(ctx, channel)) { return void cb(true); }
+
+        var title, href;
+        ctx.Store.getAllStores().some(function (s) {
+            var res = s.manager.findChannel(channel);
+            // Check if the pad is in our drive
+            return res.some(function (obj) {
+                if (!obj.data) { return; }
+                if (href && !obj.data.href) { return; } // We already have the VIEW url, we need EDIT
+                href = obj.data.href || obj.data.roHref;
+                title = obj.data.filename || obj.data.title;
+                if (obj.data.href) { return true; } // Abort only if we have the EDIT url
+            });
+        });
+
+        // If we don't have the edit url, ignore this notification
+        if (!href) { return void cb(true); }
+
+        // Add the title
+        content.href = href;
+        content.title = title;
+
+        // Remove duplicates
+        var old = formNotifs[channel];
+        var toRemove = old ? old.data : undefined;
+
+        // Update the data
+        formNotifs[channel] = {
+            data: {
+                type: box.type,
+                hash: hash
+            }
+        };
+
+        cb(false, toRemove);
+    };
+    removeHandlers['FORM_RESPONSE'] = function (ctx, box, data, hash) {
+        var content = data.content;
+        var channel = content.channel;
+        var old = formNotifs[channel];
+        if (old && old.data && old.data.hash === hash) {
+            delete formNotifs[channel];
+        }
+    };
+    // Hide duplicates when receiving a SHARE_PAD notification:
+    // Keep only one notification per channel: the stronger and more recent one
+    var comments = {};
+    handlers['COMMENT_REPLY'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var hash = data.hash;
+        var content = msg.content;
+
+        if (Util.find(ctx.store.proxy, ['settings', 'pad', 'disableNotif'])) {
+            return void cb(true);
+        }
+
+        var channel = content.channel;
+        if (!channel) { return void cb(true); }
+
+        var title, href;
+        ctx.Store.getAllStores().some(function (s) {
+            var res = s.manager.findChannel(channel);
+            // Check if the pad is in our drive
+            return res.some(function (obj) {
+                if (!obj.data) { return; }
+                if (href && !obj.data.href) { return; } // We already have the VIEW url, we need EDIT
+                href = obj.data.href || obj.data.roHref;
+                title = obj.data.filename || obj.data.title;
+                if (obj.data.href) { return true; } // Abort only if we have the EDIT url
+            });
+        });
+
+        // If we don't have the edit url, ignore this notification
+        if (!href) { return void cb(true); }
+
+        // Add the title
+        content.href = href;
+        content.title = title;
+
+        // Remove duplicates
+        var old = comments[channel];
+        var toRemove = old ? old.data : undefined;
+
+        // Update the data
+        comments[channel] = {
+            data: {
+                type: box.type,
+                hash: hash
+            }
+        };
+
+        cb(false, toRemove);
+    };
+    removeHandlers['COMMENT_REPLY'] = function (ctx, box, data, hash) {
+        var content = data.content;
+        var channel = content.channel;
+        var old = comments[channel];
+        if (old && old.data && old.data.hash === hash) {
+            delete comments[channel];
+        }
+    };
+
+    // Hide duplicates when receiving a SHARE_PAD notification:
+    // Keep only one notification per channel: the stronger and more recent one
+    var mentions = {};
+    handlers['MENTION'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var hash = data.hash;
+        var content = msg.content;
+
+        if (isMuted(ctx, data)) { return void cb(true); }
+
+        var channel = content.channel;
+        if (!channel) { return void cb(true); }
+
+        var title, href;
+        ctx.Store.getAllStores().some(function (s) {
+            var res = s.manager.findChannel(channel);
+            // Check if the pad is in our drive
+            return res.some(function (obj) {
+                if (!obj.data) { return; }
+                if (href && !obj.data.href) { return; } // We already have the VIEW url, we need EDIT
+                href = obj.data.href || obj.data.roHref;
+                title = obj.data.filename || obj.data.title;
+                if (obj.data.href) { return true; } // Abort only if we have the EDIT url
+            });
+        });
+
+        // Add the title
+        content.href = href;
+        content.title = title;
+
+        // Remove duplicates
+        var old = mentions[channel];
+        var toRemove = old ? old.data : undefined;
+
+        // Update the data
+        mentions[channel] = {
+            data: {
+                type: box.type,
+                hash: hash
+            }
+        };
+
+        cb(false, toRemove);
+    };
+    removeHandlers['MENTION'] = function (ctx, box, data, hash) {
+        var content = data.content;
+        var channel = content.channel;
+        var old = mentions[channel];
+        if (old && old.data && old.data.hash === hash) {
+            delete mentions[channel];
+        }
+    };
+
+
+    // Broadcast
+    handlers['BROADCAST_MAINTENANCE'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var uid = msg.uid;
+        ctx.Store.onMaintenanceUpdate(uid);
+        cb(true);
+    };
+    var activeSurvey;
+    handlers['BROADCAST_SURVEY'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+        var uid = msg.uid;
+        var old = activeSurvey;
+        activeSurvey = {
+            type: box.type,
+            hash: data.hash
+        };
+        ctx.Store.onSurveyUpdate(uid);
+        var dismiss = !content.url;
+        cb(dismiss, old);
+    };
+    var activeCustom;
+    handlers['BROADCAST_CUSTOM'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var uid = msg.uid;
+        var old = activeCustom;
+        activeCustom = {
+            uid: uid,
+            type: box.type,
+            hash: data.hash
+        };
+        cb(false, old);
+    };
+    handlers['BROADCAST_DELETE'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        var uid = content.uid; // uid of the message to delete
+        if (activeCustom && activeCustom.uid === uid) {
+            // We have the message in memory, remove it and don't keep the DELETE msg
+            cb(true, activeCustom);
+            activeCustom = undefined;
+            return;
+        }
+        // We don't have this message in memory, nothing to delete
+        cb(true);
+    };
+
+    var sfDeleted = {};
+    handlers['SF_DELETED'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+        var teamId = content.team;
+        var sfId = content.sfId;
+
+        if (sfDeleted[sfId]) { return void cb(true); }
+        sfDeleted[sfId] = 1;
+
+        // If it's a team SF, add the team name here
+
+        if (!teamId) { return void cb(false); }
+
+        var team = ctx.store.proxy.teams[teamId];
+        content.teamName = team.metadata && team.metadata.name;
+        cb(false);
+    };
+    removeHandlers['SF_DELETED'] = function (ctx, box, data) {
+        var id = data.content.sfId;
+        delete sfDeleted[id];
+    };
+
+    // New support
+    handlers['NEW_TICKET'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+        if (!content.time) { content.time = data.time; }
+
+        var support = Util.find(ctx, ['store', 'modules', 'support']);
+
+        // Admin to user
+        if (content.isAdmin) {
+            support.addUserTicket(content, cb);
+        }
+
+        // User to admin
+        support.addAdminTicket(content, cb);
+    };
+    var supportNotif, adminSupportNotif;
+    handlers['NOTIF_TICKET'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+        if (!content.time) { content.time = data.time; }
+
+        var support = Util.find(ctx, ['store', 'modules', 'support']);
+
+        // Admin to user
+        if (content.isAdmin) {
+            let exists = Util.find(ctx, ['store', 'proxy', 'support', content.channel]);
+
+            if (!exists) { return void cb(true); } // Deleted ticket
+            // Trigger realtime update of user support
+            support.updateUserTicket(content);
+
+            if (supportNotif) { return void cb(false, supportNotif); }
+            supportNotif = {
+                channel: content.channel,
+                type: box.type,
+                hash: data.hash
+            };
+            return void cb(false);
+        }
+
+        // User to admin
+        support.checkAdminTicket(content, (exists) => {
+            if (!exists) { return void cb(true); }
+            // Update ChainPad doc
+            support.updateAdminTicket(content);
+
+            if (Util.find(ctx.store.proxy, ['settings', 'general', 'disableSupportNotif'])) {
+                return void cb(true);
+            }
+
+            if (adminSupportNotif) { return void cb(false, adminSupportNotif); }
+            adminSupportNotif = {
+                channel: content.channel,
+                type: box.type,
+                hash: data.hash
+            };
+
+            cb(false);
+        });
+
+    };
+    removeHandlers['NOTIF_TICKET'] = function (ctx, box, data) {
+        var id = data.content.channel;
+        if (supportNotif && supportNotif.channel === id) { supportNotif = undefined; }
+        if (adminSupportNotif && adminSupportNotif.channel === id) { adminSupportNotif = undefined; }
+    };
+
+    handlers['ADD_MODERATOR'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        var support = Util.find(ctx, ['store', 'modules', 'support']);
+        support.updateAdminKey(content, cb);
+    };
+    handlers['MODERATOR_NEW_KEY'] = function (ctx, box, data, cb) {
+        var msg = data.msg;
+        var content = msg.content;
+
+        var support = Util.find(ctx, ['store', 'modules', 'support']);
+        support.updateAdminKey(content, function () {
+            cb(true); // Always dismiss, this should be invisible
+        });
+    };
+
+    return {
+        add: function (ctx, box, data, cb) {
+            /**
+             *  data = {
+                    msg: {
+                        type: 'STRING',
+                        author: 'curvePublicString',
+                        content: {} (depend on the "type")
+                    },
+                    hash: 'string'
+                }
+             */
+            if (!data.msg) { return void cb(null, null, true); }
+
+            // Check if the request is valid (sent by the correct user)
+            var myCurve = Util.find(ctx, ['store', 'proxy', 'curvePublic']);
+            var curve = Util.find(data, ['msg', 'content', 'user', 'curvePublic']) ||
+                        Util.find(data, ['msg', 'content', 'curvePublic']);
+            // Block messages that are not coming from the user described in the message
+            // except if the author is ourselves.
+            if (curve && data.msg.author !== curve && data.msg.author !== myCurve) {
+                console.error('blocked');
+                return void cb(null, null, true);
+            }
+
+            var type = data.msg.type;
+
+            if (handlers[type]) {
+                try {
+                    handlers[type](ctx, box, data, cb);
+                } catch (e) {
+                    console.error(e);
+                    cb();
+                }
+            } else {
+                cb();
+            }
+        },
+        remove: function (ctx, box, data, h) {
+            // We sometimes try to delete non-existant data (with "delete box.content[h]")
+            // In this case, we don't have the data in memory so we don't need to call
+            // any "remove" handler
+            if (!data) { return; }
+            var type = data.type;
+
+            if (removeHandlers[type]) {
+                try {
+                    removeHandlers[type](ctx, box, data, h);
+                } catch (e) {
+                    console.error(e);
+                }
+            }
+        }
+    };
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        require('../../common/common-messaging'),
+        require('../../common/common-hash'),
+        require('../../common/common-util'),
+        require('chainpad-crypto'),
+        require('../../common/login-block')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-messaging.js',
+        '/common/common-hash.js',
+        '/common/common-util.js',
+        '/components/chainpad-crypto/crypto.js',
+        '/common/outer/login-block.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/components/migrate-user-object.js b/src/worker/components/migrate-user-object.js
new file mode 100644
index 000000000..a38f62e24
--- /dev/null
+++ b/src/worker/components/migrate-user-object.js
@@ -0,0 +1,544 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (AppConfig = {}, Feedback, Hash, Util,
+            Messaging, Crypt, Mailbox, Messages = {},
+            Realtime, nThen, Crypto) => {
+
+    const setCustomize = data => {
+        AppConfig = data.AppConfig;
+        Messages = data.Messages;
+    };
+
+    // Start migration check
+    // Versions:
+    // 1: migrate pad attributes
+    // 2: migrate indent settings (codemirror)
+
+    let migrate = function (userObject, cb, progress, store) {
+        var version = userObject.version || 0;
+
+        nThen(function () {
+            // DEPRECATED
+            // Migration 1: pad attributes moved to filesData
+            var migratePadAttributesToData = function () {
+                return true;
+            };
+            if (version < 1) {
+                migratePadAttributesToData();
+            }
+        }).nThen(function () {
+            // Migration 2: global attributes from root to 'settings' subobjects
+            var migrateAttributes = function () {
+                var drawer = 'cryptpad.userlist-drawer';
+                var polls = 'cryptpad.hide_poll_text';
+                var indentKey = 'cryptpad.indentUnit';
+                var useTabsKey = 'cryptpad.indentWithTabs';
+                var settings = userObject.settings = userObject.settings || {};
+                if (typeof(userObject[indentKey]) !== "undefined") {
+                    settings.codemirror = settings.codemirror || {};
+                    settings.codemirror.indentUnit = userObject[indentKey];
+                    delete userObject[indentKey];
+                }
+                if (typeof(userObject[useTabsKey]) !== "undefined") {
+                    settings.codemirror = settings.codemirror || {};
+                    settings.codemirror.indentWithTabs = userObject[useTabsKey];
+                    delete userObject[useTabsKey];
+                }
+                if (typeof(userObject[drawer]) !== "undefined") {
+                    settings.toolbar = settings.toolbar || {};
+                    settings.toolbar['userlist-drawer'] = userObject[drawer];
+                    delete userObject[drawer];
+                }
+                if (typeof(userObject[polls]) !== "undefined") {
+                    settings.poll = settings.poll || {};
+                    settings.poll['hide-text'] = userObject[polls];
+                    delete userObject[polls];
+                }
+            };
+            if (version < 2) {
+                migrateAttributes();
+                Feedback.send('Migrate-2', true);
+                userObject.version = version = 2;
+            }
+        }).nThen(function () {
+            // Migration 3: language from localStorage to settings
+            var migrateLanguage = function () {
+                if (!localStorage.CRYPTPAD_LANG) { return; }
+                var l = localStorage.CRYPTPAD_LANG;
+                userObject.settings.language = l;
+            };
+            if (version < 3) {
+                migrateLanguage();
+                Feedback.send('Migrate-3', true);
+                userObject.version = version = 3;
+            }
+        }).nThen(function () {
+            // Migration 4: allowUserFeedback to settings
+            var migrateFeedback = function () {
+                var settings = userObject.settings = userObject.settings || {};
+                if (typeof(userObject['allowUserFeedback']) !== "undefined") {
+                    settings.general = settings.general || {};
+                    settings.general.allowUserFeedback = userObject['allowUserFeedback'];
+                    delete userObject['allowUserFeedback'];
+                }
+            };
+            if (version < 4) {
+                migrateFeedback();
+                Feedback.send('Migrate-4', true);
+                userObject.version = version = 4;
+            }
+        }).nThen(function () {
+            // Migration 5: dates to Number
+            var migrateDates = function () {
+                var data = userObject.drive && userObject.drive.filesData;
+                if (data) {
+                    for (var id in data) {
+                        if (typeof data[id].ctime !== "number") {
+                            data[id].ctime = +new Date(data[id].ctime);
+                        }
+                        if (typeof data[id].atime !== "number") {
+                            data[id].atime = +new Date(data[id].atime);
+                        }
+                    }
+                }
+            };
+            if (version < 5) {
+                migrateDates();
+                Feedback.send('Migrate-5', true);
+                userObject.version = version = 5;
+            }
+        }).nThen(function (waitFor) {
+            var addChannelId = function () {
+                var data = userObject.drive.filesData || {};
+                var el, parsed;
+                var n = nThen(function () {});
+                var padsLength = Object.keys(data).length;
+                Object.keys(data).forEach(function (k, i) {
+                    n = n.nThen(function (w) {
+                        setTimeout(w(function () {
+                            el = data[k];
+                            parsed = Hash.parsePadUrl(el.href);
+                            if (!el.href) { return; }
+                            if (!el.channel) {
+                                var secret = Hash.getSecrets(parsed.type, parsed.hash, el.password);
+                                el.channel = secret.channel;
+                                progress(6, Math.round(100*i/padsLength));
+                                console.log('Adding missing channel in filesData ', el.channel);
+                            }
+                        }));
+                    });
+                });
+                n.nThen(waitFor(function () {
+                    Feedback.send('Migrate-6', true);
+                    userObject.version = version = 6;
+                }));
+            };
+            if (version < 6) {
+                addChannelId();
+            }
+        }).nThen(function (waitFor) {
+            var addRoHref = function () {
+                var data = userObject.drive.filesData;
+                var el, parsed;
+                var n = nThen(function () {});
+                var padsLength = Object.keys(data).length;
+                Object.keys(data).forEach(function (k, i) {
+                    n = n.nThen(function (w) {
+                        setTimeout(w(function () {
+                            el = data[k];
+                            if (!el.href) {
+                                // Already migrated
+                                return void progress(7, Math.round(100*i/padsLength));
+                            }
+                            if (el.href.indexOf('#') === -1) {
+                                // Encrypted href: already migrated
+                                return void progress(7, Math.round(100*i/padsLength));
+                            }
+                            parsed = Hash.parsePadUrl(el.href);
+                            if (parsed.hashData.type !== "pad") {
+                                // No read-only mode for files
+                                return void progress(7, Math.round(100*i/padsLength));
+                            }
+                            if (parsed.hashData.mode === "view") {
+                                // This is a read-only pad in our drive
+                                el.roHref = el.href;
+                                delete el.href;
+                                console.log('Move href to roHref in filesData ', el.roHref);
+                            } else {
+                                var secret = Hash.getSecrets(parsed.type, parsed.hash, el.password);
+                                var hash = Hash.getViewHashFromKeys(secret);
+                                if (hash) {
+                                    // Version 0 won't have a view hash available
+                                    el.roHref = '/' + parsed.type + '/#' + hash;
+                                    console.log('Adding missing roHref in filesData ', el.href);
+                                }
+                            }
+                            progress(6, Math.round(100*i/padsLength));
+                        }));
+                    });
+                });
+                n.nThen(waitFor(function () {
+                    Feedback.send('Migrate-7', true);
+                    userObject.version = version = 7;
+                }));
+            };
+            if (version < 7) {
+                addRoHref();
+            }
+        }).nThen(function () {
+            // Migration 8: remove duplicate entries in proxy.FS_hashes (list of migrated anon drives)
+            var fixDuplicate = function () {
+                userObject.FS_hashes = Util.deduplicateString(userObject.FS_hashes || []);
+            };
+            if (version < 8) {
+                fixDuplicate();
+                Feedback.send('Migrate-8', true);
+                userObject.version = version = 8;
+            }
+        }).nThen(function () {
+            // Migration 9: send our mailbox channel to existing friends
+            var migrateFriends = function () {
+                var network = store.network;
+                var channels = {};
+                var ctx = {
+                    store: store
+                };
+                var myData = Messaging.createData(userObject);
+
+                var close = function (chan) {
+                    var channel = channels[chan];
+                    if (!channel) { return; }
+                    try {
+                        channel.wc.leave();
+                    } catch (e) {}
+                    delete channels[chan];
+                };
+
+                var onDirectMessage = function (msg, sender) {
+                    if (sender !== network.historyKeeper) { return; }
+                    var parsed = JSON.parse(msg);
+
+                    // Metadata msg? we don't care
+                    if ((parsed.validateKey || parsed.owners) && parsed.channel) { return; }
+
+                    // End of history message, "onReady"
+                    if (parsed.channel && channels[parsed.channel]) {
+                        // History cleared while we were offline
+                        // ==> we asked for an invalid last known hash
+                        if (parsed.error && parsed.error === "EINVAL") {
+                            var histMsg = ['GET_HISTORY', parsed.channel, {}];
+                            network.sendto(network.historyKeeper, JSON.stringify(histMsg))
+                              .then(function () {}, function () {});
+                            return;
+                        }
+                        // End of history
+                        if (parsed.state && parsed.state === 1) {
+                            // Channel is ready and we didn't receive their mailbox channel: send our channel
+                            myData.channel = parsed.channel;
+                            var updateMsg = ['UPDATE', myData.curvePublic, +new Date(), myData];
+                            var cryptMsg = channels[parsed.channel].encrypt(JSON.stringify(updateMsg));
+                            channels[parsed.channel].wc.bcast(cryptMsg).then(function () {}, function (err) {
+                                console.error("Can't migrate this friend", channels[parsed.channel].friend, err);
+                            });
+                            close(parsed.channel);
+                            return;
+                        }
+                    } else if (parsed.channel) {
+                        return;
+                    }
+
+                    // History message: we only care about "UPDATE" messages
+                    var chan = parsed[3];
+                    if (!chan || !channels[chan]) { return; }
+                    var channel = channels[chan];
+                    var msgIn = channel.decrypt(parsed[4]);
+                    var parsedMsg = JSON.parse(msgIn);
+                    if (parsedMsg[0] === 'UPDATE') {
+                        if (parsedMsg[1] === myData.curvePublic) { return; }
+                        var data = parsedMsg[3];
+                        // If it doesn't contain the mailbox channel, ignore the message
+                        if (!data.notifications) { return; }
+                        // Otherwise we know their channel, we can send them our own
+                        channel.friend.notifications = data.notifications;
+                        myData.channel = chan;
+                        Mailbox.sendTo(ctx, 'UPDATE_DATA', myData, {
+                            channel: data.notifications,
+                            curvePublic: data.curvePublic
+                        }, function (obj) {
+                            if (obj && obj.error) { return void console.error(obj); }
+                            console.log('friend migrated', channel.friend);
+                        });
+                        close(chan);
+                    }
+                };
+
+                network.on('message', function(msg, sender) {
+                    try {
+                        onDirectMessage(msg, sender);
+                    } catch (e) {
+                        console.error(e);
+                    }
+                });
+
+                var friends = userObject.friends || {};
+                Object.keys(friends).forEach(function (curve) {
+                    if (curve.length !== 44) { return; }
+                    var friend = friends[curve];
+
+                    // Check if it is already a "new" friend
+                    if (friend.notifications) { return; }
+
+                    /** Old friend:
+                     *  1. Open the messenger channel
+                     *  2. Check if they sent us their mailbox channel
+                     *  3.a. Yes ==> sent them a mail containing our mailbox channel
+                     *  3.b. No  ==> post our mailbox data to the messenger channel
+                     */
+                    network.join(friend.channel).then(function (wc) {
+                        var keys = Crypto.Curve.deriveKeys(friend.curvePublic, userObject.curvePrivate);
+                        var encryptor = Crypto.Curve.createEncryptor(keys);
+                        channels[friend.channel] = {
+                            wc: wc,
+                            friend: friend,
+                            decrypt: encryptor.decrypt,
+                            encrypt: encryptor.encrypt
+                        };
+                        var cfg = {
+                            lastKnownHash: friend.lastKnownHash
+                        };
+                        var msg = ['GET_HISTORY', friend.channel, cfg];
+                        network.sendto(network.historyKeeper, JSON.stringify(msg))
+                          .then(function () {}, function (err) {
+                            console.error("Can't migrate this friend", friend, err);
+                        });
+                    }, function (err) {
+                        console.error("Can't migrate this friend", friend, err);
+                    });
+                });
+            };
+            if (version < 9) {
+                migrateFriends();
+                Feedback.send('Migrate-9', true);
+                userObject.version = version = 9;
+            }
+        }).nThen(function (waitFor) {
+            // Migration 10: deprecate todo
+            var fixTodo = function () {
+                var h = store.proxy.todo;
+                if (!h) { return; }
+                var next = waitFor(function () {
+                    Feedback.send('Migrate-10', true);
+                    userObject.version = version = 10;
+                });
+                var old;
+                var opts = {
+                    network: store.network,
+                    initialState: '{}',
+                    metadata: {
+                        owners: store.proxy.edPublic ? [store.proxy.edPublic] : []
+                    }
+                };
+                nThen(function (w) {
+                    Crypt.get(h, w(function (err, val) {
+                        if (err || !val) {
+                            w.abort();
+                            next();
+                            return;
+                        }
+                        try {
+                            old = JSON.parse(val);
+                        } catch (e) {} // We will abort in the next step in case of error
+                    }), opts);
+                }).nThen(function (w) {
+                    if (!old || typeof(old) !== "object") {
+                        w.abort();
+                        next();
+                        return;
+                    }
+                    var k = {
+                        content: {
+                            data: {
+                                "1": {
+                                    id: "1",
+                                    color: 'color6',
+                                    item: [],
+                                    title: Messages.kanban_todo
+                                },
+                                "2": {
+                                    id: "2",
+                                    color: 'color3',
+                                    item: [],
+                                    title: Messages.kanban_working
+                                },
+                                "3": {
+                                    id: "3",
+                                    color: 'color5',
+                                    item: [],
+                                    title: Messages.kanban_done
+                                },
+                            },
+                            items: {},
+                            list: [1, 2, 3]
+                        },
+                        metadata: {
+                            title: Messages.type.todo,
+                            defaultTitle: Messages.type.todo,
+                            type: "kanban"
+                        }
+                    };
+                    var i = 4;
+                    var items = false;
+                    (old.order || []).forEach(function (key) {
+                        var data = old.data[key];
+                        if (!data || !data.task) { return; }
+                        items = true;
+                        var column = data.state ? '3' : '1';
+                        k.content.data[column].item.push(i);
+                        k.content.items[i] = {
+                            id: i,
+                            title: data.task
+                        };
+                        i++;
+                    });
+                    if (!items) {
+                        w.abort();
+                        next();
+                        return;
+                    }
+                    var newH = Hash.createRandomHash('kanban');
+                    var secret = Hash.getSecrets('kanban', newH);
+                    var oldSecret = Hash.getSecrets('todo', h);
+                    Crypt.put(newH, JSON.stringify(k), w(function (err) {
+                        if (err) {
+                            w.abort();
+                            next();
+                            return;
+                        }
+                        if (store.rpc) {
+                            store.rpc.pin([secret.channel], function () {
+                                // Try to pin and ignore errors...
+                                // Todo won't be available anyway so keep your unpinned kanban
+                            });
+                            store.rpc.unpin([oldSecret.channel], function () {
+                                // Try to unpin and ignore errors...
+                            });
+                        }
+                        var href = Hash.hashToHref(newH, 'kanban');
+                        store.manager.addPad(['root'], {
+                            title: Messages.type.todo,
+                            owners: opts.metadata.owners,
+                            channel: secret.channel,
+                            href: href,
+                            roHref: Hash.hashToHref(Hash.getViewHashFromKeys(secret), 'kanban'),
+                            atime: +new Date(),
+                            ctime: +new Date()
+                        }, w(function (e) {
+                            if (e) { return void console.error(e); }
+                            delete store.proxy.todo;
+                            var myData = Messaging.createData(userObject);
+                            var ctx = { store: store };
+                            Mailbox.sendTo(ctx, 'MOVE_TODO', {
+                                user: myData,
+                                href: href,
+                            }, {
+                                channel: myData.notifications,
+                                curvePublic: myData.curvePublic
+                            }, function (obj) {
+                                if (obj && obj.error) { return void console.error(obj); }
+                            });
+                        }));
+                    }), opts);
+                }).nThen(function () {
+                    next();
+                });
+            };
+            if (version < 10) {
+                fixTodo();
+            }
+        }).nThen(function (waitFor) {
+            if (version >= 11) { return; }
+            // Migration 11: alert users of safe links as the new default
+
+            var done = function () {
+                Feedback.send('Migrate-11', true);
+                userObject.version = version = 11;
+            };
+
+            /*  userObject.settings.security.unsafeLinks
+                    undefined => the user has never touched it
+                    false => the user has explicitly enabled "safe links"
+                    true => the user has explicitly disabled "safe links"
+            */
+            var unsafeLinks = Util.find(userObject, [ 'settings', 'security', 'unsafeLinks' ]);
+            if (unsafeLinks !== undefined) { return void done(); }
+
+            var ctx = {
+                store: store,
+            };
+            var myData = Messaging.createData(userObject);
+            if (!myData.curvePublic) { return void done(); }
+
+            Mailbox.sendTo(ctx, 'SAFE_LINKS_DEFAULT', {
+                user: myData,
+            }, {
+                channel: myData.notifications,
+                curvePublic: myData.curvePublic
+            }, waitFor(function (obj) {
+                if (obj && obj.error) { return void console.error(obj); }
+                done();
+            }));
+        /*}).nThen(function (waitFor) {
+            // Test progress bar in the loading screen
+            var i = 0;
+            var w = waitFor();
+            var it = setInterval(function () {
+                i += 5;
+                if (i >= 100) { w(); clearInterval(it); i = 100;}
+                progress(0, i);
+            }, 500);
+            progress(0, 0);*/
+        }).nThen(function () {
+            Realtime.whenRealtimeSyncs(store.realtime, Util.mkAsync(Util.bake(cb)));
+        });
+    };
+    migrate.setCustomize = setCustomize;
+    return migrate;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        undefined,
+        require('../../common/common-feedback'),
+        require('../../common/common-hash'),
+        require('../../common/common-util'),
+        require('../../common/common-messaging'),
+        require('../../common/cryptget'),
+        require('../modules/mailbox'),
+        undefined,
+        require('../../common/common-realtime'),
+        require('nthen'),
+        require('chainpad-crypto')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/customize/application_config.js',
+        '/common/common-feedback.js',
+        '/common/common-hash.js',
+        '/common/common-util.js',
+        '/common/common-messaging.js',
+        '/common/cryptget.js',
+        '/common/outer/mailbox.js',
+        '/customize/messages.js',
+        '/common/common-realtime.js',
+        '/components/nthen/index.js',
+        '/components/chainpad-crypto/crypto.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
+
diff --git a/src/worker/components/recurrence.js b/src/worker/components/recurrence.js
new file mode 100644
index 000000000..5e530f178
--- /dev/null
+++ b/src/worker/components/recurrence.js
@@ -0,0 +1,908 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Util) => {
+    var Rec = {};
+
+    const window = globalThis;
+    var debug = function () {};
+
+    // Get week number with any "WKST" (firts day of the week)
+    // Week 1 is the first week of the year containing at least 4 days in this year
+    // It depends on which day is considered the first day of the week (default Monday)
+    // In our case, wkst is a number matching the JS rule: 0 == Sunday
+    var getWeekNo = Rec.getWeekNo = function (date, wkst) {
+        if (typeof(wkst) !== "number") { wkst = 1; } // Default monday
+
+        var newYear = new Date(date.getFullYear(),0,1);
+        var day = newYear.getDay() - wkst; //the day of week the year begins on
+        day = (day >= 0 ? day : day + 7);
+        var daynum = Math.floor((date.getTime() - newYear.getTime())/86400000) + 1;
+        var weeknum;
+        // Week 1 / week 53
+        if (day < 4) {
+            weeknum = Math.floor((daynum+day-1)/7) + 1;
+            if (weeknum > 52) {
+                var nYear = new Date(date.getFullYear() + 1,0,1);
+                var nday = nYear.getDay() - wkst;
+                nday = nday >= 0 ? nday : nday + 7;
+                weeknum = nday < 4 ? 1 : 53;
+            }
+        }
+        else {
+            weeknum = Math.floor((daynum+day-1)/7);
+        }
+        return weeknum;
+    };
+
+    var getYearDay = function (date) {
+        var start = new Date(date.getFullYear(), 0, 0);
+        var diff = (date - start) +
+                    ((start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000);
+        var oneDay = 1000 * 60 * 60 * 24;
+        return Math.floor(diff / oneDay);
+    };
+    var setYearDay = function (date, day) {
+        if (typeof(day) !== "number" || Math.abs(day) < 1 || Math.abs(day) > 366) { return; }
+        if (day < 0) {
+            var max = getYearDay(new Date(date.getFullYear(), 11, 31));
+            day = max + day + 1;
+        }
+        date.setMonth(0);
+        date.setDate(day);
+        return true;
+    };
+
+    var getEndData = function (s, e) {
+        if (s > e) { return void console.error("Wrong data"); }
+        var days;
+        if (e.getFullYear() === s.getFullYear()) {
+            days = getYearDay(e) - getYearDay(s);
+        } else { // eYear < sYear
+            var tmp = new Date(s.getFullYear(), 11, 31);
+            var d1 = getYearDay(tmp) - getYearDay(s); // Number of days before December 31st
+            var de = getYearDay(e);
+            days = d1 + de;
+            while ((tmp.getFullYear()+1) < e.getFullYear()) {
+                tmp.setFullYear(tmp.getFullYear()+1);
+                days += getYearDay(tmp);
+            }
+        }
+        return {
+            h: e.getHours(),
+            m: e.getMinutes(),
+            days: days
+        };
+    };
+    var setEndData = function (s, e, data) {
+        e.setTime(+s);
+        if (!data) { return; }
+        e.setHours(data.h);
+        e.setMinutes(data.m);
+        e.setSeconds(0);
+        e.setDate(s.getDate() + data.days);
+    };
+
+    var DAYORDER = Rec.DAYORDER = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
+    var getDayData = function (str) {
+        var pos = Number(str.slice(0,-2));
+        var day = DAYORDER.indexOf(str.slice(-2));
+        return pos ? [pos, day] : day;
+    };
+
+    var goToFirstWeekDay = function (date, wkst) {
+        var d = date.getDay();
+        wkst = typeof(wkst) === "number" ? wkst : 1;
+        if (d >= wkst) {
+            date.setDate(date.getDate() - (d-wkst));
+        } else {
+            date.setDate(date.getDate() - (7+d-wkst));
+        }
+    };
+
+    var getDateStr = function (date) {
+        return date.getFullYear() + '-' + (date.getMonth()+1) + '-' + date.getDate();
+    };
+    var FREQ = {};
+    FREQ['daily'] = function (s, i) {
+        s.setDate(s.getDate()+i);
+    };
+    FREQ['weekly'] = function (s,i) {
+        s.setDate(s.getDate()+(i*7));
+    };
+    FREQ['monthly'] = function (s,i) {
+        s.setMonth(s.getMonth()+i);
+    };
+    FREQ['yearly'] = function (s,i) {
+        s.setFullYear(s.getFullYear()+i);
+    };
+
+    // EXPAND is used to create iterations added from a BYxxx rule
+    // dateA is the start date and b is the number or id of the BYxxx rule item
+    var EXPAND = {};
+    EXPAND['month'] = function (dateS, origin, b) {
+        var oS = new Date(origin.start);
+        var a = dateS.getMonth() + 1;
+        var toAdd = (b-a+12)%12;
+        var m = dateS.getMonth() + toAdd;
+        dateS.setMonth(m);
+        dateS.setDate(oS.getDate());
+        if (dateS.getMonth() !== m) { return; } // Day 31 may move us to the next month
+        return true;
+    };
+
+
+    EXPAND['weekno'] = function (dateS, origin, week, rule) {
+        var wkst = rule && rule.wkst;
+        if (typeof(wkst) !== "number") { wkst = 1; } // Default monday
+        var oS = new Date(origin.start);
+
+        var lastD = new Date(dateS.getFullYear(), 11, 31); // December 31st
+        var lastW = getWeekNo(lastD, wkst); // Last week of the year is either 52 or 53
+
+        var doubleOne = lastW === 1;
+        if (lastW === 1) { lastW = 52; }
+
+        var a = getWeekNo(dateS, wkst);
+        if (!week || week > lastW) { return false; } // Week 53 may not exist this year
+
+        if (week < 0) { week = lastW + week + 1; } // Turn negative week number into positive
+
+        var toAdd = week - a;
+        var weekS = new Date(+dateS);
+        // Go to the selected week
+        weekS.setDate(weekS.getDate() + (toAdd * 7));
+        goToFirstWeekDay(weekS, wkst);
+
+        // Then make sure we are in the correct start day
+        var all = 'aaaaaaa'.split('').map(function (o, i) {
+            var date = new Date(+weekS);
+            date.setDate(date.getDate() + i);
+            if (date.getFullYear() !== dateS.getFullYear()) { return; }
+            return date.toLocaleDateString() !== oS.toLocaleDateString() && date;
+        }).filter(Boolean);
+
+        // If we're looking for week 1 and the last week is a week 1, add the days
+        if (week === 1 && doubleOne) {
+            goToFirstWeekDay(lastD, wkst);
+            'aaaaaaa'.split('').some(function (o, i) {
+                var date = new Date(+lastD);
+                date.setDate(date.getDate() + i);
+                if (date.toLocaleDateString() === oS.toLocaleDateString()) { return; }
+                if (date.getFullYear() > dateS.getFullYear()) { return true; }
+                all.push(date);
+            });
+        }
+
+        return all.length ? all : undefined;
+    };
+    EXPAND['yearday'] = function (dateS, origin, b) {
+        var y = dateS.getFullYear();
+        var state = setYearDay(dateS, b);
+        if (!state) { return; } // Invalid day "b"
+        if (dateS.getFullYear() !== y) { return; } // Day 366 make move us to the next year
+        return true;
+    };
+    EXPAND['monthday'] = function (dateS, origin, b, rule) {
+        if (typeof(b) !== "number" || Math.abs(b) < 1 || Math.abs(b) > 31) { return false; }
+
+        var setMonthDay = function (date, day) {
+            var m = date.getMonth();
+            if (day < 0) {
+                var tmp = new Date(date.getFullYear(), date.getMonth()+1, 0); // Last day
+                day = tmp.getDate() + day + 1;
+            }
+            date.setDate(day);
+            return date.getMonth() === m; // Don't push if day 31 moved us to the next month
+
+        };
+
+        // Monthly events
+        if (rule.freq === 'monthly') {
+            return setMonthDay(dateS, b);
+        }
+
+        var all = 'aaaaaaaaaaaa'.split('').map(function (o, i) {
+            var date = new Date(dateS.getFullYear(), i, 1);
+            var ok = setMonthDay(date, b);
+            return ok ? date : undefined;
+        }).filter(Boolean);
+        return all.length ? all : undefined;
+    };
+    EXPAND['day'] = function (dateS, origin, b, rule) {
+        // Here "b" can be a single day ("TU") or a position and a day ("1MO")
+        var day = getDayData(b);
+        var pos;
+        if (Array.isArray(day)) {
+            pos = day[0];
+            day = day[1];
+        }
+
+        var all = [];
+        if (![0,1,2,3,4,5,6].includes(day)) { return false; }
+
+        var filterPos = function (m) {
+            if (!pos) { return; }
+
+            var _all = [];
+            'aaaaaaaaaaaa'.split('').some(function (a, i) {
+                if (typeof(m) !== "undefined" && i !== m) { return; }
+
+                var _pos;
+                var tmp = all.filter(function (d) {
+                    return d.getMonth() === i;
+                });
+                if (pos < 0) {
+                    _pos = tmp.length + pos;
+                } else {
+                    _pos = pos - 1; // An array starts at 0 but the recurrence rule starts at 1
+                }
+                _all.push(tmp[_pos]);
+
+                return typeof(m) !== "undefined" && i === m;
+            });
+            all = _all.filter(Boolean); // The "5th" {day} won't always exist
+        };
+
+        var tmp;
+        if (rule.freq === 'yearly') {
+            tmp = new Date(+dateS);
+            var y = dateS.getFullYear();
+            while (tmp.getDay() !== day) { tmp.setDate(tmp.getDate()+1); }
+            while (tmp.getFullYear() === y) {
+                all.push(new Date(+tmp));
+                tmp.setDate(tmp.getDate()+7);
+            }
+            filterPos();
+            return all;
+        }
+
+        if (rule.freq === 'monthly') {
+            tmp = new Date(+dateS);
+            var m = dateS.getMonth();
+            while (tmp.getDay() !== day) { tmp.setDate(tmp.getDate()+1); }
+            while (tmp.getMonth() === m) {
+                all.push(new Date(+tmp));
+                tmp.setDate(tmp.getDate()+7);
+            }
+            filterPos(m);
+            return all;
+        }
+
+        if (rule.freq === 'weekly') {
+            while (dateS.getDay() !== day) { dateS.setDate(dateS.getDate()+1); }
+        }
+        return true;
+    };
+
+    var LIMIT = {};
+    LIMIT['month'] = function (events, rule) {
+        return events.filter(function (s) {
+            return rule.includes(s.getMonth()+1);
+        });
+    };
+    LIMIT['weekno'] = function (events, weeks, rules) {
+        return events.filter(function (s) {
+            var wkst = rules && rules.wkst;
+            if (typeof(wkst) !== "number") { wkst = 1; } // Default monday
+
+            var lastD = new Date(s.getFullYear(), 11, 31); // December 31st
+            var lastW = getWeekNo(lastD, wkst); // Last week of the year is either 52 or 53
+            if (lastW === 1) { lastW = 52; }
+
+            var w = getWeekNo(s, wkst);
+
+            return weeks.some(function (week) {
+                if (week > 0) { return week === w; }
+                return w === (lastW + week + 1);
+            });
+        });
+    };
+    LIMIT['yearday'] = function (events, days) {
+        return events.filter(function (s) {
+            var d = getYearDay(s);
+            var max = getYearDay(new Date(s.getFullYear(), 11, 31));
+
+            return days.some(function (day) {
+                if (day > 0) { return day === d; }
+                return d === (max + day + 1);
+            });
+        });
+    };
+    LIMIT['monthday'] = function (events, rule) {
+        return events.filter(function (s) {
+            var r = Util.clone(rule);
+            // Transform the negative monthdays into positive for this specific month
+            r = r.map(function (b) {
+                if (b < 0) {
+                    var tmp = new Date(s.getFullYear(), s.getMonth()+1, 0); // Last day
+                    b = tmp.getDate() + b + 1;
+                }
+                return b;
+            });
+            return r.includes(s.getDate());
+        });
+    };
+    LIMIT['day'] = function (events, days, rules) {
+        return events.filter(function (s) {
+            var dayStr = s.toLocaleDateString();
+
+            // Check how to handle position in BYDAY rules (last day of the month or the year?)
+            var type = 'yearly';
+            if (rules.freq === 'monthly' ||
+                (rules.freq === 'yearly' && rules.by && rules.by.month)) {
+                type = 'monthly';
+            }
+
+            // Check if this event matches one of the allowed days
+            return days.some(function (r) {
+                // rule elements are strings with pos and day
+                var day = getDayData(r);
+                var pos;
+                if (Array.isArray(day)) {
+                    pos = day[0];
+                    day = day[1];
+                }
+                if (!pos) {
+                    return s.getDay() === day;
+                }
+
+                // If we have a position, we can use EXPAND.day to get the nth {day} of the
+                // year/month and compare if it matches with
+                var d = new Date(s.getFullYear(), s.getMonth(), 1);
+                if (type === 'yearly') { d.setMonth(0); }
+                var res = EXPAND["day"](d, {}, r, {freq: type});
+                return res.some(function (date) {
+                    return date.toLocaleDateString() === dayStr;
+                });
+            });
+        });
+    };
+    LIMIT['setpos'] = function (events, rule) {
+        var init = events.slice();
+        var rules = Util.deduplicateString(rule.slice().map(function (n) {
+            if (n > 0) { return (n-1); }
+            if (n === 0) { return; }
+            return init.length + n;
+        }));
+        return events.filter(function (ev) {
+            var idx = init.indexOf(ev);
+            return rules.includes(idx);
+        });
+    };
+
+    var BYORDER = ['month','weekno','yearday','monthday','day'];
+    var BYDAYORDER = ['month','monthday','day'];
+
+    Rec.getMonthId = function (d) {
+        return d.getFullYear() + '-' + d.getMonth();
+    };
+    var cache = window.CP_calendar_cache = {};
+    var recurringAcross = {};
+    Rec.resetCache = function () {
+        cache = window.CP_calendar_cache = {};
+        recurringAcross = {};
+    };
+
+    var iterate = function (rule, _origin, s) {
+        // "origin" is the original event to detect the start of BYxxx
+        var origin = Util.clone(_origin);
+        var oS = new Date(origin.start);
+
+        var id = origin.id.split('|')[0]; // Use same cache when updating recurrence rule
+
+        // "uid" is used for the cache
+        var uid = s.toLocaleDateString();
+        cache[id] = cache[id] || {};
+
+        var inter = rule.interval || 1;
+        var freq = rule.freq;
+
+        var all = [];
+        var limit = function (byrule, n) {
+            all = LIMIT[byrule](all, n, rule);
+        };
+        var expand = function (byrule) {
+            return function (n) {
+                // Set the start date at the beginning of the current FREQ
+                var _s = new Date(+s);
+                if (rule.freq === 'yearly') {
+                    // January 1st
+                    _s.setMonth(0);
+                    _s.setDate(1);
+                } else if (rule.freq === 'monthly') {
+                    _s.setDate(1);
+                } else if (rule.freq === 'weekly') {
+                    goToFirstWeekDay(_s, rule.wkst);
+                } else if (rule.freq === 'daily') {
+                    // We don't have < byday rules so we can't expand daily rules
+                }
+
+                var add = EXPAND[byrule](_s, origin, n, rule);
+
+                if (!add) { return; }
+
+                if (Array.isArray(add)) {
+                    add = add.filter(function (dateS) {
+                        return dateS.toLocaleDateString() !== oS.toLocaleDateString();
+                    });
+                    Array.prototype.push.apply(all, add);
+                } else {
+                    if (_s.toLocaleDateString() === oS.toLocaleDateString()) { return; }
+                    all.push(_s);
+                }
+            };
+        };
+
+        // Manage interval for the next iteration
+        var it = Util.once(function () {
+            FREQ[freq](s, inter);
+        });
+        var addDefault = function () {
+            if (freq === "monthly") {
+                s.setDate(15);
+            } else if (freq === "yearly" && oS.getMonth() === 1 && oS.getDate() === 29) {
+                s.setDate(28);
+            }
+
+            it();
+
+            var _s = new Date(+s);
+            if (freq === "monthly" || freq === "yearly") {
+                _s.setDate(oS.getDate());
+                if (_s.getDate() !== oS.getDate()) { return; } // If 31st or Feb 29th doesn't exist
+                if (freq === "yearly" && _s.getMonth() !== oS.getMonth()) { return; }
+
+                // FIXME if there is a recUpdate that moves the 31st to the 30th, the event
+                // will still only be displayed on months with 31 days
+            }
+            all.push(_s);
+        };
+
+        if (Array.isArray(cache[id][uid])) {
+            debug('Get cache', id, uid);
+            if (freq === "monthly") {
+                s.setDate(15);
+            } else if (freq === "yearly" && oS.getMonth() === 1 && oS.getDate() === 29) {
+                s.setDate(28);
+            }
+            it();
+            return cache[id][uid];
+        }
+
+        if (rule.by && freq === 'yearly') {
+            var order = BYORDER.slice();
+            var monthLimit = false;
+            if (rule.by.weekno || rule.by.yearday || rule.by.monthday || rule.by.day) {
+                order.shift();
+                monthLimit = true;
+            }
+            var first = true;
+            order.forEach(function (_order) {
+                var r = rule.by[_order];
+                if (!r) { return; }
+                if (first) {
+                    r.forEach(expand(_order));
+                    first = false;
+                } else if (_order === "day") {
+                    if (rule.by.yearday || rule.by.monthday || rule.by.weekno) {
+                        limit('day', rule.by.day);
+                    } else {
+                        rule.by.day.forEach(expand('day'));
+                    }
+                } else {
+                    limit(_order, r);
+                }
+            });
+            if (rule.by.month && monthLimit) {
+                limit('month', rule.by.month);
+            }
+        }
+        if (rule.by && freq === 'monthly') {
+            // We're going to compute all the entries for the coming month
+            if (!rule.by.monthday && !rule.by.day) {
+                addDefault();
+            } else if (rule.by.monthday) {
+                rule.by.monthday.forEach(expand('monthday'));
+            } else if (rule.by.day) {
+                rule.by.day.forEach(expand('day'));
+            }
+            if (rule.by.month) {
+                limit('month', rule.by.month);
+            }
+            if (rule.by.day && rule.by.monthday) {
+                limit('day', rule.by.day);
+            }
+        }
+        if (rule.by && freq === 'weekly') {
+            // We're going to compute all the entries for the coming week
+            if (!rule.by.day) {
+                addDefault();
+            } else {
+                rule.by.day.forEach(expand('day'));
+            }
+            if (rule.by.month) {
+                limit('month', rule.by.month);
+            }
+        }
+        if (rule.by && freq === 'daily') {
+            addDefault();
+            BYDAYORDER.forEach(function (_order) {
+                var r = rule.by[_order];
+                if (!r) { return; }
+                limit(_order, r);
+            });
+        }
+
+        all.sort(function (a, b) {
+            return a-b;
+        });
+
+        if (rule.by && rule.by.setpos) {
+            limit('setpos', rule.by.setpos);
+        }
+
+        if (!rule.by || !Object.keys(rule.by).length) {
+            addDefault();
+        } else {
+            it();
+        }
+
+
+        var done = [];
+        all = all.filter(function (newS) {
+            var start = new Date(+newS).toLocaleDateString();
+            if (done.includes(start)) { return false; }
+            done.push(start);
+            return true;
+        });
+
+        debug('Set cache', id, uid);
+        cache[id][uid] = all;
+
+        return all;
+    };
+
+    var getNextRules = function (obj) {
+        if (!obj.recUpdate) { return []; }
+        var _allRules = {};
+        var _obj = obj.recUpdate.from;
+        Object.keys(_obj || {}).forEach(function (d) {
+            var u = _obj[d];
+            if (u.recurrenceRule) { _allRules[d] = u.recurrenceRule; }
+        });
+        return Object.keys(_allRules).sort(function (a, b) { return Number(a)-Number(b); })
+                      .map(function (k) {
+            var r = Util.clone(_allRules[k]);
+            if (!FREQ[r.freq]) { return; }
+            if (r.interval && r.interval < 1) { return; }
+            r._start = Number(k);
+            return r;
+        }).filter(Boolean);
+    };
+
+    var fixTimeZone = function (evTimeZone, origin, target) {
+        var getOffset = function (date, tz) {
+            // Get an ISO string using Canadian local format
+            let iso = date.toLocaleString('en-CA', { timeZone:tz, hour12: false }).replace(', ', 'T');
+            iso += '.' + date.getMilliseconds().toString().padStart(3, '0');
+
+            // Get a UTC version of this time
+            let utcDate = new Date(iso + 'Z');
+
+            // Return the difference in timestamps, as minutes (60*1000)
+            return -(utcDate - date);
+        };
+
+        var myTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        var offset = getOffset(origin, evTimeZone) - getOffset(target, evTimeZone);
+        var myOffset = getOffset(origin, myTimeZone) - getOffset(target, myTimeZone);
+
+        return myOffset - offset;
+    };
+
+    Rec.getRecurring = function (months, events) {
+        if (window.CP_DEV_MODE) { debug = console.warn; }
+
+        var toAdd = [];
+        months.forEach(function (monthId) {
+            // from 1st day of the month at 00:00 to last day at 23:59:59:999
+            var ms = monthId.split('-');
+            var _startMonth = new Date(ms[0], ms[1]);
+            var _endMonth = new Date(+_startMonth);
+            _endMonth.setMonth(_endMonth.getMonth() + 1);
+            _endMonth.setMilliseconds(-1);
+
+            debug('Compute month', _startMonth.toLocaleDateString());
+
+            var rec = events || [];
+            rec.forEach(function (obj) {
+                var _start = new Date(obj.start);
+                var _end = new Date(obj.end);
+                var _origin = obj;
+                var rule = obj.recurrenceRule;
+                if (!rule) { return; }
+
+                var nextRules = getNextRules(obj);
+                var nextRule = nextRules.shift();
+
+                if (_start >= _endMonth) { return; }
+
+                // Check the "until" date of the latest rule we can use and stop now
+                // if the recurrence ends before the current month
+                var until = rule.until;
+                var _nextRules = nextRules.slice();
+                var _nextRule = nextRule;
+                while (_nextRule && _nextRule._start && _nextRule._start < _startMonth) {
+                    until = nextRule.until;
+                    _nextRule = _nextRules.shift();
+                }
+                if (until < _startMonth) { return; }
+
+                var endData = getEndData(_start, _end);
+
+                if (rule.interval && rule.interval < 1) { return; }
+                if (!FREQ[rule.freq]) { return; }
+
+                /*
+                // Rule examples
+                rule.by = {
+                    //month: [1, 4, 5, 8, 12],
+                    //weekno: [1, 2, 4, 5, 32, 34, 35, 50],
+                    //yearday: [1, 2, 29, 30, -2, -1, 250],
+                    //monthday: [1, 2, 3, -3, -2, -1],
+                    //day: ["MO", "WE", "FR"],
+                    //setpos: [1, 2, -1, -2]
+                };
+                rule.wkst = 0;
+                rule.interval = 2;
+                rule.freq = 'yearly';
+                rule.count = 10;
+                */
+                debug('Iterate over', obj.title, obj);
+                debug('Use rule', rule);
+
+                var count = rule.count;
+                var c = 1;
+
+                var next = function (start) {
+                    var evS = new Date(+start);
+
+                    if (count && c >= count) { return; }
+
+                    debug('Start iteration', evS.toLocaleDateString());
+
+                    var _toAdd = iterate(rule, obj, evS);
+
+                    debug('Iteration results', JSON.stringify(_toAdd.map(function (o) { return new Date(o).toLocaleDateString();})));
+
+                    // Make sure to continue if the current year doesn't provide any result
+                    if (!_toAdd.length) {
+                        if (evS.getFullYear() < _startMonth.getFullYear() ||
+                            evS < _endMonth) {
+                            return void next(evS);
+                        }
+                        return;
+                    }
+
+
+                    var stop = false;
+                    var newrule = false;
+                    _toAdd.some(function (_newS) {
+                        // Make event with correct start and end time
+                        var _ev = Util.clone(obj);
+                        _ev.id = _origin.id + '|' + (+_newS);
+                        var _evS = new Date(+_newS);
+                        var _evE = new Date(+_newS);
+                        setEndData(_evS, _evE, endData);
+                        _ev.start = +_evS;
+                        _ev.end = +_evE;
+                        _ev._count = c;
+                        if (_ev.isAllDay && _ev.startDay) { _ev.startDay = getDateStr(_evS); }
+                        if (_ev.isAllDay && _ev.endDay) { _ev.endDay = getDateStr(_evE); }
+
+                        if (nextRule && _ev.start === nextRule._start) {
+                            newrule = true;
+                        }
+
+                        var useNewRule = function () {
+                            if (!newrule) { return; }
+                            debug('Use new rule', nextRule);
+                            _ev._count = c;
+                            count = nextRule.count;
+                            c = 1;
+                            evS = +_evS;
+                            obj = _ev;
+                            rule = nextRule;
+                            nextRule = nextRules.shift();
+                        };
+
+
+                        if (c >= count) { // Limit reached
+                            debug(_evS.toLocaleDateString(), 'count');
+                            stop = true;
+                            return true;
+                        }
+                        if (_evS >= _endMonth) { // Won't affect us anymore
+                            debug(_evS.toLocaleDateString(), 'endMonth');
+                            stop = true;
+                            return true;
+                        }
+                        if (rule.until && _evS > rule.until) {
+                            debug(_evS.toLocaleDateString(), 'until');
+                            stop = true;
+                            return true;
+                        }
+                        if (_evS < _start) { // "Expand" rules may create events before the _start
+                            debug(_evS.toLocaleDateString(), 'start');
+                            return;
+                        }
+                        c++;
+                        if (_evE < _startMonth) { // Ended before the current month
+                            // Nothing to display but continue the recurrence
+                            debug(_evS.toLocaleDateString(), 'startMonth');
+                            if (newrule) { useNewRule(); }
+                            return;
+                        }
+                        // If a recurring event start and end in different months, make sure
+                        // it is only added once
+                        if ((_evS < _endMonth && _evE >= _endMonth) ||
+                                (_evS < _startMonth && _evE >= _startMonth)) {
+                            if (recurringAcross[_ev.id] && recurringAcross[_ev.id].includes(_ev.start)) {
+                                return;
+                            } else {
+                                recurringAcross[_ev.id] = recurringAcross[_ev.id] || [];
+                                recurringAcross[_ev.id].push(_ev.start);
+                            }
+
+                        }
+
+                        // Add this event
+                        if (_origin.timeZone && !_ev.isAllDay) {
+                            var offset = fixTimeZone(_origin.timeZone, _start, _evS);
+                            _ev.start += offset;
+                            _ev.end += offset;
+                        }
+                        toAdd.push(_ev);
+                        if (newrule) {
+                            useNewRule();
+                            return true;
+                        }
+                    });
+                    if (!stop) { next(evS); }
+                };
+                next(_start);
+                debug('Added this month (all events)', toAdd.map(function (ev) {
+                    return new Date(ev.start).toLocaleDateString();
+                }));
+            });
+        });
+        return toAdd;
+    };
+    Rec.getAllOccurrences = function (ev) {
+        if (!ev.recurrenceRule) { return [ev.start]; }
+        var r = ev.recurrenceRule;
+        // In case of infinite recursion, we can't get all
+        if (!r.until && !r.count) { return false; }
+        var all = [ev.start];
+        var d = new Date(ev.start);
+        d.setDate(15); // Make sure we won't skip a month if the event starts on day > 28
+        var toAdd = [];
+
+        var i = 0;
+        var check = function () {
+            return r.count ? (all.length < r.count) : (+d <= r.until);
+        };
+        while ((toAdd = Rec.getRecurring([Rec.getMonthId(d)], [ev])) && check() && i < (r.count*12)) {
+            Array.prototype.push.apply(all, toAdd.map(function (_ev) { return _ev.start; }));
+            d.setMonth(d.getMonth() + 1);
+            i++;
+        }
+
+        return all;
+    };
+
+    Rec.diffDate = function (oldTime, newTime) {
+        var n = new Date(newTime);
+        var o = new Date(oldTime);
+
+        // Diff Days
+        var d = 0;
+        var mult = n < o ? -1 : 1;
+        while (n.toLocaleDateString() !== o.toLocaleDateString() || mult >= 10000) {
+            n.setDate(n.getDate() - mult);
+            d++;
+        }
+        d = mult * d;
+
+        // Diff hours
+        n = new Date(newTime);
+        var h = n.getHours() - o.getHours();
+
+        // Diff minutes
+        var m = n.getMinutes() - o.getMinutes();
+
+        return {
+            d: d,
+            h: h,
+            m: m
+        };
+    };
+
+    var sortUpdate = function (obj) {
+        return Object.keys(obj).sort(function (d1, d2) {
+            return Number(d1) - Number(d2);
+        });
+    };
+    Rec.applyUpdates = function (events) {
+        events.forEach(function (ev) {
+            ev.raw = {
+                start: ev.start,
+                end: ev.end,
+            };
+
+            if (!ev.recUpdate) { return; }
+
+            var from = ev.recUpdate.from || {};
+            var one = ev.recUpdate.one || {};
+            var s = ev.start;
+
+            // Add "until" date to our recurrenceRule if it has been modified in future occurences
+            var nextRules = getNextRules(ev).filter(function (r) {
+                return r._start > s;
+            });
+            var nextRule = nextRules.shift();
+
+            var applyDiff = function (obj, k) {
+                var diff = obj[k]; // Diff is always compared to origin start/end
+                var d = new Date(ev.raw[k]);
+                d.setDate(d.getDate() + diff.d);
+                d.setHours(d.getHours() + diff.h);
+                d.setMinutes(d.getMinutes() + diff.m);
+                ev[k] = +d;
+            };
+
+            sortUpdate(from).forEach(function (d) {
+                if (s < Number(d)) { return; }
+                Object.keys(from[d]).forEach(function (k) {
+                    if (k === 'start' || k === 'end') { return void applyDiff(from[d], k); }
+                    if (k === "recurrenceRule" && !from[d][k]) { return; }
+                    ev[k] = from[d][k];
+                });
+            });
+            Object.keys(one[s] || {}).forEach(function (k) {
+                if (k === 'start' || k === 'end') { return void applyDiff(one[s], k); }
+                if (k === "recurrenceRule" && !one[s][k]) { return; }
+                ev[k] = one[s][k];
+            });
+            if (ev.deleted) {
+                Object.keys(ev).forEach(function (k) {
+                    delete ev[k];
+                });
+            }
+
+            if (nextRule && ev.recurrenceRule) {
+                ev.recurrenceRule._next = nextRule._start - 1;
+            }
+
+            if (ev.reminders) {
+                ev.raw.reminders = ev.reminders;
+            }
+        });
+        return events;
+    };
+
+
+    return Rec;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory('../../common/common-util');
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define(['/common/common-util'], factory);
+} else {
+    // unsupported initialization
+}
+})();
diff --git a/src/worker/components/roster.js b/src/worker/components/roster.js
new file mode 100644
index 000000000..3a0b796c5
--- /dev/null
+++ b/src/worker/components/roster.js
@@ -0,0 +1,958 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(function () {
+var factory = function (Util, Hash, CPNetflux, Sortify, nThen, Crypto, Feedback) {
+    var Roster = {};
+
+    // this constant is somewhat arbitrary.
+    // Adjust it as you like to suit performance expectations
+    var CHECKPOINT_INTERVAL = 25;
+    var TIMEOUT_INTERVAL = 30000; // TIMEOUT after 30s
+
+    /*
+        roster: {
+            state: {
+                members: {
+                    user0CurveKey: {
+                        notifications: "", // required
+                        displayName: "", // required
+                        role: "OWNER|ADMIN|MEMBER|VIEWER", // VIEWER if not specified
+                        profile: "",
+                        title: ""
+                    },
+                    user1CurveKey: {
+                        ...
+                    }
+                },
+                metadata: {
+                    // guaranteed to be strings, but may be empty
+                    topic: '',
+                    name: '',
+                    avatar: '',
+                    // anything else you use may not be defined
+                }
+            }
+        }
+    */
+
+    var isMap = function (obj) {
+        return Boolean(obj && typeof(obj) === 'object' && !Array.isArray(obj));
+    };
+
+    var getMessageId = function (msgString) {
+        return msgString.slice(0, 64);
+    };
+
+    var canCheckpoint = function (author, members) {
+        // if you're here then you've received a checkpoint message
+        // that you don't necessarily trust.
+
+        // find the author's role from your knoweldge of the state
+        var role = Util.find(members, [author, 'role']);
+
+        // and check if it is 'OWNER' or 'ADMIN'
+        return ['OWNER', 'ADMIN'].indexOf(role) !== -1;
+    };
+
+    var isValidRole = function (role) {
+        return ['OWNER', 'ADMIN', 'MEMBER', 'VIEWER'].indexOf(role) !== -1;
+    };
+
+    var isSelfDowngrade = function (author, curve, role, state) {
+        // Make sure you want to describe yourself
+        var selfDescribe = author === curve && state[curve];
+        if (!selfDescribe) { return false; }
+        // ADMIN and OWNER can always update roles
+        // we only need to allow MEMBER to downgrade themselves to VIEWER
+        var authorRole = Util.find(state, [author, 'role']);
+        if (authorRole === "MEMBER") { return role === 'VIEWER'; }
+    };
+
+    var canAddRole = function (author, role, members) {
+        var authorRole = Util.find(members, [author, 'role']);
+        if (!authorRole) { return false; }
+
+        // nobody can add an invalid role
+        if (!isValidRole(role)) { return false; }
+
+        // owners can add any valid role they want
+        if (authorRole === 'OWNER') { return true; }
+        // admins can add other admins or members or viewers
+        if (authorRole === "ADMIN") { return ['ADMIN', 'MEMBER', 'VIEWER'].indexOf(role) !== -1; }
+        // (MEMBER, other) can't add anyone of any role
+        return false;
+    };
+
+    var isValidId = function (id) {
+        return typeof(id) === 'string' && id.length === 44;
+    };
+
+    var canDescribeTarget = function (author, curve, state) {
+        // you must be in the group to describe anyone
+        if (!state[curve]) { return false; }
+
+        // anyone can describe themself
+        if (author === curve && state[curve]) { return true; }
+
+        var authorRole = Util.find(state, [author, 'role']);
+        var targetRole = Util.find(state, [curve, 'role']);
+
+        // something is really wrong if there's no authorRole
+        if (!authorRole) { return false; }
+
+        // owners can do whatever they want
+        if (authorRole === 'OWNER') { return true; }
+
+        // admins can describe anyone escept owners
+        if (authorRole === 'ADMIN' && targetRole !== 'OWNER') { return true; }
+
+        // members can't describe others
+        return false;
+    };
+
+    var canRemoveRole = function (author, role, members) {
+        var authorRole = Util.find(members, [author, 'role']);
+        if (!authorRole) { return false; }
+
+        // owners can remove anyone they want
+        if (authorRole === 'OWNER') { return true; }
+        // admins can remove other admins or members
+        if (authorRole === "ADMIN") { return ["ADMIN", "MEMBER", "VIEWER"].indexOf(role) !== -1; }
+        // MEMBERS and non-members cannot remove anyone of any role
+        return false;
+    };
+
+    var canUpdateMetadata = function (author, members) {
+        var authorRole = Util.find(members, [author, 'role']);
+        return Boolean(authorRole && ['OWNER', 'ADMIN'].indexOf(authorRole) !== -1);
+    };
+
+    var shouldCheckpoint = function (me, ref) {
+        // if you can't send valid checkpoints, don't try
+        if (!canCheckpoint(me, ref.state.members)) { return false; }
+
+        // avoid sending checkpoints too often
+        // it's a balance between network constraints
+        // and the size of the roster's log
+        var since = ref.internal.sinceLastCheckpoint;
+
+        if (!since || typeof(since) !== 'number' || since < CHECKPOINT_INTERVAL) {
+            return false;
+        }
+
+        // if you can't think of any other reason not to...
+        return true;
+    };
+
+    var commands = Roster.commands = {};
+    /*  Commands are functions with the signature
+        (args_any, base46_author_string, roster_map, optional_base64_message_id) => boolean
+
+        they:
+        * throw if any of their arguments are invalid
+        * return true if their application to previous state results in a change
+        * mutate the local account of the current state
+
+        changes to the state can be simulated locally before being sent.
+        if the simulation throws or returns false, don't send.
+
+    */
+
+    // the author is trying to add someone to the roster
+    // owners can add any role
+    commands.ADD = function (args, author, roster) {
+        if (!isMap(args)) { throw new Error("INVALID ARGS"); }
+        if (!roster.internal.initialized) { throw new Error("UNITIALIZED"); }
+        if (typeof(roster.state.members) === 'undefined') {
+            throw new Error("CANNOT_ADD_TO_UNITIALIZED_ROSTER");
+        }
+        var members = roster.state.members;
+
+        // iterate over everything and make sure it is valid, throw if not
+        Object.keys(args).forEach(function (curve) {
+            // FIXME only allow valid curve keys, anything else is pollution
+            if (!isValidId(curve)) {
+                console.log(curve, curve.length);
+                throw new Error("INVALID_CURVE_KEY");
+            }
+            // reject commands where the members are not proper objects
+            if (!isMap(args[curve])) { throw new Error("INVALID_CONTENT"); }
+            if (members[curve]) { throw new Error("ALREADY_PRESENT"); }
+
+            var data = args[curve];
+            // if no role was provided, assume MEMBER
+            if (typeof(data.role) !== 'string') { data.role = 'MEMBER'; }
+
+            if (!canAddRole(author, data.role, members)) {
+                throw new Error("INSUFFICIENT_PERMISSIONS");
+            }
+
+            if (typeof(data.displayName) !== 'string') { throw new Error("DISPLAYNAME_REQUIRED"); }
+            if (typeof(data.notifications) !== 'string') { throw new Error("NOTIFICATIONS_REQUIRED"); }
+        });
+
+        var changed = false;
+        // then iterate again and apply it
+        Object.keys(args).forEach(function (curve) {
+            // this will result in a change
+            changed = true;
+            members[curve] = args[curve];
+        });
+
+        return changed;
+    };
+
+    commands.RM = function (args, author, roster) {
+        if (!Array.isArray(args)) { throw new Error("INVALID_ARGS"); }
+
+        if (typeof(roster.state.members) === 'undefined') {
+            throw new Error("CANNOT_RM_FROM_UNITIALIZED_ROSTER");
+        }
+        var members = roster.state.members;
+
+        // validate first...
+        args.forEach(function (curve) {
+            if (!isValidId(curve)) { throw new Error("INVALID_CURVE_KEY"); }
+
+            // even members can remove themselves
+            if (curve === author) { return; }
+
+            // but if it concerns anyone else, validate that the author has sufficient permissions
+            var role = members[curve].role;
+            if (!canRemoveRole(author, role, members)) { throw new Error("INSUFFICIENT_PERMISSIONS"); }
+        });
+
+        var changed = false;
+        args.forEach(function (curve) {
+            // don't try to remove something that isn't there
+            if (!members[curve]) { return; }
+            changed = true;
+            delete members[curve];
+        });
+        return changed;
+    };
+
+    commands.DESCRIBE = function (args, author, roster) {
+        if (!args || typeof(args) !== 'object' || Array.isArray(args)) {
+            throw new Error("INVALID_ARGUMENTS");
+        }
+
+        if (typeof(roster.state.members) === 'undefined') {
+            throw new Error("NOT_READY");
+        }
+        var members = roster.state.members;
+
+        // iterate over all the data and make sure it is valid, throw otherwise
+        Object.keys(args).forEach(function (curve) {
+            if (!isValidId(curve)) {  throw new Error("INVALID_ID"); }
+            if (!members[curve]) { throw new Error("NOT_PRESENT"); }
+
+            if (!canDescribeTarget(author, curve, members)) { throw new Error("INSUFFICIENT_PERMISSIONS"); }
+
+            var data = args[curve];
+            if (!isMap(data)) { throw new Error("INVALID_ARGUMENTS"); }
+
+            var current = Util.clone(members[curve]);
+
+            if (typeof(data.role) === 'string') { // they're trying to change the role...
+                // throw if they're trying to upgrade to something greater
+                if (!isSelfDowngrade(author, curve, data.role, members) &&
+                    !canAddRole(author, data.role, members)) {
+                    throw new Error("INSUFFICIENT_PERMISSIONS");
+                }
+            }
+            // DESCRIBE commands must initialize a displayName if it isn't already present
+            if (typeof(current.displayName) !== 'string' && typeof(data.displayName) !== 'string') {
+                throw new Error('DISPLAYNAME_REQUIRED');
+            }
+
+            if (['undefined', 'string'].indexOf(typeof(data.displayName)) === -1) {
+                throw new Error("INVALID_DISPLAYNAME");
+            }
+
+            // DESCRIBE commands must initialize a mailbox channel if it isn't already present
+            if (typeof(current.notifications) !== 'string' && typeof(data.notifications) !== 'string') {
+                throw new Error('NOTIFICATIONS_REQUIRED');
+            }
+            if (['undefined', 'string'].indexOf(typeof(data.notifications)) === -1) {
+                throw new Error("INVALID_NOTIFICATIONS");
+            }
+        });
+
+        var changed = false;
+        // then do a second pass and apply it if there were changes
+        Object.keys(args).forEach(function (curve) {
+            var current = Util.clone(members[curve]);
+
+            var data = args[curve];
+
+            Object.keys(data).forEach(function (key) {
+                // when null is passed as new data and it wasn't considered an invalid change
+                // remove it from the map. This is how you delete things properly
+                if (typeof(current[key]) !== 'undefined' && data[key] === null) { return void delete current[key]; }
+                current[key] = data[key];
+            });
+
+            if (Sortify(current) !== Sortify(members[curve])) {
+                changed = true;
+                members[curve] = current;
+            }
+        });
+
+        return changed;
+    };
+
+    commands.CHECKPOINT = function (args, author, roster) {
+        // args: complete state
+
+        // args should be a map
+        if (!isMap(args)) { throw new Error("INVALID_CHECKPOINT_STATE"); }
+
+        if (!roster.internal.initialized) {
+            //console.log("INITIALIZING");
+            // either you're connecting from the beginning of the log
+            // or from a trusted lastKnownHash.
+            // Either way, initialize the roster state
+
+            roster.state = args;
+            var metadata = roster.state.metadata = roster.state.metadata || {};
+            metadata.topic = metadata.topic || '';
+            metadata.name = metadata.name || '';
+            metadata.avatar = metadata.avatar || '';
+
+            roster.internal.initialized = true;
+            return true;
+        } else if (Sortify(args) !== Sortify(roster.state)) {
+            // a checkpoint must reinsert the previous state
+            throw new Error("CHECKPOINT_DOES_NOT_MATCH_PREVIOUS_STATE");
+        }
+
+        // otherwise, you're iterating over the log from a previous checkpoint
+        // so you should know everyone's role
+
+        // owners and admins can checkpoint. members and non-members cannot
+        if (!canCheckpoint(author, roster.state.members)) { throw new Error("INSUFFICIENT_PERMISSIONS"); }
+
+        // set the state, and indicate that a change was made
+        roster.state = args;
+        return true;
+    };
+
+    var MANDATORY_METADATA_FIELDS = [
+        'avatar',
+        'name',
+        'topic',
+    ];
+
+    // only admin/owner can change group metadata
+    commands.METADATA = function (args, author, roster) {
+        if (!isMap(args)) { throw new Error("INVALID_ARGS"); }
+
+        if (!canUpdateMetadata(author, roster.state.members)) { throw new Error("INSUFFICIENT_PERMISSIONS"); }
+
+        // validate inputs
+        Object.keys(args).forEach(function (k) {
+            if (args[k] === null) {
+                if (MANDATORY_METADATA_FIELDS.indexOf(k) === -1) { return; }
+                throw new Error('CANNOT_REMOVE_MANDATORY_METADATA');
+            }
+
+            // can't set metadata to anything other than strings
+            // use empty string to unset a value if you must
+            if (typeof(args[k]) !== 'string') { throw new Error("INVALID_ARGUMENTS"); }
+        });
+
+        var changed = false;
+        // {topic, name, avatar} are all strings...
+        Object.keys(args).forEach(function (k) {
+            if (typeof(roster.state.metadata[k]) !== 'undefined' && args[k] === null) {
+                changed = true;
+                delete roster.state.metadata[k];
+            }
+
+            // ignore things that won't cause changes
+            if (args[k] === roster.state.metadata[k]) { return; }
+
+            changed = true;
+            roster.state.metadata[k] = args[k];
+        });
+        return changed;
+    };
+
+    commands.INVITE = function (args, author, roster) {
+        // an invitation is created with an ephemeral curve public key
+        // that key is ultimately given to the user you'd like on your team
+        // that user can exploit their possession of the public key to remove
+        // the pending invitation with their actual data.
+        if (!isMap(args)) { throw new Error('INVALID_ARGS'); }
+        if (!roster.internal.initialized) { throw new Error("UNINITIALIED"); }
+        if (typeof(roster.state.members) === 'undefined') {
+            throw new Error("CANNOT+INVITE_TO_UNINITIALIED_ROSTER");
+        }
+
+        var members = roster.state.members;
+
+        Object.keys(args).forEach(function (curve) {
+            if (!isValidId(curve)) {
+                console.log(curve, curve.length);
+                throw new Error("INVALID_CURVE_KEY");
+            }
+            // reject commandws wehere the members are not proper objects
+            if (!isMap(args[curve])) { throw new Error("INVALID_CONTENT"); }
+            if (members[curve]) { throw new Error("ARLEADY_PRESENT"); }
+
+            var data = args[curve];
+            // if no role was provided, assume VIEWER
+            if (typeof(data.role) !== 'string') { data.role = "VIEWER"; }
+
+            // assume that invitations are 'pending' unless stated otherwise
+            if (typeof(data.pending) === 'undefined') { data.pending = true; }
+
+            if (!canAddRole(author, data.role, members)) {
+                throw new Error("INSUFFICIENT_PERMISSIONS");
+            }
+
+            if (typeof(data.displayName) !== 'string' || !data.displayName) { throw new Error("DISPLAYNAME_REQUIRED"); }
+            //if (typeof(data.notifications) !== 'string') { throw new Error("NOTIFICATIONS_REQUIRED"); }
+        });
+
+
+        /*
+            {
+                <ephemeralCurveKey>: {
+                    role: ??? || 'VIEWER',
+                    displayName: '',
+                    pending: true,
+                }
+            }
+        */
+
+        var changed = false;
+
+        Object.keys(args).forEach(function (curve) {
+            changed = true;
+            members[curve] = args[curve];
+        });
+
+        return changed;
+    };
+
+    commands.ACCEPT = function (args, author, roster) {
+        if (!roster.internal.initialized) { throw new Error("UNINITIALIED"); }
+        if (typeof(roster.state.members) === 'undefined') {
+            throw new Error("CANNOT_ADD_TO_UNINITIALIED_ROSTER");
+        }
+
+        // an ACCEPT command replaces a pending invitation's curve key with a new one
+        // after which the invited member can use their actual curve key to describe themselves
+
+        // the author must have been invited already...
+        var members = roster.state.members;
+
+        // so you must already be in the members list
+        if (!isMap(members[author])) { throw new Error("INSUFFICIENT_PERMISSIONS"); }
+        // and your membership must indicate that you are 'pending'
+        if (!members[author].pending) { throw new Error("ALREADY_PRESENT"); }
+
+        // args should be a string
+        if (typeof(args) !== 'string') { throw new Error("INVALID_ARGS"); }
+        // ...and a valid curve key
+        if (!isValidId(args)) { throw new Error("INVALID_CURVE_KEY"); }
+
+        var curve = args;
+
+        // and the curve key must not already be a member
+        if (typeof(members[curve]) !== 'undefined') { throw new Error("MEMBER_ALREADY_PRESENT"); }
+
+        // copy the new profile from the old one
+        var clone = Util.clone(members[author]);
+        delete clone.remaining;
+        delete clone.totalUses;
+        delete clone.inviteChannel;
+        delete clone.previewChannel;
+        members[curve] = clone;
+
+        var remaining = members[author].remaining || 1;
+        if (remaining === -1) { return true; } // Infinite uses, keep the link
+        if (remaining > 1) { // Remove 1 use
+            members[author].remaining = remaining - 1;
+        } else { // Disable link
+            delete members[author];
+        }
+
+        return true;
+    };
+
+    var handleCommand = function (content, author, roster) {
+        if (!(Array.isArray(content) && typeof(author) === 'string')) {
+            throw new Error("INVALID ARGUMENTS");
+        }
+
+        var command = content[0];
+        if (typeof(commands[command]) !== 'function') { throw new Error('INVALID_COMMAND'); }
+
+        return commands[command](content[1], author, roster);
+    };
+
+    var simulate = function (content, author, roster) {
+        return handleCommand(content, author, Util.clone(roster));
+    };
+
+    Roster.create = function (config, _cb) {
+        if (typeof(_cb) !== 'function') { throw new Error("EXPECTED_CALLBACK"); }
+        var cb = Util.once(Util.mkAsync(_cb));
+
+        if (!config.network) { return void cb("EXPECTED_NETWORK"); }
+        if (!config.channel || typeof(config.channel) !== 'string' || config.channel.length !== 32) { return void cb("EXPECTED_CHANNEL"); }
+        if (!config.keys || typeof(config.keys) !== 'object') { return void cb("EXPECTED_CRYPTO_KEYS"); }
+        if (!config.store) { return void cb("EXPECTED_STORE"); }
+
+
+        var response = Util.response(function (label, info) {
+            console.error('ROSTER_RESPONSE__' + label, info);
+        });
+        var store = config.store;
+        var keys = config.keys;
+        var me = keys.myCurvePublic;
+        var channel = config.channel;
+        var lastKnownHash = config.lastKnownHash || -1;
+
+        // make sure we don't send -1 (ask for full history) when we are trying to create a new team
+        if (config.newTeam) {
+            lastKnownHash = undefined;
+        }
+
+        var ref = {
+            state: {
+                members: { },
+                metadata: { },
+            },
+            internal: {
+                initialized: false,
+                sinceLastCheckpoint: 0,
+                lastCheckpointHash: lastKnownHash,
+            },
+        };
+        var roster = {};
+        var events = {
+            change: Util.mkEvent(),
+            checkpoint: Util.mkEvent(),
+        };
+
+        roster.on = function (key, handler) {
+            if (typeof(events[key]) !== 'object') { throw new Error("unsupported event"); }
+            events[key].reg(handler);
+            return roster;
+        };
+
+        roster.off = function (key, handler) {
+            if (typeof(events[key]) !== 'object') { throw new Error("unsupported event"); }
+            events[key].unreg(handler);
+            return roster;
+        };
+
+        roster.once = function (key, handler) {
+            if (typeof(events[key]) !== 'object') { throw new Error("unsupported event"); }
+            var f = function () {
+                handler.apply(null, Array.prototype.slice.call(arguments));
+                events[key].unreg(f);
+            };
+            events[key].reg(f);
+            return roster;
+        };
+
+        roster.getState = function () {
+            //if (!isMap(ref.state)) { return; }
+            return Util.clone(ref.state);
+        };
+
+        roster.getLastCheckpointHash = function () {
+            return ref.internal.lastCheckpointHash || -1;
+        };
+
+        var clearPendingCheckpoints = function () {
+            // clear any pending checkpoints you might have...
+            if (ref.internal.pendingCheckpointId) {
+                response.clear(ref.internal.pendingCheckpointId);
+                delete ref.internal.pendingCheckpointId;
+            }
+            clearTimeout(ref.internal.checkpointTimeout);
+            delete ref.internal.checkpointTimeout;
+        };
+
+        roster.stop = function () {
+            if (ref.internal.cpNetflux && typeof(ref.internal.cpNetflux.stop) === "function") {
+                ref.internal.cpNetflux.stop();
+                clearPendingCheckpoints();
+            } else {
+                console.log("FAILED TO LEAVE");
+            }
+        };
+        var ready = false;
+        var onCacheReady = function () {
+            if (!config.onCacheReady) { return; }
+            var state = ref.state;
+            if (!Object.keys(state.members || {}).length) {
+                // No member, corrupted cache
+                try {
+                    ref.internal.cpNetflux.resetCache();
+                } catch (e) { console.error(e); }
+                return void config.onCacheReady({error: "CORRUPTED"});
+            }
+            config.onCacheReady(roster);
+        };
+        var onReady = function () {
+            //console.log("READY");
+            ready = true;
+            cb(void 0, roster);
+        };
+
+        // onError (deleted or expired)
+            // you won't be able to connect
+
+        // onMetadataUpdate
+            // update owners?
+
+        // deleted while you are open
+        // emit an event
+        var onChannelError = function (info) {
+            if (Feedback) { Feedback.send('ROSTER_CHANNEL_ERROR='+(info && info.type)); }
+            if (info && info.type === "EUNKNOWN") {
+                // chainpad-netflux should recover by itself
+                return;
+            }
+            if (!ready) { return void cb(info); }
+            console.error("CHANNEL_ERROR", info);
+        };
+
+        var onConnectionChange = function (info) {
+            if (info.state) { return; }
+            // Disconnect: don't send event anymore until ready
+            ready = false;
+        };
+
+        var onConnect = function (/* wc, sendMessage */) {
+            console.log("ROSTER CONNECTED");
+        };
+
+        var isReady = function () {
+             return Boolean(ready && me);
+        };
+
+        var onMessage = function (msg, user, vKey, isCp , hash, author) {
+            // count messages received since the last checkpoint
+            // even if they fail to parse
+            ref.internal.sinceLastCheckpoint++;
+
+            var parsed = Util.tryParse(msg);
+
+            if (!parsed) { return void console.error("could not parse"); }
+
+            var changed;
+            var error;
+            try {
+                changed = handleCommand(parsed, author, ref);
+            } catch (err) {
+                error = err.message;
+            }
+
+            var id = getMessageId(hash);
+
+            if (response.expected(id)) {
+                if (error) { return void response.handle(id, [error]); }
+                try {
+                    if (!changed) {
+                        response.handle(id, ['NO_CHANGE']);
+                        console.log(msg);
+                    } else {
+                        response.handle(id, [void 0, roster.getState()]);
+                    }
+                } catch (err) {
+                    console.log('CAUGHT', err);
+                }
+            }
+
+            // if a checkpoint was successfully applied, emit an event
+            if (parsed[0] === 'CHECKPOINT' && changed) {
+                if (isReady()) { events.checkpoint.fire(hash); }
+                // reset the counter for messages since the last checkpoint
+                ref.internal.sinceLastCheckpoint = 0;
+                ref.internal.lastCheckpointHash = hash;
+            } else if (changed) {
+                if (isReady()) { events.change.fire(); }
+            }
+
+            // CHECKPOINT logic...
+            clearPendingCheckpoints();
+            if (!isReady() || !shouldCheckpoint(me, ref)) { return; }
+            // a random number of seconds between 5 and 25
+            var delay = (1000 * Math.floor(Math.random() * 20)) + 5000;
+
+            // if you're here then you can and should send a checkpoint
+            // but since multiple users who can and should might be online at once
+            // and since they'll all trigger this process at the same time...
+            // we want to stagger attempts at random intervals
+            ref.internal.checkpointTimeout = setTimeout(function () {
+                ref.internal.pendingCheckpointId = roster.checkpoint(function (err) {
+                    if (err) { console.error(err); }
+                });
+            }, delay);
+        };
+
+        var isCacheCheckpoint = function (msg, author) {
+            var parsed = Util.tryParse(msg);
+            if (parsed[0] !== 'CHECKPOINT') { return false; }
+            var changed = simulate(parsed, author, ref);
+            return changed;
+        };
+
+        var metadata, crypto;
+        var send = function (msg, cb) {
+            if (!isReady()) { return void cb("NOT_READY"); }
+            var anon_rpc = store.anon_rpc;
+            if (!anon_rpc) { return void cb("ANON_RPC_NOT_READY"); }
+
+            var changed = false;
+            try {
+                // simulate the command before you send it
+                changed = simulate(msg, keys.myCurvePublic, ref);
+            } catch (err) {
+                return void cb(err.message);
+            }
+            if (!changed) { return void cb("NO_CHANGE"); }
+
+            var ciphertext = crypto.encrypt(Sortify(msg));
+
+            var id = getMessageId(ciphertext);
+
+            //console.log("Sending with id [%s]", id, msg);
+            //console.log();
+
+            response.expect(id, function (err, state) {
+                if (err) { return void cb(err); }
+                cb(void 0, state, id);
+            }, TIMEOUT_INTERVAL);
+            anon_rpc.send('WRITE_PRIVATE_MESSAGE', [
+                channel,
+                ciphertext
+            ], function (err) {
+                if (err) { return response.handle(id, [err.message || err]); }
+            });
+            return id;
+        };
+
+        roster.init = function (_data, _cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            if (ref.internal.initialized) { return void cb("ALREADY_INITIALIZED"); }
+            if (!isMap(_data)) { return void cb("INVALID_ARGUMENTS"); }
+            var data = Util.clone(_data);
+            data.role = 'OWNER';
+            var members = {};
+            members[me] = data;
+            send([ 'CHECKPOINT', { members: members } ], cb);
+        };
+
+        // commands
+        roster.checkpoint = function (_cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            send([ 'CHECKPOINT', Util.clone(ref.state)], cb);
+        };
+
+        roster.add = function (_data, _cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            //var state = ref.state;
+            if (!ref.internal.initialized) { return cb("UNINITIALIZED"); }
+            if (!isMap(_data)) { return void cb("INVALID_ARGUMENTS"); }
+            var data = Util.clone(_data);
+
+            // don't add members that are already present
+            // use DESCRIBE to amend
+            Object.keys(data).forEach(function (curve) {
+                if (!isValidId(curve) || isMap(ref.state.members[curve])) { return delete data[curve]; }
+            });
+
+            send([ 'ADD', data ], cb);
+        };
+
+        roster.remove = function (_data, _cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            var state = ref.state;
+            if (!state) { return cb("UNINITIALIZED"); }
+
+            if (!Array.isArray(_data)) { return void cb("INVALID_ARGUMENTS"); }
+            var data = Util.clone(_data);
+
+            var toRemove = [];
+            var current = Object.keys(state.members);
+            data.forEach(function (curve) {
+                // don't try to remove elements which are not in the current state
+                if (current.indexOf(curve) === -1) { return; }
+                toRemove.push(curve);
+            });
+
+            send([ 'RM', toRemove ], cb);
+        };
+
+        roster.describe = function (_data, _cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            var state = ref.state;
+
+            if (!state) { return cb("UNINITIALIZED"); }
+            if (!isMap(_data)) { return void cb("INVALID_ARGUMENTS"); }
+            var data = Util.clone(_data);
+
+            if (Object.keys(data).some(function (curve) {
+                var member = data[curve];
+                if (!isMap(member)) { delete data[curve]; }
+                // validate that you're trying to describe a user that is present
+                if (!isMap(state.members[curve])) { return true; }
+                // don't send fields that won't result in a change
+                Object.keys(member).forEach(function (k) {
+                    if (member[k] === state.members[curve][k]) { delete member[k]; }
+                });
+            })) {
+                // returning true in the above loop indicates that something was invalid
+                return void cb("INVALID_ARGUMENTS");
+            }
+
+            send(['DESCRIBE', data], cb);
+        };
+
+        roster.metadata = function (_data, _cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            var metadata = ref.state.metadata;
+            if (!isMap(_data)) { return void cb("INVALID_ARGUMENTS"); }
+            var data = Util.clone(_data);
+
+            Object.keys(data).forEach(function (k) {
+                if (data[k] === metadata[k]) { delete data[k]; }
+            });
+            send(['METADATA', data], cb);
+        };
+
+        // supports multiple invite
+        roster.invite = function (_data, _cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            var state = ref.state;
+            if (!state) { return cb("UNINITIALIZED"); }
+            if (!ref.internal.initialized) { return cb("UNINITIALIZED"); }
+            if (!isMap(_data)) { return void cb("INVALID_ARGUMENTS"); }
+            var data = Util.clone(_data);
+
+            Object.keys(data).forEach(function (curve) {
+                if (!isValidId(curve) || isMap(ref.state.members[curve])) { return delete data[curve]; }
+            });
+
+            send(['INVITE', data], cb);
+        };
+
+        roster.accept = function (_data, _cb) {
+            var cb = Util.once(Util.mkAsync(_cb));
+            if (typeof(_data) !== 'string' || !isValidId(_data)) {
+                return void cb("INVALID_ARGUMENTS");
+            }
+
+            send([ 'ACCEPT', _data ], cb);
+        };
+
+        nThen(function (w) {
+            // get metadata so we know the owners and validateKey
+            if (!store.anon_rpc) { return; }
+            store.anon_rpc.send('GET_METADATA', channel, function (err, data) {
+                if (err) {
+                    w.abort();
+                    return void console.error(err);
+                }
+                metadata = ref.internal.metadata = (data && data[0]) || undefined;
+            });
+        }).nThen(function (w) {
+            if (!config.keys.teamEdPublic && metadata && metadata.validateKey) {
+                config.keys.teamEdPublic = metadata.validateKey;
+            }
+            if (!config.keys.teamEdPublic) {
+                w.abort();
+                return void cb("NO_VALIDATE_KEY");
+            }
+
+            try {
+                crypto = Crypto.Team.createEncryptor(config.keys);
+            } catch (err) {
+                w.abort();
+                return void cb(err);
+            }
+        }).nThen(function () {
+            if (typeof(lastKnownHash) === 'string') {
+                console.log("Synchronizing from checkpoint");
+            }
+
+            ref.internal.cpNetflux = CPNetflux.start({
+                // if you don't have a lastKnownHash you will need the full history
+                // passing -1 forces the server to send all messages, otherwise
+                // malicious users with the signing key could send cp| messages
+                // and fool new users into initializing their session incorrectly
+                lastKnownHash: lastKnownHash,
+
+                network: config.network,
+                channel: config.channel,
+
+                crypto: crypto,
+                validateKey: config.keys.teamEdPublic,
+
+                owners: config.owners,
+
+                Cache: config.Cache,
+                isCacheCheckpoint: isCacheCheckpoint,
+                onCacheReady: onCacheReady,
+
+                onChannelError: onChannelError,
+                onReady: onReady,
+                onConnect: onConnect,
+                onConnectionChange: onConnectionChange,
+                onMessage: onMessage,
+
+                noChainPad: true,
+            });
+        });
+    };
+
+    return Roster;
+};
+
+    if (typeof(module) !== 'undefined' && module.exports) {
+        module.exports = factory(
+            require("../../common/common-util"),
+            require("../../common/common-hash"),
+            require('chainpad-netflux'),
+            require('json.sortify'),
+            require("nthen"),
+            require("chainpad-crypto"),
+            null // no feedback here
+        );
+    } else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+        require.config({ paths:  { 'json.sortify': '/components/json.sortify/dist/JSON.sortify' } });
+        define([
+            '/common/common-util.js',
+            '/common/common-hash.js',
+            'chainpad-netflux',
+            'json.sortify',
+            '/components/nthen/index.js',
+            '/components/chainpad-crypto/crypto.js',
+            '/common/common-feedback.js',
+            //'/components/tweetnacl/nacl-fast.min.js',
+        ], function (Util, Hash, CPNF, Sortify, nThen, Crypto, Feedback) {
+            return factory.apply(null, [
+                Util,
+                Hash,
+                CPNF,
+                Sortify,
+                nThen,
+                Crypto,
+                Feedback
+            ]);
+        });
+    } else {
+        // I'm not gonna bother supporting any other kind of instanciation
+    }
+}());
diff --git a/src/worker/components/sharedfolder.js b/src/worker/components/sharedfolder.js
new file mode 100644
index 000000000..705de8c88
--- /dev/null
+++ b/src/worker/components/sharedfolder.js
@@ -0,0 +1,417 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Hash, Util, UserObject, Cache,
+             nThen, Crypto, Listmap, ChainPad) => {
+    var SF = {};
+
+    /* load
+        create and load a proxy using listmap for a given shared folder
+        - config: network and "manager" (either the user one or a team manager)
+        - id: shared folder id
+    */
+
+    var allSharedFolders = {};
+
+    // No version: visible edit
+    // Version 2: encrypted edit links
+    SF.checkMigration = function (secondaryKey, proxy, uo, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var drive = proxy.drive || proxy;
+        // View access: can't migrate
+        if (!secondaryKey) { return void cb(); }
+        // Already migrated: nothing to do
+        if (drive.version >= 2) { return void cb(); }
+        // Not yet migrating: migrate
+        if (!drive.migrateRo) { return void uo.migrateReadOnly(cb); }
+        // Already migrating: wait for the end...
+        var done = false;
+        var to;
+        var it = setInterval(function () {
+            if (drive.version >= 2) {
+                done = true;
+                clearTimeout(to);
+                clearInterval(it);
+                return void cb();
+            }
+        }, 100);
+        to = setTimeout(function () {
+            clearInterval(it);
+            uo.migrateReadOnly(function () {
+                done = true;
+                cb();
+            });
+        }, 20000);
+        var path = proxy.drive ? ['drive', 'version'] : ['version'];
+        proxy.on('change', path, function () {
+            if (done) { return; }
+            if (drive.version >= 2) {
+                done = true;
+                clearTimeout(to);
+                clearInterval(it);
+                cb();
+            }
+        });
+    };
+
+    // SFMIGRATION: only needed if we want a manual migration from the share modal...
+    SF.migrate = function (channel) {
+        var sf = allSharedFolders[channel];
+        if (!sf) { return; }
+        var clients = sf.teams;
+        if (!Array.isArray(clients) || !clients.length) { return; }
+        var c = clients[0];
+        // No secondaryKey? ==> already migrated ==> abort
+        if (!c.secondaryKey) { return; }
+        var f = Util.find(c, ['store', 'manager', 'folders', c.id]);
+        // Can't find the folder: abort
+        if (!f) { return; }
+        // Already migrated: abort
+        if (!f.proxy || f.proxy.version) { return; }
+        f.userObject.migrateReadOnly(function () {
+            clients.forEach(function (obj) {
+                var uo = Util.find(obj, ['store', 'manager', 'folders', obj.id, 'userObject']);
+                uo.setReadOnly(false, obj.secondarykey);
+            });
+        });
+    };
+
+    SF.load = function (config, id, data, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var network = config.network;
+        var store = config.store;
+        var isNew = config.isNew;
+        var isNewChannel = config.isNewChannel;
+        var teamId = store.id;
+        var handler = store.handleSharedFolder;
+
+        var href = store.manager.user.userObject.getHref(data);
+
+        var parsed = Hash.parsePadUrl(href);
+        var secret = Hash.getSecrets('drive', parsed.hash, data.password);
+        // If we don't have valid keys, abort and remove the proxy to make sure
+        // we don't block the drive permanently
+        if (!secret.keys) {
+            store.manager.deprecateProxy(id);
+            return void cb(null);
+        }
+        var secondaryKey = secret.keys.secondaryKey;
+
+        // If we try to load an existing shared folder (isNew === false) but this folder
+        // doesn't exist in the database, abort and cb
+        nThen(function (waitFor) {
+            // If we're in onCacheReady, make sure we have a cache for this shared folder
+            if (config.cache) {
+                Cache.getChannelCache(secret.channel, waitFor(function (err) {
+                    if (err === "EINVAL") { // Cache not found
+                        waitFor.abort();
+                        store.manager.restrictedProxy(id, secret.channel);
+                        return void cb(null);
+                    }
+                }));
+            }
+        }).nThen(function (waitFor) {
+            isNewChannel(null, { channel: secret.channel }, waitFor(function (obj) {
+                if (obj.isNew && !isNew) {
+                    store.manager.deprecateProxy(id, secret.channel, obj.reason);
+                    waitFor.abort();
+                    return void cb(null);
+                }
+            }));
+        }).nThen(function () {
+            var sf = allSharedFolders[secret.channel];
+            if (sf && sf.readOnly && secondaryKey) {
+                // We were in readOnly mode and now we know the edit keys!
+                SF.upgrade(secret.channel, secret);
+            }
+            if (sf && sf.ready && sf.rt) {
+                // The shared folder is already loaded, return its data
+                setTimeout(function () {
+                    var leave = function () { SF.leave(secret.channel, teamId); };
+                    /*
+                    var uo = store.manager.addProxy(id, sf.rt, leave, secondaryKey);
+                    // NOTE: Shared folder migration, disable for now
+                    SF.checkMigration(secondaryKey, sf.rt.proxy, uo, function () {
+                        cb(sf.rt);
+                    });
+                    */
+                    store.manager.addProxy(id, sf.rt, leave, secondaryKey);
+                    cb(sf.rt);
+                });
+                sf.teams.push({
+                    cb: cb,
+                    store: store,
+                    id: id
+                });
+                if (handler) { handler(id, sf.rt); }
+                return;
+            }
+            if (sf && !sf.ready && sf.rt) {
+                // The shared folder is loading, add our callbacks to the queue
+                sf.teams.push({
+                    cb: cb,
+                    store: store,
+                    secondaryKey: secondaryKey,
+                    id: id
+                });
+                if (handler) { handler(id, sf.rt); }
+                return;
+            }
+
+            sf = allSharedFolders[secret.channel] = {
+                teams: [{
+                    cb: cb,
+                    store: store,
+                    secondaryKey: secondaryKey,
+                    id: id
+                }],
+                readOnly: !Boolean(secondaryKey)
+            };
+
+            var owners = data.owners;
+            var listmapConfig = {
+                data: {},
+                channel: secret.channel,
+                readOnly: !Boolean(secondaryKey),
+                crypto: Crypto.createEncryptor(secret.keys),
+                userName: 'sharedFolder',
+                logLevel: 1,
+                ChainPad: ChainPad,
+                classic: true,
+                network: network,
+                Cache: Cache, // shared-folder cache
+                metadata: {
+                    validateKey: secret.keys.validateKey || undefined,
+                    owners: owners
+                },
+                onRejected: config.Store && config.Store.onRejected
+            };
+            var rt = sf.rt = Listmap.create(listmapConfig);
+            rt.proxy.on('cacheready', function () {
+                if (!sf.teams) {
+                    return;
+                }
+                sf.teams.forEach(function (obj) {
+                    var leave = function () { SF.leave(secret.channel, obj.store.id); };
+
+                    // We can safely call addProxy and obj.cb here because
+                    // 1. addProxy won't re-add the same folder twice on 'ready'
+                    // 2. obj.cb is using Util.once
+                    rt.cache = true;
+
+                    // If we're updating the password of an existing folder, force the creation
+                    // of a new userobject in proxy-manager. Once it's done, remove this flag
+                    // to make sure we won't create a second new userobject on 'ready'
+                    obj.store.manager.addProxy(obj.id, rt, leave, obj.secondaryKey, config.updatePassword);
+                    config.updatePassword = false;
+                    obj.cb(sf.rt);
+                });
+                sf.ready = true;
+            });
+            rt.proxy.on('ready', function () {
+                if (isNew && !Object.keys(rt.proxy).length) {
+                    // New Shared folder: no migration required
+                    rt.proxy.version = 2;
+                }
+                if (!sf.teams) {
+                    return;
+                }
+                sf.teams.forEach(function (obj) {
+                    var leave = function () { SF.leave(secret.channel, obj.store.id); };
+                    /*
+                    var uo = obj.store.manager.addProxy(obj.id, rt, leave, obj.secondaryKey);
+                    // NOTE: Shared folder migration, disable for now
+                    SF.checkMigration(secondaryKey, rt.proxy, uo, function () {
+                        obj.cb(sf.rt);
+                    });
+                    */
+                    rt.cache = false;
+                    obj.store.manager.addProxy(obj.id, rt, leave, obj.secondaryKey, config.updatePassword);
+                    obj.cb(sf.rt);
+                });
+                sf.ready = true;
+            });
+            rt.proxy.on('error', function (info) {
+                if (info && info.error) {
+                    if (info.error === "EDELETED" ) {
+                        try {
+                            // Deprecate the shared folder from each team
+                            // We can only hide it
+                            sf.teams.forEach(function (obj) {
+                                obj.store.manager.deprecateProxy(obj.id, secret.channel, info.message);
+                                if (obj.store.handleSharedFolder) {
+                                    obj.store.handleSharedFolder(obj.id, null);
+                                }
+                                obj.cb();
+                            });
+                        } catch (e) {}
+                        delete allSharedFolders[secret.channel];
+                        // This shouldn't be called on init because we're calling "isNewChannel" first,
+                        // but we can still call "cb" just in case. This wait we make sure we won't block
+                        // the initial "waitFor"
+                        return void cb();
+                    }
+                    if (info.error === "ERESTRICTED" ) {
+                        sf.teams.forEach(function (obj) {
+                            obj.store.manager.restrictedProxy(obj.id, secret.channel);
+                            obj.cb();
+                        });
+                        delete allSharedFolders[secret.channel];
+                        return void cb();
+                    }
+                }
+            });
+
+            if (handler) { handler(id, rt); }
+        });
+    };
+
+
+    SF.upgrade = function (channel, secret) {
+        var sf = allSharedFolders[channel];
+        if (!sf || !sf.readOnly) { return; }
+        if (!sf.rt.setReadOnly) { return; }
+
+        if (!secret.keys || !secret.keys.editKeyStr) { return; }
+        var crypto = Crypto.createEncryptor(secret.keys);
+        sf.readOnly = false;
+        sf.rt.setReadOnly(false, crypto);
+    };
+
+    SF.leave = function (channel, teamId) {
+        var sf = allSharedFolders[channel];
+        if (!sf) { return; }
+        var clients = sf.teams;
+        if (!Array.isArray(clients)) { return; }
+        // Remove the shared folder from the client's store and
+        // remove the client/team from our list
+        var idx;
+        clients.some(function (obj, i) {
+            if (obj.store.id === teamId) {
+                if (obj.store.handleSharedFolder) {
+                    obj.store.handleSharedFolder(obj.id, null);
+                }
+                idx = i;
+                return true;
+            }
+        });
+        if (typeof (idx) === "undefined") { return; }
+        // Remove the selected team
+        clients.splice(idx, 1);
+
+        //If all the teams have closed this shared folder, stop it
+        if (clients.length) { return; }
+        if (sf.rt && sf.rt.stop) {
+            sf.rt.stop();
+        }
+    };
+
+    // Update the password locally
+    SF.updatePassword = function (Store, data, network, cb) {
+        var oldChannel = data.oldChannel;
+        var href = data.href;
+        var password = data.password;
+        var parsed = Hash.parsePadUrl(href);
+        var secret = Hash.getSecrets(parsed.type, parsed.hash, password);
+        var sf = allSharedFolders[oldChannel];
+        if (!sf) { return void cb({ error: 'ENOTFOUND' }); }
+        if (sf.rt && sf.rt.stop) {
+            try { sf.rt.stop(); } catch (e) {}
+        }
+        var nt = nThen;
+        sf.teams.forEach(function (obj) {
+            nt = nt(function (waitFor) {
+                var s = obj.store;
+                var sfId = obj.id;
+                var shared = Util.find(s.proxy, ['drive', UserObject.SHARED_FOLDERS]) || {};
+                if (!sfId || !shared[sfId]) { return; }
+                var sf = JSON.parse(JSON.stringify(shared[sfId]));
+                sf.password = password;
+                SF.load({
+                    network: network,
+                    store: s,
+                    updatePassword: true,
+                    Store: Store,
+                    isNewChannel: Store.isNewChannel
+                }, sfId, sf, waitFor());
+                if (!s.rpc) { return; }
+                s.rpc.unpin([oldChannel], waitFor());
+                s.rpc.pin([secret.channel], waitFor());
+            }).nThen;
+        });
+        nt(function () {
+            cb();
+        });
+    };
+
+    /* loadSharedFolders
+        load all shared folder stored in a given drive
+        - store: user or team main store
+        - userObject: userObject associated to the main drive
+        - handler: a function (sfid, rt) called for each shared folder loaded
+    */
+    SF.loadSharedFolders = function (Store, network, store, userObject, waitFor, progress, cache) {
+        var shared = Util.find(store.proxy, ['drive', UserObject.SHARED_FOLDERS]) || {};
+        var steps = Object.keys(shared).length;
+        var i = 1;
+        var w = waitFor();
+        progress = progress || function () {};
+        nThen(function (waitFor) {
+            Object.keys(shared).forEach(function (id) {
+                var sf = shared[id];
+                SF.load({
+                    network: network,
+                    store: store,
+                    Store: Store,
+                    cache: cache,
+                    isNewChannel: Store.isNewChannel
+                }, id, sf, waitFor(function () {
+                    progress({
+                        progress: i,
+                        max: steps
+                    });
+                    i++;
+                }));
+            });
+        }).nThen(function () {
+            setTimeout(w);
+        });
+    };
+
+    SF.isSharedFolderChannel = function (chanId) {
+        return Object.keys(allSharedFolders).includes(chanId);
+    };
+
+    return SF;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        require('../../common/common-hash'),
+        require('../../common/common-util'),
+        require('../../common/user-object'),
+        require('../../common/cache-store'),
+        require('nthen'),
+        require('chainpad-crypto'),
+        require('chainpad-listmap'),
+        require('chainpad')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-hash.js',
+        '/common/common-util.js',
+        '/common/user-object.js',
+        '/common/outer/cache-store.js',
+
+        '/components/nthen/index.js',
+        '/components/chainpad-crypto/crypto.js',
+        'chainpad-listmap',
+        '/components/chainpad/chainpad.dist.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/modules/calendar.js b/src/worker/modules/calendar.js
new file mode 100644
index 000000000..3b0cd2a49
--- /dev/null
+++ b/src/worker/modules/calendar.js
@@ -0,0 +1,1248 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Util, Hash, Constants, Realtime, Cache, Rec,
+            Messages = {}, nThen, Listmap, FP, Crypto, ChainPad) => {
+    var Calendar = {};
+
+    Calendar.setCustomize = data => {
+        Messages = data.Messages;
+    };
+
+    var getStore = function (ctx, id) {
+        if (!id || id === 1) {
+            return ctx.store;
+        }
+        var m = ctx.store.modules && ctx.store.modules.team;
+        if (!m) { return; }
+        return m.getTeam(id);
+    };
+
+    var makeCalendar = function () {
+        var hash = Hash.createRandomHash('calendar');
+        var secret = Hash.getSecrets('calendar', hash);
+        var roHash = Hash.getViewHashFromKeys(secret);
+        var href = Hash.hashToHref(hash, 'calendar');
+        var roHref = Hash.hashToHref(roHash, 'calendar');
+        return {
+            href: href,
+            roHref: roHref,
+            channel: secret.channel,
+        };
+    };
+    var initializeCalendars = function (ctx, cb) {
+        var proxy = ctx.store.proxy;
+        proxy.calendars = proxy.calendars || {};
+        setTimeout(cb);
+    };
+
+    var sendUpdate = function (ctx, c) {
+        ctx.emit('UPDATE', {
+            teams: c.stores,
+            roTeams: c.roStores,
+            id: c.channel,
+            loading: !c.ready && !c.cacheready,
+            readOnly: c.readOnly || (!c.ready && c.cacheready) || c.offline,
+            offline: c.offline,
+            deleted: !c.stores.length,
+            restricted: c.restricted,
+            owned: ctx.Store.isOwned(c.owners),
+            content: Util.clone(c.proxy),
+            hashes: c.hashes
+        }, ctx.clients);
+    };
+
+    var clearReminders = function (ctx, id) {
+        var calendar = ctx.calendars[id];
+        if (!calendar || !calendar.reminders) { return; }
+        // Clear existing reminders
+        Object.keys(calendar.reminders).forEach(function (uid) {
+            if (!Array.isArray(calendar.reminders[uid])) { return; }
+            calendar.reminders[uid].forEach(function (to) { clearTimeout(to); });
+        });
+    };
+    var closeCalendar = function (ctx, id) {
+        var ctxCal = ctx.calendars[id];
+        if (!ctxCal) { return; }
+
+        // If the calendar doesn't exist in any other team, stop it and delete it from ctx
+        if (!ctxCal.stores.length) {
+            ctxCal.lm.stop();
+            clearReminders(ctx, id);
+            delete ctx.calendars[id];
+        }
+    };
+
+    var updateLocalCalendars = function (ctx, c, data) {
+        // Also update local data
+        c.stores.forEach(function (id) {
+            var s = getStore(ctx, id);
+            if (!s || !s.proxy) { return; }
+            if (!s.rpc) { return; } // team viewer
+            if (!s.proxy.calendars) { return; }
+            var cal = s.proxy.calendars[c.channel];
+            if (!cal) { return; }
+            if (cal.color !== data.color) { cal.color = data.color; }
+            if (cal.title !== data.title) { cal.title = data.title; }
+        });
+    };
+
+    var getRecurring = function (ev) {
+        var mid = new Date();
+        var start = new Date(mid.getFullYear(), mid.getMonth()-1, 15);
+        var end = new Date(mid.getFullYear(), mid.getMonth()+1, 15);
+        var startId = Rec.getMonthId(start);
+        var midId = Rec.getMonthId(mid);
+        var endId = Rec.getMonthId(end);
+
+        var toAdd = Rec.getRecurring([startId, midId, endId], [ev]);
+
+        var all = [ev];
+        Array.prototype.push.apply(all, toAdd);
+        return Rec.applyUpdates(all);
+    };
+    var clearDismissed = function (ctx, uid) {
+        var h = Util.find(ctx, ['store', 'proxy', 'hideReminders']) || {};
+        Object.keys(h).filter(function (id) {
+            return id === uid;
+        }).forEach(function (id) {
+            delete h[id];
+        });
+    };
+    var _updateEventReminders = function (ctx, reminders, _ev, useLastVisit) {
+        var now = +new Date();
+        var ev = Util.clone(_ev);
+        var uid = ev.id;
+
+        // Clear reminders for this event
+        if (Array.isArray(reminders[uid])) {
+            reminders[uid].forEach(function (to) { clearTimeout(to); });
+        }
+        reminders[uid] = [];
+
+        if (_ev.deleted) { return; }
+
+        var d = Util.find(ctx, ['store', 'proxy', 'hideReminders', uid]) || []; // dismissed
+
+        var last = ctx.store.data.lastVisit;
+
+        if (ev.isAllDay) {
+            if (ev.startDay) { ev.start = +FP.parseDate(ev.startDay); }
+            if (ev.endDay) {
+                var endDate = FP.parseDate(ev.endDay);
+                endDate.setHours(23);
+                endDate.setMinutes(59);
+                endDate.setSeconds(59);
+                ev.end = +endDate;
+            }
+        }
+
+        var oneWeekAgo = now - (7 * 24 * 3600 * 1000);
+        var missed = useLastVisit && ev.start > last && ev.end <= now && ev.end > oneWeekAgo;
+        if (ev.end <= now && !missed) {
+            // No reminder for past events
+            delete reminders[uid];
+            clearDismissed(ctx, uid);
+            return;
+        }
+
+        var send = function (d) {
+            var hide = Util.find(ctx, ['store', 'proxy', 'settings', 'general', 'calendar', 'hideNotif']);
+            if (hide) { return; }
+            var ctime = ev.start <= now ? ev.start : +new Date(); // Correct order for past events
+            ctx.store.mailbox.showMessage('reminders', {
+                msg: {
+                    ctime: ctime,
+                    type: "REMINDER",
+                    missed: Boolean(missed),
+                    content: ev
+                },
+                hash: 'REMINDER|'+uid+'-'+d
+            }, null, function () {
+            });
+        };
+        var sent = false;
+        var sendNotif = function (delay) {
+            sent = true;
+
+            ctx.Store.onReadyEvt.reg(function () {
+                send(delay);
+            });
+        };
+
+        var notifs = ev.reminders || [];
+        notifs.sort(function (a, b) {
+            return a - b;
+        });
+
+        notifs.some(function (delayMinutes) {
+            var delay = delayMinutes * 60000;
+            var time = now + delay;
+
+            if (d.some(function (minutes) {
+                return delayMinutes >= minutes;
+            })) { return; }
+
+            // setTimeout only work with 32bit timeout values. If the event is too far away,
+            // ignore this event for now
+            // FIXME: call this function again in xxx days to reload these missing timeout?
+            if (ev.start - time >= 2147483647) { return true; }
+
+            // If we're too late to send a notification, send it instantly and ignore
+            // all notifications that were supposed to be sent even earlier
+            if (ev.start <= time) {
+                sendNotif(delayMinutes);
+                return true;
+            }
+
+            // It starts in more than "delay": prepare the notification
+            reminders[uid].push(setTimeout(function () {
+                sendNotif(delayMinutes);
+            }, (ev.start - time)));
+        });
+
+        if (!sent) {
+            // Remone any existing notification from the UI
+            ctx.Store.onReadyEvt.reg(function () {
+                ctx.store.mailbox.hideMessage('reminders', {
+                    hash: 'REMINDER|'+uid
+                }, null, function () {
+                });
+            });
+        }
+    };
+    var updateEventReminders = function (ctx, reminders, ev, useLastVisit) {
+        var all = getRecurring(Util.clone(ev));
+        all.forEach(function (_ev) {
+            _updateEventReminders(ctx, reminders, _ev, useLastVisit);
+        });
+    };
+    var addReminders = function (ctx, id, ev) {
+        var calendar = ctx.calendars[id];
+        if (!ev) { return; }
+        if (!calendar || !calendar.reminders) { return; }
+        if (calendar.stores.length === 1 && calendar.stores[0] === 0) { return; }
+
+        updateEventReminders(ctx, calendar.reminders, ev);
+    };
+    var addInitialReminders = function (ctx, id, useLastVisit) {
+        var calendar = ctx.calendars[id];
+        if (!calendar || !calendar.reminders) { return; }
+        if (Object.keys(calendar.reminders).length) { return; } // Already initialized
+
+        // No reminders for calendars not stored
+        if (calendar.stores.length === 1 && calendar.stores[0] === 0) { return; }
+
+        // Re-add all reminders
+        var content = Util.find(calendar, ['proxy', 'content']);
+        if (!content) { return; }
+        Object.keys(content).forEach(function (uid) {
+            updateEventReminders(ctx, calendar.reminders, content[uid], useLastVisit);
+        });
+    };
+    var openChannel = function (ctx, cfg, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb || function () {}));
+        var teamId = cfg.storeId;
+        var data = cfg.data;
+        var channel = data.channel;
+        if (!channel) { return; }
+
+        var c = ctx.calendars[channel];
+
+        var update = function () {
+            sendUpdate(ctx, c);
+        };
+
+        if (c) {
+            if (c.readOnly && data.href) {
+                // Upgrade readOnly calendar to editable
+                var upgradeParsed = Hash.parsePadUrl(data.href);
+                var upgradeSecret = Hash.getSecrets('calendar', upgradeParsed.hash, data.password);
+                var upgradeCrypto = Crypto.createEncryptor(upgradeSecret.keys);
+                c.hashes.editHash = Hash.getEditHashFromKeys(upgradeSecret);
+                c.lm.setReadOnly(false, upgradeCrypto);
+                c.readOnly = false;
+            } else if (teamId === 0) {
+                // If we open a second tab with the same temp URL, push to tempId
+                if (c.stores.length === 1 && c.stores[0] === 0 && c.tempId.length && cfg.cId) {
+                    c.tempId.push(cfg.cId);
+                }
+                // Existing calendars can't be "temp calendars" (unless they are an upgrade)
+                return void cb();
+            }
+
+            // Remove from roStores when upgrading this store
+            if (c.roStores.indexOf(teamId) !== -1 && data.href) {
+                c.roStores.splice(c.roStores.indexOf(teamId), 1);
+                // If we've upgraded a stored calendar, remove the temp calendar
+                if (c.stores.indexOf(0) !== -1) {
+                    c.stores.splice(c.stores.indexOf(0), 1);
+                }
+                update();
+            }
+
+            // Don't store duplicates
+            if (c.stores && c.stores.indexOf(teamId) !== -1) { return void cb(); }
+
+            // If we store a temp calendar to our account or team, remove this "temp calendar"
+            if (c.stores.indexOf(0) !== -1) {
+                c.stores.splice(c.stores.indexOf(0), 1);
+                c.tempId = [];
+            }
+
+            c.stores.push(teamId);
+            if (!data.href) {
+                c.roStores.push(teamId);
+            }
+            update();
+            return void cb();
+        }
+
+        // Multiple teams can have the same calendar. Make sure we remember the list of stores
+        // that know it so that we don't close the calendar when leaving/deleting a team.
+        c = ctx.calendars[channel] = {
+            ready: false,
+            channel: channel,
+            readOnly: !data.href,
+            tempId: [],
+            stores: [teamId],
+            roStores: data.href ? [] : [teamId],
+            reminders: {},
+            hashes: {}
+        };
+
+        if (teamId === 0) {
+            c.tempId.push(cfg.cId);
+        }
+
+
+        var parsed = Hash.parsePadUrl(data.href || data.roHref);
+        var secret = Hash.getSecrets('calendar', parsed.hash, data.password);
+        var crypto = Crypto.createEncryptor(secret.keys);
+
+        c.hashes.viewHash = Hash.getViewHashFromKeys(secret);
+        if (data.href) {
+            c.hashes.editHash = Hash.getEditHashFromKeys(secret);
+        }
+
+        c.proxy = {
+            metadata: {
+                color: data.color,
+                title: data.title
+            }
+        };
+        update();
+
+        var onDeleted = function () {
+            // Remove this calendar from all our teams
+            c.stores.forEach(function (storeId) {
+                var store = getStore(ctx, storeId);
+                if (!store || !store.rpc || !store.proxy.calendars) { return; }
+                delete store.proxy.calendars[channel];
+                // And unpin
+                var unpin = store.unpin || ctx.unpinPads;
+                unpin([channel], function (res) {
+                    if (res && res.error) { console.error(res.error); }
+                });
+            });
+
+            // Close listmap, update the UI and clear the memory
+            if (c.lm) { c.lm.stop(); }
+            c.stores = [];
+            sendUpdate(ctx, c);
+            clearReminders(ctx, channel);
+            delete ctx.calendars[channel];
+        };
+
+        nThen(function (waitFor) {
+            if (!ctx.store.network || cfg.isNew) { return; }
+            // This is supposed to be an existing channel. Make sure it exists on the server
+            // before trying to load it.
+            // NOTE: if we can't check (error), we can skip this step. On "ready", we have
+            // another check to make sure we won't make a new calendar
+            ctx.Store.isNewChannel(null, channel, waitFor(function (obj) {
+                if (obj && obj.error) {
+                    // If we can't check, skip this part
+                    return;
+                }
+                if (obj && typeof(obj.isNew) === "boolean") {
+                    if (obj.isNew) {
+                        onDeleted();
+                        cb({error: 'EDELETED'});
+                        waitFor.abort();
+                        return;
+                    }
+                }
+            }));
+        }).nThen(function () {
+            // Set the owners as the first store opening it. We don't know yet if it's a new or
+            // existing calendar. "owners' will be ignored if the calendar already exists.
+            var edPublic;
+            if (teamId === 1 || !teamId) {
+                edPublic = ctx.store.proxy.edPublic;
+            } else {
+                var teams = ctx.store.modules.team && ctx.store.modules.team.getTeamsData();
+                var team = teams && teams[teamId];
+                edPublic = team ? team.edPublic : undefined;
+            }
+
+            var config = {
+                data: {},
+                network: ctx.store.network || ctx.store.networkPromise,
+                channel: secret.channel,
+                crypto: crypto,
+                owners: [edPublic],
+                ChainPad: ChainPad,
+                validateKey: secret.keys.validateKey || undefined,
+                userName: 'calendar',
+                Cache: Cache,
+                classic: true,
+                onRejected: ctx.Store && ctx.Store.onRejected
+            };
+
+            var lm = Listmap.create(config);
+            c.lm = lm;
+            var proxy = c.proxy = lm.proxy;
+
+            var _updateCalled = false;
+            var _update = function () {
+                if (_updateCalled) { return; }
+                _updateCalled = true;
+                setTimeout(function () {
+                    _updateCalled = false;
+                    update();
+                });
+            };
+
+            lm.proxy.on('cacheready', function () {
+                if (!proxy.metadata) { return; }
+                c.cacheready = true;
+                _update();
+                if (cb) { cb(null, lm.proxy); }
+                addInitialReminders(ctx, channel, cfg.lastVisitNotif);
+            }).on('ready', function (info) {
+                var md = info.metadata;
+                c.owners = md.owners || [];
+                c.ready = true;
+                if (!proxy.metadata) {
+                    if (!cfg.isNew) {
+                        // no metadata on an existing calendar: deleted calendar
+                        return void onDeleted();
+                    }
+                    proxy.metadata = {
+                        color: data.color,
+                        title: data.title
+                    };
+                }
+                _update();
+                if (cb) { cb(null, lm.proxy); }
+                addInitialReminders(ctx, channel, cfg.lastVisitNotif);
+            }).on('change', [], function () {
+                if (!c.ready) { return; }
+                _update();
+            }).on('change', ['content'], function (o, n, p) {
+                if (p.length === 2 && n && !o) { // New event
+                    return void addReminders(ctx, channel, n);
+                }
+                if (p.length === 2 && !n && o) { // Deleted event
+                    return void addReminders(ctx, channel, {
+                        id: p[1],
+                        start: 0
+                    });
+                }
+                if (p.length >= 3 && ['start','reminders','isAllDay'].includes(p[2])) {
+                    // Updated event
+                    return void setTimeout(function () {
+                        addReminders(ctx, channel, proxy.content[p[1]]);
+                    });
+                }
+                if (p.length >= 6 && ['start','reminders','isAllDay'].includes(p[5])) {
+                    // Updated recurring event
+                    return void setTimeout(function () {
+                        addReminders(ctx, channel, proxy.content[p[1]]);
+                    });
+                }
+            }).on('remove', ['content'], function (x, p) {
+                _update();
+                if ((p.length >= 3 && p[2] === 'reminders') ||
+                    (p.length >= 6 && p[5] === 'reminders')) {
+                    return void setTimeout(function () {
+                        addReminders(ctx, channel, proxy.content[p[1]]);
+                    });
+                }
+            }).on('change', ['metadata'], function () {
+                // if title or color have changed, update our local values
+                var md = proxy.metadata;
+                if (!md || !md.title || !md.color) { return; }
+                updateLocalCalendars(ctx, c, md);
+            }).on('disconnect', function () {
+                c.offline = true;
+                _update();
+            }).on('reconnect', function () {
+                c.offline = false;
+                _update();
+            }).on('error', function (info) {
+                if (!info || !info.error) { return; }
+                if (info.error === "EDELETED" ) {
+                    return void onDeleted();
+                }
+                if (info.error === "ERESTRICTED" ) {
+                    c.restricted = true;
+                    _update();
+                }
+                cb(info);
+            });
+        });
+    };
+    var decryptTeamCalendarHref = function (store, calData) {
+        if (!calData.href) { return; }
+
+        // Already decrypted? nothing to do
+        if (calData.href.indexOf('#') !== -1) { return; }
+
+        // href exists and is encrypted: decrypt if we can or ignore the href
+        if (store.secondaryKey) {
+            try {
+                calData.href = store.userObject.cryptor.decrypt(calData.href);
+            } catch (e) {
+                console.error(e);
+                delete calData.href;
+            }
+        } else {
+            delete calData.href;
+        }
+    };
+    var initializeStore = function (ctx, store) {
+        var c = store.proxy.calendars;
+        var storeId = store.id || 1;
+
+        // Add listeners
+        store.proxy.on('change', ['calendars'], function (o, n, p) {
+            if (p.length < 2) { return; }
+
+            // Handle deletions
+            if (o && !n) {
+                (function () {
+                    var id = p[1];
+                    var ctxCal = ctx.calendars[id];
+                    if (!ctxCal) { return; }
+                    var idx = ctxCal.stores.indexOf(storeId);
+
+                    // Check if the team has loaded this calendar in memory
+                    if (idx === -1) { return; }
+
+                    // Remove the team from memory
+                    ctxCal.stores.splice(idx, 1);
+                    var roIdx = ctxCal.roStores.indexOf(storeId);
+                    if (roIdx !== -1) { ctxCal.roStores.splice(roIdx, 1); }
+
+                    // Check if we need to close listmap and update the UI
+                    closeCalendar(ctx, id);
+                    sendUpdate(ctx, ctxCal);
+                })();
+            }
+
+            // Handle additions
+            // NOTE: this also upgrade from readOnly to edit (add an "href" to the calendar)
+            if (!o && n) {
+                (function () {
+                    var id = p[1];
+                    var _cal = store.proxy.calendars[id];
+                    if (!_cal) { return; }
+                    var cal = Util.clone(_cal);
+                    decryptTeamCalendarHref(store, cal);
+                    openChannel(ctx, {
+                        storeId: storeId,
+                        data: cal
+                    });
+                })();
+            }
+        });
+
+        // If this store contains existing calendars, open them
+        Object.keys(c || {}).forEach(function (channel) {
+            var cal = Util.clone(c[channel]);
+            decryptTeamCalendarHref(store, cal);
+            openChannel(ctx, {
+                storeId: storeId,
+                lastVisitNotif: true,
+                data: cal
+            });
+        });
+    };
+    var openChannels = function (ctx) {
+        // Personal drive
+        initializeStore(ctx, ctx.store);
+
+        var teams = ctx.store.modules.team && ctx.store.modules.team.getTeamsData();
+        if (!teams) { return; }
+        Object.keys(teams).forEach(function (id) {
+            var store = getStore(ctx, id);
+            initializeStore(ctx, store);
+        });
+    };
+
+
+    var subscribe = function (ctx, data, cId, cb) {
+        // Subscribe to new notifications
+        var idx = ctx.clients.indexOf(cId);
+        if (idx === -1) {
+            ctx.clients.push(cId);
+        }
+        cb({
+            empty: !Object.keys(ctx.calendars).length
+        });
+        Object.keys(ctx.calendars).forEach(function (channel) {
+            var c = ctx.calendars[channel] || {};
+            sendUpdate(ctx, c);
+        });
+    };
+
+    var importICSCalendar = function (ctx, data, cId, cb) {
+        var id = data.id;
+        var c = ctx.calendars[id];
+        if (!c || !c.proxy) { return void cb({error: "ENOENT"}); }
+        var json = data.json;
+        c.proxy.content = c.proxy.content || {};
+        Object.keys(json).forEach(function (uid) {
+            c.proxy.content[uid] = json[uid];
+            addReminders(ctx, id, json[uid]);
+        });
+
+        Realtime.whenRealtimeSyncs(c.lm.realtime, function () {
+            sendUpdate(ctx, c);
+            cb();
+        });
+    };
+
+    var openCalendar = function (ctx, data, cId, cb) {
+        var secret = Hash.getSecrets('calendar', data.hash, data.password);
+        var hash = Hash.getEditHashFromKeys(secret);
+        var roHash = Hash.getViewHashFromKeys(secret);
+
+        //if (!ctx.loggedIn) { hash = undefined; }
+
+        var cal = {
+            href: hash && Hash.hashToHref(hash, 'calendar'),
+            roHref: roHash && Hash.hashToHref(roHash, 'calendar'),
+            channel: secret.channel,
+            color: Util.getRandomColor(),
+            title: '...'
+        };
+        openChannel(ctx, {
+            cId: cId,
+            storeId: 0,
+            data: cal
+        }, cb);
+    };
+    var importCalendar = function (ctx, data, cId, cb) {
+        var id = data.id;
+        var c = ctx.calendars[id];
+        if (!c) { return void cb({error: "ENOENT"}); }
+        if (!Array.isArray(c.stores) || c.stores.indexOf(data.teamId) === -1) {
+            return void cb({error: 'EINVAL'});
+        }
+
+        // Add to my calendars
+        var store = ctx.store;
+        var calendars = store.proxy.calendars = store.proxy.calendars || {};
+        var hash = c.hashes.editHash;
+        var roHash = c.hashes.viewHash;
+        calendars[id] = {
+            href: hash && Hash.hashToHref(hash, 'calendar'),
+            roHref: roHash && Hash.hashToHref(roHash, 'calendar'),
+            channel: id,
+            color: Util.find(c,['proxy', 'metadata', 'color']) || Util.getRandomColor(),
+            title: Util.find(c,['proxy', 'metadata', 'title']) || '...'
+        };
+        ctx.Store.onSync(null, cb);
+
+        // Make the change in memory
+        openChannel(ctx, {
+            storeId: 1,
+            data: {
+                href: calendars[id].href,
+                toHref: calendars[id].roHref,
+                channel: id
+            }
+        });
+    };
+    var addCalendar = function (ctx, data, cId, cb) {
+        var store = getStore(ctx, data.teamId);
+        if (!store) { return void cb({error: "NO_STORE"}); }
+        // Check team edit rights: viewers in teams don't have rpc
+        if (!store.rpc) { return void cb({error: "EFORBIDDEN"}); }
+
+        var c = store.proxy.calendars = store.proxy.calendars || {};
+        var parsed = Hash.parsePadUrl(data.href);
+        var secret = Hash.getSecrets(parsed.type, parsed.hash, data.password);
+
+        if (secret.channel !== data.channel) { return void cb({error: 'EINVAL'}); }
+
+        var hash = Hash.getEditHashFromKeys(secret);
+        var roHash = Hash.getViewHashFromKeys(secret);
+        var href = hash && Hash.hashToHref(hash, 'calendar');
+        var cal = {
+            href: href,
+            roHref: roHash && Hash.hashToHref(roHash, 'calendar'),
+            color: data.color,
+            title: data.title,
+            channel: data.channel
+        };
+
+        // If it already existed and it's not an upgrade, nothing to do
+        if (c[data.channel] && (c[data.channel].href || !cal.href)) { return void cb(); }
+
+        cal.color = data.color;
+        cal.title = data.title;
+        openChannel(ctx, {
+            storeId: store.id || 1,
+            data: Util.clone(cal)
+        }, function (err) {
+            if (err) {
+                // Can't open this channel, don't store it
+                console.error(err);
+                return void cb({error: err.error});
+            }
+
+            if (href && store.id && store.secondaryKey) {
+                try {
+                    cal.href = store.userObject.cryptor.encrypt(href);
+                } catch (e) {
+                    console.error(e);
+                }
+            }
+
+            // Add the calendar and call back
+            // If it already existed it means this is an upgrade
+            c[cal.channel] = cal;
+            var pin = store.pin || ctx.pinPads;
+            pin([cal.channel], function (res) {
+                if (res && res.error) { console.error(res.error); }
+            });
+            ctx.Store.onSync(store.id, cb);
+        });
+    };
+    var createCalendar = function (ctx, data, cId, cb) {
+        var store = getStore(ctx, data.teamId);
+        if (!store) { return void cb({error: "NO_STORE"}); }
+        // Check team edit rights: viewers in teams don't have rpc
+        if (!store.rpc) { return void cb({error: "EFORBIDDEN"}); }
+
+        var c = store.proxy.calendars = store.proxy.calendars || {};
+        var cal = makeCalendar();
+        cal.color = data.color;
+        cal.title = data.title;
+        openChannel(ctx, {
+            storeId: store.id || 1,
+            data: cal,
+            isNew: true
+        }, function (err) {
+            if (err) {
+                // Can't open this channel, don't store it
+                console.error(err);
+                return void cb({error: err.error});
+            }
+            // Add the calendar and call back
+            // Wait for the metadata to be stored (channel fully ready) before adding it
+            // to our store
+            var ctxCal = ctx.calendars[cal.channel];
+            Realtime.whenRealtimeSyncs(ctxCal.lm.realtime, function () {
+                c[cal.channel] = cal;
+                var pin = store.pin || ctx.pinPads;
+                pin([cal.channel], function (res) {
+                    if (res && res.error) { console.error(res.error); }
+                });
+                ctx.Store.onSync(store.id, cb);
+            });
+        });
+    };
+    var updateCalendar = function (ctx, data, cId, cb) {
+        var id = data.id;
+        var c = ctx.calendars[id];
+        if (!c) { return void cb({error: "ENOENT"}); }
+        var md = Util.find(c, ['proxy', 'metadata']);
+        if (!md) { return void cb({error: 'EINVAL'}); }
+        md.title = data.title;
+        md.color = data.color;
+        Realtime.whenRealtimeSyncs(c.lm.realtime, cb);
+        sendUpdate(ctx, c);
+
+        updateLocalCalendars(ctx, c, data);
+    };
+    var deleteCalendar = function (ctx, data, cId, cb) {
+        var store = getStore(ctx, data.teamId);
+        if (!store) { return void cb({error: "NO_STORE"}); }
+        if (!store.rpc) { return void cb({error: "EFORBIDDEN"}); }
+        if (!store.proxy.calendars) { return; }
+        var id = data.id;
+        var cal = store.proxy.calendars[id];
+        if (!cal) { return void cb(); } // Already deleted
+
+        // Delete
+        delete store.proxy.calendars[id];
+
+        // Unpin
+        var unpin = store.unpin || ctx.unpinPads;
+        unpin([id], function (res) {
+            if (res && res.error) { console.error(res.error); }
+        });
+
+        // Clear/update ctx data
+
+        // Remove this store from the calendar's clients
+        var ctxCal = ctx.calendars[id];
+        var idx = ctxCal.stores.indexOf(store.id || 1);
+        ctxCal.stores.splice(idx, 1);
+
+        closeCalendar(ctx, id);
+
+        ctx.Store.onSync(store.id, function () {
+            sendUpdate(ctx, ctxCal);
+            cb();
+        });
+    };
+
+    var createEvent = function (ctx, data, cId, cb) {
+        var id = data.calendarId;
+        var c = ctx.calendars[id];
+        if (!c) { return void cb({error: "ENOENT"}); }
+
+        var startDate = new Date(data.start);
+        var endDate = new Date(data.end);
+        if (data.isAllDay) {
+            data.startDay = startDate.getFullYear() + '-' + (startDate.getMonth()+1) + '-' + startDate.getDate();
+            data.endDay = endDate.getFullYear() + '-' + (endDate.getMonth()+1) + '-' + endDate.getDate();
+        } else {
+            delete data.startDay;
+            delete data.endDay;
+        }
+
+        c.proxy.content = c.proxy.content || {};
+        c.proxy.content[data.id] = data;
+
+        Realtime.whenRealtimeSyncs(c.lm.realtime, function () {
+            addReminders(ctx, id, data);
+            sendUpdate(ctx, c);
+            cb();
+        });
+    };
+    var updateEvent = function (ctx, data, cId, cb) {
+        if (!data || !data.ev) { return void cb({error: 'EINVAL'}); }
+        var id = data.ev.calendarId;
+        var c = ctx.calendars[id];
+        if (!c || !c.proxy || !c.proxy.content) { return void cb({error: "ENOENT"}); }
+
+        // Find the event
+        var ev = c.proxy.content[data.ev.id];
+        if (!ev) { return void cb({error: "EINVAL"}); }
+
+        data.rawData = data.rawData || {};
+
+        // update the event
+        var changes = data.changes || {};
+        var type = data.type || {};
+
+        var newC;
+        if (changes.calendarId) {
+            newC = ctx.calendars[changes.calendarId];
+            if (!newC || !newC.proxy) { return void cb({error: "ENOENT"}); }
+            newC.proxy.content = newC.proxy.content || {};
+        }
+
+        var RECUPDATE = {
+            one: {},
+            from: {}
+        };
+        if (['one','from','all'].includes(type.which)) {
+            ev.recUpdate = ev.recUpdate || RECUPDATE;
+            if (!ev.recUpdate.one) { ev.recUpdate.one = {}; }
+            if (!ev.recUpdate.from) { ev.recUpdate.from = {}; }
+        }
+        var update = ev.recUpdate;
+        var alwaysAll = ['calendarId'];
+        var keys = Object.keys(changes).filter(function (s) {
+            // we can only change the calendar or recurrence rule on the origin
+            return !alwaysAll.includes(s);
+        });
+
+        // Delete (future) affected keys
+        var cleanAfter = function (time) {
+            [update.from, update.one].forEach(function (obj) {
+                Object.keys(obj).forEach(function (d) {
+                    if (Number(d) < time) { return; }
+                    delete obj[d];
+                });
+            });
+        };
+        var cleanKeys = function (obj, when) {
+            Object.keys(obj).forEach(function (d) {
+                if (when && Number(d) < when) { return; }
+                keys.forEach(function (k) {
+                    delete obj[d][k];
+                });
+            });
+        };
+
+
+        // Update recurrence rule. We may create a new event here
+        var dontSendUpdate = false;
+        if (typeof(changes.recurrenceRule) !== "undefined") {
+            if (type.which === "all" && changes.recurrenceRule.until) {
+                // Remove changes after the last iteration
+                cleanAfter(changes.recurrenceRule.until);
+            }
+            else if (['one','from'].includes(type.which) && !data.rawData.isOrigin) {
+                // Start cleaning after the event (otherwise it resets the current event)
+                cleanAfter(type.when + 1);
+            } else {
+                // Else wipe everything
+                update = ev.recUpdate = RECUPDATE;
+            }
+        }
+
+        if (type.which === "one") {
+            update.one[type.when] = update.one[type.when] || {};
+            // Nothing to delete
+        } else if (type.which === "from") {
+            update.from[type.when] = update.from[type.when] || {};
+            // Delete all "single/from" updates (affected keys only) after this "from" date
+            cleanKeys(update.from, type.when);
+            cleanKeys(update.one, type.when);
+        } else if (type.which === "all") {
+            // Delete all "single/from" updates (affected keys only) after
+            cleanKeys(update.from);
+            cleanKeys(update.one);
+        }
+
+        if (changes.start && update && (!type.which || type.which === "all")) {
+            var diff = changes.start - ev.start;
+            var newOne = {};
+            var newFrom = {};
+            Object.keys(update.one || {}).forEach(function (time) {
+                newOne[Number(time)+diff] = update.one[time];
+            });
+            Object.keys(update.from || {}).forEach(function (time) {
+                newFrom[Number(time)+diff] = update.from[time];
+            });
+            update.one = newOne;
+            update.from = newFrom;
+        }
+
+
+        // Clear the "dismissed" reminders when the user is updating reminders
+        var h = Util.find(ctx, ['store', 'proxy', 'hideReminders']) || {};
+        if (changes.reminders) {
+            if (type.which === 'one') {
+                if (!type.when || type.when === ev.start) { delete h[data.ev.id]; }
+                else { delete h[data.ev.id +'|'+ type.when]; }
+            } else if (type.which === "from") {
+                Object.keys(h).filter(function (id) {
+                    return id.indexOf(data.ev.id) === 0;
+                }).forEach(function (id) {
+                    var time = Number(id.split('|')[1]);
+                    if (!time) { return; }
+                    if (time < type.when) { return; }
+                    delete h[id];
+                });
+            } else {
+                Object.keys(h).filter(function (id) {
+                    return id.indexOf(data.ev.id) === 0;
+                }).forEach(function (id) {
+                    delete h[id];
+                });
+            }
+        }
+
+        // Apply the changes
+        Object.keys(changes).forEach(function (key) {
+            if (!alwaysAll.includes(key) && type.which === "one") {
+                if (key === "recurrenceRule") {
+                    if (data.rawData && data.rawData.isOrigin) {
+                        return (ev[key] = changes[key]);
+                    }
+                    // Always "from", never "one" for recurrence rules
+                    update.from[type.when] = update.from[type.when] || {};
+                    return (update.from[type.when][key] = changes[key]);
+                }
+                update.one[type.when][key] = changes[key];
+                return;
+            }
+            if (!alwaysAll.includes(key) && type.which === "from") {
+                update.from[type.when][key] = changes[key];
+                return;
+            }
+            ev[key] = changes[key];
+        });
+
+        var startDate = new Date(ev.start);
+        var endDate = new Date(ev.end);
+        if (ev.isAllDay) {
+            ev.startDay = startDate.getFullYear() + '-' + (startDate.getMonth()+1) + '-' + startDate.getDate();
+            ev.endDay = endDate.getFullYear() + '-' + (endDate.getMonth()+1) + '-' + endDate.getDate();
+        } else {
+            delete ev.startDay;
+            delete ev.endDay;
+        }
+
+        // Move to a different calendar?
+        if (changes.calendarId && newC) {
+            newC.proxy.content[data.ev.id] = Util.clone(ev);
+            delete c.proxy.content[data.ev.id];
+        }
+
+
+        nThen(function (waitFor) {
+            Realtime.whenRealtimeSyncs(c.lm.realtime, waitFor());
+            if (newC) { Realtime.whenRealtimeSyncs(newC.lm.realtime, waitFor()); }
+        }).nThen(function () {
+            if (newC) {
+                // Move reminders to the new calendar
+                addReminders(ctx, id, {
+                    id: ev.id,
+                    start: 0
+                });
+                addReminders(ctx, ev.calendarId, ev);
+            } else if (changes.start || changes.reminders || changes.isAllDay) {
+                // Update reminders
+                addReminders(ctx, id, ev);
+            }
+
+            if (!dontSendUpdate || newC) { sendUpdate(ctx, c); }
+            if (newC && !dontSendUpdate) { sendUpdate(ctx, newC); }
+            cb();
+        });
+    };
+    var deleteEvent = function (ctx, data, cId, cb) {
+        var id = data.calendarId;
+        var c = ctx.calendars[id];
+        if (!c) { return void cb({error: "ENOENT"}); }
+        c.proxy.content = c.proxy.content || {};
+        var evId = data.id.split('|')[0];
+        if (data.id === evId) {
+            delete c.proxy.content[data.id];
+        } else {
+            var ev = c.proxy.content[evId];
+            var s = data.raw && data.raw.start;
+            if (s) {
+                ev.recUpdate = ev.recUpdate || {
+                    one: {},
+                    from: {}
+                };
+                ev.recUpdate.one[s] = {
+                    deleted: true
+                };
+            }
+        }
+        Realtime.whenRealtimeSyncs(c.lm.realtime, function () {
+            addReminders(ctx, id, {
+                id: data.id,
+                start: 0
+            });
+            sendUpdate(ctx, c);
+            cb();
+        });
+    };
+
+    var removeClient = function (ctx, cId) {
+        var idx = ctx.clients.indexOf(cId);
+        if (idx !== -1) { ctx.clients.splice(idx, 1); }
+
+        Object.keys(ctx.calendars).forEach(function (id) {
+            var cal = ctx.calendars[id];
+            if (cal.stores.length !== 1 || cal.stores[0] !== 0 || !cal.tempId.length) { return; }
+            // This is a temp calendar: check if the closed tab had this calendar opened
+            var idx = cal.tempId.indexOf(cId);
+            if (idx !== -1) { cal.tempId.splice(idx, 1); }
+            if (!cal.tempId.length) {
+                cal.stores = [];
+                // Close calendar
+                closeCalendar(ctx, id);
+            }
+        });
+    };
+
+    Calendar.init = function (cfg, waitFor, emit) {
+        var calendar = {};
+        var store = cfg.store;
+        var ctx = {
+            loggedIn: store.loggedIn && store.proxy.edPublic,
+            store: store,
+            Store: cfg.Store,
+            pinPads: cfg.pinPads,
+            unpinPads: cfg.unpinPads,
+            updateMetadata: cfg.updateMetadata,
+            emit: emit,
+            onReady: Util.mkEvent(true),
+            calendars: {},
+            clients: []
+        };
+
+        initializeCalendars(ctx, waitFor(function (err) {
+            if (err) { return; }
+            openChannels(ctx);
+        }));
+
+        ctx.store.proxy.on('change', ['hideReminders'], function (o,n,p) {
+            var uid = p[1].split('|')[0];
+            Object.keys(ctx.calendars).some(function (calId) {
+                var c = ctx.calendars[calId];
+                if (!c || !c.proxy || !c.proxy.content) { return; }
+                if (c.proxy.content[uid]) {
+                    setTimeout(function () {
+                        addReminders(ctx, calId, c.proxy.content[uid]);
+                    });
+                    return true;
+                }
+            });
+        });
+
+        calendar.closeTeam = function (teamId) {
+            Object.keys(ctx.calendars).forEach(function (id) {
+                var ctxCal = ctx.calendars[id];
+                var idx = ctxCal.stores.indexOf(teamId);
+                if (idx === -1) { return; }
+                ctxCal.stores.splice(idx, 1);
+                var roIdx = ctxCal.roStores.indexOf(teamId);
+                if (roIdx !== -1) { ctxCal.roStores.splice(roIdx, 1); }
+
+                closeCalendar(ctx, id);
+                sendUpdate(ctx, ctxCal);
+            });
+        };
+        calendar.openTeam = function (teamId) {
+            var store = getStore(ctx, teamId);
+            if (!store) { return; }
+            initializeStore(ctx, store);
+        };
+        calendar.upgradeTeam = function (teamId) {
+            if (!teamId) { return; }
+            var store = getStore(ctx, teamId);
+            if (!store) { return; }
+            Object.keys(ctx.calendars).forEach(function (id) {
+                var ctxCal = ctx.calendars[id];
+                var idx = ctxCal.stores.indexOf(teamId);
+                if (idx === -1) { return; }
+                var _cal = store.proxy.calendars[id];
+                var cal = Util.clone(_cal);
+                decryptTeamCalendarHref(store, cal);
+                openChannel(ctx, {
+                    storeId: teamId,
+                    data: cal
+                });
+                sendUpdate(ctx, ctxCal);
+            });
+        };
+
+        calendar.removeClient = function (clientId) {
+            removeClient(ctx, clientId);
+        };
+        calendar.execCommand = function (clientId, obj, cb) {
+            var cmd = obj.cmd;
+            var data = obj.data;
+            if (cmd === 'SUBSCRIBE') {
+                return void subscribe(ctx, data, clientId, cb);
+            }
+            if (cmd === 'OPEN') {
+                ctx.Store.onReadyEvt.reg(function () {
+                    openCalendar(ctx, data, clientId, cb);
+                });
+                return;
+            }
+            if (cmd === 'IMPORT') {
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                return void importCalendar(ctx, data, clientId, cb);
+            }
+            if (cmd === 'IMPORT_ICS') {
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                //if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                return void importICSCalendar(ctx, data, clientId, cb);
+            }
+            if (cmd === 'ADD') {
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                return void addCalendar(ctx, data, clientId, cb);
+            }
+            if (cmd === 'CREATE') {
+                if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                if (data.initialCalendar) {
+                    return void ctx.Store.onReadyEvt.reg(function () {
+                        createCalendar(ctx, data, clientId, cb);
+                    });
+                }
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                return void createCalendar(ctx, data, clientId, cb);
+            }
+            if (cmd === 'UPDATE') {
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                //if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                return void updateCalendar(ctx, data, clientId, cb);
+            }
+            if (cmd === 'DELETE') {
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                return void deleteCalendar(ctx, data, clientId, cb);
+            }
+            if (cmd === 'CREATE_EVENT') {
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                //if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                return void createEvent(ctx, data, clientId, cb);
+            }
+            if (cmd === 'UPDATE_EVENT') {
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                //if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                return void updateEvent(ctx, data, clientId, cb);
+            }
+            if (cmd === 'DELETE_EVENT') {
+                if (ctx.store.offline) { return void cb({error: 'OFFLINE'}); }
+                //if (!ctx.loggedIn) { return void cb({error: 'NOT_LOGGED_IN'}); }
+                return void deleteEvent(ctx, data, clientId, cb);
+            }
+        };
+
+        return calendar;
+    };
+
+    return Calendar;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        require('../../common/common-util'),
+        require('../../common/common-hash'),
+        require('../../common/common-constants'),
+        require('../../common/common-realtime'),
+        require('../../common/cache-store'),
+        require('../components/recurrence'),
+        undefined,
+        require('nthen'),
+        require('chainpad-listmap'),
+        require('../../../www/lib/datepicker/flatpickr'),
+        require('chainpad-crypto'),
+        require('chainpad'),
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/common-constants.js',
+        '/common/common-realtime.js',
+        '/common/outer/cache-store.js',
+        '/calendar/recurrence.js',
+        '/customize/messages.js',
+        '/components/nthen/index.js',
+        'chainpad-listmap',
+        '/lib/datepicker/flatpickr.js',
+        '/components/chainpad-crypto/crypto.js',
+        '/components/chainpad/chainpad.dist.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
+
diff --git a/src/worker/modules/cursor.js b/src/worker/modules/cursor.js
new file mode 100644
index 000000000..17fe40cf9
--- /dev/null
+++ b/src/worker/modules/cursor.js
@@ -0,0 +1,312 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Util, Constants, Messages = {},
+                    AppConfig = {}, Crypto) => {
+    var Cursor = {};
+
+    Cursor.setCustomize = data => {
+        Messages = data.Messages;
+        AppConfig = data.AppConfig;
+    };
+
+
+    var DEGRADED = AppConfig.degradedLimit || 8;
+
+    var convertToUint8 = function (obj) {
+        var l = Object.keys(obj).length;
+        var u = new Uint8Array(l);
+        for (var i = 0; i<l; i++) {
+            u[i] = obj[i];
+        }
+        return u;
+    };
+
+    // Send the client's cursor to their channel when we receive an update
+    var sendMyCursor = function (ctx, clientId) {
+        var client = ctx.clients[clientId];
+        if (!client || !client.cursor) { return; }
+        var chan = ctx.channels[client.channel];
+        if (!chan) { return; }
+        if (chan.degraded) { return; }
+        if (!chan.sendMsg) { return; } // Store not synced yet, we're running with the cache
+        var data = {
+            id: client.id,
+            cursor: client.cursor
+        };
+        chan.sendMsg(JSON.stringify(data));
+        ctx.emit('MESSAGE', data, chan.clients.filter(function (cl) {
+            return cl !== clientId;
+        }));
+    };
+
+    // Send all our cursors data when someone remote joins the channel
+    var sendOurCursors = function (ctx, chan) {
+        if (chan.degraded) { return; }
+        chan.clients.forEach(function (c) {
+            var client = ctx.clients[c];
+            if (!client) { return; }
+            var data = {
+                id: client.id,
+                cursor: client.cursor
+            };
+            // Send our data to the other users (NOT including the other tabs of the same worker)
+            chan.sendMsg(JSON.stringify(data));
+        });
+    };
+
+    var updateDegraded = function (ctx, wc, chan) {
+        var m = wc.members;
+        chan.degraded = (m.length-1) >= DEGRADED;
+        ctx.emit('DEGRADED', { degraded: chan.degraded }, chan.clients);
+    };
+
+    var initCursor = function (ctx, obj, client, cb) {
+        var channel = obj.channel;
+        var secret = obj.secret;
+        if (secret.keys.cryptKey) {
+            secret.keys.cryptKey = convertToUint8(secret.keys.cryptKey);
+        }
+
+        var padChan = secret.channel;
+        var network = ctx.store.network;
+        var first = true;
+
+        var c = ctx.clients[client];
+        if (!c) {
+            c = ctx.clients[client] = {
+                channel: channel,
+                cursor: {}
+            };
+        } else {
+            return void cb();
+        }
+
+        var chan = ctx.channels[channel];
+        if (chan) {
+            // This channel is already open in another tab
+
+            // ==> Set the ID to our client object
+            if (!c.id) { c.id = chan.wc.myID + '-' + client; }
+
+            // ==> Send the cursor position of the other tabs
+            chan.clients.forEach(function (cl) {
+                var clientObj = ctx.clients[cl];
+                if (chan.degraded) { return; }
+                if (!clientObj) { return; }
+                ctx.emit('MESSAGE', {
+                    id: clientObj.id,
+                    cursor: clientObj.cursor
+                }, [client]);
+            });
+            chan.sendMsg(JSON.stringify({join: true, id: c.id}));
+
+            // ==> And push the new tab to the list
+            chan.clients.push(client);
+            updateDegraded(ctx, chan.wc, chan);
+            return void cb();
+        }
+
+        var onOpen = function (wc) {
+
+            ctx.channels[channel] = ctx.channels[channel] || {};
+
+            var chan = ctx.channels[channel];
+            chan.padChan = padChan;
+
+            if (!c.id) { c.id = wc.myID + '-' + client; }
+            if (chan.clients) {
+                // If 2 tabs from the same worker have been opened at the same time,
+                // we have to fix both of them
+                chan.clients.forEach(function (cl) {
+                    if (ctx.clients[cl] && !ctx.clients[cl].id) {
+                        ctx.clients[cl].id = wc.myID + '-' + cl;
+                    }
+                });
+            }
+
+
+            if (!chan.encryptor) { chan.encryptor = Crypto.createEncryptor(secret.keys); }
+
+            wc.on('join', function () {
+                sendOurCursors(ctx, chan);
+                updateDegraded(ctx, wc, chan);
+            });
+            wc.on('leave', function (peer) {
+                ctx.emit('MESSAGE', {leave: true, id: peer}, chan.clients);
+                updateDegraded(ctx, wc, chan);
+            });
+            wc.on('message', function (cryptMsg) {
+                if (chan.degraded) { return; }
+                var msg = chan.encryptor.decrypt(cryptMsg, secret.keys && secret.keys.validateKey);
+                var parsed;
+                try {
+                    parsed = JSON.parse(msg);
+                    if (parsed && parsed.join) {
+                        return void sendOurCursors(ctx, chan);
+                    }
+                    ctx.emit('MESSAGE', parsed, chan.clients);
+                } catch (e) { console.error(e); }
+            });
+
+
+            chan.wc = wc;
+            chan.sendMsg = function (msg, cb) {
+                cb = cb || function () {};
+                var cmsg = chan.encryptor.encrypt(msg);
+                wc.bcast(cmsg).then(function () {
+                    cb();
+                }, function (err) {
+                    cb({error: err});
+                });
+            };
+
+            if (!first) { return; }
+            chan.clients = [client];
+            first = false;
+            cb();
+
+            updateDegraded(ctx, wc, chan);
+        };
+
+        network.join(channel).then(onOpen, function (err) {
+            return void cb({error: err});
+        });
+
+        var onReconnect = function () {
+            if (!ctx.channels[channel]) { console.log("cant reconnect", channel); return; }
+            network.join(channel).then(onOpen, function (err) {
+                console.error(err);
+            });
+        };
+        ctx.channels[channel] = ctx.channels[channel] || {};
+        ctx.channels[channel].onReconnect = onReconnect;
+        network.on('reconnect', onReconnect);
+    };
+
+    var updateCursor = function (ctx, data, client, cb) {
+        var c = ctx.clients[client];
+        if (!c) { return void cb({error: 'NO_CLIENT'}); }
+        var proxy = ctx.store.proxy || {};
+        data.color = Util.find(proxy, ['settings', 'general', 'cursor', 'color']);
+        data.name = proxy[Constants.displayNameKey] || ctx.store.noDriveName || Messages.anonymous;
+        data.avatar = Util.find(proxy, ['profile', 'avatar']);
+        data.uid = Util.find(proxy, ['uid']) || ctx.store.noDriveUid;
+        c.cursor = data;
+        sendMyCursor(ctx, client);
+        cb();
+    };
+
+    var leaveChannel = function (ctx, padChan) {
+        // Leave channel and prevent reconnect when we leave a pad
+        Object.keys(ctx.channels).some(function (cursorChan) {
+            var channel = ctx.channels[cursorChan];
+            if (channel.padChan !== padChan) { return; }
+            if (channel.wc) { channel.wc.leave(); }
+            if (channel.onReconnect) {
+                var network = ctx.store.network;
+                network.off('reconnect', channel.onReconnect);
+            }
+            delete ctx.channels[cursorChan];
+            return true;
+        });
+    };
+    // Remove the client from all its channels when a tab is closed
+    var removeClient = function (ctx, clientId) {
+        var filter = function (c) {
+            return c !== clientId;
+        };
+
+        // Remove the client from our channels
+        var chan;
+        for (var k in ctx.channels) {
+            chan = ctx.channels[k];
+            chan.clients = chan.clients.filter(filter);
+            if (chan.clients.length === 0) {
+                if (chan.wc) { chan.wc.leave(); }
+                if (chan.onReconnect) {
+                    var network = ctx.store.network;
+                    network.off('reconnect', chan.onReconnect);
+                }
+                delete ctx.channels[k];
+            }
+        }
+
+        // Send the leave message to the channel we were in
+        if (ctx.clients[clientId]) {
+            var leaveMsg = {
+                leave: true,
+                id: ctx.clients[clientId].id
+            };
+            chan = ctx.channels[ctx.clients[clientId].channel];
+            if (chan) {
+                chan.sendMsg(JSON.stringify(leaveMsg));
+                ctx.emit('MESSAGE', leaveMsg, chan.clients);
+            }
+        }
+
+        delete ctx.clients[clientId];
+    };
+
+    Cursor.init = function (cfg, waitFor, emit) {
+        var cursor = {};
+
+        // Already initialized by a "noDrive" tab?
+        if (cfg.store && cfg.store.modules && cfg.store.modules['cursor']) {
+            return cfg.store.modules['cursor'];
+        }
+
+        var ctx = {
+            store: cfg.store,
+            emit: emit,
+            channels: {},
+            clients: {}
+        };
+
+        cursor.removeClient = function (clientId) {
+            removeClient(ctx, clientId);
+        };
+        cursor.leavePad = function (padChan) {
+            leaveChannel(ctx, padChan);
+        };
+        cursor.execCommand = function (clientId, obj, cb) {
+            var cmd = obj.cmd;
+            var data = obj.data;
+            if (cmd === 'INIT_CURSOR') {
+                return void initCursor(ctx, data, clientId, cb);
+            }
+            if (cmd === 'UPDATE') {
+                return void updateCursor(ctx, data, clientId, cb);
+            }
+        };
+
+        return cursor;
+    };
+
+    return Cursor;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        require('../../common/common-util'),
+        require('../../common/common-constants'),
+        undefined,
+        undefined,
+        require('chainpad-crypto')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-util.js',
+        '/common/common-constants.js',
+        '/customize/messages.js',
+        '/customize/application_config.js',
+        '/components/chainpad-crypto/crypto.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/modules/history.js b/src/worker/modules/history.js
new file mode 100644
index 000000000..337b88ace
--- /dev/null
+++ b/src/worker/modules/history.js
@@ -0,0 +1,279 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Util, Hash, UserObject, nThen) => {
+    var History = {};
+    var commands = {};
+
+    var getAccountChannels = function (ctx) {
+        var channels = [];
+        var edPublic = Util.find(ctx.store, ['proxy', 'edPublic']);
+
+        // Drive
+        var driveOwned = (Util.find(ctx.store, ['driveMetadata', 'owners']) || []).indexOf(edPublic) !== -1;
+        if (driveOwned) {
+            channels.push(ctx.store.driveChannel);
+        }
+
+        // Profile
+        var profile = ctx.store.proxy.profile;
+        if (profile) {
+            var profileChan = profile.edit ? Hash.hrefToHexChannelId('/profile/#' + profile.edit, null) : null;
+            if (profileChan) { channels.push(profileChan); }
+        }
+
+        // Todo
+        if (ctx.store.proxy.todo) {
+            channels.push(Hash.hrefToHexChannelId('/todo/#' + ctx.store.proxy.todo, null));
+        }
+
+
+        // Mailboxes
+        var mailboxes = ctx.store.proxy.mailboxes;
+        if (mailboxes) {
+            var mList = Object.keys(mailboxes).map(function (m) {
+                return {
+                    lastKnownHash: mailboxes[m].lastKnownHash,
+                    channel: mailboxes[m].channel
+                };
+            });
+            Array.prototype.push.apply(channels, mList);
+        }
+
+        // Shared folders owned by me
+        var sf = ctx.store.proxy[UserObject.SHARED_FOLDERS];
+        if (sf) {
+            var sfChannels = Object.keys(sf).map(function (fId) {
+                var data = sf[fId];
+                if (!data || !data.owners) { return; }
+                var isOwner = Array.isArray(data.owners) && data.owners.indexOf(edPublic) !== -1;
+                if (!isOwner) { return; }
+                return data.channel;
+            }).filter(Boolean);
+            Array.prototype.push.apply(channels, sfChannels);
+        }
+
+        return channels;
+    };
+
+    let getTeamChannels = function (ctx, teamId) {
+        let team = Util.find(ctx.store, ['proxy', 'teams', teamId]);
+        if (!team) { return []; }
+
+        let channels = [team.channel];
+        let roster = team.keys.roster;
+        channels.push({
+            channel: roster.channel,
+            lastKnownHash: roster.lastKnownHash
+        });
+        return channels;
+    };
+
+    var getEdPublic = function (ctx, teamId) {
+        if (!teamId) { return Util.find(ctx.store, ['proxy', 'edPublic']); }
+
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        return Util.find(teamData, ['keys', 'drive', 'edPublic']);
+    };
+    var getRpc = function (ctx, teamId) {
+        if (!teamId) { return ctx.store.rpc; }
+        var teams = ctx.store.modules['team'];
+        if (!teams) { return; }
+        var team = teams.getTeam(teamId);
+        if (!team) { return; }
+        return team.rpc;
+    };
+
+    var getHistoryData = function (ctx, channel, lastKnownHash, teamId, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var edPublic = getEdPublic(ctx, teamId);
+        var Store = ctx.Store;
+
+        var total = 0;
+        var history = 0;
+        var metadata = 0;
+        var hash;
+        nThen(function (waitFor) {
+            // Total size
+            Store.getFileSize(null, {
+                channel: channel
+            }, waitFor(function (obj) {
+                if (obj && obj.error) {
+                    waitFor.abort();
+                    return void cb(obj);
+                }
+                if (typeof(obj.size) === "undefined") {
+                    waitFor.abort();
+                    return void cb({error: 'ENOENT'});
+                }
+                total = obj.size;
+            }));
+            // Pad
+            Store.getHistory(null, {
+                channel: channel,
+                lastKnownHash: lastKnownHash
+            }, waitFor(function (obj) {
+                if (obj && obj.error) {
+                    waitFor.abort();
+                    return void cb(obj);
+                }
+                if (!Array.isArray(obj)) {
+                    waitFor.abort();
+                    return void cb({error: 'EINVAL'});
+                }
+
+                if (!obj.length) { return; }
+
+                hash = obj[0].hash;
+                var messages = obj.map(function(data) {
+                    return data.msg;
+                });
+                history = messages.join('\n').length;
+            }), true);
+            // Metadata
+            Store.getPadMetadata(null, {
+                channel: channel
+            }, waitFor(function (obj) {
+                if (obj && obj.error) { return; }
+                if (!obj || typeof(obj) !== "object") { return; }
+                metadata = JSON.stringify(obj).length;
+                if (!obj || !Array.isArray(obj.owners) ||
+                    obj.owners.indexOf(edPublic) === -1) {
+                    waitFor.abort();
+                    return void cb({error: 'INSUFFICIENT_PERMISSIONS'});
+                }
+            }));
+        }).nThen(function () {
+            cb({
+                size: (total - metadata - history),
+                hash: hash
+            });
+        });
+
+    };
+
+    commands.GET_HISTORY_SIZE = function (ctx, data, cId, cb) {
+        if (!ctx.store.loggedIn || !ctx.store.rpc) { return void cb({ error: 'INSUFFICIENT_PERMISSIONS' }); }
+        var channels = data.channels;
+        if (!Array.isArray(channels)) { return void cb({ error: 'EINVAL' }); }
+
+        var warning = [];
+
+        // If account trim history, get the correct channels here
+        if (data.account) {
+            channels = getAccountChannels(ctx);
+        } else if (data.team) {
+            channels = getTeamChannels(ctx, data.team);
+        }
+
+        var size = 0;
+        var res = [];
+        nThen(function (waitFor) {
+            channels.forEach(function (chan) {
+                var channel = chan;
+                var lastKnownHash;
+                if (typeof (chan) === "object" && chan.channel) {
+                    channel = chan.channel;
+                    lastKnownHash = chan.lastKnownHash;
+                }
+                getHistoryData(ctx, channel, lastKnownHash, data.teamId, waitFor(function (obj) {
+                    if (obj && obj.error) {
+                        warning.push(obj.error);
+                        return;
+                    }
+                    size += obj.size;
+                    if (!obj.hash) { return; }
+                    res.push({
+                        channel: channel,
+                        hash: obj.hash
+                    });
+                }));
+            });
+        }).nThen(function () {
+            cb({
+                warning: warning.length ? warning : undefined,
+                channels: res,
+                size: size
+            });
+        });
+    };
+
+    commands.TRIM_HISTORY = function (ctx, data, cId, cb) {
+        if (!ctx.store.loggedIn || !ctx.store.rpc) { return void cb({ error: 'INSUFFICIENT_PERMISSIONS' }); }
+        var channels = data.channels;
+        if (!Array.isArray(channels)) { return void cb({ error: 'EINVAL' }); }
+
+        var rpc = getRpc(ctx, data.teamId);
+        if (!rpc) { return void cb({ error: 'ENORPC'}); }
+
+        var warning = [];
+
+        nThen(function (waitFor) {
+            channels.forEach(function (obj) {
+                rpc.trimHistory(obj, waitFor(function (err) {
+                    if (err) {
+                        warning.push(err);
+                        return;
+                    }
+                }));
+            });
+        }).nThen(function () {
+            // Only one channel and warning: error
+            if (channels.length === 1 && warning.length) {
+                return void cb({error: warning[0]});
+            }
+            cb({
+                warning: warning.length ? warning : undefined
+            });
+        });
+    };
+
+    History.init = function (cfg, waitFor, emit) {
+        var history = {};
+        if (!cfg.store) { return; }
+        var ctx = {
+            store: cfg.store,
+            Store: cfg.Store,
+            pinPads: cfg.pinPads,
+            updateMetadata: cfg.updateMetadata,
+            emit: emit,
+        };
+
+        history.execCommand = function (clientId, obj, cb) {
+            var cmd = obj.cmd;
+            var data = obj.data;
+            try {
+                commands[cmd](ctx, data, clientId, cb);
+            } catch (e) {
+                console.error(e);
+            }
+        };
+
+        return history;
+    };
+
+    return History;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        undefined,
+        require('../../common/common-util'),
+        require('../../common/common-hash'),
+        require('../../common/user-object'),
+        require('nthen')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/user-object.js',
+        '/components/nthen/index.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+})();
diff --git a/src/worker/modules/integration.js b/src/worker/modules/integration.js
new file mode 100644
index 000000000..a3ee75c72
--- /dev/null
+++ b/src/worker/modules/integration.js
@@ -0,0 +1,219 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Crypto) => {
+    var Integration = {};
+
+    var convertToUint8 = function (obj) {
+        var l = Object.keys(obj).length;
+        var u = new Uint8Array(l);
+        for (var i = 0; i<l; i++) {
+            u[i] = obj[i];
+        }
+        return u;
+    };
+
+    var sendMsg = function (ctx, data, client, cb) {
+        var c = ctx.clients[client];
+        if (!c) { return void cb({error: 'NO_CLIENT'}); }
+        var chan = ctx.channels[c.channel];
+        if (!chan) { return void cb({error: 'NO_CHAN'}); }
+        var obj = {
+            id: client,
+            msg: data.msg,
+            uid: data.uid,
+        };
+        chan.sendMsg(JSON.stringify(obj), cb);
+        ctx.emit('MESSAGE', obj, chan.clients.filter(function (cl) {
+            return cl !== client;
+        }));
+
+    };
+
+    var initIntegration = function (ctx, obj, client, cb) {
+        var channel = obj.channel;
+        var secret = obj.secret;
+        if (secret.keys.cryptKey) {
+            secret.keys.cryptKey = convertToUint8(secret.keys.cryptKey);
+        }
+
+        var padChan = secret.channel;
+        var network = ctx.store.network;
+        var first = true;
+
+        var c = ctx.clients[client];
+        if (!c) {
+            c = ctx.clients[client] = {
+                channel: channel
+            };
+        } else {
+            return void cb();
+        }
+
+        var chan = ctx.channels[channel];
+        if (chan) {
+            // This channel is already open in another tab
+
+            // ==> Set the ID to our client object
+            if (!c.id) { c.id = chan.wc.myID + '-' + client; }
+
+            // ==> And push the new tab to the list
+            chan.clients.push(client);
+
+            return void cb();
+        }
+
+        var onOpen = function (wc) {
+
+            ctx.channels[channel] = ctx.channels[channel] || {};
+
+            var chan = ctx.channels[channel];
+            chan.padChan = padChan;
+
+            if (!c.id) { c.id = wc.myID + '-' + client; }
+            if (chan.clients) {
+                // If 2 tabs from the same worker have been opened at the same time,
+                // we have to fix both of them
+                chan.clients.forEach(function (cl) {
+                    if (ctx.clients[cl] && !ctx.clients[cl].id) {
+                        ctx.clients[cl].id = wc.myID + '-' + cl;
+                    }
+                });
+            }
+
+
+            if (!chan.encryptor) { chan.encryptor = Crypto.createEncryptor(secret.keys); }
+
+            wc.on('message', function (cryptMsg) {
+                var msg = chan.encryptor.decrypt(cryptMsg, secret.keys && secret.keys.validateKey);
+                var parsed;
+                try {
+                    parsed = JSON.parse(msg);
+                    ctx.emit('MESSAGE', parsed, chan.clients);
+                } catch (e) { console.error(e); }
+            });
+
+            chan.wc = wc;
+            chan.sendMsg = function (msg, cb) {
+                cb = cb || function () {};
+                var cmsg = chan.encryptor.encrypt(msg);
+                wc.bcast(cmsg).then(function () {
+                    cb();
+                }, function (err) {
+                    cb({error: err});
+                });
+            };
+
+            if (!first) { return; }
+            chan.clients = [client];
+            first = false;
+            cb();
+        };
+
+        network.join(channel).then(onOpen, function (err) {
+            return void cb({error: err});
+        });
+
+        var onReconnect = function () {
+            if (!ctx.channels[channel]) { console.log("cant reconnect", channel); return; }
+            network.join(channel).then(onOpen, function (err) {
+                console.error(err);
+            });
+        };
+        ctx.channels[channel] = ctx.channels[channel] || {};
+        ctx.channels[channel].onReconnect = onReconnect;
+        network.on('reconnect', onReconnect);
+    };
+
+    var leaveChannel = function (ctx, padChan) {
+        // Leave channel and prevent reconnect when we leave a pad
+        Object.keys(ctx.channels).some(function (cursorChan) {
+            var channel = ctx.channels[cursorChan];
+            if (channel.padChan !== padChan) { return; }
+            if (channel.wc) { channel.wc.leave(); }
+            if (channel.onReconnect) {
+                var network = ctx.store.network;
+                network.off('reconnect', channel.onReconnect);
+            }
+            delete ctx.channels[cursorChan];
+            return true;
+        });
+    };
+    // Remove the client from all its channels when a tab is closed
+    var removeClient = function (ctx, clientId) {
+        var filter = function (c) {
+            return c !== clientId;
+        };
+
+        // Remove the client from our channels
+        var chan;
+        for (var k in ctx.channels) {
+            chan = ctx.channels[k];
+            chan.clients = chan.clients.filter(filter);
+            if (chan.clients.length === 0) {
+                if (chan.wc) { chan.wc.leave(); }
+                if (chan.onReconnect) {
+                    var network = ctx.store.network;
+                    network.off('reconnect', chan.onReconnect);
+                }
+                delete ctx.channels[k];
+            }
+        }
+
+        delete ctx.clients[clientId];
+    };
+
+    Integration.init = function (cfg, waitFor, emit) {
+        var integration = {};
+
+        // Already initialized by a "noDrive" tab?
+        if (cfg.store && cfg.store.modules && cfg.store.modules['integration']) {
+            return cfg.store.modules['integration'];
+        }
+
+        var ctx = {
+            store: cfg.store,
+            emit: emit,
+            channels: {},
+            clients: {}
+        };
+
+        integration.removeClient = function (clientId) {
+            removeClient(ctx, clientId);
+        };
+        integration.leavePad = function (padChan) {
+            leaveChannel(ctx, padChan);
+        };
+        integration.execCommand = function (clientId, obj, cb) {
+            var cmd = obj.cmd;
+            var data = obj.data;
+            if (cmd === 'INIT') {
+                return void initIntegration(ctx, data, clientId, cb);
+            }
+            if (cmd === 'SEND') {
+                return void sendMsg(ctx, data, clientId, cb);
+            }
+        };
+
+        return integration;
+    };
+
+    return Integration;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        require('chainpad-crypto')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/components/chainpad-crypto/crypto.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/modules/mailbox.js b/src/worker/modules/mailbox.js
new file mode 100644
index 000000000..507c6a69c
--- /dev/null
+++ b/src/worker/modules/mailbox.js
@@ -0,0 +1,707 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Config = {}, BCast = {}, Util, Hash,
+    Realtime, Messaging, Notify, Handlers, CpNetflux, Crypto) => {
+    var Mailbox = {};
+
+    Config.setCustomize = data => {
+        Config = data.ApiConfig;
+        BCast = data.Broadcast;
+    };
+
+    var TYPES = [
+        'notifications',
+        'supportteam',
+        'broadcast'
+    ];
+    var BLOCKING_TYPES = [
+    ];
+
+    var BROADCAST_CHAN = '000000000000000000000000000000000'; // Admin channel, 33 characters
+
+    var initializeMailboxes = function (ctx, mailboxes) {
+        if (!mailboxes['notifications'] && ctx.loggedIn) {
+            mailboxes.notifications = {
+                channel: Hash.createChannelId(),
+                lastKnownHash: '',
+                viewed: []
+            };
+            ctx.pinPads([mailboxes.notifications.channel], function (res) {
+                if (res.error) { console.error(res); }
+            });
+        }
+
+        // no need for the "support" mailbox anymore
+        if (mailboxes.support) {
+            delete mailboxes.support;
+        }
+
+        if (!mailboxes['broadcast']) {
+            mailboxes.broadcast = {
+                channel: BROADCAST_CHAN,
+                lastKnownHash: BCast.lastBroadcastHash,
+                decrypted: true,
+                viewed: []
+            };
+        }
+    };
+
+/*
+proxy.mailboxes = {
+    friends: {
+        channel: '',
+        lastKnownHash: '',
+        viewed: []
+    }
+};
+
+*/
+
+    var isMessageNew = function (hash, m) {
+        return (m.viewed || []).indexOf(hash) === -1 && hash !== m.lastKnownHash;
+    };
+
+    var showMessage = function (ctx, type, msg, cId, cb) {
+        ctx.emit('MESSAGE', {
+            type: type,
+            content: msg
+        }, cId ? [cId] : ctx.clients, cb);
+    };
+    var hideMessage = function (ctx, type, hash, clients) {
+        ctx.emit('VIEWED', {
+            type: type,
+            hash: hash
+        }, clients || ctx.clients);
+    };
+
+    var getMyKeys = function (ctx) {
+        var proxy = ctx.store && ctx.store.proxy;
+        if (!proxy.curvePrivate || !proxy.curvePublic) { return; }
+        return {
+            curvePrivate: proxy.curvePrivate,
+            curvePublic: proxy.curvePublic
+        };
+    };
+
+    // Send a message to someone else
+    var sendTo = Mailbox.sendTo = function (ctx, type, msg, user, _cb) {
+        user = user || {};
+        var cb = _cb || function (obj) {
+            if (obj && obj.error) {
+                console.error(obj.error);
+            }
+        };
+
+        if (!Crypto.Mailbox) {
+            return void cb({error: "chainpad-crypto is outdated and doesn't support mailboxes."});
+        }
+
+        var anonRpc = Util.find(ctx, [ 'store', 'anon_rpc', ]);
+        if (!anonRpc) { return void cb({error: "anonymous rpc session not ready"}); }
+
+        // Broadcast mailbox doesn't use encryption. Sending messages there is restricted
+        // to admins in the server directly
+        var crypto = { encrypt: function (x) { return x; } };
+        var channel = BROADCAST_CHAN;
+        var obj = {
+            uid: Util.uid(), // add uid at the beginning to have a unique server hash
+            type: type,
+            content: msg
+        };
+
+        if (!/^BROADCAST/.test(type)) {
+            var keys = getMyKeys(ctx);
+            if (!keys) { return void cb({error: "missing asymmetric encryption keys"}); }
+            if (!user || !user.channel || !user.curvePublic) { return void cb({error: "no notification channel"}); }
+            channel = user.channel;
+            crypto = Crypto.Mailbox.createEncryptor(keys);
+
+            // Always send your data
+            if (typeof(msg) === "object" && !msg.user) {
+                var myData = Messaging.createData(ctx.store.proxy, false);
+                msg.user = myData;
+            }
+            obj = {
+                type: type,
+                content: msg
+            };
+        }
+
+        var text = JSON.stringify(obj);
+        var ciphertext = crypto.encrypt(text, user.curvePublic);
+
+        // If we've sent this message to one of our teams' mailbox, we may want to "dismiss" it
+        // automatically
+        if (user.viewed) {
+            var team = Util.find(ctx, ['store', 'proxy', 'teams', user.viewed]);
+            if (team) {
+                var hash = ciphertext.slice(0,64);
+                var viewed = Util.find(team, ['keys', 'mailbox', 'viewed']);
+                if (Array.isArray(viewed)) { viewed.push(hash); }
+            }
+        }
+
+        anonRpc.send("WRITE_PRIVATE_MESSAGE", [
+            channel,
+            ciphertext
+        ], function (err /*, response */) {
+            if (err) {
+                return void cb({
+                    error: err,
+                });
+            }
+            return void cb({
+                hash: ciphertext.slice(0,64)
+            });
+        });
+    };
+    Mailbox.sendToAnon = function (anonRpc, type, msg, user, cb) {
+        var Nacl = Crypto.Nacl;
+        var curveSeed = Nacl.randomBytes(32);
+        var curvePair = Nacl.box.keyPair.fromSecretKey(new Uint8Array(curveSeed));
+        var curvePrivate = Nacl.util.encodeBase64(curvePair.secretKey);
+        var curvePublic = Nacl.util.encodeBase64(curvePair.publicKey);
+        sendTo({
+            store: {
+                anon_rpc: anonRpc,
+                proxy: {
+                    curvePrivate: curvePrivate,
+                    curvePublic: curvePublic
+                }
+            }
+        }, type, msg, user, cb);
+    };
+
+    // Mark a message as read
+    var dismiss = function (ctx, data, cId, cb) {
+        var type = data.type;
+        var hash = data.hash;
+
+        // Reminder messages don't persist
+        if (/^REMINDER\|/.test(hash)) {
+            cb();
+            delete ctx.boxes.reminders.content[hash];
+            hideMessage(ctx, type, hash, ctx.clients.filter(function (clientId) {
+                return clientId !== cId;
+            }));
+
+            var uid = hash.slice(9).split('-')[0];
+            var d = Util.find(ctx, ['store', 'proxy', 'hideReminders', uid]);
+            if (!d) {
+                var h = ctx.store.proxy.hideReminders = ctx.store.proxy.hideReminders || {};
+                d = h[uid] = h[uid] || [];
+            }
+            var delay = hash.split('-')[1];
+            if (delay && !d.includes(delay)) { d.push(Number(delay)); }
+            return;
+        }
+
+
+        var box = ctx.boxes[type];
+        if (!box) { return void cb({error: 'NOT_LOADED'}); }
+        var m = box.data || {};
+
+        // If the hash in in our history, get the index from the history:
+        // - if the index is 0, we can change our lastKnownHash
+        // - otherwise, just push to view
+        var idx = box.history.indexOf(hash);
+        if (idx !== -1) {
+            if (idx === 0) {
+                m.lastKnownHash = hash;
+                box.history.shift();
+            } else if (m.viewed.indexOf(hash) === -1) {
+                m.viewed.push(hash);
+            }
+        }
+
+        // Clear data in memory if needed
+        // Check the "viewed" array to see if we're able to bump lastKnownhash more
+        var sliceIdx;
+        var lastKnownHash;
+        var toForget = [];
+        box.history.some(function (hash, i) {
+            // naming here is confusing... isViewed implies it's a boolean
+            // when in fact it's an index
+            var isViewed = m.viewed.indexOf(hash);
+
+            // iterate over your history until you hit an element you haven't viewed
+            if (isViewed === -1) { return true; }
+            // update the index that you'll use to slice off viewed parts of history
+            sliceIdx = i + 1;
+            // keep track of which hashes you should remove from your 'viewed' array
+            toForget.push(hash);
+            // prevent fetching dismissed messages on (re)connect
+            lastKnownHash = hash;
+        });
+
+        // remove all elements in 'toForget' from the 'viewed' array in one step
+        m.viewed = m.viewed.filter(function (hash) {
+            return toForget.indexOf(hash) === -1;
+        });
+
+        if (sliceIdx) {
+            box.history = box.history.slice(sliceIdx);
+            m.lastKnownHash = lastKnownHash;
+        }
+
+        // Make sure we remove data about dismissed messages
+        Object.keys(box.content).forEach(function (h) {
+            if (box.history.indexOf(h) === -1 || m.viewed.indexOf(h) !== -1) {
+                Handlers.remove(ctx, box, box.content[h], h);
+                delete box.content[h];
+            }
+        });
+
+        Realtime.whenRealtimeSyncs(ctx.store.realtime, function () {
+            cb();
+            hideMessage(ctx, type, hash, ctx.clients.filter(function (clientId) {
+                return clientId !== cId;
+            }));
+        });
+    };
+
+
+    var leaveChannel = function (ctx, type, cb) {
+        cb = cb || function () {};
+        var box = ctx.boxes[type];
+        if (!box) { return void cb(); }
+        if (!box.cpNf || typeof(box.cpNf.stop) !== "function") { return void cb('EINVAL'); }
+        box.cpNf.stop();
+        Object.keys(box.content).forEach(function (h) {
+            Handlers.remove(ctx, box, box.content[h], h);
+            hideMessage(ctx, type, h, ctx.clients);
+        });
+        delete ctx.boxes[type];
+    };
+    var openChannel = function (ctx, type, m, onReady, opts) {
+        opts = opts || {};
+        var box = ctx.boxes[type] = {
+            channel: m.channel,
+            type: type,
+            queue: [], // Store the messages to send when the channel is ready
+            history: [], // All the hashes loaded from the server in corretc order
+            content: {}, // Content of the messages that should be displayed
+            sendMessage: function (msg) { // To send a message to our box
+                // Always send your data
+                if (typeof(msg) === "object" && !msg.user) {
+                    var myData = Messaging.createData(ctx.store.proxy, false);
+                    msg.user = myData;
+                }
+                try {
+                    msg = JSON.stringify(msg);
+                } catch (e) {
+                    console.error(e);
+                }
+                box.queue.push(msg);
+            },
+            data: m
+        };
+        if (!Crypto.Mailbox) {
+            return void console.error("chainpad-crypto is outdated and doesn't support mailboxes.");
+        }
+        var keys = m.keys || getMyKeys(ctx);
+        if (!keys && !m.decrypted) { return void console.error("missing asymmetric encryption keys"); }
+        var crypto = m.decrypted ? {
+            encrypt: function (x) { return x; },
+            decrypt: function (x) { return x; }
+        } : Crypto.Mailbox.createEncryptor(keys);
+        box.encryptor = crypto;
+        var cfg = {
+            network: ctx.store.network,
+            channel: m.channel,
+            noChainPad: true,
+            crypto: crypto,
+            owners: type === 'broadcast' ? [] : (opts.owners || [ctx.store.proxy.edPublic]),
+            lastKnownHash: m.lastKnownHash
+        };
+        cfg.onConnectionChange = function () {}; // Allow reconnections in chainpad-netflux
+        cfg.onConnect = function (wc, sendMessage) {
+            // Send a message to our box?
+            // NOTE: we use our own curvePublic so that we can decrypt our own message :)
+            box.sendMessage = function (_msg, cb) {
+                cb = cb || function () {};
+                var msg;
+                try {
+                    msg = JSON.stringify(_msg);
+                } catch (e) {
+                    console.error(e);
+                }
+                sendMessage(msg, function (err, hash) {
+                    if (err) { return void console.error(err); }
+                    box.history.push(hash);
+                    _msg.ctime = +new Date();
+                    box.content[hash] = _msg;
+                    var message = {
+                        msg: _msg,
+                        hash: hash
+                    };
+                    showMessage(ctx, type, message);
+                    cb(hash);
+                }, keys.curvePublic);
+            };
+            box.queue.forEach(function (msg) {
+                box.sendMessage(msg);
+            });
+            box.queue = [];
+        };
+        var lastReceivedHash; // Don't send a duplicate of the last known hash on reconnect
+        box.onMessage = cfg.onMessage = function (msg, user, vKey, isCp, hash, author, data) {
+            if (hash === m.lastKnownHash) { return; }
+            if (hash === lastReceivedHash) { return; }
+            var time = data && data.time;
+            lastReceivedHash = hash;
+            try {
+                msg = JSON.parse(msg);
+            } catch (e) {
+                console.error(e);
+            }
+            if (author) { msg.author = author; }
+            box.history.push(hash);
+            if (isMessageNew(hash, m)) {
+                // Message should be displayed
+                var message = {
+                    msg: msg,
+                    hash: hash,
+                    time: time
+                };
+                var notify = box.ready;
+                Handlers.add(ctx, box, message, function (dismissed, toDismiss, invalid) {
+                    if (toDismiss) { // List of other messages to remove
+                        dismiss(ctx, toDismiss, '', function () {
+                            console.log('Notification handled automatically');
+                        });
+                    }
+                    if (invalid || dismissed) { // This message should be removed
+                        dismiss(ctx, {
+                            type: type,
+                            hash: hash
+                        }, '', function () {
+                            console.log('Notification handled automatically');
+                        });
+                        return;
+                    }
+                    msg.ctime = time || 0;
+                    box.content[hash] = msg;
+                    if (opts.dump) { return; }
+                    showMessage(ctx, type, message, null, function (obj) {
+                        if (!obj || !obj.msg || !notify) { return; }
+                        Notify.system(undefined, obj.msg);
+                    });
+                });
+            } else {
+                // Message has already been viewed by the user
+                if (Object.keys(box.content).length === 0) {
+                    // If nothing is displayed yet, we can bump our lastKnownHash and remove this hash
+                    // from our "viewed" array
+                    m.lastKnownHash = hash;
+                    box.history = [];
+                    var idxViewed = m.viewed.indexOf(hash);
+                    if (idxViewed !== -1) { m.viewed.splice(idxViewed, 1); }
+                }
+            }
+        };
+        cfg.onReady = function () {
+            // Clean the "viewed" array: make sure all the "viewed" hashes are
+            // in history
+            var toClean = [];
+            m.viewed.forEach(function (h, i) {
+                if (box.history.indexOf(h) === -1) {
+                    toClean.push(i);
+                }
+            });
+            for (var i = toClean.length-1; i>=0; i--) {
+                m.viewed.splice(toClean[i], 1);
+            }
+            // Listen for changes in the "viewed" and lastKnownHash values
+            var view = function (h) {
+                Handlers.remove(ctx, box, box.content[h], h);
+                delete box.content[h];
+                hideMessage(ctx, type, h);
+            };
+            ctx.store.proxy.on('change', ['mailboxes', type], function (o, n, p) {
+                if (p[2] === 'lastKnownHash') {
+                    // Hide everything up to this hash
+                    var sliceIdx;
+                    box.history.some(function (h, i) {
+                        sliceIdx = i + 1;
+                        view(h);
+                        if (h === n) { return true; }
+                    });
+                    box.history = box.history.slice(sliceIdx);
+                }
+                if (p[2] === 'viewed') {
+                    // Hide this message
+                    view(n);
+                }
+            });
+            box.ready = true;
+            // Continue
+            onReady(box.content);
+        };
+        box.cpNf = CpNetflux.start(cfg);
+    };
+
+    var initializeHistory = function (ctx) {
+        var network = ctx.store.network;
+        network.on('message', function (msg, sender) {
+            if (sender !== network.historyKeeper) { return; }
+            var parsed = JSON.parse(msg);
+            if (!/HISTORY_RANGE/.test(parsed[0])) { return; }
+
+            var txid = parsed[1];
+            var req = ctx.req[txid];
+            if (!req) { return; }
+            var type = parsed[0];
+            var _msg = parsed[2];
+            var box = req.box;
+
+            if (type === 'HISTORY_RANGE') {
+                if (!Array.isArray(_msg)) { return; }
+                var message;
+                if (req.box.type === 'broadcast') {
+                    message = Util.tryParse(_msg[4]);
+                } else {
+                    try {
+                        var decrypted = box.encryptor.decrypt(_msg[4]);
+                        message = JSON.parse(decrypted.content);
+                        message.author = decrypted.author;
+                    } catch (e) {
+                        console.log(e);
+                    }
+                }
+                var hash = _msg[4].slice(0,64);
+                ctx.emit('HISTORY', {
+                    txid: txid,
+                    time: _msg[5],
+                    message: message,
+                    hash: hash
+                }, [req.cId]);
+            } else if (type === 'HISTORY_RANGE_END') {
+                ctx.emit('HISTORY', {
+                    txid: txid,
+                    complete: true
+                }, [req.cId]);
+                delete ctx.req[txid];
+            }
+        });
+    };
+    var loadHistory = function (ctx, clientId, data, cb) {
+        var box = ctx.boxes[data.type];
+        if (!box) { return void cb({error: 'ENOENT'}); }
+        var msg = [ 'GET_HISTORY_RANGE', box.channel, {
+                from: data.lastKnownHash,
+                count: data.count,
+                txid: data.txid
+            }
+        ];
+        if (data.type === 'broadcast') {
+            msg = [ 'GET_HISTORY_RANGE', box.channel, {
+                    to: data.lastKnownHash,
+                    txid: data.txid
+                }
+            ];
+        }
+        ctx.req[data.txid] = {
+            cId: clientId,
+            box: box
+        };
+        var network = ctx.store.network;
+        network.sendto(network.historyKeeper, JSON.stringify(msg)).then(function () {
+        }, function (err) {
+            console.error(err);
+        });
+    };
+
+    var subscribe = function (ctx, data, cId, cb) {
+        // Get existing notifications
+        Object.keys(ctx.boxes).forEach(function (type) {
+            Object.keys(ctx.boxes[type].content).forEach(function (h) {
+                var message = {
+                    msg: ctx.boxes[type].content[h],
+                    hash: h
+                };
+                showMessage(ctx, type, message, cId, function (obj) {
+                    if (obj.error) { return; }
+                    // Notify only if "requiresNotif" is true
+                    if (!message.msg || !message.msg.requiresNotif) { return; }
+                    Notify.system(undefined, obj.msg);
+                    delete message.msg.requiresNotif;
+                });
+            });
+        });
+        // Subscribe to new notifications
+        var idx = ctx.clients.indexOf(cId);
+        if (idx === -1) {
+            ctx.clients.push(cId);
+        }
+        cb();
+    };
+
+    var removeClient = function (ctx, cId) {
+        var idx = ctx.clients.indexOf(cId);
+        ctx.clients.splice(idx, 1);
+    };
+
+    Mailbox.init = function (cfg, waitFor, emit) {
+        var mailbox = {};
+        var store = cfg.store;
+        var mailboxes = store.proxy.mailboxes = store.proxy.mailboxes || {};
+
+        var ctx = {
+            Store: cfg.Store,
+            store: store,
+            pinPads: cfg.pinPads,
+            updateMetadata: cfg.updateMetadata,
+            updateDrive: cfg.updateDrive,
+            mailboxes: mailboxes,
+            emit: emit,
+            clients: [],
+            boxes: {},
+            req: {},
+            loggedIn: store.loggedIn && store.proxy.edPublic
+        };
+
+        initializeMailboxes(ctx, mailboxes);
+        if (ctx.loggedIn) {
+            initializeHistory(ctx);
+        }
+
+        ctx.boxes.reminders = {
+            content: {}
+        };
+
+        Object.keys(mailboxes).forEach(function (key) {
+            if (TYPES.indexOf(key) === -1) { return; }
+            var m = mailboxes[key];
+
+            if (BLOCKING_TYPES.indexOf(key) === -1) {
+                openChannel(ctx, key, m, function () {
+                    //console.log(key + ' mailbox is ready');
+                });
+            } else {
+                openChannel(ctx, key, m, waitFor(function () {
+                    //console.log(key + ' mailbox is ready');
+                }));
+            }
+        });
+
+        if (ctx.loggedIn) {
+            Object.keys(store.proxy.teams || {}).forEach(function (teamId) {
+                var team = store.proxy.teams[teamId];
+                if (!team) { return; }
+                var teamMailbox = team.keys.mailbox || {};
+                if (!teamMailbox.channel) { return; }
+                var opts = {
+                    owners: [Util.find(team, ['keys', 'drive', 'edPublic'])]
+                };
+                openChannel(ctx, 'team-'+teamId, teamMailbox, function () {
+                    //console.log('Mailbox team', teamId);
+                }, opts);
+            });
+        }
+
+        mailbox.post = function (box, type, content) {
+            var b = ctx.boxes[box];
+            if (!b) { return; }
+            b.sendMessage({
+                type: type,
+                content: content,
+                sender: store.proxy.curvePublic
+            });
+        };
+
+        mailbox.hideMessage = function (type, msg) {
+            hideMessage(ctx, type, msg.hash, ctx.clients);
+        };
+        mailbox.showMessage = function (type, msg, cId, cb) {
+            if (type === "reminders" && msg) {
+                ctx.boxes.reminders.content[msg.hash] = msg.msg;
+                if (!ctx.clients.length) {
+                    ctx.boxes.reminders.content[msg.hash].requiresNotif = true;
+                }
+                // Hide existing messages for this event
+                hideMessage(ctx, type, msg.hash, ctx.clients);
+            }
+            showMessage(ctx, type, msg, cId, function (obj) {
+                Notify.system(undefined, obj.msg);
+                if (cb) { cb(); }
+            });
+        };
+
+        mailbox.open = function (key, m, cb, team, opts) {
+            if (TYPES.indexOf(key) === -1 && !team) { return; }
+            openChannel(ctx, key, m, cb, opts);
+        };
+        mailbox.close = function (key, cb) {
+            leaveChannel(ctx, key, cb);
+        };
+
+        mailbox.dismiss = function (data, cb) {
+            dismiss(ctx, data, '', cb);
+        };
+
+        mailbox.sendTo = function (type, msg, user, cb) {
+            if (!ctx.loggedIn) { return void cb({error:'NOT_LOGGED_IN'}); }
+            sendTo(ctx, type, msg, user, cb);
+        };
+
+        mailbox.removeClient = function (clientId) {
+            removeClient(ctx, clientId);
+        };
+        mailbox.execCommand = function (clientId, obj, cb) {
+            var cmd = obj.cmd;
+            var data = obj.data;
+            if (cmd === 'SUBSCRIBE') {
+                return void subscribe(ctx, data, clientId, cb);
+            }
+            if (cmd === 'DISMISS') {
+                return void dismiss(ctx, data, clientId, cb);
+            }
+            if (cmd === 'SENDTO') {
+                return void sendTo(ctx, data.type, data.msg, data.user, cb);
+            }
+            if (cmd === 'LOAD_HISTORY') {
+                return void loadHistory(ctx, clientId, data, cb);
+            }
+        };
+
+        return mailbox;
+    };
+
+    return Mailbox;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory(
+        undefined,
+        undefined,
+        require('../../common/common-util'),
+        require('../../common/common-hash'),
+        require('../../common/common-realtime'),
+        require('../../common/common-messaging'),
+        require('../../common/notify'),
+        require('../components/mailbox-handlers'),
+        require('chainpad-netflux'),
+        require('chainpad-crypto')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/api/config',
+        '/api/broadcast',
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/common-realtime.js',
+        '/common/common-messaging.js',
+        '/common/notify.js',
+        '/common/outer/mailbox-handlers.js',
+        'chainpad-netflux',
+        '/components/chainpad-crypto/crypto.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/modules/messenger.js b/src/worker/modules/messenger.js
new file mode 100644
index 000000000..74b454186
--- /dev/null
+++ b/src/worker/modules/messenger.js
@@ -0,0 +1,1146 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Crypto, Hash, Util, Realtime, Messaging,
+                Constants, Messages = {}, PadTypes, nThen) => {
+    var Curve = Crypto.Curve;
+
+    var Msg = {};
+
+    Msg.setCustomize = data => {
+        Messages = data.Messages;
+    };
+
+    var Types = {
+        message: 'MSG',
+        unfriend: 'UNFRIEND',
+        mapId: 'MAP_ID',
+        mapIdAck: 'MAP_ID_ACK'
+    };
+
+    var clone = function (o) {
+        return JSON.parse(JSON.stringify(o));
+    };
+
+    var convertToUint8 = function (obj) {
+        var l = Object.keys(obj).length;
+        var u = new Uint8Array(l);
+        for (var i = 0; i<l; i++) {
+            u[i] = obj[i];
+        }
+        return u;
+    };
+
+    var createData = Messaging.createData;
+
+    var getFriend = function (proxy, pubkey) {
+        if (pubkey === proxy.curvePublic) {
+            var data = createData(proxy);
+            delete data.channel;
+            return data;
+        }
+        return proxy.friends ? proxy.friends[pubkey] : undefined;
+    };
+
+    var getFriendList = Msg.getFriendList = function (proxy) {
+        if (!proxy.friends) { proxy.friends = {}; }
+        return proxy.friends;
+    };
+
+    var msgAlreadyKnown = function (channel, sig) {
+        return channel.messages.some(function (message) {
+            return message.sig === sig;
+        });
+    };
+
+    var getFriendFromChannel = function (ctx, id) {
+        var proxy = ctx.store.proxy;
+        var friends = getFriendList(proxy);
+        var friend;
+        for (var k in friends) {
+            if (friends[k].channel === id) {
+                friend = friends[k];
+                break;
+            }
+        }
+        return friend;
+    };
+
+    var initRangeRequest = function (ctx, txid, chanId, cb) {
+        if (!ctx.range_requests) { ctx.range_requests = {}; }
+        ctx.range_requests[txid] = {
+            messages: [],
+            cb: cb,
+            chanId: chanId,
+        };
+    };
+    var getRangeRequest = function (ctx, txid) {
+        return ctx.range_requests[txid];
+    };
+    var deleteRangeRequest = function (ctx, txid) {
+        delete ctx.range_requests[txid];
+    };
+
+    // History
+    var getMoreHistory = function (ctx, chanId, hash, count, cb) {
+        if (typeof(cb) !== 'function') { return; }
+
+        if (typeof(hash) !== 'string') {
+            // Channel is empty!
+            return void cb([]);
+        }
+
+        var chan = ctx.channels[chanId];
+        if (typeof(chan) === 'undefined') {
+            console.error("chan is undefined. we're going to have a problem here");
+            return;
+        }
+
+        var txid = Util.uid();
+        initRangeRequest(ctx, txid, chanId, cb);
+        var msg = [ 'GET_HISTORY_RANGE', chan.id, {
+                from: hash,
+                count: count,
+                txid: txid,
+            }
+        ];
+
+        var network = ctx.store.network;
+        network.sendto(network.historyKeeper, JSON.stringify(msg)).then(function () {
+        }, function (err) {
+            console.error(err);
+        });
+    };
+
+    var getChannelMessagesSince = function (ctx, channel, data, keys) {
+        var network = ctx.store.network;
+        console.log('Fetching [%s] messages since [%s]', channel.id, data.lastKnownHash || '');
+
+        if (channel.isPadChat || channel.isTeamChat) {
+            // We need to use GET_HISTORY_RANGE to make sure we won't get the full history
+            var txid = Util.uid();
+            initRangeRequest(ctx, txid, channel.id, undefined);
+            var msg0 = ['GET_HISTORY_RANGE', channel.id, {
+                    //from: hash,
+                    count: 10,
+                    txid: txid,
+                }
+            ];
+            network.sendto(network.historyKeeper, JSON.stringify(msg0)).then(function () {
+            }, function (err) {
+                console.error(err);
+            });
+            return;
+        }
+
+        // Friend chat, intial history
+        var proxy = ctx.store.proxy;
+        var friend = getFriendFromChannel(ctx, channel.id) || {};
+        var cfg = {
+            metadata: {
+                validateKey: keys ? keys.validateKey : undefined,
+                owners: [proxy.edPublic, friend.edPublic],
+            },
+            lastKnownHash: data.lastKnownHash
+        };
+        var msg = ['GET_HISTORY', channel.id, cfg];
+        network.sendto(network.historyKeeper, JSON.stringify(msg))
+          .then(function () {}, function (err) {
+            console.error(err);
+        });
+    };
+
+
+    var setChannelHead = function (ctx, id, hash, cb) {
+        var channel = ctx.channels[id];
+        if (channel.isFriendChat) {
+            var friend = getFriendFromChannel(ctx, id);
+            if (!friend) { return void cb({error: 'NO_SUCH_FRIEND'}); }
+            friend.lastKnownHash = hash;
+        } else if (channel.isPadChat) {
+            // Nothing to do
+        } else if (channel.isTeamChat) {
+            // Nothing to do
+        } else {
+            // TODO room
+            return void cb({error: 'NOT_IMPLEMENTED'});
+        }
+        cb();
+    };
+
+    var onChannelReady = function (ctx, chanId) {
+        var channel = ctx.channels[chanId];
+        if (!channel) { return; }
+        channel.ready = true;
+        channel.onReady.fire();
+    };
+
+    // Id message allows us to map a netfluxId with a public curve key
+    var onIdMessage = function (ctx, msg, sender) {
+        // Parse the history message and make sure it is related to an existing channel
+        var channel, parsed0;
+        try {
+            parsed0 = JSON.parse(msg);
+            channel = ctx.channels[parsed0.channel];
+            if (!channel || channel.wc.members.indexOf(sender) === -1) { return; }
+        } catch (e) {
+            return void console.error(e, msg);
+        }
+
+        // Decrypt and parse its content...
+        var decryptedMsg = channel.decrypt(parsed0.msg);
+        if (!decryptedMsg) { return void console.error("Failed to decrypt message"); }
+        var parsed = Util.tryParse(decryptedMsg);
+        if (!parsed) { return void console.error(decryptedMsg); }
+
+        // Keep only ID messages here
+        if (parsed[0] !== Types.mapId && parsed[0] !== Types.mapIdAck) { return; }
+
+        // check that the responding peer's encrypted netflux id matches
+        // the sender field. This is to prevent replay attacks.
+        if (parsed[2] !== sender || !parsed[1]) { return; }
+        channel.mapId[sender] = parsed[1];
+        ctx.emit('JOIN', {
+            info: parsed[1],
+            id: channel.id
+        }, channel.clients);
+
+        if (channel.readOnly) { return; } // Don't send your key if you're a reader
+        if (parsed[0] !== Types.mapId) { return; } // Don't send your key if it's already an ACK
+
+        // Answer with your own key
+        var proxy = ctx.store.proxy || {};
+        var myData = createData(proxy);
+        delete myData.channel;
+        var rMsg = [Types.mapIdAck, myData, channel.wc.myID];
+        var rMsgStr = JSON.stringify(rMsg);
+        var cryptMsg = channel.encrypt(rMsgStr);
+        var data = {
+            channel: channel.id,
+            msg: cryptMsg
+        };
+        var network = ctx.store.network;
+        network.sendto(sender, JSON.stringify(data));
+    };
+
+    var orderMessages = function (channel, new_messages) {
+        var messages = channel.messages;
+        // TODO improve performance, guarantee correct ordering
+        new_messages.reverse().forEach(function (msg) {
+            messages.unshift(msg);
+        });
+    };
+
+    var removeFromFriendList = function (ctx, curvePublic, cb) {
+        var proxy = ctx.store.proxy;
+        var friends = proxy.friends;
+        // FIXME this probably shouldn't happen, but functions that take callbacks
+        // should be guaranteed to call back.
+        if (!friends) { return; }
+        delete friends[curvePublic];
+        Realtime.whenRealtimeSyncs(ctx.store.realtime, function () {
+            ctx.updateMetadata();
+            cb();
+        });
+    };
+
+    var pushMsg = function (ctx, channel, cryptMsg) {
+        var sig = cryptMsg.slice(0, 64);
+        if (msgAlreadyKnown(channel, sig)) { return; }
+        var msg = channel.decrypt(cryptMsg);
+
+        var parsedMsg = JSON.parse(msg);
+        var curvePublic;
+        // Chat message
+        if (parsedMsg[0] === Types.message) {
+            var res = {
+                type: parsedMsg[0],
+                sig: sig,
+                author: parsedMsg[1],
+                time: parsedMsg[2],
+                text: parsedMsg[3],
+                channel: channel.id,
+                name: parsedMsg[4] // Display name for multi-user rooms
+            };
+
+            channel.messages.push(res);
+            if (channel.ready) { ctx.emit('MESSAGE', res, channel.clients); }
+
+            return true;
+        }
+        var proxy = ctx.store.proxy;
+        if (parsedMsg[0] === Types.unfriend) {
+            curvePublic = parsedMsg[1];
+
+            // If this a removal from our part in another tab, do nothing.
+            // The channel is already closed in the proxy.on('remove') part
+            if (curvePublic === proxy.curvePublic) { return; }
+
+            removeFromFriendList(ctx, curvePublic, function () {
+                channel.wc.leave(Types.unfriend);
+                var network = ctx.store.network;
+                if (channel.onReconnect) { network.off('reconnect', channel.onReconnect); }
+                delete ctx.channels[channel.id];
+                ctx.emit('UNFRIEND', {
+                    curvePublic: curvePublic,
+                    fromMe: false
+                }, channel.clients);
+            });
+            return;
+        }
+    };
+
+    var onDirectMessage = function (ctx, msg, sender) {
+        var hk = ctx.store.network.historyKeeper;
+        if (sender !== hk) { return void onIdMessage(ctx, msg, sender); }
+        var parsed = JSON.parse(msg);
+
+        if ((parsed.validateKey || parsed.owners) && parsed.channel) {
+            // Metadata message
+            return;
+        }
+
+        var channel;
+
+        if (/HISTORY_RANGE/.test(parsed[0])) {
+            var txid = parsed[1];
+            var req = getRangeRequest(ctx, txid);
+            var type = parsed[0];
+            if (!req) { return; }
+            channel = ctx.channels[req.chanId];
+            if (!channel) { return; }
+
+            if (!req.cb) { // This is the initial history for a pad chat
+                if (type === 'HISTORY_RANGE') {
+                    if (!Array.isArray(parsed[2])) { return; }
+                    pushMsg(ctx, channel, parsed[2][4]);
+                } else if (type === 'HISTORY_RANGE_END') {
+                    onChannelReady(ctx, req.chanId);
+                    return deleteRangeRequest(ctx, txid);
+                }
+                return;
+            }
+
+            // "More history": we need to store all the messages and cb all of them at once
+            // to make sure we won't display them in the wrong order (we receive the oldest first...)
+            if (type === 'HISTORY_RANGE') {
+                req.messages.push(parsed[2]);
+            } else if (type === 'HISTORY_RANGE_END') {
+                // process all the messages (decrypt)
+                var decrypted = req.messages.map(function (msg) {
+                    if (msg[2] !== 'MSG') { return; }
+                    try {
+                        return {
+                            d: JSON.parse(channel.decrypt(msg[4])),
+                            sig: msg[4].slice(0, 64),
+                        };
+                    } catch (e) {
+                        return void console.log('failed to decrypt');
+                    }
+                }).filter(function (decrypted) {
+                    if (!decrypted || !decrypted.d || decrypted.d[0] !== Types.message) { return; }
+                    if (msgAlreadyKnown(channel, decrypted.sig)) { return; }
+                    return decrypted;
+                }).map(function (O) {
+                    return {
+                        type: O.d[0],
+                        sig: O.sig,
+                        author: O.d[1],
+                        time: O.d[2],
+                        text: O.d[3],
+                        channel: req.chanId,
+                        name: O.d[4]
+                    };
+                });
+
+                orderMessages(channel, decrypted);
+                req.cb(decrypted);
+                return deleteRangeRequest(ctx, txid);
+            } else {
+                console.log(parsed);
+            }
+            return;
+        }
+
+        if (parsed.channel && ctx.channels[parsed.channel]) {
+            channel = ctx.channels[parsed.channel];
+            // Error in initial history
+            // History cleared while we're in the channel
+            if (parsed.error === 'ECLEARED') {
+                setChannelHead(ctx, parsed.channel, '', function () {});
+                channel.messages = [];
+                ctx.emit('CLEAR_CHANNEL', parsed.channel, channel.clients);
+                return;
+            }
+            // History cleared while we were offline
+            // ==> we asked for an invalid last known hash
+            if (parsed.error && parsed.error === "EINVAL") {
+                setChannelHead(ctx, parsed.channel, '', function () {
+                    getChannelMessagesSince(ctx, channel, {}, {});
+                });
+                return;
+            }
+
+            // End of initial history
+            if (parsed.state && parsed.state === 1 && parsed.channel) {
+                return void onChannelReady(ctx, parsed.channel);
+            }
+        }
+
+        // Initial history message
+        channel = ctx.channels[parsed[3]];
+        if (!channel) { return; }
+        pushMsg(ctx, channel, parsed[4]);
+    };
+
+    var onMessage = function (ctx, msg, sender, chan) {
+        var channel = ctx.channels[chan.id];
+        if (!channel) { return; }
+        pushMsg(ctx, channel, msg);
+    };
+
+    var onFriendRemoved = function (ctx, curvePublic, chanId) {
+        var channel = ctx.channels[chanId];
+        if (!channel) { return; }
+        if (channel.wc) {
+            channel.wc.leave(Types.unfriend);
+        }
+        var network = ctx.store.network;
+        if (channel.onReconnect) { network.off('reconnect', channel.onReconnect); }
+        delete ctx.channels[channel.id];
+        ctx.emit('UNFRIEND', {
+            curvePublic: curvePublic,
+            fromMe: true
+        }, ctx.friendsClients);
+    };
+    var removeFriend = function (ctx, curvePublic, _cb) {
+        var cb = Util.once(_cb);
+        if (typeof(cb) !== 'function') { return void console.error('NO_CALLBACK'); }
+        var proxy = ctx.store.proxy;
+        var data = getFriend(proxy, curvePublic);
+
+        if (!data) {
+            // friend is not valid
+            console.error('friend is not valid');
+            return void cb({error: 'INVALID_FRIEND'});
+        }
+
+        var channel = ctx.channels[data.channel];
+
+        // Unfriend with mailbox
+        if (ctx.store.mailbox && data.curvePublic && data.notifications) {
+            Messaging.removeFriend(ctx.store, curvePublic, function (obj) {
+                if (obj && obj.error) { return void cb({error:obj.error}); }
+                ctx.updateMetadata();
+                cb(obj);
+            });
+            return;
+        }
+
+        // Unfriend with channel
+        if (!channel) {
+            return void cb({error: "NO_SUCH_CHANNEL"});
+        }
+        try {
+            var msg = [Types.unfriend, proxy.curvePublic, +new Date()];
+            var msgStr = JSON.stringify(msg);
+            var cryptMsg = channel.encrypt(msgStr);
+            channel.wc.bcast(cryptMsg).then(function () {
+                onFriendRemoved(ctx, curvePublic, data.channel);
+                removeFromFriendList(ctx, curvePublic, function () {
+                    cb();
+                });
+            }, function (err) {
+                if (err) { return void cb({error:err}); }
+                onFriendRemoved(ctx, curvePublic, data.channel);
+                removeFromFriendList(ctx, curvePublic, function () {
+                    cb();
+                });
+            });
+        } catch (e) {
+            cb({error: e});
+        }
+    };
+
+    // Cancel pending friend requests
+    var cancelFriend = function (ctx, data, _cb) {
+        var cb = Util.once(_cb);
+        if (typeof(cb) !== 'function') { return void console.error('NO_CALLBACK'); }
+        ctx.Store.cancelFriendRequest(data, cb);
+    };
+
+    var getAllClients = function (ctx) {
+        var all = [];
+        Array.prototype.push.apply(all, ctx.friendsClients);
+        Object.keys(ctx.channels).forEach(function (id) {
+            Array.prototype.push.apply(all, ctx.channels[id].clients);
+        });
+        return Util.deduplicateString(all);
+    };
+
+    var muteUser = function (ctx, data, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var proxy = ctx.store.proxy;
+        var muted = proxy.mutedUsers = proxy.mutedUsers || {};
+        if (muted[data.curvePublic]) { return void cb(); }
+        muted[data.curvePublic] = data;
+        ctx.emit('UPDATE_MUTED', null, getAllClients(ctx));
+        cb();
+    };
+    var unmuteUser = function (ctx, curvePublic, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var proxy = ctx.store.proxy;
+        var muted = proxy.mutedUsers = proxy.mutedUsers || {};
+        delete muted[curvePublic];
+        ctx.emit('UPDATE_MUTED', null, getAllClients(ctx));
+        cb(Object.keys(muted).length);
+    };
+    var getMutedUsers = function (ctx, cb) {
+        var proxy = ctx.store.proxy;
+        if (cb) {
+            return void cb(proxy.mutedUsers || {});
+        }
+        return proxy.mutedUsers || {};
+    };
+
+    var openChannel = function (ctx, data) {
+        var proxy = ctx.store.proxy;
+        var network = ctx.store.network;
+        var hk = network.historyKeeper;
+
+        var keys = data.keys;
+        var encryptor = data.encryptor || Curve.createEncryptor(keys);
+        var channel = {
+            id: data.channel,
+            isFriendChat: data.isFriendChat,
+            isPadChat: data.isPadChat,
+            isTeamChat: data.isTeamChat,
+            padChan: data.padChan, // Channel ID of the pad linked to this pad chat
+            readOnly: data.readOnly,
+            ready: false,
+            onReady: Util.mkEvent(true),
+            sending: false,
+            messages: [],
+            clients: data.clients || [],
+            onUserlistUpdate: data.onUserlistUpdate || function () {},
+            mapId: {},
+        };
+
+        if (data.onReady) { channel.onReady.reg(data.onReady); }
+
+        channel.encrypt = function (msg) {
+            if (channel.readOnly) { return; }
+            return encryptor.encrypt(msg);
+        };
+        channel.decrypt = data.decrypt || function (msg) {
+            return encryptor.decrypt(msg);
+        };
+
+        var onJoining = function (peer) {
+            if (peer === hk) { return; }
+            if (channel.readOnly) { return; }
+
+            // Sending myData is used to build a "mapId" object which links
+            // netflux IDs to a curvePublic/uid. We use this map in friend chat
+            // to detect if the other user is online and we also use it in team chat
+            // to show if other team members are online (in the roster section).
+            // It is not needed in the pad chat for now and only causes useless
+            // network usage.
+            if (channel.isPadChat) { return; }
+
+            // Join event will be sent once we are able to ID this peer
+            var myData = createData(proxy);
+            delete myData.channel;
+            var msg = [Types.mapId, myData, channel.wc.myID];
+            var msgStr = JSON.stringify(msg);
+            var cryptMsg = channel.encrypt(msgStr);
+            var data = {
+                channel: channel.id,
+                msg: cryptMsg
+            };
+            network.sendto(peer, JSON.stringify(data));
+        };
+
+        var onLeaving = function (peer) {
+            if (peer === hk) { return; }
+
+            // update status
+            var otherData = channel.mapId[peer];
+            if (!otherData) { return; }
+
+            // Make sure the leaving user is not connected with another netflux id
+            if (channel.wc.members.some(function (nId) {
+                return channel.mapId[nId]
+                        && channel.mapId[nId].curvePublic === otherData.curvePublic;
+            })) { return; }
+
+            // Send the notification
+            ctx.emit('LEAVE', {
+                info: otherData,
+                id: channel.id
+            }, channel.clients);
+        };
+
+        var onOpen = function (chan) {
+            channel.wc = chan;
+            ctx.channels[data.channel] = channel;
+
+            chan.on('message', function (msg, sender) {
+                onMessage(ctx, msg, sender, chan);
+            });
+
+            chan.on('join', onJoining);
+            chan.on('leave', onLeaving);
+
+            getChannelMessagesSince(ctx, channel, data, keys);
+        };
+        network.join(data.channel).then(onOpen, function (err) {
+            console.error(err);
+        });
+        channel.onReconnect = function () {
+            if (channel && channel.stopped) { return; }
+            if (!ctx.channels[data.channel]) { return; }
+
+            network.join(data.channel).then(onOpen, function (err) {
+                console.error(err);
+            });
+        };
+        network.on('reconnect', channel.onReconnect);
+    };
+
+    var sendMessage = function (ctx, id, payload, cb) {
+        var channel = ctx.channels[id];
+        if (!channel) { return void cb({error: 'NO_CHANNEL'}); }
+        if (channel.readOnly) { return void cb({error: 'FORBIDDEN'}); }
+
+        var network = ctx.store.network;
+        if (!network.webChannels.some(function (wc) {
+            if (wc.id === channel.wc.id) { return true; }
+        })) {
+            return void cb({error: 'NO_SUCH_CHANNEL'});
+        }
+
+        var proxy = ctx.store.proxy || {};
+        var msg = [Types.message, proxy.curvePublic, +new Date(), payload];
+        if (!channel.isFriendChat) {
+            var name = proxy[Constants.displayNameKey] ||
+                        Messages.anonymous + '#' + (proxy.uid || ctx.store.noDriveUid).slice(0,5);
+            msg.push(name);
+        }
+        var msgStr = JSON.stringify(msg);
+        var cryptMsg = channel.encrypt(msgStr);
+
+        channel.wc.bcast(cryptMsg).then(function () {
+            pushMsg(ctx, channel, cryptMsg);
+            cb();
+        }, function (err) {
+            cb({error: err});
+        });
+    };
+
+    var getOnlineList = function (ctx, chanId) {
+        var channel = ctx.channels[chanId];
+        if (!channel) { return; }
+        var online = []; // Store online members to avoid duplicates
+
+        // Add ourselves
+        var myData = createData(ctx.store.proxy, false);
+        online.push(myData.curvePublic);
+
+        channel.wc.members.forEach(function (nId) {
+            if (nId === ctx.store.network.historyKeeper) { return; }
+            var data = channel.mapId[nId] || {};
+            if (!data.curvePublic) { return; }
+            if (online.indexOf(data.curvePublic) !== -1) { return; }
+            online.push(data.curvePublic);
+        });
+        return online;
+    };
+
+    // Display green status if one member is not me
+    var getStatus = function (ctx, chanId, cb) {
+        var channel = ctx.channels[chanId];
+        if (!channel) { return void cb('NO_SUCH_CHANNEL'); }
+        if (channel.onUserlistUpdate) {
+            channel.onUserlistUpdate();
+        }
+        var proxy = ctx.store.proxy || {};
+        var online = channel.wc.members.some(function (nId) {
+            if (nId === ctx.store.network.historyKeeper) { return; }
+            var data = channel.mapId[nId] || undefined;
+            if (!data) { return false; }
+            return data.curvePublic !== proxy.curvePublic;
+        });
+        cb(online);
+    };
+
+    var getMyInfo = function (ctx, cb) {
+        var proxy = ctx.store.proxy || {};
+        cb({
+            curvePublic: proxy.curvePublic,
+            displayName: proxy[Constants.displayNameKey]
+        });
+    };
+
+    var loadFriend = function (ctx, clientId, friend, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+
+        var chanId = friend.channel;
+        var channel = ctx.channels[chanId];
+        if (channel) {
+            // Fired instantly if already ready
+            return void channel.onReady.reg(function () {
+                if (channel.clients.indexOf(clientId) === -1) {
+                    channel.clients.push(clientId);
+                }
+                cb();
+            });
+        }
+
+        var proxy = ctx.store.proxy;
+        var keys = Curve.deriveKeys(friend.curvePublic, proxy.curvePrivate);
+        var data = {
+            keys: keys,
+            channel: friend.channel,
+            lastKnownHash: friend.lastKnownHash,
+            owners: [proxy.edPublic, friend.edPublic],
+            isFriendChat: true,
+            clients: clientId ? [clientId] : ctx.friendsClients,
+            onReady: cb
+        };
+        openChannel(ctx, data);
+    };
+
+    var initFriends = function (ctx, clientId, cb) {
+        var friends = getFriendList(ctx.store.proxy);
+
+        nThen(function (waitFor) {
+            // Load or get all friends channels
+            Object.keys(friends).forEach(function (key) {
+                if (key === 'me') {
+                    // At some point a bug inserted a friend's channel into our "me" data.
+                    // This led to displaying our name instead of our friend's name in the
+                    // contacts app. The following line is here to prevent this issue to happen
+                    // again.
+                    delete friends.me.channel;
+                    return;
+                }
+                var friend = clone(friends[key]);
+                if (typeof(friend) !== 'object') { return; }
+                if (!friend.channel) { return; }
+                loadFriend(ctx, clientId, friend, waitFor());
+            });
+        }).nThen(function () {
+            if (ctx.friendsClients.indexOf(clientId) === -1) {
+                ctx.friendsClients.push(clientId);
+            }
+            cb();
+        });
+    };
+
+    var getRooms = function (ctx, data, cb) {
+        var proxy = ctx.store.proxy;
+
+        // Get a single friend's room (on friend added)
+        if (data && data.curvePublic) {
+            var curvePublic = data.curvePublic;
+            // We need to get data about a new friend's room
+            var friend = getFriend(proxy, curvePublic);
+            if (!friend) { return void cb({error: 'NO_SUCH_FRIEND'}); }
+            var channel = ctx.channels[friend.channel];
+            if (!channel) { return void cb({error: 'NO_SUCH_CHANNEL'}); }
+            return void cb([{
+                id: channel.id,
+                isFriendChat: true,
+                name: friend.displayName,
+                lastKnownHash: friend.lastKnownHash,
+                curvePublic: friend.curvePublic,
+                messages: channel.messages
+            }]);
+        }
+
+        // Pad chat room
+        if (data && data.padChat) {
+            var pCChannel = ctx.channels[data.padChat];
+            if (!pCChannel) { return void cb({error: 'NO_SUCH_CHANNEL'}); }
+            return void cb([{
+                id: pCChannel.id,
+                isPadChat: true,
+                messages: pCChannel.messages
+            }]);
+        }
+
+        // Team chat room
+        if (data && data.teamChat) {
+            var tCChannel = ctx.channels[data.teamChat];
+            if (!tCChannel) { return void cb({error: 'NO_SUCH_CHANNEL'}); }
+            return void cb([{
+                id: tCChannel.id,
+                isTeamChat: true,
+                messages: tCChannel.messages
+            }]);
+        }
+
+        // Existing friends...
+        var rooms = Object.keys(ctx.channels).map(function (id) {
+            var r = ctx.channels[id];
+            var name, lastKnownHash, curvePublic;
+            if (r.isFriendChat) {
+                var friend = getFriendFromChannel(ctx, id);
+                if (!friend) { return null; }
+                name = friend.displayName;
+                lastKnownHash = friend.lastKnownHash;
+                curvePublic = friend.curvePublic;
+            } else if (r.isPadChat) {
+                return;
+            } else if (r.isTeamChat) {
+                return;
+            } else {
+                // TODO room get metadata (name) && lastKnownHash
+            }
+            return {
+                id: r.id,
+                isFriendChat: r.isFriendChat,
+                name: name,
+                lastKnownHash: lastKnownHash,
+                curvePublic: curvePublic,
+                messages: r.messages
+            };
+        }).filter(function (x) { return x; });
+        cb(rooms);
+    };
+
+    // Gte the static userlist of a room (eveyrone who has accessed to the room)
+    var getUserList = function (ctx, data, cb) {
+        var room = ctx.channels[data.id];
+        if (!room) { return void cb({error: 'NO_SUCH_CHANNEL'}); }
+        if (room.isFriendChat) {
+            var friend = getFriendFromChannel(ctx, data.id);
+            if (!friend) { return void cb({error: 'NO_SUCH_FRIEND'}); }
+            cb([friend]);
+        } else {
+            // TODO room userlist in rooms...
+            // (this is the static userlist, not the netflux one)
+            cb([]);
+        }
+    };
+
+    var openPadChat = function (ctx, clientId, data, _cb) {
+        var chanId = data.channel;
+
+        var cb = Util.once(Util.mkAsync(function () {
+            ctx.emit('PADCHAT_READY', chanId, [clientId]);
+            _cb();
+        }));
+
+        var channel = ctx.channels[chanId];
+        if (channel) {
+            return void channel.onReady.reg(function () {
+                if (channel.clients.indexOf(clientId) === -1) {
+                    channel.clients.push(clientId);
+                }
+                cb();
+            });
+        }
+
+        var secret = data.secret;
+        if (secret.keys.cryptKey) {
+            secret.keys.cryptKey = convertToUint8(secret.keys.cryptKey);
+        }
+        var encryptor = Crypto.createEncryptor(secret.keys);
+        var vKey = (secret.keys && secret.keys.validateKey) || ctx.validateKeys[secret.channel];
+        var chanData = {
+            padChan: data.secret && data.secret.channel,
+            readOnly: typeof(secret.keys) === "object" && !secret.keys.validateKey,
+            encryptor: encryptor,
+            channel: data.channel,
+            isPadChat: true,
+            decrypt: function (msg) {
+                return encryptor.decrypt(msg, vKey);
+            },
+            clients: [clientId],
+            onReady: cb
+        };
+        openChannel(ctx, chanData);
+    };
+
+    var openTeamChat = function (ctx, clientId, data, onUpdate, _cb) {
+        var chatData = data;
+        var chanId = chatData.channel;
+        var secret = chatData.secret;
+
+        if (!chanId || !secret) { return void _cb({error: 'EINVAL'}); }
+
+        var cb = Util.once(Util.mkAsync(function () {
+            ctx.emit('TEAMCHAT_READY', chanId, [clientId]);
+            _cb({
+                readOnly: typeof(secret.keys) === "object" && !secret.keys.validateKey,
+                channel: chanId
+            });
+        }));
+
+        var channel = ctx.channels[chanId];
+        if (channel) {
+            return void channel.onReady.reg(function () {
+                if (channel.clients.indexOf(clientId) === -1) {
+                    channel.clients.push(clientId);
+                }
+                cb();
+            });
+        }
+
+        if (secret.keys.cryptKey) {
+            secret.keys.cryptKey = convertToUint8(secret.keys.cryptKey);
+        }
+        var encryptor = Crypto.createEncryptor(secret.keys);
+        var vKey = (secret.keys && secret.keys.validateKey) || chatData.validateKey;
+        var chanData = {
+            teamId: data.teamId,
+            readOnly: typeof(secret.keys) === "object" && !secret.keys.validateKey,
+            encryptor: encryptor,
+            channel: chanId,
+            isTeamChat: true,
+            decrypt: function (msg) {
+                return encryptor.decrypt(msg, vKey);
+            },
+            clients: [clientId],
+            onUserlistUpdate: onUpdate,
+            onReady: cb
+        };
+        openChannel(ctx, chanData);
+    };
+
+    var clearOwnedChannel = function (ctx, id, cb) {
+        var channel = ctx.channels[id];
+        if (!channel) { return void cb({error: 'NO_CHANNEL'}); }
+        if (!ctx.store.rpc) { return void cb({error: 'RPC_NOT_READY'}); }
+        ctx.store.rpc.clearOwnedChannel(id, function (err) {
+            cb({error:err});
+            if (!err) {
+                channel.messages = [];
+                ctx.emit('CLEAR_CHANNEL', id, channel.clients);
+            }
+        });
+    };
+
+    // Remove a client from all the team they're subscribed to
+    var removeClient = function (ctx, cId) {
+        var friendsIdx = ctx.friendsClients.indexOf(cId);
+        if (friendsIdx !== -1) {
+            ctx.friendsClients.splice(friendsIdx, 1);
+        }
+        Object.keys(ctx.channels).forEach(function (id) {
+            var channel = ctx.channels[id];
+            var clients = channel.clients;
+            var idx = clients.indexOf(cId);
+            if (idx !== -1) { clients.splice(idx, 1); }
+
+            if (clients.length === 0) {
+                if (channel.wc) { channel.wc.leave(); }
+                var network = ctx.store.network;
+                if (channel.onReconnect) { network.off('reconnect', channel.onReconnect); }
+                channel.stopped = true;
+                delete ctx.channels[id];
+                return true;
+            }
+
+        });
+    };
+
+    Msg.init = function (cfg, waitFor, emit) {
+        var messenger = {};
+        var store = cfg.store;
+
+        // Already initialized by a "noDrive" tab
+        // If this one is a normal tab, add the missing listener if we can
+        if (store.messenger) {
+            store.messenger.addListener();
+            return store.messenger;
+        }
+
+        if (!PadTypes.isAvailable('contacts')) { return; }
+        var ctx = {
+            store: store,
+            Store: cfg.Store,
+            updateMetadata: cfg.updateMetadata,
+            pinPads: cfg.pinPads,
+            emit: emit,
+            friendsClients: [],
+            channels: {},
+            validateKeys: {},
+            range_requests: {}
+        };
+
+        messenger.addListener = function () {
+            if (store.proxy) {
+                store.proxy.on('change', ['mutedUsers'], function () {
+                    ctx.emit('UPDATE_MUTED', null, getAllClients(ctx));
+                });
+            }
+        };
+        messenger.addListener();
+
+        ctx.store.network.on('message', function(msg, sender) {
+            onDirectMessage(ctx, msg, sender);
+        });
+        ctx.store.network.on('disconnect', function () {
+            ctx.emit('DISCONNECT', null, getAllClients(ctx));
+        });
+        ctx.store.network.on('reconnect', function () {
+            ctx.emit('RECONNECT', null, getAllClients(ctx));
+        });
+
+        messenger.onFriendUpdate = function (curve) {
+            var friend = getFriend(store.proxy, curve);
+            if (!friend || !friend.channel) { return; }
+            var chan = ctx.channels[friend.channel];
+            if (chan) {
+                ctx.emit('UPDATE_DATA', {
+                    info: clone(friend),
+                    channel: friend.channel
+                }, chan.clients);
+            }
+        };
+        // Friend added in our contacts in the current worker
+        messenger.onFriendAdded = function (friendData) {
+            if (!ctx.friendsClients.length) { return; }
+
+            var friend = getFriend(ctx.store.proxy, friendData.curvePublic);
+            if (typeof(friend) !== 'object') { return; }
+            var channel = friend.channel;
+            if (!channel) { return; }
+
+            // Already friend? don't load the channel a second time
+            var chanId = friend.channel;
+            var chan = ctx.channels[chanId];
+            if (chan) { return; }
+
+            // Load the channel and add the friend to the contacts app
+            loadFriend(ctx, null, friend, function () {
+                emit('FRIEND', {
+                    curvePublic: friend.curvePublic,
+                }, ctx.friendsClients);
+            });
+        };
+        messenger.onFriendRemoved = function (curvePublic, chanId) {
+            onFriendRemoved(ctx, curvePublic, chanId);
+        };
+
+        messenger.getOnlineList = function (chanId) {
+            return getOnlineList(ctx, chanId);
+        };
+
+        messenger.storeValidateKey = function (chan, key) {
+            ctx.validateKeys[chan] = key;
+        };
+        messenger.leavePad = function (padChan) {
+            // Leave chat and prevent reconnect when we leave a pad
+            delete ctx.validateKeys[padChan];
+            Object.keys(ctx.channels).some(function (chatChan) {
+                var channel = ctx.channels[chatChan];
+                if (channel.padChan !== padChan) { return; }
+                if (channel.wc) { channel.wc.leave(); }
+                var network = ctx.store.network;
+                if (channel.onReconnect) { network.off('reconnect', channel.onReconnect); }
+                channel.stopped = true;
+                delete ctx.channels[chatChan];
+                return true;
+            });
+        };
+
+        messenger.openTeamChat = function (data, onUpdate, cId, cb) {
+            openTeamChat(ctx, cId, data, onUpdate, cb);
+        };
+
+        messenger.removeClient = function (clientId) {
+            removeClient(ctx, clientId);
+        };
+        messenger.execCommand = function (clientId, obj, cb) {
+            var cmd = obj.cmd;
+            var data = obj.data;
+            if (cmd === 'INIT_FRIENDS') {
+                return void initFriends(ctx, clientId, cb);
+            }
+            if (cmd === 'GET_ROOMS') {
+                return void getRooms(ctx, data, cb);
+            }
+            if (cmd === 'GET_MUTED_USERS') {
+                return void getMutedUsers(ctx, cb);
+            }
+            if (cmd === 'GET_USERLIST') {
+                return void getUserList(ctx, data, cb);
+            }
+            if (cmd === 'OPEN_PAD_CHAT') {
+                return void openPadChat(ctx, clientId, data, cb);
+            }
+            if (cmd === 'GET_MY_INFO') {
+                return void getMyInfo(ctx, cb);
+            }
+            if (cmd === 'REMOVE_FRIEND') {
+                return void removeFriend(ctx, data, cb);
+            }
+            if (cmd === 'CANCEL_FRIEND') {
+                return void cancelFriend(ctx, data, cb);
+            }
+            if (cmd === 'MUTE_USER') {
+                return void muteUser(ctx, data, cb);
+            }
+            if (cmd === 'UNMUTE_USER') {
+                return void unmuteUser(ctx, data, cb);
+            }
+            if (cmd === 'GET_STATUS') {
+                return void getStatus(ctx, data, cb);
+            }
+            if (cmd === 'GET_MORE_HISTORY') {
+                return void getMoreHistory(ctx, data.id, data.sig, data.count, cb);
+            }
+            if (cmd === 'SEND_MESSAGE') {
+                return void sendMessage(ctx, data.id, data.content, cb);
+            }
+            if (cmd === 'SET_CHANNEL_HEAD') {
+                return void setChannelHead(ctx, data.id, data.sig, cb);
+            }
+            if (cmd === 'CLEAR_OWNED_CHANNEL') {
+                return void clearOwnedChannel(ctx, data, cb);
+            }
+        };
+
+        return messenger;
+    };
+
+    return Msg;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        require('chainpad-crypto'),
+        require('../../common/common-hash'),
+        require('../../common/common-util'),
+        require('../../common/common-realtime'),
+        require('../../common/common-messaging'),
+        require('../../common/common-constants'),
+        undefined,
+        require('../../common/pad-types'),
+        require('nthen')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/components/chainpad-crypto/crypto.js',
+        '/common/common-hash.js',
+        '/common/common-util.js',
+        '/common/common-realtime.js',
+        '/common/common-messaging.js',
+        '/common/common-constants.js',
+        '/customize/messages.js',
+        '/common/pad-types.js',
+
+        '/components/nthen/index.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/modules/onlyoffice.js b/src/worker/modules/onlyoffice.js
new file mode 100644
index 000000000..fd72ac8d6
--- /dev/null
+++ b/src/worker/modules/onlyoffice.js
@@ -0,0 +1,361 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = () => {
+    var OO = {};
+
+    var getHistory = function (ctx, client, cb) {
+        var c = ctx.clients[client];
+        if (!c) { return void cb({error: 'ENOENT'}); }
+        var chan = ctx.channels[c.channel];
+        if (!chan) { return void cb({error: 'ENOCHAN'}); }
+        cb();
+        chan.history.forEach(function (msg) {
+            ctx.emit('MESSAGE', {
+                msg: msg,
+                validateKey: chan.validateKey
+            }, [client]);
+        });
+        ctx.emit('HISTORY_SYNCED', {}, [client]);
+    };
+
+    var openChannel = function (ctx, obj, client, cb) {
+        var channel = obj.channel;
+        var padChan = obj.padChan;
+        var network = ctx.store.network;
+        var first = true;
+
+        var c = ctx.clients[client];
+        if (!c) {
+            c = ctx.clients[client] = {
+                channel: channel,
+            };
+        } else {
+            return void cb();
+        }
+
+        var chan = ctx.channels[channel];
+        if (chan) {
+            // This channel is already open in another tab
+
+            // ==> Use our netflux ID to create our client ID
+            if (!c.id) { c.id = chan.wc.myID + '-' + client; }
+
+            getHistory(ctx, client, function () {
+                ctx.emit('READY', chan.clients, [client]);
+            });
+
+            // ==> And push the new tab to the list
+            chan.clients.push(client);
+            return void cb();
+        }
+
+        var txid = Math.floor(Math.random() * 1000000);
+        var onOpen = function (wc) {
+
+            ctx.channels[channel] = ctx.channels[channel] || {
+                history: [],
+                validateKey: obj.validateKey
+            };
+
+            chan = ctx.channels[channel];
+            chan.padChan = padChan;
+
+            // Create our client ID using the netflux ID
+            if (!c.id) { c.id = wc.myID + '-' + client; }
+
+            // If this is a reconnect, we have a new netflux ID so we're going to fix
+            // all our client IDs.
+            if (chan.clients) {
+                chan.clients.forEach(function (cl) {
+                    if (ctx.clients[cl]) {
+                        ctx.clients[cl].id = wc.myID + '-' + cl;
+                    }
+                });
+            }
+
+            wc.on('join', function () {
+            });
+            wc.on('leave', function () {
+            });
+            wc.on('message', function (msg) {
+                chan.history.push(msg);
+                ctx.emit('MESSAGE', {
+                    msg: msg,
+                    validateKey: chan.validateKey
+                }, chan.clients);
+            });
+
+            chan.wc = wc;
+            chan.sendMsg = function (msg, cb) {
+                cb = cb || function () {};
+                var hash = msg.slice(0, 64);
+                wc.bcast(msg).then(function () {
+                    chan.history.push(msg);
+                    chan.lastKnownHash = hash;
+                    cb();
+                }, function (err) {
+                    cb({error: err});
+                });
+            };
+
+            if (first) {
+                chan.clients = [client];
+                chan.lastCpHash = obj.lastCpHash;
+                first = false;
+                cb();
+            }
+
+            var hk = network.historyKeeper;
+            var cfg = {
+                txid: txid,
+                lastKnownHash: chan.lastKnownHash || chan.lastCpHash,
+                metadata: {
+                    validateKey: obj.validateKey,
+                    owners: obj.owners,
+                    expire: obj.expire
+                }
+            };
+            var msg = ['GET_HISTORY', wc.id, cfg];
+            // Add the validateKey if we are the channel creator and we have a validateKey
+            if (hk) {
+                network.sendto(hk, JSON.stringify(msg)).then(function () {
+                }, function (err) {
+                    console.error(err);
+                });
+            }
+
+        };
+
+        network.on('message', function (msg, sender) {
+            if (!ctx.channels[channel]) { return; }
+            var hk = network.historyKeeper;
+            if (sender !== hk) { return; }
+
+            // Parse the message
+            var parsed;
+            try {
+                parsed = JSON.parse(msg);
+            } catch (e) {}
+            if (!parsed) { return; }
+
+            // If there is a txid, make sure it's ours or abort
+            if (parsed.txid && parsed.txid !== txid) { return; }
+
+            // Keep only metadata messages for the current channel
+            if (parsed.channel && parsed.channel !== channel) { return; }
+            // Ignore the metadata message
+            if (parsed.validateKey && parsed.channel) {
+                if (!chan.validateKey) {
+                    chan.validateKey = parsed.validateKey;
+                }
+                return;
+            }
+            // End of history: emit READY
+            if (parsed.state && parsed.state === 1 && parsed.channel) {
+                ctx.emit('READY', chan.clients, chan.clients);
+                return;
+            }
+            if (parsed.error && parsed.channel) { return; }
+
+            // If there is a txid, make sure it's ours or abort
+            if (Array.isArray(parsed) && parsed[0] && parsed[0] !== txid) {
+                return;
+            }
+
+            msg = parsed[4];
+
+            // Keep only the history for our channel
+            if (parsed[3] !== channel) { return; }
+
+            var hash = msg.slice(0,64);
+            if (hash === chan.lastKnownHash || hash === chan.lastCpHash) { return; }
+
+            chan.lastKnownHash = hash;
+            ctx.emit('MESSAGE', {
+                msg: msg,
+            }, chan.clients);
+            chan.history.push(msg);
+        });
+
+        network.join(channel).then(onOpen, function (err) {
+            return void cb({error: err});
+        });
+
+        network.on('reconnect', function () {
+            if (!ctx.channels[channel]) { return; }
+            network.join(channel).then(onOpen, function (err) {
+                console.error(err);
+            });
+        });
+    };
+
+    var updateHash = function (ctx, data, clientId, cb) {
+        var c = ctx.clients[clientId];
+        if (!c) { return void cb({ error: 'NOT_IN_CHANNEL' }); }
+        var chan = ctx.channels[c.channel];
+        if (!chan) { return void cb({ error: 'INVALID_CHANNEL' }); }
+        var hash = data;
+        var index = -1;
+        chan.history.some(function (msg, idx) {
+            if (msg.slice(0,64) === hash) {
+                index = idx + 1;
+                return true;
+            }
+        });
+        if (index !== -1) {
+            chan.history = chan.history.slice(index);
+        }
+        cb();
+    };
+
+    var sendMessage = function (ctx, data, clientId, cb) {
+        var c = ctx.clients[clientId];
+        if (!c) { return void cb({ error: 'NOT_IN_CHANNEL' }); }
+        var chan = ctx.channels[c.channel];
+        if (!chan) { return void cb({ error: 'INVALID_CHANNEL' }); }
+        // Prepare the callback: broadcast the message to the other local tabs
+        // if the message is sent
+        var _cb = function (obj) {
+            if (obj && obj.error) { return void cb(obj); }
+            ctx.emit('MESSAGE', {
+                msg: data.msg
+            }, chan.clients.filter(function (cl) {
+                return cl !== clientId;
+            }));
+            cb();
+        };
+        // Send the message
+        if (data.isCp) {
+            return void chan.sendMsg(data.isCp, _cb);
+        }
+        chan.sendMsg(data.msg, _cb);
+    };
+
+    var reencrypt = function (ctx, data, cId, cb) {
+        var channel = data.channel;
+        var network = ctx.store.network;
+
+        var onOpen = function (wc) {
+            var hk = network.historyKeeper;
+            var cfg = {
+                metadata: data.metadata
+            };
+            var msg = ['GET_HISTORY', wc.id, cfg];
+            network.sendto(hk, JSON.stringify(msg));
+            data.msgs.forEach(function (msg) {
+                wc.bcast(msg);
+            });
+            wc.leave();
+            cb();
+        };
+
+        ctx.store.anon_rpc.send("IS_NEW_CHANNEL", channel, function (e, response) {
+            if (e) { return void cb({error: e}); }
+            var isNew;
+            if (response && response.length && typeof(response[0]) === 'object') {
+                isNew = response[0].isNew;
+            } else {
+                cb({error: 'INVALID_RESPONSE'});
+            }
+            if (!isNew) { return void cb({error: 'EEXISTS'}); }
+
+            // Channel is new: we can push our reencrypted history
+            network.join(channel).then(onOpen, function (err) {
+                return void cb({error: err});
+            });
+        });
+    };
+
+    var leaveChannel = function (ctx, padChan) {
+        // Leave channel and prevent reconnect when we leave a pad
+        Object.keys(ctx.channels).some(function (ooChan) {
+            var channel = ctx.channels[ooChan];
+            if (channel.padChan !== padChan) { return; }
+            if (channel.wc) { channel.wc.leave(); }
+            delete ctx.channels[ooChan];
+            return true;
+        });
+    };
+
+    // Remove the client from all its channels when a tab is closed
+    var removeClient = function (ctx, clientId) {
+        var filter = function (c) {
+            return c !== clientId;
+        };
+
+        // Remove the client from our channels
+        var chan;
+        for (var k in ctx.channels) {
+            chan = ctx.channels[k];
+            chan.clients = chan.clients.filter(filter);
+            if (chan.clients.length === 0) {
+                if (chan.wc) { chan.wc.leave(); }
+                delete ctx.channels[k];
+            }
+        }
+
+        if (ctx.clients[clientId]) {
+            var oldChannel = ctx.clients[clientId].channel;
+            var oldChan = ctx.channels[oldChannel];
+            if (oldChan) {
+                ctx.emit('LEAVE', {id: clientId}, [oldChan.clients[0]]);
+            }
+            delete ctx.clients[clientId];
+        }
+    };
+
+
+
+    OO.init = function (store, emit) {
+        var oo = {};
+        var ctx = {
+            store: store,
+            emit: emit,
+            channels: {},
+            clients: {}
+        };
+
+        oo.removeClient = function (clientId) {
+            removeClient(ctx, clientId);
+        };
+        oo.leavePad = function (padChan) {
+            leaveChannel(ctx, padChan);
+        };
+        oo.execCommand = function (clientId, obj, cb) {
+            var cmd = obj.cmd;
+            var data = obj.data;
+            if (cmd === 'SEND_MESSAGE') {
+                return void sendMessage(ctx, data, clientId, cb);
+            }
+            if (cmd === 'UPDATE_HASH') {
+                return void updateHash(ctx, data, clientId, cb);
+            }
+            if (cmd === 'OPEN_CHANNEL') {
+                return void openChannel(ctx, data, clientId, cb);
+            }
+            if (cmd === 'GET_HISTORY') {
+                return void getHistory(ctx, clientId, cb);
+            }
+            if (cmd === 'REENCRYPT') {
+                return void reencrypt(ctx, data, clientId, cb);
+            }
+        };
+
+        return oo;
+    };
+
+    return OO;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory();
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([], factory);
+} else {
+    // unsupported initialization
+}
+})();
diff --git a/src/worker/modules/profile.js b/src/worker/modules/profile.js
new file mode 100644
index 000000000..8e4c97566
--- /dev/null
+++ b/src/worker/modules/profile.js
@@ -0,0 +1,185 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Util, Hash, Constants, Realtime,
+                Listmap, Crypto, ChainPad) => {
+    var Profile = {};
+
+    var initializeProfile = function (ctx, cb) {
+        var profile = ctx.profile;
+        if (!profile.edit || !profile.view) {
+            var hash = Hash.createRandomHash('profile');
+            var secret = Hash.getSecrets('profile', hash);
+            ctx.pinPads([secret.channel], function (res) {
+                if (res.error) {
+                    return void cb(res.error);
+                }
+                profile.edit = Hash.getEditHashFromKeys(secret);
+                profile.view = Hash.getViewHashFromKeys(secret);
+                setTimeout(cb);
+            });
+            return;
+        }
+        setTimeout(cb);
+    };
+
+    var openChannel = function (ctx) {
+        var profile = ctx.profile;
+        var secret = Hash.getSecrets('profile', profile.edit);
+        var crypto = Crypto.createEncryptor(secret.keys);
+
+        var cfg = {
+            data: {},
+            network: ctx.store.network,
+            channel: secret.channel,
+            crypto: crypto,
+            owners: [ctx.store.proxy.edPublic],
+            ChainPad: ChainPad,
+            validateKey: secret.keys.validateKey || undefined,
+            userName: 'profile',
+            classic: true
+        };
+        var lm = Listmap.create(cfg);
+        lm.proxy.on('create', function () {
+        }).on('ready', function () {
+            lm.proxy.name = ctx.store.proxy[Constants.displayNameKey] || "";
+            ctx.listmap = lm;
+            if (!lm.proxy.curvePublic) {
+                lm.proxy.curvePublic = ctx.store.proxy.curvePublic;
+            }
+            if (!lm.proxy.notifications) {
+                lm.proxy.notifications = Util.find(ctx.store.proxy, ['mailboxes', 'notifications', 'channel']);
+            }
+            if (!lm.proxy.edPublic) {
+                lm.proxy.edPublic = ctx.store.proxy.edPublic;
+            }
+            if (ctx.onReadyHandlers.length) {
+                ctx.onReadyHandlers.forEach(function (f) {
+                    try {
+                        f(lm.proxy);
+                    } catch (e) { console.error(e); }
+                });
+                ctx.onReadyHandlers = [];
+            }
+        }).on('change', [], function () {
+            ctx.emit('UPDATE', lm.proxy, ctx.clients);
+        });
+    };
+
+    var setName = function (ctx, value) {
+        ctx.listmap.proxy.name = value;
+        Realtime.whenRealtimeSyncs(ctx.listmap.realtime, function () {
+            if (!ctx.listmap) { return; }
+            ctx.emit('UPDATE', ctx.listmap.proxy, ctx.clients);
+        });
+    };
+
+    var subscribe = function (ctx, data, cId, cb) {
+        // Subscribe to new notifications
+        var idx = ctx.clients.indexOf(cId);
+        if (idx === -1) {
+            ctx.clients.push(cId);
+        }
+        if (ctx.listmap) {
+            return void cb(ctx.listmap.proxy);
+        }
+        ctx.onReadyHandlers.push(function (proxy) {
+            cb(proxy);
+        });
+    };
+
+    var setValue = function (ctx, data, cId, cb) {
+        var key = data.key;
+        var value = data.value;
+        if (!key) { return; }
+        ctx.listmap.proxy[key] = value;
+        Realtime.whenRealtimeSyncs(ctx.listmap.realtime, function () {
+            ctx.emit('UPDATE', ctx.listmap.proxy, ctx.clients.filter(function (clientId) {
+                return clientId !== cId;
+            }));
+            cb(ctx.listmap.proxy);
+        });
+    };
+
+    var removeClient = function (ctx, cId) {
+        var idx = ctx.clients.indexOf(cId);
+        if (idx !== -1) { ctx.clients.splice(idx, 1); }
+    };
+
+    Profile.init = function (cfg, waitFor, emit) {
+        var profile = {};
+        var store = cfg.store;
+        if (!store.loggedIn || !store.proxy.edPublic) { return; }
+        var ctx = {
+            store: store,
+            pinPads: cfg.pinPads,
+            updateMetadata: cfg.updateMetadata,
+            emit: emit,
+            onReadyHandlers: [],
+            clients: [],
+        };
+
+        ctx.profile = store.proxy.profile = store.proxy.profile || {};
+
+        initializeProfile(ctx, waitFor(function (err) {
+            if (err) { return; }
+            openChannel(ctx);
+        }));
+
+        profile.setName = function (value) {
+            setName(ctx, value);
+        };
+        profile.removeClient = function (clientId) {
+            removeClient(ctx, clientId);
+        };
+        profile.update = function () {
+            if (!ctx.listmap) { return; }
+            ctx.emit('UPDATE', ctx.listmap.proxy, ctx.clients);
+        };
+        profile.execCommand = function (clientId, obj, cb) {
+            console.log(obj);
+            var cmd = obj.cmd;
+            var data = obj.data;
+            if (cmd === 'SUBSCRIBE') {
+                return void subscribe(ctx, data, clientId, cb);
+            }
+            if (cmd === 'SET') {
+                return void setValue(ctx, data, clientId, cb);
+            }
+        };
+
+        return profile;
+    };
+
+    return Profile;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        undefined,
+        require('../../common/common-util'),
+        require('../../common/common-hash'),
+        require('../../common/common-constants'),
+        require('../../common/common-realtime'),
+        require('chainpad-listmap'),
+        require('chainpad-crypto'),
+        require('chainpad')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/common-constants.js',
+        '/common/common-realtime.js',
+        'chainpad-listmap',
+        '/components/chainpad-crypto/crypto.js',
+        '/components/chainpad/chainpad.dist.js',
+        ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/modules/support.js b/src/worker/modules/support.js
new file mode 100644
index 000000000..c058ef71e
--- /dev/null
+++ b/src/worker/modules/support.js
@@ -0,0 +1,1446 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (ApiConfig = {}, Util, Hash, Realtime, Pinpad, Crypt,
+            nThen, Crypto, Listmap, ChainPad, CpNetflux) => {
+    var Support = {};
+
+    Support.setCustomize = data => {
+        ApiConfig = data.ApiConfig;
+    };
+
+    var Nacl = Crypto.Nacl;
+
+    // UTILS
+
+    var notifyClient = function (ctx, admin, type, channel) {
+        let notifyList = Object.keys(ctx.clients).filter((cId) => {
+            return Boolean(ctx.clients[cId].admin) === admin;
+        });
+        if (!notifyList.length) { return; }
+        ctx.emit(type, { channel }, [notifyList]);
+    };
+
+    var getKeys = function (ctx, isAdmin, data, _cb) {
+        var cb = Util.mkAsync(_cb);
+        if (isAdmin && !ctx.adminRdyEvt) { return void cb('EFORBIDDEN'); }
+        require(['/api/config?' + (+new Date())], function (NewConfig) {
+            ctx.moderatorKeys = NewConfig.moderatorKeys; // Update moderator keys
+            ctx.adminKeys = NewConfig.adminKeys; // Update moderator keys
+
+            var supportKey = NewConfig.supportMailboxKey;
+            if (!supportKey) { return void cb('E_NOT_INIT'); }
+
+            // If admin, check key
+            if (isAdmin && Util.find(ctx.store.proxy, [
+                'mailboxes', 'supportteam', 'keys', 'curvePublic']) !== supportKey) {
+                return void cb('EFORBIDDEN');
+            }
+
+            if (isAdmin) {
+                return ctx.adminRdyEvt.reg(() => {
+                    cb(null, {
+                        supportKey: supportKey,
+                        myCurve: data.adminCurvePrivate || Util.find(ctx.store.proxy, [
+                                    'mailboxes', 'supportteam', 'keys', 'curvePrivate']),
+                        theirPublic: data.curvePublic,
+                        notifKey: data.curvePublic
+                    });
+                });
+            }
+
+            cb(null, {
+                supportKey: supportKey,
+                myCurve: ctx.store.proxy.curvePrivate,
+                theirPublic: data.curvePublic || supportKey, // old tickets may use deprecated key
+                notifKey: supportKey
+            });
+        });
+    };
+
+    // Get the content of a ticket mailbox and close it
+    var getContent = function (ctx, data, isAdmin, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        var theirPublic, myCurve;
+        nThen((waitFor) => {
+            getKeys(ctx, isAdmin, data, waitFor((err, obj) => {
+                if (err) {
+                    waitFor.abort();
+                    return void cb({error: err});
+                }
+                theirPublic = obj.theirPublic;
+                myCurve = obj.myCurve;
+            }));
+        }).nThen(() => {
+            var keys = Crypto.Curve.deriveKeys(theirPublic, myCurve);
+            var crypto = Crypto.Curve.createEncryptor(keys);
+            var cfg = {
+                network: ctx.store.network,
+                channel: data.channel,
+                noChainPad: true,
+                crypto: crypto,
+                owners: []
+            };
+            var all = [];
+            var cpNf;
+            var close = function () {
+                if (!cpNf) { return; }
+                if (typeof(cpNf.stop) !== "function") { return; }
+                cpNf.stop();
+            };
+            cb = Util.both(close, cb);
+            cfg.onMessage = function (msg, user, vKey, isCp, hash, author, data) {
+                var time = data && data.time;
+                try {
+                    msg = JSON.parse(msg);
+                } catch (e) {
+                    console.error(e);
+                }
+                msg.time = time;
+                if (author) { msg.author = author; }
+                all.push(msg);
+            };
+            cfg.onError = cb;
+            cfg.onChannelError = cb;
+            cfg.onReady = function () {
+                cb(null, all);
+            };
+            cpNf = CpNetflux.start(cfg);
+        });
+    };
+
+    var makeTicket = function (ctx, data, isAdmin, cb) {
+        var mailbox = Util.find(ctx, [ 'store', 'mailbox' ]);
+        var anonRpc = Util.find(ctx, [ 'store', 'anon_rpc' ]);
+        if (!mailbox) { return void cb({error: 'E_NOT_READY'}); }
+        if (!anonRpc) { return void cb({error: "anonymous rpc session not ready"}); }
+
+        var channel = data.channel;
+        var title = data.title;
+        var ticket = data.ticket;
+        var supportKey, theirPublic, myCurve;
+        var time = +new Date();
+        nThen((waitFor) => {
+            // Send ticket to the admins and call back
+            getKeys(ctx, isAdmin, data, waitFor((err, obj) => {
+                if (err) {
+                    waitFor.abort();
+                    return void cb({error: err});
+                }
+                supportKey = obj.supportKey;
+                theirPublic = obj.theirPublic;
+                myCurve = obj.myCurve;
+                // No need for notifKey here: users can only create tickets for the
+                // currently used key
+            }));
+        }).nThen((waitFor) => {
+            // Create ticket mailbox
+            var keys = Crypto.Curve.deriveKeys(theirPublic, myCurve);
+            var crypto = Crypto.Curve.createEncryptor(keys);
+            var text = JSON.stringify(ticket);
+            var ciphertext = crypto.encrypt(text);
+            anonRpc.send("WRITE_PRIVATE_MESSAGE", [
+                channel,
+                ciphertext
+            ], waitFor((err, res) => {
+                if (err) {
+                    waitFor.abort();
+                    return void cb({error: err});
+                }
+                time = res && res[0];
+            }));
+        }).nThen((waitFor) => {
+            if (!isAdmin) { return; }
+            // ADMIN: Store in chainpad
+            var doc = ctx.adminDoc.proxy;
+            var active = doc.tickets.active;
+            if (active[channel]) {
+                waitFor.abort();
+                return void cb({error: 'EEXISTS'});
+            }
+            active[channel] = {
+                title: ticket.title,
+                restored: ticket.legacy,
+                premium: false,
+                time: time,
+                author: data.name,
+                supportKey: supportKey, // Store current support key
+                lastAdmin: true,
+                authorKey: data.curvePublic,
+                notifications: data.notifications // Ticket created as admin, add user chan
+            };
+        }).nThen((waitFor) => {
+            if (isAdmin) { return; }
+            // USER: Store in my worker
+            ctx.supportData[channel] = {
+                time: +new Date(),
+                title: title,
+                curvePublic: supportKey // Old tickets still use previous keys
+            };
+            ctx.Store.onSync(null, waitFor());
+        }).nThen(() => {
+            var notifChannel = isAdmin ? data.notifications
+                                    : Hash.getChannelIdFromKey(supportKey);
+            // First message to deal with the new ticket (store it in the list)
+            mailbox.sendTo('NEW_TICKET', {
+                title: title,
+                channel: channel,
+                time,
+                isAdmin,
+                supportKey: supportKey, // Store current support key
+                premium: isAdmin ? '' : Util.find(ctx, ['store', 'account', 'plan']),
+                user: Util.find(data.ticket, ['sender', 'curvePublic']) ? undefined : {
+                    supportTeam: true
+                }
+            }, {
+                channel: notifChannel,
+                curvePublic: theirPublic
+            }, (obj) => {
+                console.error(obj);
+                // Don't store the ticket in case of error
+                if (obj && obj.error) { delete ctx.supportData[channel]; }
+                cb(obj);
+            });
+            // Second message is only a notification to warn the user/admins
+            mailbox.sendTo('NOTIF_TICKET', {
+                title: title,
+                channel: channel,
+                time,
+                isAdmin,
+                isNewTicket: true,
+                user: Util.find(data.ticket, ['sender', 'curvePublic']) ? undefined : {
+                    supportTeam: true
+                }
+            }, {
+                channel: notifChannel,
+                curvePublic: theirPublic
+            }, () => {});
+        });
+    };
+
+    var replyTicket = function (ctx, data, isAdmin, cb) {
+        var mailbox = Util.find(ctx, [ 'store', 'mailbox' ]);
+        var anonRpc = Util.find(ctx, [ 'store', 'anon_rpc' ]);
+        if (!mailbox) { return void cb('E_NOT_READY'); }
+        if (!anonRpc) { return void cb("anonymous rpc session not ready"); }
+        var theirPublic, myCurve, notifKey;
+        var time;
+        nThen((waitFor) => {
+            // Get correct keys
+            getKeys(ctx, isAdmin, data, waitFor((err, obj) => {
+                if (err) {
+                    waitFor.abort();
+                    return void cb(err);
+                }
+                theirPublic = obj.theirPublic;
+                myCurve = obj.myCurve;
+                notifKey = obj.notifKey;
+            }));
+        }).nThen((waitFor) => {
+            // Send message
+            var keys = Crypto.Curve.deriveKeys(theirPublic, myCurve);
+            var crypto = Crypto.Curve.createEncryptor(keys);
+            var text = JSON.stringify(data.ticket);
+            var ciphertext = crypto.encrypt(text);
+            anonRpc.send("WRITE_PRIVATE_MESSAGE", [
+                data.channel,
+                ciphertext
+            ], waitFor((err, res) => {
+                if (err) {
+                    waitFor.abort();
+                    return void cb(err);
+                }
+                time = res && res[0];
+                cb(void 0, time);
+            }));
+        }).nThen(() => {
+            // On success, notify
+            var notifChannel = isAdmin ? data.notifChannel : Hash.getChannelIdFromKey(notifKey);
+            if (!notifChannel) { return; }
+            mailbox.sendTo('NOTIF_TICKET', {
+                isAdmin: isAdmin,
+                title: data.ticket.title,
+                isClose: data.ticket.close,
+                channel: data.channel,
+                time: time,
+                user: Util.find(data.ticket, ['sender', 'curvePublic']) ? undefined : {
+                    supportTeam: true
+                }
+            }, {
+                channel: notifChannel,
+                curvePublic: notifKey
+            }, () => {
+                // Do nothing, not a problem if notifications fail
+            });
+        });
+    };
+
+    // INITIALIZE ADMIN
+
+    var getPinList = function (ctx) {
+        if (!ctx.adminDoc || !ctx.supportRpc) { return; }
+        let adminChan = ctx.adminDoc.metadata && ctx.adminDoc.metadata.channel;
+        let doc = ctx.adminDoc.proxy;
+        let t = doc.tickets;
+        let list = [
+            adminChan,
+            ...Object.keys(t.active),
+            ...Object.keys(t.pending),
+            ...Object.keys(t.closed)
+        ];
+        return Util.deduplicateString(list).sort();
+    };
+    var initAdminRpc = function (ctx, _cb) {
+        let cb = Util.mkAsync(_cb);
+        let proxy = ctx.store.proxy;
+        let curvePrivate = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePrivate']);
+        if (!curvePrivate) { return void cb('EFORBIDDEN'); }
+        let edPrivate, edPublic;
+        try {
+            let pair = Nacl.sign.keyPair.fromSeed(Nacl.util.decodeBase64(curvePrivate));
+            edPrivate = Nacl.util.encodeBase64(pair.secretKey);
+            edPublic = Nacl.util.encodeBase64(pair.publicKey);
+        } catch (e) {
+            return void cb(e);
+        }
+        Pinpad.create(ctx.store.network, {
+            edPublic: edPublic,
+            edPrivate: edPrivate
+        }, (e, call) => {
+            if (e) { return void cb(e); }
+            console.log("Support RPC ready, public key is ", edPublic);
+            ctx.supportRpc = call;
+            cb();
+        });
+    };
+    var loadAdminDoc = function (ctx, hash, cb) {
+        var secret = Hash.getSecrets('support', hash);
+        var listmapConfig = {
+            data: {},
+            channel: secret.channel,
+            crypto: Crypto.createEncryptor(secret.keys),
+            userName: 'support',
+            ChainPad: ChainPad,
+            classic: true,
+            network: ctx.store.network,
+            metadata: {
+                validateKey: secret.keys.validateKey || undefined,
+            },
+        };
+        var rt = ctx.adminDoc = Listmap.create(listmapConfig);
+        rt.proxy.on('ready', function () {
+            var doc = rt.proxy;
+            doc.tickets = doc.tickets || {};
+            doc.tickets.active = doc.tickets.active || {};
+            doc.tickets.closed = doc.tickets.closed || {};
+            doc.tickets.pending = doc.tickets.pending || {};
+            ctx.adminRdyEvt.fire();
+            cb();
+
+            if (!ctx.supportRpc) { return; }
+            // Check pin list
+            let list = getPinList(ctx);
+            let local = Hash.hashChannelList(list);
+            ctx.supportRpc.getServerHash(function (e, hash) {
+                if (e) { return void console.warn(e); }
+                if (hash !== local) {
+                    ctx.supportRpc.reset(list, function (e) {
+                        if (e) { console.warn(e); }
+                    });
+                }
+            });
+        });
+        rt.proxy.on('change', ['recorded'], function () {
+            notifyClient(ctx, true, 'RECORDED_CHANGE', '');
+        });
+        rt.proxy.on('remove', ['recorded'], function () {
+            notifyClient(ctx, true, 'RECORDED_CHANGE', '');
+        });
+    };
+
+
+    var initializeSupportAdmin = function (ctx, isReset, waitFor) {
+        let unlock = waitFor();
+        let proxy = ctx.store.proxy;
+        let supportKey = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePublic']);
+        let privateKey = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePrivate']);
+        if (!isReset) { ctx.adminRdyEvt = Util.mkEvent(true); }
+        nThen((waitFor) => {
+            getKeys(ctx, false, {}, waitFor((err, obj) => {
+                setTimeout(unlock); // Unlock loading process
+                if (err) { return void waitFor.abort(); }
+                if (obj.theirPublic !== supportKey) {
+                    try {
+                        delete proxy.mailboxes.supportteam;
+                        ctx.store.mailbox.close('supportteam');
+                    } catch (e) {}
+                    delete ctx.adminRdyEvt;
+                    return void waitFor.abort();
+                }
+            }));
+        }).nThen((waitFor) => {
+            initAdminRpc(ctx, waitFor((err) => {
+                if (err) { console.error('Support RPC not ready', err); }
+            }));
+        }).nThen((waitFor) => {
+            let seed = privateKey.slice(0,24); // also in admin/inner.js
+            let hash = Hash.getEditHashFromKeys({
+                version: 2,
+                type: 'support',
+                keys: {
+                    editKeyStr: seed
+                }
+            });
+            loadAdminDoc(ctx, hash, waitFor());
+        }).nThen(() => {
+            console.log('Support admin loaded');
+        });
+
+    };
+
+    // USER COMMANDS
+
+    var getMyTickets = function (ctx, data, cId, cb) {
+        var all = [];
+        var n = nThen;
+        if (!ctx.clients[cId]) {
+            ctx.clients[cId] = {
+                admin: false
+            };
+        }
+        Object.keys(ctx.supportData).forEach(function (ticket) {
+            n = n((waitFor) => {
+                var t = Util.clone(ctx.supportData[ticket]);
+                getContent(ctx, {
+                    channel: ticket,
+                    curvePublic: t.curvePublic
+                }, false, waitFor((err, messages) => {
+                    if (err) {
+                        if (err.type === 'EDELETED') {
+                            delete ctx.supportData[ticket];
+                            return;
+                        }
+                        t.error = err;
+                    } else {
+                        t.messages = messages;
+                        if (messages.length && messages[messages.length -1].close) {
+                            ctx.supportData[ticket].closed = true;
+                            t.closed = true;
+                        }
+                    }
+
+                    t.id = ticket;
+                    all.push(t);
+                }));
+            }).nThen;
+        });
+
+
+        n(() => {
+            all.sort((t1, t2) => {
+                if (t1.closed && t2.closed) { return t1.time - t2.time; }
+                if (t1.closed) { return 1; }
+                if (t2.closed) { return -1; }
+                return t1.time - t2.time;
+            });
+            cb({tickets: all});
+        });
+    };
+    var makeMyTicket = function (ctx, data, cId, cb) {
+        makeTicket(ctx, data, false, cb);
+    };
+    var replyMyTicket = function (ctx, data, cId, cb) {
+        replyTicket(ctx, data, false, (err) => {
+            if (err) { return void cb({error: err}); }
+            cb({sent: true});
+        });
+    };
+    var closeMyTicket = function (ctx, data, cId, cb) {
+        replyTicket(ctx, data, false, (err) => {
+            if (err) { return void cb({error: err}); }
+            cb({closed: true});
+        });
+    };
+    var deleteMyTicket = function (ctx, data, cId, cb) {
+        let support = ctx.supportData;
+        let channel = data.channel;
+        if (!support[channel] || !support[channel].closed) { return void cb({error: 'ENOTCLOSED'}); }
+        delete support[channel];
+        cb({deleted: true});
+    };
+
+    // MODERATOR COMMANDS
+
+    var listTicketsAdmin = function (ctx, data, cId, cb) {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        if (!ctx.clients[cId]) {
+            ctx.clients[cId] = {
+                admin: true
+            };
+        }
+        ctx.adminRdyEvt.reg(() => {
+            var doc = ctx.adminDoc.proxy;
+            if (data.type === 'pending') { return cb(Util.clone(doc.tickets.pending)); }
+            if (data.type === 'closed') { return cb(Util.clone(doc.tickets.closed)); }
+            cb(Util.clone(doc.tickets.active));
+        });
+    };
+
+    var loadTicketAdmin = function (ctx, data, cId, cb) {
+        let supportKey = data.supportKey;
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            // If this ticket was created with an older support key, use the old one
+            if (doc.oldKeys && doc.oldKeys[supportKey]) {
+                data.adminCurvePrivate = doc.oldKeys[supportKey].curvePrivate;
+            }
+
+            getContent(ctx, data, true, function (err, res) {
+                if (err) { return void cb({error: err}); }
+                var doc = ctx.adminDoc.proxy;
+                if (!Array.isArray(res) || !res.length) { return void cb(res); }
+
+                // Sort messages by server time
+                res.sort((t1, t2) => { return t1.time - t2.time; });
+                let last = res[res.length - 1];
+                let premium = res.some((msg) => {
+                    let curve = Util.find(msg, ['sender', 'curvePublic']);
+                    if (data.curvePublic !== curve) { return; }
+                    return Util.find(msg, ['sender', 'quota', 'plan']);
+                });
+
+                // Update ChainPad with latest ticket data
+                var entry = doc.tickets.active[data.channel];
+                if (entry) {
+                    if (last.legacy) {
+                        let lastMsg = Array.isArray(last.messages)
+                                    && last.messages[last.messages.length - 1];
+                        last = lastMsg;
+                    }
+                    entry.time = last.time;
+                    entry.premium = premium;
+                    if (last.sender) {
+                        entry.lastAdmin = !last.sender.blockLocation;
+                    }
+                    /*
+                    let senderKey = last.sender && last.sender.edPublic;
+                    if (senderKey) {
+                        entry.lastAdmin = ctx.moderatorKeys.indexOf(senderKey) !== -1;
+                    }
+                    */
+                }
+                cb(res);
+            });
+        });
+    };
+
+    var makeTicketAdmin = function (ctx, data, cId, cb) {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        ctx.adminRdyEvt.reg(() => {
+            makeTicket(ctx, data, true, cb);
+        });
+    };
+
+    var replyTicketAdmin = function (ctx, data, cId, cb) {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        let supportKey = data.supportKey;
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            // If this ticket was created with an older support key, use the old one
+            if (doc.oldKeys && doc.oldKeys[supportKey]) {
+                data.adminCurvePrivate = doc.oldKeys[supportKey].curvePrivate;
+            }
+            replyTicket(ctx, data, true, (err, time) => {
+                if (err) { return void cb({error: err}); }
+                var doc = ctx.adminDoc.proxy;
+                var entry = doc.tickets.active[data.channel] || doc.tickets.pending[data.channel];
+                entry.time = time;
+                entry.lastAdmin = true;
+                cb({sent: true});
+            });
+        });
+    };
+
+    var closeTicketAdmin = function (ctx, data, cId, cb) {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        // Reply with `data.ticket.close = true`
+        let supportKey = data.supportKey;
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            // If this ticket was created with an older support key, use the old one
+            if (doc.oldKeys && doc.oldKeys[supportKey]) {
+                data.adminCurvePrivate = doc.oldKeys[supportKey].curvePrivate;
+            }
+            replyTicket(ctx, data, true, (err) => {
+                if (err) { return void cb({error: err}); }
+                var doc = ctx.adminDoc.proxy;
+                var entry = doc.tickets.active[data.channel] || doc.tickets.pending[data.channel];
+                entry.time = +new Date();
+                entry.lastAdmin = true;
+                doc.tickets.closed[data.channel] = entry;
+                delete doc.tickets.active[data.channel];
+                delete doc.tickets.pending[data.channel];
+                cb({closed: true});
+            });
+        });
+    };
+
+    var moveTicketAdmin = function (ctx, data, cId, cb) {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        let ticketId = data.channel;
+        let from = data.from;
+        let to = data.to;
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            let fromDoc = doc.tickets[from];
+            let toDoc = doc.tickets[to];
+            if (!from || !to) { return void cb({ error: 'EINVAL' }); }
+            let ticket = fromDoc[ticketId];
+            if (!ticket || toDoc[ticketId]) { return void cb({ error: 'CANT_MOVE' }); }
+            toDoc[ticketId] = ticket;
+            delete fromDoc[ticketId];
+            Realtime.whenRealtimeSyncs(ctx.adminDoc.realtime, function () {
+                cb({ moved: true });
+            });
+        });
+    };
+
+    var getRecorded = function (ctx, data, cId, cb) {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            let recorded = doc.recorded = doc.recorded || {};
+            cb({messages: Util.clone(recorded)});
+        });
+    };
+    var setRecorded = function (ctx, data, cId, cb) {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        let id = data.id;
+        let content = data.content;
+        let remove = Boolean(data.remove);
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            let recorded = doc.recorded = doc.recorded || {};
+            if (remove) {
+                delete recorded[id];
+            } else {
+                recorded[id] = {
+                    content,
+                    count: 0
+                };
+            }
+            Realtime.whenRealtimeSyncs(ctx.adminDoc.realtime, function () {
+                cb({done:true});
+            });
+        });
+    };
+    var useRecorded = function (ctx, data, cId, cb) {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        let id = data.id;
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            let recorded = doc.recorded = doc.recorded || {};
+            let entry = recorded[id];
+            if (entry) {
+                entry.count = (entry.count || 0) + 1;
+            }
+            cb();
+        });
+    };
+
+    var searchAdmin = (ctx, data, cId, cb) => {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        let tags = data.tags || [];
+        let text = (data.text || '').toLowerCase();
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            let t = doc.tickets;
+
+            let all = {};
+            let add = (id, data, category) => {
+                let clone = Util.clone(data);
+                clone.category = category;
+                all[id] = clone;
+            };
+            ['active', 'pending', 'closed'].some(cat => {
+                let tickets = t[cat];
+                return Object.keys(tickets).some(id => {
+                    let ticket = tickets[id];
+                    // Check if this ticket uses at least one selected tag
+                    let hasTag = !tags.length || (ticket.tags || []).some(tag => {
+                        return tags.includes(tag);
+                    });
+                    if (!hasTag) { return; }
+                    // Filter by searched text within these tags
+                    let id64 = Util.hexToBase64(id).slice(0,10);
+                    if (text === id64) { // If ticket ID found, stop search and return result
+                        all = {};
+                        add(id, ticket, cat);
+                        return true;
+                    }
+                    let hasText = !text || ticket.title.toLowerCase().includes(text);
+                    if (!hasText) { return; }
+                    add(id, ticket, cat);
+                });
+            });
+            cb({ tickets: all });
+        });
+    };
+    var setTagsAdmin = (ctx, data, cId, cb) => {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            let t = doc.tickets;
+            let chan = data.channel;
+
+            let ticket = t.active[chan] || t.pending[chan] || t.closed[chan];
+            ticket.tags = data.tags || [];
+            Realtime.whenRealtimeSyncs(ctx.adminDoc.realtime, function () {
+                let allTags = [];
+                ['active', 'pending', 'closed'].forEach(cat => {
+                    let tickets = t[cat];
+                    Object.keys(tickets).forEach(id => {
+                        let ticket = tickets[id];
+                        (ticket.tags || []).forEach(tag => {
+                            if (!allTags.includes(tag)) { allTags.push(tag); }
+                        });
+                    });
+                });
+                cb({done:true, allTags});
+            });
+        });
+    };
+    var filterTagsAdmin = (ctx, data, cId, cb) => {
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        let tags = data.tags || [];
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            let t = doc.tickets;
+
+            if (!tags.length) { return void cb({ all: true }); }
+            let all = [];
+            ['active', 'pending', 'closed'].forEach(cat => {
+                let tickets = t[cat];
+                Object.keys(tickets).forEach(id => {
+                    let ticket = tickets[id];
+                    // Check if this ticket uses at least one selected tag
+                    let hasTag = (ticket.tags || []).some(tag => {
+                        return tags.includes(tag);
+                    });
+                    if (!hasTag) { all.push(id); }
+                });
+            });
+            cb({ tickets: all });
+        });
+    };
+
+    var clearLegacy = function (ctx, data, cId, cb) {
+        let proxy = ctx.store.proxy;
+        ctx.store.mailbox.close('supportadmin', function () {
+            delete proxy.mailboxes.supportadmin;
+            ctx.Store.onSync(null, function () {
+                cb({done: true});
+            });
+        });
+    };
+
+    var dumpLegacy = function (ctx, data, cId, cb) {
+        let proxy = ctx.store.proxy;
+        let _legacy = Util.find(proxy, ['mailboxes', 'supportadmin']);
+        if (!_legacy) { return void cb({error: 'ENOENT'}); }
+        let legacy = Util.clone(_legacy);
+        legacy.lastKnownHash = undefined;
+        legacy.viewed = [];
+        ctx.store.mailbox.open('supportadmin', legacy, function (contentByHash) {
+            ctx.store.mailbox.close('supportadmin', function () {});
+            cb(contentByHash);
+        }, true, { // Opts
+            dump: true
+        });
+    };
+    let findLegacy = (ctx, author, title) => {
+        let doc = ctx.adminDoc.proxy;
+        return ['active', 'pending', 'closed'].some(k => {
+            let all = doc.tickets[k];
+            return Object.keys(all).some(id => {
+                let ticket = all[id];
+                return ticket.authorKey === author && ticket.title === title && ticket.restored;
+            });
+        });
+    };
+    var getLegacy = function (ctx, data, cId, cb) {
+        let proxy = ctx.store.proxy;
+        let legacy = Util.find(proxy, ['mailboxes', 'supportadmin']);
+        if (!legacy) { return void cb({error: 'ENOENT'}); }
+        ctx.store.mailbox.open('supportadmin', legacy, function (contentByHash) {
+            ctx.store.mailbox.close('supportadmin', function () {});
+            let c = Util.clone(contentByHash || {});
+            let toFilter = [];
+            Object.keys(c).forEach(h => {
+                let msg = c[h];
+                if (msg.type === 'CLOSE') {
+                    if (!toFilter.includes(msg.content.id)) {
+                        toFilter.push(msg.content.id);
+                    }
+                    return;
+                }
+                let author = msg.author;
+                let title = msg.content && msg.content.title;
+                if (findLegacy(ctx, author, title)) {
+                    if (!toFilter.includes(msg.content.id)) {
+                        toFilter.push(msg.content.id);
+                    }
+                }
+            });
+            Object.keys(c).forEach(h => {
+                let msg = c[h];
+                if (msg.content && toFilter.includes(msg.content.id)) {
+                    delete c[h];
+                }
+            });
+            cb(c);
+        }, true, { // Opts
+            dump: true
+        });
+    };
+    var restoreLegacy = function (ctx, data, cId, cb) {
+        let proxy = ctx.store.proxy;
+        let legacy = Util.find(proxy, ['mailboxes', 'supportadmin']);
+        if (!legacy) { return void cb({error: 'ENOENT'}); }
+        if (!ctx.adminRdyEvt) { return void cb({ error: 'EFORBIDDEN' }); }
+        let messages = data.messages;
+        let hashes = data.hashes;
+        let first = messages[0];
+        let last = messages[messages.length - 1];
+        if (!first) { return void cb({error: 'EINVAL'}); }
+        ctx.adminRdyEvt.reg(() => {
+            let ticketData = {
+                name: Util.find(first, ['sender', 'name']),
+                notifications: Util.find(first, ['sender', 'notifications']),
+                curvePublic: Util.find(first, ['sender', 'curvePublic']),
+                channel: Hash.createChannelId(),
+                title: first.title,
+                time: last.time,
+                ticket: {
+                    legacy: true,
+                    title: first.title,
+                    sender: first.sender,
+                    messages: messages
+                }
+            };
+            makeTicket(ctx, ticketData, true, obj => {
+                if (obj && obj.error) { return void cb(obj); }
+                hashes.forEach(hash => {
+                    legacy.viewed.push(hash);
+                });
+                ctx.Store.onSync(null, function () {
+                    cb({done: true});
+                });
+            });
+        });
+    };
+
+    // Mailbox events
+
+    var addAdminTicket = function (ctx, data, cb) {
+        // Wait for the chainpad to be ready before adding the data
+        if (!ctx.adminRdyEvt) { return void cb(true); }
+
+        ctx.adminRdyEvt.reg(() => {
+            let supportKey;
+            nThen((waitFor) => {
+                // Send ticket to the admins and call back
+                getKeys(ctx, true, data, waitFor((err, obj) => {
+                    if (err) {
+                        waitFor.abort();
+                        return void cb(true);
+                    }
+                    supportKey = obj.supportKey;
+                }));
+            }).nThen(() => {
+                // random timeout to avoid duplication wiht multiple admins
+                var rdmTo = Math.floor(Math.random() * 2000); // Between 0 and 2000ms
+                setTimeout(() => {
+                    var doc = ctx.adminDoc.proxy;
+                    if (doc.tickets.active[data.channel] || doc.tickets.closed[data.channel]
+                        || doc.tickets.pending[data.channel]) {
+                        return void cb(true); }
+                    doc.tickets.active[data.channel] = {
+                        title: data.title,
+                        premium: data.premium,
+                        time: data.time,
+                        author: data.user && data.user.displayName,
+                        supportKey: data.supportKey || supportKey, // Store current support key
+                        authorKey: data.user && data.user.curvePublic
+                    };
+                    Realtime.whenRealtimeSyncs(ctx.adminDoc.realtime, function () {
+                        // Call back only when synced. That way we can handle the mailbox message
+                        // later in case of network issues.
+                        cb(true);
+                    });
+                    notifyClient(ctx, true, 'NEW_TICKET', data.channel);
+                    if (ctx.supportRpc) { ctx.supportRpc.pin([data.channel], () => {}); }
+                }, rdmTo);
+            });
+        });
+    };
+    var updateAdminTicket = function (ctx, data) {
+        // Wait for the chainpad to be ready before adding the data
+        if (!ctx.adminRdyEvt) { return; }
+
+        ctx.adminRdyEvt.reg(() => {
+            // random timeout to avoid duplication wiht multiple admins
+            var rdmTo = Math.floor(Math.random() * 2000); // Between 0 and 2000ms
+            setTimeout(() => {
+                var doc = ctx.adminDoc.proxy;
+                let t = doc.tickets.active[data.channel] || doc.tickets.pending[data.channel];
+                if (!t) { return; }
+                if (data.time <= t.time) { return; }
+                if (data.isClose) {
+                    doc.tickets.closed[data.channel] = t;
+                    delete doc.tickets.active[data.channel];
+                    delete doc.tickets.pending[data.channel];
+                }
+
+                t.time = data.time;
+                t.lastAdmin = false;
+                notifyClient(ctx, true, 'UPDATE_TICKET', data.channel);
+            }, rdmTo);
+        });
+    };
+    var checkAdminTicket = function (ctx, data, cb) {
+        if (!ctx.adminRdyEvt) { return void cb(true); }
+
+        ctx.adminRdyEvt.reg(() => {
+            let doc = ctx.adminDoc.proxy;
+            let exists = doc.tickets.active[data.channel] || doc.tickets.pending[data.channel];
+            cb(exists);
+        });
+    };
+
+    var addUserTicket = function (ctx, data, cb) {
+        if (!ctx.supportData) { return void cb(true); }
+        let channel = data.channel;
+        ctx.supportData[channel] = {
+            time: data.time,
+            title: data.title,
+            curvePublic: data.supportKey // Old tickets still use previous keys
+        };
+        ctx.Store.onSync(null, function () {
+            cb(true);
+        });
+    };
+    var updateUserTicket = function (ctx, data) {
+        notifyClient(ctx, false, 'UPDATE_TICKET', data.channel);
+        if (data.isClose) {
+            let ticket = ctx.supportData[data.channel];
+            if (!ticket) { return; }
+            ticket.closed = true;
+        }
+    };
+
+    var updateAdminKey = (ctx, data, cb) => {
+        let newKey = data.supportKey;
+        let newKeyPub = Hash.getBoxPublicFromSecret(newKey);
+
+        let proxy = ctx.store.proxy;
+        const oldKey = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePrivate']);
+        const oldKeyPub = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePublic']);
+
+        getKeys(ctx, false, {}, (err, obj) => {
+            if (err) { return void cb(true); }
+            // already deprecated? abort
+            if (newKeyPub !== obj.theirPublic) { return void cb(true); }
+            // already known? abort
+            if (oldKey === newKey || oldKeyPub === newKeyPub) { return void cb(true); }
+
+            // Close old data
+            let mailbox = Util.find(ctx, [ 'store', 'mailbox' ]);
+            try {
+                if (ctx.adminDoc) { ctx.adminDoc.stop(); }
+                if (mailbox) { mailbox.close('supportteam'); }
+                if (ctx.supportRpc) { ctx.supportRpc.destroy(); }
+                ctx.adminRdyEvt = Util.mkEvent(true);
+            } catch (e) { console.error(e); }
+
+            // Store new key
+            ctx.Store.addAdminMailbox(null, {
+                version: 2,
+                priv: newKey
+            }, (obj) => {
+                if (obj && obj.error) { return void cb(true); }
+                // Reload moderator data
+                nThen((waitFor) => {
+                    initializeSupportAdmin(ctx, true, waitFor);
+                    ctx.adminRdyEvt.reg(() => {
+                        notifyClient(ctx, true, 'UPDATE_RIGHTS');
+                        cb(false);
+                    });
+                });
+            });
+        });
+    };
+
+
+    // ADMIN COMMANDS
+
+    let updateServerKey = (ctx, curvePublic, curvePrivate, cb) => {
+        let edPublic;
+        try {
+            let pair = Nacl.sign.keyPair.fromSeed(Nacl.util.decodeBase64(curvePrivate));
+            edPublic = Nacl.util.encodeBase64(pair.publicKey);
+        } catch (e) {
+            return void cb(e);
+        }
+        ctx.Store.adminRpc(null, {
+            cmd: 'ADMIN_DECREE',
+            data: ['SET_SUPPORT_KEYS', [curvePublic, edPublic]]
+        }, cb);
+    };
+    let getModerators = (ctx, data, cId, cb) => {
+        ctx.Store.adminRpc(null, {
+            cmd: 'GET_MODERATORS',
+            data: {}
+        }, cb);
+    };
+    let rotateKeys = function (ctx, data, cId, _cb) {
+        let cb = Util.once(Util.mkAsync(_cb));
+        let oldSupportKey;
+        let proxy = ctx.store.proxy;
+        let edPublic = proxy.edPublic;
+
+        const keyPair = Nacl.box.keyPair();
+        const newKeyPub = Nacl.util.encodeBase64(keyPair.publicKey);
+        const newKey = Nacl.util.encodeBase64(keyPair.secretKey);
+
+        const oldKey = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePrivate']);
+        const oldKeyPub = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePublic']);
+
+        if (!newKey || !newKeyPub) { return void cb({ error: 'INVALID_KEY' }); }
+        let oldAdminChan;
+        nThen((waitFor) => {
+            // Check if support was already enabled
+            getKeys(ctx, false, {}, waitFor((err, obj) => {
+                if (err === 'E_NOT_INIT') { return; } // We're going to set up a support key
+                if (err) {
+                    cb({error: err});
+                    return void waitFor.abort();
+                }
+                oldSupportKey = obj.theirPublic;
+            }));
+        }).nThen((waitFor) => {
+            // Only admins can rotate the keys
+            if (!ctx.adminKeys.includes(edPublic)) {
+                waitFor.abort();
+                return void cb({error: 'EFORBIDDEN'});
+            }
+        }).nThen((waitFor) => {
+            // If support is enabled, only current moderators can rotate keys.
+            // Other admins can only delete the support
+            if (!oldSupportKey) { return; } // support disabled
+            if (!ctx.moderatorKeys.includes(edPublic)) {
+                waitFor.abort();
+                return void cb({error: 'EINVAL'});
+            }
+            if (oldKeyPub !== oldSupportKey) {
+                waitFor.abort();
+                return void cb({error: 'EFORBIDDEN'});
+            }
+        }).nThen((waitFor) => {
+            // If support was enabled, migrate old chainpad
+            if (!oldSupportKey) { return; } // No old doc to copy
+            ctx.adminRdyEvt.reg(() => {
+                let oldDoc = ctx.adminDoc.proxy;
+                oldAdminChan = ctx.adminDoc.metadata && ctx.adminDoc.metadata.channel;
+
+                let seed = newKey.slice(0,24);
+                let hash = Hash.getEditHashFromKeys({
+                    version: 2,
+                    type: 'support',
+                    keys: {
+                        editKeyStr: seed
+                    }
+                });
+                let cfg = {
+                    network: ctx.store.network,
+                    initialState: '{}'
+                };
+                var oldKeys = oldDoc.oldKeys = oldDoc.oldKeys || {};
+                oldKeys[oldKeyPub] = {
+                    curvePrivate: oldKey,
+                    rotatedOn: +new Date(),
+                    rotatedBy: edPublic
+                };
+                Crypt.put(hash, JSON.stringify(oldDoc), waitFor((err) => {
+                    if (err) {
+                        waitFor.abort();
+                        return void cb({error: err});
+                    }
+                }), cfg);
+            });
+        }).nThen((waitFor) => {
+            // Send new key to server
+            updateServerKey(ctx, newKeyPub, newKey, waitFor((obj) => {
+                if (obj && obj.error) {
+                    waitFor.abort();
+                    return void cb(obj);
+                }
+            }));
+        }).nThen(() => {
+            // From now on, each error may cause issue because
+            // the server has already stored the new key
+
+            // Disconnect old doc and mailbox
+            if (!oldSupportKey) { return; } // support disabled
+
+            if (ctx.adminDoc) { ctx.adminDoc.stop(); }
+
+            let mailbox = Util.find(ctx, [ 'store', 'mailbox' ]);
+            if (mailbox) { mailbox.close('supportteam'); }
+
+            if (ctx.supportRpc) { ctx.supportRpc.destroy(); }
+
+            ctx.adminRdyEvt = Util.mkEvent(true);
+        }).nThen((waitFor) => {
+            // Add key to my proxy
+            ctx.Store.addAdminMailbox(null, {
+                version: 2,
+                priv: newKey
+            }, waitFor((obj) => {
+                if (obj && obj.error) { // Should never happen with the previous checks
+                    waitFor.abort();
+                    if (oldSupportKey) {
+                        // If we weren't able to store the new key, abort and restore old keys
+                        return updateServerKey(ctx, oldKeyPub, oldKey, () => {
+                            return void cb(obj);
+                        });
+                    }
+                    return void cb(obj);
+                }
+            }));
+        }).nThen((waitFor) => {
+            // Notify other moderators
+            if (!oldSupportKey) { return; }
+            let mailbox = Util.find(ctx, [ 'store', 'mailbox' ]);
+            getModerators(ctx, null, null, waitFor((obj) => {
+                if (obj && obj.error) {
+                    return void cb({
+                        success: true,
+                        noNotify: true
+                    });
+                }
+                let all = obj && obj[0];
+                Object.keys(all || {}).forEach((modEdPub) => {
+                    let modData = all[modEdPub];
+                    mailbox.sendTo('MODERATOR_NEW_KEY', {
+                        supportKey: newKey
+                    }, {
+                        channel: modData.mailbox,
+                        curvePublic: modData.curvePublic
+                    }, () => {});
+                });
+            }));
+        }).nThen((waitFor) => {
+            // Initialize new chainpad
+            initializeSupportAdmin(ctx, true, waitFor);
+        }).nThen((waitFor) => {
+            // Clean old data
+            if (!oldAdminChan) { return; }
+            ctx.Store.adminRpc(null, {
+                cmd: 'ARCHIVE_DOCUMENT',
+                data: {
+                    id: oldAdminChan,
+                    reason: 'Deprecated support pad'
+                }
+            }, waitFor());
+        }).nThen(() => {
+            // Call back
+            cb({success: true});
+        });
+    };
+    let disableSupport = function (ctx, data, cId, _cb) {
+        let cb = Util.once(Util.mkAsync(_cb));
+        let proxy = ctx.store.proxy;
+        let edPublic = proxy.edPublic;
+
+        let moderators;
+        nThen((waitFor) => {
+            // Check if support is enabled
+            // and update ctx.adminKeys
+            getKeys(ctx, false, {}, waitFor((err) => {
+                if (err) {
+                    cb({error: err});
+                    return void waitFor.abort();
+                }
+            }));
+        }).nThen((waitFor) => {
+            // Only admins can disable support
+            if (!ctx.adminKeys.includes(edPublic)) {
+                waitFor.abort();
+                return void cb({error: 'EFORBIDDEN'});
+            }
+        }).nThen((waitFor) => {
+            // Archive ChainPad and all the tickets (from pin log)
+            ctx.Store.adminRpc(null, {
+                cmd: 'ARCHIVE_SUPPORT',
+                data: {}
+            }, waitFor((obj) => {
+                if (obj && obj.error) {
+                    waitFor.abort();
+                    return void cb(obj);
+                }
+            }));
+        }).nThen((waitFor) => {
+            ctx.Store.adminRpc(null, {
+                cmd: 'ADMIN_DECREE',
+                data: ['SET_SUPPORT_KEYS', ['', '']]
+            }, waitFor(function (obj) {
+                if (obj && obj.error) {
+                    waitFor.abort();
+                    return void cb(obj);
+                }
+            }));
+        }).nThen((waitFor) => {
+            getModerators(ctx, null, null, waitFor((obj) => {
+                if (!obj || obj.error) {
+                    waitFor.abort();
+                    return void cb();
+                }
+                moderators = obj[0] || {};
+            }));
+        }).nThen(() => {
+            let n = nThen;
+            Object.keys(moderators).forEach((ed) => {
+                n = n((waitFor) => {
+                    ctx.Store.adminRpc(null, {
+                        cmd: 'REMOVE_MODERATOR',
+                        data: ed
+                    }, waitFor(obj => {
+                        if (obj && obj.error) {
+                            console.error('Error removing moderator data', ed, obj.error);
+                        }
+                    }));
+                }).nThen;
+            });
+            n(() => {
+                cb();
+            });
+        });
+    };
+
+    var getAdminKey = function (ctx, data, cId, cb) {
+        let proxy = ctx.store.proxy;
+        let supportKey = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePublic']);
+        let privateKey = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePrivate']);
+        getKeys(ctx, false, {}, (err, obj) => {
+            if (err) { return void cb({error: err}); }
+            if (supportKey && obj.theirPublic !== supportKey) {
+                privateKey = undefined;
+            }
+            cb({
+                curvePrivate: privateKey,
+                curvePublic: obj.theirPublic
+            });
+        });
+    };
+    var addModerator = function (ctx, data, cId, cb) {
+        let proxy = ctx.store.proxy;
+        var mailbox = Util.find(ctx, [ 'store', 'mailbox' ]);
+
+        let supportKey = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePublic']);
+        let privateKey = Util.find(proxy, ['mailboxes', 'supportteam', 'keys', 'curvePrivate']);
+        let lastKnownHash = Util.find(proxy, ['mailboxes', 'supportteam', 'lastKnownHash']);
+        let edPublic = proxy.edPublic;
+
+        // Confirm that I know the latest private key
+        getKeys(ctx, false, {}, (err, obj) => {
+            if (err) { return void cb({error: err}); }
+            if (obj.theirPublic !== supportKey) { return void cb({ error: 'EFORBIDDEN' }); }
+            if (!ctx.moderatorKeys.includes(edPublic)) { return void cb({ error: 'EFORBIDDEN' }); }
+            // Send this private key to the selected user
+            mailbox.sendTo('ADD_MODERATOR', {
+                supportKey: privateKey,
+                lastKnownHash
+            }, {
+                channel: data.mailbox,
+                curvePublic: data.curvePublic
+            }, () => {
+                cb();
+            });
+        });
+    };
+
+    Support.init = function (cfg, waitFor, emit) {
+        var support = {};
+
+        // Already initialized by a "noDrive" tab?
+        if (cfg.store && cfg.store.modules && cfg.store.modules['support']) {
+            return cfg.store.modules['support'];
+        }
+
+        var store = cfg.store;
+        var proxy = store.proxy.support = store.proxy.support || {};
+
+        var ctx = {
+            moderatorKeys: ApiConfig.moderatorKeys,
+            adminKeys: ApiConfig.adminKeys,
+            supportData: proxy,
+            store: cfg.store,
+            Store: cfg.Store,
+            emit: emit,
+            clients: {}
+        };
+
+        if (Util.find(store, ['proxy', 'mailboxes', 'supportteam'])) {
+            initializeSupportAdmin(ctx, false, waitFor);
+        }
+
+        support.ctx = ctx;
+        support.removeClient = function (clientId) {
+            delete ctx.clients[clientId];
+        };
+        support.leavePad = function () {};
+        support.addAdminTicket = function (content, cb) {
+            addAdminTicket(ctx, content, cb);
+        };
+        support.updateAdminTicket = function (content) {
+            updateAdminTicket(ctx, content);
+        };
+        support.updateAdminKey = function (content, cb) {
+            updateAdminKey(ctx, content, cb);
+        };
+        support.checkAdminTicket = function (content, cb) {
+            checkAdminTicket(ctx, content, cb);
+        };
+        support.addUserTicket = function (content, cb) {
+            addUserTicket(ctx, content, cb);
+        };
+        support.updateUserTicket = function (content) {
+            updateUserTicket(ctx, content);
+        };
+        support.execCommand = function (clientId, obj, cb) {
+            var cmd = obj.cmd;
+            var data = obj.data;
+            // User commands
+            if (cmd === 'MAKE_TICKET') {
+                return void makeMyTicket(ctx, data, clientId, cb);
+            }
+            if (cmd === 'GET_MY_TICKETS') {
+                return void getMyTickets(ctx, data, clientId, cb);
+            }
+            if (cmd === 'REPLY_TICKET') {
+                return void replyMyTicket(ctx, data, clientId, cb);
+            }
+            if (cmd === 'CLOSE_TICKET') {
+                return void closeMyTicket(ctx, data, clientId, cb);
+            }
+            if (cmd === 'DELETE_TICKET') {
+                return void deleteMyTicket(ctx, data, clientId, cb);
+            }
+            // Moderator commands
+            if (cmd === 'MAKE_TICKET_ADMIN') {
+                return void makeTicketAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'LIST_TICKETS_ADMIN') {
+                return void listTicketsAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'LOAD_TICKET_ADMIN') {
+                return void loadTicketAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'REPLY_TICKET_ADMIN') {
+                return void replyTicketAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'CLOSE_TICKET_ADMIN') {
+                return void closeTicketAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'MOVE_TICKET_ADMIN') {
+                return void moveTicketAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'GET_RECORDED') {
+                return void getRecorded(ctx, data, clientId, cb);
+            }
+            if (cmd === 'SET_RECORDED') {
+                return void setRecorded(ctx, data, clientId, cb);
+            }
+            if (cmd === 'USE_RECORDED') {
+                return void useRecorded(ctx, data, clientId, cb);
+            }
+            if (cmd === 'SEARCH_ADMIN') {
+                return void searchAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'FILTER_TAGS_ADMIN') {
+                return void filterTagsAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'SET_TAGS_ADMIN') {
+                return void setTagsAdmin(ctx, data, clientId, cb);
+            }
+            if (cmd === 'GET_LEGACY') {
+                return void getLegacy(ctx, data, clientId, cb);
+            }
+            if (cmd === 'DUMP_LEGACY') {
+                return void dumpLegacy(ctx, data, clientId, cb);
+            }
+            if (cmd === 'CLEAR_LEGACY') {
+                return void clearLegacy(ctx, data, clientId, cb);
+            }
+            if (cmd === 'RESTORE_LEGACY') {
+                return void restoreLegacy(ctx, data, clientId, cb);
+            }
+            // Admin commands
+            if (cmd === 'GET_PRIVATE_KEY') {
+                return void getAdminKey(ctx, data, clientId, cb);
+            }
+            if (cmd === 'DISABLE_SUPPORT') {
+                return void disableSupport(ctx, data, clientId, cb);
+            }
+            if (cmd === 'ROTATE_KEYS') {
+                return void rotateKeys(ctx, data, clientId, cb);
+            }
+            if (cmd === 'ADD_MODERATOR') {
+                return void addModerator(ctx, data, clientId, cb);
+            }
+            cb({error: 'NOT_SUPPORTED'});
+        };
+
+        return support;
+    };
+
+    return Support;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        undefined,
+        require('../../common/common-util'),
+        require('../../common/common-hash'),
+        require('../../common/common-realtime'),
+        require('../../common/pinpad'),
+        require('../../common/cryptget'),
+        require('nthen'),
+        require('chainpad-crypto'),
+        require('chainpad-listmap'),
+        require('chainpad'),
+        require('chainpad-netflux')
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/api/config',
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/common-realtime.js',
+        '/common/pinpad.js',
+        '/common/cryptget.js',
+        '/components/nthen/index.js',
+        '/components/chainpad-crypto/crypto.js',
+        'chainpad-listmap',
+        '/components/chainpad/chainpad.dist.js',
+        'chainpad-netflux'
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/modules/team.js b/src/worker/modules/team.js
new file mode 100644
index 000000000..3b9464995
--- /dev/null
+++ b/src/worker/modules/team.js
@@ -0,0 +1,2281 @@
+// SPDX-FileCopyrightText: 2023 XWiki CryptPad Team <contact@cryptpad.org> and contributors
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+(() => {
+const factory = (Util, Hash, Constants, Realtime, ProxyManager,
+                UserObject, SF, Roster, Messaging, Feedback,
+                Invite, Crypt, Cache, Listmap, Crypto,
+                CpNetflux, ChainPad, nThen, Saferphore, Nacl) => {
+    var Team = {};
+
+    Nacl = Nacl || (typeof(window) !== "undefined" && window.nacl);
+    var onStoreReady = Util.mkEvent(true);
+    var openCachedTeamChat = function () {}; // Placeholder
+
+    var registerChangeEvents = function (ctx, team, proxy, fId) {
+        if (!team) { return; }
+        if (!fId) {
+            // Listen for shared folder password change
+            proxy.on('change', ['drive', UserObject.SHARED_FOLDERS], function (o, n, p) {
+                if (p.length > 3 && p[3] === 'password') {
+                    var id = p[2];
+                    var data = proxy.drive[UserObject.SHARED_FOLDERS][id];
+                    var href = team.manager.user.userObject.getHref ?
+                            team.manager.user.userObject.getHref(data) : data.href;
+                    var parsed = Hash.parsePadUrl(href);
+                    var secret = Hash.getSecrets(parsed.type, parsed.hash, o);
+                    // We've received a new password, we should update it locally
+                    // NOTE: this is an async call because new password means new roHref!
+                    // We need to wait for the new roHref in the proxy before calling the handlers
+                    // because a read-only team will use it when connecting to the new channel
+                    setTimeout(function () {
+                        SF.updatePassword(ctx.Store, {
+                            oldChannel: secret.channel,
+                            password: n,
+                            href: href
+                        }, ctx.store.network, function () {
+                            console.log('Shared folder password changed');
+                        });
+                    });
+                    return false;
+                }
+            });
+            proxy.on('disconnect', function () {
+                team.offline = true;
+                team.sendEvent('NETWORK_DISCONNECT', team.id);
+            });
+            proxy.on('reconnect', function () {
+                team.offline = false;
+                team.sendEvent('NETWORK_RECONNECT', team.id);
+            });
+        }
+        proxy.on('change', [], function (o, n, p) {
+            if (fId) {
+                // Pin the new pads
+                if (p[0] === UserObject.FILES_DATA && typeof(n) === "object" && n.channel && !n.owners) {
+                    var toPin = [n.channel];
+                    // Also pin the onlyoffice channels if they exist
+                    if (n.rtChannel) { toPin.push(n.rtChannel); }
+                    if (n.lastVersion) { toPin.push(n.lastVersion); }
+                    team.pin(toPin, function (obj) {
+                        if (obj && obj.error) { console.error(obj.error); }
+                    });
+                }
+                // Unpin the deleted pads (deleted <=> changed to undefined)
+                if (p[0] === UserObject.FILES_DATA && typeof(o) === "object" && o.channel && !n) {
+                    var toUnpin = [o.channel];
+                    var c = team.manager.findChannel(o.channel);
+                    var exists = c.some(function (data) {
+                        return data.fId !== fId;
+                    });
+                    if (!exists) { // Unpin
+                        // Also unpin the onlyoffice channels if they exist
+                        if (o.rtChannel) { toUnpin.push(o.rtChannel); }
+                        if (o.lastVersion) { toUnpin.push(o.lastVersion); }
+                        team.unpin(toUnpin, function (obj) {
+                            if (obj && obj.error) { console.error(obj); }
+                        });
+                    }
+                }
+            }
+            if (o && !n && Array.isArray(p) && (p[0] === UserObject.FILES_DATA ||
+                (p[0] === 'drive' && p[1] === UserObject.FILES_DATA))) {
+                setTimeout(function () {
+                    ctx.Store.checkDeletedPad(o && o.channel);
+                });
+            }
+            team.sendEvent('DRIVE_CHANGE', {
+                id: fId,
+                old: o,
+                new: n,
+                path: p
+            });
+        });
+        proxy.on('remove', [], function (o, p) {
+            team.sendEvent('DRIVE_REMOVE', {
+                id: fId,
+                old: o,
+                path: p
+            });
+        });
+    };
+
+    var closeTeam = function (ctx, teamId) {
+        var team = ctx.teams[teamId];
+        if (!team) { return; }
+        try { team.listmap.stop(); } catch (e) {}
+        try { team.roster.stop(); } catch (e) {}
+        team.proxy = {};
+        team.stopped = true;
+        delete ctx.teams[teamId];
+        delete ctx.cache[teamId];
+        delete ctx.store.proxy.teams[teamId];
+        ctx.emit('LEAVE_TEAM', teamId, team.clients);
+        ctx.updateMetadata();
+        if (ctx.store.calendar) {
+            ctx.store.calendar.closeTeam(teamId);
+        }
+        if (ctx.store.mailbox) {
+            ctx.store.mailbox.close('team-'+teamId, function () {
+                // Close team mailbox
+            });
+        }
+    };
+
+    var getTeamChannelList = function (ctx, id) {
+        // Get the list of pads' channel ID in your drive
+        // This list is filtered so that it doesn't include pad owned by other users
+        // It now includes channels from shared folders
+        var store = ctx.teams[id];
+        if (!store) { return null; }
+        var list = store.manager.getChannelsList('pin');
+
+        var team = ctx.store.proxy.teams[id];
+        list.push(`${team.channel}#drive`);
+        var chatChannel = Util.find(team, ['keys', 'chat', 'channel']);
+        var membersChannel = Util.find(team, ['keys', 'roster', 'channel']);
+        var mailboxChannel = Util.find(team, ['keys', 'mailbox', 'channel']);
+        if (chatChannel) { list.push(chatChannel); }
+        if (membersChannel) { list.push(membersChannel); }
+        if (mailboxChannel) { list.push(mailboxChannel); }
+
+        if (store.proxy.calendars) {
+            var cList = Object.keys(store.proxy.calendars).map(function (c) {
+                return store.proxy.calendars[c].channel;
+            });
+            list = list.concat(cList);
+        }
+
+        var state = store.roster.getState();
+        if (state.members) {
+            Object.keys(state.members).forEach(function (curve) {
+                var m = state.members[curve];
+                if (m.inviteChannel && m.pending) { list.push(m.inviteChannel); }
+                if (m.previewChannel && m.pending) { list.push(m.previewChannel); }
+            });
+        }
+
+        list.sort();
+        return list;
+    };
+
+    var handleSharedFolder = function (ctx, id, sfId, rt) {
+        var t = ctx.teams[id];
+        if (!t) { return; }
+        if (!rt) {
+            delete t.sharedFolders[sfId];
+            return;
+        }
+        t.sharedFolders[sfId] = rt;
+        registerChangeEvents(ctx, t, rt.proxy, sfId);
+    };
+
+    var initRpc = function (ctx, team, data, cb) {
+        if (team.rpc) { return void cb(); }
+        if (!data.edPrivate || !data.edPublic) { return void cb('EFORBIDDEN'); }
+        require(['/common/pinpad.js'], function (Pinpad) {
+            Pinpad.create(ctx.store.network, data, function (e, call) {
+                if (e) { return void cb(e); }
+                team.rpc = call;
+                if (team && team.onRpcReadyEvt) { team.onRpcReadyEvt.fire(); }
+                cb();
+            }, Cache);
+        });
+    };
+
+    var onCacheReady = function (ctx, id, lm, roster, keys, cId, _cb) {
+        var cb = Util.once(Util.mkAsync(_cb));
+        if (ctx.cache[id]) { return void cb(); }
+        var proxy = lm.proxy;
+        var team = {
+            id: id,
+            proxy: proxy,
+            listmap: lm,
+            clients: [],
+            realtime: lm.realtime,
+            handleSharedFolder: function (sfId, rt) { handleSharedFolder(ctx, id, sfId, rt); },
+            sharedFolders: {}, // equivalent of store.sharedFolders in async-store
+            roster: roster,
+            onRpcReadyEvt: Util.mkEvent(true),
+            offline: true
+        };
+        ctx.cache[id] = team;
+
+        // Subscribe to events
+        if (cId) { team.clients.push(cId); }
+
+        // Listen for roster changes
+        roster.on('change', function () {
+            var state = roster.getState();
+            var me = Util.find(ctx, ['store', 'proxy', 'curvePublic']);
+            if (!state.members || !Object.keys(state.members).length) {
+                // invalid roster, don't leave the team
+                console.error(JSON.stringify(state));
+                return;
+            }
+            if (!state.members[me]) {
+                return void closeTeam(ctx, id);
+            }
+            var teamData = Util.find(ctx, ['store', 'proxy', 'teams', id]);
+            if (teamData) { teamData.metadata = state.metadata; }
+            ctx.updateMetadata();
+            ctx.emit('ROSTER_CHANGE', id, team.clients);
+        });
+        roster.on('checkpoint', function (hash) {
+            var rosterData = Util.find(ctx, ['store', 'proxy', 'teams', id, 'keys', 'roster']);
+            rosterData.lastKnownHash = hash;
+        });
+
+        // Broadcast an event to all the tabs displaying this team
+        team.sendEvent = function (q, data, sender) {
+            ctx.emit(q, data, team.clients.filter(function (cId) {
+                return cId !== sender;
+            }));
+        };
+
+        // Provide team chat keys to the messenger app
+        team.getChatData = function () {
+            var chatKeys = keys.chat || {};
+            var hash = chatKeys.edit || chatKeys.view;
+            if (!hash) { return {}; }
+            var secret = Hash.getSecrets('chat', hash);
+            return {
+                teamId: id,
+                channel: secret.channel,
+                secret: secret,
+                validateKey: chatKeys.validateKey
+            };
+        };
+
+        team.pin = function (data, cb) {
+            if (!keys.drive.edPrivate) { return void cb({error: 'EFORBIDDEN'}); }
+            if (!team.rpc) { return void cb({error: 'TEAM_RPC_NOT_READY'}); }
+            if (typeof(cb) !== 'function') { console.error('expected a callback'); }
+            team.rpc.pin(data, function (e, hash) {
+                if (e) { return void cb({error: e}); }
+                cb({hash: hash});
+            });
+        };
+        team.unpin = function (data, cb) {
+            if (!keys.drive.edPrivate) { return void cb({error: 'EFORBIDDEN'}); }
+            if (!team.rpc) { return void cb({error: 'TEAM_RPC_NOT_READY'}); }
+            if (typeof(cb) !== 'function') { console.error('expected a callback'); }
+            team.rpc.unpin(data, function (e, hash) {
+                if (e) { return void cb({error: e}); }
+                cb({hash: hash});
+            });
+        };
+
+        // Create the proxy manager
+        var loadSharedFolder = function (id, data, cb, isNew) {
+            SF.load({
+                isNew: isNew,
+                network: ctx.store.network || ctx.store.networkPromise,
+                store: team,
+                isNewChannel: ctx.Store.isNewChannel,
+                Store: ctx.Store
+            }, id, data, cb);
+        };
+        var teamData = ctx.store.proxy.teams[team.id];
+        var hash = teamData.hash || teamData.roHash;
+        var secret = Hash.getSecrets('team', hash, teamData.password);
+        var manager = team.manager = ProxyManager.create(proxy.drive, {
+            onSync: function (cb) { ctx.Store.onSync(id, cb); },
+            edPublic: keys.drive.edPublic,
+            pin: team.pin,
+            unpin: team.unpin,
+            loadSharedFolder: loadSharedFolder,
+            settings: {
+                drive: Util.find(ctx.store, ['proxy', 'settings', 'drive'])
+            },
+            removeOwnedChannel: function (channel, cb) {
+                var data;
+                if (typeof(channel) === "object") {
+                    channel.teamId = id;
+                    data = channel;
+                } else {
+                    data = {
+                        channel: channel,
+                        teamId: id
+                    };
+                }
+                ctx.Store.removeOwnedChannel('', data, cb);
+            },
+            Store: ctx.Store,
+            store: ctx.store
+        }, {
+            teamId: team.id,
+            outer: true,
+            edPublic: keys.drive.edPublic,
+            loggedIn: true,
+            log: function (msg) {
+                // broadcast to all drive apps
+                team.sendEvent("DRIVE_LOG", msg);
+            },
+            rt: team.realtime,
+            editKey: secret.keys.secondaryKey,
+            readOnly: Boolean(!secret.keys.secondaryKey)
+        });
+        team.secondaryKey = secret && secret.keys.secondaryKey;
+        team.userObject = manager.user.userObject;
+
+        nThen(function (waitFor) {
+            // Load the shared folders
+            ctx.teams[id] = team;
+            registerChangeEvents(ctx, team, proxy);
+            var network = ctx.store.network || ctx.store.networkPromise;
+            SF.loadSharedFolders(ctx.Store, network, team,
+                                team.userObject, waitFor, function (data) {
+                ctx.progress += 70/(ctx.numberOfTeams * data.max);
+                ctx.updateProgress({
+                    progress: ctx.progress
+                });
+            }, true);
+        }).nThen(function () {
+            if (ctx.store.modules.calendar) { ctx.store.modules.calendar.openTeam(id); }
+            cb();
+        });
+    };
+
+    var onReady = function (ctx, id, lm, roster, keys, cId, cb) {
+        // Update metadata
+        var state = roster.getState();
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', id]);
+        if (teamData) { teamData.metadata = state.metadata; }
+
+        var team;
+        if (!ctx.store.proxy.teams[id]) { return; }
+        nThen(function (waitFor) {
+            onCacheReady(ctx, id, lm, roster, keys, cId, waitFor());
+            team = ctx.teams[id] || ctx.cache[id];
+
+            // Init Team RPC
+            if (!keys.drive.edPrivate) { return; }
+            initRpc(ctx, team, keys.drive, waitFor(function () {}));
+        }).nThen(function (waitFor) {
+            // Load the shared folders
+            team.userObject.fixFiles();
+            SF.checkMigration(team.secondaryKey, team.proxy, team.userObject, waitFor());
+            SF.loadSharedFolders(ctx.Store, ctx.store.network, team,
+                                team.userObject, waitFor, function (data) {
+                ctx.progress += 70/(ctx.numberOfTeams * data.max);
+                ctx.updateProgress({
+                    progress: ctx.progress
+                });
+            });
+        }).nThen(function () {
+            if (!team.rpc) { return; }
+            var list = getTeamChannelList(ctx, id);
+            var local = Hash.hashChannelList(list);
+            // Check pin list
+            team.rpc.getServerHash(function (e, hash) {
+                if (e) { return void console.warn(e); }
+                if (hash !== local) {
+                    // Reset pin list
+                    team.rpc.reset(list, function (e/*, hash*/) {
+                        if (e) { console.warn(e); }
+                    });
+                }
+            });
+        }).nThen(function () {
+            team.offline = false;
+            if (ctx.onReadyHandlers[id]) {
+                ctx.onReadyHandlers[id].forEach(function (obj) {
+                    // Callback and subscribe the client to new notifications
+                    if (typeof (obj.cb) === "function") { obj.cb(); }
+                    if (!obj.cId) { return; }
+                    var idx = team.clients.indexOf(obj.cId);
+                    if (idx === -1) {
+                        team.clients.push(obj.cId);
+                    }
+                });
+            }
+            delete ctx.onReadyHandlers[id];
+            if (ctx.store.modules.calendar) { ctx.store.modules.calendar.openTeam(id); }
+            cb();
+        });
+
+    };
+
+    var checkTeamChannels = function (ctx, id, channel, roster, waitFor, cb) {
+        var close = function () {
+            if (ctx.cache[id] || ctx.teams[id]) { closeTeam(ctx, id); }
+            delete ctx.store.proxy.teams[id];
+            delete ctx.onReadyHandlers[id];
+            waitFor.abort();
+            cb({error: 'ENOENT'});
+        };
+        if (channel) {
+            ctx.store.anon_rpc.send("IS_NEW_CHANNEL", channel, waitFor(function (e, res) {
+                if (res && res.length && typeof(res[0]) === 'object' && res[0].isNew) {
+                    // Channel is empty: remove this team
+                    close();
+                }
+            }));
+        }
+        if (roster) {
+            ctx.store.anon_rpc.send("IS_NEW_CHANNEL", roster, waitFor(function (e, res) {
+                if (res && res.length && typeof(res[0]) === 'object' && res[0].isNew) {
+                    // Channel is empty: remove this team
+                    close();
+                }
+            }));
+        }
+    };
+
+    // Progress:
+    // One team = (30/(#teams))%
+    // One shared folder = (70/(#teams * #folders))%
+    var openChannel = function (ctx, teamData, id, _cb, cache) {
+        var cb = Util.once(Util.mkAsync(_cb));
+
+        var hash = teamData.hash || teamData.roHash;
+        var secret = Hash.getSecrets('team', hash, teamData.password);
+        var crypto = Crypto.createEncryptor(secret.keys);
+
+        if (!teamData.roHash) {
+            teamData.roHash = Hash.getViewHashFromKeys(secret);
+        }
+
+        var keys = teamData.keys;
+        if (!keys.chat.validateKey && keys.chat.edit) {
+            var chatSecret = Hash.getSecrets('chat', keys.chat.edit);
+            keys.chat.validateKey = chatSecret.keys.validateKey;
+        }
+
+
+        var roster;
+        var lm;
+
+        // Roster keys
+        var myKeys = {
+            curvePublic: ctx.store.proxy.curvePublic,
+            curvePrivate: ctx.store.proxy.curvePrivate
+        };
+        var rosterData = keys.roster || {};
+        var rosterKeys = rosterData.edit ? Crypto.Team.deriveMemberKeys(rosterData.edit, myKeys)
+                                        : Crypto.Team.deriveGuestKeys(rosterData.view || '');
+
+        nThen(function (waitFor) {
+            if (cache) {
+                // If we're in cache mode, make sure we have a cache for this team
+                Cache.getChannelCache(secret.channel, waitFor(function (err, obj) {
+                    var c = obj && obj.c; // content
+                    if (!c) {
+                        waitFor.abort();
+                        cb({error: 'NOCACHE_DRIVE'});
+                    }
+                }));
+                Cache.getChannelCache(rosterKeys.channel, waitFor(function (err, obj) {
+                    var c = obj && obj.c; // content
+                    var k = obj && obj.k;
+                    if (k && !rosterKeys.teamEdPublic) {
+                        rosterKeys.teamEdPublic = k;
+                    }
+                    if (!c) {
+                        waitFor.abort();
+                        cb({error: 'NOCACHE_ROSTER'});
+                    }
+                }));
+                return;
+            }
+            checkTeamChannels(ctx, id, secret.channel, rosterKeys.channel, waitFor, cb);
+        }).nThen(function (waitFor) {
+            var cacheRdy = {
+                lm: false,
+                roster: false,
+                check: function () {
+                    if (!this.lm || !this.roster) { return; }
+                    if (!cache) { return; }
+                    // Both are cacheready!
+                    ctx.progress += 30/ctx.numberOfTeams;
+                    ctx.updateProgress({
+                        progress: ctx.progress
+                    });
+                    onCacheReady(ctx, id, lm, roster, keys, null, waitFor(cb));
+                    this.check = function () {};
+                }
+            };
+
+            // Load the proxy
+            var cfg = {
+                data: {},
+                readOnly: !Boolean(secret.keys.signKey),
+                network: ctx.store.network || ctx.store.networkPromise,
+                channel: secret.channel,
+                crypto: crypto,
+                ChainPad: ChainPad,
+                Cache: Cache,
+                metadata: {
+                    validateKey: secret.keys.validateKey || undefined,
+                },
+                userName: 'team',
+                classic: true
+            };
+            cfg.onMetadataUpdate = function () {
+                var team = ctx.teams[id];
+                if (!team) { return; }
+                ctx.emit('ROSTER_CHANGE', id, team.clients);
+            };
+            lm = Listmap.create(cfg);
+            lm.proxy.on('cacheready', function () {
+                cacheRdy.lm = true;
+                cacheRdy.check();
+            });
+            lm.proxy.on('ready', waitFor());
+            lm.proxy.on('error', function (info) {
+                if (info && typeof (info.loaded) !== "undefined"  && !info.loaded) {
+                    cb({error:'ECONNECT'});
+                }
+                if (info && info.error) {
+                    if (info.error === "EDELETED" ) {
+                        closeTeam(ctx, id);
+                    }
+                }
+            });
+
+            // Load the roster
+            Roster.create({
+                network: ctx.store.network || ctx.store.networkPromise,
+                channel: rosterKeys.channel,
+                keys: rosterKeys,
+                store: ctx.store,
+                lastKnownHash: rosterData.lastKnownHash,
+                onCacheReady: function (_roster) {
+                    if (!cache) { return; }
+                    if (_roster && _roster.error === "CORRUPTED") {
+                        console.error('Corrupted roster cache, cant load this team offline', teamData);
+                        if (lm && typeof(lm.stop) === "function") { lm.stop(); }
+                        waitFor.abort();
+                        cb({error: 'CACHE_CORRUPTED_ROSTER'});
+                        return;
+                    }
+                    roster = _roster;
+                    cacheRdy.roster = true;
+                    cacheRdy.check();
+                },
+                Cache: Cache
+            }, waitFor(function (err, _roster) {
+                if (err) {
+                    waitFor.abort();
+                    console.error(err);
+                    return void cb({error: 'ROSTER_ERROR'});
+                }
+                roster = _roster;
+
+                rosterData.lastKnownHash = roster.getLastCheckpointHash();
+
+                // If we've been kicked, don't try to update our data, we'll close everything
+                // in the next nThen part
+                var state = roster.getState();
+                var me = Util.find(ctx, ['store', 'proxy', 'curvePublic']);
+                if (!state.members[me]) { return; }
+
+                onStoreReady.reg(function () {
+                    // If you're allowed to edit the roster, try to update your data
+                    if (!rosterData.edit) { return; }
+                    var data = {};
+                    var myData = Messaging.createData(ctx.store.proxy, false);
+                    myData.pending = false;
+                    data[ctx.store.proxy.curvePublic] = myData;
+                    roster.describe(data, function (err) {
+                        if (!err) { return; }
+                        if (err === 'NO_CHANGE') { return; }
+                        console.error(err);
+                    });
+                });
+            }));
+        }).nThen(function (waitFor) {
+            // Make sure we have not been kicked from the roster
+            var state = roster.getState();
+            var me = Util.find(ctx, ['store', 'proxy', 'curvePublic']);
+            // FIXME roster history temporarily corrupted, don't leave the team
+            if (!state.members || !Object.keys(state.members).length) {
+                lm.stop();
+                roster.stop();
+                lm.proxy = {};
+                cb({error: 'EINVAL'});
+                waitFor.abort();
+                console.error(JSON.stringify(state));
+                Feedback.send("ROSTER_CORRUPTED");
+                return;
+            }
+            // Kicked from the team
+            if (!state.members[me]) {
+                lm.stop();
+                roster.stop();
+                lm.proxy = {};
+                delete ctx.store.proxy.teams[id];
+                ctx.updateMetadata();
+                cb({error: 'EFORBIDDEN'});
+                waitFor.abort();
+                return;
+            }
+            // Check access rights
+            // If we're not a viewer, make sure we have edit rights
+            var s = state.members[me];
+            var teamEdPrivate = Util.find(teamData, ['keys', 'drive', 'edPrivate']);
+            if ((!teamData.hash || !teamEdPrivate) && ['ADMIN', 'MEMBER'].indexOf(s.role) !== -1) {
+                console.warn("Missing edit rights: demote to viewer");
+                var data = {};
+                data[ctx.store.proxy.curvePublic] = {
+                    role: "VIEWER"
+                };
+                roster.describe(data, function (err) {
+                    Feedback.send("TEAM_RIGHTS_FIXED");
+                    // Make sure we've removed all the keys
+                    delete teamData.hash;
+                    delete teamData.keys.drive.edPrivate;
+                    delete teamData.keys.chat.edit;
+                    if (!err) { return; }
+                    if (err === 'NO_CHANGE') { return; }
+                    console.error(err);
+                });
+            } else if ((!teamData.hash || !teamEdPrivate) && s.role === "OWNER") {
+                Feedback.send("TEAM_RIGHTS_OWNER");
+            }
+        }).nThen(function () {
+            if (!cache) {
+                ctx.progress += 30/ctx.numberOfTeams;
+                ctx.updateProgress({
+                    progress: ctx.progress
+                });
+            }
+            onReady(ctx, id, lm, roster, keys, null, cb);
+        });
+    };
+
+    var createTeam = function (ctx, data, cId, _cb) {
+        var cb = Util.once(_cb);
+
+        var password = Hash.createChannelId();
+        var hash = Hash.createRandomHash('team', password);
+        var secret = Hash.getSecrets('team', hash, password);
+        var roHash = Hash.getViewHashFromKeys(secret);
+        var keyPair = Nacl.sign.keyPair(); // keyPair.secretKey , keyPair.publicKey
+
+        var curvePair = Nacl.box.keyPair();
+
+        var rosterSeed = Crypto.Team.createSeed();
+        var rosterKeys = Crypto.Team.deriveMemberKeys(rosterSeed, {
+            curvePublic: ctx.store.proxy.curvePublic,
+            curvePrivate: ctx.store.proxy.curvePrivate
+        });
+        var roster;
+
+        var chatSecret = Hash.getSecrets('chat');
+        var chatHashes = Hash.getHashes(chatSecret);
+
+        var config = {
+            network: ctx.store.network,
+            channel: secret.channel,
+            data: {},
+            validateKey: secret.keys.validateKey, // derived validation key
+            crypto: Crypto.createEncryptor(secret.keys),
+            logLevel: 1,
+            classic: true,
+            ChainPad: ChainPad,
+            Cache: Cache,
+            owners: [ctx.store.proxy.edPublic]
+        };
+        nThen(function (waitFor) {
+            // Initialize the roster
+            Roster.create({
+                network: ctx.store.network || ctx.store.networkPromise,
+                channel: rosterKeys.channel, //sharedConfig.rosterChannel,
+                owners: [ctx.store.proxy.edPublic],
+                keys: rosterKeys,
+                store: ctx.store,
+                lastKnownHash: void 0,
+                newTeam: true,
+                Cache: Cache
+            }, waitFor(function (err, _roster) {
+                if (err) {
+                    waitFor.abort();
+                    console.error(err);
+                    return void cb({error: 'ROSTER_ERROR'});
+                }
+                roster = _roster;
+                var myData = Messaging.createData(ctx.store.proxy);
+                delete myData.channel;
+                roster.init(myData, waitFor(function (err) {
+                    if (err) {
+                        waitFor.abort();
+                        return void cb({error: 'ROSTER_INIT_ERROR'});
+                    }
+                }));
+            }));
+
+            // Add yourself as owner of the chat channel
+            var crypto = Crypto.createEncryptor(chatSecret.keys);
+            var chatCfg = {
+                network: ctx.store.network,
+                channel: chatSecret.channel,
+                noChainPad: true,
+                crypto: crypto,
+                metadata: {
+                    validateKey: chatSecret.keys.validateKey,
+                    owners: [ctx.store.proxy.edPublic],
+                }
+            };
+            var chatReady = waitFor();
+            var cpNf2;
+            chatCfg.onReady = function () {
+                if (cpNf2) { cpNf2.stop(); }
+                chatReady();
+            };
+            chatCfg.onError = function () {
+                waitFor.abort();
+                return void cb({error: 'CHAT_INIT_ERROR'});
+            };
+            cpNf2 = CpNetflux.start(chatCfg);
+        }).nThen(function (waitFor) {
+            roster.metadata({
+                name: data.name
+            }, waitFor(function (err) {
+                if (err) {
+                    waitFor.abort();
+                    return void cb({error: 'ROSTER_INIT_ERROR'});
+                }
+            }));
+        }).nThen(function () {
+            var id = Util.createRandomInteger();
+            config.onMetadataUpdate = function () {
+                var team = ctx.teams[id];
+                if (!team) { return; }
+                ctx.emit('ROSTER_CHANGE', id, team.clients);
+            };
+            var lm = Listmap.create(config);
+            var proxy = lm.proxy;
+            proxy.version = 2; // No migration needed
+            proxy.on('ready', function () {
+                // Store keys in our drive
+                var keys = {
+                    mailbox: {
+                        channel: Hash.createChannelId(),
+                        viewed: [],
+                        keys: {
+                            curvePrivate: Nacl.util.encodeBase64(curvePair.secretKey),
+                            curvePublic: Nacl.util.encodeBase64(curvePair.publicKey)
+                        }
+                    },
+                    drive: {
+                        edPrivate: Nacl.util.encodeBase64(keyPair.secretKey),
+                        edPublic: Nacl.util.encodeBase64(keyPair.publicKey)
+                    },
+                    chat: {
+                        edit: chatHashes.editHash,
+                        view: chatHashes.viewHash,
+                        validateKey: chatSecret.keys.validateKey,
+                        channel: chatSecret.channel
+                    },
+                    roster: {
+                        channel: rosterKeys.channel,
+                        edit: rosterSeed,
+                        view: rosterKeys.viewKeyStr,
+                    }
+                };
+                var t = ctx.store.proxy.teams[id] = {
+                    owner: true,
+                    channel: secret.channel,
+                    hash: hash,
+                    roHash: roHash,
+                    password: password,
+                    keys: keys,
+                    //members: membersHashes.editHash,
+                    metadata: {
+                        name: data.name
+                    }
+                };
+                // Initialize the team drive
+                proxy.drive = {};
+
+                onReady(ctx, id, lm, roster, keys, cId, function () {
+                    Feedback.send('TEAM_CREATION');
+                    ctx.store.mailbox.open('team-'+id, t.keys.mailbox, function () {
+                        // Team mailbox loaded
+                    }, true, {
+                        owners: t.keys.drive.edPublic
+                    });
+                    ctx.updateMetadata();
+                    cb();
+                });
+            }).on('error', function (info) {
+                if (info && typeof (info.loaded) !== "undefined"  && !info.loaded) {
+                    cb({error:'ECONNECT'});
+                }
+                if (info && info.error) {
+                    if (info.error === "EDELETED") {
+                        closeTeam(ctx, id);
+                    }
+                }
+            });
+        });
+    };
+
+    var deleteTeam = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var team = ctx.teams[teamId];
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!team || !teamData) { return void cb ({error: 'ENOENT'}); }
+        var state = team.roster.getState();
+        var curvePublic = Util.find(ctx, ['store', 'proxy', 'curvePublic']);
+        var me = state.members[curvePublic];
+        if (!me || me.role !== "OWNER") { return cb({ error: "EFORBIDDEN"}); }
+
+        var edPublic = Util.find(ctx, ['store', 'proxy', 'edPublic']);
+        var teamEdPublic = Util.find(teamData, ['keys', 'drive', 'edPublic']);
+
+        nThen(function (waitFor) {
+            ctx.Store.anonRpcMsg(null, {
+                msg: 'GET_METADATA',
+                data: teamData.channel
+            }, waitFor(function (obj) {
+                // If we can't get owners, abort
+                if (obj && obj.error) {
+                    waitFor.abort();
+                    return cb({ error: obj.error});
+                }
+                // Check if we're an owner of the team drive
+                var metadata = obj[0];
+                if (metadata && Array.isArray(metadata.owners) &&
+                    metadata.owners.indexOf(edPublic) !== -1) { return; }
+                // If w'e're not an owner, abort
+                waitFor.abort();
+                cb({error: 'EFORBIDDEN'});
+            }));
+        }).nThen(function (waitFor) {
+            team.proxy.delete = true;
+            // For each pad, check on the server if there are other owners.
+            // If yes, then remove yourself as an owner
+            // If no, delete the pad
+            var ownedPads = team.manager.getChannelsList('owned');
+            var sem = Saferphore.create(10);
+            ownedPads.forEach(function (c) {
+                var w = waitFor();
+                sem.take(function (give) {
+                    var otherOwners = false;
+                    nThen(function (_w) {
+                        // Don't check server metadata for blobs
+                        if (c.length !== 32) { return; }
+                        ctx.Store.anonRpcMsg(null, {
+                            msg: 'GET_METADATA',
+                            data: c
+                        }, _w(function (obj) {
+                            if (obj && obj.error) {
+                                give();
+                                return void _w.abort();
+                            }
+                            var md = obj[0];
+                            var isOwner = md && Array.isArray(md.owners) && md.owners.indexOf(teamEdPublic) !== -1;
+                            if (!isOwner) {
+                                give();
+                                return void _w.abort();
+                            }
+                            otherOwners = md.owners.some(function (ed) { return ed !== teamEdPublic; });
+                        }));
+                    }).nThen(function (_w) {
+                        if (otherOwners) {
+                            ctx.Store.setPadMetadata(null, {
+                                channel: c,
+                                command: 'RM_OWNERS',
+                                value: [teamEdPublic],
+                            }, _w());
+                            return;
+                        }
+                        // We're the only owner: delete the pad
+                        team.rpc.removeOwnedChannel(c, _w(function (err) {
+                            if (err) { console.error(err); }
+                        }));
+                    }).nThen(function () {
+                        give();
+                        w();
+                    });
+                });
+             });
+        }).nThen(function (waitFor) {
+            // Delete the pins log
+            team.rpc.removePins(waitFor(function (err) {
+                if (err) { console.error(err); }
+            }));
+            // Delete the mailbox
+            var mailboxChan = Util.find(teamData, ['keys', 'mailbox', 'channel']);
+            team.rpc.removeOwnedChannel(mailboxChan, waitFor(function (err) {
+                if (err) { console.error(err); }
+            }));
+            // Delete the roster
+            var rosterChan = Util.find(teamData, ['keys', 'roster', 'channel']);
+            ctx.store.rpc.removeOwnedChannel(rosterChan, waitFor(function (err) {
+                if (err) { console.error(err); }
+            }));
+            // Delete the chat
+            var chatChan = Util.find(teamData, ['keys', 'chat', 'channel']);
+            ctx.store.rpc.removeOwnedChannel(chatChan, waitFor(function (err) {
+                if (err) { console.error(err); }
+            }));
+            // Delete the team drive
+            ctx.store.rpc.removeOwnedChannel(teamData.channel, waitFor(function (err) {
+                if (err) { console.error(err); }
+            }));
+        }).nThen(function () {
+            Feedback.send('TEAM_DELETION');
+            closeTeam(ctx, teamId);
+            cb();
+        });
+    };
+
+    var joinTeam = function (ctx, data, cId, cb) {
+        var team = data.team;
+        if (!(team.hash || team.roHash) || !team.channel || !team.password
+            || !team.keys || !team.metadata) { return void cb({error: 'EINVAL'}); }
+        var id = Util.createRandomInteger();
+        ctx.store.proxy.teams[id] = team;
+        ctx.onReadyHandlers[id] = [];
+        openChannel(ctx, team, id, function (obj) {
+            if (!(obj && obj.error)) { console.debug('Team joined:' + id); }
+            var t = ctx.store.proxy.teams[id];
+            ctx.store.mailbox.open('team-'+id, t.keys.mailbox, function () {
+                // Team mailbox loaded
+            }, true, {
+                owners: t.keys.drive.edPublic
+            });
+            ctx.updateMetadata();
+            cb(obj);
+        });
+    };
+
+    var leaveTeam = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        var curvePublic = ctx.store.proxy.curvePublic;
+        team.roster.remove([curvePublic], function (err) {
+            if (err) { return void cb({error: err}); }
+            closeTeam(ctx, teamId);
+            cb();
+        });
+    };
+
+    var getTeamRoster = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!teamData) { return void cb ({error: 'ENOENT'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        var state = team.roster.getState() || {};
+        var members = state.members || {};
+
+        var md;
+        nThen(function (waitFor) {
+            // Get pending owners
+            ctx.Store.getPadMetadata(null, {
+                channel: teamData.channel
+            }, waitFor(function (obj) {
+                if (obj && obj.error) {
+                    md = team.listmap.metadata || {};
+                    return;
+                }
+                md = obj;
+            }));
+        }).nThen(function () {
+            ctx.pending_owners = md.pending_owners;
+            if (Array.isArray(md.pending_owners)) {
+                // Get the members associated to the pending_owners' edPublic and mark them as such
+                md.pending_owners.forEach(function (ed) {
+                    var member;
+                    Object.keys(members).some(function (curve) {
+                        if (members[curve].edPublic === ed) {
+                            member = members[curve];
+                            return true;
+                        }
+                    });
+                    if (!member && teamData.owner) {
+                        var removeOwnership = function (chan) {
+                            ctx.Store.setPadMetadata(null, {
+                                channel: chan,
+                                command: 'RM_PENDING_OWNERS',
+                                value: [ed],
+                            }, function () {});
+                        };
+                        removeOwnership(teamData.channel);
+                        removeOwnership(Util.find(teamData, ['keys', 'roster', 'channel']));
+                        removeOwnership(Util.find(teamData, ['keys', 'chat', 'channel']));
+                        return;
+                    }
+                    member.pendingOwner = true;
+                });
+            }
+
+            // Add online status (using messenger data)
+            if (ctx.store.messenger) {
+                var chatData = team.getChatData();
+                var online = ctx.store.messenger.getOnlineList(chatData.channel) || [];
+                online.forEach(function (curve) {
+                    if (members[curve]) {
+                        members[curve].online = true;
+                    }
+                });
+            }
+
+            // Decrypt hash for invite links
+            Object.keys(members).forEach(function (curve) {
+                var member = members[curve];
+                if (!member.inviteChannel) { return; }
+                if (!member.hash) { return; }
+                if (!teamData.hash) { delete member.hash; return; }
+                try {
+                    member.hash = Invite.decryptHash(member.hash, teamData.hash);
+                } catch (e) { console.error(e); }
+            });
+
+            cb(members);
+        });
+    };
+
+    // Return folders with edit rights available to everybody (decrypted pad href)
+    var getEditableFolders = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        var folders = team.manager.folders || {};
+        var ids = Object.keys(folders).filter(function (id) {
+            return !folders[id].proxy.version;
+        });
+        cb(ids.map(function (id) {
+            var uo = Util.find(team, ['user', 'userObject']);
+            return {
+                name: Util.find(folders, [id, 'proxy', 'metadata', 'title']),
+                path: uo ? uo.findFile(id)[0] : []
+            };
+        }));
+    };
+
+    var getTeamMetadata = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        var state = team.roster.getState() || {};
+        var md = state.metadata || {};
+        md.offline = team.offline;
+        cb(md);
+    };
+
+    var setTeamMetadata = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        if (team.offline) { return void cb({error: 'OFFLINE'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        if (data.metadata) { delete data.metadata.offline; }
+        team.roster.metadata(data.metadata, function (err) {
+            if (err) { return void cb({error: err}); }
+            var localTeam = ctx.store.proxy.teams[teamId];
+            if (localTeam) {
+                localTeam.metadata = data.metadata;
+            }
+            cb();
+        });
+    };
+
+    var offerOwnership = function (ctx, data, cId, _cb) {
+        var cb = Util.once(_cb);
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!teamData) { return void cb ({error: 'ENOENT'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        if (!data.curvePublic) { return void cb({error: 'MISSING_DATA'}); }
+        var state = team.roster.getState();
+        var user = state.members[data.curvePublic];
+        nThen(function (waitFor) {
+            // Offer ownership to a friend
+            var onError = function (res) {
+                var err = res && res.error;
+                if (err) {
+                    console.error(err);
+                    waitFor.abort();
+                    return void cb({error:err});
+                }
+            };
+            var addPendingOwner = function (chan) {
+                ctx.Store.setPadMetadata(null, {
+                    channel: chan,
+                    command: 'ADD_PENDING_OWNERS',
+                    value: [user.edPublic],
+                }, waitFor(onError));
+            };
+            // Team proxy
+            addPendingOwner(teamData.channel);
+            // Team roster
+            addPendingOwner(Util.find(teamData, ['keys', 'roster', 'channel']));
+            // Team chat
+            addPendingOwner(Util.find(teamData, ['keys', 'chat', 'channel']));
+        }).nThen(function (waitFor) {
+            var obj = {};
+            obj[user.curvePublic] = {
+                role: 'OWNER'
+            };
+            team.roster.describe(obj, waitFor(function (err) {
+                if (err) { console.error(err); }
+            }));
+        }).nThen(function (waitFor) {
+            // Send mailbox to offer ownership
+            ctx.store.mailbox.sendTo("ADD_OWNER", {
+                teamChannel: teamData.channel,
+                chatChannel: Util.find(teamData, ['keys', 'chat', 'channel']),
+                rosterChannel: Util.find(teamData, ['keys', 'roster', 'channel']),
+                title: teamData.metadata.name
+            }, {
+                channel: user.notifications,
+                curvePublic: user.curvePublic
+            }, waitFor());
+        }).nThen(function () {
+            cb();
+        });
+    };
+
+    var revokeOwnership = function (ctx, teamId, user, _cb) {
+        var cb = Util.once(_cb);
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!teamData) { return void cb ({error: 'ENOENT'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        var isPendingOwner = user.pendingOwner;
+        nThen(function (waitFor) {
+            var cmd = isPendingOwner ? 'RM_PENDING_OWNERS' : 'RM_OWNERS';
+
+            var onError = function (res) {
+                var err = res && res.error;
+                if (err) {
+                    console.error(err);
+                    waitFor.abort();
+                    return void cb(err);
+                }
+            };
+            var removeOwnership = function (chan) {
+                ctx.Store.setPadMetadata(null, {
+                    channel: chan,
+                    command: cmd,
+                    value: [user.edPublic],
+                }, waitFor(onError));
+            };
+            // Team proxy
+            removeOwnership(teamData.channel);
+            // Team roster
+            removeOwnership(Util.find(teamData, ['keys', 'roster', 'channel']));
+            // Team chat
+            removeOwnership(Util.find(teamData, ['keys', 'chat', 'channel']));
+        }).nThen(function (waitFor) {
+            var obj = {};
+            obj[user.curvePublic] = {
+                role: 'ADMIN',
+                pendingOwner: false
+            };
+            team.roster.describe(obj, waitFor(function (err) {
+                if (err) { console.error(err); }
+            }));
+        }).nThen(function (waitFor) {
+            // Send mailbox to offer ownership
+            ctx.store.mailbox.sendTo("RM_OWNER", {
+                teamChannel: teamData.channel,
+                title: teamData.metadata.name,
+                pending: isPendingOwner
+            }, {
+                channel: user.notifications,
+                curvePublic: user.curvePublic
+            }, waitFor());
+        }).nThen(function () {
+            cb();
+        });
+    };
+
+    // We've received an offer to be an owner of the team.
+    // If we accept, we need to set the "owner" flag in our team data
+    // If we decline, we need to change our role back to "ADMIN"
+    var answerOwnership = function (ctx, data, cId, cb) {
+        var myTeams = ctx.store.proxy.teams;
+        var teamId;
+        Object.keys(myTeams).forEach(function (id) {
+            if (myTeams[id].channel === data.teamChannel) {
+                teamId = id;
+                return true;
+            }
+        });
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!teamData) { return void cb ({error: 'ENOENT'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        var obj = {};
+
+        // Accept
+        if (data.answer) {
+            teamData.owner = true;
+            return;
+        }
+        // Decline
+        obj[ctx.store.proxy.curvePublic] = {
+            role: 'ADMIN',
+        };
+        team.roster.describe(obj, function (err) {
+            if (err) { return void cb({error: err}); }
+            cb();
+        });
+    };
+
+    var getInviteData = function (ctx, teamId, edit) {
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!teamData) { return {}; }
+        var data = Util.clone(teamData);
+        if (!edit) {
+            // Delete edit keys
+            delete data.hash;
+            delete data.keys.drive.edPrivate;
+            delete data.keys.chat.edit;
+        }
+        // Delete owner key
+        delete data.owner;
+        return data;
+    };
+
+    // Update my edit rights in listmap (only upgrade) and userObject (upgrade and downgrade)
+    // We also need to propagate the changes to the shared folders
+    var updateMyRights = function (ctx, teamId, hash) {
+        if (!teamId) { return true; }
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!teamData) { return true; }
+        var team = ctx.teams[teamId];
+        if (!team) { return true; }
+
+        var secret = Hash.getSecrets('team', hash || teamData.roHash, teamData.password);
+        // Upgrade the listmap if we can
+        SF.upgrade(teamData.channel, secret);
+        // Set the new readOnly value in userObject
+        if (team.userObject) {
+            team.userObject.setReadOnly(!secret.keys.secondaryKey, secret.keys.secondaryKey);
+        }
+
+        // Upgrade? update calendar rights
+        if (secret.keys.secondaryKey) {
+            try {
+                ctx.store.modules.calendar.upgradeTeam(teamId);
+            } catch (e) { console.error(e); }
+        }
+
+        if (!secret.keys.secondaryKey && team.rpc) {
+            team.rpc.destroy();
+        }
+
+        // Upgrade the shared folders
+        var folders = Util.find(team, ['proxy', 'drive', 'sharedFolders']);
+        Object.keys(folders || {}).forEach(function (sfId) {
+            var data = team.manager.getSharedFolderData(sfId);
+            var parsed = Hash.parsePadUrl(data.href || data.roHref);
+            var secret = Hash.getSecrets(parsed.type, parsed.hash, data.password);
+            SF.upgrade(secret.channel, secret);
+            var uo = Util.find(team, ['manager', 'folders', sfId, 'userObject']);
+            if (uo) {
+                uo.setReadOnly(!secret.keys.secondaryKey, secret.keys.secondaryKey);
+            }
+        });
+        ctx.updateMetadata();
+        ctx.emit('ROSTER_CHANGE_RIGHTS', teamId, team.clients);
+    };
+
+    var changeMyRights = function (ctx, teamId, state, data, cb) {
+        if (!teamId) { return void cb(false); }
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!teamData) { return void cb(false); }
+        var onReady = ctx.onReadyHandlers[teamId];
+        var team = ctx.teams[teamId];
+
+        if (teamData.channel !== data.channel || teamData.password !== data.password) { return void cb(false); }
+
+        // Update our proxy
+        if (state) {
+            teamData.hash = data.hash;
+            teamData.keys.drive.edPrivate = data.keys.drive.edPrivate;
+            teamData.keys.chat.edit = data.keys.chat.edit;
+        } else {
+            delete teamData.hash;
+            delete teamData.keys.drive.edPrivate;
+            delete teamData.keys.chat.edit;
+        }
+
+        // Team not ready yet: try again onReady
+        if (!team && Array.isArray(onReady)) {
+            onReady.push({
+                cb: function () {
+                    changeMyRights(ctx, teamId, state, data, cb);
+                }
+            });
+            return;
+        }
+
+        // No team and not initialized at all...
+        if (!team) { return void cb(false); }
+
+        // Team is initialized and ready: update the loaded elements
+        if (state) {
+            initRpc(ctx, team, teamData.keys.drive, function () {
+                team.manager.addPin(team.pin, team.unpin);
+            });
+
+            var secret = Hash.getSecrets('team', data.hash, teamData.password);
+            team.secondaryKey = secret && secret.keys.secondaryKey;
+
+            var crypto = Crypto.createEncryptor(secret.keys);
+            team.listmap.setReadOnly(false, crypto);
+        } else {
+            delete team.secondaryKey;
+            if (team.rpc && team.rpc.destroy) {
+                team.rpc.destroy();
+            }
+            team.manager.removePin();
+            team.listmap.setReadOnly(true);
+        }
+
+        updateMyRights(ctx, teamId, data.hash);
+        cb(true);
+    };
+    var changeEditRights = function (ctx, teamId, user, state, cb) {
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        if (!teamData) { return void cb ({error: 'ENOENT'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+
+        // Send mailbox to offer ownership
+        ctx.store.mailbox.sendTo("TEAM_EDIT_RIGHTS", {
+            state: state,
+            teamData: getInviteData(ctx, teamId, state)
+        }, {
+            channel: user.notifications,
+            curvePublic: user.curvePublic
+        }, cb);
+    };
+
+    var describeUser = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        var team = ctx.teams[teamId];
+        if (!teamData || !team) { return void cb ({error: 'ENOENT'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        if (!data.curvePublic || !data.data) { return void cb({error: 'MISSING_DATA'}); }
+        var state = team.roster.getState();
+        var user = state.members[data.curvePublic];
+
+        var md;
+        nThen(function (waitFor) {
+            // Get pending owners
+            ctx.Store.getPadMetadata(null, {
+                channel: teamData.channel
+            }, waitFor(function (obj) {
+                if (obj && obj.error) {
+                    md = team.listmap.metadata || {};
+                    return;
+                }
+                md = obj;
+            }));
+        }).nThen(function () {
+            user.pendingOwner = Array.isArray(md.pending_owners) &&
+                                md.pending_owners.indexOf(user.edPublic) !== -1;
+
+            // It it is an ownership revocation, we have to set it in pad metadata first
+            if (user.role === "OWNER" && data.data.role !== "OWNER") {
+                revokeOwnership(ctx, teamId, user, function (err) {
+                    if (!err) { return void cb(); }
+                    console.error(err);
+                    return void cb({error: err});
+                });
+                return;
+            }
+
+            // Viewer to editor
+            if (user.role === "VIEWER" && data.data.role !== "VIEWER") {
+                changeEditRights(ctx, teamId, user, true, function (obj) {
+                    return void cb(obj);
+                });
+            }
+
+            // Editor to viewer
+            if (user.role !== "VIEWER" && data.data.role === "VIEWER") {
+                changeEditRights(ctx, teamId, user, false, function (obj) {
+                    return void cb(obj);
+                });
+            }
+
+            var obj = {};
+            obj[data.curvePublic] = data.data;
+            team.roster.describe(obj, function (err) {
+                if (err) { return void cb({error: err}); }
+                cb();
+            });
+        });
+    };
+
+    var inviteToTeam = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        var user = data.user;
+        if (!user || !user.curvePublic || !user.notifications) { return void cb({error: 'MISSING_DATA'}); }
+        delete user.channel;
+        delete user.lastKnownHash;
+        user.pending = true;
+
+        var obj = {};
+        obj[user.curvePublic] = user;
+        obj[user.curvePublic].role = 'VIEWER';
+        team.roster.add(obj, function (err) {
+            if (err && err !== 'NO_CHANGE') { return void cb({error: err}); }
+            ctx.store.mailbox.sendTo('INVITE_TO_TEAM', {
+                team: getInviteData(ctx, teamId)
+            }, {
+                channel: user.notifications,
+                curvePublic: user.curvePublic
+            }, function (obj) {
+                cb(obj);
+            });
+        });
+    };
+
+    var removeUser = function (ctx, data, cId, cb) {
+        var teamId = data.teamId;
+        if (!teamId) { return void cb({error: 'EINVAL'}); }
+        var team = ctx.teams[teamId];
+        if (!team) { return void cb ({error: 'ENOENT'}); }
+        if (!team.roster) { return void cb({error: 'NO_ROSTER'}); }
+        if (!data.curvePublic) { return void cb({error: 'MISSING_DATA'}); }
+
+        var state = team.roster.getState();
+        var userData = state.members[data.curvePublic];
+        team.roster.remove([data.curvePublic], function (err) {
+            if (err) { return void cb({error: err}); }
+            // The user has been removed, send them a notification
+            if (!userData || !userData.notifications) { return cb(); }
+            ctx.store.mailbox.sendTo('KICKED_FROM_TEAM', {
+                pending: data.pending,
+                teamChannel: getInviteData(ctx, teamId).channel,
+                teamName: getInviteData(ctx, teamId).metadata.name
+            }, {
+                channel: userData.notifications,
+                curvePublic: userData.curvePublic
+            }, function (obj) {
+                cb(obj);
+            });
+        });
+    };
+
+    // Remove a client from all the team they're subscribed to
+    var removeClient = function (ctx, cId) {
+        Object.keys(ctx.onReadyHandlers).forEach(function (teamId) {
+            var idx = -1;
+            ctx.onReadyHandlers[teamId].some(function (obj, _idx) {
+                if (obj.cId === cId) {
+                    idx = _idx;
+                    return true;
+                }
+            });
+            if (idx !== -1) {
+                ctx.onReadyHandlers[teamId].splice(idx, 1);
+            }
+        });
+
+        Object.keys(ctx.teams).forEach(function (id) {
+            var clients = ctx.teams[id].clients;
+            var idx = clients.indexOf(cId);
+            if (idx !== -1) { clients.splice(idx, 1); }
+        });
+    };
+
+    var subscribe = function (ctx, id, cId, cb) {
+        // Unsubscribe from other teams: one tab can only receive events about one team
+        removeClient(ctx, cId);
+        // And leave the chat channel
+        try {
+            ctx.store.messenger.removeClient(cId);
+        } catch (e) {}
+        openCachedTeamChat = function () {};
+
+        if (!id) { return void cb(); }
+        // If the team is loading, add ourselves to the list
+        if (ctx.onReadyHandlers[id] && !ctx.teams[id]) {
+            var _idx = ctx.onReadyHandlers[id].indexOf(cId);
+            if (_idx === -1) {
+                ctx.onReadyHandlers[id].push({
+                    cId: cId,
+                    cb: cb
+                });
+            }
+            return;
+        }
+        // Otherwise, subscribe to new notifications
+        if (!ctx.teams[id]) {
+            return void cb({error: 'EINVAL'});
+        }
+        var clients = ctx.teams[id].clients;
+        var idx = clients.indexOf(cId);
+        if (idx === -1) {
+            clients.push(cId);
+        }
+        cb();
+    };
+
+    var openTeamChat = function (ctx, data, cId, cb) {
+        var team = ctx.teams[data.teamId];
+        if (!team) { return void cb({error: 'ENOENT'}); }
+        var onUpdate = function () {
+            ctx.emit('ROSTER_CHANGE', data.teamId, team.clients);
+        };
+        if (ctx.store.messenger) {
+            ctx.store.messenger.openTeamChat(team.getChatData(), onUpdate, cId, cb);
+        } else {
+            openCachedTeamChat = function () {
+                ctx.store.messenger.openTeamChat(team.getChatData(), onUpdate, cId, cb);
+            };
+        }
+    };
+
+    var createInviteLink = function (ctx, data, cId, _cb) {
+        var cb = Util.mkAsync(Util.once(_cb));
+
+        var teamId = data.teamId;
+        var team = ctx.teams[data.teamId];
+        var seeds = data.seeds; // {scrypt, preview}
+        var bytes64 = data.bytes64;
+
+        if (!teamId || !team) { return void cb({error: 'EINVAL'}); }
+
+        var roster = team.roster;
+
+        var teamName;
+        try {
+            teamName = roster.getState().metadata.name;
+        } catch (err) {
+            return void cb({ error: "TEAM_NAME_ERR" });
+        }
+
+        var message = data.message;
+        var name = data.name;
+
+        //var password = data.password;
+        var hash = data.hash;
+        var teamData = Util.find(ctx, ['store', 'proxy', 'teams', teamId]);
+        try {
+            var encryptedHash = Invite.encryptHash(hash, teamData.hash);
+        } catch (e) { console.error(e); }
+
+        // derive { channel, cryptKey} for the preview content channel
+        var previewKeys = Invite.derivePreviewKeys(seeds.preview);
+
+        // derive {channel, cryptkey} for the invite content channel
+        var inviteKeys = Invite.deriveInviteKeys(bytes64);
+
+        // randomly generate ephemeral keys for ownership of the above content
+        // and a placeholder in the roster
+        var ephemeralKeys = Invite.generateKeys();
+
+        // Initial role of the invited users
+        var role = data.role || "VIEWER";
+        var uses = data.uses || 1;
+
+        nThen(function (w) {
+
+
+            (function () {
+                // a random signing keypair to prevent further writes to the channel
+                // we don't need to remember it cause we're only writing once
+                var sign = Invite.generateSignPair(); // { validateKey, signKey}
+                var putOpts = {
+                    initialState: '{}',
+                    network: ctx.store.network,
+                    metadata: {
+                        owners: [ctx.store.proxy.edPublic, ephemeralKeys.edPublic]
+                    }
+                };
+                putOpts.metadata.validateKey = sign.validateKey;
+
+                // visible with only the invite link
+                var previewContent = {
+                    teamName: teamName,
+                    message: message,
+                    author: Messaging.createData(ctx.store.proxy, false),
+                    displayName: name,
+                };
+
+                var cryptput_config = {
+                    channel: previewKeys.channel,
+                    type: 'pad',
+                    version: 2,
+                    keys: { // what would normally be provided by getSecrets
+                        cryptKey: previewKeys.cryptKey,
+                        validateKey: sign.validateKey, // sent to historyKeeper
+                        signKey: sign.signKey, // b64EdPrivate
+                    },
+                };
+
+                Crypt.put(cryptput_config, JSON.stringify(previewContent), w(function (err /*, doc */) {
+                    if (err) {
+                        console.error("CRYPTPUT_ERR", err);
+                        w.abort();
+                        return void cb({ error: "SET_PREVIEW_CONTENT" });
+                    }
+                }), putOpts);
+            }());
+
+            (function () {
+                // a different random signing key so that the server can't correlate these documents
+                // as components of an invite
+                var sign = Invite.generateSignPair(); // { validateKey, signKey}
+                var putOpts = {
+                    initialState: '{}',
+                    network: ctx.store.network,
+                    metadata: {
+                        owners: [ctx.store.proxy.edPublic, ephemeralKeys.edPublic]
+                    }
+                };
+                putOpts.metadata.validateKey = sign.validateKey;
+
+
+
+
+                // available only with the link and the content
+                var inviteContent = {
+                    teamData: getInviteData(ctx, teamId, role === "MEMBER"),
+                    ephemeral: {
+                        edPublic: ephemeralKeys.edPublic,
+                        edPrivate: ephemeralKeys.edPrivate,
+                        curvePublic: ephemeralKeys.curvePublic,
+                        curvePrivate: ephemeralKeys.curvePrivate,
+                    },
+                };
+
+                var cryptput_config = {
+                    channel: inviteKeys.channel,
+                    type: 'pad',
+                    version: 2,
+                    keys: {
+                        cryptKey: inviteKeys.cryptKey,
+                        validateKey: sign.validateKey,
+                        signKey: sign.signKey,
+                    },
+                };
+
+                Crypt.put(cryptput_config, JSON.stringify(inviteContent), w(function (err /*, doc */) {
+                    if (err) {
+                        console.error("CRYPTPUT_ERR", err);
+                        w.abort();
+                        return void cb({ error: "SET_PREVIEW_CONTENT" });
+                    }
+                }), putOpts);
+            }());
+        }).nThen(function (w) {
+            team.pin([inviteKeys.channel, previewKeys.channel], function (obj) {
+                if (obj && obj.error) { console.error(obj.error); }
+            });
+            Invite.createRosterEntry(team.roster, {
+                curvePublic: ephemeralKeys.curvePublic,
+                content: {
+                    curvePublic: ephemeralKeys.curvePublic,
+                    displayName: data.name,
+                    pending: true,
+                    remaining: uses,
+                    totalUses: uses,
+                    role: role,
+                    hash: encryptedHash,
+                    inviteChannel: inviteKeys.channel,
+                    previewChannel: previewKeys.channel,
+                }
+            }, w(function (err) {
+                if (err) {
+                    w.abort();
+                    cb(err);
+                }
+            }));
+        }).nThen(function () {
+            // call back empty if everything worked
+            cb();
+        });
+    };
+
+    var getPreviewContent = function (ctx, data, cId, cb) {
+        var seeds = data.seeds;
+        var previewKeys;
+        try {
+            previewKeys = Invite.derivePreviewKeys(seeds.preview);
+        } catch (err) {
+            return void cb({ error: "INVALID_SEEDS" });
+        }
+        Crypt.get({ // secrets
+            channel: previewKeys.channel,
+            type: 'pad',
+            version: 2,
+            keys: {
+                cryptKey: previewKeys.cryptKey,
+            },
+        }, function (err, val) {
+            if (err) { return void cb({ error: err }); }
+            if (!val) { return void cb({ error: 'DELETED' }); }
+
+            var json = Util.tryParse(val);
+            if (!json) { return void cb({ error: "parseError" }); }
+            cb(json);
+        }, { // cryptget opts
+            network: ctx.store.network,
+            initialState: '{}',
+        });
+    };
+
+    var getInviteContent = function (ctx, data, cId, cb) {
+        var bytes64 = data.bytes64;
+        var previewKeys;
+        try {
+            previewKeys = Invite.deriveInviteKeys(bytes64);
+        } catch (err) {
+            return void cb({ error: "INVALID_SEEDS" });
+        }
+        Crypt.get({ // secrets
+            channel: previewKeys.channel,
+            type: 'pad',
+            version: 2,
+            keys: {
+                cryptKey: previewKeys.cryptKey,
+            },
+        }, function (err, val) {
+            if (err) { return void cb({error: err}); }
+            if (!val) { return void cb({error: 'DELETED'}); }
+
+            var json = Util.tryParse(val);
+            if (!json) { return void cb({error: "parseError"}); }
+            cb(json);
+        }, { // cryptget opts
+            network: ctx.store.network,
+            initialState: '{}',
+        });
+    };
+
+    var acceptLinkInvitation = function (ctx, data, cId, cb) {
+        var inviteContent;
+        var rosterState;
+        nThen(function (waitFor) {
+            // Get team keys and ephemeral keys
+            getInviteContent(ctx, data, cId, waitFor(function (obj) {
+                if (obj && obj.error) {
+                    waitFor.abort();
+                    return void cb(obj);
+                }
+                inviteContent = obj;
+            }));
+        }).nThen(function (waitFor) {
+            // Check if you're already a member of this team
+            var chan = Util.find(inviteContent, ['teamData', 'channel']);
+            var myTeams = ctx.store.proxy.teams || {};
+            var isMember = Object.keys(myTeams).some(function (k) {
+                var t = myTeams[k];
+                return t.channel === chan;
+            });
+            if (isMember) {
+                waitFor.abort();
+                return void cb({error: 'ALREADY_MEMBER'});
+            }
+            // Accept the roster invitation: relplace our ephemeral keys with our user keys
+            var rosterData = Util.find(inviteContent, ['teamData', 'keys', 'roster']);
+            var myKeys = inviteContent.ephemeral;
+            if (!rosterData || !myKeys) {
+                waitFor.abort();
+                return void cb({error: 'INVALID_INVITE_CONTENT'});
+            }
+            var rosterKeys = Crypto.Team.deriveMemberKeys(rosterData.edit, myKeys);
+            Roster.create({
+                network: ctx.store.network || ctx.store.networkPromise,
+                channel: rosterData.channel,
+                keys: rosterKeys,
+                store: ctx.store,
+                Cache: Cache
+            }, waitFor(function (err, roster) {
+                if (err) {
+                    waitFor.abort();
+                    console.error(err);
+                    return void cb({error: 'ROSTER_ERROR'});
+                }
+                var myData = Messaging.createData(ctx.store.proxy, false);
+                var state = roster.getState();
+                rosterState = state.members[myKeys.curvePublic];
+                roster.accept(myData.curvePublic, waitFor(function (err) {
+                    roster.stop();
+                    if (err) {
+                        waitFor.abort();
+                        console.error(err);
+                        return void cb({error: 'ACCEPT_ERROR'});
+                    }
+                }));
+            }));
+        }).nThen(function () {
+            var tempRpc = {};
+            if (!rosterState.remaining || rosterState.remaining === 1) {
+                initRpc(ctx, tempRpc, inviteContent.ephemeral, function (err) {
+                    if (err) { return; }
+                    var rpc = tempRpc.rpc;
+                    if (rosterState.inviteChannel) {
+                        rpc.removeOwnedChannel(rosterState.inviteChannel, function (err) {
+                            if (err) { console.error(err); }
+                        });
+                    }
+                    if (rosterState.previewChannel) {
+                        rpc.removeOwnedChannel(rosterState.previewChannel, function (err) {
+                            if (err) { console.error(err); }
+                        });
+                    }
+                });
+            }
+            // Add the team to our list and join...
+            joinTeam(ctx, {
+                team: inviteContent.teamData
+            }, cId, cb);
+        });
+    };
+
+    var deriveMailbox = function (team) {
+        if (!team) { return; }
+        if (team.keys && team.keys.mailbox) { return team.keys.mailbox; }
+        var strSeed = Util.find(team, ['keys', 'roster', 'edit']);
+        if (!strSeed) { return; }
+        var hash = Nacl.hash(Nacl.util.decodeUTF8(strSeed));
+        var seed = hash.slice(0,32);
+        var mailboxChannel = Util.uint8ArrayToHex(hash.slice(32,48));
+        var curvePair = Nacl.box.keyPair.fromSecretKey(seed);
+        return {
+            channel: mailboxChannel,
+            viewed: [],
+            keys: {
+                curvePrivate: Nacl.util.encodeBase64(curvePair.secretKey),
+                curvePublic: Nacl.util.encodeBase64(curvePair.publicKey)
+            }
+        };
+    };
+
+    Team.init = function (cfg, waitFor, emit) {
+        var team = {};
+        var store = cfg.store;
+        if (!store.loggedIn || !store.proxy.edPublic) { return; }
+        var ctx = {
+            store: store,
+            Store: cfg.Store,
+            pinPads: cfg.pinPads,
+            emit: emit,
+            onReadyHandlers: {},
+            teams: {},
+            cache: {},
+            updateMetadata: cfg.updateMetadata,
+            updateProgress: cfg.updateLoadingProgress,
+            progress: 0
+        };
+
+        if (!store.proxy.teams) { store.proxy.teams = {}; }
+        var teams = store.proxy.teams;
+
+        ctx.numberOfTeams = Object.keys(teams).length;
+
+        // Listen for changes in our access rights (if another worker receives edit access)
+        ctx.store.proxy.on('change', ['teams'], function (o, n, p) {
+            if (p[2] !== 'hash') { return; }
+            updateMyRights(ctx, p[1], n);
+        });
+        ctx.store.proxy.on('remove', ['teams'], function (o, p) {
+            if (p[2] !== 'hash') { return; }
+            updateMyRights(ctx, p[1]);
+        });
+
+        var checkKeyPair = function (edPrivate, edPublic) {
+            if (!edPrivate || !edPublic) { return true; }
+            try {
+                var secretKey = Nacl.util.decodeBase64(edPrivate);
+                var pair = Nacl.sign.keyPair.fromSecretKey(secretKey);
+                return Nacl.util.encodeBase64(pair.publicKey) === edPublic;
+            } catch (e) {
+                return false;
+            }
+        };
+
+        // Remove duplicate teams
+        var removeDuplicates = function () {
+            var _teams = {};
+            Object.keys(teams).forEach(function (id) {
+                try {
+                    var t = teams[id];
+                    var _t = _teams[t.channel];
+
+                    var edPrivate = Util.find(t, ['keys', 'drive', 'edPrivate']);
+                    var edPublic = Util.find(t, ['keys', 'drive', 'edPublic']);
+
+                    // If the edPrivate is corrupted, remove it
+                    if (!edPublic) {
+                        Feedback.send("TEAM_CORRUPTED_EDPUBLIC");
+                    } else if (edPrivate && edPublic && !checkKeyPair(edPrivate, edPublic)) {
+                        Feedback.send("TEAM_CORRUPTED_EDPRIVATE");
+                        delete teams[id].keys.drive.edPrivate;
+                        edPrivate = undefined;
+                    }
+
+                    // If the hash is corrupted, feedback
+                    if (t.hash) {
+                        var parsed = Hash.parseTypeHash('drive', t.hash);
+                        if (parsed.version === 2 && t.hash.length !== 40) {
+                            Feedback.send("TEAM_CORRUPTED_HASH");
+                            // FIXME ?
+                        }
+                    }
+
+                    // Not found yet? add to the list
+                    if (!_t) {
+                        _teams[t.channel] = id;
+                        return;
+                    }
+
+                    // Duplicate found: update our team to add missing data
+                    var best = teams[_t]; // This is a proxy!
+                    var bestPrivate = Util.find(best, ['keys', 'drive', 'edPrivate']);
+                    var bestChat = Util.find(best, ['keys', 'chat', 'edit']);
+                    var chat = Util.find(t, ['keys', 'chat', 'edit']);
+                    if (!best.hash && t.hash) {
+                        best.hash = t.hash;
+                    }
+                    if (!bestPrivate && edPrivate) {
+                        best.keys.drive.edPrivate = edPrivate;
+                    }
+                    if (!bestChat && chat) {
+                        best.keys.chat.edit = chat;
+                    }
+
+                    // Deprecate the duplicate
+                    ctx.store.proxy.duplicateTeams = ctx.store.proxy.duplicateTeams || {};
+                    ctx.store.proxy.duplicateTeams[id] = teams[id];
+                    delete teams[id];
+                } catch (e) { console.error(e); }
+            });
+        };
+
+        // Load teams
+        Object.keys(teams).forEach(function (id) {
+            ctx.onReadyHandlers[id] = [];
+            if (!Util.find(teams, [id, 'keys', 'mailbox'])) {
+                teams[id].keys.mailbox = deriveMailbox(teams[id]);
+            }
+            openChannel(ctx, teams[id], id, waitFor(function (err) {
+                if (err) {
+                    delete ctx.onReadyHandlers[id];
+                    delete ctx.cache[id];
+                    var txt = typeof(err) === "string" ? err : (err.type || err.message);
+                    Feedback.send("TEAM_LOADING_ERROR="+txt);
+                    return void console.error(err);
+                }
+                console.debug('Team '+id+' cache ready');
+            }), true);
+        });
+
+        // Proxy is ready, check if our team list has changed
+        team.onReady = function (waitFor) {
+            removeDuplicates();
+
+            // Close all the teams from our cache that have been removed and add waitFor to the
+            // one that still exist
+            var checkTeam = function (id) {
+                if (!teams[id]) {
+                    closeTeam(ctx, id);
+                    delete ctx.onReadyHandlers[id];
+                    return true;
+                }
+                return false;
+            };
+            Object.keys(ctx.teams).forEach(checkTeam);
+            Object.keys(ctx.onReadyHandlers).forEach(function (id) {
+                var closed = checkTeam(id);
+                if (closed) { return; }
+                var team = ctx.store.proxy.teams[id];
+                var rosterChan = Util.find(team, ['keys', 'roster', 'channel']);
+                var _cb = Util.once(Util.mkAsync(waitFor()));
+                nThen(function (w) {
+                    checkTeamChannels(ctx, id, team.channel, rosterChan, w, _cb);
+                });
+                ctx.onReadyHandlers[id].push({
+                    cb: _cb
+                });
+            });
+
+            // Load all the teams that weren't in our cache
+            Object.keys(teams).forEach(function (id) {
+                // Team already loaded? abort
+                if (ctx.onReadyHandlers[id] || ctx.teams[id]) { return; }
+
+                // Load team
+                ctx.onReadyHandlers[id] = [];
+                if (!Util.find(teams, [id, 'keys', 'mailbox'])) {
+                    teams[id].keys.mailbox = deriveMailbox(teams[id]);
+                }
+                openChannel(ctx, teams[id], id, waitFor(function (err) {
+                    if (err) {
+                        var txt = typeof(err) === "string" ? err : (err.type || err.message);
+                        Feedback.send("TEAM_LOADING_ERROR="+txt);
+                        return void console.error(err);
+                    }
+                    console.debug('Team '+id+' ready');
+                }));
+            });
+
+            openCachedTeamChat();
+            onStoreReady.fire();
+        };
+
+        team.getTeam = function (id) {
+            return ctx.teams[id];
+        };
+        team.getTeamsData = function (app) {
+            var t = {};
+            var safe = false;
+            if (['drive', 'teams', 'settings'].indexOf(app) !== -1) { safe = true; }
+            Object.keys(teams).forEach(function (id) {
+                if (!ctx.teams[id]) { return; }
+                var proxy = ctx.teams[id].proxy || {};
+                var nPads = proxy.drive && Object.keys(proxy.drive.filesData || {}).length;
+                var nSf = proxy.drive && Object.keys(proxy.drive.sharedFolders || {}).length;
+                t[id] = {
+                    owner: teams[id].owner,
+                    name: teams[id].metadata.name,
+                    channel: teams[id].channel,
+                    numberPads: nPads,
+                    numberSf: nSf,
+                    roster: Util.find(teams[id], ['keys', 'roster', 'channel']),
+                    edPublic: Util.find(teams[id], ['keys', 'drive', 'edPublic']),
+                    avatar: Util.find(teams[id], ['metadata', 'avatar']),
+                    viewer: !Util.find(teams[id], ['keys', 'drive', 'edPrivate']),
+                    notifications: Util.find(teams[id], ['keys', 'mailbox', 'channel']),
+                    curvePublic: Util.find(teams[id], ['keys', 'mailbox', 'keys', 'curvePublic']),
+                    validKeys: checkKeyPair(Util.find(teams[id], ['keys', 'drive', 'edPrivate']), Util.find(teams[id], ['keys', 'drive', 'edPublic']))
+                };
+                if (safe && ctx.teams[id]) {
+                    t[id].secondaryKey = ctx.teams[id].secondaryKey;
+                }
+                if (ctx.teams[id]) {
+                    t[id].hasSecondaryKey = Boolean(ctx.teams[id].secondaryKey);
+                }
+            });
+            return t;
+        };
+        team.getTeams = function () {
+            return Object.keys(ctx.teams);
+        };
+
+        var isPending = function (teamId, curve) {
+            var team = ctx.teams[teamId];
+            if (!team) { return; }
+            var state = team.roster && team.roster.getState();
+            if (!state.members) { return; }
+            var m = state.members[curve] || {};
+            return m.pending;
+        };
+        team.removeFromTeam = function (teamId, curve, pendingOnly) {
+            if (!teams[teamId]) { return; }
+
+            // When receiving a negative answer to a team invitation, remove
+            // the pending user from the roster.
+            if (pendingOnly && !isPending(teamId, curve)) { return; }
+
+            if (ctx.onReadyHandlers[teamId]) {
+                ctx.onReadyHandlers[teamId].push({cb : function () {
+                    ctx.teams[teamId].roster.remove([curve], function (err) {
+                        if (err && err !== 'NO_CHANGE') { console.error(err); }
+                    });
+                }});
+                return;
+            }
+            var team = ctx.teams[teamId];
+            if (!team) { return void console.error("TEAM MODULE ERROR"); }
+            team.roster.remove([curve], function (err) {
+                if (err && err !== 'NO_CHANGE') { console.error(err); }
+            });
+
+        };
+        team.changeMyRights = function (id, edit, teamData, cb) {
+            changeMyRights(ctx, id, edit, teamData, cb);
+        };
+        team.updateMyData = function (data) {
+            Object.keys(ctx.teams).forEach(function (id) {
+                var team = ctx.teams[id];
+                if (!team.roster) { return; }
+                var obj = {};
+                obj[data.curvePublic] = data;
+                team.roster.describe(obj, function (err) {
+                    if (err) { console.error(err); }
+                });
+            });
+        };
+        team.removeClient = function (clientId) {
+            removeClient(ctx, clientId);
+        };
+        var listTeams = function (cb) {
+            var t = Util.clone(teams);
+            Object.keys(t).forEach(function (id) {
+                // If failure to load the team, don't send it
+                if (ctx.teams[id]) {
+                    t[id].offline = ctx.teams[id].offline;
+                    return;
+                }
+                t[id].error = true;
+            });
+            cb(t);
+        };
+        team.execCommand = function (clientId, obj, cb) {
+
+            var cmd = obj.cmd;
+            var data = obj.data;
+            if (cmd === 'SUBSCRIBE') {
+                // Only the team app will subscribe to events?
+                return void subscribe(ctx, data, clientId, cb);
+            }
+            if (cmd === 'LIST_TEAMS') {
+                return void listTeams(cb);
+            }
+            if (cmd === 'OPEN_TEAM_CHAT') {
+                return void openTeamChat(ctx, data, clientId, cb);
+            }
+            if (cmd === 'GET_TEAM_ROSTER') {
+                return void getTeamRoster(ctx, data, clientId, cb);
+            }
+            if (cmd === 'GET_TEAM_METADATA') {
+                return void getTeamMetadata(ctx, data, clientId, cb);
+            }
+            if (cmd === 'SET_TEAM_METADATA') {
+                return void setTeamMetadata(ctx, data, clientId, cb);
+            }
+            if (cmd === 'OFFER_OWNERSHIP') {
+                if (ctx.store.offline) { return void cb({ error: 'OFFLINE' }); }
+                return void offerOwnership(ctx, data, clientId, cb);
+            }
+            if (cmd === 'ANSWER_OWNERSHIP') {
+                if (ctx.store.offline) { return void cb({ error: 'OFFLINE' }); }
+                return void answerOwnership(ctx, data, clientId, cb);
+            }
+            if (cmd === 'DESCRIBE_USER') {
+                return void describeUser(ctx, data, clientId, cb);
+            }
+            if (cmd === 'INVITE_TO_TEAM') {
+                if (ctx.store.offline) { return void cb({ error: 'OFFLINE' }); }
+                return void inviteToTeam(ctx, data, clientId, cb);
+            }
+            if (cmd === 'LEAVE_TEAM') {
+                return void leaveTeam(ctx, data, clientId, cb);
+            }
+            if (cmd === 'JOIN_TEAM') {
+                if (ctx.store.offline) { return void cb({ error: 'OFFLINE' }); }
+                return void joinTeam(ctx, data, clientId, cb);
+            }
+            if (cmd === 'REMOVE_USER') {
+                return void removeUser(ctx, data, clientId, cb);
+            }
+            if (cmd === 'DELETE_TEAM') {
+                if (ctx.store.offline) { return void cb({ error: 'OFFLINE' }); }
+                return void deleteTeam(ctx, data, clientId, cb);
+            }
+            if (cmd === 'CREATE_TEAM') {
+                if (ctx.store.offline) { return void cb({ error: 'OFFLINE' }); }
+                return void createTeam(ctx, data, clientId, cb);
+            }
+            if (cmd === 'GET_EDITABLE_FOLDERS') {
+                return void getEditableFolders(ctx, data, clientId, cb);
+            }
+            if (cmd === 'CREATE_INVITE_LINK') {
+                return void createInviteLink(ctx, data, clientId, cb);
+            }
+            if (cmd === 'GET_PREVIEW_CONTENT') {
+                return void getPreviewContent(ctx, data, clientId, cb);
+            }
+            if (cmd === 'ACCEPT_LINK_INVITATION') {
+                if (ctx.store.offline) { return void cb({ error: 'OFFLINE' }); }
+                return void acceptLinkInvitation(ctx, data, clientId, cb);
+            }
+        };
+
+        return team;
+    };
+
+    Team.anonGetPreviewContent = function (cfg, data, cb) {
+        getPreviewContent(cfg, data, null, cb);
+    };
+
+    return Team;
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    // Code from customize can't be laoded directly in the build
+    module.exports = factory(
+        require('../../common/common-util'),
+        require('../../common/common-hash'),
+        require('../../common/common-constants'),
+        require('../../common/common-realtime'),
+
+        require('../../common/proxy-manager'),
+        require('../../common/user-object'),
+        require('../components/sharedfolder'),
+        require('../components/roster'),
+        require('../../common/common-messaging'),
+        require('../../common/common-feedback'),
+        require('../components/invitation'),
+        require('../../common/cryptget'),
+        require('../../common/cache-store'),
+
+        require('chainpad-listmap'),
+        require('chainpad-crypto'),
+        require('chainpad-netflux'),
+        require('chainpad'),
+        require('nthen'),
+        require('saferphore'),
+        require('tweetnacl/nacl-fast'),
+    );
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define([
+        '/common/common-util.js',
+        '/common/common-hash.js',
+        '/common/common-constants.js',
+        '/common/common-realtime.js',
+
+        '/common/proxy-manager.js',
+        '/common/user-object.js',
+        '/common/outer/sharedfolder.js',
+        '/common/outer/roster.js',
+        '/common/common-messaging.js',
+        '/common/common-feedback.js',
+        '/common/outer/invitation.js',
+        '/common/cryptget.js',
+        '/common/outer/cache-store.js',
+
+        'chainpad-listmap',
+        '/components/chainpad-crypto/crypto.js',
+        'chainpad-netflux',
+        '/components/chainpad/chainpad.dist.js',
+        '/components/nthen/index.js',
+        '/components/saferphore/index.js',
+        '/components/tweetnacl/nacl-fast.min.js',
+    ], factory);
+} else {
+    // unsupported initialization
+}
+
+})();
diff --git a/src/worker/modules/test.ts b/src/worker/modules/test.ts
new file mode 100644
index 000000000..e24e970ef
--- /dev/null
+++ b/src/worker/modules/test.ts
@@ -0,0 +1,32 @@
+import nacl from 'tweetnacl';
+import { Module, ModuleObject } from '../types'
+
+export interface TestModuleObject extends ModuleObject {
+    toBase64: (str: string) => string
+}
+
+const TestModule: Module<TestModuleObject> = {
+
+    init: (config, cb) => {
+        let myTest = {};
+
+        cb();
+
+        return {
+            removeClient: (clientId) => {
+                console.log('Remove client', clientId);
+            },
+            execCommand: (clientId, obj, cb) => {
+                console.log('Exex command', clientId, obj);
+                cb();
+            },
+            toBase64: (str) => {
+                return nacl.util.encodeBase64(nacl.util.decodeUTF8(str));
+            }
+        }
+    }
+
+
+};
+
+export { TestModule }
diff --git a/src/worker/store.ts b/src/worker/store.ts
new file mode 100644
index 000000000..846163a72
--- /dev/null
+++ b/src/worker/store.ts
@@ -0,0 +1,93 @@
+import nacl from 'tweetnacl/nacl-fast';
+import { Module } from './types';
+import { TestModule, TestModuleObject } from './modules/test';
+import * as Util from '../common/common-util.js';
+import * as Hash from '../common/common-hash.js';
+import * as Feedback from '../common/common-feedback.js';
+import * as Realtime from '../common/common-realtime.js';
+import * as Messaging from '../common/common-messaging.js';
+import * as Constants from '../common/common-constants.js';
+import * as Credential from '../common/common-credential.js';
+import * as ProxyManager from '../common/proxy-manager.js';
+import * as UO from '../common/user-object.js';
+import * as UOSetter from '../common/user-object-setter.js';
+import * as Pinpad from '../common/pinpad.js';
+import * as PadTypes from '../common/pad-types.js';
+import * as NetworkConfig from '../common/network-config.js';
+import * as LoginBlock from '../common/login-block.js';
+import * as Migrate from './components/migrate-user-object.js';
+
+
+// Modules
+import * as Mailbox from './modules/mailbox.js';
+import * as Cursor from './modules/cursor.js';
+import * as Support from './modules/support.js';
+import * as Integration from './modules/integration.js';
+
+import * as OnlyOffice from './modules/onlyoffice.js';
+import * as Profile from './modules/profile.js';
+import * as Team from './modules/team.js';
+import * as Messenger from './modules/messenger.js';
+
+import * as History from './modules/history.js';
+import * as Calendar from './modules/calendar.js';
+
+interface StoreConfig {
+    ApiConfig: any,
+    AppConfig: any,
+    Broadcast: any,
+    Messages: any
+}
+
+
+let start = (cfg: StoreConfig):void => {
+
+    [
+        Feedback,
+        UO,
+        Constants,
+        ProxyManager,
+        NetworkConfig,
+        Migrate,
+        LoginBlock,
+        PadTypes,
+        Credential,
+        Cursor,
+        Support,
+        Calendar
+    ].forEach(dep => {
+        if (typeof(dep.setCustomize) === "function") {
+            dep.setCustomize(cfg);
+        }
+    });
+
+    const AppConfig = cfg.AppConfig;
+
+    let test = TestModule.init({
+        emit: () => {}
+    }, () => {
+        console.log('Test initialized');
+    });
+    let b64 = test.toBase64('pewpewPEZPEZ');
+    console.error(b64);
+    console.error(AppConfig.minimumPasswordLength, AppConfig.degradedLimit);
+    console.error(Hash.getSecrets);
+    console.error(Util.mkEvent);
+    console.error(Messaging.createData);
+    console.log('UO & UOSetter:');
+    console.error(UO.getDefaultName({type:'pad'}));
+    console.error(UO.getDefaultName);
+    console.error(UOSetter.init);
+    console.error(ProxyManager.createInner);
+    console.log('Pinpad');
+    console.error(Pinpad.create);
+    console.error(LoginBlock.getBlockUrl);
+    console.error(Mailbox.init, Cursor.init, Support.init, Integration.init);
+    console.error(Profile.init, OnlyOffice.init, Team.init, Messenger.init);
+    console.error(History.init, Calendar.init);
+};
+
+export {
+    start
+};
+
diff --git a/src/worker/types.ts b/src/worker/types.ts
new file mode 100644
index 000000000..8bc6e72f6
--- /dev/null
+++ b/src/worker/types.ts
@@ -0,0 +1,28 @@
+// Default CryptPad worker module, extended with
+// specific methods for each module
+type Callback = (...args: any[]) => void
+
+declare module globalThis {
+    let CryptPad_Messages: any;
+    let CryptPad_AppConfig: any;
+    let window: any;
+}
+
+export type ModuleConfig = {
+    emit: Function
+}
+
+export type CommandData = {
+    cmd: string,
+    data: any
+}
+
+export interface ModuleObject {
+    removeClient: (clientId: string) => void
+    execCommand: (clientId: string, obj: CommandData, cb: Callback) => void
+}
+
+export interface Module<T> {
+    init: (config: ModuleConfig, cb: Callback) => T
+}
+
diff --git a/testapi.js b/testapi.js
index b0f1c832b..b909bb4c5 100644
--- a/testapi.js
+++ b/testapi.js
@@ -1,4 +1,4 @@
-const Messages = require('./_src/messages');
+const Messages = require('./src/messages');
 const AppConfig = require('./customize/application_config');
 const App = require('./_build/worker.bundle');
 const Http = require('node:http');
diff --git a/tsconfig.json b/tsconfig.json
index d559e5876..1fe96fa51 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -6,6 +6,6 @@
         "moduleResolution": "node",
         "outDir": "./_build"
     },
-    "include": ["_src/**/*"]
+    "include": ["src/**/*"]
 }
 
diff --git a/www/calendar/recurrence.js b/www/calendar/recurrence.js
index 601a84130..dd6eac787 100644
--- a/www/calendar/recurrence.js
+++ b/www/calendar/recurrence.js
@@ -2,9 +2,8 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-define([
-    '/common/common-util.js',
-], function (Util) {
+(() => {
+const factory = (Util) => {
     var Rec = {};
 
     var debug = function () {};
@@ -896,4 +895,13 @@ define([
 
 
     return Rec;
-});
+};
+
+if (typeof(module) !== 'undefined' && module.exports) {
+    module.exports = factory('../../common/common-util');
+} else if ((typeof(define) !== 'undefined' && define !== null) && (define.amd !== null)) {
+    define(['/common/common-util.js'], factory);
+} else {
+    // unsupported initialization
+}
+})();
diff --git a/www/common/outer/async-store.js b/www/common/outer/async-store.js
index 7444e99e0..f92255e3e 100644
--- a/www/common/outer/async-store.js
+++ b/www/common/outer/async-store.js
@@ -17,16 +17,16 @@ define([
     '/common/pinpad.js', // OK
     '/common/outer/cache-store.js', // OK
     '/common/outer/sharedfolder.js', // OK
-    '/common/outer/cursor.js',
-    '/common/outer/support.js',
-    '/common/outer/integration.js',
-    '/common/outer/onlyoffice.js',
+    '/common/outer/cursor.js', // OK
+    '/common/outer/support.js', // OK
+    '/common/outer/integration.js', // OK
+    '/common/outer/onlyoffice.js', // OK
     '/common/outer/mailbox.js', // OK
-    '/common/outer/profile.js',
-    '/common/outer/team.js',
-    '/common/outer/messenger.js',
-    '/common/outer/history.js',
-    '/common/outer/calendar.js',
+    '/common/outer/profile.js', // OK
+    '/common/outer/team.js', // OK
+    '/common/outer/messenger.js', // OK
+    '/common/outer/history.js', // OK
+    '/common/outer/calendar.js', // OK
     '/common/outer/login-block.js', // OK
     '/common/outer/network-config.js', // OK
     '/customize/application_config.js', // OK