@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/test/unit/run-migrations.test.js

@@ -13,6 +13,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
 const sinon_1 = __importDefault(require("sinon"));
 const run_migrations_1 = require("../../src/scripts/run-migrations");
 const config_1 = require("../../src/config");
@@ -20,6 +23,7 @@ const logger_1 = __importDefault(require("../../src/logger"));
 describe('runMigrations', () => {
     afterEach(() => sinon_1.default.restore());
     it('skips with an info log when XENON_AUTO_MIGRATE=false (autoMigrate=false)', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
         const orig = config_1.config.autoMigrate;
         config_1.config.autoMigrate = false;
         const info = sinon_1.default.spy(logger_1.default, 'info');
@@ -29,6 +33,10 @@ describe('runMigrations', () => {
             yield (0, run_migrations_1.runMigrations)();
             const calls = info.getCalls().map((c) => c.args.join(' '));
             (0, chai_1.expect)(calls.some((m) => /Auto-migrate disabled/i.test(m))).to.be.true;
+            // It says how to choose the command, as the server would.
+            const line = (_a = calls.find((m) => /Auto-migrate disabled/i.test(m))) !== null && _a !== void 0 ? _a : '';
+            (0, chai_1.expect)(line).to.match(/matches its tables/);
+            (0, chai_1.expect)(line).to.match(/P3018/);
         }
         finally {
             config_1.config.autoMigrate = orig;
@@ -36,3 +44,259 @@ describe('runMigrations', () => {
         }
     }));
 });
+describe('planSchemaSync', () => {
+    const LOCAL = ['20250101_a', '20250102_b', '20250103_c'];
+    const unasked = () => {
+        throw new Error('the tables only need comparing when a migration is left to apply');
+    };
+    it('pushes a database with no migration history, accepting data loss as the default always did', () => {
+        const plan = (0, run_migrations_1.planSchemaSync)(null, LOCAL, unasked);
+        (0, chai_1.expect)(plan.command).to.equal('db push');
+        (0, chai_1.expect)(plan.acceptDataLoss).to.equal(true);
+    });
+    it('deploys to a database whose history has every migration', () => {
+        const history = { applied: [...LOCAL], failed: [] };
+        (0, chai_1.expect)((0, run_migrations_1.planSchemaSync)(history, LOCAL, unasked).command).to.equal('migrate deploy');
+    });
+    it('deploys the missing migrations when the tables are what the history says', () => {
+        const history = { applied: LOCAL.slice(0, 2), failed: [] };
+        const compared = [];
+        const plan = (0, run_migrations_1.planSchemaSync)(history, LOCAL, (applied) => {
+            compared.push(applied);
+            return true;
+        });
+        (0, chai_1.expect)(plan.command).to.equal('migrate deploy');
+        (0, chai_1.expect)(compared).to.deep.equal([LOCAL.slice(0, 2)]);
+    });
+    it('pushes when the tables are ahead of the history, so deploy would redo a change', () => {
+        const history = { applied: LOCAL.slice(0, 1), failed: [] };
+        const plan = (0, run_migrations_1.planSchemaSync)(history, LOCAL, () => false);
+        (0, chai_1.expect)(plan.command).to.equal('db push');
+        (0, chai_1.expect)(plan.acceptDataLoss).to.equal(false);
+        (0, chai_1.expect)(plan.reason).to.match(/differ from what its recorded migrations make/);
+        // The failure message depends on why: see schemaSyncFailure.
+        (0, chai_1.expect)(plan.basis).to.equal('tables-differ');
+    });
+    it('deploys, as the history says, when the tables could not be compared', () => {
+        const history = { applied: LOCAL.slice(0, 1), failed: [] };
+        const plan = (0, run_migrations_1.planSchemaSync)(history, LOCAL, () => null);
+        (0, chai_1.expect)(plan.command).to.equal('migrate deploy');
+        (0, chai_1.expect)(plan.reason).to.match(/could not be compared/);
+    });
+    it('pushes a database whose history records a failed migration', () => {
+        const history = { applied: LOCAL.slice(0, 2), failed: [LOCAL[2]] };
+        const plan = (0, run_migrations_1.planSchemaSync)(history, LOCAL, unasked);
+        (0, chai_1.expect)(plan.command).to.equal('db push');
+        (0, chai_1.expect)(plan.acceptDataLoss).to.equal(false);
+        (0, chai_1.expect)(plan.reason).to.include(LOCAL[2]);
+        (0, chai_1.expect)(plan.basis).to.equal('failed-migration');
+        (0, chai_1.expect)(plan.failed).to.deep.equal([LOCAL[2]]);
+    });
+});
+describe('runMigrations chooses by the database, not by databaseProvider', () => {
+    const scratchUrl = `file:${path_1.default.join(os_1.default.tmpdir(), `xenon-choose-${process.pid}-absent.db`)}`;
+    const everyMigration = fs_1.default
+        .readdirSync(path_1.default.resolve(__dirname, '../../prisma/migrations'))
+        .filter((name) => !name.endsWith('.toml'));
+    let saved;
+    beforeEach(() => {
+        saved = {
+            autoMigrate: config_1.config.autoMigrate,
+            databaseProvider: config_1.config.databaseProvider,
+            databaseUrl: config_1.config.databaseUrl,
+        };
+        config_1.config.autoMigrate = true;
+        config_1.config.databaseUrl = scratchUrl;
+    });
+    afterEach(() => {
+        Object.assign(config_1.config, saved);
+    });
+    /** The prisma subcommand runMigrations ran, given the history the database reports. */
+    function commandFor(provider, history) {
+        return __awaiter(this, void 0, void 0, function* () {
+            config_1.config.databaseProvider = provider;
+            const commands = [];
+            yield (0, run_migrations_1.runMigrations)((_cmd, args) => {
+                commands.push(args.filter((a) => !a.startsWith('-') && !a.includes(path_1.default.sep)).join(' '));
+                return Buffer.from('ok');
+            }, () => __awaiter(this, void 0, void 0, function* () { return history; }));
+            return commands[commands.length - 1];
+        });
+    }
+    for (const provider of ['sqlite', 'postgresql']) {
+        it(`pushes a database with no history when databaseProvider is ${provider}`, () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield commandFor(provider, null)).to.equal('db push');
+        }));
+        it(`deploys to a database with a complete history when databaseProvider is ${provider}`, () => __awaiter(void 0, void 0, void 0, function* () {
+            const history = { applied: everyMigration, failed: [] };
+            (0, chai_1.expect)(yield commandFor(provider, history)).to.equal('migrate deploy');
+        }));
+    }
+});
+// `db push --accept-data-loss` drops whatever the schema doesn't have. On a
+// database with no history that is what the default always did. On one with a
+// history it would drop what the history doesn't explain, such as a table added
+// by hand or a half-finished table a failed migration left, where `migrate
+// deploy` (the old `postgresql` path) kept them.
+describe('runMigrations: what each plan runs', () => {
+    const scratchUrl = `file:${path_1.default.join(os_1.default.tmpdir(), `xenon-flags-${process.pid}-absent.db`)}`;
+    const everyMigration = fs_1.default
+        .readdirSync(path_1.default.resolve(__dirname, '../../prisma/migrations'))
+        .filter((name) => !name.endsWith('.toml'))
+        .sort();
+    let saved;
+    beforeEach(() => {
+        saved = { autoMigrate: config_1.config.autoMigrate, databaseUrl: config_1.config.databaseUrl };
+        config_1.config.autoMigrate = true;
+        config_1.config.databaseUrl = scratchUrl;
+    });
+    afterEach(() => {
+        Object.assign(config_1.config, saved);
+        sinon_1.default.restore();
+    });
+    /** Every prisma call's arguments, with `diff` and the update answered by the given steps. */
+    function run(history_1) {
+        return __awaiter(this, arguments, void 0, function* (history, steps = {}) {
+            const calls = [];
+            try {
+                yield (0, run_migrations_1.runMigrations)((_cmd, args) => {
+                    calls.push(args);
+                    const step = args.includes('diff') ? steps.diff : steps.update;
+                    return step ? step(args) : Buffer.from('ok');
+                }, () => __awaiter(this, void 0, void 0, function* () { return history; }));
+                return { calls };
+            }
+            catch (error) {
+                return { calls, error };
+            }
+        });
+    }
+    const fail = (status, stderr, stdout = '') => () => {
+        throw Object.assign(new Error('Command failed'), {
+            status,
+            stderr: Buffer.from(stderr),
+            stdout: Buffer.from(stdout),
+        });
+    };
+    const update = (calls) => calls[calls.length - 1];
+    it('accepts data loss only for a database with no history, as the default always did', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { calls } = yield run(null);
+        (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push', '--accept-data-loss']);
+    }));
+    it('pushes without accepting data loss when the tables differ from the history', () => __awaiter(void 0, void 0, void 0, function* () {
+        const history = { applied: everyMigration.slice(0, -1), failed: [] };
+        const { calls } = yield run(history, { diff: fail(2, '') });
+        (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
+        (0, chai_1.expect)(update(calls)).to.not.include('--accept-data-loss');
+    }));
+    it('pushes without accepting data loss when the history records a failed migration', () => __awaiter(void 0, void 0, void 0, function* () {
+        const history = { applied: everyMigration.slice(0, -1), failed: everyMigration.slice(-1) };
+        const { calls } = yield run(history);
+        (0, chai_1.expect)(update(calls)).to.include.members(['db', 'push']);
+        (0, chai_1.expect)(update(calls)).to.not.include('--accept-data-loss');
+    }));
+    it('deploys to a database whose history matches its tables', () => __awaiter(void 0, void 0, void 0, function* () {
+        const history = { applied: everyMigration.slice(0, -1), failed: [] };
+        const { calls } = yield run(history);
+        (0, chai_1.expect)(update(calls)).to.include.members(['migrate', 'deploy']);
+    }));
+    // What `db push` without --accept-data-loss prints when it would drop a table
+    // that holds rows: the list on stdout, the refusal on stderr.
+    const refusesDataLoss = fail(1, 'Error: Use the --accept-data-loss flag to ignore the data loss warnings like prisma db push --accept-data-loss', '⚠️  There might be data loss when applying the changes:\n\n' +
+        '  • You are about to drop the `LabNotes` table, which is not empty (1 rows).');
+    const root = path_1.default.resolve(__dirname, '../..');
+    const prisma = path_1.default.join(root, 'node_modules', '.bin', 'prisma');
+    const schema = path_1.default.join(root, 'prisma', 'schema.prisma');
+    const scratchFile = scratchUrl.slice('file:'.length);
+    /** The commands a failure message gives, one to an indented line, in its order. */
+    const commandsIn = (message) => message
+        .split('\n')
+        .filter((line) => /^ {2}(DATABASE_URL=|echo )/.test(line))
+        .map((line) => line.trim());
+    const letGo = `DATABASE_URL=file:${scratchFile} ${prisma} db push --skip-generate --accept-data-loss ` +
+        `--schema ${schema}`;
+    // A history database whose tables differ from its migrations: `migrate
+    // deploy` works on it when something was added by hand, and fails (P3018)
+    // when db push moved the tables past the history. The message can't tell
+    // which, so it never sends migrate deploy to the file before a copy.
+    it('says how to let go of what db push would delete, or keep it by trying migrate deploy on a copy first', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const history = { applied: everyMigration.slice(0, -1), failed: [] };
+        const { error } = yield run(history, { diff: fail(2, ''), update: refusesDataLoss });
+        (0, chai_1.expect)(error, 'the start stops').to.be.an('Error');
+        const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
+        (0, chai_1.expect)(message).to.match(/stopped rather than delete/);
+        (0, chai_1.expect)(message).to.match(/differ from what its recorded migrations make/);
+        // Prisma's own list of what it would drop, which is only on stdout.
+        (0, chai_1.expect)(message).to.include('LabNotes');
+        (0, chai_1.expect)(message).to.not.match(/required column/);
+        (0, chai_1.expect)(message, 'no plain advice to migrate deploy the file').to.not.match(/by hand with prisma migrate deploy/);
+        const commands = commandsIn(message);
+        const backup = commands.findIndex((c) => c.includes(`VACUUM INTO '${scratchFile}.backup-`) &&
+            c.endsWith(`| ${prisma} db execute --url file:${scratchFile} --stdin`));
+        (0, chai_1.expect)(backup, `a backup first:\n${message}`).to.equal(0);
+        (0, chai_1.expect)(commands).to.include(letGo);
+        const onCopy = commands.findIndex((c) => c.startsWith(`DATABASE_URL=file:${scratchFile}.copy ${prisma} migrate deploy --schema ${schema}`));
+        const copied = commands.findIndex((c) => c.includes(`VACUUM INTO '${scratchFile}.copy'`));
+        const onFile = commands.indexOf(`DATABASE_URL=file:${scratchFile} ${prisma} migrate deploy --schema ${schema}`);
+        (0, chai_1.expect)(copied, 'the copy is made').to.be.greaterThan(backup);
+        (0, chai_1.expect)(onCopy, 'migrate deploy runs on the copy').to.be.greaterThan(copied);
+        (0, chai_1.expect)(onFile, 'and on the file only after the copy').to.be.greaterThan(onCopy);
+    }));
+    // With a failed migration recorded, `migrate deploy` stops at once (P3009),
+    // whatever the tables hold, so the message never suggests it.
+    it('names the failed migration and never suggests migrate deploy when the history records one', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const failed = everyMigration[everyMigration.length - 1];
+        const history = { applied: everyMigration.slice(0, -1), failed: [failed] };
+        const { error } = yield run(history, { update: refusesDataLoss });
+        (0, chai_1.expect)(error, 'the start stops').to.be.an('Error');
+        const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
+        (0, chai_1.expect)(message).to.match(/stopped rather than delete/);
+        (0, chai_1.expect)(message).to.include(failed);
+        (0, chai_1.expect)(message).to.match(/records a failed migration/);
+        (0, chai_1.expect)(message).to.not.match(/differ from what its recorded migrations make/);
+        (0, chai_1.expect)(message).to.include('LabNotes');
+        const commands = commandsIn(message);
+        (0, chai_1.expect)(commands[0]).to.include(`VACUUM INTO '${scratchFile}.backup-`);
+        (0, chai_1.expect)(commands).to.include(letGo);
+        (0, chai_1.expect)(commands.filter((c) => c.includes('migrate deploy'))).to.deep.equal([]);
+        (0, chai_1.expect)(message).to.not.match(/by hand with prisma migrate deploy/);
+    }));
+    // A migration can fail on what is already in the tables, which a later
+    // start deals with, or on the rows (a unique index over duplicate values),
+    // which no start gets past until someone changes them.
+    it('says what to check when migrate deploy fails on a migration (P3018), without promising the next start recovers', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const history = { applied: everyMigration.slice(0, -1), failed: [] };
+        const { error } = yield run(history, {
+            diff: fail(1, 'simulated diff failure'),
+            update: fail(1, 'Error: P3018\n\nA migration failed to apply.\n\nMigration name: 20261101000000_uniq\n\n' +
+                'Database error:\nUNIQUE constraint failed: LocatorEtalon.strategy, LocatorEtalon.nodeName'),
+        });
+        (0, chai_1.expect)(error, 'the start stops').to.be.an('Error');
+        const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : '';
+        (0, chai_1.expect)(message).to.include('20261101000000_uniq');
+        (0, chai_1.expect)(message).to.include('UNIQUE constraint failed');
+        (0, chai_1.expect)(message).to.not.match(/next start brings the database up to date/);
+        (0, chai_1.expect)(message).to.not.match(/start again, or first/);
+        // Both things to check: a change already there, and rows the migration can't take.
+        (0, chai_1.expect)(message).to.match(/already there/);
+        (0, chai_1.expect)(message).to.match(/duplicate values/);
+        (0, chai_1.expect)(message).to.match(/change those rows/);
+    }));
+    it("says it couldn't read the history without blaming the file outright", () => __awaiter(void 0, void 0, void 0, function* () {
+        let error;
+        try {
+            yield (0, run_migrations_1.runMigrations)(() => Buffer.from('ok'), () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error('database is locked');
+            }));
+        }
+        catch (e) {
+            error = e;
+        }
+        (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/could not read the migration history/);
+        (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.match(/another server/);
+        (0, chai_1.expect)(error === null || error === void 0 ? void 0 : error.message).to.include('database is locked');
+    }));
+});

