diff --git a/lib/workers/db-worker.js b/lib/workers/db-worker.js
index 42c75fdca..0b4c4d03d 100644
--- a/lib/workers/db-worker.js
+++ b/lib/workers/db-worker.js
@@ -568,7 +568,7 @@ process.on('message', function (data) {
 
     const cb = function (err, value) {
         process.send({
-            error: err,
+            error: Util.serializeError(err),
             txid: data.txid,
             pid: data.pid,
             value: value,
@@ -577,7 +577,7 @@ process.on('message', function (data) {
 
     if (!ready) {
         return void init(data.config, function (err) {
-            if (err) { return void cb(err); }
+            if (err) { return void cb(Util.serializeError(err)); }
             ready = true;
             cb();
         });
diff --git a/lib/workers/index.js b/lib/workers/index.js
index 6e9f57e88..522339812 100644
--- a/lib/workers/index.js
+++ b/lib/workers/index.js
@@ -9,6 +9,7 @@ const PID = process.pid;
 
 const DB_PATH = 'lib/workers/db-worker';
 const MAX_JOBS = 16;
+const DEFAULT_QUERY_TIMEOUT = 60000 * 15; // increased from three to fifteen minutes because queries for very large files were taking as long as seven minutes
 
 Workers.initialize = function (Env, config, _cb) {
     var cb = Util.once(Util.mkAsync(_cb));
@@ -113,6 +114,7 @@ Workers.initialize = function (Env, config, _cb) {
         const txid = guid();
         var cb = Util.once(Util.mkAsync(Util.both(_cb, function (err /*, value */) {
             if (err !== 'TIMEOUT') { return; }
+            Log.debug("WORKER_TIMEOUT_CAUSE", msg);
             // in the event of a timeout the user will receive an error
             // but the state used to resend a query in the event of a worker crash
             // won't be cleared. This also leaks a slot that could be used to keep
@@ -132,7 +134,7 @@ Workers.initialize = function (Env, config, _cb) {
         state.tasks[txid] = msg;
 
         // default to timing out affter 180s if no explicit timeout is passed
-        var timeout = typeof(opt.timeout) !== 'undefined'? opt.timeout: 180000;
+        var timeout = typeof(opt.timeout) !== 'undefined'? opt.timeout: DEFAULT_QUERY_TIMEOUT;
         response.expect(txid, cb, timeout);
         state.worker.send(msg);
     };
diff --git a/server.js b/server.js
index 60247f47a..eb2787475 100644
--- a/server.js
+++ b/server.js
@@ -202,6 +202,7 @@ var serveConfig = (function () {
                 adminKeys: Env.admins,
                 inactiveTime: Env.inactiveTime,
                 supportMailbox: Env.supportMailbox,
+                defaultStorageLimit: Env.defaultStorageLimit,
                 maxUploadSize: Env.maxUploadSize,
                 premiumUploadSize: Env.premiumUploadSize,
             }, null, '\t'),
diff --git a/www/common/common-util.js b/www/common/common-util.js
index 41797e7c8..dfc6e12d7 100644
--- a/www/common/common-util.js
+++ b/www/common/common-util.js
@@ -30,6 +30,15 @@
         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;}
     };
@@ -113,13 +122,13 @@
         var handle = function (id, args) {
             var fn = pending[id];
             if (typeof(fn) !== 'function') {
-                errorHandler("MISSING_CALLBACK", {
+                return void errorHandler("MISSING_CALLBACK", {
                     id: id,
                     args: args,
                 });
             }
             try {
-                pending[id].apply(null, Array.isArray(args)? args : [args]);
+                fn.apply(null, Array.isArray(args)? args : [args]);
             } catch (err) {
                 errorHandler('HANDLER_ERROR', {
                     error: err,
diff --git a/www/common/cryptpad-common.js b/www/common/cryptpad-common.js
index ca65ce77b..9a9807e7e 100644
--- a/www/common/cryptpad-common.js
+++ b/www/common/cryptpad-common.js
@@ -2057,6 +2057,33 @@ define([
 
         var userHash;
 
+        (function iOSFirefoxFix () {
+/*
+    For some bizarre reason Firefox on iOS throws an error during the
+    loading process unless we call this function. Drawing these elements
+    to the DOM presumably causes the JS engine to wait just a little bit longer
+    until some APIs we need are ready. This occurs despite all this code being
+    run after the usual dom-ready events. This fix was discovered while trying
+    to log the error messages to the DOM because it's extremely difficult
+    to debug Firefox iOS in the usual ways. In summary, computers are terrible.
+*/
+             try {
+                var style = document.createElement('style');
+                    style.type = 'text/css';
+                    style.appendChild(document.createTextNode('#cp-logger { display: none; }'));
+                document.head.appendChild(style);
+
+                var logger = document.createElement('div');
+                    logger.setAttribute('id', 'cp-logger');
+                document.body.appendChild(logger);
+
+                var pre = document.createElement('pre');
+                    pre.innerText = 'x';
+                    pre.style.display = 'none';
+                logger.appendChild(pre);
+            } catch (err) { console.error(err); }
+        }());
+
         Nthen(function (waitFor) {
             if (AppConfig.beforeLogin) {
                 AppConfig.beforeLogin(LocalStore.isLoggedIn(), waitFor());
diff --git a/www/common/notify.js b/www/common/notify.js
index a3c8cd2b8..81dee662d 100644
--- a/www/common/notify.js
+++ b/www/common/notify.js
@@ -16,6 +16,8 @@ define(['/api/config'], function (ApiConfig) {
 
     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); }