@proteinjs/db-file 1.8.3 → 1.9.0

package/dist/test/FileVariants.test.js

@@ -0,0 +1,1008 @@
+"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;
+    return g = { next: verb(0), "throw": verb(1), "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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var db_1 = require("@proteinjs/db");
+var reflection_1 = require("@proteinjs/reflection");
+var user_1 = require("@proteinjs/user");
+var tables_1 = require("../src/tables/tables");
+var FileStorage_1 = require("../src/FileStorage");
+var getFile_1 = require("../src/routes/getFile");
+var getFileVariant_1 = require("../src/routes/getFileVariant");
+var getFileVariantRoute_1 = require("../src/routes/getFileVariantRoute");
+var FileTestEnvironment_1 = require("./FileTestEnvironment");
+/**
+ * A derived File of a File — the preview and the stage variant — has ONE lifecycle, the library's:
+ * made by the registered maker (at ingest with the bytes in hand, or once on the first request from
+ * a surface that draws it), stored as the owner's own File naming its original, named on the
+ * original's row, dropped when the original's bytes change, deleted with the original, readable by
+ * whoever can read the original, and served like any File — through the same non-owner copy rule.
+ * This suite proves the seam contract with a stub maker (the real one — a picture's 512 px thumbnail
+ * and its 1600 px rendition — lives in the package that knows pictures).
+ *
+ * The stub maker marks what it makes: `PREVIEW:`/`STAGE:` and the first bytes of the original.
+ */
+var originalBytes = Buffer.concat([Buffer.from('ORIGINAL:'), Buffer.from(Array.from({ length: 64 }, function (_, i) { return i; }))]);
+var variantOf = function (kind, bytes) {
+    return Buffer.concat([Buffer.from("".concat(kind.toUpperCase(), ":")), bytes.subarray(0, 8)]);
+};
+var VARIANT_EDGE = { preview: 512, stage: 1600 };
+/** What the copy-for-others maker takes off a copy (the location marker of the real one). */
+var COPY_MARK = Buffer.from('-FOR-OTHERS');
+/** In-memory proxy-shape driver (no signed URLs) — the DbFileStorageDriver serving shape. */
+var ProxyDriver = /** @class */ (function () {
+    function ProxyDriver() {
+        this.store = new Map();
+        /** Every id whose bytes were read, in order — what a derivation costs the store. */
+        this.reads = [];
+        /** Every id whose bytes were deleted, in order. */
+        this.deletes = [];
+    }
+    ProxyDriver.prototype.createFile = function (file, fileData) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.store.set(file.id, Buffer.from(fileData, 'base64'));
+                        return [4 /*yield*/, atBarrier()];
+                    case 1:
+                        _a.sent(); // the racing case: every variant's bytes are stored before any row is asked its word
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    ProxyDriver.prototype.getFileData = function (fileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                this.reads.push(fileId);
+                data = this.store.get(fileId);
+                if (data === undefined) {
+                    throw new Error("No such object: ".concat(fileId));
+                }
+                return [2 /*return*/, data.toString('base64')];
+            });
+        });
+    };
+    ProxyDriver.prototype.updateFileData = function (fileId, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.store.set(fileId, Buffer.from(data, 'base64'));
+                return [2 /*return*/];
+            });
+        });
+    };
+    ProxyDriver.prototype.deleteFile = function (fileId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.deletes.push(fileId);
+                this.store.delete(fileId);
+                return [2 /*return*/];
+            });
+        });
+    };
+    return ProxyDriver;
+}());
+var ResponseRecorder = /** @class */ (function () {
+    function ResponseRecorder() {
+        this.headers = {};
+    }
+    ResponseRecorder.prototype.status = function (code) {
+        this.statusCode = code;
+        return this;
+    };
+    ResponseRecorder.prototype.send = function (body) {
+        this.body = body;
+        return this;
+    };
+    ResponseRecorder.prototype.setHeader = function (name, value) {
+        this.headers[name.toLowerCase()] = value;
+    };
+    ResponseRecorder.prototype.redirect = function () {
+        throw new Error('the proxy driver never redirects');
+    };
+    return ResponseRecorder;
+}());
+var invokeRoute = function (fileId) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                response = new ResponseRecorder();
+                return [4 /*yield*/, getFile_1.getFile.onRequest({ params: { id: fileId }, headers: {} }, response)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/, response];
+        }
+    });
+}); };
+/** `GET /file/:id/variant/:kind` — the URL a surface asks for a file's variant by (a plain `<img src>`). */
+var invokeVariantRoute = function (fileId, kind) { return __awaiter(void 0, void 0, void 0, function () {
+    var response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                response = new ResponseRecorder();
+                return [4 /*yield*/, getFileVariant_1.getFileVariant.onRequest({ params: { id: fileId, kind: kind }, headers: {} }, response)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/, response];
+        }
+    });
+}); };
+var testEnv = new FileTestEnvironment_1.FileTestEnvironment();
+var objectCache = function () { return reflection_1.SourceRepository.get().objectCache; };
+var owner;
+var recipient;
+var stranger;
+var reachableFileIds = new Set();
+/** Every call the variant maker took: which file, which kind, the bytes it was handed. */
+var makerCalls = [];
+/** The kinds the stub maker applies to (of a picture) — the suite's own rule. */
+var kindsApplied = new Set(['preview', 'stage']);
+/** A barrier for the racing case — `makerBarrier = n` holds every maker call until n are inside, then releases them on one tick. */
+var makerBarrier = 0;
+var makerWaiting = [];
+/** A hold for the in-flight case — the maker waits on it (when set) so readers can arrive while one derivation runs. */
+var makerHold;
+/** The maker cannot make anything of these bytes (a picture the decoder cannot read). */
+var makerRefuses = false;
+var atBarrier = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (makerBarrier <= 0) {
+                    return [2 /*return*/];
+                }
+                return [4 /*yield*/, new Promise(function (resolve) {
+                        makerWaiting.push(resolve);
+                        if (makerWaiting.length >= makerBarrier) {
+                            var release = makerWaiting;
+                            makerWaiting = [];
+                            release.forEach(function (go) { return go(); });
+                        }
+                    })];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); };
+var registerVariantMaker = function () {
+    objectCache()['@proteinjs/db-file/FileVariantMaker'] = [
+        {
+            appliesTo: function (file, kind) { return file.type.startsWith('image/') && kindsApplied.has(kind); },
+            make: function (file, bytes, kind) { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            makerCalls.push({ fileId: file.id, kind: kind, bytes: Buffer.from(bytes) });
+                            return [4 /*yield*/, atBarrier()];
+                        case 1:
+                            _a.sent();
+                            return [4 /*yield*/, makerHold];
+                        case 2:
+                            _a.sent();
+                            if (makerRefuses) {
+                                throw new Error('the decoder cannot decode these bytes');
+                            }
+                            return [2 /*return*/, {
+                                    bytes: variantOf(kind, bytes),
+                                    type: 'image/webp',
+                                    width: VARIANT_EDGE[kind],
+                                    height: VARIANT_EDGE[kind] / 2,
+                                }];
+                    }
+                });
+            }); },
+        },
+    ];
+};
+/** The copy-for-others maker of the copy suite, in miniature: a picture's copy is its bytes with the mark taken off. */
+var copyMakerCalls = [];
+var registerCopyMaker = function () {
+    objectCache()['@proteinjs/db-file/FileCopyForOthers'] = [
+        {
+            appliesTo: function (file) { return file.type.startsWith('image/'); },
+            make: function (file, bytes) { return __awaiter(void 0, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    copyMakerCalls.push(file.id);
+                    return [2 /*return*/, bytes.subarray(0, bytes.length - COPY_MARK.length)];
+                });
+            }); },
+        },
+    ];
+};
+beforeAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, testEnv.beforeAll()];
+            case 1:
+                _a.sent();
+                objectCache()['@proteinjs/user-auth/AuthenticatedUserRepo'] = [new user_1.UserRepo()];
+                user_1.UserAuth.userRepo = undefined;
+                objectCache()['@proteinjs/db-file/FileReachabilityResolver'] = [
+                    // The content leg vouches for the RECIPIENT alone (a share they accepted); a stranger holds no grant.
+                    {
+                        canReadViaReference: function (fileId) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                            return [2 /*return*/, reachableFileIds.has(fileId) && new user_1.UserRepo().getUser().id === recipient.id];
+                        }); }); },
+                    },
+                ];
+                return [4 /*yield*/, testEnv.createUser({ name: 'File owner', email: 'variant-owner@test.local' })];
+            case 2:
+                owner = _a.sent();
+                return [4 /*yield*/, testEnv.createUser({ name: 'Share recipient', email: 'variant-recipient@test.local' })];
+            case 3:
+                recipient = _a.sent();
+                return [4 /*yield*/, testEnv.createUser({ name: 'Stranger', email: 'variant-stranger@test.local' })];
+            case 4:
+                stranger = _a.sent();
+                testEnv.actAs(owner);
+                return [2 /*return*/];
+        }
+    });
+}); });
+afterAll(function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                delete objectCache()['@proteinjs/db-file/FileReachabilityResolver'];
+                delete objectCache()['@proteinjs/db-file/FileVariantMaker'];
+                delete objectCache()['@proteinjs/db-file/FileCopyForOthers'];
+                user_1.UserAuth.userRepo = undefined;
+                return [4 /*yield*/, testEnv.afterAll()];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); });
+var driver = new ProxyDriver();
+beforeEach(function () {
+    reachableFileIds.clear();
+    makerCalls = [];
+    copyMakerCalls = [];
+    kindsApplied = new Set(['preview', 'stage']);
+    makerBarrier = 0;
+    makerWaiting = [];
+    makerHold = undefined;
+    makerRefuses = false;
+    driver.reads = [];
+    driver.deletes = [];
+    registerVariantMaker();
+    objectCache()['@proteinjs/db-file/FileCopyForOthers'] = [];
+    testEnv.setDriver(driver);
+    testEnv.actAs(owner);
+});
+/** A picture of the owner's, stored with no variant (a file made before the seam, or by a producer that did not derive one). */
+var createOwnerPicture = function (name, type, bytes) {
+    if (name === void 0) { name = 'photo.jpg'; }
+    if (type === void 0) { type = 'image/jpeg'; }
+    if (bytes === void 0) { bytes = originalBytes; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, new FileStorage_1.FileStorage().createFile({ name: name, type: type, size: bytes.length, width: 4032, height: 3024 }, bytes.toString('base64'))];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+};
+var rowAsSystem = function (fileId) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, (0, db_1.getDbAsSystem)().get(tables_1.tables.File, { id: fileId })];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
+var fileRowsInScope = function (scope) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, db_1.getDbAsSystem)().query(tables_1.tables.File, new db_1.QueryBuilderFactory().getQueryBuilder(tables_1.tables.File).condition({ field: 'scope', operator: '=', value: scope }))];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+describe('the ingest door — deriveVariants with the bytes in hand', function () {
+    it("makes every kind the maker applies to, beside each other: two Files of the OWNER's, each naming its original, each named on the row", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, derived, row, _i, _a, kind, variant;
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        return __generator(this, function (_l) {
+            switch (_l.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('camera.jpg')];
+                case 1:
+                    file = _l.sent();
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().deriveVariants(file, originalBytes)];
+                case 2:
+                    derived = _l.sent();
+                    expect(makerCalls.map(function (call) { return [call.fileId, call.kind]; })).toEqual([
+                        [file.id, 'preview'],
+                        [file.id, 'stage'],
+                    ]);
+                    expect(makerCalls.every(function (call) { return call.bytes.equals(originalBytes); })).toBe(true);
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    row = (_l.sent());
+                    expect((_b = row.preview) === null || _b === void 0 ? void 0 : _b._id).toEqual(derived.variants.preview.id);
+                    expect((_c = row.stage) === null || _c === void 0 ? void 0 : _c._id).toEqual(derived.variants.stage.id);
+                    expect((_d = derived.file.preview) === null || _d === void 0 ? void 0 : _d._id).toEqual((_e = row.preview) === null || _e === void 0 ? void 0 : _e._id);
+                    expect((_f = derived.file.stage) === null || _f === void 0 ? void 0 : _f._id).toEqual((_g = row.stage) === null || _g === void 0 ? void 0 : _g._id);
+                    _i = 0, _a = ['preview', 'stage'];
+                    _l.label = 4;
+                case 4:
+                    if (!(_i < _a.length)) return [3 /*break*/, 7];
+                    kind = _a[_i];
+                    return [4 /*yield*/, rowAsSystem(derived.variants[kind].id)];
+                case 5:
+                    variant = (_l.sent());
+                    expect(variant.scope).toEqual(owner.id);
+                    expect((_h = variant.variantOf) === null || _h === void 0 ? void 0 : _h._id).toEqual(file.id);
+                    expect([variant.name, variant.type, variant.size, variant.width, variant.height]).toEqual([
+                        "(".concat(kind, ") camera.jpg"),
+                        'image/webp',
+                        variantOf(kind, originalBytes).length,
+                        VARIANT_EDGE[kind],
+                        VARIANT_EDGE[kind] / 2,
+                    ]);
+                    expect(driver.store.get(variant.id).equals(variantOf(kind, originalBytes))).toBe(true);
+                    _l.label = 6;
+                case 6:
+                    _i++;
+                    return [3 /*break*/, 4];
+                case 7:
+                    // The original is untouched: its bytes, its size, its own seat empty.
+                    expect(driver.store.get(file.id).equals(originalBytes)).toBe(true);
+                    expect((_k = (_j = row.variantOf) === null || _j === void 0 ? void 0 : _j._id) !== null && _k !== void 0 ? _k : null).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('a kind the maker does not apply to is not made and its seat stays empty; a kind already named is not made again; with no maker nothing is made', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, first, _a, second, bare, none, _b;
+        var _c, _d, _e, _f, _g, _h;
+        return __generator(this, function (_j) {
+            switch (_j.label) {
+                case 0:
+                    kindsApplied = new Set(['preview']);
+                    return [4 /*yield*/, createOwnerPicture('small.png', 'image/png')];
+                case 1:
+                    file = _j.sent();
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().deriveVariants(file, originalBytes)];
+                case 2:
+                    first = _j.sent();
+                    expect(Object.keys(first.variants)).toEqual(['preview']);
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    _a.apply(void 0, [(_d = (_c = (_j.sent()).stage) === null || _c === void 0 ? void 0 : _c._id) !== null && _d !== void 0 ? _d : null]).toBeNull();
+                    kindsApplied = new Set(['preview', 'stage']);
+                    makerCalls = [];
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().deriveVariants(first.file, originalBytes)];
+                case 4:
+                    second = _j.sent();
+                    expect(makerCalls.map(function (call) { return call.kind; })).toEqual(['stage']);
+                    expect((_e = second.file.preview) === null || _e === void 0 ? void 0 : _e._id).toEqual(first.variants.preview.id);
+                    expect((_f = second.file.stage) === null || _f === void 0 ? void 0 : _f._id).toEqual(second.variants.stage.id);
+                    objectCache()['@proteinjs/db-file/FileVariantMaker'] = [];
+                    return [4 /*yield*/, createOwnerPicture('bare.jpg')];
+                case 5:
+                    bare = _j.sent();
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().deriveVariants(bare, originalBytes)];
+                case 6:
+                    none = _j.sent();
+                    expect(none.variants).toEqual({});
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(bare.id)];
+                case 7:
+                    _b.apply(void 0, [(_h = (_g = (_j.sent()).stage) === null || _g === void 0 ? void 0 : _g._id) !== null && _h !== void 0 ? _h : null]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('the lifecycle — the stage dies with its original and with its bytes, exactly as the preview does', function () {
+    it('deleting the original deletes the stage variant: its row and its bytes (the cascade)', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, variants, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('gone.jpg')];
+                case 1:
+                    file = _c.sent();
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().deriveVariants(file, originalBytes)];
+                case 2:
+                    variants = (_c.sent()).variants;
+                    expect(driver.store.has(variants.stage.id)).toBe(true);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().deleteFile(file.id)];
+                case 3:
+                    _c.sent();
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(variants.stage.id)];
+                case 4:
+                    _a.apply(void 0, [_c.sent()]).toBeUndefined();
+                    expect(driver.store.has(variants.stage.id)).toBe(false);
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(variants.preview.id)];
+                case 5:
+                    _b.apply(void 0, [_c.sent()]).toBeUndefined();
+                    expect(driver.store.has(variants.preview.id)).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('new bytes drop every derived File — the preview, the stage and the copy for others: the row forgets them, their rows and bytes go', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, variants, before, newBytes, after, _i, _a, id, _b, fresh;
+        var _c, _d, _e, _f, _g, _h, _j;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0:
+                    registerCopyMaker();
+                    return [4 /*yield*/, createOwnerPicture('rewritten.jpg')];
+                case 1:
+                    file = _k.sent();
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().deriveVariants(file, originalBytes)];
+                case 2:
+                    variants = (_k.sent()).variants;
+                    reachableFileIds.add(file.id);
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFileData(file.id)];
+                case 3:
+                    _k.sent(); // the copy for others is made and named
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 4:
+                    before = (_k.sent());
+                    expect((_c = before.copyForOthers) === null || _c === void 0 ? void 0 : _c._id).toBeTruthy();
+                    testEnv.actAs(owner);
+                    newBytes = Buffer.from('NEW-BYTES');
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().updateFileData(file.id, newBytes.toString('base64'))];
+                case 5:
+                    _k.sent();
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 6:
+                    after = (_k.sent());
+                    expect([(_e = (_d = after.preview) === null || _d === void 0 ? void 0 : _d._id) !== null && _e !== void 0 ? _e : null, (_g = (_f = after.stage) === null || _f === void 0 ? void 0 : _f._id) !== null && _g !== void 0 ? _g : null, (_j = (_h = after.copyForOthers) === null || _h === void 0 ? void 0 : _h._id) !== null && _j !== void 0 ? _j : null]).toEqual([
+                        null,
+                        null,
+                        null,
+                    ]);
+                    _i = 0, _a = [variants.preview.id, variants.stage.id, before.copyForOthers._id];
+                    _k.label = 7;
+                case 7:
+                    if (!(_i < _a.length)) return [3 /*break*/, 10];
+                    id = _a[_i];
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(id)];
+                case 8:
+                    _b.apply(void 0, [_k.sent()]).toBeUndefined();
+                    expect(driver.store.has(id)).toBe(false);
+                    _k.label = 9;
+                case 9:
+                    _i++;
+                    return [3 /*break*/, 7];
+                case 10:
+                    expect(driver.store.get(file.id).equals(newBytes)).toBe(true);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 11:
+                    fresh = (_k.sent());
+                    expect(driver.store.get(fresh.id).equals(variantOf('stage', newBytes))).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('the read path — a File without a stage derives it on the first request, once', function () {
+    it('the first getVariant makes the stage and names it; the second is served the same row without the maker', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, _a, first, second, _b, _c;
+        var _d, _e, _f, _g, _h, _j;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('existing.jpg')];
+                case 1:
+                    file = _k.sent();
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 2:
+                    _a.apply(void 0, [(_e = (_d = (_k.sent()).stage) === null || _d === void 0 ? void 0 : _d._id) !== null && _e !== void 0 ? _e : null]).toBeNull();
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 3:
+                    first = (_k.sent());
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 4:
+                    second = (_k.sent());
+                    expect(makerCalls.map(function (call) { return call.kind; })).toEqual(['stage']);
+                    expect(makerCalls[0].bytes.equals(originalBytes)).toBe(true);
+                    expect(second.id).toEqual(first.id);
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 5:
+                    _b.apply(void 0, [(_f = (_k.sent()).stage) === null || _f === void 0 ? void 0 : _f._id]).toEqual(first.id);
+                    expect((_g = first.variantOf) === null || _g === void 0 ? void 0 : _g._id).toEqual(file.id);
+                    expect([first.type, first.width, first.height]).toEqual(['image/webp', 1600, 800]);
+                    expect(driver.store.get(first.id).equals(variantOf('stage', originalBytes))).toBe(true);
+                    // Only the kind asked for: the preview seat stays empty.
+                    _c = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 6:
+                    // Only the kind asked for: the preview seat stays empty.
+                    _c.apply(void 0, [(_j = (_h = (_k.sent()).preview) === null || _h === void 0 ? void 0 : _h._id) !== null && _j !== void 0 ? _j : null]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("a recipient's read derives it as the OWNER's File; the owner is then served the same row", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, theirs, mine, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('shared.jpg')];
+                case 1:
+                    file = _b.sent();
+                    reachableFileIds.add(file.id);
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 2:
+                    theirs = (_b.sent());
+                    testEnv.actAs(owner);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 3:
+                    mine = (_b.sent());
+                    expect(theirs.scope).toEqual(owner.id);
+                    expect(mine.id).toEqual(theirs.id);
+                    expect(makerCalls).toHaveLength(1);
+                    _a = expect;
+                    return [4 /*yield*/, fileRowsInScope(recipient.id)];
+                case 4:
+                    _a.apply(void 0, [(_b.sent()).map(function (row) { return row.id; })]).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('a kind the maker does not apply to makes nothing and answers undefined; a caller who cannot read the original gets undefined and nothing is made', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var clip, _a, _b, photo, _c, _d;
+        var _e, _f, _g, _h;
+        return __generator(this, function (_j) {
+            switch (_j.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('clip.mp4', 'video/mp4')];
+                case 1:
+                    clip = _j.sent();
+                    _a = expect;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(clip.id, 'stage')];
+                case 2:
+                    _a.apply(void 0, [_j.sent()]).toBeUndefined();
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(clip.id)];
+                case 3:
+                    _b.apply(void 0, [(_f = (_e = (_j.sent()).stage) === null || _e === void 0 ? void 0 : _e._id) !== null && _f !== void 0 ? _f : null]).toBeNull();
+                    return [4 /*yield*/, createOwnerPicture('private.jpg')];
+                case 4:
+                    photo = _j.sent();
+                    testEnv.actAs(stranger);
+                    _c = expect;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(photo.id, 'stage')];
+                case 5:
+                    _c.apply(void 0, [_j.sent()]).toBeUndefined();
+                    expect(makerCalls).toEqual([]);
+                    _d = expect;
+                    return [4 /*yield*/, rowAsSystem(photo.id)];
+                case 6:
+                    _d.apply(void 0, [(_h = (_g = (_j.sent()).stage) === null || _g === void 0 ? void 0 : _g._id) !== null && _h !== void 0 ? _h : null]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('two PROCESSES deriving at once (the row is the only thing they share): the row names one stage, the other is deleted with its bytes', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, storedBefore, storage, _a, a, b, named, stagesOfFile;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('raced.jpg')];
+                case 1:
+                    file = _b.sent();
+                    storedBefore = driver.store.size;
+                    makerBarrier = 2;
+                    storage = new FileStorage_1.FileStorage();
+                    return [4 /*yield*/, Promise.all([
+                            storage.makeVariant(file, 'stage', originalBytes),
+                            storage.makeVariant(file, 'stage', originalBytes),
+                        ])];
+                case 2:
+                    _a = _b.sent(), a = _a[0], b = _a[1];
+                    expect(a).toEqual(b);
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    named = (_b.sent()).stage._id;
+                    expect(named).toEqual(a);
+                    return [4 /*yield*/, fileRowsInScope(owner.id)];
+                case 4:
+                    stagesOfFile = (_b.sent()).filter(function (row) { var _a; return ((_a = row.variantOf) === null || _a === void 0 ? void 0 : _a._id) === file.id; });
+                    expect(stagesOfFile.map(function (row) { return row.id; })).toEqual([named]);
+                    // One stage's bytes remain of the two made: the loser's row went, and its bytes with it.
+                    expect(driver.store.size).toEqual(storedBefore + 1);
+                    expect(driver.store.has(named)).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('N readers asking one process for the same absent stage while it derives cost ONE derivation: one read of the original, one maker call, one object stored, no loser to delete; every reader is served the same row', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, storedBefore, readsBefore, release, readers, served, named, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('burst.jpg')];
+                case 1:
+                    file = _b.sent();
+                    storedBefore = driver.store.size;
+                    readsBefore = driver.reads.filter(function (id) { return id === file.id; }).length;
+                    makerHold = new Promise(function (resolve) { return (release = resolve); });
+                    readers = Array.from({ length: 4 }, function () { return new FileStorage_1.FileStorage().getVariant(file.id, 'stage'); });
+                    _b.label = 2;
+                case 2:
+                    if (!(makerCalls.length < 1)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5); })];
+                case 3:
+                    _b.sent();
+                    return [3 /*break*/, 2];
+                case 4: return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                case 5:
+                    _b.sent();
+                    release();
+                    return [4 /*yield*/, Promise.all(readers)];
+                case 6:
+                    served = _b.sent();
+                    expect(makerCalls).toHaveLength(1);
+                    expect(driver.reads.filter(function (id) { return id === file.id; }).length).toEqual(readsBefore + 1);
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 7:
+                    named = (_b.sent()).stage._id;
+                    expect(served.map(function (row) { return row.id; })).toEqual([named, named, named, named]);
+                    expect(driver.store.size).toEqual(storedBefore + 1);
+                    expect(driver.deletes).toEqual([]);
+                    // The next reader, after the derivation, is served the row without the maker.
+                    _a = expect;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 8:
+                    // The next reader, after the derivation, is served the row without the maker.
+                    _a.apply(void 0, [(_b.sent()).id]).toEqual(named);
+                    expect(makerCalls).toHaveLength(1);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('a maker that cannot make the stage of these bytes on the read path: nothing is stored, the reader is answered undefined (the file itself is drawn), the next reader asks the maker again', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, _a, _b, _c, served;
+        var _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('unreadable.jpg')];
+                case 1:
+                    file = _f.sent();
+                    makerRefuses = true;
+                    _a = expect;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 2:
+                    _a.apply(void 0, [_f.sent()]).toBeUndefined();
+                    expect(makerCalls).toHaveLength(1);
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 3:
+                    _b.apply(void 0, [(_e = (_d = (_f.sent()).stage) === null || _d === void 0 ? void 0 : _d._id) !== null && _e !== void 0 ? _e : null]).toBeNull();
+                    _c = expect;
+                    return [4 /*yield*/, fileRowsInScope(owner.id)];
+                case 4:
+                    _c.apply(void 0, [(_f.sent()).filter(function (row) { var _a; return ((_a = row.variantOf) === null || _a === void 0 ? void 0 : _a._id) === file.id; })]).toEqual([]);
+                    return [4 /*yield*/, invokeVariantRoute(file.id, 'stage')];
+                case 5:
+                    served = _f.sent();
+                    expect(served.statusCode).toBeUndefined();
+                    expect(served.body.equals(originalBytes)).toBe(true);
+                    expect(served.headers['content-type']).toEqual('image/jpeg');
+                    expect(makerCalls).toHaveLength(2);
+                    // The ingest door is not softened: the maker's failure reaches the caller that holds the bytes.
+                    return [4 /*yield*/, expect(new FileStorage_1.FileStorage().deriveVariants(file, originalBytes)).rejects.toThrow('cannot decode')];
+                case 6:
+                    // The ingest door is not softened: the maker's failure reaches the caller that holds the bytes.
+                    _f.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('access — a variant is readable by whoever can read its original, and served like any File', function () {
+    it('a stage derived after the content was placed is reachable by its own id through its original: the recipient reads it, a stranger cannot', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, stage, _a, _b, _c, _d, _e, _f, _g, _h;
+        var _j;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('placed.jpg')];
+                case 1:
+                    file = _k.sent();
+                    reachableFileIds.add(file.id); // the content row names the ORIGINAL only — nothing names the stage
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 2:
+                    stage = (_k.sent());
+                    _a = expect;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFile(stage.id)];
+                case 3:
+                    _a.apply(void 0, [(_j = (_k.sent())) === null || _j === void 0 ? void 0 : _j.id]).toEqual(stage.id);
+                    _b = expect;
+                    return [4 /*yield*/, invokeRoute(stage.id)];
+                case 4:
+                    _b.apply(void 0, [(_k.sent()).statusCode]).toBeUndefined(); // a plain 200 send: no status set
+                    _c = expect;
+                    _e = (_d = Buffer).isBuffer;
+                    return [4 /*yield*/, invokeRoute(stage.id)];
+                case 5:
+                    _c.apply(void 0, [_e.apply(_d, [(_k.sent()).body])]).toBe(true);
+                    testEnv.actAs(stranger);
+                    _f = expect;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFile(stage.id)];
+                case 6:
+                    _f.apply(void 0, [_k.sent()]).toBeUndefined();
+                    _g = expect;
+                    return [4 /*yield*/, invokeRoute(stage.id)];
+                case 7:
+                    _g.apply(void 0, [(_k.sent()).statusCode]).toEqual(404);
+                    // Revoked: the moment the original is out of reach, so is its variant.
+                    reachableFileIds.delete(file.id);
+                    testEnv.actAs(recipient);
+                    _h = expect;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFile(stage.id)];
+                case 8:
+                    _h.apply(void 0, [_k.sent()]).toBeUndefined();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('the non-owner copy rule applies to the stage automatically: a recipient is served the copy of the STAGE, made once and named on the stage row; the owner the stage itself', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, stage, stageBytes, served, _a, _b, routed, again, _c, _d, ownersOwn, _e, _f, stageRow, copy, _g;
+        var _h, _j, _k;
+        return __generator(this, function (_l) {
+            switch (_l.label) {
+                case 0:
+                    registerCopyMaker();
+                    return [4 /*yield*/, createOwnerPicture('located.jpg', 'image/jpeg', Buffer.concat([originalBytes, COPY_MARK]))];
+                case 1:
+                    file = _l.sent();
+                    reachableFileIds.add(file.id);
+                    // The stub variant maker keeps the mark on what it makes (the real one keeps a picture's tags for its owner).
+                    objectCache()['@proteinjs/db-file/FileVariantMaker'] = [
+                        {
+                            appliesTo: function (candidate, kind) { return candidate.type.startsWith('image/') && kind === 'stage'; },
+                            make: function (candidate, bytes) { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    return [2 /*return*/, ({
+                                            bytes: Buffer.concat([Buffer.from('STAGE:'), bytes.subarray(0, 8), COPY_MARK]),
+                                            type: 'image/webp',
+                                        })];
+                                });
+                            }); },
+                        },
+                    ];
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getVariant(file.id, 'stage')];
+                case 2:
+                    stage = (_l.sent());
+                    stageBytes = driver.store.get(stage.id);
+                    expect(stageBytes.includes(COPY_MARK)).toBe(true);
+                    testEnv.actAs(recipient);
+                    _b = (_a = Buffer).from;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFileData(stage.id)];
+                case 3:
+                    served = _b.apply(_a, [_l.sent(), 'base64']);
+                    return [4 /*yield*/, invokeRoute(stage.id)];
+                case 4:
+                    routed = (_l.sent()).body;
+                    _d = (_c = Buffer).from;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFileData(stage.id)];
+                case 5:
+                    again = _d.apply(_c, [_l.sent(), 'base64']);
+                    testEnv.actAs(owner);
+                    _f = (_e = Buffer).from;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFileData(stage.id)];
+                case 6:
+                    ownersOwn = _f.apply(_e, [_l.sent(), 'base64']);
+                    expect(served.includes(COPY_MARK)).toBe(false);
+                    expect(served.equals(stageBytes.subarray(0, stageBytes.length - COPY_MARK.length))).toBe(true);
+                    expect(routed.equals(served)).toBe(true);
+                    expect(again.equals(served)).toBe(true);
+                    expect(copyMakerCalls).toEqual([stage.id]);
+                    return [4 /*yield*/, rowAsSystem(stage.id)];
+                case 7:
+                    stageRow = (_l.sent());
+                    expect((_h = stageRow.copyForOthers) === null || _h === void 0 ? void 0 : _h._id).toBeTruthy();
+                    return [4 /*yield*/, rowAsSystem(stageRow.copyForOthers._id)];
+                case 8:
+                    copy = (_l.sent());
+                    expect(copy.scope).toEqual(owner.id);
+                    expect((_k = (_j = copy.variantOf) === null || _j === void 0 ? void 0 : _j._id) !== null && _k !== void 0 ? _k : null).toBeNull(); // the copy's own id stays nobody's but the owner's
+                    testEnv.actAs(recipient);
+                    _g = expect;
+                    return [4 /*yield*/, new FileStorage_1.FileStorage().getFile(copy.id)];
+                case 9:
+                    _g.apply(void 0, [_l.sent()]).toBeUndefined();
+                    expect(ownersOwn.equals(stageBytes)).toBe(true);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+describe('the route — GET /file/:id/variant/:kind is the one URL a surface asks a variant by (an existing row derives on the first request)', function () {
+    it('names its path as the file route does', function () {
+        expect(getFileVariantRoute_1.getFileVariantRoute.path('abc', 'stage')).toEqual('/file/abc/variant/stage');
+        expect(getFileVariant_1.getFileVariant.path).toEqual('/file/:id/variant/:kind');
+    });
+    it("the first request derives the stage and serves ITS bytes with ITS headers; the second is served the same row without the maker; the original's own route is untouched", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, first, second, stageId, _i, _a, served, _b, original;
+        var _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('old-row.jpg')];
+                case 1:
+                    file = _d.sent();
+                    return [4 /*yield*/, invokeVariantRoute(file.id, 'stage')];
+                case 2:
+                    first = _d.sent();
+                    return [4 /*yield*/, invokeVariantRoute(file.id, 'stage')];
+                case 3:
+                    second = _d.sent();
+                    expect(makerCalls.map(function (call) { return call.kind; })).toEqual(['stage']);
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 4:
+                    stageId = (_d.sent()).stage._id;
+                    for (_i = 0, _a = [first, second]; _i < _a.length; _i++) {
+                        served = _a[_i];
+                        expect(served.statusCode).toBeUndefined();
+                        expect(served.body.equals(variantOf('stage', originalBytes))).toBe(true);
+                        expect(served.headers['content-type']).toEqual('image/webp');
+                        expect(served.headers['content-disposition']).toEqual("inline; filename=\"".concat(encodeURIComponent("(stage) old-row.jpg"), "\""));
+                    }
+                    _b = expect;
+                    return [4 /*yield*/, rowAsSystem(stageId)];
+                case 5:
+                    _b.apply(void 0, [(_c = (_d.sent()).variantOf) === null || _c === void 0 ? void 0 : _c._id]).toEqual(file.id);
+                    return [4 /*yield*/, invokeRoute(file.id)];
+                case 6:
+                    original = _d.sent();
+                    expect(original.body.equals(originalBytes)).toBe(true);
+                    expect(original.headers['content-type']).toEqual('image/jpeg');
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('a file the maker does not apply to is served as ITSELF through the variant route (the consumer always gets a picture); nothing is made', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var clip, served, _a;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('clip.mp4', 'video/mp4')];
+                case 1:
+                    clip = _d.sent();
+                    return [4 /*yield*/, invokeVariantRoute(clip.id, 'stage')];
+                case 2:
+                    served = _d.sent();
+                    expect(served.statusCode).toBeUndefined();
+                    expect(served.body.equals(originalBytes)).toBe(true);
+                    expect(served.headers['content-type']).toEqual('video/mp4');
+                    expect(makerCalls).toEqual([]);
+                    _a = expect;
+                    return [4 /*yield*/, rowAsSystem(clip.id)];
+                case 3:
+                    _a.apply(void 0, [(_c = (_b = (_d.sent()).stage) === null || _b === void 0 ? void 0 : _b._id) !== null && _c !== void 0 ? _c : null]).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('a kind the library does not know, a file the caller cannot read, and no session each answer without a byte', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var photo, _a, _b, _c, _d;
+        var _e, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0: return [4 /*yield*/, createOwnerPicture('private.jpg')];
+                case 1:
+                    photo = _g.sent();
+                    _a = expect;
+                    return [4 /*yield*/, invokeVariantRoute(photo.id, 'poster')];
+                case 2:
+                    _a.apply(void 0, [(_g.sent()).statusCode]).toEqual(404);
+                    expect(makerCalls).toEqual([]);
+                    testEnv.actAs(stranger);
+                    _b = expect;
+                    return [4 /*yield*/, invokeVariantRoute(photo.id, 'stage')];
+                case 3:
+                    _b.apply(void 0, [(_g.sent()).statusCode]).toEqual(404);
+                    expect(makerCalls).toEqual([]);
+                    _c = expect;
+                    return [4 /*yield*/, rowAsSystem(photo.id)];
+                case 4:
+                    _c.apply(void 0, [(_f = (_e = (_g.sent()).stage) === null || _e === void 0 ? void 0 : _e._id) !== null && _f !== void 0 ? _f : null]).toBeNull();
+                    testEnv.actAs(user_1.guestUser);
+                    _d = expect;
+                    return [4 /*yield*/, invokeVariantRoute(photo.id, 'stage')];
+                case 5:
+                    _d.apply(void 0, [(_g.sent()).statusCode]).toEqual(401);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("a recipient's request through the route derives the stage as the OWNER's File and is served the COPY of it (the non-owner rule, on the route); the owner the stage itself", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var file, theirs, mine, stageRow, _a, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    registerCopyMaker();
+                    return [4 /*yield*/, createOwnerPicture('shared-old.jpg', 'image/jpeg', Buffer.concat([originalBytes, COPY_MARK]))];
+                case 1:
+                    file = _c.sent();
+                    reachableFileIds.add(file.id);
+                    objectCache()['@proteinjs/db-file/FileVariantMaker'] = [
+                        {
+                            appliesTo: function (candidate, kind) { return candidate.type.startsWith('image/') && kind === 'stage'; },
+                            make: function (candidate, bytes) { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    return [2 /*return*/, ({
+                                            bytes: Buffer.concat([Buffer.from('STAGE:'), bytes.subarray(0, 8), COPY_MARK]),
+                                            type: 'image/webp',
+                                        })];
+                                });
+                            }); },
+                        },
+                    ];
+                    testEnv.actAs(recipient);
+                    return [4 /*yield*/, invokeVariantRoute(file.id, 'stage')];
+                case 2:
+                    theirs = _c.sent();
+                    testEnv.actAs(owner);
+                    return [4 /*yield*/, invokeVariantRoute(file.id, 'stage')];
+                case 3:
+                    mine = _c.sent();
+                    _a = rowAsSystem;
+                    return [4 /*yield*/, rowAsSystem(file.id)];
+                case 4: return [4 /*yield*/, _a.apply(void 0, [(_c.sent()).stage._id])];
+                case 5:
+                    stageRow = (_c.sent());
+                    expect(stageRow.scope).toEqual(owner.id);
+                    expect(theirs.body.includes(COPY_MARK)).toBe(false);
+                    expect(mine.body.includes(COPY_MARK)).toBe(true);
+                    expect(mine.body.equals(driver.store.get(stageRow.id))).toBe(true);
+                    expect(copyMakerCalls).toEqual([stageRow.id]);
+                    _b = expect;
+                    return [4 /*yield*/, fileRowsInScope(recipient.id)];
+                case 6:
+                    _b.apply(void 0, [(_c.sent()).map(function (row) { return row.id; })]).toEqual([]);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+});
+//# sourceMappingURL=FileVariants.test.js.map