editmamei 0.22.4 → 0.24.1

package/dist/perception/select-recipes.js

@@ -1,7 +1,7 @@
 import { runScript } from '../utils/run-script.js';
 import { jsNum } from '../utils/jsx.js';
 import { getContextInfo, getSelectionInfo } from '../api/extendscript/_helpers.js';
-import { computeSkyMaskFromJpeg } from './sky-ground-flood.js';
+import { computeSkyMask } from './sky-ground-flood.js';
 import { loadSkyMaskAsSelection } from './sky-mask-transfer.js';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('select-recipes');
@@ -63,8 +63,7 @@ function sceneCtx(model) {
         indoorObjectCount,
     };
 }
-async function measureAndScore(connection, model, kind, composition) {
-    const info = await measure(connection);
+function scoreInfo(info, model, kind, composition) {
     const signals = buildRegionSignals({
         has_selection: info.has_selection,
         bounds: info.bounds ?? null,
@@ -72,7 +71,11 @@ async function measureAndScore(connection, model, kind, composition) {
         edge_complexity: info.edge_complexity,
         bounds_fill_ratio: info.bounds_fill_ratio,
     }, sceneCtx(model));
-    return { info, score: scoreRegion(kind, signals, composition) };
+    return scoreRegion(kind, signals, composition);
+}
+async function measureAndScore(connection, model, kind, composition) {
+    const info = await measure(connection);
+    return { info, score: scoreInfo(info, model, kind, composition) };
 }
 async function deselect(connection, snippet) {
     try {
@@ -98,13 +101,14 @@ async function gateResult(connection, snippet, target, method, info, score, deta
 async function bestOf(connection, snippet, model, kind, composition, target, candidates, detail = {}) {
     let winner = null;
     for (const c of candidates) {
+        let info;
         try {
-            await c.produce();
+            info = await c.produce();
         }
         catch {
             continue;
         }
-        const { score } = await measureAndScore(connection, model, kind, composition);
+        const score = scoreInfo(info, model, kind, composition);
         if (!winner || score.confidence > winner.confidence)
             winner = { c, confidence: score.confidence };
     }
@@ -119,14 +123,15 @@ async function bestOf(connection, snippet, model, kind, composition, target, can
             detail,
         };
     }
-    await winner.c.produce();
-    const { info, score } = await measureAndScore(connection, model, kind, composition);
+    const info = await winner.c.produce();
+    const score = scoreInfo(info, model, kind, composition);
     return gateResult(connection, snippet, target, winner.c.method, info, score, detail);
 }
 function thresholdSkyScript(level, seedX, seedY) {
     return `
     // __mcp_scene_thr__ region-select glue
     ${getContextInfo}
+    ${getSelectionInfo}
     function cTID(s){ return app.charIDToTypeID(s); }
     function sTID(s){ return app.stringIDToTypeID(s); }
     if (app.documents.length === 0) { throw new Error('No active document'); }
@@ -155,13 +160,14 @@ function thresholdSkyScript(level, seedX, seedY) {
     __wand.putBoolean(cTID('Mrgd'), true);
     app.executeAction(cTID('setd'), __wand, DialogModes.NO);
     try { __adj.remove(); } catch (eRm) {}
-    return { ok: true };
+    return getSelectionInfo();
   `;
 }
 function posterizeRegionScript(seedX, seedY) {
     return `
     // __mcp_scene_pst__ region-select glue
     ${getContextInfo}
+    ${getSelectionInfo}
     function cTID(s){ return app.charIDToTypeID(s); }
     function sTID(s){ return app.stringIDToTypeID(s); }
     if (app.documents.length === 0) { throw new Error('No active document'); }
@@ -190,7 +196,7 @@ function posterizeRegionScript(seedX, seedY) {
     __wand.putBoolean(cTID('Mrgd'), true);
     app.executeAction(cTID('setd'), __wand, DialogModes.NO);
     try { __adj.remove(); } catch (eRm) {}
-    return { ok: true };
+    return getSelectionInfo();
   `;
 }
 function skySeed(model) {
@@ -226,17 +232,16 @@ export async function resolveSelection(connection, snippet, model, target, opts
             throw new Error(`Unknown select-by-reference target: ${String(target)}`);
     }
 }
-async function produceThresholdSky(connection, model) {
+async function deriveAndMeasureThresholdSky(connection, model) {
     const skyRecipe = model.regions.find((r) => r.kind === 'sky');
     const level = skyRecipe && skyRecipe.recipe.kind === 'threshold_white' ? skyRecipe.recipe.level : 128;
     const seed = skySeed(model);
-    await runScript(connection, thresholdSkyScript(level, seed.x, seed.y));
-    return { level, seed };
+    return (await runScript(connection, thresholdSkyScript(level, seed.x, seed.y)));
 }
 async function resolveSky(connection, snippet, model, composition, skyCtx) {
-    if (skyCtx) {
+    if (skyCtx?.decoded) {
         try {
-            const { mask, width, height } = computeSkyMaskFromJpeg(skyCtx.exportBytes, skyCtx.boxes);
+            const { mask, width, height } = computeSkyMask(skyCtx.decoded.data, skyCtx.decoded.width, skyCtx.decoded.height, skyCtx.boxes);
             await loadSkyMaskAsSelection(connection, mask, width, height, skyCtx.docW, skyCtx.docH);
             const { info, score } = await measureAndScore(connection, model, 'sky', composition);
             if (score.passed) {
@@ -250,45 +255,59 @@ async function resolveSky(connection, snippet, model, composition, skyCtx) {
     return bestOf(connection, snippet, model, 'sky', composition, 'sky', [
         {
             method: 'threshold_white',
-            produce: async () => {
-                await produceThresholdSky(connection, model);
-            },
+            produce: () => deriveAndMeasureThresholdSky(connection, model),
         },
         {
             method: 'sensei_select_sky',
             produce: async () => {
                 await runScript(connection, await snippet.build('selectSky', { sampleAllLayers: true, selectionType: 'replace' }));
+                return measure(connection);
             },
         },
     ]);
 }
 async function resolveGround(connection, snippet, model, composition) {
-    await produceThresholdSky(connection, model);
-    const sky = await measureAndScore(connection, model, 'sky', composition);
-    if (!sky.score.passed) {
+    const skyInfo = await deriveAndMeasureThresholdSky(connection, model);
+    const skyScore = scoreInfo(skyInfo, model, 'sky', composition);
+    if (!skyScore.passed) {
         await deselect(connection, snippet);
         return {
             target: 'ground',
             method: 'invert_sky_minus_subjects',
             passed: false,
             confidence: 0,
-            reasons: ['no confident sky to invert', ...sky.score.reasons],
+            reasons: ['no confident sky to invert', ...skyScore.reasons],
             detail: { note: 'ground = invert(confident sky) − subjects; no confident sky found' },
         };
     }
-    await runScript(connection, await snippet.build('invertSelection'));
-    for (const s of model.subjects) {
-        const [l, t, r, b] = s.bbox;
-        await runScript(connection, await snippet.build('selectRectangle', {
-            left: l,
-            top: t,
-            right: r,
-            bottom: b,
-            featherPx: 0,
-            selectionType: 'subtract',
-        }));
+    const [invertScript, ...subtractScripts] = await Promise.all([
+        snippet.build('invertSelection'),
+        ...model.subjects.map((s) => {
+            const [l, t, r, b] = s.bbox;
+            return snippet.build('selectRectangle', {
+                left: l,
+                top: t,
+                right: r,
+                bottom: b,
+                featherPx: 0,
+                selectionType: 'subtract',
+            });
+        }),
+    ]);
+    await runScript(connection, invertScript);
+    let lastResult;
+    for (const script of subtractScripts) {
+        lastResult = (await runScript(connection, script));
+    }
+    let info;
+    let score;
+    if (lastResult?.selection_info) {
+        info = lastResult.selection_info;
+        score = scoreInfo(info, model, 'ground', composition);
+    }
+    else {
+        ({ info, score } = await measureAndScore(connection, model, 'ground', composition));
     }
-    const { info, score } = await measureAndScore(connection, model, 'ground', composition);
     return gateResult(connection, snippet, 'ground', 'invert_sky_minus_subjects', info, score, {
         subjects_subtracted: model.subjects.length,
     });
@@ -296,44 +315,64 @@ async function resolveGround(connection, snippet, model, composition) {
 async function resolveFoliage(connection, snippet, model, composition) {
     const seedX = Math.round(model.doc.width / 2);
     const seedY = Math.round(model.doc.height * 0.8);
-    await runScript(connection, posterizeRegionScript(seedX, seedY));
-    const { info, score } = await measureAndScore(connection, model, 'foliage', composition);
+    const info = (await runScript(connection, posterizeRegionScript(seedX, seedY)));
+    const score = scoreInfo(info, model, 'foliage', composition);
     return gateResult(connection, snippet, 'foliage', 'posterize_region', info, score, {
         seed: { x: seedX, y: seedY },
     });
 }
 async function resolveLuminance(connection, snippet, model, band, composition) {
-    await runScript(connection, await snippet.build('selectLuminanceRange', {
+    const result = (await runScript(connection, await snippet.build('selectLuminanceRange', {
         mode: band,
         fuzziness: 40,
         selectionType: 'replace',
-    }));
-    const { info, score } = await measureAndScore(connection, model, band, composition);
+    })));
+    const info = result.selection_info ?? (await measure(connection));
+    const score = scoreInfo(info, model, band, composition);
     return gateResult(connection, snippet, band, 'luminance_range', info, score, { band });
 }
 async function resolveSkin(connection, snippet, model, composition) {
-    await runScript(connection, await snippet.build('selectColorPreset', {
-        preset: 'skin_tones',
-        fuzziness: 40,
-        useFaces: false,
-        selectionType: 'replace',
-    }));
     const person = model.subjects.find((s) => s.label === 'person');
     const box = person?.bbox ?? model.faces.find((f) => f.is_primary)?.bbox;
-    let intersected = false;
-    if (box) {
-        const [l, t, r, b] = box;
-        await runScript(connection, await snippet.build('selectRectangle', {
-            left: l,
-            top: t,
-            right: r,
-            bottom: b,
-            featherPx: 0,
-            selectionType: 'intersect',
-        }));
-        intersected = true;
+    if (!box) {
+        await deselect(connection, snippet);
+        return {
+            target: 'skin',
+            method: 'color_range_skin_∩_box',
+            passed: false,
+            confidence: 0,
+            reasons: [
+                'no person or face detected — skin-tone colour alone cannot tell skin from ' +
+                    'any other warm subject (tungsten light, wood, amber signage), so nothing was selected',
+            ],
+            detail: { intersected_with_box: false, no_person_or_face: true },
+        };
+    }
+    const [colorPresetScript, intersectScript] = await Promise.all([
+        snippet.build('selectColorPreset', {
+            preset: 'skin_tones',
+            fuzziness: 40,
+            useFaces: false,
+            selectionType: 'replace',
+        }),
+        box
+            ? snippet.build('selectRectangle', {
+                left: box[0],
+                top: box[1],
+                right: box[2],
+                bottom: box[3],
+                featherPx: 0,
+                selectionType: 'intersect',
+            })
+            : Promise.resolve(undefined),
+    ]);
+    let lastResult = (await runScript(connection, colorPresetScript));
+    const intersected = intersectScript !== undefined;
+    if (intersectScript !== undefined) {
+        lastResult = (await runScript(connection, intersectScript));
     }
-    const { info, score } = await measureAndScore(connection, model, 'skin', composition);
+    const info = lastResult.selection_info ?? (await measure(connection));
+    const score = scoreInfo(info, model, 'skin', composition);
     return gateResult(connection, snippet, 'skin', 'color_range_skin_∩_box', info, score, {
         intersected_with_box: intersected,
     });
@@ -368,8 +407,8 @@ async function resolveSubject(connection, snippet, model, opts) {
     }
     const cx = Math.round((box.bbox[0] + box.bbox[2]) / 2);
     const cy = Math.round((box.bbox[1] + box.bbox[3]) / 2);
-    await runScript(connection, posterizeRegionScript(cx, cy));
-    const { info, score } = await measureAndScore(connection, model, 'subject', opts.composition);
+    const info = (await runScript(connection, posterizeRegionScript(cx, cy)));
+    const score = scoreInfo(info, model, 'subject', opts.composition);
     return gateResult(connection, snippet, 'subject', 'box_posterize_wand', info, score, {
         label: box.label,
         box: box.bbox,
@@ -397,7 +436,7 @@ async function resolveFace(connection, snippet, model, opts) {
     }
     const [l, t, r2, b] = face.bbox;
     const feather = Math.max(4, Math.round(Math.min(r2 - l, b - t) * 0.08));
-    await runScript(connection, await snippet.build('selectEllipse', {
+    const result = (await runScript(connection, await snippet.build('selectEllipse', {
         left: l,
         top: t,
         right: r2,
@@ -405,8 +444,9 @@ async function resolveFace(connection, snippet, model, opts) {
         featherPx: feather,
         antiAlias: true,
         selectionType: 'replace',
-    }));
-    const { info, score } = await measureAndScore(connection, model, 'face', opts.composition);
+    })));
+    const info = result.selection_info ?? (await measure(connection));
+    const score = scoreInfo(info, model, 'face', opts.composition);
     return gateResult(connection, snippet, 'face', 'face_box_ellipse', info, score, {
         box: face.bbox,
         feather,
@@ -451,15 +491,16 @@ async function resolveFaceFeature(connection, snippet, target, feature, opts) {
 }
 async function resolveAboveHorizon(connection, snippet, model, composition) {
     const y = Math.max(1, Math.min(model.doc.height, model.horizon.y));
-    await runScript(connection, await snippet.build('selectRectangle', {
+    const result = (await runScript(connection, await snippet.build('selectRectangle', {
         left: 0,
         top: 0,
         right: model.doc.width,
         bottom: y,
         featherPx: Math.max(2, Math.round(model.doc.height * 0.01)),
         selectionType: 'replace',
-    }));
-    const { info, score } = await measureAndScore(connection, model, 'above_horizon', composition);
+    })));
+    const info = result.selection_info ?? (await measure(connection));
+    const score = scoreInfo(info, model, 'above_horizon', composition);
     return gateResult(connection, snippet, 'above_horizon', 'rectangle_to_horizon', info, score, {
         horizon_y: y,
     });

package/dist/perception/sky-ground-flood.js

@@ -1,4 +1,3 @@
-import { decode } from 'jpeg-js';
 const GREEN_SCALE = 35;
 const DARK_LUM = 60;
 const DARK_SCALE = 45;
@@ -79,10 +78,6 @@ export function computeSkyMask(rgba, srcW, srcH, boxes, opts = {}) {
     const finalMask = close(mask, W, H, CLOSE_R);
     return { mask: finalMask, width: W, height: H };
 }
-export function computeSkyMaskFromJpeg(jpegBytes, boxes, opts = {}) {
-    const img = decode(jpegBytes, { useTArray: true, formatAsRGBA: true });
-    return computeSkyMask(img.data, img.width, img.height, boxes, opts);
-}
 function rasterizeBoxes(boxes, W, H, F) {
     const m = new Uint8Array(W * H);
     for (const b of boxes) {

package/dist/perception/sky-mask-transfer.js

@@ -1,19 +1,69 @@
 import * as fs from 'node:fs/promises';
-import { encode } from 'jpeg-js';
 import { runScript } from '../utils/run-script.js';
 import { TempDir, userOwnedTempRoot } from '../utils/temp.js';
 import { getContextInfo } from '../api/extendscript/_helpers.js';
 import { jsLit, jsNum } from '../utils/jsx.js';
-function encodeMaskJpeg(mask, w, h) {
-    const rgba = Buffer.alloc(w * h * 4);
-    for (let i = 0; i < w * h; i++) {
-        const v = mask[i] ? 255 : 0;
-        rgba[i * 4] = v;
-        rgba[i * 4 + 1] = v;
-        rgba[i * 4 + 2] = v;
-        rgba[i * 4 + 3] = 255;
+const BMP_FILE_HEADER_SIZE = 14;
+const BMP_INFO_HEADER_SIZE = 40;
+const BMP_PALETTE_ENTRIES = 256;
+const BMP_PALETTE_SIZE = BMP_PALETTE_ENTRIES * 4;
+const BMP_PIXEL_OFFSET = BMP_FILE_HEADER_SIZE + BMP_INFO_HEADER_SIZE + BMP_PALETTE_SIZE;
+export function encodeMaskBmp(mask, w, h) {
+    if (!Number.isInteger(w) || !Number.isInteger(h) || w <= 0 || h <= 0) {
+        throw new Error(`encodeMaskBmp: w/h must be positive integers (got w=${w}, h=${h})`);
     }
-    return encode({ data: rgba, width: w, height: h }, 92).data;
+    if (mask.length < w * h) {
+        throw new Error(`encodeMaskBmp: mask.length (${mask.length}) is smaller than w*h (${w * h}) — refusing to silently encode the missing tail as black`);
+    }
+    const rowSize = (w + 3) & ~3;
+    const pixelArraySize = rowSize * h;
+    const fileSize = BMP_PIXEL_OFFSET + pixelArraySize;
+    const buf = Buffer.alloc(fileSize);
+    let o = 0;
+    buf.write('BM', o, 'ascii');
+    o += 2;
+    buf.writeUInt32LE(fileSize, o);
+    o += 4;
+    buf.writeUInt32LE(0, o);
+    o += 4;
+    buf.writeUInt32LE(BMP_PIXEL_OFFSET, o);
+    o += 4;
+    buf.writeUInt32LE(BMP_INFO_HEADER_SIZE, o);
+    o += 4;
+    buf.writeInt32LE(w, o);
+    o += 4;
+    buf.writeInt32LE(h, o);
+    o += 4;
+    buf.writeUInt16LE(1, o);
+    o += 2;
+    buf.writeUInt16LE(8, o);
+    o += 2;
+    buf.writeUInt32LE(0, o);
+    o += 4;
+    buf.writeUInt32LE(pixelArraySize, o);
+    o += 4;
+    buf.writeInt32LE(0, o);
+    o += 4;
+    buf.writeInt32LE(0, o);
+    o += 4;
+    buf.writeUInt32LE(BMP_PALETTE_ENTRIES, o);
+    o += 4;
+    buf.writeUInt32LE(0, o);
+    o += 4;
+    for (let i = 0; i < BMP_PALETTE_ENTRIES; i++) {
+        buf[o++] = i;
+        buf[o++] = i;
+        buf[o++] = i;
+        buf[o++] = 0;
+    }
+    for (let y = 0; y < h; y++) {
+        const srcRow = h - 1 - y;
+        const rowStart = BMP_PIXEL_OFFSET + y * rowSize;
+        for (let x = 0; x < w; x++) {
+            buf[rowStart + x] = mask[srcRow * w + x] ? 255 : 0;
+        }
+    }
+    return buf;
 }
 function buildLoadScript(maskPath, docW, docH, selType) {
     return `
@@ -50,6 +100,15 @@ function buildLoadScript(maskPath, docW, docH, selType) {
     // Bring the upscaled mask onto the clipboard, then paste it INTO a fresh full-canvas
     // alpha channel on the original (selectAll + paste-into keeps it aligned to canvas).
     var maskDoc = app.open(new File(${jsLit(maskPath)}));
+    // TRAP: encodeMaskBmp writes an 8bpp PALETTIZED bitmap (a 256-entry grayscale
+    // palette over indexed pixel data — see sky-mask-transfer.ts's encodeMaskBmp),
+    // so Photoshop opens this file in INDEXED COLOR mode, not Grayscale. In Indexed
+    // Color, resizeImage's ResampleMethod argument is silently IGNORED — there is no
+    // palette-space bicubic — so the upscale below would degrade to nearest-neighbor
+    // and hard-edge the sky/SAM selection despite asking for BICUBIC. Indexed →
+    // Grayscale is a legal direct conversion (no intermediate RGB round trip needed)
+    // and must happen BEFORE resizeImage for the requested resample method to apply.
+    maskDoc.changeMode(ChangeMode.GRAYSCALE);
     maskDoc.resizeImage(
       UnitValue(${jsNum(docW, 1)}, 'px'),
       UnitValue(${jsNum(docH, 1)}, 'px'),
@@ -93,13 +152,13 @@ const SELECTION_TYPE_ENUM = {
     intersect: 'INTERSECT',
 };
 export async function loadMaskAsSelection(connection, mask, maskW, maskH, docW, docH, selectionType = 'replace') {
-    const jpg = encodeMaskJpeg(mask, maskW, maskH);
+    const bmp = encodeMaskBmp(mask, maskW, maskH);
     const dir = process.platform === 'darwin'
         ? await TempDir.createWithRoot(userOwnedTempRoot(), 'editmamei-mask-')
         : await TempDir.create('editmamei-mask-');
     try {
-        const maskPath = dir.path('mask.jpg');
-        await fs.writeFile(maskPath, jpg);
+        const maskPath = dir.path('mask.bmp');
+        await fs.writeFile(maskPath, bmp);
         await runScript(connection, buildLoadScript(maskPath, docW, docH, SELECTION_TYPE_ENUM[selectionType]));
     }
     finally {

package/dist/platform/connection.js

@@ -3,20 +3,25 @@ import { Logger } from '../utils/logger.js';
 import { PhotoshopDetector } from './detector.js';
 import { WindowsExecutor } from './windows-executor.js';
 import { MacOSExecutor } from './macos-executor.js';
-function truncateForLog(s, maxLen) {
+export function truncateForLog(s, maxLen) {
     if (s.length <= maxLen)
         return s;
     return `${s.slice(0, maxLen)}…[+${s.length - maxLen} chars]`;
 }
+export const RUNNING_LATCH_TTL_MS = 30_000;
 export class PhotoshopConnection {
     logger;
     detector;
     executor;
     photoshopInfo = null;
+    detectInFlight = null;
     macosExecutor;
-    constructor() {
+    now;
+    runningLatchUntil = 0;
+    constructor(opts = {}) {
         this.logger = new Logger('PhotoshopConnection');
         this.detector = new PhotoshopDetector();
+        this.now = opts.now ?? Date.now;
         const platformType = platform();
         if (platformType === 'win32') {
             this.executor = new WindowsExecutor();
@@ -40,11 +45,26 @@ export class PhotoshopConnection {
             return false;
         }
     }
+    async ensureDetected() {
+        if (this.photoshopInfo)
+            return this.photoshopInfo;
+        if (!this.detectInFlight) {
+            this.detectInFlight = this.detector
+                .detect()
+                .then((info) => {
+                if (info)
+                    this.photoshopInfo = info;
+                return info;
+            })
+                .finally(() => {
+                this.detectInFlight = null;
+            });
+        }
+        return this.detectInFlight;
+    }
     async getVersion() {
         try {
-            if (!this.photoshopInfo) {
-                this.photoshopInfo = await this.detector.detect();
-            }
+            await this.ensureDetected();
             return this.photoshopInfo?.version || 'Unknown';
         }
         catch (error) {
@@ -54,22 +74,33 @@ export class PhotoshopConnection {
     }
     async executeScript(script, timeout) {
         try {
+            await this.ensureDetected();
             if (!this.photoshopInfo) {
-                this.photoshopInfo = await this.detector.detect();
+                throw new Error('Photoshop info not available — the local install could not be detected. ' +
+                    'Check that Photoshop is installed (set PHOTOSHOP_PATH to override detection).');
             }
             if (this.macosExecutor && this.photoshopInfo.appName) {
                 this.macosExecutor.setAppName(this.photoshopInfo.appName);
             }
-            const isRunning = await this.executor.isPhotoshopRunning();
-            if (!isRunning) {
-                this.logger.info('Photoshop not running, launching...');
-                await this.executor.launchPhotoshop(this.photoshopInfo.path);
+            if (this.now() >= this.runningLatchUntil) {
+                const isRunning = await this.executor.isPhotoshopRunning();
+                if (!isRunning) {
+                    this.logger.info('Photoshop not running, launching...');
+                    await this.executor.launchPhotoshop(this.photoshopInfo.path);
+                }
+                else {
+                    this.runningLatchUntil = this.now() + RUNNING_LATCH_TTL_MS;
+                }
+            }
+            if (this.logger.isDebugEnabled()) {
+                this.logger.debug(`Executing script (${script.length} chars, PS ${this.photoshopInfo.version}, ${platform()}): ${truncateForLog(script, 200)}`);
             }
-            this.logger.debug(`Executing script (${script.length} chars, PS ${this.photoshopInfo.version}, ${platform()}): ${truncateForLog(script, 200)}`);
             const result = await this.executor.execute(script, timeout);
+            this.runningLatchUntil = this.now() + RUNNING_LATCH_TTL_MS;
             return result;
         }
         catch (error) {
+            this.runningLatchUntil = 0;
             const psVersion = this.photoshopInfo?.version ?? 'unknown';
             const head = truncateForLog(script, 200);
             this.logger.error(`Script execution failed (PS ${psVersion}, ${platform()}, ${script.length} chars):`, error, `\n--- script head (200 chars) ---\n${head}`);

package/dist/platform/executor-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/macos-detector.js

@@ -55,7 +55,8 @@ export class MacOSDetector {
     }
     getCommonPaths() {
         const paths = [];
-        for (let year = 2025; year >= 2012; year--) {
+        const maxYear = Math.max(new Date().getFullYear() + 1, 2026);
+        for (let year = maxYear; 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');