@sasjs/cli 6.30.0 → 6.31.0

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,303 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @jest-environment jsdom
+ * @jest-environment-options {"url": "http://localhost/demo/api/"}
+ */
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+/**
+ * The console under a base path.
+ *
+ * `mockWebBasePath` is a supported option (a site published at `/demo`), and the
+ * console derives everything from its own URL: the API calls come from
+ * `location.pathname` with `/api/` cut off, and the worker is registered beside
+ * the site. Both are right at the origin root by accident there - this file runs
+ * the same page at `/demo/api/`, where the wrong derivation is silent: the page
+ * still renders, and every call goes to a path the host does not answer.
+ */
+var assets = path_1.default.join(__dirname, '..', 'assets');
+var page = function () { return fs_1.default.readFileSync(path_1.default.join(assets, 'api-index.html'), 'utf8'); };
+var bodyOf = function (html) {
+    return html.slice(html.indexOf('<body>') + 6, html.lastIndexOf('</body>'));
+};
+var jsonResponse = function (body) { return ({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    headers: { get: function () { return 'application/json'; } },
+    json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, body];
+    }); }); },
+    text: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+        return [2 /*return*/, JSON.stringify(body)];
+    }); }); }
+}); };
+var operations = [
+    {
+        id: 'GET /SASjsApi/user',
+        method: 'GET',
+        path: '/SASjsApi/user',
+        tag: 'User',
+        summary: 'List all users',
+        params: [],
+        requestBodies: [],
+        responses: [{ status: 200, description: 'Ok' }],
+        implemented: true
+    }
+];
+var settle = function (check) { return __awaiter(void 0, void 0, void 0, function () {
+    var i;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                i = 0;
+                _a.label = 1;
+            case 1:
+                if (!(i < 400)) return [3 /*break*/, 4];
+                if (check())
+                    return [2 /*return*/];
+                return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+            case 2:
+                _a.sent();
+                _a.label = 3;
+            case 3:
+                i++;
+                return [3 /*break*/, 1];
+            case 4: throw new Error('the page did not reach the state the case expected');
+        }
+    });
+}); };
+describe('the API console under a base path', function () {
+    afterEach(function () {
+        delete navigator.serviceWorker;
+    });
+    it('finds the folder from a URL without its trailing slash', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var realCreate, sw, asked;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // `/demo/api` is the shape a person types, and the page used to read that as
+                    // the origin root: every call went to /SASjsApi/... and the worker to /sw.js
+                    history.replaceState({}, '', '/demo/api');
+                    expect(location.pathname).toBe('/demo/api');
+                    document.body.innerHTML = bodyOf(page());
+                    document.head.innerHTML =
+                        '<meta name="sasjs-mock-version" content="2.0.0" />';
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, String(url).includes('operations.json')
+                                    ? jsonResponse(operations)
+                                    : jsonResponse({ format: 1, users: [] })];
+                        });
+                    }); });
+                    realCreate = document.createElement.bind(document);
+                    jest.spyOn(document, 'createElement').mockImplementation(function (tag) {
+                        var node = realCreate(tag);
+                        if (String(tag).toLowerCase() === 'script')
+                            setTimeout(function () { return node.dispatchEvent(new Event('load')); }, 0);
+                        return node;
+                    });
+                    sw = {
+                        controller: {},
+                        register: jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, ({})];
+                        }); }); }),
+                        addEventListener: jest.fn()
+                    };
+                    Object.defineProperty(navigator, 'serviceWorker', {
+                        value: sw,
+                        configurable: true
+                    });
+                    jest.resetModules();
+                    require('../assets/api-console.js');
+                    return [4 /*yield*/, settle(function () { return sw.register.mock.calls.length === 1; })];
+                case 1:
+                    _a.sent();
+                    expect(sw.register.mock.calls[0][0]).toContain('/demo/sw.js?v=2.0.0');
+                    expect(sw.register.mock.calls[0][1]).toEqual(expect.objectContaining({ scope: '/demo/' }));
+                    return [4 /*yield*/, settle(function () { return document.querySelectorAll('#routes .route').length > 0; })];
+                case 2:
+                    _a.sent();
+                    asked = global.fetch.mock.calls.map(function (call) {
+                        return String(call[0]);
+                    });
+                    expect(asked).toContain('/demo/host/identity.json');
+                    history.replaceState({}, '', '/demo/api/');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('registers the worker and calls the API under the folder the site lives in', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var calls, realCreate, sw, errors, errorSpy, warnSpy, asked;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    document.body.innerHTML = bodyOf(page());
+                    document.head.innerHTML =
+                        '<meta name="sasjs-mock-version" content="2.0.0" />';
+                    calls = [];
+                    global.fetch = jest.fn(function (url_1) {
+                        var args_1 = [];
+                        for (var _i = 1; _i < arguments.length; _i++) {
+                            args_1[_i - 1] = arguments[_i];
+                        }
+                        return __awaiter(void 0, __spreadArray([url_1], __read(args_1), false), void 0, function (url, init) {
+                            if (init === void 0) { init = {}; }
+                            return __generator(this, function (_a) {
+                                if (String(url).includes('operations.json'))
+                                    return [2 /*return*/, jsonResponse(operations)];
+                                if (String(url).includes('identity.json'))
+                                    return [2 /*return*/, jsonResponse({ format: 1, users: [] })];
+                                calls.push({ url: String(url), init: init });
+                                return [2 /*return*/, jsonResponse([])];
+                            });
+                        });
+                    });
+                    realCreate = document.createElement.bind(document);
+                    jest.spyOn(document, 'createElement').mockImplementation(function (tag) {
+                        var node = realCreate(tag);
+                        if (String(tag).toLowerCase() === 'script')
+                            setTimeout(function () { return node.dispatchEvent(new Event('load')); }, 0);
+                        return node;
+                    });
+                    sw = {
+                        controller: {},
+                        register: jest.fn(function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, ({})];
+                        }); }); }),
+                        addEventListener: jest.fn()
+                    };
+                    Object.defineProperty(navigator, 'serviceWorker', {
+                        value: sw,
+                        configurable: true
+                    });
+                    errors = [];
+                    errorSpy = jest
+                        .spyOn(console, 'error')
+                        .mockImplementation(function () {
+                        var args = [];
+                        for (var _i = 0; _i < arguments.length; _i++) {
+                            args[_i] = arguments[_i];
+                        }
+                        return errors.push(args);
+                    });
+                    warnSpy = jest
+                        .spyOn(console, 'warn')
+                        .mockImplementation(function () {
+                        var args = [];
+                        for (var _i = 0; _i < arguments.length; _i++) {
+                            args[_i] = arguments[_i];
+                        }
+                        return errors.push(args);
+                    });
+                    jest.resetModules();
+                    require('../assets/api-console.js');
+                    return [4 /*yield*/, settle(function () { return sw.register.mock.calls.length === 1; }).catch(function (e) {
+                            throw new Error(e.message +
+                                ' | errors: ' +
+                                JSON.stringify(errors) +
+                                ' | routes: ' +
+                                (document.getElementById('routes') || {}).textContent);
+                        })];
+                case 1:
+                    _a.sent();
+                    errorSpy.mockRestore();
+                    warnSpy.mockRestore();
+                    expect(sw.register.mock.calls[0][0]).toContain('/demo/sw.js?v=2.0.0');
+                    expect(sw.register.mock.calls[0][1]).toEqual(expect.objectContaining({ scope: '/demo/' }));
+                    // the page's data comes from the same folder, not from the origin root
+                    return [4 /*yield*/, settle(function () { return document.querySelectorAll('#routes .route').length > 0; }).catch(function (e) {
+                            throw new Error(e.message +
+                                ' | routes: ' +
+                                JSON.stringify((document.getElementById('routes') || {}).textContent) +
+                                ' | fetched: ' +
+                                JSON.stringify(global.fetch.mock.calls.map(function (c) { return String(c[0]); })) +
+                                ' | errors: ' +
+                                JSON.stringify(errors));
+                        })];
+                case 2:
+                    // the page's data comes from the same folder, not from the origin root
+                    _a.sent();
+                    asked = global.fetch.mock.calls.map(function (call) {
+                        return String(call[0]);
+                    });
+                    // the page's own table is fetched relative to the page, so it follows the
+                    // folder without any substitution; the host files are addressed absolutely
+                    expect(asked).toContain('operations.json');
+                    expect(asked).toContain('/demo/host/identity.json');
+                    __spreadArray([], __read(document.querySelectorAll('#routes .route')), false)[0].click();
+                    document.getElementById('send').click();
+                    return [4 /*yield*/, settle(function () { return calls.length > 0; })];
+                case 3:
+                    _a.sent();
+                    expect(calls[0].url).toBe('/demo/SASjsApi/user');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});

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*/];
             }
         });

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