package/lib/test/unit/selector-health-actions.spec.js

@@ -25,7 +25,9 @@ describe('POST /healing/selector/state (real queries)', function () {
     before(() => __awaiter(this, void 0, void 0, function* () {
         yield (0, selector_health_fixture_1.seedSelectorHealth)(scratch.db);
         // The service's transactions use the scratch database's own client.
-        typedi_1.Container.set(SelectorStateService_1.SelectorStateService, new SelectorStateService_1.SelectorStateService(scratch.db, { emitToDashboard: () => undefined }));
+        typedi_1.Container.set(SelectorStateService_1.SelectorStateService, new SelectorStateService_1.SelectorStateService(scratch.db, {
+            emitToDashboardForSelector: () => __awaiter(this, void 0, void 0, function* () { return undefined; }),
+        }));
     }));
     after(() => {
         typedi_1.Container.remove(SelectorStateService_1.SelectorStateService);

package/lib/test/unit/selector-state-service.spec.js

@@ -38,7 +38,7 @@ function buildPrismaStub() {
 }
 function buildSocketStub() {
     return {
-        emitToDashboard: sinon_1.default.stub(),
+        emitToDashboardForSelector: sinon_1.default.stub().resolves(),
     };
 }
 const STRATEGY = 'accessibility id';
@@ -105,8 +105,8 @@ describe('SelectorStateService', () => {
                 selector: SELECTOR,
                 apiKeyId: API_KEY_ID,
             });
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            const [event, payload] = socketStub.emitToDashboard.firstCall.args;
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            const [event, payload] = socketStub.emitToDashboardForSelector.firstCall.args;
             (0, chai_1.expect)(event).to.equal(SocketEvents_1.SocketEvents.SELECTOR_FIXED);
             (0, chai_1.expect)(payload).to.include({
                 original_strategy: STRATEGY,
@@ -133,7 +133,7 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(err).to.be.instanceOf(SelectorStateService_1.SelectorStateConflictError);
             (0, chai_1.expect)(err.currentStatus).to.equal('muted');
             (0, chai_1.expect)(prismaStub.selectorState.upsert.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
     });
     describe('mute', () => {
@@ -170,8 +170,8 @@ describe('SelectorStateService', () => {
                 selector: SELECTOR,
                 apiKeyId: API_KEY_ID,
             });
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            const [event, payload] = socketStub.emitToDashboard.firstCall.args;
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            const [event, payload] = socketStub.emitToDashboardForSelector.firstCall.args;
             (0, chai_1.expect)(event).to.equal(SocketEvents_1.SocketEvents.SELECTOR_MUTED);
             (0, chai_1.expect)(payload.status).to.equal('muted');
             (0, chai_1.expect)(payload.muted_at).to.equal('2026-04-25T02:00:00.000Z');
@@ -195,8 +195,8 @@ describe('SelectorStateService', () => {
             });
             (0, chai_1.expect)(prismaStub.selectorState.delete.calledOnce).to.equal(true);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_UNMUTED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_UNMUTED);
         }));
         it('keeps the row and sets status=active when history exists', () => __awaiter(void 0, void 0, void 0, function* () {
             const muted = makeRow({
@@ -217,8 +217,8 @@ describe('SelectorStateService', () => {
             const args = prismaStub.selectorState.update.firstCall.args[0];
             (0, chai_1.expect)(args.data.status).to.equal('active');
             (0, chai_1.expect)(args.data.muted_at).to.equal(null);
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_UNMUTED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_UNMUTED);
         }));
         it('is a no-op when the row exists but is not muted', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'active' }));
@@ -229,7 +229,7 @@ describe('SelectorStateService', () => {
             });
             (0, chai_1.expect)(prismaStub.selectorState.delete.called).to.equal(false);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('is a no-op when no row exists', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(null);
@@ -240,7 +240,7 @@ describe('SelectorStateService', () => {
             });
             (0, chai_1.expect)(prismaStub.selectorState.delete.called).to.equal(false);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
     });
     describe('cancelVerification', () => {
@@ -261,7 +261,7 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(err.currentStatus).to.equal('active');
             (0, chai_1.expect)(prismaStub.selectorState.delete.called).to.equal(false);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('throws SelectorStateConflictError when no row exists', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(null);
@@ -294,8 +294,8 @@ describe('SelectorStateService', () => {
             });
             (0, chai_1.expect)(prismaStub.selectorState.delete.calledOnce).to.equal(true);
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED);
         }));
         it('keeps row and clears fixed state when history exists (resolved_at not null)', () => __awaiter(void 0, void 0, void 0, function* () {
             const pending = makeRow({
@@ -318,7 +318,7 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(args.data.status).to.equal('active');
             (0, chai_1.expect)(args.data.fixed_at).to.equal(null);
             (0, chai_1.expect)(args.data.clean_builds_count).to.equal(0);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED);
         }));
     });
     describe('onHealRecorded', () => {
@@ -344,8 +344,8 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(args.data.resolved_at).to.equal(null);
             (0, chai_1.expect)(args.data.regression_count).to.deep.equal({ increment: 1 });
             (0, chai_1.expect)(args.data.clean_builds_count).to.equal(0);
-            (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.equal(true);
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.equal(true);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
         }));
         it('flips resolved → active, clears resolved_at, and increments regression_count', () => __awaiter(void 0, void 0, void 0, function* () {
             const resolved = makeRow({
@@ -368,7 +368,7 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(args.data.resolved_at).to.equal(null);
             (0, chai_1.expect)(args.data.fixed_at).to.equal(null);
             (0, chai_1.expect)(args.data.regression_count).to.deep.equal({ increment: 1 });
-            (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED);
         }));
         it('is a no-op when the row is muted', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'muted' }));
@@ -378,7 +378,7 @@ describe('SelectorStateService', () => {
                 sessionId: SESSION_ID,
             });
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('is a no-op when no row exists', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(null);
@@ -388,7 +388,7 @@ describe('SelectorStateService', () => {
                 sessionId: SESSION_ID,
             });
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('is a no-op when row is already active', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'active' }));
@@ -398,7 +398,7 @@ describe('SelectorStateService', () => {
                 sessionId: SESSION_ID,
             });
             (0, chai_1.expect)(prismaStub.selectorState.update.called).to.equal(false);
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
     });
     describe('getState', () => {
@@ -443,7 +443,7 @@ describe('SelectorStateService', () => {
                 thrown = e;
             }
             (0, chai_1.expect)(thrown.message).to.equal('disk full');
-            (0, chai_1.expect)(socketStub.emitToDashboard.called).to.equal(false);
+            (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.equal(false);
         }));
         it('records the mute with its reason', () => __awaiter(void 0, void 0, void 0, function* () {
             prismaStub.selectorState.upsert.resolves(makeRow({ status: 'muted', muted_at: new Date() }));
@@ -483,4 +483,53 @@ describe('SelectorStateService', () => {
             (0, chai_1.expect)(prismaStub.selectorEvent.create.called).to.equal(false);
         }));
     });
+    // The socket server sends a selector's event only to the dashboards whose
+    // caller may see the selector, so every event names it.
+    describe('each event names its selector, for the socket server to scope it', () => {
+        const KEY = { strategy: STRATEGY, selector: SELECTOR };
+        const ctx = { strategy: STRATEGY, selector: SELECTOR, apiKeyId: API_KEY_ID };
+        const sent = () => socketStub.emitToDashboardForSelector.getCalls().map((c) => [c.args[0], c.args[2]]);
+        it('markFixed and mute', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(null);
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'pending' }));
+            yield svc.markFixed(ctx);
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'muted' }));
+            yield svc.mute(ctx);
+            (0, chai_1.expect)(sent()).to.deep.equal([
+                [SocketEvents_1.SocketEvents.SELECTOR_FIXED, KEY],
+                [SocketEvents_1.SocketEvents.SELECTOR_MUTED, KEY],
+            ]);
+        }));
+        it('unmute and cancelVerification, whether the row is kept or deleted', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'muted' }));
+            yield svc.unmute(ctx);
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'muted', regression_count: 1 }));
+            prismaStub.selectorState.update.resolves(makeRow({ status: 'active', regression_count: 1 }));
+            yield svc.unmute(ctx);
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'pending' }));
+            yield svc.cancelVerification(ctx);
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'pending', regression_count: 1 }));
+            yield svc.cancelVerification(ctx);
+            (0, chai_1.expect)(sent()).to.deep.equal([
+                [SocketEvents_1.SocketEvents.SELECTOR_UNMUTED, KEY],
+                [SocketEvents_1.SocketEvents.SELECTOR_UNMUTED, KEY],
+                [SocketEvents_1.SocketEvents.SELECTOR_CANCELLED, KEY],
+                [SocketEvents_1.SocketEvents.SELECTOR_CANCELLED, KEY],
+            ]);
+        }));
+        it('onHealRecorded', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(makeRow({ status: 'pending' }));
+            prismaStub.selectorState.update.resolves(makeRow({ status: 'active', regression_count: 1 }));
+            yield svc.onHealRecorded({ strategy: STRATEGY, selector: SELECTOR, sessionId: SESSION_ID });
+            (0, chai_1.expect)(sent()).to.deep.equal([[SocketEvents_1.SocketEvents.SELECTOR_REGRESSED, KEY]]);
+        }));
+        it('a heal recorded with no strategy names strategy ""', () => __awaiter(void 0, void 0, void 0, function* () {
+            prismaStub.selectorState.findUnique.resolves(null);
+            prismaStub.selectorState.upsert.resolves(makeRow({ status: 'muted', original_strategy: '' }));
+            yield svc.mute({ strategy: '', selector: SELECTOR, apiKeyId: API_KEY_ID });
+            (0, chai_1.expect)(sent()).to.deep.equal([
+                [SocketEvents_1.SocketEvents.SELECTOR_MUTED, { strategy: '', selector: SELECTOR }],
+            ]);
+        }));
+    });
 });

