@sasjs/cli 6.29.0 → 6.30.1

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

@@ -79,7 +79,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DRIVE_FORMAT = exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = exports.buildLintBundle = exports.WEBOUT_SENTINELS = void 0;
+exports.SHARD_GROUP_BYTES = exports.SHARD_FILE_BYTES = exports.DRIVE_FORMAT = exports.MAX_SEED_BYTES = exports.MAX_BINARY_SEED_BYTES = exports.buildLintBundle = exports.WEBOUT_SENTINELS = void 0;
 exports.buildMockSite = buildMockSite;
 var crypto_1 = require("crypto");
 var fs_1 = __importDefault(require("fs"));
@@ -130,10 +130,11 @@ var toPosix = function (value) { return value.split(path_1.default.sep).join('/'
  * configuration by walking a filesystem - but the linter's core (`lintText`,
  * `formatText`) reads only the text it is given and the configuration it is
  * passed, so the two can run anywhere the module graph can be built. This
- * bundle is that graph: the package's own code service, the linter it wraps, and
- * shims for the four node modules reached at import time (`path` and `os` for
- * resolution, `fs` and `@sasjs/utils/file` for the config lookup that a mock
- * never makes, because it hands the linter the default configuration).
+ * bundle is that graph: the package's own code service, the configuration class
+ * a host builds from its own rules file, the linter behind both, and shims for
+ * the four node modules reached at import time (`path` and `os` for resolution,
+ * `fs` and `@sasjs/utils/file` for the linter's own filesystem lookup, which
+ * this host never makes - it hands the routes the rules it read from the drive).
  *
  * It is built from the installed @sasjs/api and @sasjs/lint on every mock
  * build, so the rules a client sees are the version the CLI resolved - a
@@ -142,8 +143,8 @@ var toPosix = function (value) { return value.split(path_1.default.sep).join('/'
 var LINT_BUNDLE_FILES = {
     'entry.js': [
         "import './process.js'",
-        "import { createCodeService } from '@sasjs/api/code'",
-        'globalThis.SASjsCode = { createCodeService }'
+        "import { createCodeService, LintConfig } from '@sasjs/api/code'",
+        'globalThis.SASjsCode = { createCodeService, LintConfig }'
     ].join('\n'),
     'process.js': [
         '// the linter reads process.env for a default and process.cwd() for a root;',
@@ -511,6 +512,137 @@ var countPrograms = function (files, extension) {
         return inProgramFolder && key.toLowerCase().endsWith(extension);
     }).length;
 };
+/**
+ * The size at which a captured file is fetched on its own rather than with its
+ * folder.
+ *
+ * A shard is a download the visitor waits for, and an app's folder holds both
+ * its bundles and the small files a listing shows - its logo, a config. Splitting
+ * on size keeps one from dragging the other: the tile asks for the folder's small
+ * files, the app's own page asks for the bundle.
+ */
+exports.SHARD_FILE_BYTES = 256 * 1024;
+/**
+ * The size below which a folder's files ride in the boot shard.
+ *
+ * The boot shard is fetched before the first page renders, so it is paid by every
+ * visit. Folders under this size are cheaper there than as a request of their
+ * own; folders over it are only fetched when something reads them.
+ */
+exports.SHARD_GROUP_BYTES = 64 * 1024;
+/** The folder a captured path is grouped under: its first three segments. */
+var shardFolderFor = function (filePath) {
+    var prefix = '/sasjs/drive/files/';
+    if (!filePath.startsWith(prefix))
+        return path_1.default.dirname(filePath);
+    var parts = filePath.slice(prefix.length).split('/');
+    // a file at the drive root groups with the other root files, which is where
+    // the index, the linter rules and a project's configs live
+    return (prefix +
+        parts
+            .slice(0, Math.max(0, parts.length - 1))
+            .slice(0, 3)
+            .join('/'));
+};
+/**
+ * Splits a captured drive into a boot shard and the pieces fetched on demand.
+ *
+ * A site that ships its whole drive as one file makes every visitor download all
+ * of it before the first page renders - on a demonstration site that is every
+ * app's bundle, behind a list of tiles that names them. The split is by what a
+ * page reads, not by what the drive holds:
+ *
+ * - a file at or over `SHARD_FILE_BYTES` gets a shard of its own;
+ * - the rest are grouped by folder, and a folder under `SHARD_GROUP_BYTES` joins
+ *   the boot shard (id 0), so no visit pays a round trip for a logo;
+ * - everything over it becomes a shard, fetched when a path in it is read.
+ *
+ * The index carries every path with its shard and byte count, so a listing, a
+ * stat and an existence check answer for the whole drive with nothing fetched.
+ */
+var shardSnapshot = function (files) {
+    var e_7, _a, e_8, _b, _c;
+    var paths = Object.keys(files).sort();
+    var bytesOf = function (filePath) {
+        return Buffer.byteLength(String(files[filePath]));
+    };
+    var groups = new Map();
+    try {
+        for (var paths_1 = __values(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
+            var filePath = paths_1_1.value;
+            var big = bytesOf(filePath) >= exports.SHARD_FILE_BYTES;
+            var key = big ? "file:".concat(filePath) : "dir:".concat(shardFolderFor(filePath));
+            groups.set(key, (groups.get(key) || []).concat(filePath));
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    var shards = [{ paths: [], bytes: 0 }];
+    try {
+        for (var _d = __values(__spreadArray([], __read(groups.keys()), false).sort()), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var key = _e.value;
+            var members = groups.get(key);
+            var bytes = members.reduce(function (total, filePath) { return total + bytesOf(filePath); }, 0);
+            var ridesInBoot = key.startsWith('dir:') && bytes <= exports.SHARD_GROUP_BYTES;
+            if (ridesInBoot) {
+                (_c = shards[0].paths).push.apply(_c, __spreadArray([], __read(members), false));
+                shards[0].bytes += bytes;
+                continue;
+            }
+            shards.push({ paths: members, bytes: bytes });
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    var entries = {};
+    shards.forEach(function (shard, id) {
+        var e_9, _a;
+        try {
+            for (var _b = __values(shard.paths), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var filePath = _c.value;
+                entries[filePath] = { shard: id, bytes: bytesOf(filePath) };
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+    });
+    return {
+        index: {
+            format: exports.DRIVE_FORMAT,
+            sharded: true,
+            boot: 0,
+            files: paths.length,
+            entries: entries,
+            shards: shards.map(function (shard, id) { return ({
+                id: id,
+                file: "host/vfs-snapshot-".concat(id, ".json"),
+                bytes: shard.bytes,
+                files: shard.paths.length
+            }); })
+        },
+        shards: shards.map(function (shard, id) { return ({
+            id: id,
+            file: "vfs-snapshot-".concat(id, ".json"),
+            bytes: shard.bytes,
+            files: Object.fromEntries(shard.paths.map(function (filePath) { return [filePath, files[filePath]]; }))
+        }); })
+    };
+};
 /** The script-tag attributes that change how an app's script runs. */
 var REPLAYED_ATTRIBUTES = {
     type: 'type',
@@ -519,6 +651,20 @@ var REPLAYED_ATTRIBUTES = {
     integrity: 'integrity',
     nomodule: 'noModule'
 };
+/**
+ * Script types a preload may name.
+ *
+ * The loader only re-runs a tag once the worker controls the page, so without a
+ * hint the app's bundle is not requested until the install has finished - the
+ * largest asset on the site behind the largest prerequisite. A preload link
+ * executes nothing, so the download can start while the worker is still
+ * installing.
+ *
+ * `module` is excluded on purpose: a module is fetched with different
+ * credentials semantics from a classic script, so `as="script"` does not match
+ * the later tag and the file is fetched twice - slower than no hint at all.
+ */
+var PRELOADABLE_TYPES = ['', 'text/javascript', 'application/javascript'];
 var parseAttributes = function (source) {
     var _a, _b, _c;
     var attributes = {};
@@ -537,6 +683,45 @@ var escapeAttribute = function (value) {
         .replace(/</g, '&lt;')
         .replace(/>/g, '&gt;');
 };
+/** Puts markup at the end of the head, or leaves the page alone when it has none. */
+var insertIntoHead = function (html, markup) {
+    var head = /<head(\s[^>]*)?>/i.exec(html);
+    if (!head)
+        return html;
+    var start = head.index + head[0].length;
+    var close = html.toLowerCase().indexOf('</head>', start);
+    var at = close < 0 ? start : close;
+    return html.slice(0, at) + markup + html.slice(at);
+};
+/**
+ * Hints the app scripts the loader will replay, so their download starts while
+ * the worker installs rather than after it.
+ *
+ * Only scripts this build owns are hinted - the file has to be in the output for
+ * the version query to be meaningful - and only classic ones. A `type="module"`
+ * tag is fetched with different credentials semantics, so an `as="script"`
+ * preload does not match it; and a cross-origin src would need `crossorigin` on
+ * the hint to match its tag. Either mismatch fetches the file twice, which is
+ * worse than no hint.
+ */
+var preloadHints = function (scripts, outputFolder) {
+    return scripts
+        .filter(function (script) {
+        if (!script.src)
+            return false;
+        if (!PRELOADABLE_TYPES.includes((script.type || '').trim().toLowerCase()))
+            return false;
+        if (script.crossOrigin)
+            return false;
+        if (/^([a-z]+:)?\/\//i.test(script.src))
+            return false;
+        if (!outputFolder)
+            return true;
+        var pathname = script.src.split('?')[0];
+        return fs_1.default.existsSync(path_1.default.join(outputFolder, pathname.replace(/^(\.\/|\/)/, '')));
+    })
+        .map(function (script) { return "<link rel=\"preload\" as=\"script\" href=\"".concat(script.src, "\" />"); });
+};
 /**
  * The boot loader is a FILE rather than an inline script: an app with a strict
  * Content-Security-Policy (`default-src 'self'`, no `unsafe-inline`) refuses an
@@ -713,7 +898,7 @@ var patchIndexHtml = function (html, version, basePath, outputFolder) {
     var early = [];
     var tagPattern = /<script\b([^>]*)>([\s\S]*?)<\/script>[ \t]*\r?\n?/gi;
     patched = patched.replace(tagPattern, function (tag, source, body) {
-        var e_7, _a;
+        var e_10, _a;
         var attributes = parseAttributes(source);
         var type = (attributes.type || '').trim().toLowerCase();
         var inlined = !attributes.src;
@@ -752,12 +937,12 @@ var patchIndexHtml = function (html, version, basePath, outputFolder) {
                 spec[name_2] = attribute === 'nomodule' ? 'true' : attributes[attribute];
             }
         }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_7) throw e_7.error; }
+            finally { if (e_10) throw e_10.error; }
         }
         scripts.push(spec);
         return '';
@@ -766,6 +951,9 @@ var patchIndexHtml = function (html, version, basePath, outputFolder) {
         var versioned = outputFolder
             ? versionScripts(scripts, outputFolder)
             : scripts;
+        var hints = preloadHints(versioned, outputFolder);
+        if (hints.length)
+            patched = insertIntoHead(patched, hints.join(''));
         var tag_1 = bootTag(versioned, version, basePath);
         // a function, not a replacement string: the tag carries the page's own srcs
         // in `data-scripts`, and a `$&` in one would expand to the matched markup
@@ -836,11 +1024,11 @@ var patchIndexHtml = function (html, version, basePath, outputFolder) {
  */
 function buildMockSite(target) {
     return __awaiter(this, void 0, void 0, function () {
-        var projectDir, appLocRaw, appLoc, buildFolder, basePath, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, identity, webFileCount, hostFolder, _b, _c, asset, hostVersion, buildStamp, swPath, snapshotSource, hasSnapshot, transcriptSource, hasTranscript, indexPath, _d, patched, warnings;
-        var e_8, _e;
-        var _f, _g, _h, _j, _k, _l;
-        return __generator(this, function (_m) {
-            switch (_m.label) {
+        var projectDir, appLocRaw, appLoc, buildFolder, basePath, webSourceRaw, webFolder, outputFolder, streamConfig, excluded, _a, seed, skipped, jsPrograms, sasPrograms, driveEntries, identity, webFileCount, hostFolder, _b, _c, asset, hostVersion, buildStamp, swPath, snapshotSource, hasSnapshot, snapshotShards, capture, files, split, _d, _e, shard, transcriptSource, hasTranscript, indexPath, _f, patched, warnings;
+        var e_11, _g, e_12, _h;
+        var _j, _k, _l, _m, _o, _p;
+        return __generator(this, function (_q) {
+            switch (_q.label) {
                 case 0:
                     projectDir = process.projectDir || process.cwd();
                     appLocRaw = target.appLoc;
@@ -852,24 +1040,24 @@ function buildMockSite(target) {
                         path_1.default.join(projectDir, 'sasjsbuild');
                     return [4 /*yield*/, (0, utils_1.folderExists)(buildFolder)];
                 case 1:
-                    if (!(_m.sent())) {
+                    if (!(_q.sent())) {
                         throw new Error("Build folder not found: ".concat(buildFolder, ". Run `sasjs compile` first."));
                     }
-                    basePath = normaliseBasePath((_f = target.streamConfig) === null || _f === void 0 ? void 0 : _f.mockWebBasePath);
-                    webSourceRaw = (_g = target.streamConfig) === null || _g === void 0 ? void 0 : _g.webSourcePath;
+                    basePath = normaliseBasePath((_j = target.streamConfig) === null || _j === void 0 ? void 0 : _j.mockWebBasePath);
+                    webSourceRaw = (_k = target.streamConfig) === null || _k === void 0 ? void 0 : _k.webSourcePath;
                     if (!webSourceRaw) {
                         throw new Error('No built web app. Set streamConfig.webSourcePath on the target (for example ./client/dist), and build the frontend first.');
                     }
                     webFolder = path_1.default.resolve(projectDir, webSourceRaw);
                     return [4 /*yield*/, (0, utils_1.folderExists)(webFolder)];
                 case 2:
-                    if (!(_m.sent())) {
+                    if (!(_q.sent())) {
                         throw new Error("Web source folder not found: ".concat(webFolder, ". Check streamConfig.webSourcePath - build the frontend first."));
                     }
                     if (!fs_1.default.existsSync(path_1.default.join(webFolder, 'index.html'))) {
                         throw new Error("".concat(webFolder, " does not contain an index.html - is streamConfig.webSourcePath pointing at the built app?"));
                     }
-                    outputFolder = ((_h = target.streamConfig) === null || _h === void 0 ? void 0 : _h.mockWebFolder)
+                    outputFolder = ((_l = target.streamConfig) === null || _l === void 0 ? void 0 : _l.mockWebFolder)
                         ? path_1.default.resolve(projectDir, target.streamConfig.mockWebFolder)
                         : path_1.default.join(buildFolder, 'mock');
                     assertSafeOutputFolder(outputFolder, projectDir, buildFolder, webFolder);
@@ -890,14 +1078,14 @@ function buildMockSite(target) {
                     // without a SAS licence and without a login. What they cannot do is run here,
                     // so the build says so rather than letting a Run button be the surprise.
                     if (jsPrograms === 0 && sasPrograms > 0) {
-                        (_j = process.logger) === null || _j === void 0 ? void 0 : _j.warn("".concat(sasPrograms, " SAS program(s) and no JavaScript in ").concat(buildFolder, ": they are placed on the drive to read, and cannot run in a browser."));
+                        (_m = process.logger) === null || _m === void 0 ? void 0 : _m.warn("".concat(sasPrograms, " SAS program(s) and no JavaScript in ").concat(buildFolder, ": they are placed on the drive to read, and cannot run in a browser."));
                     }
                     // No PROGRAMS is a different thing again: a compile that produced nothing, or
                     // a stale sasjsbuild from an unrelated command - `sasjs doc` leaves a folder
                     // behind that is not a program folder but does reach the drive, so the count
                     // that decides this is of programs, not of files.
                     if (jsPrograms + sasPrograms === 0) {
-                        (_k = process.logger) === null || _k === void 0 ? void 0 : _k.warn("No compiled programs in ".concat(buildFolder, ": this site ships with an empty drive. ") +
+                        (_o = process.logger) === null || _o === void 0 ? void 0 : _o.warn("No compiled programs in ".concat(buildFolder, ": this site ships with an empty drive. ") +
                             'That is expected for an interface with no services; for anything else, check that compile wrote the target.');
                     }
                     // The package supplies the drive rules the worker answers with, so an install
@@ -910,7 +1098,7 @@ function buildMockSite(target) {
                             'or check that @sasjs/api still publishes build/browser.js.');
                     }
                     if (skipped.length) {
-                        (_l = process.logger) === null || _l === void 0 ? void 0 : _l.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: ") +
+                        (_p = process.logger) === null || _p === void 0 ? void 0 : _p.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) {
@@ -941,12 +1129,12 @@ function buildMockSite(target) {
                             fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, asset), path_1.default.join(hostFolder, asset));
                         }
                     }
-                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
                     finally {
                         try {
-                            if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
+                            if (_c && !_c.done && (_g = _b.return)) _g.call(_b);
                         }
-                        finally { if (e_8) throw e_8.error; }
+                        finally { if (e_11) throw e_11.error; }
                     }
                     fs_1.default.copyFileSync(API_BROWSER_BUILD, path_1.default.join(hostFolder, 'api-browser.js'));
                     // 2. the linter, bundled from the installed packages so the code routes answer
@@ -958,7 +1146,7 @@ function buildMockSite(target) {
                 case 3:
                     // 2. the linter, bundled from the installed packages so the code routes answer
                     // with the rules this CLI resolved rather than a second implementation
-                    _m.sent();
+                    _q.sent();
                     // 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 /
                     fs_1.default.copyFileSync(path_1.default.join(ASSETS_FOLDER, 'sw.js'), path_1.default.join(outputFolder, 'sw.js'));
@@ -1014,8 +1202,34 @@ function buildMockSite(target) {
                         .replace("importScripts('host/lint-browser.js')", "importScripts('host/lint-browser.js?v=".concat(hostVersion, "')")));
                     snapshotSource = path_1.default.join(buildFolder, 'mock-snapshot.json');
                     hasSnapshot = fs_1.default.existsSync(snapshotSource);
+                    snapshotShards = 0;
                     if (hasSnapshot) {
-                        fs_1.default.copyFileSync(snapshotSource, path_1.default.join(hostFolder, 'vfs-snapshot.json'));
+                        capture = JSON.parse(fs_1.default.readFileSync(snapshotSource, 'utf8'));
+                        if (capture &&
+                            capture.format !== undefined &&
+                            capture.format !== exports.DRIVE_FORMAT)
+                            throw new Error("The captured drive at ".concat(snapshotSource, " is format ") +
+                                "".concat(JSON.stringify(capture.format), ", and this build writes format ") +
+                                "".concat(exports.DRIVE_FORMAT, ". Seed the drive again with window.SASjsMock.download()."));
+                        files = capture && capture.files ? capture.files : capture;
+                        if (!files || typeof files !== 'object')
+                            throw new Error("The captured drive at ".concat(snapshotSource, " carries no files - the export is a JSON object of path to contents."));
+                        split = shardSnapshot(files);
+                        try {
+                            for (_d = __values(split.shards), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                shard = _e.value;
+                                fs_1.default.writeFileSync(path_1.default.join(hostFolder, shard.file), JSON.stringify({ format: exports.DRIVE_FORMAT, files: shard.files }));
+                            }
+                        }
+                        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                        finally {
+                            try {
+                                if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
+                            }
+                            finally { if (e_12) throw e_12.error; }
+                        }
+                        fs_1.default.writeFileSync(path_1.default.join(hostFolder, 'vfs-snapshot.json'), JSON.stringify(split.index, null, 2));
+                        snapshotShards = split.shards.length;
                     }
                     transcriptSource = path_1.default.join(buildFolder, 'sas-transcript.json');
                     hasTranscript = fs_1.default.existsSync(transcriptSource);
@@ -1030,13 +1244,14 @@ function buildMockSite(target) {
                         jsPrograms: jsPrograms,
                         programFolders: PROGRAM_FOLDERS,
                         snapshot: hasSnapshot,
+                        snapshotShards: snapshotShards,
                         sasTranscript: hasTranscript,
                         identity: identity.source,
                         buildStamp: buildStamp,
                         builtAt: new Date().toISOString()
                     }, null, 2));
                     indexPath = path_1.default.join(outputFolder, 'index.html');
-                    _d = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion, basePath, outputFolder), patched = _d.patched, warnings = _d.warnings;
+                    _f = patchIndexHtml(fs_1.default.readFileSync(indexPath, 'utf8'), hostVersion, basePath, outputFolder), patched = _f.patched, warnings = _f.warnings;
                     fs_1.default.writeFileSync(indexPath, patched);
                     warnings.forEach(function (warning) { var _a; return (_a = process.logger) === null || _a === void 0 ? void 0 : _a.warn(warning); });
                     return [2 /*return*/, {
@@ -1046,6 +1261,7 @@ function buildMockSite(target) {
                             jsPrograms: jsPrograms,
                             webFileCount: webFileCount,
                             snapshot: hasSnapshot,
+                            snapshotShards: snapshotShards,
                             sasTranscript: hasTranscript,
                             identitySource: identity.source
                         }];

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

@@ -100,9 +100,11 @@ var loadBoot = function (specs, options) {
     };
     var listeners = {};
     var controller = options.controller || 'present';
+    var timelineAtRegister = [];
     var navigator = {
         serviceWorker: {
             register: function (url, init) {
+                timelineAtRegister = timeline.slice();
                 registered.push(url + ' ' + JSON.stringify(init));
                 return options.registerFails
                     ? Promise.reject(new Error('nope'))
@@ -127,7 +129,11 @@ var loadBoot = function (specs, options) {
     global.navigator = navigator;
     global.window = options.bootError
         ? { __sasjsMockReady: Promise.resolve({ error: options.bootError }) }
-        : {};
+        : options.driveError
+            ? {
+                __sasjsMockReady: Promise.resolve({ driveError: options.driveError })
+            }
+            : {};
     global.sessionStorage = {
         getItem: function (key) { return (key in stored ? stored[key] : null); },
         setItem: function (key, value) {
@@ -146,7 +152,7 @@ var loadBoot = function (specs, options) {
         late = true;
         (listeners['controllerchange'] || []).forEach(function (fn) { return fn(); });
     };
-    return { appended: appended, timeline: timeline, registered: registered, stored: stored, claim: claim };
+    return { appended: appended, timeline: timeline, registered: registered, stored: stored, claim: claim, timelineAtRegister: timelineAtRegister };
 };
 var settle = function () { return __awaiter(void 0, void 0, void 0, function () {
     var i;
@@ -336,6 +342,29 @@ describe('the boot loader', function () {
             }
         });
     }); });
+    it('starts the drive restore before the worker is registered', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var timelineAtRegister;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    timelineAtRegister = loadBoot([{ src: 'sasjs.js' }]).timelineAtRegister;
+                    return [4 /*yield*/, settle()
+                        // persist.js reads the page's own IndexedDB and hands the drive to the
+                        // worker as soon as there is one, so nothing about it needs the worker to be
+                        // ready: sequenced after the registration it is another download plus a
+                        // store read on top of the install, which is what made a first visit slow
+                    ];
+                case 1:
+                    _a.sent();
+                    // persist.js reads the page's own IndexedDB and hands the drive to the
+                    // worker as soon as there is one, so nothing about it needs the worker to be
+                    // ready: sequenced after the registration it is another download plus a
+                    // store read on top of the install, which is what made a first visit slow
+                    expect(timelineAtRegister).toEqual(['host/persist.js']);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('keeps the attributes an app relies on', function () { return __awaiter(void 0, void 0, void 0, function () {
         var appended, app;
         return __generator(this, function (_a) {
@@ -430,6 +459,21 @@ describe('the boot loader', function () {
             }
         });
     }); });
+    it('reports a drive that was restored from less than the whole capture', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // the page still runs - a missing piece only fails the file that needed it -
+                    // so the error is the only thing that says the drive is incomplete
+                    loadBoot([], { driveError: 'the drive index answered 500' });
+                    return [4 /*yield*/, settle()];
+                case 1:
+                    _a.sent();
+                    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('the drive index answered 500'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('refuses a boot config it cannot read instead of guessing', function () { return __awaiter(void 0, void 0, void 0, function () {
         var timeline;
         return __generator(this, function (_a) {
@@ -527,7 +571,10 @@ describe('the boot loader', function () {
                     // into the next test's globals
                     _b.sent();
                     expect(stored['mock-sw-reloaded']).toEqual('1');
-                    expect(timeline).toEqual(['reload']);
+                    // the drive restore is requested before the registration (it overlaps the
+                    // install), so it is already in flight when the page decides to reload; the
+                    // reload discards it, which costs nothing the cache does not already hold
+                    expect(timeline).toEqual(['host/persist.js', 'reload']);
                     return [2 /*return*/];
             }
         });