@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/src/services/TracingService.js

@@ -38,6 +38,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TracingService = void 0;
 const api_1 = require("@opentelemetry/api");
@@ -53,15 +62,32 @@ const resources_1 = require("@opentelemetry/resources");
 const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
 const typedi_1 = require("typedi");
 const logger_1 = __importStar(require("../logger"));
+/** Why a session's span ended, on the span. */
+const SESSION_STOP_REASON = 'xenon.session.stop_reason';
+function failSpan(span, error) {
+    var _a;
+    const exception = error instanceof Error ? error : { message: String((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error) };
+    span.recordException(exception);
+    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: exception.message });
+}
 let TracingService = class TracingService {
     constructor() {
         this.sdk = null;
+        // Built here only while tracing is off; with it on, the NodeSDK owns them.
         this.loggerProvider = null;
         this.meterProvider = null;
+        // Whether Xenon's own log export and metric export are configured.
+        this.logsOn = false;
+        this.metricsOn = false;
         this.tracer = api_1.trace.getTracer('xenon-core');
         this.activeSpans = new Map();
+        // Which of activeSpans are sessions' (keyed by session id) rather than
+        // commands' (`<sessionId>:<command>`).
+        this.sessionSpanIds = new Set();
+        this.spanProcessorsInUse = [];
     }
     initialize(opts = { isHub: true }) {
+        var _a;
         if (process.env.OTEL_SDK_DISABLED === 'true') {
             logger_1.default.info('[TracingService] OTEL_SDK_DISABLED=true — OTel disabled.');
             return;
@@ -71,14 +97,56 @@ let TracingService = class TracingService {
             [semantic_conventions_1.ATTR_SERVICE_NAME]: 'xenon',
             service: role,
         });
-        this.initTraces(resource);
-        this.initLogs(resource);
-        this.initMetrics(resource);
+        const spanProcessors = this.spanProcessors();
+        const logRecordProcessors = this.logRecordProcessors();
+        const metricReaders = this.metricReaders();
+        if (spanProcessors.length > 0) {
+            // A NodeSDK that isn't handed log processors and metric readers builds
+            // its own from the standard OTEL_* variables (OTLP exporters at
+            // OTEL_EXPORTER_OTLP_ENDPOINT + /v1/logs and /v1/metrics, which is
+            // Xenon's trace URL) and registers them globally before Xenon could, so
+            // Xenon's settings for logs and metrics did nothing while tracing was
+            // on. It gets Xenon's, or none. With none for logs it still registers
+            // a logger provider, one that exports nothing.
+            this.spanProcessorsInUse = spanProcessors;
+            this.sdk = new sdk_node_1.NodeSDK({
+                resource,
+                spanProcessors,
+                logRecordProcessors,
+                metricReaders,
+            });
+            try {
+                this.sdk.start();
+                logger_1.default.info('[TracingService] Trace SDK started.');
+            }
+            catch (err) {
+                logger_1.default.error(`[TracingService] Failed to start trace SDK: ${err.message}`);
+            }
+        }
+        else {
+            if (logRecordProcessors.length > 0) {
+                this.loggerProvider = new sdk_logs_1.LoggerProvider({ resource, processors: logRecordProcessors });
+                api_logs_1.logs.setGlobalLoggerProvider(this.loggerProvider);
+            }
+            if (metricReaders.length > 0) {
+                this.meterProvider = new sdk_metrics_1.MeterProvider({ resource, readers: metricReaders });
+                api_1.metrics.setGlobalMeterProvider(this.meterProvider);
+            }
+        }
+        if (logRecordProcessors.length > 0) {
+            this.logsOn = true;
+            logger_1.XenonLogger.setOtlpReady(true);
+            logger_1.default.info(`[TracingService] Log OTLP endpoint: ${process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT}. Log SDK started.`);
+        }
+        if (metricReaders.length > 0) {
+            this.metricsOn = true;
+            logger_1.default.info(`[TracingService] Metric OTLP endpoint: ${(_a = process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT) !== null && _a !== void 0 ? _a : '(console-only)'}. Metrics SDK started.`);
+        }
     }
-    initTraces(resource) {
+    spanProcessors() {
         if (process.env.OTEL_TRACES_ENABLED === 'false') {
             logger_1.default.info('[TracingService] OTEL_TRACES_ENABLED=false — trace export disabled.');
-            return;
+            return [];
         }
         const exporters = [];
         if (process.env.XENON_OTEL_DEBUG === 'true') {
@@ -93,52 +161,37 @@ let TracingService = class TracingService {
         }
         if (exporters.length === 0) {
             logger_1.default.info('[TracingService] No trace exporters configured. Spans recorded in-memory only.');
-            return;
+            return [];
         }
         // Pre-existing pre-PR-86 bug: only exporters[0] was wired, so combining
         // XENON_OTEL_DEBUG=true with an OTLP endpoint silently dropped one of the
         // two destinations. Each exporter now gets its own SimpleSpanProcessor.
-        const spanProcessors = exporters.map((e) => new sdk_trace_base_1.SimpleSpanProcessor(e));
-        this.sdk = new sdk_node_1.NodeSDK({
-            resource,
-            spanProcessors,
-        });
-        try {
-            this.sdk.start();
-            logger_1.default.info('[TracingService] Trace SDK started.');
-        }
-        catch (err) {
-            logger_1.default.error(`[TracingService] Failed to start trace SDK: ${err.message}`);
-        }
+        return exporters.map((e) => new sdk_trace_base_1.SimpleSpanProcessor(e));
     }
-    initLogs(resource) {
+    logRecordProcessors() {
         if (process.env.OTEL_LOGS_ENABLED === 'false') {
             logger_1.default.info('[TracingService] OTEL_LOGS_ENABLED=false — log export disabled.');
-            return;
+            return [];
         }
         const endpoint = process.env.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT;
         if (!endpoint)
-            return;
+            return [];
         const processors = [];
         if (process.env.XENON_OTEL_DEBUG === 'true') {
             processors.push(new sdk_logs_1.SimpleLogRecordProcessor(new sdk_logs_1.ConsoleLogRecordExporter()));
         }
         processors.push(new sdk_logs_1.BatchLogRecordProcessor(new exporter_logs_otlp_http_1.OTLPLogExporter({ url: endpoint })));
-        const provider = new sdk_logs_1.LoggerProvider({ resource, processors });
-        api_logs_1.logs.setGlobalLoggerProvider(provider);
-        this.loggerProvider = provider;
-        logger_1.XenonLogger.setOtlpReady(true);
-        logger_1.default.info(`[TracingService] Log OTLP endpoint: ${endpoint}. Log SDK started.`);
+        return processors;
     }
-    initMetrics(resource) {
+    metricReaders() {
         if (process.env.OTEL_METRICS_ENABLED === 'false') {
             logger_1.default.info('[TracingService] OTEL_METRICS_ENABLED=false — metrics export disabled.');
-            return;
+            return [];
         }
         const endpoint = process.env.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT;
         const debug = process.env.XENON_OTEL_DEBUG === 'true';
         if (!endpoint && !debug)
-            return;
+            return [];
         const readers = [];
         if (debug) {
             // 10s interval keeps console output readable during dev sessions.
@@ -154,18 +207,15 @@ let TracingService = class TracingService {
                 exportIntervalMillis: 60000,
             }));
         }
-        const provider = new sdk_metrics_1.MeterProvider({ resource, readers });
-        api_1.metrics.setGlobalMeterProvider(provider);
-        this.meterProvider = provider;
-        logger_1.default.info(`[TracingService] Metric OTLP endpoint: ${endpoint !== null && endpoint !== void 0 ? endpoint : '(console-only)'}. Metrics SDK started.`);
+        return readers;
     }
     getLogger(name = 'xenon-core') {
-        if (!this.loggerProvider)
+        if (!this.logsOn)
             return undefined;
         return api_logs_1.logs.getLogger(name);
     }
     getMeter(name = 'xenon-core') {
-        if (!this.meterProvider)
+        if (!this.metricsOn)
             return undefined;
         return api_1.metrics.getMeter(name);
     }
@@ -177,8 +227,18 @@ let TracingService = class TracingService {
             attributes: Object.assign({ 'xenon.session_id': sessionId }, attributes),
         });
         this.activeSpans.set(sessionId, span);
+        this.sessionSpanIds.add(sessionId);
         return span;
     }
+    /**
+     * Ends a session's span. Every way a session ends calls this (the client's
+     * delete, Appium's new-command timeout, the idle release, the heartbeat
+     * sweeps, a shutdown's drain), so whichever comes second finds nothing.
+     * `failed` for a session that ended failed; `reason` says why it ended.
+     */
+    endSessionSpan(sessionId, ending = {}) {
+        this.endSpan(sessionId, ending.failed ? 'ERROR' : 'OK', ending.reason ? { [SESSION_STOP_REASON]: ending.reason } : {});
+    }
     startCommandSpan(sessionId, commandName, attributes = {}) {
         if (!this.sdk)
             return undefined;
@@ -202,28 +262,34 @@ let TracingService = class TracingService {
         if (!this.sdk)
             return;
         const span = this.activeSpans.get(id);
-        if (span) {
-            if (Object.keys(attributes).length > 0) {
-                span.setAttributes(attributes);
-            }
-            span.setStatus({
-                code: status === 'OK' ? api_1.SpanStatusCode.OK : api_1.SpanStatusCode.ERROR,
-            });
-            span.end();
-            this.activeSpans.delete(id);
-        }
-    }
-    recordError(id, error) {
-        if (!this.sdk)
+        if (!span)
             return;
-        const span = this.activeSpans.get(id);
-        if (span) {
-            span.recordException(error);
-            span.setStatus({
-                code: api_1.SpanStatusCode.ERROR,
-                message: typeof error === 'string' ? error : error.message,
-            });
+        this.activeSpans.delete(id);
+        this.sessionSpanIds.delete(id);
+        if (Object.keys(attributes).length > 0) {
+            span.setAttributes(attributes);
         }
+        span.setStatus({
+            code: status === 'OK' ? api_1.SpanStatusCode.OK : api_1.SpanStatusCode.ERROR,
+        });
+        span.end();
+    }
+    /**
+     * Ends the span a command started: ERROR with the exception when it
+     * `failed`, else OK. By the span itself, not by its id: two commands of the
+     * same name on one session at once (the Inspector reading the page source
+     * while a test does) share `<sessionId>:<command>`, and the second's span
+     * replaced the first's under it, so one command's error went on the other's
+     * span and its own never ended.
+     */
+    endCommandSpan(id, span, failed) {
+        if (failed)
+            failSpan(span, failed.error);
+        else
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+        span.end();
+        if (this.activeSpans.get(id) === span)
+            this.activeSpans.delete(id);
     }
     getTraceId(sessionId) {
         var _a;
@@ -233,12 +299,57 @@ let TracingService = class TracingService {
         var _a;
         return (_a = this.activeSpans.get(id)) === null || _a === void 0 ? void 0 : _a.spanContext().spanId;
     }
+    /**
+     * shutdown(), waiting no longer than `budgetMs`: an export to a collector
+     * that doesn't answer is held for the exporter's own timeout (10 s), and a
+     * process that is exiting can't wait that long.
+     */
+    shutdownWithin(budgetMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let timer;
+            try {
+                yield Promise.race([
+                    this.shutdown(),
+                    new Promise((resolve) => {
+                        timer = setTimeout(resolve, budgetMs);
+                    }),
+                ]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
+    /**
+     * Stops every exporter, once what each still holds is sent. A session span
+     * still open belongs to a session this process didn't end: one running on a
+     * node or at a cloud provider, which a hub's shutdown leaves running, or one
+     * whose ending was missed. It ends here, saying so, or it is never exported.
+     */
     shutdown() {
-        var _a, _b, _c;
-        (_a = this.sdk) === null || _a === void 0 ? void 0 : _a.shutdown();
-        logger_1.XenonLogger.setOtlpReady(false);
-        (_b = this.loggerProvider) === null || _b === void 0 ? void 0 : _b.shutdown();
-        (_c = this.meterProvider) === null || _c === void 0 ? void 0 : _c.shutdown();
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const sessionId of [...this.sessionSpanIds]) {
+                const span = this.activeSpans.get(sessionId);
+                this.activeSpans.delete(sessionId);
+                span === null || span === void 0 ? void 0 : span.setAttribute(SESSION_STOP_REASON, 'Xenon shut down while the session was running');
+                span === null || span === void 0 ? void 0 : span.end();
+            }
+            this.sessionSpanIds.clear();
+            // A span processor's shutdown doesn't wait for the exports it started,
+            // and with the NodeSDK's resource detection every export waits on it.
+            yield Promise.allSettled(this.spanProcessorsInUse.map((p) => p.forceFlush()));
+            this.spanProcessorsInUse = [];
+            logger_1.XenonLogger.setOtlpReady(false);
+            const stopping = [this.sdk, this.loggerProvider, this.meterProvider].map((owner) => owner === null || owner === void 0 ? void 0 : owner.shutdown());
+            this.sdk = null;
+            this.loggerProvider = null;
+            this.meterProvider = null;
+            this.logsOn = false;
+            this.metricsOn = false;
+            this.activeSpans.clear();
+            yield Promise.allSettled(stopping);
+        });
     }
 };
 exports.TracingService = TracingService;

package/lib/src/services/UserService.js

@@ -24,6 +24,7 @@ const bcrypt_1 = __importDefault(require("bcrypt"));
 const crypto_1 = __importDefault(require("crypto"));
 const logger_1 = __importDefault(require("../logger"));
 const prisma_1 = require("../prisma");
+const identityChanges_1 = require("./identity/identityChanges");
 const ACCESS_KEY_PREFIX = 'xen_';
 const ACCESS_KEY_LEN = 12;
 const PASSWORD_MIN = 8;
@@ -92,14 +93,18 @@ let UserService = class UserService {
             return prisma_1.prisma.user.findUnique({ where: { id } });
         });
     }
+    // The old access key's (accessKey, token) pairs stop working, a node's
+    // socket's included.
     rotateAccessKey(userId) {
         return __awaiter(this, void 0, void 0, function* () {
             const accessKey = this.generateAccessKey();
-            return prisma_1.prisma.user.update({
+            const updated = yield prisma_1.prisma.user.update({
                 where: { id: userId },
                 data: { accessKey },
                 select: { id: true, accessKey: true },
             });
+            yield (0, identityChanges_1.identityChanged)(userId);
+            return updated;
         });
     }
     changePassword(userId, oldPassword, newPassword) {
@@ -163,18 +168,23 @@ let UserService = class UserService {
                 data.role = patch.role;
             if (patch.status !== undefined)
                 data.status = patch.status;
-            return prisma_1.prisma.user.update({ where: { id: userId }, data });
+            const updated = yield prisma_1.prisma.user.update({ where: { id: userId }, data });
+            yield (0, identityChanges_1.identityChanged)(userId);
+            return updated;
         });
     }
     setRole(userId, role) {
         return __awaiter(this, void 0, void 0, function* () {
-            return prisma_1.prisma.user.update({ where: { id: userId }, data: { role } });
+            const updated = yield prisma_1.prisma.user.update({ where: { id: userId }, data: { role } });
+            yield (0, identityChanges_1.identityChanged)(userId);
+            return updated;
         });
     }
     deactivateUser(userId) {
         return __awaiter(this, void 0, void 0, function* () {
             yield prisma_1.prisma.user.update({ where: { id: userId }, data: { status: 'INACTIVE' } });
             yield prisma_1.prisma.userSession.deleteMany({ where: { userId } });
+            yield (0, identityChanges_1.identityChanged)(userId);
         });
     }
     deleteUser(userId) {
@@ -184,6 +194,7 @@ let UserService = class UserService {
             // relying on cascade semantics for security-critical cleanup.
             yield prisma_1.prisma.userSession.deleteMany({ where: { userId } });
             yield prisma_1.prisma.user.delete({ where: { id: userId } });
+            yield (0, identityChanges_1.identityChanged)(userId);
         });
     }
 };

