abb-rws-client 0.5.0 → 0.7.2

package/dist/RobotManager.js

@@ -0,0 +1,1523 @@
+import { RwsClient } from './RwsClient.js';
+import * as https from 'https';
+import * as http from 'http';
+import * as net from 'net';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { RWS1Adapter } from './RWS1Adapter.js';
+import { RWS2Adapter } from './RWS2Adapter.js';
+import { Logger } from './Logger.js';
+const SESSION_FILE = path.join(os.homedir(), '.abb-rws-session');
+export class RobotManager {
+    adapter = null;
+    adapterConfig = null;
+    errorListener = null;
+    _state = {
+        connected: false, host: '', ctrlstate: null, opmode: null,
+        execstate: null, execCycle: null, speedRatio: null, coldetstate: null,
+        tasks: [], modules: [], mechunits: [], joints: null,
+        cartesian: null, cartesianFull: null, identity: null, systemInfo: null,
+        eventLog: [], ioSignals: [],
+    };
+    handlers = [];
+    timer = null;
+    /** Unsubscribe function returned by adapter.subscribe(); null when not using WebSockets. */
+    unsubscribeFn = null;
+    /** True when WebSocket subscriptions are active (drives reduced polling interval). */
+    subscriptionActive = false;
+    /** In-flight connect promise — used to dedupe rapid-clicks so we never run two connects in parallel. */
+    connectingPromise = null;
+    /** Monotonic counter so old polling timers can detect they've been superseded and self-cancel. */
+    pollGeneration = 0;
+    get state() { return this._state; }
+    /** The port currently in use (or last attempted). Useful for persisting auto-recovered port changes. */
+    get currentPort() { return this.adapterConfig?.port; }
+    /** The HTTPS flag matching `currentPort`. */
+    get currentUseHttps() {
+        if (!this.adapter || !this.adapterConfig) {
+            return undefined;
+        }
+        // RWS2Adapter is HTTPS, RWS1Adapter is HTTP
+        return this.adapter.constructor.name === 'RWS2Adapter';
+    }
+    onDidChange(fn) { this.handlers.push(fn); }
+    notify() { this.handlers.forEach(h => h()); }
+    /**
+     * Install an error listener. Called when the manager auto-disconnects after 3 failed
+     * polls. Hosts can route to UI dialogs (vscode.window.showErrorMessage), prompts, or
+     * alerting systems. The listener returns the chosen action; only 'Reconnect' is acted
+     * on internally — others are passed through for the host to handle.
+     */
+    onError(fn) { this.errorListener = fn; }
+    // ─── Auto-detection ─────────────────────────────────────────────────────────
+    static probePort(host, port, useHttps, timeoutMs = 3000) {
+        return new Promise(resolve => {
+            const agent = useHttps ? new https.Agent({ rejectUnauthorized: false }) : undefined;
+            const options = {
+                method: 'GET', hostname: host, port,
+                path: '/rw/system',
+                headers: { Accept: 'application/xhtml+xml;v=2.0' },
+                ...(useHttps ? { agent } : {}),
+            };
+            const tid = setTimeout(() => { req.destroy(); resolve(null); }, timeoutMs);
+            const req = (useHttps ? https : http).request(options, res => {
+                clearTimeout(tid);
+                const wwwAuth = (res.headers['www-authenticate'] ?? '');
+                res.resume();
+                if (res.statusCode === 401) {
+                    if (wwwAuth.startsWith('Digest')) {
+                        resolve({ port, useHttps, authType: 'digest' });
+                    }
+                    else if (wwwAuth.startsWith('Basic')) {
+                        resolve({ port, useHttps, authType: 'basic' });
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }
+                else {
+                    resolve(null);
+                }
+            });
+            req.on('error', () => { clearTimeout(tid); resolve(null); });
+            req.end();
+        });
+    }
+    /** Common ports to check on any host. */
+    static PROBE_PORTS = [
+        { port: 80, useHttps: false },
+        { port: 443, useHttps: true },
+        { port: 28447, useHttps: false },
+        { port: 9403, useHttps: true },
+    ];
+    /** Returns ALL responding controllers on a single host. */
+    static async detectAllControllers(host) {
+        const results = await Promise.all(RobotManager.PROBE_PORTS.map(c => RobotManager.probePort(host, c.port, c.useHttps)));
+        return results.filter((r) => r !== null);
+    }
+    /**
+     * Scan a set of standard ABB hosts for any responding RWS controller.
+     * Uses a shorter timeout (1.5 s) for snappy discovery UX.
+     * Returns every found controller with its host attached.
+     *
+     * If nothing is found on 127.0.0.1 via standard ports, falls back to a wide
+     * TCP scan of the local-VC port range — this catches RobotStudio VCs whose
+     * ports are randomly assigned each startup.
+     */
+    static async discoverControllers(extraHosts = []) {
+        const hosts = [
+            '127.0.0.1', // Local virtual controllers (RobotStudio)
+            '192.168.125.1', // ABB standard service port — both IRC5 and OmniCore real robots
+            ...extraHosts,
+        ];
+        const probes = hosts.flatMap(host => RobotManager.PROBE_PORTS.map(c => RobotManager.probePort(host, c.port, c.useHttps, 1500)
+            .then((r) => r ? { host, port: r.port, useHttps: r.useHttps, authType: r.authType } : null)));
+        const results = await Promise.all(probes);
+        const found = results.filter((r) => r !== null);
+        // Fallback: nothing on standard ports of 127.0.0.1 — try wide scan
+        // (RobotStudio assigns random high ports to VCs each restart).
+        const localHits = found.filter(c => c.host === '127.0.0.1' || c.host === 'localhost');
+        if (localHits.length === 0) {
+            Logger.info(`no controllers on standard ports of 127.0.0.1 — running wide scan…`);
+            const wide = await RobotManager.wideHostScan('127.0.0.1');
+            Logger.info(`wide scan found ${wide.length} ABB controller(s) on 127.0.0.1`);
+            found.push(...wide);
+        }
+        return found;
+    }
+    /** Returns only the first responding controller (used internally during connect). */
+    static async detectController(host) {
+        const all = await RobotManager.detectAllControllers(host);
+        return all[0] ?? null;
+    }
+    /**
+     * Probe an exact host:port to discover its auth type and protocol.
+     * Tries HTTPS first (most OmniCore VCs use it), then HTTP.
+     * Returns null only if neither responds — protects against guessing wrong
+     * (e.g. RobotStudio-assigned port 5466 is HTTPS but doesn't fit any heuristic).
+     */
+    static async probeSpecificPort(host, port) {
+        return ((await RobotManager.probePort(host, port, true, 2000)) ??
+            (await RobotManager.probePort(host, port, false, 2000)));
+    }
+    /** Fast TCP-only check to see if a port is accepting connections. */
+    static tcpPing(host, port, timeoutMs = 100) {
+        return new Promise(resolve => {
+            const socket = new net.Socket();
+            const done = (open) => { socket.destroy(); resolve(open); };
+            socket.setTimeout(timeoutMs);
+            socket.once('connect', () => done(true));
+            socket.once('timeout', () => done(false));
+            socket.once('error', () => done(false));
+            socket.connect(port, host);
+        });
+    }
+    /**
+     * Wide-range port scan for RobotStudio VCs whose ports get reassigned each restart.
+     * Two-phase: TCP probe everything fast, then HTTP-probe only ports that responded.
+     *
+     * Uses a sliding-window worker pool to keep concurrency below the OS socket limit
+     * (Windows in particular drops connections silently above ~500 concurrent sockets).
+     *
+     * Heavy operation — only call when standard-port detection finds nothing.
+     * Prefer host=127.0.0.1; scanning a remote host this aggressively is rude.
+     */
+    static async wideHostScan(host) {
+        // RobotStudio assigns RWS ports across a wide range. Observed values include
+        // 5466, 9403, 11811, 15120, 16146, 28447 — covering 4000–30000 catches them all.
+        const startPort = 1024;
+        const endPort = 30000;
+        const concurrency = 300; // safe on Windows; ~500 is the practical ceiling
+        const tcpTimeoutMs = 250; // generous to avoid false negatives
+        const tcpOpen = [];
+        let next = startPort;
+        // Worker pool: each worker pulls the next port until we run out
+        const worker = async () => {
+            while (next <= endPort) {
+                const port = next++;
+                if (await RobotManager.tcpPing(host, port, tcpTimeoutMs)) {
+                    tcpOpen.push(port);
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: concurrency }, worker));
+        Logger.info(`wide scan: ${tcpOpen.length} open TCP port(s) on ${host}, HTTP-probing each…`);
+        // HTTP-probe TCP-open ports — filter to actual ABB controllers
+        const probes = await Promise.all(tcpOpen.map(port => RobotManager.probeSpecificPort(host, port)
+            .then((r) => r ? { host, port: r.port, useHttps: r.useHttps, authType: r.authType } : null)));
+        return probes.filter((r) => r !== null);
+    }
+    // ─── Connection ─────────────────────────────────────────────────────────────
+    /**
+     * Connect to a controller.
+     * @param port     If provided, skip auto-detection and use this port directly.
+     *                 Required when two controllers share the same host IP.
+     * @param useHttps If provided alongside port, sets the protocol explicitly.
+     *
+     * Rapid duplicate calls are coalesced — concurrent callers receive the same
+     * in-flight promise. Without this, fast double-clicks would spawn parallel
+     * adapters/timers and overwhelm the controller's session pool.
+     */
+    connect(host, username, password, port, useHttps) {
+        if (this.connectingPromise) {
+            Logger.info(`connect → ${host}${port !== undefined ? ':' + port : ''} ignored (connect already in flight)`);
+            return this.connectingPromise;
+        }
+        this.connectingPromise = this.doConnect(host, username, password, port, useHttps)
+            .finally(() => { this.connectingPromise = null; });
+        return this.connectingPromise;
+    }
+    async doConnect(host, username, password, port, useHttps) {
+        // If we're already connected to the same controller, this is a no-op.
+        // Without this, every accidental click of the Connect button burns a session
+        // through the disconnect → /logout → /rw/system reconnect cycle.
+        const cfg = this.adapterConfig;
+        if (this._state.connected && cfg
+            && cfg.host === host
+            && (port === undefined || cfg.port === port)
+            && cfg.username === username) {
+            Logger.info(`connect → ${host}${port !== undefined ? ':' + port : ''} skipped (already connected)`);
+            return;
+        }
+        if (this._state.connected) {
+            await this.disconnect();
+        }
+        Logger.info(`connect → ${host}${port !== undefined ? ':' + port : ' (auto-detect)'} as "${username}"`);
+        let probe;
+        if (port !== undefined) {
+            // Port is pinned in config — verify it's actually reachable with the right protocol.
+            const verified = await RobotManager.probeSpecificPort(host, port);
+            if (verified) {
+                probe = verified;
+                Logger.info(`port ${port} verified: ${verified.useHttps ? 'HTTPS' : 'HTTP'}/${verified.authType}`);
+            }
+            else {
+                // Saved port didn't respond — RobotStudio reassigns VC ports each restart.
+                Logger.warn(`saved port ${port} not responding — scanning ${host} for an active controller…`);
+                const expectedAuth = (useHttps ?? (port === 443 || port === 9403)) ? 'basic' : 'digest';
+                // Phase 1: quick scan of the standard ports
+                let candidates = await RobotManager.detectAllControllers(host);
+                // Phase 2: if nothing on standard ports and we're scanning localhost, do a wide scan
+                if (candidates.length === 0 && (host === '127.0.0.1' || host === 'localhost')) {
+                    Logger.info(`standard ports empty — running wide scan 1024–30000 (this takes ~3 s)…`);
+                    const wide = await RobotManager.wideHostScan(host);
+                    candidates = wide.map(c => ({ port: c.port, useHttps: c.useHttps, authType: c.authType }));
+                    Logger.info(`wide scan found ${candidates.length} ABB controller(s) on ${host}`);
+                }
+                const match = candidates.find(c => c.authType === expectedAuth) ?? candidates[0];
+                if (match) {
+                    probe = match;
+                    Logger.info(`recovered: ${match.useHttps ? 'HTTPS' : 'HTTP'}/${match.authType} on port ${match.port} (saved was ${port})`);
+                }
+                else {
+                    // Last resort: try the saved port anyway — maybe a firewall blocks the probe but lets through auth
+                    const https_ = useHttps ?? (port === 443 || port === 9403);
+                    probe = { port, useHttps: https_, authType: https_ ? 'basic' : 'digest' };
+                    Logger.warn(`no controller found anywhere on ${host} — falling back to saved port ${port}`);
+                }
+            }
+        }
+        else {
+            // Auto-detect: probe all common ports
+            Logger.info(`auto-detecting controller at ${host} (ports 80, 443, 28447, 9403)`);
+            const found = await RobotManager.detectController(host);
+            if (!found) {
+                const err = `No ABB RWS controller found at ${host}.\nChecked ports: 80, 443, 28447, 9403.\nEnsure the controller is reachable and RWS is enabled.`;
+                Logger.error(`auto-detect failed for ${host}`);
+                throw new Error(err);
+            }
+            probe = found;
+            Logger.info(`auto-detected: port ${probe.port} ${probe.useHttps ? 'HTTPS' : 'HTTP'}/${probe.authType}`);
+        }
+        const cookieKey = `${host}:${probe.port}`;
+        const prevCfg = this.adapterConfig;
+        const sameConfig = prevCfg
+            && prevCfg.host === host && prevCfg.username === username
+            && prevCfg.password === password && prevCfg.port === probe.port;
+        if (!this.adapter || !sameConfig) {
+            if (probe.authType === 'basic') {
+                const scheme = probe.useHttps ? 'https' : 'http';
+                this.adapter = new RWS2Adapter(`${scheme}://${host}:${probe.port}`, username, password);
+            }
+            else {
+                // Session cookie keyed by host:port so two controllers on same IP don't clobber each other
+                const cookie = this.loadSessionCookie(cookieKey) ?? undefined;
+                const rwsClient = new RwsClient({ host, port: probe.port, username, password, sessionCookie: cookie });
+                this.adapter = new RWS1Adapter(rwsClient, { host, port: probe.port, username, password });
+            }
+            this.adapterConfig = { host, username, password, port: probe.port };
+        }
+        try {
+            await this.adapter.connect();
+        }
+        catch (e) {
+            Logger.error(`adapter.connect() failed for ${host}:${probe.port}`, e);
+            throw e;
+        }
+        const cookie = this.adapter.getSessionCookie();
+        if (cookie) {
+            this.saveSessionCookie(cookieKey, cookie);
+        }
+        this._state.connected = true;
+        this._state.host = host;
+        Logger.info(`connected to ${host}:${probe.port}`);
+        this.notify();
+        // Start WebSocket subscriptions for instant state-change events.
+        // If subscriptions succeed, polling runs at 5 s (positions only).
+        // If they fail, polling runs at 1 s (full state coverage as before).
+        await this.startSubscriptions();
+        // Every connect() invalidates older polling cycles so any timer that
+        // wasn't cleared (race between disconnect/reconnect) self-cancels.
+        const myGeneration = ++this.pollGeneration;
+        this.consecutiveFails = 0;
+        await this.fetchAll(myGeneration);
+        const pollMs = this.subscriptionActive ? 5000 : 1000;
+        // Single-flight guard: if a fetchAll is still running when the timer
+        // fires, skip this tick. Prevents the request pile-up that caused
+        // 10-second timeouts on /cartesian and /tasks during heavy motion
+        // (controller's RWS layer queues behind the motion planner — responses
+        // can take >1s when joints are moving fast). Without this, a slow poll
+        // would stack against the next-second poll, causing both to timeout.
+        this.timer = setInterval(() => {
+            if (this.fetchInFlight) {
+                return;
+            }
+            this.fetchAll(myGeneration);
+        }, pollMs);
+    }
+    async disconnect() {
+        // Bump generation FIRST so any in-flight fetchAll calls bail before they
+        // can trigger another disconnect cascade.
+        this.pollGeneration++;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        // Release any held motion mastership BEFORE closing the adapter
+        await this.releaseJogMastership();
+        // Unsubscribe WebSocket before closing adapter so DELETE /subscription fires correctly
+        if (this.unsubscribeFn) {
+            await this.unsubscribeFn().catch(() => { });
+            this.unsubscribeFn = null;
+        }
+        this.subscriptionActive = false;
+        if (this.adapter) {
+            await this.adapter.disconnect().catch(() => { });
+        }
+        this._state = {
+            connected: false, host: '', ctrlstate: null, opmode: null,
+            execstate: null, execCycle: null, speedRatio: null, coldetstate: null,
+            tasks: [], modules: [], mechunits: [], joints: null,
+            cartesian: null, cartesianFull: null, identity: null, systemInfo: null,
+            eventLog: [], ioSignals: [],
+        };
+        this.notify();
+    }
+    async refresh() { await this.fetchAll(); }
+    // ─── Panel control ──────────────────────────────────────────────────────────
+    async setMotorsOn() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.requestMastership('rapid');
+        try {
+            await this.adapter.setControllerState('motoron');
+        }
+        finally {
+            await this.adapter.releaseMastership('rapid').catch(() => { });
+        }
+    }
+    async setMotorsOff() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.requestMastership('rapid');
+        try {
+            await this.adapter.setControllerState('motoroff');
+        }
+        finally {
+            await this.adapter.releaseMastership('rapid').catch(() => { });
+        }
+    }
+    async setSpeedRatio(ratio) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.setSpeedRatio(ratio);
+        this._state.speedRatio = ratio;
+        this.notify();
+    }
+    async lockOperationMode(pin, permanent) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.lockOperationMode(pin, permanent);
+    }
+    async unlockOperationMode() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.unlockOperationMode();
+    }
+    /**
+     * Switch operation mode (AUTO/MANR/MANF). VC-only — real hardware respects
+     * the FlexPendant key switch.
+     *
+     * State-machine constraints (ABB safety design):
+     *   AUTO ↔ MANR: direct transition allowed.
+     *   MANR ↔ MANF: direct transition allowed.
+     *   AUTO ↔ MANF: NOT allowed direct — must go through MANR.
+     *     Controller rejects with HTTP 500 "Operation failed" on the direct call.
+     *     We auto-handle this by routing through MANR (two POSTs).
+     *
+     * Privilege:
+     *   Going TO MANR/MANF: usually works without mastership (safer direction).
+     *   Going TO AUTO: requires `edit` mastership + a confirmation popup on the
+     *     FlexPendant. We wrap with mastership; the popup must be approved
+     *     manually (no API path bypasses it — verified live).
+     */
+    async setOperationMode(mode) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        if (!this.adapter.setOperationMode) {
+            throw new Error('setOperationMode not exposed by this adapter');
+        }
+        // Detect "must transit through MANR" pairs (AUTO ↔ MANF) and route via MANR.
+        const current = this._state.opmode;
+        const needsTransit = (current === 'AUTO' && mode === 'MANF') ||
+            (current === 'MANF' && mode === 'AUTO');
+        if (needsTransit) {
+            Logger.info(`opmode: routing ${current} → MANR → ${mode} (direct transition not allowed)`);
+            await this.setOpmodeOnce('MANR');
+            // Brief pause so the controller settles the safety-chain state before the
+            // second hop — direct back-to-back POSTs sometimes get the second one
+            // rejected as "operation in progress."
+            await new Promise(r => setTimeout(r, 600));
+            await this.setOpmodeOnce(mode);
+            return;
+        }
+        await this.setOpmodeOnce(mode);
+    }
+    /** Single hop. Used internally + as the building block for multi-hop transitions. */
+    async setOpmodeOnce(mode) {
+        const goingToAuto = mode === 'AUTO';
+        if (goingToAuto) {
+            try {
+                await this.adapter.requestMastership('rapid');
+            }
+            catch { /* keep going */ }
+            try {
+                await this.adapter.setOperationMode(mode);
+            }
+            finally {
+                await this.adapter.releaseMastership('rapid').catch(() => { });
+            }
+            return;
+        }
+        await this.adapter.setOperationMode(mode);
+    }
+    // ─── RAPID execution ────────────────────────────────────────────────────────
+    //
+    // start/stop/resetpp/cycle all REQUIRE 'edit' mastership on RWS 2.0
+    // (RWS 1.0 calls it 'rapid', the adapter aliases internally).
+    // Live-confirmed: calling resetpp without mastership returns
+    // HTTP 403 with org_code -4501 / new_code 0xc004841d which the controller
+    // misleadingly tags as "RAPID error" — but the real cause is mastership.
+    //
+    // We acquire+release per-call so the manager doesn't hold mastership
+    // longer than necessary (other clients can use the controller meanwhile).
+    /**
+     * Wrap an op with auto-acquire-and-release of 'rapid'/'edit' mastership.
+     *
+     * NOTE: We deliberately do NOT proactively check RMMP here. Doing so caused
+     * false-positive errors when:
+     *   - the controller is in AUTO mode and grants are sufficient without RMMP
+     *   - the logged-in user lacks UAS grant to even *request* RMMP
+     *   - the controller is a VC with no FlexPendant target for the popup
+     *
+     * Mastership-only is the right default. If the op fails because RMMP is
+     * actually missing, the caller's error handler can offer a Request-RMMP
+     * action — but it's a recovery path, not a precondition.
+     */
+    async withMastership(fn) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.requestMastership('rapid');
+        try {
+            return await fn();
+        }
+        finally {
+            await this.adapter.releaseMastership('rapid').catch(() => { });
+        }
+    }
+    // ─── Remote Mastership Privilege (RMMP) ──────────────────────────────────
+    /** Get current RMMP — 'none' / 'pending modify' / 'modify' / 'exclusive'. */
+    async getRmmpPrivilege() {
+        if (!this.adapter?.getRmmpPrivilege) {
+            return 'unsupported';
+        }
+        return this.adapter.getRmmpPrivilege();
+    }
+    /** Request RMMP — triggers a FlexPendant popup that the operator must approve. */
+    async requestRmmp(level = 'modify') {
+        if (!this.adapter?.requestRmmp) {
+            throw new Error('RMMP not supported on this controller');
+        }
+        return this.adapter.requestRmmp(level);
+    }
+    /**
+     * Tracks the last PP target the user explicitly chose via setPPToRoutine.
+     * Used by startRapid() to re-apply on next start when execstate is 'stopped'.
+     * Reason: when a routine completes (e.g. has `Stop;` at end, or cycle=once),
+     * PP advances past the routine's last instruction. The next Start with
+     * `execmode=continue` then does nothing visible — controller accepts the
+     * call (HTTP 204) but there's nothing left to execute.
+     * By re-applying the target on each Start-from-stopped, the user's mental
+     * model becomes "Start runs the routine I picked" — every time.
+     * Cleared by resetRapid() (PP-to-Main) so the user can then run main again.
+     */
+    lastPPTarget = null;
+    /**
+     * Start RAPID execution.
+     * If the program is currently stopped AND the user previously set PP to a
+     * specific routine via setPPToRoutine(), we re-apply that target before
+     * starting. This makes "Start" reliable across multiple clicks: the chosen
+     * routine runs from the top each time the program has finished and is
+     * idle.
+     * If the program is paused mid-execution (e.g. user hit Stop in the middle
+     * of a long routine), the PP target is NOT re-applied — Start resumes
+     * from where the user stopped.
+     * Detection: if PP currently lives in `lastPPTarget.routine`, we assume
+     * the user is in the "ran-then-stopped" state (PP at end-of-routine).
+     * If PP is in some other routine (controller moved it for an interrupt,
+     * trap, etc.), we leave it alone.
+     */
+    async startRapid() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.withMastership(async () => {
+            const target = this.lastPPTarget;
+            const stopped = this._state.execstate === 'stopped';
+            if (target && stopped && this.adapter.setProgramPointer) {
+                // Best-effort: re-apply the target. If PP is still mid-routine
+                // (paused, not finished), this is still safe — it just resets PP
+                // to the start of the same routine.
+                await this.adapter.setProgramPointer(this.activeTaskName(), {
+                    module: target.module,
+                    routine: target.routine,
+                }).catch(() => { });
+            }
+            await this.adapter.startRapid();
+        });
+    }
+    /** Active task name. We currently target T_ROB1; future: track multi-task. */
+    activeTaskName() {
+        const active = this._state.tasks.find(t => t.active);
+        return active?.name ?? 'T_ROB1';
+    }
+    async stopRapid() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.withMastership(() => this.adapter.stopRapid());
+    }
+    async resetRapid() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        // PP-to-Main clears the routine target — Start will go to main from now on.
+        this.lastPPTarget = null;
+        await this.withMastership(() => this.adapter.resetRapid());
+    }
+    async setExecutionCycle(cycle) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.withMastership(() => this.adapter.setExecutionCycle(cycle));
+    }
+    async activateRapidTask(task) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.activateRapidTask(task);
+    }
+    async deactivateRapidTask(task) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.deactivateRapidTask(task);
+    }
+    async activateAllRapidTasks() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.activateAllRapidTasks();
+    }
+    async deactivateAllRapidTasks() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.deactivateAllRapidTasks();
+    }
+    // ─── RAPID variables ────────────────────────────────────────────────────────
+    async getRapidVariable(task, module, symbol) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.getRapidVariable(task, module, symbol);
+    }
+    async setRapidVariable(task, module, symbol, value) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.setRapidVariable(task, module, symbol, value);
+    }
+    async validateRapidValue(task, value, datatype) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.validateRapidValue(task, value, datatype);
+    }
+    async getRapidSymbolProperties(task, module, symbol) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.getRapidSymbolProperties(task, module, symbol);
+    }
+    async searchRapidSymbols(params) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.searchRapidSymbols(params);
+    }
+    /**
+     * Detailed list of loaded modules — each entry has `name` + `type` (SysMod / ProgMod).
+     * Used by the Modules tree to render system vs program modules differently.
+     * Falls back to bare names from `listModules` if the adapter doesn't support details.
+     */
+    async listModulesDetailed(task) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        if (this.adapter.listModulesDetailed) {
+            return this.adapter.listModulesDetailed(task);
+        }
+        const names = await this.adapter.listModules(task);
+        return names.map(n => ({ name: n, type: '' }));
+    }
+    /**
+     * Current program-pointer location for a task (module + routine + line).
+     * Returns null if the controller can't currently report a PP (e.g. no
+     * program loaded). Surfaces the data the Modules tree uses to highlight
+     * which routine is "active".
+     */
+    async getCurrentPP(task) {
+        if (!this.adapter?.getProgramPointer) {
+            return null;
+        }
+        try {
+            return await this.adapter.getProgramPointer(task);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List the routines (PROCs, FUNCs, TRAPs) defined in a loaded module.
+     * Uses the controller's symbol search rather than parsing the source —
+     * works even when the module file isn't on disk anymore (e.g. it was
+     * loaded then the file was deleted / never persisted).
+     *
+     * Returns: array of `{ name, symtyp }` where `symtyp` is one of:
+     *   - 'prc'  procedure (no return value, callable)
+     *   - 'fun'  function (returns a value)
+     *   - 'trp'  trap (interrupt handler)
+     * Routines from the controller's BASE / system modules are NOT included
+     * unless `includeSystem=true`.
+     */
+    async listRoutines(task, moduleName, includeSystem = false) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        const symbols = await this.adapter.searchRapidSymbols({
+            task,
+            blockurl: `RAPID/${task}/${moduleName}`,
+            symtyp: 'any',
+            // `recursive` accepts boolean in our type; the wire format is upper-case 'TRUE'
+            // and the adapter stringifies. Lib's default already sets 'TRUE' if omitted.
+        });
+        const routineKinds = new Set(['prc', 'fun', 'trp']);
+        return symbols
+            .filter(s => routineKinds.has(s.symtyp.toLowerCase()))
+            .filter(s => includeSystem || !s.local /* keep public; refine if needed */)
+            .map(s => ({ name: s.name, symtyp: s.symtyp, symburl: s.symburl, local: s.local }));
+    }
+    /**
+     * Set the program pointer to a specific routine, optionally in a specific module.
+     * If `module` is omitted, the controller picks based on its current scope.
+     * Wraps with `edit`/`rapid` mastership.
+     *
+     * After this returns successfully, the user can click Start and execution
+     * will begin at this routine instead of `main`.
+     */
+    async setPPToRoutine(task, moduleName, routine) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        if (!this.adapter.setProgramPointer) {
+            throw new Error('setProgramPointer not supported on this protocol');
+        }
+        await this.withMastership(async () => {
+            await this.adapter.stopRapid().catch(() => { });
+            await this.adapter.setProgramPointer(task, { module: moduleName, routine });
+        });
+        // Remember so startRapid() can re-apply on subsequent clicks once PP advances past the end.
+        this.lastPPTarget = { module: moduleName, routine };
+    }
+    async getActiveUiInstruction() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.getActiveUiInstruction();
+    }
+    async setUiInstructionParam(stackurl, uiparam, value) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.setUiInstructionParam(stackurl, uiparam, value);
+    }
+    // ─── File system ────────────────────────────────────────────────────────────
+    async listDirectory(remotePath) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.listDirectory(remotePath);
+    }
+    async readFile(remotePath) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.readFile(remotePath);
+    }
+    async deleteControllerFile(remotePath) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.deleteFile(remotePath);
+    }
+    /**
+     * Create a directory on the controller filesystem.
+     * If `parentPath` itself doesn't exist, recursively creates the missing
+     * parents under the volume root ($HOME / HOME / BACKUP / …). This is
+     * mkdir -p semantics — friendlier than the bare ABB endpoint which
+     * returns 404 "Path does not exist" if any intermediate is missing.
+     */
+    async createDirectory(parentPath, dirName) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        try {
+            await this.adapter.createDirectory(parentPath, dirName);
+            return;
+        }
+        catch (e) {
+            // 404 "Path does not exist" → ensure parents exist, then retry once.
+            const msg = e instanceof Error ? e.message : String(e);
+            if (!/HTTP 404|Path does not exist/i.test(msg)) {
+                throw e;
+            }
+            await this.ensureDirectory(parentPath);
+            await this.adapter.createDirectory(parentPath, dirName);
+        }
+    }
+    /**
+     * Walk down `path` from the volume root, creating each missing segment.
+     * Volumes ($HOME, HOME, BACKUP, DATA, …) themselves are NEVER created —
+     * they're controller-managed.
+     */
+    async ensureDirectory(targetPath) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        // Strip leading slash if any; first segment is the volume name.
+        const cleaned = targetPath.replace(/^\/+/, '');
+        const segments = cleaned.split('/').filter(Boolean);
+        if (segments.length <= 1) {
+            return;
+        } // just a volume — caller can't create that
+        // Walk: $HOME, $HOME/a, $HOME/a/b, ...
+        let cursor = segments[0]; // the volume
+        for (let i = 1; i < segments.length; i++) {
+            const seg = segments[i];
+            try {
+                await this.adapter.createDirectory(cursor, seg);
+            }
+            catch (e) {
+                // 409-ish "already exists" or 200 — treat as ok. Other errors propagate.
+                const msg = e instanceof Error ? e.message : String(e);
+                if (!/already exists|HTTP 200|HTTP 204|409/i.test(msg)) {
+                    // Path didn't exist AND we couldn't create it — keep walking but
+                    // re-throw at the end if the final create fails. (One forgiving pass.)
+                    if (!/HTTP 404|Path does not exist/i.test(msg)) {
+                        throw e;
+                    }
+                }
+            }
+            cursor = `${cursor}/${seg}`;
+        }
+    }
+    async copyControllerFile(sourcePath, destPath) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.copyFile(sourcePath, destPath);
+    }
+    // ─── Event log ──────────────────────────────────────────────────────────────
+    async refreshEventLog() {
+        if (!this.adapter) {
+            return;
+        }
+        try {
+            this._state.eventLog = await this.adapter.getEventLog(0, 'en');
+            this.notify();
+        }
+        catch { /* non-fatal */ }
+    }
+    async clearEventLog() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.clearEventLog(0);
+        this._state.eventLog = [];
+        this.notify();
+    }
+    async clearAllEventLogs() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.clearAllEventLogs();
+        this._state.eventLog = [];
+        this.notify();
+    }
+    // ─── Controller info ─────────────────────────────────────────────────────────
+    async restartController(mode) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.restartController(mode);
+    }
+    async getControllerClock() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return (await this.adapter.getControllerClock()).datetime;
+    }
+    async setControllerClock(year, month, day, hour, min, sec) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.setControllerClock(year, month, day, hour, min, sec);
+    }
+    // ─── I/O ─────────────────────────────────────────────────────────────────────
+    async refreshIoSignals() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        const PAGE = 100;
+        let start = 0;
+        const all = [];
+        while (true) {
+            const page = await this.adapter.listAllSignals(start, PAGE);
+            all.push(...page);
+            if (page.length < PAGE) {
+                break;
+            }
+            start += PAGE;
+        }
+        this._state.ioSignals = all;
+        this.notify();
+    }
+    async writeIoSignal(name, value) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.writeSignal('', '', name, value);
+        const sig = this._state.ioSignals.find(s => s.name === name);
+        if (sig) {
+            sig.lvalue = value;
+            sig.value = value;
+            this.notify();
+        }
+    }
+    async readIoSignal(network, device, name) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.readSignal(network, device, name);
+    }
+    async listNetworks() {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.listNetworks();
+    }
+    async listDevices(network) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.listDevices(network);
+    }
+    // ─── Program loading ─────────────────────────────────────────────────────────
+    /**
+     * Upload a single .mod / .sys file and load it into a task.
+     *
+     * Behavior:
+     *   1. Stop RAPID briefly so the symbol table isn't being mutated mid-load.
+     *   2. **If a module with the same name (= file basename without ext) is
+     *      already loaded, unload it first.** Live-verified gotcha: passing
+     *      `replace=true` to loadmod refreshes the *file* but the program's
+     *      symbol table still references the OLD module's procedures, so
+     *      `resetRapid()` afterwards reports "no main" even though the new
+     *      file has one. Explicit unload + load fixes this.
+     *   3. Upload the file to $HOME (or HOME/ on RWS 2.0 — adapter rewrites).
+     *   4. loadModule the new file.
+     *   5. **If the new module declares `PROC main()`, auto-call PP-to-Main.**
+     *      This restores the original v0.1 ergonomics without the destructive
+     *      behavior the earlier loadProgram had — the user can immediately
+     *      click Start. Failures during the auto-resetpp are swallowed (the
+     *      module loaded fine; the user can manually click PP-to-Main if
+     *      needed). Detect by regex over the file content.
+     *   6. **Does NOT unload OTHER modules.** Old versions unloaded every
+     *      non-system module, which destroyed the controller's pre-existing
+     *      program (e.g. OmniCore's `Module1`).
+     */
+    async loadProgram(localFilePath, taskName) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.requestMastership('rapid');
+        try {
+            await this.adapter.stopRapid().catch(() => { });
+            const content = fs.readFileSync(localFilePath, 'utf8');
+            const fileName = path.basename(localFilePath);
+            const moduleName = fileName.replace(/\.(mod|sys)$/i, '');
+            const remotePath = `$HOME/${fileName}`;
+            const existing = await this.adapter.listModules(taskName).catch(() => []);
+            if (existing.includes(moduleName)) {
+                await this.adapter.unloadModule(taskName, moduleName).catch(() => { });
+            }
+            await this.adapter.uploadFile(remotePath, content);
+            await this.adapter.loadModule(taskName, remotePath, true);
+            this._state.modules = await this.adapter.listModules(taskName);
+            this.notify();
+            // If the new module has a main proc, auto-resetpp so the user can Start
+            // immediately. Match `PROC main(` allowing whitespace + comments above.
+            // Errors here are non-fatal — the module loaded successfully even if
+            // PP-to-Main fails (e.g. another module's main collides; user resolves manually).
+            const hasMainProc = /\bPROC\s+main\s*\(/i.test(content);
+            if (hasMainProc) {
+                await this.adapter.resetRapid().catch(() => { });
+            }
+        }
+        finally {
+            await this.adapter.releaseMastership('rapid').catch(() => { });
+        }
+    }
+    /** @deprecated use loadProgram */
+    uploadAndLoad(p, t) { return this.loadProgram(p, t); }
+    /**
+     * Unload a single RAPID module from a task. Useful for resolving a
+     * `main`-proc collision: if two modules both define `PROC main()`, RWS
+     * refuses PP-to-Main with a semantic error — unload one and the other
+     * becomes the program's entry point.
+     */
+    async unloadModule(taskName, moduleName) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        await this.adapter.requestMastership('rapid');
+        try {
+            await this.adapter.stopRapid().catch(() => { });
+            await this.adapter.unloadModule(taskName, moduleName);
+            this._state.modules = await this.adapter.listModules(taskName);
+            this.notify();
+        }
+        finally {
+            await this.adapter.releaseMastership('rapid').catch(() => { });
+        }
+    }
+    // ─── New verified endpoints (exposed for commands) ────────────────────────
+    async getLicenseInfo() { return this.adapter?.getLicenseInfo?.() ?? { entries: [] }; }
+    async listProducts() { return this.adapter?.listProducts?.() ?? []; }
+    async getRobotType() { return this.adapter?.getRobotType?.() ?? { type: '' }; }
+    async getEnergyStats() { return this.adapter?.getEnergyStats?.() ?? {}; }
+    async getReturnCode(code, lang = 'en') { return this.adapter?.getReturnCode?.(code, lang) ?? null; }
+    async listControllerOptions() { return this.adapter?.listControllerOptions?.() ?? []; }
+    async listFeatures() { return this.adapter?.listFeatures?.() ?? []; }
+    async getMotionChangeCount() { return this.adapter?.getMotionChangeCount?.() ?? 0; }
+    async getMotionErrorState() { return this.adapter?.getMotionErrorState?.() ?? { state: 'unknown' }; }
+    async getNonMotionExecution() { return this.adapter?.getNonMotionExecution?.() ?? false; }
+    async setNonMotionExecution(enabled) { return this.adapter?.setNonMotionExecution?.(enabled); }
+    async getCollisionPredictionMode() { return this.adapter?.getCollisionPredictionMode?.() ?? 'OFF'; }
+    async setCollisionPredictionMode(m) { return this.adapter?.setCollisionPredictionMode?.(m); }
+    async getEnableRequest() { return this.adapter?.getEnableRequest?.() ?? { state: 'unknown', raw: {} }; }
+    async listAliasIO() { return this.adapter?.listAliasIO?.() ?? []; }
+    async getTaskSelection() { return this.adapter?.getTaskSelection?.() ?? { selected: [], available: [] }; }
+    async setTaskSelection(tasks) { return this.adapter?.setTaskSelection?.(tasks); }
+    async getProgramPointer(task) { return this.adapter?.getProgramPointer?.(task) ?? {}; }
+    async getMotionPointer(task) { return this.adapter?.getMotionPointer?.(task) ?? {}; }
+    // CFG
+    async listCfgDomains() { return this.adapter?.listCfgDomains?.() ?? []; }
+    async listCfgTypes(d) { return this.adapter?.listCfgTypes?.(d) ?? []; }
+    async listCfgInstances(d, t) { return this.adapter?.listCfgInstances?.(d, t) ?? []; }
+    async getCfgInstance(d, t, i) { return this.adapter?.getCfgInstance?.(d, t, i) ?? {}; }
+    async setCfgInstance(d, t, i, attrs) {
+        if (!this.adapter?.setCfgInstance) {
+            throw new Error('setCfgInstance not supported');
+        }
+        await this.withMastership(() => this.adapter.setCfgInstance(d, t, i, attrs));
+    }
+    async createCfgInstance(d, t, i, attrs) {
+        if (!this.adapter?.createCfgInstance) {
+            throw new Error('createCfgInstance not supported');
+        }
+        await this.withMastership(() => this.adapter.createCfgInstance(d, t, i, attrs));
+    }
+    async removeCfgInstance(d, t, i) {
+        if (!this.adapter?.removeCfgInstance) {
+            throw new Error('removeCfgInstance not supported');
+        }
+        await this.withMastership(() => this.adapter.removeCfgInstance(d, t, i));
+    }
+    async loadCfgFile(filepath, action = 'add') {
+        if (!this.adapter?.loadCfgFile) {
+            throw new Error('loadCfgFile not supported');
+        }
+        await this.withMastership(() => this.adapter.loadCfgFile(filepath, action));
+    }
+    async saveCfgFile(domain, filepath) {
+        if (!this.adapter?.saveCfgFile) {
+            throw new Error('saveCfgFile not supported');
+        }
+        await this.withMastership(() => this.adapter.saveCfgFile(domain, filepath));
+    }
+    // Backup / restore
+    async listBackups() { return this.adapter?.listBackups?.() ?? []; }
+    async createBackup(n) {
+        if (!this.adapter?.createBackup) {
+            throw new Error('createBackup not supported');
+        }
+        return this.adapter.createBackup(n);
+    }
+    async restoreBackup(n) {
+        if (!this.adapter?.restoreBackup) {
+            throw new Error('restoreBackup not supported');
+        }
+        return this.adapter.restoreBackup(n);
+    }
+    async getBackupStatus() { return this.adapter?.getBackupStatus?.() ?? { active: false }; }
+    // Module info / source / symbols / service-routine / tool-wobj activation
+    // (getModuleSource, listModuleSymbols, calcCartesianFromJoints already
+    // defined further below in this file.)
+    async getModuleInfo(task, moduleName) {
+        if (!this.adapter?.getModuleInfo) {
+            return {};
+        }
+        return this.adapter.getModuleInfo(task, moduleName);
+    }
+    async callServiceRoutine(task, routineName, args) {
+        if (!this.adapter?.callServiceRoutine) {
+            throw new Error('callServiceRoutine not supported');
+        }
+        return this.adapter.callServiceRoutine(task, routineName, args);
+    }
+    async setActiveTool(mechunit, toolName) {
+        if (!this.adapter?.setActiveTool) {
+            throw new Error('setActiveTool not supported');
+        }
+        return this.adapter.setActiveTool(mechunit, toolName);
+    }
+    async setActiveWobj(mechunit, wobjName) {
+        if (!this.adapter?.setActiveWobj) {
+            throw new Error('setActiveWobj not supported');
+        }
+        return this.adapter.setActiveWobj(mechunit, wobjName);
+    }
+    // DIPC — Distributed Inter-Process Communication. Lets RAPID and external
+    // clients exchange typed messages through named queues.
+    async listDipcQueues() {
+        if (!this.adapter?.listDipcQueues) {
+            return [];
+        }
+        return this.adapter.listDipcQueues();
+    }
+    async createDipcQueue(name, options) {
+        if (!this.adapter?.createDipcQueue) {
+            throw new Error('DIPC not supported');
+        }
+        return this.adapter.createDipcQueue(name, options);
+    }
+    async sendDipcMessage(queue, payload, type = 'string') {
+        if (!this.adapter?.sendDipcMessage) {
+            throw new Error('DIPC not supported');
+        }
+        return this.adapter.sendDipcMessage(queue, payload, type);
+    }
+    async readDipcMessage(queue, timeoutMs) {
+        if (!this.adapter?.readDipcMessage) {
+            throw new Error('DIPC not supported');
+        }
+        return this.adapter.readDipcMessage(queue, timeoutMs);
+    }
+    async removeDipcQueue(name) {
+        if (!this.adapter?.removeDipcQueue) {
+            throw new Error('DIPC not supported');
+        }
+        return this.adapter.removeDipcQueue(name);
+    }
+    // File volumes (HOME, BACKUP, DATA, ADDINDATA, PRODUCTS, RAMDISK, TEMP)
+    async listFileVolumes() {
+        if (!this.adapter?.listFileVolumes) {
+            return ['HOME'];
+        } // safe default
+        return this.adapter.listFileVolumes();
+    }
+    // (validateRapidValue defined earlier; compressPath kept on adapter only)
+    async compressPath(source, destination) {
+        if (!this.adapter?.compressPath) {
+            throw new Error('Compress not supported on this protocol');
+        }
+        return this.adapter.compressPath(source, destination);
+    }
+    // Tool/WObj
+    async getActiveTool(m) { return this.adapter?.getActiveTool?.(m) ?? { name: '' }; }
+    async getActiveWobj(m) { return this.adapter?.getActiveWobj?.(m) ?? { name: '' }; }
+    async getActivePayload(m) { return this.adapter?.getActivePayload?.(m) ?? { name: '' }; }
+    // Vision/Safety/VirtualTime
+    async listVisionSystems() { return this.adapter?.listVisionSystems?.() ?? []; }
+    async getSafetyStatus() { return this.adapter?.getSafetyStatus?.() ?? { state: 'unavailable' }; }
+    async getVirtualTime() { return this.adapter?.getVirtualTime?.() ?? { time: 0, running: false }; }
+    async setVirtualTimeRunning(r) { return this.adapter?.setVirtualTimeRunning?.(r); }
+    async setVirtualTimeScale(s) { return this.adapter?.setVirtualTimeScale?.(s); }
+    // Mechunit details
+    async getMechunitBaseFrame(m) { return this.adapter?.getMechunitBaseFrame?.(m) ?? null; }
+    async getMechunitAxes(m) { return this.adapter?.getMechunitAxes?.(m) ?? []; }
+    async getMechunitInfo(m) { return this.adapter?.getMechunitInfo?.(m) ?? {}; }
+    // Task details
+    async getTaskStructuralChangeCount(t) { return this.adapter?.getTaskStructuralChangeCount?.(t) ?? 0; }
+    async getTaskMotion(t) { return this.adapter?.getTaskMotion?.(t) ?? {}; }
+    async getTaskActivationRecord(t) { return this.adapter?.getTaskActivationRecord?.(t) ?? {}; }
+    async getTaskProgramInfo(t) { return this.adapter?.getTaskProgramInfo?.(t) ?? {}; }
+    // Module
+    async getModuleSource(t, n) { return this.adapter?.getModuleSource?.(t, n) ?? ''; }
+    async listModuleSymbols(t, n) { return this.adapter?.listModuleSymbols?.(t, n) ?? []; }
+    // ─── Inverse + Forward Kinematics ───────────────────────────────────────────
+    async calcJointsFromCartesian(pos, seedJoints, mechunit) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.calcJointsFromCartesian(pos, seedJoints, mechunit);
+    }
+    async calcCartesianFromJoints(joints, mechunit = 'ROB_1', tool = 'tool0', wobj = 'wobj0') {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        if (!this.adapter.calcCartesianFromJoints) {
+            throw new Error('Forward kinematics not supported on this protocol');
+        }
+        return this.adapter.calcCartesianFromJoints(joints, mechunit, tool, wobj);
+    }
+    // ─── Devices ─────────────────────────────────────────────────────────────────
+    async listSystemDevices() {
+        if (!this.adapter?.listSystemDevices) {
+            return [];
+        }
+        return this.adapter.listSystemDevices();
+    }
+    async listAllIoDevices() {
+        if (!this.adapter?.listAllIoDevices) {
+            return [];
+        }
+        return this.adapter.listAllIoDevices();
+    }
+    // ─── Mastership extras ───────────────────────────────────────────────────────
+    async requestMastershipAll() {
+        if (!this.adapter?.requestMastershipAll) {
+            throw new Error('requestMastershipAll not supported');
+        }
+        return this.adapter.requestMastershipAll();
+    }
+    async releaseMastershipAll() {
+        if (!this.adapter?.releaseMastershipAll) {
+            throw new Error('releaseMastershipAll not supported');
+        }
+        return this.adapter.releaseMastershipAll();
+    }
+    async requestMastershipWithId(domain) {
+        if (!this.adapter?.requestMastershipWithId) {
+            throw new Error('Token-based mastership requires RWS 2.0');
+        }
+        return this.adapter.requestMastershipWithId(domain);
+    }
+    async releaseMastershipWithId(domain, id) {
+        if (!this.adapter?.releaseMastershipWithId) {
+            throw new Error('Token-based mastership requires RWS 2.0');
+        }
+        return this.adapter.releaseMastershipWithId(domain, id);
+    }
+    async resetMastershipWatchdog() {
+        if (!this.adapter?.resetMastershipWatchdog) {
+            throw new Error('Mastership watchdog requires RobotWare 7.8+');
+        }
+        return this.adapter.resetMastershipWatchdog();
+    }
+    /** Query who currently holds mastership on a domain. Returns null if adapter doesn't support it. */
+    async getMastershipStatus(domain = 'rapid') {
+        if (!this.adapter?.getMastershipStatus) {
+            return null;
+        }
+        try {
+            return await this.adapter.getMastershipStatus(domain);
+        }
+        catch {
+            return null;
+        }
+    }
+    // ─── Jogging ──────────────────────────────────────────────────────────────────
+    /** Tracks whether motion mastership is currently held — avoids redundant requests on rapid jog clicks. */
+    motionMastershipHeld = false;
+    jogReleaseTimer = null;
+    /**
+     * Jog the robot. Wraps the adapter call with safety checks and mastership.
+     * Requests motion mastership on first call, releases 2s after the last call
+     * (so rapid successive jogs don't churn mastership).
+     */
+    async jog(params) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        // Safety: only allow jog in manual modes
+        const mode = this._state.opmode;
+        if (mode === 'AUTO') {
+            throw new Error(`Jogging is not allowed in AUTO mode. Switch the controller to MANR or MANF first.`);
+        }
+        // Safety: motors must be on
+        if (this._state.ctrlstate !== 'motoron') {
+            throw new Error(`Motors are off (state: ${this._state.ctrlstate}). Turn motors on before jogging.`);
+        }
+        // Ensure RMMP (Remote Mastership Privilege) — required for ANY modify op via RWS.
+        // Without this, jog returns 403 "Operation not allowed for user".
+        if (this.adapter.getRmmpPrivilege && this.adapter.requestRmmp) {
+            const priv = await this.adapter.getRmmpPrivilege().catch(() => 'none');
+            if (priv === 'none') {
+                await this.adapter.requestRmmp('modify');
+                Logger.warn('RMMP requested — open FlexPendant and approve the remote-control popup, then click jog again');
+                throw new Error('Remote control not authorized yet. Open the FlexPendant and approve the popup that asks "Allow remote user to modify?", then click jog again.');
+            }
+            if (priv.startsWith('pending')) {
+                throw new Error('Remote control approval is still pending. Open the FlexPendant and approve the popup, then click jog again.');
+            }
+            // 'modify' or 'exclusive' — proceed
+        }
+        if (!this.motionMastershipHeld) {
+            await this.adapter.requestMastership('motion');
+            this.motionMastershipHeld = true;
+        }
+        // Reset the auto-release timer on every jog so it only fires after 2 s of no jogging
+        if (this.jogReleaseTimer) {
+            clearTimeout(this.jogReleaseTimer);
+        }
+        this.jogReleaseTimer = setTimeout(() => { this.releaseJogMastership().catch(() => { }); }, 2000);
+        await this.adapter.jog(params);
+    }
+    /** Release motion mastership immediately (called by disconnect and the auto-release timer). */
+    async releaseJogMastership() {
+        if (this.jogReleaseTimer) {
+            clearTimeout(this.jogReleaseTimer);
+            this.jogReleaseTimer = null;
+        }
+        if (this.motionMastershipHeld && this.adapter) {
+            await this.adapter.releaseMastership('motion').catch(() => { });
+            this.motionMastershipHeld = false;
+        }
+    }
+    async downloadModule(moduleName) {
+        if (!this.adapter) {
+            throw new Error('Not connected');
+        }
+        return this.adapter.readFile(`$HOME/${moduleName}.mod`);
+    }
+    // ─── Session cookie (RWS 1.0 only) ──────────────────────────────────────────
+    // ─── WebSocket subscriptions ──────────────────────────────────────────────────
+    /**
+     * Subscribe to state-change events for instant UI updates.
+     * Non-fatal: if subscriptions fail (e.g. controller doesn't support WS),
+     * polling covers all state at full frequency.
+     */
+    async startSubscriptions() {
+        if (!this.adapter) {
+            return;
+        }
+        try {
+            this.unsubscribeFn = await this.adapter.subscribe([
+                'controllerstate',
+                'operationmode',
+                'speedratio',
+                'execution',
+                'coldetstate',
+                { type: 'elog', domain: 0 },
+            ], event => this.handleSubscriptionEvent(event));
+            this.subscriptionActive = true;
+        }
+        catch (e) {
+            this.subscriptionActive = false;
+            // Not an error — polling is the fallback
+            console.log(`[RobotManager] WS subscriptions unavailable, using polling only: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    handleSubscriptionEvent(event) {
+        if (!this._state.connected) {
+            return;
+        }
+        let changed = false;
+        // event.resource can be a friendly name ('controllerstate') from RWS 1.0 via abb-rws-client,
+        // or a URL path ('/rw/panel/ctrl-state;ctrlstate') from RWS 2.0.
+        // RWS2Adapter.resourcePathToName() normalizes before calling here, but we also
+        // match URL fragments as a safety net so both paths work regardless of adapter.
+        const r = event.resource;
+        const isCtrlState = r === 'controllerstate' || /\/(ctrlstate|ctrl-state)/.test(r);
+        const isOpMode = r === 'operationmode' || /\/opmode/.test(r);
+        const isSpeed = r === 'speedratio' || /\/speedratio/.test(r);
+        const isExec = (r === 'execution' || /\/execution/.test(r)) && !/execycle/.test(r);
+        const isColdet = r === 'coldetstate' || /\/coldetstate/.test(r);
+        const isElog = r === 'elog' || /\/elog\//.test(r);
+        if (isCtrlState) {
+            if (this._state.ctrlstate !== event.value) {
+                this._state.ctrlstate = event.value;
+                changed = true;
+            }
+        }
+        else if (isOpMode) {
+            if (this._state.opmode !== event.value) {
+                this._state.opmode = event.value;
+                changed = true;
+            }
+        }
+        else if (isSpeed) {
+            const n = Number(event.value);
+            if (!isNaN(n) && this._state.speedRatio !== n) {
+                this._state.speedRatio = n;
+                changed = true;
+            }
+        }
+        else if (isExec) {
+            if (this._state.execstate !== event.value) {
+                this._state.execstate = event.value;
+                changed = true;
+            }
+        }
+        else if (isColdet) {
+            if (this._state.coldetstate !== event.value) {
+                this._state.coldetstate = event.value;
+                changed = true;
+            }
+        }
+        else if (isElog) {
+            // New elog message arrived — refresh the log asynchronously
+            this.adapter?.getEventLog(0, 'en').then(log => {
+                this._state.eventLog = log;
+                this.notify();
+            }).catch(() => { });
+            return; // notify() called inside the promise above
+        }
+        if (changed) {
+            this.notify();
+        }
+    }
+    // ─── Session cookie ──────────────────────────────────────────────────────────
+    loadSessionCookie(host) {
+        try {
+            return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'))[host] ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    saveSessionCookie(host, cookie) {
+        try {
+            let data = {};
+            try {
+                data = JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
+            }
+            catch { /* new file */ }
+            data[host] = cookie;
+            fs.writeFileSync(SESSION_FILE, JSON.stringify(data), 'utf8');
+        }
+        catch { /* non-fatal */ }
+    }
+    // ─── Polling ─────────────────────────────────────────────────────────────────
+    fetchCount = 0;
+    /** Consecutive poll failures — only disconnects after 3, so transient blips don't drop the connection. */
+    consecutiveFails = 0;
+    fetchInFlight = false;
+    async fetchAll(generation) {
+        // Bail if this fetch belongs to an old generation (we've reconnected or disconnected since).
+        if (generation !== undefined && generation !== this.pollGeneration) {
+            return;
+        }
+        if (!this.adapter) {
+            return;
+        }
+        if (this.fetchInFlight) {
+            return;
+        }
+        this.fetchInFlight = true;
+        try {
+            const taskName = 'T_ROB1';
+            const [execInfo, ctrlstate, opmode, speedRatio, tasks, modules, joints, cartesianFull] = await Promise.all([
+                this.adapter.getRapidExecutionInfo(),
+                this.adapter.getControllerState(),
+                this.adapter.getOperationMode(),
+                this.adapter.getSpeedRatio(),
+                this.adapter.getRapidTasks(),
+                this.adapter.listModules(taskName),
+                this.adapter.getJointPositions(),
+                this.adapter.getCartesianFull(),
+            ]);
+            const cartesian = { x: cartesianFull.x, y: cartesianFull.y, z: cartesianFull.z, q1: cartesianFull.q1, q2: cartesianFull.q2, q3: cartesianFull.q3, q4: cartesianFull.q4 };
+            Object.assign(this._state, {
+                ctrlstate, opmode, execstate: execInfo.state, execCycle: execInfo.cycle,
+                speedRatio, tasks, modules, joints, cartesian, cartesianFull,
+            });
+            this._state.coldetstate = await this.adapter.getCollisionDetectionState().catch(() => null);
+            this.fetchCount++;
+            // Identity / systemInfo / eventLog / mechunits — only refresh occasionally,
+            // BUT keep retrying every poll until they're populated (so a transient first-poll
+            // failure doesn't leave the Status panel stuck on the IP fallback forever).
+            const needSlowFetch = this.fetchCount === 1 ||
+                this.fetchCount % 30 === 0 ||
+                !this._state.systemInfo ||
+                !this._state.identity;
+            if (needSlowFetch) {
+                const [identity, systemInfo, eventLog, mechunits] = await Promise.all([
+                    this.adapter.getControllerIdentity().catch(e => { Logger.warn(`getControllerIdentity failed: ${e instanceof Error ? e.message : String(e)}`); return null; }),
+                    this.adapter.getSystemInfo().catch(e => { Logger.warn(`getSystemInfo failed: ${e instanceof Error ? e.message : String(e)}`); return null; }),
+                    this.adapter.getEventLog(0, 'en').catch(e => { Logger.warn(`getEventLog failed: ${e instanceof Error ? e.message : String(e)}`); return []; }),
+                    this.adapter.listMechunits().catch(e => { Logger.warn(`listMechunits failed: ${e instanceof Error ? e.message : String(e)}`); return ['ROB_1']; }),
+                ]);
+                if (identity) {
+                    this._state.identity = identity;
+                }
+                if (systemInfo) {
+                    this._state.systemInfo = systemInfo;
+                }
+                this._state.eventLog = eventLog;
+                this._state.mechunits = mechunits;
+            }
+            if (this.fetchCount === 1 || this.fetchCount % 5 === 0) {
+                const PAGE = 100;
+                let start = 0;
+                const all = [];
+                try {
+                    while (true) {
+                        const page = await this.adapter.listAllSignals(start, PAGE);
+                        all.push(...page);
+                        if (page.length < PAGE) {
+                            break;
+                        }
+                        start += PAGE;
+                    }
+                    this._state.ioSignals = all;
+                }
+                catch { /* non-fatal */ }
+            }
+            this.consecutiveFails = 0;
+            this.notify();
+        }
+        catch (e) {
+            // Stale poll (disconnect or reconnect happened mid-flight) — don't count this failure.
+            if (generation !== undefined && generation !== this.pollGeneration) {
+                return;
+            }
+            this.consecutiveFails++;
+            // First failure is usually transient (controller queued behind motion).
+            // Log at info-level for the first; only warn from the second onward.
+            const msg = `poll failed (${this.consecutiveFails}/3) — ${e instanceof Error ? e.message : String(e)}`;
+            if (this.consecutiveFails >= 2) {
+                Logger.warn(msg);
+            }
+            else {
+                Logger.info(msg);
+            }
+            if (this.consecutiveFails >= 3) {
+                const reason = e instanceof Error ? e.message : String(e);
+                Logger.error(`disconnecting after 3 failed polls`, e);
+                Logger.show();
+                // Capture config BEFORE disconnect (which clears it) so the Reconnect button works.
+                const cfg = this.adapterConfig;
+                await this.disconnect();
+                // Hand off to the host's error listener (VS Code extension, CLI, etc.).
+                // If no listener is installed, the failure is silent beyond the log lines above.
+                if (this.errorListener) {
+                    this.errorListener(`ABB Robot disconnected: ${reason}`, ['Show Logs', 'Reconnect']).then(choice => {
+                        if (choice === 'Show Logs') {
+                            Logger.show();
+                        }
+                        if (choice === 'Reconnect' && cfg) {
+                            this.connect(cfg.host, cfg.username, cfg.password, cfg.port)
+                                .catch(err => Logger.error('reconnect failed', err));
+                        }
+                    });
+                }
+            }
+        }
+        finally {
+            this.fetchInFlight = false;
+        }
+    }
+}
+//# sourceMappingURL=RobotManager.js.map