editmamei 0.23.0 → 1.0.0

package/dist/platform/macos-detector.js

@@ -3,135 +3,106 @@ import { promisify } from 'util';
 import { access, constants, readFile } from 'fs/promises';
 import { Logger } from '../utils/logger.js';
 const execFileAsync = promisify(execFile);
+export function bundleDisplayName(bundlePath) {
+    const leaf = bundlePath.replace(/\/+$/, '').split('/').pop();
+    if (!leaf)
+        return undefined;
+    return leaf.endsWith('.app') ? leaf.slice(0, -'.app'.length) : leaf;
+}
 export class MacOSDetector {
-    logger;
-    constructor() {
-        this.logger = new Logger('MacOSDetector');
-    }
+    logger = new Logger('MacOSDetector');
     async detect() {
-        this.logger.info('Detecting Photoshop on macOS...');
-        const envPath = process.env.PHOTOSHOP_PATH;
-        if (envPath) {
-            this.logger.debug(`Using environment variable: ${envPath}`);
-            const info = await this.checkPath(envPath);
+        this.logger.info('Looking for a Photoshop install on macOS');
+        const override = process.env.PHOTOSHOP_PATH;
+        if (override) {
+            this.logger.debug('Trying PHOTOSHOP_PATH override', override);
+            const info = await this.inspectBundle(override);
             if (info)
                 return info;
         }
         try {
-            const spotlightInfo = await this.detectUsingSpotlight();
-            if (spotlightInfo)
-                return spotlightInfo;
+            const fromSpotlight = await this.findViaSpotlight();
+            if (fromSpotlight)
+                return fromSpotlight;
         }
         catch (error) {
-            this.logger.warn('Spotlight detection failed:', error);
+            this.logger.warn('Spotlight lookup did not resolve an install', error);
         }
-        const commonPaths = this.getCommonPaths();
-        for (const path of commonPaths) {
-            const info = await this.checkPath(path);
+        for (const path of this.conventionalPaths()) {
+            const info = await this.inspectBundle(path);
             if (info)
                 return info;
         }
-        throw new Error('Photoshop not found on this system');
+        throw new Error('No Photoshop install could be found on this machine');
     }
-    async detectUsingSpotlight() {
+    async findViaSpotlight() {
         try {
             const { stdout } = await execFileAsync('mdfind', [
                 'kMDItemCFBundleIdentifier == com.adobe.Photoshop',
             ]);
-            const apps = stdout
+            const bundles = stdout
                 .split('\n')
                 .filter((line) => line.trim() && line.endsWith('.app'))
                 .sort((a, b) => b.localeCompare(a));
-            for (const appPath of apps) {
-                const info = await this.checkPath(appPath);
+            for (const bundlePath of bundles) {
+                const info = await this.inspectBundle(bundlePath);
                 if (info)
                     return info;
             }
         }
         catch (error) {
-            this.logger.debug('Spotlight search failed:', error);
+            this.logger.debug('Spotlight query failed', error);
         }
         return null;
     }
-    getCommonPaths() {
+    conventionalPaths() {
         const paths = [];
-        for (let year = 2025; year >= 2012; year--) {
+        const newestYear = Math.max(new Date().getFullYear() + 1, 2026);
+        for (let year = newestYear; year >= 2012; year--) {
             paths.push(`/Applications/Adobe Photoshop ${year}/Adobe Photoshop ${year}.app`, `/Applications/Adobe Photoshop CC ${year}/Adobe Photoshop CC ${year}.app`, `/Applications/Adobe Photoshop ${year}.app`);
         }
         paths.push('/Applications/Adobe Photoshop CC/Adobe Photoshop CC.app', '/Applications/Adobe Photoshop/Adobe Photoshop.app', '/Applications/Adobe Photoshop.app');
         return paths;
     }
-    async checkPath(path) {
+    async inspectBundle(path) {
         try {
             const cleanPath = path.trim();
             await access(cleanPath, constants.F_OK);
-            const version = await this.extractVersionFromApp(cleanPath);
-            const appName = cleanPath.split('/').pop()?.replace('.app', '') || 'Adobe Photoshop 2025';
-            this.logger.info(`Found Photoshop at: ${cleanPath}`);
-            return {
-                version,
-                path: cleanPath,
-                isRunning: await this.checkIfRunning(cleanPath),
-                appName,
-            };
+            const version = await this.readBundleVersion(cleanPath);
+            const appName = bundleDisplayName(cleanPath);
+            this.logger.info('Using Photoshop at', cleanPath);
+            return { version, path: cleanPath, appName };
         }
         catch {
             return null;
         }
     }
-    async extractVersionFromApp(appPath) {
+    async readBundleVersion(bundlePath) {
         try {
-            const plistPath = `${appPath}/Contents/Info.plist`;
+            const plistPath = `${bundlePath}/Contents/Info.plist`;
             try {
                 await access(plistPath, constants.F_OK);
-                const { stdout: version } = await execFileAsync('/usr/libexec/PlistBuddy', [
+                const { stdout } = await execFileAsync('/usr/libexec/PlistBuddy', [
                     '-c',
                     'Print :CFBundleShortVersionString',
                     plistPath,
                 ]);
-                if (version.trim()) {
-                    return version.trim();
-                }
+                if (stdout.trim())
+                    return stdout.trim();
             }
             catch {
                 const content = await readFile(plistPath, 'utf8');
                 const versionMatch = content.match(/<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/);
-                if (versionMatch) {
+                if (versionMatch)
                     return versionMatch[1];
-                }
             }
-            const yearMatch = appPath.match(/(\d{4})/);
-            if (yearMatch) {
+            const yearMatch = bundlePath.match(/(\d{4})/);
+            if (yearMatch)
                 return yearMatch[1];
-            }
         }
         catch (err) {
-            this.logger.debug('Failed to extract version from app:', err);
+            this.logger.debug('Could not read a version from the bundle', err);
         }
         return 'Unknown';
     }
-    async checkIfRunning(appPath) {
-        try {
-            const appName = appPath.split('/').pop()?.replace('.app', '') || 'Adobe Photoshop';
-            const { stdout } = await execFileAsync('pgrep', ['-f', appName]);
-            return stdout.trim().length > 0;
-        }
-        catch {
-            return false;
-        }
-    }
-    async getAppBundleId(appPath) {
-        try {
-            const plistPath = `${appPath}/Contents/Info.plist`;
-            const { stdout } = await execFileAsync('/usr/libexec/PlistBuddy', [
-                '-c',
-                'Print :CFBundleIdentifier',
-                plistPath,
-            ]);
-            return stdout.trim();
-        }
-        catch {
-            return null;
-        }
-    }
 }

package/dist/platform/macos-runner.js

@@ -0,0 +1,94 @@
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import { Logger } from '../utils/logger.js';
+import { TempDir } from '../utils/temp.js';
+import { ScriptQueue } from './script-queue.js';
+import { runChildWithTimeout } from './run-child.js';
+import { decodeScriptResult } from './script-result.js';
+const execAsync = promisify(exec);
+const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
+const LAUNCH_GRACE_MS = 5_000;
+const UNSAFE_IN_APPLESCRIPT_LITERAL = /["\\\r\n\t]/;
+export class MacOSScriptRunner {
+    logger = new Logger('MacOSScriptRunner');
+    queue = new ScriptQueue(this.logger);
+    appName = null;
+    useInstall(install) {
+        const name = install.appName;
+        if (!name) {
+            this.logger.warn('This Photoshop install carries no application name, so AppleScript has nothing to address', install.path);
+            return;
+        }
+        if (UNSAFE_IN_APPLESCRIPT_LITERAL.test(name)) {
+            throw new Error(`Photoshop's application name (${JSON.stringify(name)}) contains a character that ` +
+                'cannot be composed into AppleScript.');
+        }
+        this.appName = name;
+        this.logger.debug('Addressing Photoshop as', name);
+    }
+    async run(script, timeoutMs = DEFAULT_SCRIPT_TIMEOUT_MS) {
+        return this.queue.enqueue(() => this.runOnce(script, timeoutMs), timeoutMs);
+    }
+    async runOnce(script, timeoutMs) {
+        const dir = await TempDir.create('editmamei-mac-');
+        try {
+            const scriptPath = await dir.write('script.jsx', script);
+            const wrapperPath = await dir.write('run.scpt', this.buildAppleScriptWrapper(scriptPath, timeoutMs));
+            const { stdout, stderr, exitCode } = await runChildWithTimeout('osascript', [wrapperPath], {
+                timeout: timeoutMs,
+                diagLabel: 'osascript run.scpt',
+            });
+            if (stderr) {
+                this.logger.warn('Script execution reported a warning', stderr);
+            }
+            if (exitCode !== 0) {
+                throw new Error(`osascript exited with code ${exitCode}: ${stderr.trim() || '(no output on stderr)'}`);
+            }
+            return decodeScriptResult(stdout);
+        }
+        finally {
+            await dir.cleanup();
+        }
+    }
+    buildAppleScriptWrapper(scriptPath, timeoutMs = DEFAULT_SCRIPT_TIMEOUT_MS) {
+        if (!this.appName) {
+            throw new Error('No Photoshop application name has been set for this runner — the install was never ' +
+                'handed to useInstall(), so there is no application for AppleScript to address.');
+        }
+        const posixPath = scriptPath.replace(/\\/g, '/');
+        if (posixPath.includes('"') || posixPath.includes('\n')) {
+            throw new Error('Refusing to compose the wrapper: script path would break the AppleScript');
+        }
+        const timeoutSeconds = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.max(1, Math.ceil(timeoutMs / 1000)) : 1;
+        const encodedPath = encodeURI(posixPath).replace(/'/g, '%27');
+        return `with timeout of ${timeoutSeconds} seconds
+\ttell application "${this.appName}"
+\t\tdo javascript "$.evalFile(decodeURI('${encodedPath}'))"
+\tend tell
+end timeout`;
+    }
+    async isRunning() {
+        try {
+            const { stdout } = await execAsync('pgrep -f "Adobe Photoshop"');
+            return stdout.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async launch(executablePath) {
+        return new Promise((resolve, reject) => {
+            this.logger.info('Launching Photoshop', executablePath);
+            const child = spawn('open', ['-a', executablePath], { detached: true, stdio: 'ignore' });
+            child.unref();
+            const grace = setTimeout(() => {
+                grace.unref();
+                resolve();
+            }, LAUNCH_GRACE_MS);
+            child.on('error', (error) => {
+                clearTimeout(grace);
+                reject(new Error(`Could not launch Photoshop at ${executablePath}: ${error.message}`));
+            });
+        });
+    }
+}

package/dist/platform/script-queue.js

@@ -0,0 +1,68 @@
+export const QUEUE_SLACK_MS = 3500;
+export class ScriptQueue {
+    logger;
+    queue = [];
+    isProcessing = false;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    enqueue(run, timeout) {
+        return new Promise((resolve, reject) => {
+            const task = {
+                run,
+                resolve,
+                reject,
+                cancelled: false,
+                settled: false,
+                timeoutId: null,
+            };
+            task.timeoutId = setTimeout(() => {
+                if (task.settled)
+                    return;
+                task.cancelled = true;
+                task.settled = true;
+                task.timeoutId = null;
+                reject(new Error('Script execution timeout'));
+            }, timeout + QUEUE_SLACK_MS);
+            this.queue.push(task);
+            void this.processQueue();
+        });
+    }
+    settleTask(task, fn) {
+        if (task.settled)
+            return;
+        task.settled = true;
+        if (task.timeoutId !== null) {
+            clearTimeout(task.timeoutId);
+            task.timeoutId = null;
+        }
+        fn();
+    }
+    async processQueue() {
+        if (this.isProcessing)
+            return;
+        this.isProcessing = true;
+        try {
+            while (this.queue.length > 0) {
+                const task = this.queue.shift();
+                if (task.cancelled)
+                    continue;
+                try {
+                    const result = await task.run();
+                    this.settleTask(task, () => task.resolve(result));
+                }
+                catch (error) {
+                    if (task.settled) {
+                        this.logger.error('Script execution failed after settle:', error);
+                    }
+                    else {
+                        this.settleTask(task, () => task.reject(error));
+                    }
+                }
+            }
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+}

package/dist/platform/script-result.js

@@ -0,0 +1,39 @@
+const TRANSPORT_FAILURE_MARKER = 'ERROR:';
+const ENVELOPE_TAG = '__em';
+function isEnvelope(payload) {
+    return (typeof payload === 'object' &&
+        payload !== null &&
+        ENVELOPE_TAG in payload);
+}
+export class PhotoshopScriptError extends Error {
+    psErrorNumber;
+    psLine;
+    constructor(message, psErrorNumber = null, psLine = null) {
+        super(message);
+        this.name = 'PhotoshopScriptError';
+        this.psErrorNumber = psErrorNumber;
+        this.psLine = psLine;
+    }
+}
+function asNumberOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+export function decodeScriptResult(raw) {
+    const payload = raw.trim();
+    if (payload.startsWith(TRANSPORT_FAILURE_MARKER)) {
+        throw new PhotoshopScriptError(payload.slice(TRANSPORT_FAILURE_MARKER.length).trim());
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        return payload;
+    }
+    if (!isEnvelope(parsed))
+        return parsed;
+    if (parsed.ok)
+        return parsed.value;
+    const detail = parsed.error ?? {};
+    throw new PhotoshopScriptError(typeof detail.message === 'string' ? detail.message : '', asNumberOrNull(detail.number), asNumberOrNull(detail.line));
+}

package/dist/platform/windows-detector.js

@@ -4,48 +4,42 @@ import { access, constants } from 'fs/promises';
 import { Logger } from '../utils/logger.js';
 const execAsync = promisify(exec);
 export class WindowsDetector {
-    logger;
-    constructor() {
-        this.logger = new Logger('WindowsDetector');
-    }
+    logger = new Logger('WindowsDetector');
     async detect() {
-        this.logger.info('Detecting Photoshop on Windows...');
-        const envPath = process.env.PHOTOSHOP_PATH;
-        if (envPath) {
-            this.logger.debug(`Using environment variable: ${envPath}`);
-            const info = await this.checkPath(envPath);
+        this.logger.info('Looking for a Photoshop install on Windows');
+        const override = process.env.PHOTOSHOP_PATH;
+        if (override) {
+            this.logger.debug('Trying PHOTOSHOP_PATH override', override);
+            const info = await this.inspectPath(override);
             if (info)
                 return info;
         }
         try {
-            const registryInfo = await this.detectFromRegistry();
-            if (registryInfo)
-                return registryInfo;
+            const fromRegistry = await this.findViaRegistry();
+            if (fromRegistry)
+                return fromRegistry;
         }
         catch (error) {
-            this.logger.warn('Registry detection failed:', error);
-        }
-        const commonPaths = this.getCommonPaths();
-        for (const path of commonPaths) {
-            const info = await this.checkPath(path);
-            if (info)
-                return info;
+            this.logger.warn('Registry lookup did not resolve an install', error);
         }
-        throw new Error('Photoshop not found on this system');
+        const fromConventionalPaths = await this.probeCandidates(this.conventionalPaths());
+        if (fromConventionalPaths)
+            return fromConventionalPaths;
+        throw new Error('No Photoshop install could be found on this machine');
     }
-    async detectFromRegistry() {
+    async findViaRegistry() {
         try {
-            const registryPaths = [
+            const productKeys = [
                 'HKLM\\SOFTWARE\\Adobe\\Photoshop',
                 'HKLM\\SOFTWARE\\WOW6432Node\\Adobe\\Photoshop',
             ];
-            for (const regPath of registryPaths) {
+            for (const key of productKeys) {
                 try {
-                    const { stdout } = await execAsync(`reg query "${regPath}" /s`);
-                    const entries = this.parseRegistryOutput(stdout);
+                    const { stdout } = await execAsync(`reg query "${key}" /s`);
+                    const entries = this.readRegistryEntries(stdout);
                     if (entries.length > 0) {
-                        const latest = entries.sort((a, b) => b.version.localeCompare(a.version))[0];
-                        const info = await this.checkPath(latest.path);
+                        const newest = entries.sort((a, b) => b.version.localeCompare(a.version))[0];
+                        const info = await this.inspectPath(newest.path);
                         if (info)
                             return info;
                     }
@@ -54,16 +48,16 @@ export class WindowsDetector {
                     continue;
                 }
             }
-            const clsidPaths = [
+            const comRegistrations = [
                 'HKCR\\CLSID\\{06870682-6f3c-4b97-9143-f03e85c0bd3e}\\LocalServer32',
                 'HKCR\\Wow6432Node\\CLSID\\{06870682-6f3c-4b97-9143-f03e85c0bd3e}\\LocalServer32',
             ];
-            for (const clsidPath of clsidPaths) {
+            for (const key of comRegistrations) {
                 try {
-                    const { stdout } = await execAsync(`reg query "${clsidPath}" /ve`);
-                    const exePath = this.extractPathFromCLSID(stdout);
+                    const { stdout } = await execAsync(`reg query "${key}" /ve`);
+                    const exePath = this.readComServerPath(stdout);
                     if (exePath) {
-                        const info = await this.checkPath(exePath);
+                        const info = await this.inspectPath(exePath);
                         if (info)
                             return info;
                     }
@@ -74,82 +68,71 @@ export class WindowsDetector {
             }
         }
         catch (err) {
-            this.logger.error('Registry query failed:', err);
+            this.logger.error('Registry query failed outright', err);
         }
         return null;
     }
-    parseRegistryOutput(output) {
+    readRegistryEntries(output) {
         const entries = [];
-        const lines = output.split('\n');
         let currentVersion = '';
-        for (const line of lines) {
+        for (const line of output.split('\n')) {
             const versionMatch = line.match(/Photoshop\\(\d+\.\d+)/);
             if (versionMatch) {
                 currentVersion = versionMatch[1];
             }
             const pathMatch = line.match(/ApplicationPath\s+REG_SZ\s+(.+)/);
             if (pathMatch && currentVersion) {
-                entries.push({
-                    version: currentVersion,
-                    path: pathMatch[1].trim(),
-                });
+                entries.push({ version: currentVersion, path: pathMatch[1].trim() });
             }
         }
         return entries;
     }
-    extractPathFromCLSID(output) {
+    readComServerPath(output) {
         const match = output.match(/REG_SZ\s+"?(.+?\.exe)"?/i);
         if (!match)
             return null;
         return match[1].trim();
     }
-    getCommonPaths() {
+    conventionalPaths() {
         const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
         const programFilesX86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)';
         const paths = [];
-        for (let year = 2025; year >= 2012; year--) {
+        const newestYear = Math.max(new Date().getFullYear() + 1, 2026);
+        for (let year = newestYear; year >= 2012; year--) {
             paths.push(`${programFiles}\\Adobe\\Adobe Photoshop ${year}\\Photoshop.exe`, `${programFilesX86}\\Adobe\\Adobe Photoshop ${year}\\Photoshop.exe`, `${programFiles}\\Adobe\\Adobe Photoshop CC ${year}\\Photoshop.exe`, `${programFilesX86}\\Adobe\\Adobe Photoshop CC ${year}\\Photoshop.exe`);
         }
         paths.push(`${programFiles}\\Adobe\\Adobe Photoshop CC\\Photoshop.exe`, `${programFiles}\\Adobe\\Photoshop CC\\Photoshop.exe`);
         return paths;
     }
-    async checkPath(path) {
+    async probeCandidates(candidates) {
+        const results = await Promise.all(candidates.map((path) => this.inspectPath(path)));
+        const selected = results.find((result) => result !== null) ?? null;
+        if (selected) {
+            this.logger.info('Using Photoshop at', selected.path);
+        }
+        return selected;
+    }
+    async inspectPath(path) {
         try {
             let cleanPath = path.trim().replace(/^"|"$/g, '');
             if (!cleanPath.toLowerCase().endsWith('.exe')) {
-                cleanPath = `${cleanPath}\\Photoshop.exe`;
+                cleanPath = `${cleanPath.replace(/[\\/]+$/, '')}\\Photoshop.exe`;
             }
             await access(cleanPath, constants.F_OK);
-            const version = this.extractVersionFromPath(cleanPath);
-            this.logger.info(`Found Photoshop at: ${cleanPath}`);
-            return {
-                version,
-                path: cleanPath,
-                isRunning: await this.checkIfRunning(),
-            };
+            this.logger.debug('Candidate install exists', cleanPath);
+            return { version: this.readVersionFromPath(cleanPath), path: cleanPath };
         }
         catch {
             return null;
         }
     }
-    extractVersionFromPath(path) {
+    readVersionFromPath(path) {
         const yearMatch = path.match(/(\d{4})/);
-        if (yearMatch) {
+        if (yearMatch)
             return yearMatch[1];
-        }
         const versionMatch = path.match(/(\d+\.\d+)/);
-        if (versionMatch) {
+        if (versionMatch)
             return versionMatch[1];
-        }
         return 'Unknown';
     }
-    async checkIfRunning() {
-        try {
-            const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Photoshop.exe"');
-            return stdout.toLowerCase().includes('photoshop.exe');
-        }
-        catch {
-            return false;
-        }
-    }
 }

package/dist/platform/windows-runner.js

@@ -0,0 +1,84 @@
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import { Logger } from '../utils/logger.js';
+import { TempDir } from '../utils/temp.js';
+import { ScriptQueue } from './script-queue.js';
+import { runChildWithTimeout } from './run-child.js';
+import { decodeScriptResult } from './script-result.js';
+const execAsync = promisify(exec);
+const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
+const LAUNCH_GRACE_MS = 5_000;
+export class WindowsScriptRunner {
+    logger = new Logger('WindowsScriptRunner');
+    queue = new ScriptQueue(this.logger);
+    async run(script, timeoutMs = DEFAULT_SCRIPT_TIMEOUT_MS) {
+        return this.queue.enqueue(() => this.runOnce(script, timeoutMs), timeoutMs);
+    }
+    async runOnce(script, timeoutMs) {
+        const dir = await TempDir.create('editmamei-win-');
+        try {
+            const scriptPath = await dir.write('script.jsx', script);
+            const shimPath = await dir.write('run.vbs', this.buildComShim(scriptPath));
+            const { stdout, stderr } = await runChildWithTimeout('cscript', ['//nologo', shimPath], {
+                timeout: timeoutMs,
+                diagLabel: 'cscript run.vbs',
+            });
+            if (stderr) {
+                this.logger.warn('Script execution reported a warning', stderr);
+            }
+            return decodeScriptResult(stdout);
+        }
+        finally {
+            await dir.cleanup();
+        }
+    }
+    buildComShim(scriptPath) {
+        if (scriptPath.includes('"')) {
+            throw new Error('Refusing to compose the COM shim: script path contains a double quote');
+        }
+        return `
+On Error Resume Next
+Dim ps
+Set ps = CreateObject("Photoshop.Application")
+
+If Err.Number <> 0 Then
+    WScript.Echo "ERROR: could not attach to Photoshop over COM - " & Err.Description
+    WScript.Quit 1
+End If
+
+Dim scriptResult
+scriptResult = ps.DoJavaScript("$.evalFile(""" & Replace("${scriptPath}", "\\", "\\\\") & """);")
+
+If Err.Number <> 0 Then
+    WScript.Echo "ERROR: " & Err.Description
+    WScript.Quit 1
+Else
+    WScript.Echo scriptResult
+End If
+`.trim();
+    }
+    async isRunning() {
+        try {
+            const { stdout } = await execAsync('tasklist /FI "IMAGENAME eq Photoshop.exe"');
+            return stdout.toLowerCase().includes('photoshop.exe');
+        }
+        catch {
+            return false;
+        }
+    }
+    async launch(executablePath) {
+        return new Promise((resolve, reject) => {
+            this.logger.info('Launching Photoshop', executablePath);
+            const child = spawn(executablePath, [], { detached: true, stdio: 'ignore' });
+            child.unref();
+            const grace = setTimeout(() => {
+                grace.unref();
+                resolve();
+            }, LAUNCH_GRACE_MS);
+            child.on('error', (error) => {
+                clearTimeout(grace);
+                reject(new Error(`Could not launch Photoshop at ${executablePath}: ${error.message}`));
+            });
+        });
+    }
+}