package/lib/src/services/UserSessionService.js

@@ -22,6 +22,7 @@ exports.UserSessionService = void 0;
 const typedi_1 = require("typedi");
 const prisma_1 = require("../prisma");
 const logger_1 = __importDefault(require("../logger"));
+const identityChanges_1 = require("./identity/identityChanges");
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 let UserSessionService = class UserSessionService {
     constructor() {
@@ -38,13 +39,20 @@ let UserSessionService = class UserSessionService {
             });
         });
     }
-    resolve(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
+    /**
+     * The sign-in, if it exists and hasn't expired. A use of it renews it
+     * (sliding TTL); `renew: false` only looks, for a check that isn't a use: a
+     * socket's re-check must not keep a sign-in alive for as long as a tab is open.
+     */
+    resolve(sessionId_1) {
+        return __awaiter(this, arguments, void 0, function* (sessionId, { renew = true } = {}) {
             const row = yield prisma_1.prisma.userSession.findUnique({ where: { id: sessionId } });
             if (!row)
                 return null;
             if (row.expiresAt.getTime() < Date.now())
                 return null;
+            if (!renew)
+                return row;
             const newExpiresAt = new Date(Date.now() + this.ttlMs());
             // Fire-and-forget sliding-TTL update; failures must not block auth, but
             // log them at debug level so chronic write issues are diagnosable.
@@ -62,13 +70,15 @@ let UserSessionService = class UserSessionService {
     // which is fine. Other errors get logged for diagnosis but don't bubble.
     revoke(sessionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield prisma_1.prisma.userSession.delete({ where: { id: sessionId } }).catch((e) => {
+            const row = yield prisma_1.prisma.userSession.delete({ where: { id: sessionId } }).catch((e) => {
                 var _a;
                 const code = e === null || e === void 0 ? void 0 : e.code;
                 if (code === 'P2025')
-                    return;
+                    return null;
                 this.log.warn(`revoke: unexpected delete error for session ${sessionId}: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
+                return null;
             });
+            yield (0, identityChanges_1.identityChanged)(row === null || row === void 0 ? void 0 : row.userId);
         });
     }
     revokeAllForUserExcept(userId, keepSessionId) {
@@ -78,6 +88,7 @@ let UserSessionService = class UserSessionService {
             });
             if (r.count > 0) {
                 this.log.info(`revoked ${r.count} sessions for user ${userId} (kept ${keepSessionId})`);
+                yield (0, identityChanges_1.identityChanged)(userId);
             }
             return r.count;
         });
@@ -87,6 +98,7 @@ let UserSessionService = class UserSessionService {
             const r = yield prisma_1.prisma.userSession.deleteMany({ where: { userId } });
             if (r.count > 0) {
                 this.log.info(`revoked all ${r.count} sessions for user ${userId}`);
+                yield (0, identityChanges_1.identityChanged)(userId);
             }
             return r.count;
         });

package/lib/src/services/bug-report/video-slice.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sliceVideo = sliceVideo;
 const child_process_1 = require("child_process");
+const ffmpegPath_1 = require("../../helpers/ffmpegPath");
 const logger_1 = __importDefault(require("../../logger"));
 function sliceVideo(inputPath, startSec, endSec, outPath, spawnFn = child_process_1.spawn) {
     return new Promise((resolve) => {
@@ -16,7 +17,9 @@ function sliceVideo(inputPath, startSec, endSec, outPath, spawnFn = child_proces
             '-c', 'copy',
             outPath,
         ];
-        const proc = spawnFn('ffmpeg', args);
+        // Xenon's own ffmpeg, as everywhere else: a bare name isn't found by a
+        // server the Mac app started, and finds a system ffmpeg first otherwise.
+        const proc = spawnFn((0, ffmpegPath_1.resolveFfmpegPath)(), args);
         let stderr = '';
         if (proc.stderr) {
             proc.stderr.on('data', (chunk) => {

package/lib/src/services/device-access/leaseOverride.js

@@ -2,18 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canOverrideLease = canOverrideLease;
 function canOverrideLease(credential) {
-    var _a, _b;
     switch (credential.kind) {
         case 'auth-disabled':
             return true;
-        case 'api-key': {
+        case 'api-key':
+        case 'session-token': {
             if (!credential.user)
                 return false;
             const scopes = new Set(credential.scopes.split(',').map((s) => s.trim()));
-            return scopes.has('admin') || credential.user.role === 'SUPER_ADMIN';
+            const { role } = credential.user;
+            if (credential.kind === 'session-token') {
+                return role === 'SUPER_ADMIN' || (role === 'ADMIN' && scopes.has('admin'));
+            }
+            return scopes.has('admin') || role === 'SUPER_ADMIN';
         }
-        case 'session-token':
-            return ((_a = credential.user) === null || _a === void 0 ? void 0 : _a.role) === 'SUPER_ADMIN' || ((_b = credential.user) === null || _b === void 0 ? void 0 : _b.role) === 'ADMIN';
         default:
             return false;
     }

package/lib/src/services/healing/FuzzyXmlHealingProvider.js

@@ -20,6 +20,9 @@ const xpath_1 = require("xpath");
 const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../../logger"));
 const HealedLocatorGenerator_1 = require("./HealedLocatorGenerator");
+const fingerprintIdentity_1 = require("./fingerprintIdentity");
+/** What an element says in words, for telling it apart once its identifier differs. */
+const TEXTS = ['text', 'label', 'content-desc'];
 class FuzzyXmlHealingProvider {
     constructor(etalonService) {
         this.etalonService = etalonService;
@@ -41,6 +44,12 @@ class FuzzyXmlHealingProvider {
                 if (this.etalonService) {
                     etalon = yield this.etalonService.getSignature(context.selector);
                 }
+                // A fingerprint with only a rect and a type (every learnt one through
+                // 2.14) would heal to whatever element of that type is at that spot.
+                if (etalon && !(0, fingerprintIdentity_1.hasIdentity)(etalon.attributes)) {
+                    this.logger.info('The baseline signature says nothing about which element it is; matching without it.');
+                    etalon = null;
+                }
                 const keywords = this.extractKeywords(context.selector);
                 if (keywords.length === 0 && !etalon)
                     return null;
@@ -135,6 +144,9 @@ class FuzzyXmlHealingProvider {
             if (etalonTag !== nodeTag && etalonTag !== 'xcuielementtypeany' && etalonTag !== 'unknown') {
                 return 0; // Immediate rejection — wrong element type
             }
+            // Position can't heal to an element whose identifier says it's another one.
+            if (this.contradictsIdentifier(node, etalon))
+                return 0;
             // Tag matches perfectly
             totalWeight += 1.0;
             totalScore += 1.0;
@@ -260,6 +272,45 @@ class FuzzyXmlHealingProvider {
         }
         return finalScore;
     }
+    /**
+     * Whether `node` is, by its identifier, another element than the
+     * fingerprint's: the fingerprint has an identifier (an Android resource-id,
+     * compared without its package, or an iOS accessibility identifier), `node`
+     * has another one (sameIdentifier), and no text of it (text, label,
+     * content-desc) reads the same as the fingerprint's (sameText). Its
+     * position then counts for nothing.
+     *
+     * A renamed id that kept its text or description still heals, and so does
+     * a renamed text that kept its id. An element without an identifier, where
+     * the fingerprint has one, is judged by its text alone: an Android element
+     * with no resource-id, or an iOS one, whose name is then its label. Only
+     * where neither has one does position decide, as through 2.14.
+     * What this stops is the button that took the old one's place: "Cancel
+     * order" (cancel) where "Pay now" (pay) was, "Log out" where "Log in" was.
+     */
+    contradictsIdentifier(node, etalon) {
+        const identifier = (0, fingerprintIdentity_1.stableIdentifierOf)(etalon.attributes);
+        if (!identifier)
+            return false;
+        // Another identifier, or none where the fingerprint has one, and the
+        // text decides. iOS gives an element without one its label as name.
+        const theirs = this.getAttrValue(node, identifier.attribute);
+        if ((0, fingerprintIdentity_1.meaningful)(theirs)) {
+            const [mine, other] = identifier.attribute === 'resource-id'
+                ? [(0, fingerprintIdentity_1.resourceIdName)(identifier.value), (0, fingerprintIdentity_1.resourceIdName)(theirs)]
+                : [identifier.value, theirs];
+            if ((0, fingerprintIdentity_1.sameIdentifier)(mine, other))
+                return false;
+        }
+        const texts = TEXTS.map((name) => etalon.attributes[name]).filter(fingerprintIdentity_1.meaningful);
+        if (texts.length === 0)
+            return true;
+        const nodeTexts = [
+            node.textContent,
+            ...TEXTS.map((name) => this.getAttrValue(node, name)),
+        ].filter(fingerprintIdentity_1.meaningful);
+        return !nodeTexts.some((t) => texts.some((w) => (0, fingerprintIdentity_1.sameText)(t, w)));
+    }
     getAttrValue(node, name) {
         if (typeof node.getAttribute === 'function') {
             const val = node.getAttribute(name);

package/lib/src/services/healing/HealEtalonService.js

@@ -37,7 +37,9 @@ let HealEtalonService = class HealEtalonService {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const attributes = {};
-                // Extract identifying attributes
+                // Extract identifying attributes. Not `value`: on a text field it is
+                // what the test typed, an email or a name, which says nothing about
+                // which field it is.
                 const nodeAttrs = node.attributes || [];
                 const anchorNames = [
                     'content-desc',
@@ -48,7 +50,6 @@ let HealEtalonService = class HealEtalonService {
                     'hint',
                     'label',
                     'accessibility-id',
-                    'value',
                     'x',
                     'y',
                     'width',