package/lib/test/unit/selector-verification-clean-build.spec.js

@@ -59,7 +59,7 @@ describe('SelectorVerificationJob counts only builds where the selector was foun
         yield scratch.db.selectorEvent.deleteMany();
         yield scratch.db.selectorState.deleteMany();
         yield scratch.db.sessionLog.deleteMany();
-        socket = { emitToDashboard: sinon_1.default.stub() };
+        socket = { emitToDashboardForSelector: sinon_1.default.stub().resolves() };
         yield scratch.db.selectorState.create({
             data: {
                 original_strategy: 'xpath',

package/lib/test/unit/selector-verification-job.spec.js

@@ -49,7 +49,7 @@ describe('SelectorVerificationJob.run', () => {
         prismaStub.$transaction = sinon_1.default
             .stub()
             .callsFake((fn) => fn(prismaStub));
-        socketStub = { emitToDashboard: sinon_1.default.stub() };
+        socketStub = { emitToDashboardForSelector: sinon_1.default.stub().resolves() };
         job = new SelectorVerificationJob_1.SelectorVerificationJob(prismaStub, socketStub);
     });
     afterEach(() => sinon_1.default.restore());
@@ -84,8 +84,13 @@ describe('SelectorVerificationJob.run', () => {
         (0, chai_1.expect)(updateArg.data.status).to.equal('resolved');
         (0, chai_1.expect)(updateArg.data.resolved_at).to.be.instanceOf(Date);
         (0, chai_1.expect)(updateArg.data.clean_builds_count).to.equal(3);
-        (0, chai_1.expect)(socketStub.emitToDashboard.calledOnce).to.be.true;
-        (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal('selector_resolved');
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.calledOnce).to.be.true;
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal('selector_resolved');
+        // Named, so only the dashboards that may see the selector get it.
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[2]).to.deep.equal({
+            strategy: 'xpath',
+            selector: '//x',
+        });
     }));
     it('updates clean_builds_count and emits PROGRESS when below 3 and value changed', () => __awaiter(void 0, void 0, void 0, function* () {
         prismaStub.selectorState.findMany.resolves([
@@ -111,7 +116,11 @@ describe('SelectorVerificationJob.run', () => {
         const updateArg = prismaStub.selectorState.update.firstCall.args[0];
         (0, chai_1.expect)(updateArg.data.status).to.be.undefined;
         (0, chai_1.expect)(updateArg.data.clean_builds_count).to.equal(1);
-        (0, chai_1.expect)(socketStub.emitToDashboard.firstCall.args[0]).to.equal('selector_progress');
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[0]).to.equal('selector_progress');
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.firstCall.args[2]).to.deep.equal({
+            strategy: 'xpath',
+            selector: '//x',
+        });
     }));
     it('does not write or emit when clean_builds_count is unchanged and not promoting', () => __awaiter(void 0, void 0, void 0, function* () {
         prismaStub.selectorState.findMany.resolves([
@@ -130,7 +139,7 @@ describe('SelectorVerificationJob.run', () => {
         ]);
         yield job.run();
         (0, chai_1.expect)(prismaStub.selectorState.update.called).to.be.false;
-        (0, chai_1.expect)(socketStub.emitToDashboard.called).to.be.false;
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.be.false;
     }));
     it('SQL filters out builds with NULL build_id and only counts findElement(s) commands', () => __awaiter(void 0, void 0, void 0, function* () {
         prismaStub.selectorState.findMany.resolves([
@@ -160,7 +169,7 @@ describe('SelectorVerificationJob.run', () => {
         yield job.run();
         (0, chai_1.expect)(prismaStub.$queryRaw.called).to.be.false;
         (0, chai_1.expect)(prismaStub.selectorState.update.called).to.be.false;
-        (0, chai_1.expect)(socketStub.emitToDashboard.called).to.be.false;
+        (0, chai_1.expect)(socketStub.emitToDashboardForSelector.called).to.be.false;
     }));
     it('continues processing remaining rows if one fails', () => __awaiter(void 0, void 0, void 0, function* () {
         prismaStub.selectorState.findMany.resolves([

package/lib/test/unit/selector-verification-missed-regression.spec.js

@@ -53,7 +53,7 @@ describe('SelectorVerificationJob catches a heal the live check missed', functio
         yield scratch.db.selectorEvent.deleteMany();
         yield scratch.db.selectorState.deleteMany();
         yield scratch.db.sessionLog.deleteMany();
-        socket = { emitToDashboard: sinon_1.default.stub() };
+        socket = { emitToDashboardForSelector: sinon_1.default.stub().resolves() };
     }));
     const find = (build, selector, healed, at) => scratch.db.sessionLog.create({
         data: {
@@ -105,7 +105,7 @@ describe('SelectorVerificationJob catches a heal the live check missed', functio
         (0, chai_1.expect)(row).to.include({ status: 'active', regression_count: 1, clean_builds_count: 0 });
         (0, chai_1.expect)(row.fixed_at).to.equal(null);
         (0, chai_1.expect)(yield actionsOf('//pending/broke')).to.deep.equal(['broke_again']);
-        (0, chai_1.expect)(socket.emitToDashboard.firstCall.args[0]).to.equal('selector_regressed');
+        (0, chai_1.expect)(socket.emitToDashboardForSelector.firstCall.args[0]).to.equal('selector_regressed');
     }));
     it('sends a fixed selector back to fix', () => __awaiter(this, void 0, void 0, function* () {
         yield state('//resolved/broke', 'resolved');