@sasjs/cli 6.30.0 → 6.31.0

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

@@ -86,6 +86,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
 var path_1 = __importDefault(require("path"));
 var api_1 = require("@sasjs/api");
 var os_1 = __importDefault(require("os"));
@@ -147,7 +148,11 @@ var loadWorker = function (base, options) {
         }
     };
     global.self = self;
+    // what the worker pulled into itself, so a test can assert that a script it
+    // does not need at boot is not fetched at boot
+    var imported = [];
     global.importScripts = function (path) {
+        imported.push(path);
         if (path.includes('md5'))
             return;
         if (path.includes('api-browser'))
@@ -185,7 +190,7 @@ var loadWorker = function (base, options) {
     };
     require('../assets/sw.js');
     global.fetch = jest.fn(function (input) { return __awaiter(void 0, void 0, void 0, function () {
-        var target, fixture, fixture;
+        var target, fixture, fixture, shards, piece, id, requested, shards_1;
         var _a;
         return __generator(this, function (_b) {
             target = typeof input === 'string' ? input : (input && input.url) || String(input);
@@ -222,7 +227,29 @@ var loadWorker = function (base, options) {
                             userId: mockSite_1.WEBOUT_SENTINELS.userId,
                             apiServerUrl: mockSite_1.WEBOUT_SENTINELS.apiServerUrl
                         })
-                    })];
+                    })
+                    // a sharded drive, when a test sets one up: the index answers the snapshot
+                    // URL and each piece answers its own file, so the worker's fetch of a shard
+                    // is the same request it makes against a static host
+                ];
+            shards = global.__sasjsShards;
+            if (shards && target.includes('vfs-snapshot')) {
+                piece = /vfs-snapshot-(\d+)\.json/.exec(target);
+                if (piece) {
+                    id = Number(piece[1]);
+                    requested = (global.__sasjsShardFetches =
+                        global.__sasjsShardFetches || []);
+                    requested.push(id);
+                    return [2 /*return*/, jsonResponse({ format: mockSite_1.DRIVE_FORMAT, files: shards[id] || {} })];
+                }
+                return [2 /*return*/, jsonResponse(shards.index)];
+            }
+            if (target.includes('mock-config')) {
+                shards_1 = global.__sasjsShards;
+                return [2 /*return*/, jsonResponse(__assign({ appLoc: appLoc }, (shards_1
+                        ? { snapshotShards: (shards_1.index.shards || []).length }
+                        : {})))];
+            }
             return [2 /*return*/, target.includes('vfs-seed')
                     ? jsonResponse({
                         files: (_a = {},
@@ -266,6 +293,7 @@ var loadWorker = function (base, options) {
         dispatch: dispatch,
         message: message,
         lifecycle: lifecycle,
+        imported: imported,
         self: self,
         refuseWrites: function (value) {
             refusingWrites = value;
@@ -308,6 +336,8 @@ describe('service worker host', function () {
         delete global.importScripts;
         delete global.fetch;
         delete global.__sasjsIdentity;
+        delete global.__sasjsShards;
+        delete global.__sasjsShardFetches;
         delete global.__mockHostClients;
     });
     var seeded = function () {
@@ -1412,6 +1442,161 @@ describe('service worker host', function () {
                 }
             });
         }); });
+        /**
+         * The linter is not part of the install.
+         *
+         * The page cannot make its first request until the worker has installed, so
+         * anything the worker imports at boot is on the critical path of every
+         * visit. The linter answers two routes; it is fetched when one of them is
+         * called.
+         */
+        it('fetches the linter on the first code route, not at boot', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        worker = seeded();
+                        expect(worker.imported.some(function (path) { return path.includes('lint-browser'); })).toBe(false);
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/code/lint', runRequest({ code: 'data a;\nrun;\n' }))];
+                    case 1:
+                        response = _a.sent();
+                        expect(response.status).toBe(200);
+                        expect(worker.imported.some(function (path) { return path.includes('lint-browser'); })).toBe(true);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        /**
+         * A route that resolves a path from the drive is not left with a hole.
+         *
+         * The rules an edited file is linted against are found by walking up from
+         * the file, so the request names neither path. The read that fails says
+         * which piece it needs, and the request is answered again with it - the body
+         * re-read from the copy taken before the first attempt.
+         */
+        it('fetches the piece a route resolves from the drive, not the one it names', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var worker, longLine, response, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        ;
+                        global.__sasjsShards = {
+                            index: {
+                                format: mockSite_1.DRIVE_FORMAT,
+                                sharded: true,
+                                boot: 0,
+                                entries: {
+                                    '/sasjs/drive/files/.sasjslint': { shard: 1, bytes: 20 },
+                                    '/sasjs/drive/files/Public/app/test/prog.sas': {
+                                        shard: 0,
+                                        bytes: 12
+                                    }
+                                },
+                                shards: [
+                                    { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                    { id: 1, file: 'host/vfs-snapshot-1.json' }
+                                ]
+                            },
+                            0: { '/sasjs/drive/files/Public/app/test/prog.sas': 'data a; run;' },
+                            1: {
+                                '/sasjs/drive/files/.sasjslint': JSON.stringify({
+                                    maxLineLength: 200
+                                })
+                            }
+                        };
+                        global.__sasjsShardFetches = [];
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.runtime.load({})];
+                    case 1:
+                        _d.sent();
+                        longLine = 'x'.repeat(150);
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/code/lint', runRequest({
+                                code: "data _null_;\n".concat(longLine, "\nrun;\n"),
+                                filePath: '/Public/app/test/prog.sas'
+                            }))];
+                    case 2:
+                        response = _d.sent();
+                        expect(response.status).toBe(200);
+                        // the line is over the linter's default 80 and under this drive's 200, so
+                        // the answer proves the rules file was read - from a piece the request
+                        // never named
+                        _a = expect;
+                        _c = (_b = JSON).stringify;
+                        return [4 /*yield*/, response.json()];
+                    case 3:
+                        // the line is over the linter's default 80 and under this drive's 200, so
+                        // the answer proves the rules file was read - from a piece the request
+                        // never named
+                        _a.apply(void 0, [_c.apply(_b, [_d.sent()])]).not.toContain('Line exceeds');
+                        expect(global.__sasjsShardFetches).toEqual([0, 1]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        /**
+         * A request that needs a second piece is answered, body and all.
+         *
+         * The first retry fetches the piece the failed read named; a request that
+         * reads two pieces one after another reaches the second retry, which fetches
+         * the rest. Either way the body has to arrive again - a Request's body can
+         * only be read once, so the first attempt keeps an unread copy and each
+         * attempt after it is made from a copy of that.
+         */
+        it('replays a request that needs two pieces, with its body intact', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var near, far, worker, longLine, response, findings, _a, _b;
+            var _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        near = '/sasjs/drive/files/Public/app/test/.sasjslint';
+                        far = '/sasjs/drive/files/.sasjslint';
+                        global.__sasjsShards = {
+                            index: {
+                                format: mockSite_1.DRIVE_FORMAT,
+                                sharded: true,
+                                boot: 0,
+                                entries: (_c = {},
+                                    _c[near] = { shard: 1, bytes: 20 },
+                                    _c[far] = { shard: 2, bytes: 20 },
+                                    _c),
+                                shards: [
+                                    { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                    { id: 1, file: 'host/vfs-snapshot-1.json' },
+                                    { id: 2, file: 'host/vfs-snapshot-2.json' }
+                                ]
+                            },
+                            0: {},
+                            // the nearest rules file is unreadable as a config, so the walk goes on
+                            // to the drive root's - a second piece, in a second shard
+                            1: (_d = {}, _d[near] = 'not json', _d),
+                            2: (_e = {}, _e[far] = JSON.stringify({ maxLineLength: 200 }), _e)
+                        };
+                        global.__sasjsShardFetches = [];
+                        worker = loadWorker();
+                        return [4 /*yield*/, worker.runtime.load({})];
+                    case 1:
+                        _f.sent();
+                        longLine = 'x'.repeat(150);
+                        return [4 /*yield*/, worker.dispatch('/SASjsApi/code/lint', runRequest({
+                                code: "data _null_;\n".concat(longLine, "\nrun;\n"),
+                                filePath: '/Public/app/test/prog.sas'
+                            }))];
+                    case 2:
+                        response = _f.sent();
+                        expect(response.status).toBe(200);
+                        _b = (_a = JSON).stringify;
+                        return [4 /*yield*/, response.json()];
+                    case 3:
+                        findings = _b.apply(_a, [_f.sent()]);
+                        // the code arrived on the second attempt and the root rules applied: both
+                        // halves of the claim
+                        expect(findings).toContain('Doxygen');
+                        expect(findings).not.toContain('Line exceeds');
+                        expect(global.__sasjsShardFetches).toEqual([0, 1, 2]);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
         /**
          * The rules are the drive's, not the linter's defaults.
          *
@@ -2264,6 +2449,168 @@ describe('service worker host', function () {
             }
         });
     }); });
+    /**
+     * A sharded drive supplies the piece a request names, and only that one.
+     *
+     * The build splits a captured drive so the first page does not download every
+     * app's bundle. That makes it the host's job to fetch the piece holding the
+     * path a route reads - here a drive file, named in `_filePath` - and to leave
+     * the pieces nobody asked for on the site.
+     */
+    it('fetches the piece a drive request names, and leaves the rest', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var small, large, worker, response, _a;
+        var _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    small = '/sasjs/drive/files/config.json';
+                    large = '/sasjs/drive/files/data/large.csv';
+                    global.__sasjsShards = {
+                        index: {
+                            format: mockSite_1.DRIVE_FORMAT,
+                            sharded: true,
+                            boot: 0,
+                            entries: (_b = {},
+                                _b[small] = { shard: 0, bytes: 2 },
+                                _b[large] = { shard: 1, bytes: 64 },
+                                _b),
+                            shards: [
+                                { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                { id: 1, file: 'host/vfs-snapshot-1.json' }
+                            ]
+                        },
+                        0: (_c = {}, _c[small] = '{}', _c),
+                        1: (_d = {}, _d[large] = 'a,b\n1,2\n3,4\n', _d)
+                    };
+                    global.__sasjsShardFetches = [];
+                    worker = loadWorker();
+                    return [4 /*yield*/, worker.runtime.load({})
+                        // the boot shard arrived with the drive; the second piece did not
+                    ];
+                case 1:
+                    _e.sent();
+                    // the boot shard arrived with the drive; the second piece did not
+                    expect(global.__sasjsShardFetches).toEqual([0]);
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/large.csv'))];
+                case 2:
+                    response = _e.sent();
+                    expect(response.status).toBe(200);
+                    _a = expect;
+                    return [4 /*yield*/, response.text()];
+                case 3:
+                    _a.apply(void 0, [_e.sent()]).toContain('a,b');
+                    expect(global.__sasjsShardFetches).toEqual([0, 1]);
+                    // a second read of the same piece is answered from memory
+                    return [4 /*yield*/, worker.dispatch('/SASjsApi/drive/file?_filePath=' + encodeURIComponent('/data/large.csv'))];
+                case 4:
+                    // a second read of the same piece is answered from memory
+                    _e.sent();
+                    expect(global.__sasjsShardFetches).toEqual([0, 1]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * An export is the whole drive, not the part in memory.
+     *
+     * `window.SASjsMock.download()` writes the file a project ships as
+     * `mock-snapshot.json`, so a sharded drive must be fetched before it is
+     * dumped - otherwise the next build ships a snapshot that has quietly lost
+     * every app the visitor never opened.
+     */
+    it('exports every piece of a sharded drive, not only the loaded ones', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var small, large, worker, _a, replies, pending, exported;
+        var _b, _c, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    small = '/sasjs/drive/files/config.json';
+                    large = '/sasjs/drive/files/data/large.csv';
+                    global.__sasjsShards = {
+                        index: {
+                            format: mockSite_1.DRIVE_FORMAT,
+                            sharded: true,
+                            boot: 0,
+                            entries: (_b = {},
+                                _b[small] = { shard: 0, bytes: 2 },
+                                _b[large] = { shard: 1, bytes: 8 },
+                                _b),
+                            shards: [
+                                { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                { id: 1, file: 'host/vfs-snapshot-1.json' }
+                            ]
+                        },
+                        0: (_c = {}, _c[small] = '{}', _c),
+                        1: (_d = {}, _d[large] = 'a,b\n1,2\n', _d)
+                    };
+                    global.__sasjsShardFetches = [];
+                    worker = loadWorker();
+                    return [4 /*yield*/, worker.runtime.load({})];
+                case 1:
+                    _e.sent();
+                    _a = worker.message({ type: 'sasjs-snapshot' }), replies = _a.replies, pending = _a.pending;
+                    return [4 /*yield*/, pending
+                        // the piece nobody read was fetched for the export
+                    ];
+                case 2:
+                    _e.sent();
+                    // the piece nobody read was fetched for the export
+                    expect(global.__sasjsShardFetches).toEqual([0, 1]);
+                    exported = replies.find(function (reply) { return reply.type === 'sasjs-snapshot'; });
+                    expect(Object.keys(exported.files).sort()).toEqual([large, small].sort());
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * The console's own files are the page, not an API call.
+     *
+     * `/api/...` is the API's short spelling, so the worker answers it - except for
+     * the four files the console is made of, which the static host serves. Getting
+     * that wrong answers the page's own script with an API 404, and the console
+     * renders nothing.
+     */
+    it('leaves the API console to the static host, and still answers /api calls', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var worker, source, listed, files, files_1, files_1_1, name_1, log, response;
+        var e_2, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    worker = seeded();
+                    source = fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'assets', 'sw.js'), 'utf8');
+                    listed = /const API_CONSOLE_FILES = \[([^\]]*)\]/.exec(source);
+                    expect(listed).not.toBeNull();
+                    files = listed[1]
+                        .split(',')
+                        .map(function (entry) { return entry.trim().replace(/^'|'$/g, ''); })
+                        .filter(Boolean);
+                    expect(files.length).toBeGreaterThan(3);
+                    expect(worker.dispatch('/api/')).toBeUndefined();
+                    try {
+                        for (files_1 = __values(files), files_1_1 = files_1.next(); !files_1_1.done; files_1_1 = files_1.next()) {
+                            name_1 = files_1_1.value;
+                            expect(worker.dispatch("/api/".concat(name_1))).toBeUndefined();
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (files_1_1 && !files_1_1.done && (_a = files_1.return)) _a.call(files_1);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    return [4 /*yield*/, worker.dispatch('/api/admin/logs/missing.log')];
+                case 1:
+                    log = _b.sent();
+                    expect(log.status).not.toBeUndefined();
+                    return [4 /*yield*/, worker.dispatch('/api/user')];
+                case 2:
+                    response = _b.sent();
+                    expect(response.status).toBe(200);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('answers 404 for a drive file the drive does not hold', function () { return __awaiter(void 0, void 0, void 0, function () {
         var dispatch, response, _a;
         return __generator(this, function (_b) {
@@ -2283,8 +2630,8 @@ describe('service worker host', function () {
         });
     }); });
     it('publishes, lists, serves and removes an app through the package surface', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var dispatch, _a, _b, path_2, listing, _c, e_2_1, _d, _e, path_3, landing, e_3_1, root, archive, form, published, app, _f, _g, path_4, listing, _h, e_4_1, _j, _k, path_5, page, _l, e_5_1, folder, _m, refused, missing, removed, _o, after, _p, gone;
-        var e_2, _q, e_3, _r, e_4, _s, e_5, _t;
+        var dispatch, _a, _b, path_2, listing, _c, e_3_1, _d, _e, path_3, landing, e_4_1, root, archive, form, published, app, _f, _g, path_4, listing, _h, e_5_1, _j, _k, path_5, page, _l, e_6_1, folder, _m, refused, missing, removed, _o, after, _p, gone;
+        var e_3, _q, e_4, _r, e_5, _s, e_6, _t;
         return __generator(this, function (_u) {
             switch (_u.label) {
                 case 0:
@@ -2311,14 +2658,14 @@ describe('service worker host', function () {
                     return [3 /*break*/, 2];
                 case 6: return [3 /*break*/, 9];
                 case 7:
-                    e_2_1 = _u.sent();
-                    e_2 = { error: e_2_1 };
+                    e_3_1 = _u.sent();
+                    e_3 = { error: e_3_1 };
                     return [3 /*break*/, 9];
                 case 8:
                     try {
                         if (_b && !_b.done && (_q = _a.return)) _q.call(_a);
                     }
-                    finally { if (e_2) throw e_2.error; }
+                    finally { if (e_3) throw e_3.error; }
                     return [7 /*endfinally*/];
                 case 9:
                     _u.trys.push([9, 14, 15, 16]);
@@ -2338,14 +2685,14 @@ describe('service worker host', function () {
                     return [3 /*break*/, 10];
                 case 13: return [3 /*break*/, 16];
                 case 14:
-                    e_3_1 = _u.sent();
-                    e_3 = { error: e_3_1 };
+                    e_4_1 = _u.sent();
+                    e_4 = { error: e_4_1 };
                     return [3 /*break*/, 16];
                 case 15:
                     try {
                         if (_e && !_e.done && (_r = _d.return)) _r.call(_d);
                     }
-                    finally { if (e_3) throw e_3.error; }
+                    finally { if (e_4) throw e_4.error; }
                     return [7 /*endfinally*/];
                 case 16: return [4 /*yield*/, dispatch('/AppStream')];
                 case 17:
@@ -2398,14 +2745,14 @@ describe('service worker host', function () {
                     return [3 /*break*/, 22];
                 case 26: return [3 /*break*/, 29];
                 case 27:
-                    e_4_1 = _u.sent();
-                    e_4 = { error: e_4_1 };
+                    e_5_1 = _u.sent();
+                    e_5 = { error: e_5_1 };
                     return [3 /*break*/, 29];
                 case 28:
                     try {
                         if (_g && !_g.done && (_s = _f.return)) _s.call(_f);
                     }
-                    finally { if (e_4) throw e_4.error; }
+                    finally { if (e_5) throw e_5.error; }
                     return [7 /*endfinally*/];
                 case 29:
                     _u.trys.push([29, 35, 36, 37]);
@@ -2432,14 +2779,14 @@ describe('service worker host', function () {
                     return [3 /*break*/, 30];
                 case 34: return [3 /*break*/, 37];
                 case 35:
-                    e_5_1 = _u.sent();
-                    e_5 = { error: e_5_1 };
+                    e_6_1 = _u.sent();
+                    e_6 = { error: e_6_1 };
                     return [3 /*break*/, 37];
                 case 36:
                     try {
                         if (_k && !_k.done && (_t = _j.return)) _t.call(_j);
                     }
-                    finally { if (e_5) throw e_5.error; }
+                    finally { if (e_6) throw e_6.error; }
                     return [7 /*endfinally*/];
                 case 37: return [4 /*yield*/, dispatch("/app/".concat(app.id))];
                 case 38:
@@ -2835,16 +3182,23 @@ describe('service worker host', function () {
                     expect(seed.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-seed-ack' }));
                     runtime.load(files);
                     snapshot = message({ type: 'sasjs-snapshot' });
+                    // the reply waits for the drive to be whole, so a sharded site's export is
+                    // not the part of it that happens to be in memory
+                    return [4 /*yield*/, snapshot.pending];
+                case 3:
+                    // the reply waits for the drive to be whole, so a sharded site's export is
+                    // not the part of it that happens to be in memory
+                    _c.sent();
                     expect(snapshot.replies[0].type).toBe('sasjs-snapshot');
                     expect(Object.keys(snapshot.replies[0].files).length).toBe(1);
                     reset = message({ type: 'sasjs-reset' });
                     return [4 /*yield*/, reset.pending];
-                case 3:
+                case 4:
                     _c.sent();
                     expect(reset.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-reset-ack' }));
                     stats = message({ type: 'sasjs-stats' });
                     return [4 /*yield*/, stats.pending];
-                case 4:
+                case 5:
                     _c.sent();
                     expect(stats.replies[0]).toEqual(expect.objectContaining({ type: 'sasjs-stats' }));
                     return [2 /*return*/];
@@ -3381,7 +3735,7 @@ describe('service worker host', function () {
         }); });
     });
     describe('conformance corpus', function () {
-        var e_6, _a, e_7, _b;
+        var e_7, _a, e_8, _b;
         /**
          * The corpus is what "the same API" means: the cases @sasjs/api runs against
          * its own services, and against a live sasjs/server, run here against this
@@ -3390,7 +3744,7 @@ describe('service worker host', function () {
          * used to have - and it is a test rather than a review.
          */
         var httpFor = function (testCase) {
-            var e_8, _a;
+            var e_9, _a;
             var _b;
             var _c = __read(testCase.route.split(' '), 2), method = _c[0], routePath = _c[1];
             var query = new URLSearchParams();
@@ -3401,12 +3755,12 @@ describe('service worker host', function () {
                         query.set(key, String(value));
                 }
             }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
             finally {
                 try {
                     if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
                 }
-                finally { if (e_8) throw e_8.error; }
+                finally { if (e_9) throw e_9.error; }
             }
             var suffix = query.toString() ? "?".concat(query) : '';
             var init = { method: method };
@@ -3437,8 +3791,8 @@ describe('service worker host', function () {
          * does.
          */
         var seedDrive = function (runtime, testCase) { return __awaiter(void 0, void 0, void 0, function () {
-            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_9_1;
-            var e_10, _g, e_9, _h;
+            var text, _a, _b, _c, file, contents, _d, _e, _f, file, contents, e_10_1;
+            var e_11, _g, e_10, _h;
             return __generator(this, function (_j) {
                 switch (_j.label) {
                     case 0:
@@ -3450,12 +3804,12 @@ describe('service worker host', function () {
                                     text["/sasjs/drive/files".concat(file)] = contents;
                             }
                         }
-                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
                         finally {
                             try {
                                 if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
                             }
-                            finally { if (e_10) throw e_10.error; }
+                            finally { if (e_11) throw e_11.error; }
                         }
                         return [4 /*yield*/, runtime.load(text)];
                     case 1:
@@ -3478,14 +3832,14 @@ describe('service worker host', function () {
                         return [3 /*break*/, 3];
                     case 6: return [3 /*break*/, 9];
                     case 7:
-                        e_9_1 = _j.sent();
-                        e_9 = { error: e_9_1 };
+                        e_10_1 = _j.sent();
+                        e_10 = { error: e_10_1 };
                         return [3 /*break*/, 9];
                     case 8:
                         try {
                             if (_e && !_e.done && (_h = _d.return)) _h.call(_d);
                         }
-                        finally { if (e_9) throw e_9.error; }
+                        finally { if (e_10) throw e_10.error; }
                         return [7 /*endfinally*/];
                     case 9: return [2 /*return*/];
                 }
@@ -3596,12 +3950,12 @@ describe('service worker host', function () {
                 _loop_1(testCase);
             }
         }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
         finally {
             try {
                 if (DRIVE_CORPUS_1_1 && !DRIVE_CORPUS_1_1.done && (_a = DRIVE_CORPUS_1.return)) _a.call(DRIVE_CORPUS_1);
             }
-            finally { if (e_6) throw e_6.error; }
+            finally { if (e_7) throw e_7.error; }
         }
         /** The app a removal case names, as the corpus states it. */
         var CORPUS_APP = {
@@ -3670,7 +4024,7 @@ describe('service worker host', function () {
             return __generator(this, function (_a) {
                 files = {};
                 walk = function (members, prefix) {
-                    var e_11, _a;
+                    var e_12, _a;
                     var _b;
                     try {
                         for (var _c = __values(members || []), _d = _c.next(); !_d.done; _d = _c.next()) {
@@ -3685,12 +4039,12 @@ describe('service worker host', function () {
                                         : String((_b = member.code) !== null && _b !== void 0 ? _b : '');
                         }
                     }
-                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
                     finally {
                         try {
                             if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                         }
-                        finally { if (e_11) throw e_11.error; }
+                        finally { if (e_12) throw e_12.error; }
                     }
                 };
                 walk(tree === null || tree === void 0 ? void 0 : tree.members, '');
@@ -3707,7 +4061,7 @@ describe('service worker host', function () {
          */
         var deployRequest = function (testCase) { return __awaiter(void 0, void 0, void 0, function () {
             var _a, requestPath, init, body, archive, form, _b, _c, _d, field, value;
-            var e_12, _e;
+            var e_13, _e;
             return __generator(this, function (_f) {
                 switch (_f.label) {
                     case 0:
@@ -3726,12 +4080,12 @@ describe('service worker host', function () {
                                     form.set(field, String(value));
                             }
                         }
-                        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                        catch (e_13_1) { e_13 = { error: e_13_1 }; }
                         finally {
                             try {
                                 if (_c && !_c.done && (_e = _b.return)) _e.call(_b);
                             }
-                            finally { if (e_12) throw e_12.error; }
+                            finally { if (e_13) throw e_13.error; }
                         }
                         form.set('file', new Blob([new Uint8Array(archive)]), 'deploy.zip');
                         return [2 /*return*/, { requestPath: requestPath, init: { method: 'POST', body: form } }];
@@ -3740,8 +4094,8 @@ describe('service worker host', function () {
         }); };
         var _loop_2 = function (testCase) {
             it(testCase.id, function () { return __awaiter(void 0, void 0, void 0, function () {
-                var worker, _a, requestPath, init, response, listing, ids, _b, _c, path_6, file, e_13_1, _d, _e, path_7, file, e_14_1;
-                var e_13, _f, e_14, _g;
+                var worker, _a, requestPath, init, response, listing, ids, _b, _c, path_6, file, e_14_1, _d, _e, path_7, file, e_15_1;
+                var e_14, _f, e_15, _g;
                 var _h, _j, _k;
                 return __generator(this, function (_l) {
                     switch (_l.label) {
@@ -3793,14 +4147,14 @@ describe('service worker host', function () {
                             return [3 /*break*/, 9];
                         case 12: return [3 /*break*/, 15];
                         case 13:
-                            e_13_1 = _l.sent();
-                            e_13 = { error: e_13_1 };
+                            e_14_1 = _l.sent();
+                            e_14 = { error: e_14_1 };
                             return [3 /*break*/, 15];
                         case 14:
                             try {
                                 if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
                             }
-                            finally { if (e_13) throw e_13.error; }
+                            finally { if (e_14) throw e_14.error; }
                             return [7 /*endfinally*/];
                         case 15:
                             _l.trys.push([15, 20, 21, 22]);
@@ -3819,14 +4173,14 @@ describe('service worker host', function () {
                             return [3 /*break*/, 16];
                         case 19: return [3 /*break*/, 22];
                         case 20:
-                            e_14_1 = _l.sent();
-                            e_14 = { error: e_14_1 };
+                            e_15_1 = _l.sent();
+                            e_15 = { error: e_15_1 };
                             return [3 /*break*/, 22];
                         case 21:
                             try {
                                 if (_e && !_e.done && (_g = _d.return)) _g.call(_d);
                             }
-                            finally { if (e_14) throw e_14.error; }
+                            finally { if (e_15) throw e_15.error; }
                             return [7 /*endfinally*/];
                         case 22: return [2 /*return*/];
                     }
@@ -3859,12 +4213,12 @@ describe('service worker host', function () {
                 _loop_2(testCase);
             }
         }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
         finally {
             try {
                 if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
             }
-            finally { if (e_7) throw e_7.error; }
+            finally { if (e_8) throw e_8.error; }
         }
     });
     /**
@@ -3876,7 +4230,7 @@ describe('service worker host', function () {
      * are the package's.
      */
     describe('identity and record conformance', function () {
-        var e_15, _a;
+        var e_16, _a;
         /**
          * Boots the worker from a fixture, the way the page does: the case's own
          * identity, and `subject: null` for no implicit caller, so a case that
@@ -3909,7 +4263,7 @@ describe('service worker host', function () {
         };
         /** The request a case describes, as HTTP: path parameters filled, token sent. */
         var httpForCase = function (testCase) {
-            var e_16, _a;
+            var e_17, _a;
             var _b = __read(testCase.route.split(' '), 2), method = _b[0], routePath = _b[1];
             var filled = routePath.replace(/\{(\w+)\}/g, function (_match, name) {
                 return encodeURIComponent(String((testCase.request.params || {})[name]));
@@ -3922,12 +4276,12 @@ describe('service worker host', function () {
                         query.set(key, String(value));
                 }
             }
-            catch (e_16_1) { e_16 = { error: e_16_1 }; }
+            catch (e_17_1) { e_17 = { error: e_17_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_16) throw e_16.error; }
+                finally { if (e_17) throw e_17.error; }
             }
             var suffix = query.toString() ? "?".concat(query) : '';
             var headers = {};
@@ -4049,12 +4403,12 @@ describe('service worker host', function () {
                 _loop_3(testCase);
             }
         }
-        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_15) throw e_15.error; }
+            finally { if (e_16) throw e_16.error; }
         }
         it('answers as the fixture administrator when no subject was chosen', function () { return __awaiter(void 0, void 0, void 0, function () {
             var worker, response, rules;