@sasjs/cli 6.30.0 → 6.30.1

package/build/commands/build/internal/mockSite/spec/runtime-core.spec.js

@@ -35,6 +35,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 };
 };
@@ -118,6 +143,527 @@ describe('browser runtime', function () {
         delete global.self;
         delete global.fetch;
     });
+    /**
+     * A sharded drive is read without fetching what the request does not need.
+     *
+     * The build splits a captured drive so a first page does not download every
+     * app's bundle. What must hold here is that the split is invisible: a listing,
+     * an existence check and a stat answer for files whose bytes are still on the
+     * site, and only a read goes back for them.
+     */
+    it('answers for a sharded drive without fetching the pieces it does not need', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, indexShard, bundleShard, bundle, fetched, listing, refused, read;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    indexShard = "".concat(drivePath('index.json'));
+                    bundleShard = "".concat(drivePath('services/web/index.bundle.js'));
+                    bundle = 'x'.repeat(400);
+                    fetched = [];
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var id, files;
+                        var _a, _b, _c;
+                        return __generator(this, function (_d) {
+                            fetched.push(url);
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc })];
+                            if (/vfs-snapshot-\d+\.json/.test(url)) {
+                                id = Number(/vfs-snapshot-(\d+)\.json/.exec(url)[1]);
+                                files = id === 0 ? (_a = {}, _a[indexShard] = '{"apps":[]}', _a) : (_b = {}, _b[bundleShard] = bundle, _b);
+                                return [2 /*return*/, jsonResponse({ format: mockSite_1.DRIVE_FORMAT, files: files })];
+                            }
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        sharded: true,
+                                        boot: 0,
+                                        entries: (_c = {},
+                                            _c[indexShard] = { shard: 0, bytes: 12 },
+                                            _c[bundleShard] = { shard: 1, bytes: bundle.length },
+                                            _c),
+                                        shards: [
+                                            { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                            { id: 1, file: 'host/vfs-snapshot-1.json' }
+                                        ]
+                                    })];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.seed()
+                        // the boot shard came with the drive; the bundle did not
+                    ];
+                case 1:
+                    _a.sent();
+                    // the boot shard came with the drive; the bundle did not
+                    expect(fetched.some(function (url) { return url.includes('vfs-snapshot-1'); })).toBe(false);
+                    listing = runtime.run({
+                        code: [
+                            "const bundle = '".concat(bundleShard, "'"),
+                            "const folder = '".concat(drivePath('services/web'), "'"),
+                            "const seen = fs.readdirSync(folder).join(',')",
+                            "_webout = [seen, fs.existsSync(bundle), fs.statSync(bundle).size].join('|')"
+                        ].join('\n')
+                    });
+                    expect(listing.error).toBeNull();
+                    expect(listing.webout).toBe("index.bundle.js|true|".concat(bundle.length));
+                    refused = runtime.run({
+                        code: [
+                            "let code = 'none'",
+                            "try { fs.readFileSync('".concat(bundleShard, "') } catch (e) { code = e.code }"),
+                            "_webout = code"
+                        ].join('\n')
+                    });
+                    expect(refused.webout).toBe(runtime.PENDING_CODE);
+                    return [4 /*yield*/, runtime.ensurePaths([bundleShard])];
+                case 2:
+                    _a.sent();
+                    expect(fetched.some(function (url) { return url.includes('vfs-snapshot-1'); })).toBe(true);
+                    read = runtime.run({
+                        code: "_webout = String(fs.readFileSync('".concat(bundleShard, "').length)")
+                    });
+                    expect(read.webout).toBe(String(bundle.length));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * A shard that cannot be read is named, not silently absent.
+     *
+     * The drive answers for a file it holds whether or not its bytes are in
+     * memory, so a piece that fails to arrive is the one way a read can end up
+     * with nothing: saying which file was missing is the difference between a
+     * broken deployment and a mystery.
+     */
+    it('names a shard it cannot fetch, and refuses one of another format', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, missing, foreign, index;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    missing = "".concat(drivePath('missing.json'));
+                    foreign = "".concat(drivePath('foreign.bin'));
+                    index = function (shardFiles) { return ({
+                        format: mockSite_1.DRIVE_FORMAT,
+                        sharded: true,
+                        boot: 0,
+                        entries: Object.fromEntries(shardFiles.map(function (path, i) { return [path, { shard: i + 1, bytes: 4 }]; })),
+                        shards: __spreadArray([
+                            { id: 0, file: 'host/vfs-snapshot-0.json' }
+                        ], __read(shardFiles.map(function (_, i) { return ({
+                            id: i + 1,
+                            file: "host/vfs-snapshot-".concat(i + 1, ".json")
+                        }); })), false)
+                    }); };
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc })];
+                            if (url.includes('vfs-snapshot-0'))
+                                return [2 /*return*/, jsonResponse({ files: {} })];
+                            if (url.includes('vfs-snapshot-1'))
+                                return [2 /*return*/, { ok: false, status: 404 }];
+                            if (url.includes('vfs-snapshot-2'))
+                                return [2 /*return*/, jsonResponse({ format: 99, files: {} })];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, jsonResponse(index([missing, foreign]))];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.seed()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, expect(runtime.ensurePaths([missing])).rejects.toThrow(/vfs-snapshot-1\.json.*404/)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, expect(runtime.ensurePaths([foreign])).rejects.toThrow(/format 99/)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('boots without its boot shard, and names the piece a read could not fetch', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, path;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    path = "".concat(drivePath('config.json'));
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a;
+                        return __generator(this, function (_b) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc, snapshotShards: 1 })];
+                            if (/vfs-snapshot-0\.json/.test(url))
+                                return [2 /*return*/, { ok: false, status: 404 }];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        sharded: true,
+                                        boot: 0,
+                                        entries: (_a = {}, _a[path] = { shard: 0, bytes: 2 }, _a),
+                                        shards: [{ id: 0, file: 'host/vfs-snapshot-0.json' }]
+                                    })];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    // a half-uploaded deploy must not leave the page with no drive at all
+                    return [4 /*yield*/, expect(runtime.seed()).resolves.toEqual(expect.objectContaining({ booted: true, driveError: expect.any(String) }))];
+                case 1:
+                    // a half-uploaded deploy must not leave the page with no drive at all
+                    _a.sent();
+                    return [4 /*yield*/, expect(runtime.ensurePaths([path])).rejects.toThrow(/vfs-snapshot-0\.json.*404/)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('counts the pieces still on the site in the drive total', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, onSite;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    onSite = "".concat(drivePath('bundle.js'));
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a, _b;
+                        return __generator(this, function (_c) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc, snapshotShards: 2 })];
+                            if (/vfs-snapshot-0\.json/.test(url))
+                                return [2 /*return*/, jsonResponse({ files: (_a = {}, _a[drivePath('small.txt')] = 'ab', _a) })];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        sharded: true,
+                                        boot: 0,
+                                        entries: (_b = {},
+                                            _b[drivePath('small.txt')] = { shard: 0, bytes: 2 },
+                                            _b[onSite] = { shard: 1, bytes: 4096 },
+                                            _b),
+                                        shards: [
+                                            { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                            { id: 1, file: 'host/vfs-snapshot-1.json' }
+                                        ]
+                                    })];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.seed()
+                        // the piece nobody read is still part of the drive
+                    ];
+                case 1:
+                    _a.sent();
+                    // the piece nobody read is still part of the drive
+                    expect(runtime.stats()).toEqual(expect.objectContaining({ files: 1, onSite: 1, bytes: 2 + 4096 }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * A deletion outlives the page, and the index must not undo it.
+     *
+     * A sharded site's index lists every file the build ships, so a file the
+     * visitor removed would come back with the next page load - the tombstone the
+     * page keeps is what stops it.
+     */
+    it('keeps a deleted file deleted across a restore', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, captured, kept, read;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    captured = "".concat(drivePath('captured.txt'));
+                    kept = "".concat(drivePath('kept.txt'));
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a, _b;
+                        return __generator(this, function (_c) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc, snapshotShards: 1 })];
+                            if (/vfs-snapshot-0\.json/.test(url))
+                                return [2 /*return*/, jsonResponse({ files: (_a = {}, _a[kept] = 'kept', _a) })];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        sharded: true,
+                                        boot: 0,
+                                        entries: (_b = {},
+                                            _b[captured] = { shard: 0, bytes: 8 },
+                                            _b[kept] = { shard: 0, bytes: 4 },
+                                            _b),
+                                        shards: [{ id: 0, file: 'host/vfs-snapshot-0.json' }]
+                                    })];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.load((_a = {}, _a[kept] = 'kept', _a), [captured])];
+                case 1:
+                    _b.sent();
+                    expect(runtime.stats()).toEqual(expect.objectContaining({ files: 1, onSite: 0 }));
+                    read = runtime.run({
+                        code: [
+                            "let seen = 'read'",
+                            "try { fs.readFileSync('".concat(captured, "') } catch (e) { seen = e.code }"),
+                            "_webout = [fs.existsSync('".concat(captured, "'), seen].join('|')")
+                        ].join('\n')
+                    });
+                    expect(read.webout).toBe('false|ENOENT');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('asks for no drive index when the build shipped an unsharded capture', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, fetched;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    fetched = [];
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            fetched.push(url);
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc })];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    // a site built before the split carries no count, and the warm path must not
+                    // pay a request for an index that does not exist
+                    return [4 /*yield*/, runtime.load((_a = {}, _a[drivePath('a.txt')] = 'a', _a))];
+                case 1:
+                    // a site built before the split carries no count, and the warm path must not
+                    // pay a request for an index that does not exist
+                    _b.sent();
+                    expect(fetched.some(function (url) { return url.includes('vfs-snapshot'); })).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('restores a drive whose boot shard did not arrive, and says so', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, path;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    path = "".concat(drivePath('config.json'));
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a;
+                        return __generator(this, function (_b) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc, snapshotShards: 1 })];
+                            if (/vfs-snapshot-0\.json/.test(url))
+                                return [2 /*return*/, { ok: false, status: 404 }];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        sharded: true,
+                                        boot: 0,
+                                        entries: (_a = {}, _a[path] = { shard: 0, bytes: 2 }, _a),
+                                        shards: [{ id: 0, file: 'host/vfs-snapshot-0.json' }]
+                                    })];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    // a returning visitor must not be refused where a fresh visitor is only
+                    // short: the restore reports the failure and keeps the index
+                    return [4 /*yield*/, expect(runtime.load({})).resolves.toEqual(expect.objectContaining({ booted: true, driveError: expect.any(String) }))];
+                case 1:
+                    // a returning visitor must not be refused where a fresh visitor is only
+                    // short: the restore reports the failure and keeps the index
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    /**
+     * A write over a captured file replaces it, in both directions.
+     *
+     * The file's bytes are still on the site, so it is in the index as well as in
+     * memory unless the write takes it out - and then a listing names it twice, the
+     * drive total counts it twice, and a piece fetched later puts the capture's copy
+     * back over the visitor's.
+     */
+    it('takes a written path out of the capture, so it is counted and listed once', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, path, written, read;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    path = "".concat(drivePath('overwritten.txt'));
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a, _b;
+                        return __generator(this, function (_c) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc, snapshotShards: 2 })];
+                            if (/vfs-snapshot-0\.json/.test(url))
+                                return [2 /*return*/, jsonResponse({ files: {} })];
+                            if (/vfs-snapshot-1\.json/.test(url))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        files: (_a = {}, _a[path] = 'captured content', _a)
+                                    })];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        sharded: true,
+                                        boot: 0,
+                                        entries: (_b = {}, _b[path] = { shard: 1, bytes: 16 }, _b),
+                                        shards: [
+                                            { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                            { id: 1, file: 'host/vfs-snapshot-1.json' }
+                                        ]
+                                    })];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.seed()];
+                case 1:
+                    _a.sent();
+                    written = runtime.run({
+                        code: "fs.writeFileSync('".concat(path, "', 'mine'); _webout = 'ok'")
+                    });
+                    expect(written.webout).toBe('ok');
+                    read = runtime.run({
+                        code: [
+                            "const folder = fs.readdirSync('".concat(drivePath(''), "').filter((name) => name === 'overwritten.txt')"),
+                            "_webout = [folder.length, fs.readFileSync('".concat(path, "')].join('|')")
+                        ].join('\n')
+                    });
+                    expect(read.webout).toBe('1|mine');
+                    // nothing of the capture is left unloaded for that path: the run's own session
+                    // files are the only other entries, so the count of pieces still on the site
+                    // is what says the write took the path out of the index
+                    expect(runtime.stats()).toEqual(expect.objectContaining({ onSite: 0 }));
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('reports an index that failed, rather than restoring the visitor files alone', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc, snapshotShards: 1 })];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, { ok: false, status: 500 }];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    // a 500 is not "this site ships no snapshot": restoring without the index
+                    // would leave only the files this visitor changed, silently
+                    return [4 /*yield*/, expect(runtime.load({})).resolves.toEqual(expect.objectContaining({
+                            booted: true,
+                            driveError: expect.stringContaining('answered 500')
+                        }))
+                        // and 404 still reads as a site with nothing to ship
+                    ];
+                case 1:
+                    // a 500 is not "this site ships no snapshot": restoring without the index
+                    // would leave only the files this visitor changed, silently
+                    _a.sent();
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc, snapshotShards: 1 })];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, { ok: false, status: 404 }];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    return [4 /*yield*/, expect(loadRuntime().load({})).resolves.toEqual(expect.objectContaining({ booted: true }))];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('refuses an append onto a file whose bytes are still on the site', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var runtime, path, refused, appended;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    runtime = loadRuntime();
+                    path = "".concat(drivePath('appended.txt'));
+                    global.fetch = jest.fn(function (url) { return __awaiter(void 0, void 0, void 0, function () {
+                        var _a, _b;
+                        return __generator(this, function (_c) {
+                            if (url.includes('mock-config'))
+                                return [2 /*return*/, jsonResponse({ appLoc: appLoc, snapshotShards: 2 })];
+                            if (/vfs-snapshot-0\.json/.test(url))
+                                return [2 /*return*/, jsonResponse({ files: {} })];
+                            if (/vfs-snapshot-1\.json/.test(url))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        files: (_a = {}, _a[path] = 'first', _a)
+                                    })];
+                            if (url.includes('vfs-snapshot'))
+                                return [2 /*return*/, jsonResponse({
+                                        format: mockSite_1.DRIVE_FORMAT,
+                                        sharded: true,
+                                        boot: 0,
+                                        entries: (_b = {}, _b[path] = { shard: 1, bytes: 5 }, _b),
+                                        shards: [
+                                            { id: 0, file: 'host/vfs-snapshot-0.json' },
+                                            { id: 1, file: 'host/vfs-snapshot-1.json' }
+                                        ]
+                                    })];
+                            return [2 /*return*/, { ok: false, json: function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                                        return [2 /*return*/, ({})];
+                                    }); }); } }];
+                        });
+                    }); });
+                    return [4 /*yield*/, runtime.seed()
+                        // the capture's bytes are still on the site, and appending would replace them
+                    ];
+                case 1:
+                    _a.sent();
+                    refused = runtime.run({
+                        code: "fs.appendFileSync('".concat(path, "', 'plus'); _webout = 'ok'")
+                    });
+                    // the statement after the append never ran: the write was refused, not done
+                    expect(refused.webout).not.toBe('ok');
+                    expect(runtime.stats()).toEqual(expect.objectContaining({ onSite: 1 }));
+                    // once the piece is here the append lands on top of what was captured
+                    return [4 /*yield*/, runtime.ensurePaths([path])];
+                case 2:
+                    // once the piece is here the append lands on top of what was captured
+                    _a.sent();
+                    appended = runtime.run({
+                        code: "fs.appendFileSync('".concat(path, "', 'plus'); _webout = fs.readFileSync('").concat(path, "')")
+                    });
+                    expect(appended.webout).toBe('firstplus');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
     it('refuses a drive file whose format it does not speak', function () { return __awaiter(void 0, void 0, void 0, function () {
         var runtime, result;
         return __generator(this, function (_a) {