editmamei 0.24.1 → 1.0.0

package/dist/platform/macos-detector.js

@@ -3,136 +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 = [];
-        const maxYear = Math.max(new Date().getFullYear() + 1, 2026);
-        for (let year = maxYear; 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-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,46 +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);
+            this.logger.warn('Registry lookup did not resolve an install', error);
         }
-        const commonPaths = this.getCommonPaths();
-        const commonPathInfo = await this.checkCommonPaths(commonPaths);
-        if (commonPathInfo)
-            return commonPathInfo;
-        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;
                     }
@@ -52,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;
                     }
@@ -72,91 +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 = [];
-        const maxYear = Math.max(new Date().getFullYear() + 1, 2026);
-        for (let year = maxYear; 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 checkCommonPaths(paths) {
-        const results = await Promise.all(paths.map((path) => this.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(`Found Photoshop at: ${selected.path}`);
+            this.logger.info('Using Photoshop at', selected.path);
         }
         return selected;
     }
-    async checkPath(path) {
+    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.debug(`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}`));
+            });
+        });
+    }
+}

package/dist/tools/adjustment-tools.js

@@ -423,9 +423,24 @@ const addAdjustmentLayerSchema = {
         gm_preset: {
             type: 'string',
             enum: ['black_to_white', 'sepia', 'tint'],
-            description: 'For type=gradient_map. Preset gradient. "black_to_white" is the canonical tonal B&W via gradient. "sepia" is a warm vintage tone. "tint" maps black→tint_color→white using gm_tint_color_hex. Custom gradient stops are not supported in v1 — record an Action for arbitrary gradients.',
+            description: 'For type=gradient_map. Preset gradient. "black_to_white" is the canonical tonal B&W via gradient. "sepia" is a warm vintage tone. "tint" maps black→tint_color→white using gm_tint_color_hex. For arbitrary color mappings pass gm_stops instead (overrides the preset).',
             default: 'black_to_white',
         },
+        gm_stops: {
+            type: 'array',
+            description: 'For type=gradient_map. Custom color stops overriding gm_preset — each {red,green,blue (0-255), location (0-100 shadows→highlights), midpoint (5-95, default 50)}. At least 2; sorted by location. E.g. a blue→orange stylized grade: [{red:20,green:40,blue:120,location:0},{red:250,green:150,blue:50,location:100}].',
+            items: {
+                type: 'object',
+                properties: {
+                    red: { type: 'integer', minimum: 0, maximum: 255 },
+                    green: { type: 'integer', minimum: 0, maximum: 255 },
+                    blue: { type: 'integer', minimum: 0, maximum: 255 },
+                    location: { type: 'number', minimum: 0, maximum: 100 },
+                    midpoint: { type: 'number', minimum: 5, maximum: 95, default: 50 },
+                },
+                required: ['red', 'green', 'blue', 'location'],
+            },
+        },
         gm_tint_color_hex: {
             type: 'string',
             description: 'For type=gradient_map with gm_preset=tint. Mid-tone tint color as a hex string like "#5588CC". Only used when gm_preset=tint.',
@@ -621,7 +636,7 @@ export function createAdjustmentTools(connection, snippetClient) {
         {
             tool: {
                 name: 'ps_apply_adjustment',
-                description: "Apply a DESTRUCTIVE tonal adjustment that Photoshop does NOT offer as an adjustment layer — chosen via `type`. Runs on a DUPLICATE of the active layer by default (auto-duplicate-first per Bundle O — the original is preserved; revert by deleting the copy); pass `apply_to_active_layer: true` to bake in place. Auto-rasterizes text/smart-object layers. `shadows_highlights` recovers blown highlights + crushed shadows in one pass (defaults match Adobe's dialog: 35 shadow amount, +20 color correction); `equalize` stretches/flattens the histogram (parameter-free); `color_lookup` bakes a 3DLUT grade (cl_lut_name required — leaf name of a file in Presets/3DLUTs/ or an absolute .cube/.3dl/.look path). For EDITABLE tonal/color work, prefer ps_add_adjustment_layer.",
+                description: "Apply a DESTRUCTIVE tonal adjustment that Photoshop does NOT offer as an adjustment layer — chosen via `type`. Runs on a DUPLICATE of the active layer by default (auto-duplicate-first — the original is preserved; revert by deleting the copy); pass `apply_to_active_layer: true` to bake in place. Auto-rasterizes text/smart-object layers. `shadows_highlights` recovers blown highlights + crushed shadows in one pass (defaults match Adobe's dialog: 35 shadow amount, +20 color correction); `equalize` stretches/flattens the histogram (parameter-free); `color_lookup` bakes a 3DLUT grade (cl_lut_name required — leaf name of a file in Presets/3DLUTs/ or an absolute .cube/.3dl/.look path). For EDITABLE tonal/color work, prefer ps_add_adjustment_layer.",
                 inputSchema: APPLY_ADJUSTMENT_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
@@ -772,6 +787,7 @@ const FORWARDED_KEYS = new Set([
     'gm_tint_color_hex',
     'gm_reverse',
     'gm_dither',
+    'gm_stops',
     'exp_exposure',
     'exp_offset',
     'exp_gamma',

package/dist/tools/brush-tools.js

@@ -119,7 +119,7 @@ export function createBrushTools(connection, snippetClient, client = new OnnxLan
         {
             tool: {
                 name: 'ps_apply_brush_stroke',
-                description: 'Paint along a path with one of PS\'s 16 brush-family tools — supply the path EITHER as an anchor-relational `placement` (preferred: a path relation → the stroke traces a resolved, gate-verified curve along a traced edge / landmark / between two anchors, no pixel-guessing) OR as an explicit `path` list of anchor points — the retouch tools (`healing_brush`, `clone_stamp`, `burn`, `dodge`, `blur`, `sharpen`, `smudge`), the paint family (`brush`, `pencil`, `eraser`), and the specialty tools (`pattern_stamp`, `art_history_brush`, `history_brush`, `color_replacement`, `background_eraser`, `sponge`). The `path` parameter takes a list of anchor points with optional bezier handles, so the same tool handles straight-line strokes, freeform curves, and closed shapes — all by varying the path geometry. **Reach for this when**: (a) cloning out a distraction along a specific shape (clone_stamp with a source_point + a path tracing the unwanted edge); (b) healing a scratch or seam (healing_brush with source_point); (c) dodging / burning to redirect tonal balance along a contour; (d) painting a freehand line into the canvas (brush + foreground_color). Active layer must be a normal pixel layer (background auto-promotes); rasterize adjustment/shape/text/smart-object layers first. Auto-duplicates per Bundle O — the original is preserved and a "Brush Stroke (<name>)" copy receives the paint. **Brush dynamics**: hardness, opacity, and flow are independently settable via `hardness_pct` / `opacity_pct` / `flow_pct` (the live tool options are mutated before stroking and restored to the user\'s prior state in `finally`). Sampled brushes (custom shape-stamp presets) silently ignore hardness/diameter mutations — vary their character via `brush_preset` instead.',
+                description: 'Paint along a path with one of PS\'s 16 brush-family tools — supply the path EITHER as an anchor-relational `placement` (preferred: a path relation → the stroke traces a resolved, gate-verified curve along a traced edge / landmark / between two anchors, no pixel-guessing) OR as an explicit `path` list of anchor points — the retouch tools (`healing_brush`, `clone_stamp`, `burn`, `dodge`, `blur`, `sharpen`, `smudge`), the paint family (`brush`, `pencil`, `eraser`), and the specialty tools (`pattern_stamp`, `art_history_brush`, `history_brush`, `color_replacement`, `background_eraser`, `sponge`). The `path` parameter takes a list of anchor points with optional bezier handles, so the same tool handles straight-line strokes, freeform curves, and closed shapes — all by varying the path geometry. **Reach for this when**: (a) cloning out a distraction along a specific shape (clone_stamp with a source_point + a path tracing the unwanted edge); (b) healing a scratch or seam (healing_brush with source_point); (c) dodging / burning to redirect tonal balance along a contour; (d) painting a freehand line into the canvas (brush + foreground_color). Active layer must be a normal pixel layer (background auto-promotes); rasterize adjustment/shape/text/smart-object layers first. Auto-duplicates — the original is preserved and a "Brush Stroke (<name>)" copy receives the paint. **Brush dynamics**: hardness, opacity, and flow are independently settable via `hardness_pct` / `opacity_pct` / `flow_pct` (the live tool options are mutated before stroking and restored to the user\'s prior state in `finally`). Sampled brushes (custom shape-stamp presets) silently ignore hardness/diameter mutations — vary their character via `brush_preset` instead.',
                 inputSchema: applyBrushStrokeSchema,
                 outputSchema: {
                     type: 'object',