@sasjs/cli 6.1.0 → 6.2.1

package/build/commands/build/internal/mockSite/assets/sw.js

@@ -40,6 +40,87 @@ const text = (body, status) =>
     headers: { 'content-type': 'text/plain' }
   })
 
+/**
+ * A byte body travels as base64. The runtime encodes it, and refuses a drive
+ * entry that will not decode before it hands the value over, so this is a plain
+ * decode - the corrupt-entry error lives in one place, runtime-core.js.
+ */
+const toBytes = (base64) => {
+  const binary = atob(String(base64 || '').replace(/\s+/g, ''))
+  const out = new Uint8Array(binary.length)
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i)
+  return out
+}
+
+// ------------------------------------------------------------ webout headers
+// A service declares the response it wants by writing `Name: value` lines to
+// the file the preamble hands it as _SASJS_WEBOUT_HEADERS - the same channel
+// %mp_streamfile uses on the SAS side, and the one the server reads. Only the
+// two headers that change how a reply is delivered are applied: the content
+// type, and the disposition that makes the browser save it under the name the
+// service chose. Everything else (cache-control, cookies, ...) has no meaning
+// on a static host.
+const RESPONSE_HEADERS = ['content-type', 'content-disposition']
+
+/**
+ * Parses what the service wrote. A header value is a byte string, so a value up
+ * to U+00FF is passed through as written - the same bytes node writes when the
+ * server sets the same header, which is what the mock has to match. HTAB is
+ * allowed inside a field value by HTTP and the server passes it through, so it
+ * is part of the set.
+ *
+ * 0x7F and 0x80-0x9F are outside it: the browser's Headers implementation strips
+ * those bytes from a value without complaining, which would save a download
+ * under a name with characters missing, so such a value is refused instead and
+ * the reply keeps its default delivery. CR, LF and NUL are refused for the same
+ * reason - they make the Response constructor throw.
+ *
+ * A filename outside ASCII belongs in RFC 6266 form
+ * (`filename*=UTF-8''r%C3%A9sum%C3%A9.csv`) - raw non-ASCII bytes in a header
+ * are not portable, on this host or on the server.
+ */
+const HEADER_VALUE = /^[\x09\x20-\x7E\xA0-\xFF]+$/
+
+const parseHeaders = (content) => {
+  const headers = {}
+  String(content || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .forEach((line) => {
+      const separator = line.indexOf(':')
+      if (separator < 1) return
+      const name = line.slice(0, separator).trim().toLowerCase()
+      const value = line.slice(separator + 1).trim()
+      if (!RESPONSE_HEADERS.includes(name)) return
+      // the last line for a name wins, and a value that cannot be sent removes
+      // the header - the rule the server applies in extractHeaders
+      if (HEADER_VALUE.test(value)) headers[name] = value
+      else delete headers[name]
+    })
+  return headers
+}
+
+/**
+ * The reply a run produces: the webout, in the shape and under the name the
+ * service asked for. A debug reply is the webout framed with the log, so it
+ * stays text - honouring a download there would put the frame in the file.
+ */
+const weboutResponse = (result, debug) => {
+  if (debug)
+    return text(
+      [result.webout, LOGS_SEPARATOR, result.log, LOGS_SEPARATOR].join('\n')
+    )
+
+  const headers = parseHeaders(result.headers)
+  if (result.binary) {
+    if (!headers['content-type'])
+      headers['content-type'] = 'application/octet-stream'
+    return new Response(toBytes(result.webout), { status: 200, headers })
+  }
+  return new Response(result.webout, { status: 200, headers })
+}
+
 const broadcast = async (message) => {
   const clients = await self.clients.matchAll({ includeUncontrolled: true })
   clients.forEach((client) => client.postMessage(message))
@@ -105,7 +186,12 @@ const handle = async (request, url) => {
     }
 
     if (path.endsWith('/SASjsApi/drive/file') && request.method === 'GET') {
-      return text(R.read(query._filePath || '').contents)
+      const file = R.read(query._filePath || '')
+      return file.binary
+        ? new Response(toBytes(file.contents), {
+            headers: { 'content-type': 'application/octet-stream' }
+          })
+        : text(file.contents)
     }
 
     if (
@@ -138,13 +224,7 @@ const handle = async (request, url) => {
         )
       }
       const debug = String(merged._debug || '').length > 0
-      return text(
-        debug
-          ? [result.webout, LOGS_SEPARATOR, result.log, LOGS_SEPARATOR].join(
-              '\n'
-            )
-          : result.webout
-      )
+      return weboutResponse(result, debug)
     }
 
     if (path.includes('/SASjsApi/session')) {
@@ -219,9 +299,18 @@ self.addEventListener('message', (event) => {
 
     case 'sasjs-stats':
       event.waitUntil(
-        R.ensureReady().then(() =>
-          reply({ type: 'sasjs-stats', boot: R.bootInfo(), stats: R.stats() })
-        )
+        R.ensureReady().then(() => {
+          try {
+            reply({ type: 'sasjs-stats', boot: R.bootInfo(), stats: R.stats() })
+          } catch (e) {
+            // a corrupt entry fails the whole total, so the page is answered
+            // with the reason instead of waiting out its own timeout
+            reply({
+              type: 'sasjs-stats',
+              error: (e && e.message) || String(e)
+            })
+          }
+        })
       )
       break
   }

package/build/commands/build/internal/mockSite/mockSite.d.ts

@@ -10,6 +10,17 @@ export interface MockSiteResult {
     /** True when a captured drive snapshot was shipped with the site. */
     snapshot: boolean;
 }
+/**
+ * The bounds on what the browser drive seeds. A byte entry is carried as base64
+ * in vfs-seed.json and held in the worker's memory, so a large artefact - an
+ * export, a media file, a vendored archive - makes the generated site
+ * unloadable: one file over the per-file bound, or enough files to pass the
+ * total, is left off the drive and named in a warning, as every non-text file
+ * was when the drive carried text only. Text has no bound: a program folder is
+ * text by nature and the drive has always carried it.
+ */
+export declare const MAX_BINARY_SEED_BYTES: number;
+export declare const MAX_SEED_BYTES: number;
 /**
  * Builds a static site that runs the project's JS services (its mocks) in the
  * browser, so a frontend can be tested with no server and no SAS.

package/build/commands/build/internal/mockSite/mockSite.js

@@ -75,6 +75,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = void 0;
 exports.buildMockSite = buildMockSite;
 var crypto_1 = require("crypto");
 var fs_1 = __importDefault(require("fs"));
@@ -140,28 +141,58 @@ var copyFolder = function (from, to) {
  */
 var PROGRAM_FOLDERS = ['services', 'jobs', 'tests'];
 /**
- * A drive file is a string in the browser runtime, so a file that does not
- * survive a UTF-8 round trip (an image, an archive, a compiled artefact) cannot
- * be carried onto it. Returning null for those keeps the site honest: the app
- * sees a missing file rather than mojibake it would happily write back.
+ * The bounds on what the browser drive seeds. A byte entry is carried as base64
+ * in vfs-seed.json and held in the worker's memory, so a large artefact - an
+ * export, a media file, a vendored archive - makes the generated site
+ * unloadable: one file over the per-file bound, or enough files to pass the
+ * total, is left off the drive and named in a warning, as every non-text file
+ * was when the drive carried text only. Text has no bound: a program folder is
+ * text by nature and the drive has always carried it.
  */
-var readTextFile = function (absolute) {
+exports.MAX_BINARY_SEED_BYTES = 10 * 1024 * 1024;
+exports.MAX_SEED_BYTES = 25 * 1024 * 1024;
+/**
+ * What the drive stores for a file: its text when the bytes survive a UTF-8
+ * round trip, and behind the byte marker (BINARY_PREFIX in runtime-core.js)
+ * otherwise. An archive, an image or an xlsx therefore lands on the drive as
+ * bytes, so a service that downloads a project-supplied file finds it.
+ *
+ * Text that begins with U+0000 is escaped, because the runtime reads a leading
+ * NUL as its own marker - the same rule the runtime applies to a write.
+ */
+var DRIVE_BINARY_PREFIX = '\u0000base64:';
+var DRIVE_TEXT_PREFIX = '\u0000text:';
+/** A byte count in MB, for the message that names a file too large to seed. */
+var megabytes = function (bytes) {
+    return "".concat(Math.round((bytes / 1024 / 1024) * 10) / 10, " MB");
+};
+var readDriveFile = function (absolute) {
     var buffer = fs_1.default.readFileSync(absolute);
     var text = buffer.toString('utf8');
-    return Buffer.from(text, 'utf8').equals(buffer) ? text : null;
+    if (!Buffer.from(text, 'utf8').equals(buffer))
+        return {
+            contents: DRIVE_BINARY_PREFIX + buffer.toString('base64'),
+            // the raw size, which is what the seed bounds are measured in
+            bytes: buffer.length
+        };
+    return {
+        contents: text.startsWith('\u0000') ? DRIVE_TEXT_PREFIX + text : text
+    };
 };
 var seedFromBuild = function (buildFolder, appLoc, exclude, excludeFolders) {
-    var e_3, _a, e_4, _b;
+    var e_3, _a, e_4, _b, e_5, _c;
     if (exclude === void 0) { exclude = []; }
     if (excludeFolders === void 0) { excludeFolders = []; }
     var files = {};
     var skipped = [];
     var driveBase = "/sasjs/drive/files".concat(appLoc);
+    var seededBytes = 0;
     // Every folder of the build goes on the drive, so a sync folder's content (a
     // licence store, for instance) survives as well as the program folders.
     var directories = fs_1.default
         .readdirSync(buildFolder, { withFileTypes: true })
         .filter(function (entry) { return entry.isDirectory(); });
+    var candidates = [];
     try {
         for (var directories_1 = __values(directories), directories_1_1 = directories_1.next(); !directories_1_1.done; directories_1_1 = directories_1.next()) {
             var entry = directories_1_1.value;
@@ -172,22 +203,18 @@ var seedFromBuild = function (buildFolder, appLoc, exclude, excludeFolders) {
                 var key = "".concat(driveBase, "/").concat(entry.name, "/").concat(relative);
                 if (exclude.some(function (prefix) { return key.startsWith(prefix); }))
                     return "continue";
-                var contents = readTextFile(path_1.default.join(folder, relative));
-                if (contents === null)
-                    skipped.push(key);
-                else
-                    files[key] = contents;
+                candidates.push({ key: key, absolute: path_1.default.join(folder, relative) });
             };
             try {
-                for (var _c = (e_4 = void 0, __values(listFiles(folder))), _d = _c.next(); !_d.done; _d = _c.next()) {
-                    var relative = _d.value;
+                for (var _d = (e_4 = void 0, __values(listFiles(folder))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var relative = _e.value;
                     _loop_1(relative);
                 }
             }
             catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
-                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
                 }
                 finally { if (e_4) throw e_4.error; }
             }
@@ -200,6 +227,39 @@ var seedFromBuild = function (buildFolder, appLoc, exclude, excludeFolders) {
         }
         finally { if (e_3) throw e_3.error; }
     }
+    // The budget is spent in path order, not in whatever order the folder listing
+    // returns, so the same project yields the same drive - and the same warning -
+    // on every machine and filesystem.
+    candidates.sort(function (first, second) {
+        return first.key < second.key ? -1 : first.key > second.key ? 1 : 0;
+    });
+    try {
+        for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+            var candidate = candidates_1_1.value;
+            var file = readDriveFile(candidate.absolute);
+            // a byte entry counts against both bounds; a text entry counts against
+            // neither, because the drive has always carried the program folders
+            if (file.bytes !== undefined) {
+                if (file.bytes > exports.MAX_BINARY_SEED_BYTES) {
+                    skipped.push({ key: candidate.key, bytes: file.bytes, limit: 'file' });
+                    continue;
+                }
+                if (seededBytes + file.bytes > exports.MAX_SEED_BYTES) {
+                    skipped.push({ key: candidate.key, bytes: file.bytes, limit: 'total' });
+                    continue;
+                }
+                seededBytes += file.bytes;
+            }
+            files[candidate.key] = file.contents;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (candidates_1_1 && !candidates_1_1.done && (_c = candidates_1.return)) _c.call(candidates_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
     return { files: files, skipped: skipped };
 };
 /**
@@ -282,7 +342,7 @@ var patchIndexHtml = function (html, version) {
 function buildMockSite(target) {
     return __awaiter(this, void 0, void 0, function () {
         var projectDir, appLocRaw, appLoc, buildFolder, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, driveEntries, webFileCount, hostFolder, _b, _c, asset, hostVersion, swPath, snapshotSource, hasSnapshot, indexPath, _d, patched, warnings;
-        var e_5, _e;
+        var e_6, _e;
         var _f, _g, _h;
         return __generator(this, function (_j) {
             switch (_j.label) {
@@ -332,8 +392,15 @@ function buildMockSite(target) {
                             'Build a target whose services are JavaScript (typically a mocks project).');
                     }
                     if (skipped.length) {
-                        (_h = process.logger) === null || _h === void 0 ? void 0 : _h.warn("Left ".concat(skipped.length, " non-text file(s) off the mock drive, which holds text files only: ") +
-                            "".concat(skipped.slice(0, 3).join(', ')).concat(skipped.length > 3 ? ', ...' : ''));
+                        (_h = process.logger) === null || _h === void 0 ? void 0 : _h.warn("Left ".concat(skipped.length, " file(s) off the mock drive, over the ").concat(megabytes(exports.MAX_BINARY_SEED_BYTES), " per-file or ").concat(megabytes(exports.MAX_SEED_BYTES), " total the browser build seeds: ") +
+                            "".concat(skipped
+                                .slice(0, 3)
+                                .map(function (file) {
+                                return "".concat(file.key, " (").concat(megabytes(file.bytes), ", ").concat(file.limit === 'file'
+                                    ? 'over the per-file limit'
+                                    : 'over the drive budget', ")");
+                            })
+                                .join(', ')).concat(skipped.length > 3 ? ', ...' : ''));
                     }
                     // Only now is the previous site expendable.
                     fs_1.default.rmSync(outputFolder, { recursive: true, force: true });
@@ -354,12 +421,12 @@ function buildMockSite(target) {
                             fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, asset), path_1.default.join(hostFolder, asset));
                         }
                     }
-                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
                     finally {
                         try {
                             if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
                         }
-                        finally { if (e_5) throw e_5.error; }
+                        finally { if (e_6) throw e_6.error; }
                     }
                     // sw.js sits at the site root: a worker can only control the folder it is
                     // served from, and the app has to be controlled from /

package/build/commands/build/internal/mockSite/spec/mockSite.spec.js

@@ -228,23 +228,115 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
-    it('leaves non-text files off the drive instead of corrupting them', function () { return __awaiter(void 0, void 0, void 0, function () {
+    it('carries a non-text file onto the drive as bytes', function () { return __awaiter(void 0, void 0, void 0, function () {
         var png, result, seed;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'fixtures.json'), '{}');
+                    fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'logo.png'), png);
+                    // text that begins with the marker's own NUL is escaped, so it cannot be
+                    // mistaken for a byte entry
+                    fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'odd.txt'), '\u0000base64:not really');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _a.sent();
+                    seed = readSeed();
+                    // stored behind the marker the runtime decodes, and the text files beside it
+                    // stay text
+                    expect(seed.files["/sasjs/drive/files".concat(appLoc, "/mock-storage/logo.png")]).toBe('\u0000base64:' + png.toString('base64'));
+                    expect(seed.files["/sasjs/drive/files".concat(appLoc, "/mock-storage/fixtures.json")]).toBe('{}');
+                    expect(seed.files["/sasjs/drive/files".concat(appLoc, "/mock-storage/odd.txt")]).toBe('\u0000text:\u0000base64:not really');
+                    expect(result.driveEntries).toBe(7); // 3 programs + 3 text files + the png
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves a byte file over the seed bound off the drive, and names it', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, seed;
         var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
-                    png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
                     write(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'fixtures.json'), '{}');
-                    fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'logo.png'), png);
+                    fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'export.zip'), Buffer.alloc(mockSite_1.MAX_BINARY_SEED_BYTES + 1, 0x89));
                     return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
                 case 1:
                     result = _b.sent();
                     seed = readSeed();
-                    expect(Object.keys(seed.files).some(function (k) { return k.endsWith('logo.png'); })).toBe(false);
-                    expect(seed.files["/sasjs/drive/files".concat(appLoc, "/mock-storage/fixtures.json")]).toBe('{}');
+                    // one large artefact must not make the generated site unloadable
+                    expect(seed.files["/sasjs/drive/files".concat(appLoc, "/mock-storage/export.zip")]).toBeUndefined();
                     expect(result.driveEntries).toBe(5); // 3 programs + 2 text files
-                    expect((_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn).toHaveBeenCalledWith(expect.stringContaining('logo.png'));
+                    expect((_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn).toHaveBeenCalledWith(expect.stringContaining('export.zip (10 MB'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('stops seeding bytes once the drive budget is spent, and names the file', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var chunk, _a, _b, name_1, seed, seeded;
+        var e_2, _c;
+        var _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'fixtures.json'), '{}');
+                    chunk = Buffer.alloc(Math.floor(mockSite_1.MAX_BINARY_SEED_BYTES * 0.9), 0x89);
+                    try {
+                        for (_a = __values(['one.bin', 'two.bin', 'three.bin']), _b = _a.next(); !_b.done; _b = _a.next()) {
+                            name_1 = _b.value;
+                            fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', name_1), chunk);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
+                        // the budget is spent in path order, so the drive is the same on every host:
+                        // one and three fit, two does not
+                    ];
+                case 1:
+                    _e.sent();
+                    seed = readSeed();
+                    seeded = Object.keys(seed.files)
+                        .filter(function (key) { return key.endsWith('.bin'); })
+                        .map(function (key) { return key.slice(key.lastIndexOf('/') + 1); });
+                    expect(seeded).toEqual(['one.bin', 'three.bin']);
+                    expect((_d = process.logger) === null || _d === void 0 ? void 0 : _d.warn).toHaveBeenCalledWith(expect.stringContaining('two.bin (9 MB, over the drive budget)'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('seeds a project file the runtime reads back as its bytes', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var png, runtime, served;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'fixtures.json'), '{}');
+                    fs_1.default.writeFileSync(path_1.default.join(root, 'sasjsbuild', 'mock-storage', 'logo.png'), png);
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
+                        // the seed is only useful if the runtime decodes what the build wrote
+                    ];
+                case 1:
+                    _a.sent();
+                    global.self = {};
+                    jest.resetModules();
+                    runtime = require('../assets/runtime-core.js');
+                    runtime.load(readSeed().files);
+                    served = runtime.run({
+                        code: [
+                            "const file = '/sasjs/drive/files".concat(appLoc, "/mock-storage/logo.png'"),
+                            "_webout = [fs.readFileSync(file).toString('hex'), fs.statSync(file).size].join('|')"
+                        ].join('\n')
+                    });
+                    delete global.self;
+                    expect(served.error).toBeNull();
+                    expect(served.webout).toBe("".concat(png.toString('hex'), "|").concat(png.length));
                     return [2 /*return*/];
             }
         });
@@ -355,8 +447,8 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('refuses a mockWebFolder that would delete the project or its inputs', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var _a, _b, mockWebFolder, e_2_1;
-        var e_2, _c;
+        var _a, _b, mockWebFolder, e_3_1;
+        var e_3, _c;
         return __generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
@@ -387,14 +479,14 @@ describe('browser-hosted build', function () {
                     return [3 /*break*/, 1];
                 case 4: return [3 /*break*/, 7];
                 case 5:
-                    e_2_1 = _d.sent();
-                    e_2 = { error: e_2_1 };
+                    e_3_1 = _d.sent();
+                    e_3 = { error: e_3_1 };
                     return [3 /*break*/, 7];
                 case 6:
                     try {
                         if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
                     }
-                    finally { if (e_2) throw e_2.error; }
+                    finally { if (e_3) throw e_3.error; }
                     return [7 /*endfinally*/];
                 case 7:
                     expect(fs_1.default.existsSync(path_1.default.join(root, 'client', 'dist', 'index.html'))).toBe(true);

package/build/commands/build/internal/mockSite/spec/persist.spec.js

@@ -279,9 +279,8 @@ describe('page-side store', function () {
                     return [4 /*yield*/, window.SASjsMock.writeFiles({ '/sasjs/drive/b.txt': 'bb' })];
                 case 5:
                     _a.sent();
-                    return [4 /*yield*/, expect(window.SASjsMock.stats()).resolves.toEqual({
-                            files: 1,
-                            bytes: 2
+                    return [4 /*yield*/, expect(window.SASjsMock.readAll()).resolves.toEqual({
+                            '/sasjs/drive/b.txt': 'bb'
                         })];
                 case 6:
                     _a.sent();
@@ -295,6 +294,65 @@ describe('page-side store', function () {
             }
         });
     }); });
+    it('takes the drive total from the worker, which owns the storage format', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, posted, reply, pending;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = loadPersist(), window = _a.window, posted = _a.posted, reply = _a.reply;
+                    pending = window.SASjsMock.stats();
+                    return [4 /*yield*/, Promise.resolve()];
+                case 1:
+                    _b.sent();
+                    expect(posted).toContainEqual({ type: 'sasjs-stats' });
+                    // the worker measures a byte entry as its bytes, not as base64
+                    reply({ type: 'sasjs-stats', boot: {}, stats: { files: 2, bytes: 7 } });
+                    return [4 /*yield*/, expect(pending).resolves.toEqual({ files: 2, bytes: 7 })];
+                case 2:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fails the read when the worker cannot report, rather than returning NaN', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var window, pending;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jest.useFakeTimers();
+                    window = loadPersist().window;
+                    pending = expect(window.SASjsMock.stats()).rejects.toThrow('timed out waiting for sasjs-stats');
+                    return [4 /*yield*/, jest.advanceTimersByTimeAsync(20000)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, pending];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('fails the read when the reply carries no stats', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, window, reply, pending;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = loadPersist(), window = _a.window, reply = _a.reply;
+                    pending = expect(window.SASjsMock.stats()).rejects.toThrow('carried no stats');
+                    return [4 /*yield*/, Promise.resolve()
+                        // a worker left over from an older build answers the message with no stats
+                    ];
+                case 1:
+                    _b.sent();
+                    // a worker left over from an older build answers the message with no stats
+                    reply({ type: 'sasjs-stats' });
+                    return [4 /*yield*/, pending];
+                case 2:
+                    _b.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('writes nothing when a change set is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
         var window;
         return __generator(this, function (_a) {