@@ -140,6 +140,12 @@ describe('browser-hosted build', function () {
     var readConfig = function () {
         return JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'mock-config.json'), 'utf8'));
     };
+    var readIndex = function () {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'vfs-snapshot.json'), 'utf8'));
+    };
+    var readShard = function (id) {
+        return JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', "vfs-snapshot-".concat(id, ".json")), 'utf8')).files;
+    };
     beforeEach(function () {
         root = fs_1.default.mkdtempSync(path_1.default.join(require('os').tmpdir(), 'sasjs-mock-'));
         createProject(root);
@@ -558,6 +564,66 @@ describe('browser-hosted build', function () {
             }
         });
     }); });
+    /**
+     * The loader replays the app's tags only once the worker controls the page.
+     * Right for answerability, but it also puts the largest asset on the site
+     * behind the largest prerequisite - so a classic script is hinted in the head,
+     * where the parser reaches it before the loader runs.
+     */
+    it('hints a classic app script so it downloads while the worker installs', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html, hint;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+                        '<!doctype html><html><head><title>App</title></head><body>',
+                        "<sasjs serverurl=\"https://sas.example.com\" apploc=\"".concat(appLoc, "\" servertype=\"SASJS\"></sasjs>"),
+                        '<script src="main.abc123.js"></script>',
+                        '<script src="deferred.js" type="module"></script>',
+                        '</body></html>'
+                    ].join('\n'));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    hint = html.match(/<link rel="preload" as="script" href="([^"]+)" \/>/);
+                    expect(hint).not.toBeNull();
+                    // the hint names the URL the replayed tag carries, version query included: a
+                    // mismatch is a second download rather than a warm cache
+                    expect(hint[1]).toMatch(/^main\.abc123\.js\?v=[0-9a-f]{10}$/);
+                    expect(html).toContain("\"src\":\"".concat(hint[1], "\""));
+                    // and it has to be in the head, ahead of the loader that replays the tag
+                    expect(html.indexOf('rel="preload"')).toBeLessThan(html.indexOf('host/boot.js'));
+                    // a module is fetched with different credentials semantics, so a script hint
+                    // would not match its tag - it is replayed without one
+                    expect(html).not.toMatch(/as="script" href="deferred/);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves a script this build does not own unhinted', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var html;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    // a page may load a script from somewhere else; a version guess or a
+                    // cross-origin hint only breaks it
+                    write(path_1.default.join(root, 'client', 'dist', 'index.html'), [
+                        '<!doctype html><html><head><title>App</title></head><body>',
+                        "<sasjs serverurl=\"https://sas.example.com\" apploc=\"".concat(appLoc, "\" servertype=\"SASJS\"></sasjs>"),
+                        '<script src="https://cdn.example.com/lib.js"></script>',
+                        '<script src="not-in-this-build.js"></script>',
+                        '</body></html>'
+                    ].join('\n'));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    _a.sent();
+                    html = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    expect(html).not.toContain('rel="preload"');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it("leaves a stylesheet alone when the file is not this build's", function () { return __awaiter(void 0, void 0, void 0, function () {
         var html, specs;
         return __generator(this, function (_a) {
@@ -889,7 +955,7 @@ describe('browser-hosted build', function () {
         });
     }); });
     it('ships a captured drive snapshot when the project has one', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var snapshot, result, shipped;
+        var snapshot, result, index;
         var _a;
         return __generator(this, function (_b) {
             switch (_b.label) {
@@ -905,11 +971,159 @@ describe('browser-hosted build', function () {
                 case 1:
                     result = _b.sent();
                     expect(result.snapshot).toBe(true);
-                    shipped = JSON.parse(fs_1.default.readFileSync(path_1.default.join(out(), 'host', 'vfs-snapshot.json'), 'utf8'));
-                    expect(Object.keys(shipped.files).length).toBe(2);
+                    index = readIndex();
+                    expect(index.sharded).toBe(true);
+                    expect(Object.keys(index.entries).length).toBe(2);
+                    // two small files under one folder: one boot shard, no request of their own
+                    expect(result.snapshotShards).toBe(1);
+                    expect(index.boot).toBe(0);
+                    expect(readShard(0)).toEqual(snapshot.files);
                     // the runtime prefers a snapshot over the seed, so it must not be mistaken
                     // for one of the seeded folders
                     expect(readConfig().snapshot).toBe(true);
+                    expect(readConfig().snapshotShards).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * A captured drive is not one download.
+     *
+     * The first page of a demonstration site reads a listing and a handful of
+     * logos; the bundles behind the tiles are opened by whoever clicks them. One
+     * file for the lot makes every visitor pay for all of it before the page
+     * renders, so the build splits it: small files in the boot shard, an app's
+     * bundle in its own.
+     */
+    it('ships a large capture as a boot shard plus a piece per bundle', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var bundle, capture, result, index, bundlePath, bundleShard, bootBytes, total;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    bundle = 'x'.repeat(mockSite_1.SHARD_FILE_BYTES + 1024);
+                    capture = {
+                        files: (_a = {
+                                '/sasjs/drive/files/.sasjs/apps.json': '{"apps":[]}'
+                            },
+                            _a["/sasjs/drive/files/Public/app/demo/logo.png"] = 'not really a png',
+                            _a["/sasjs/drive/files/Public/app/demo/services/web/index.bundle.js"] = bundle,
+                            _a)
+                    };
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-snapshot.json'), JSON.stringify(capture));
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _b.sent();
+                    index = readIndex();
+                    expect(result.snapshotShards).toBe(2);
+                    // what a first page reads is in the boot shard
+                    expect(index.entries['/sasjs/drive/files/.sasjs/apps.json'].shard).toBe(0);
+                    expect(index.entries["/sasjs/drive/files/Public/app/demo/logo.png"].shard).toBe(0);
+                    bundlePath = "/sasjs/drive/files/Public/app/demo/services/web/index.bundle.js";
+                    bundleShard = index.entries[bundlePath].shard;
+                    expect(bundleShard).not.toBe(0);
+                    expect(readShard(bundleShard)[bundlePath]).toBe(bundle);
+                    bootBytes = index.shards[0].bytes;
+                    total = Object.keys(index.entries).reduce(function (sum, key) { return sum + index.entries[key].bytes; }, 0);
+                    expect(bootBytes).toBeLessThan(total / 10);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses a capture written by a runtime of another format', function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    write(path_1.default.join(root, 'sasjsbuild', 'mock-snapshot.json'), JSON.stringify({ format: mockSite_1.DRIVE_FORMAT + 1, files: {} }));
+                    return [4 /*yield*/, expect((0, mockSite_1.buildMockSite)(target())).rejects.toThrow(/format/)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * The API console is generated, not written.
+     *
+     * It is the page that lets a visitor try the API a mock site is a mock of, so
+     * it has to list the operations the package actually answers - and be
+     * generated from the same route table the worker dispatches, or the page and
+     * the host drift.
+     */
+    it('ships an API console built from the route table', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, folder, shipped, sw, listed, operations, createUser, html, version, appHtml, loader;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())];
+                case 1:
+                    result = _a.sent();
+                    expect(result.apiConsole).toBe(true);
+                    folder = path_1.default.join(out(), 'api');
+                    shipped = fs_1.default.readdirSync(folder).sort();
+                    // every file the folder holds, and the worker's passthrough list is that same
+                    // list: a second copy in sw.js would let a new file be answered as an API path
+                    expect(shipped).toEqual([
+                        'console.css',
+                        'console.js',
+                        'index.html',
+                        'operations.json'
+                    ]);
+                    sw = fs_1.default.readFileSync(path_1.default.join(out(), 'sw.js'), 'utf8');
+                    listed = /const API_CONSOLE_FILES = (\[[^\]]*\])/.exec(sw);
+                    expect(listed).not.toBeNull();
+                    expect(JSON.parse(listed[1]).sort()).toEqual(shipped);
+                    operations = JSON.parse(fs_1.default.readFileSync(path_1.default.join(folder, 'operations.json'), 'utf8'));
+                    expect(operations.length).toBeGreaterThan(20);
+                    createUser = operations.find(function (operation) { return operation.id === 'POST /SASjsApi/user'; });
+                    expect(createUser).toBeDefined();
+                    expect(createUser.params.map(function (parameter) { return parameter.name; })).toEqual(expect.arrayContaining(['username', 'password']));
+                    expect(createUser.method).toBe('POST');
+                    html = fs_1.default.readFileSync(path_1.default.join(folder, 'index.html'), 'utf8');
+                    expect(html).toContain('<script src="console.js"></script>');
+                    expect(html).not.toMatch(/<script(?![^>]*\ssrc=)[^>]*>[\s\S]*?<\/script>/);
+                    version = /<meta name="sasjs-mock-version" content="([^"]+)" \/>/.exec(html);
+                    expect(version).not.toBeNull();
+                    appHtml = fs_1.default.readFileSync(path_1.default.join(out(), 'index.html'), 'utf8');
+                    loader = /host\/boot\.js\?v=([^"']+)/.exec(appHtml);
+                    expect(loader).not.toBeNull();
+                    expect(version[1]).toBe(loader[1]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves the console out when the site ships its own api folder, and says so', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var own, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    own = path_1.default.join(root, 'client', 'dist', 'api');
+                    fs_1.default.mkdirSync(own, { recursive: true });
+                    fs_1.default.writeFileSync(path_1.default.join(own, 'index.html'), '<p>ours</p>');
+                    return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target())
+                        // the project's file is not replaced, and the loss is reported rather than
+                        // silent: the build has no way to know which of the two the site wants
+                    ];
+                case 1:
+                    result = _a.sent();
+                    // the project's file is not replaced, and the loss is reported rather than
+                    // silent: the build has no way to know which of the two the site wants
+                    expect(result.apiConsole).toBe(false);
+                    expect(fs_1.default.readFileSync(path_1.default.join(out(), 'api', 'index.html'), 'utf8')).toBe('<p>ours</p>');
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'api', 'console.js'))).toBe(false);
+                    expect(process.logger.warn).toHaveBeenCalledWith(expect.stringContaining('api/index.html'));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('leaves the console out when the target asks for the app alone', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, mockSite_1.buildMockSite)(target({ mockApi: false }))];
+                case 1:
+                    result = _a.sent();
+                    expect(result.apiConsole).toBe(false);
+                    expect(fs_1.default.existsSync(path_1.default.join(out(), 'api'))).toBe(false);
                     return [2 /*return*/];
             }
         });