editmamei 0.22.4 → 0.24.1

package/dist/tools/channel-compose-tools.js

@@ -1,5 +1,6 @@
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
+import { toolErrorResult, applyToActiveLayerProp } from '../utils/tool-helpers.js';
 const BLEND_MODES = [
     'normal',
     'multiply',
@@ -45,11 +46,7 @@ const applyImageSchema = {
             maximum: 100,
             default: 100,
         },
-        apply_to_active_layer: {
-            type: 'boolean',
-            description: 'If false (default) the composite is baked onto a DUPLICATE of the active layer (original preserved — delete the copy to revert). Set true to bake destructively in place.',
-            default: false,
-        },
+        apply_to_active_layer: applyToActiveLayerProp('the composite'),
     },
     required: ['blend'],
 };
@@ -182,15 +179,7 @@ async function applyImage(connection, snippetClient, rawArgs) {
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error in ps_apply_image: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+        return toolErrorResult('Error in ps_apply_image', error);
     }
 }
 async function calculations(connection, snippetClient, rawArgs) {
@@ -228,14 +217,6 @@ async function calculations(connection, snippetClient, rawArgs) {
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error in ps_calculations: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+        return toolErrorResult('Error in ps_calculations', error);
     }
 }

package/dist/tools/detection-tools.js

@@ -1,7 +1,11 @@
-import { decode, encode } from 'jpeg-js';
+import { encode } from 'jpeg-js';
 import { validateArgs } from '../utils/validate.js';
 import { detectActiveDoc } from '../detection/detect-active-doc.js';
+import { ANNOTATED_PREVIEW_JPEG_QUALITY } from '../utils/jpeg-quality.js';
 import { OnnxDetectionClient, } from '../detection/detection-client.js';
+import { toolErrorResult } from '../utils/tool-helpers.js';
+import { computePixelIdentity, docKeyFrom, samePixelIdentity, } from '../perception/pixel-identity.js';
+import { ANNOTATION_RGB, annotationThickness, drawBoxOutline, } from '../perception/overlay.js';
 const detectSchema = {
     type: 'object',
     properties: {
@@ -46,36 +50,15 @@ const detectSchema = {
         },
     },
 };
-function drawBoxes(bytes, boxes) {
-    const img = decode(bytes, { useTArray: true, formatAsRGBA: true });
-    const { width: w, height: h, data } = img;
-    const thickness = Math.max(2, Math.round(Math.max(w, h) / 400));
-    const setPx = (x, y, r, g, b) => {
-        if (x < 0 || y < 0 || x >= w || y >= h)
-            return;
-        const i = (y * w + x) * 4;
-        data[i] = r;
-        data[i + 1] = g;
-        data[i + 2] = b;
-        data[i + 3] = 255;
-    };
+export function drawBoxes(img, boxes) {
+    const { width: w, height: h } = img;
+    const data = Uint8Array.from(img.data);
+    const out = { data, width: w, height: h };
+    const thickness = annotationThickness(out);
     for (const { bbox, rgb } of boxes) {
-        const x1 = Math.round(bbox[0]);
-        const y1 = Math.round(bbox[1]);
-        const x2 = Math.round(bbox[2]);
-        const y2 = Math.round(bbox[3]);
-        for (let x = x1; x <= x2; x++)
-            for (let k = 0; k < thickness; k++) {
-                setPx(x, y1 + k, rgb[0], rgb[1], rgb[2]);
-                setPx(x, y2 - k, rgb[0], rgb[1], rgb[2]);
-            }
-        for (let y = y1; y <= y2; y++)
-            for (let k = 0; k < thickness; k++) {
-                setPx(x1 + k, y, rgb[0], rgb[1], rgb[2]);
-                setPx(x2 - k, y, rgb[0], rgb[1], rgb[2]);
-            }
+        drawBoxOutline(out, bbox, rgb, thickness);
     }
-    return encode({ data, width: w, height: h }, 88).data;
+    return encode({ data, width: w, height: h }, ANNOTATED_PREVIEW_JPEG_QUALITY).data;
 }
 function summarizeObjects(objects) {
     if (!objects || objects.length === 0)
@@ -85,13 +68,27 @@ function summarizeObjects(objects) {
         counts.set(o.label, (counts.get(o.label) ?? 0) + 1);
     return [...counts.entries()].map(([l, n]) => (n > 1 ? `${l}×${n}` : l)).join(', ');
 }
-async function detect(connection, client, rawArgs) {
+let detectCache = null;
+export function __clearDetectCache() {
+    detectCache = null;
+}
+async function detect(connection, client, rawArgs, detectDeps) {
     try {
         const args = validateArgs(detectSchema, rawArgs);
         const target = args.target ?? 'both';
         const annotate = args.annotate ?? true;
         const wantFaces = target === 'faces' || target === 'both';
         const wantObjects = target === 'objects' || target === 'both';
+        const detectKey = JSON.stringify({
+            faces: wantFaces,
+            objects: wantObjects,
+            maxDimension: args.max_dimension ?? null,
+            faceThreshold: args.face_threshold ?? null,
+            objectThreshold: args.object_threshold ?? null,
+            maxObjects: args.max_objects ?? null,
+        });
+        let hit = null;
+        let pendingIdentity = null;
         const det = await detectActiveDoc(connection, client, {
             faces: wantFaces,
             objects: wantObjects,
@@ -99,22 +96,41 @@ async function detect(connection, client, rawArgs) {
             faceThreshold: args.face_threshold,
             objectThreshold: args.object_threshold,
             maxObjects: args.max_objects,
-        });
-        const mapped = det.result;
+            shouldDetect: ({ decoded, context, docWidth, docHeight }) => {
+                if (!decoded)
+                    return true;
+                const identity = computePixelIdentity(decoded, docKeyFrom(context, docWidth, docHeight));
+                if (detectCache &&
+                    detectCache.optionsKey === detectKey &&
+                    samePixelIdentity(detectCache.identity, identity)) {
+                    hit = detectCache;
+                    return false;
+                }
+                pendingIdentity = identity;
+                return true;
+            },
+        }, detectDeps);
+        const mapped = hit ? hit.result : det.result;
+        const rawDetections = hit ? hit.raw : det.raw;
+        if (!hit && pendingIdentity) {
+            detectCache = {
+                identity: pendingIdentity,
+                optionsKey: detectKey,
+                result: det.result,
+                raw: det.raw,
+            };
+        }
         const content = [];
-        if (annotate) {
+        if (annotate && det.decoded) {
             try {
                 const boxes = [
-                    ...(det.raw.faces ?? []).map((f) => ({
-                        bbox: f.bbox,
-                        rgb: [0, 220, 255],
-                    })),
-                    ...(det.raw.objects ?? []).map((o) => ({
+                    ...(rawDetections.faces ?? []).map((f) => ({ bbox: f.bbox, rgb: ANNOTATION_RGB.face })),
+                    ...(rawDetections.objects ?? []).map((o) => ({
                         bbox: o.bbox,
-                        rgb: [255, 0, 220],
+                        rgb: ANNOTATION_RGB.object,
                     })),
                 ];
-                const annotated = drawBoxes(det.exportBytes, boxes);
+                const annotated = drawBoxes(det.decoded, boxes);
                 content.push({
                     type: 'image',
                     data: annotated.toString('base64'),
@@ -150,14 +166,10 @@ async function detect(connection, client, rawArgs) {
         };
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error during detection: ${msg}` }],
-            isError: true,
-        };
+        return toolErrorResult('Error during detection', error);
     }
 }
-export function createDetectionTools(connection, _snippetClient, client = new OnnxDetectionClient()) {
+export function createDetectionTools(connection, _snippetClient, client = new OnnxDetectionClient(), detectDeps) {
     return [
         {
             tool: {
@@ -203,7 +215,7 @@ export function createDetectionTools(connection, _snippetClient, client = new On
                     idempotentHint: true,
                 },
             },
-            handler: async (args) => detect(connection, client, args),
+            handler: async (args) => detect(connection, client, args, detectDeps),
         },
     ];
 }

package/dist/tools/document-tools.js

@@ -1,5 +1,10 @@
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
+import { OPEN_DOCUMENT_TIMEOUT_MS, OPEN_DOCUMENT_REPROBE_TIMEOUT_MS, } from '../utils/operation-timeouts.js';
+import { toolErrorResult, runSnippetTool } from '../utils/tool-helpers.js';
+import { purgeSceneChannels } from '../perception/region-precompute.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('document-tools');
 const createDocumentSchema = {
     type: 'object',
     properties: {
@@ -68,6 +73,11 @@ const savePsdSchema = {
             description: 'Include flattened composite for compatibility with other apps. Default true.',
             default: true,
         },
+        keep_scene_channels: {
+            type: 'boolean',
+            description: "Keep the managed scene:* alpha channels ps_read_scene precomputes. Default false — they are DERIVED masks (rebuilt by the next scene read) and each is a full-resolution channel, so baking them into the .psd bloats it badly (~51MB per channel on a 51MP document). Set true only if you want the saved file to carry the masks. The result reports scene_channels_purged either way, so it's never silent.",
+            default: false,
+        },
     },
     required: ['output_path'],
 };
@@ -195,7 +205,7 @@ export function createDocumentTools(connection, snippetClient) {
         {
             tool: {
                 name: 'ps_open_document',
-                description: 'Open a file from disk into Photoshop with all dialogs suppressed (uses last-used Camera Raw settings for raw/HEIC). Returns document name, dimensions, color mode, and whether the source was a raw format. Use this in the pipeline to load Inbox files for editing.',
+                description: 'Open a file from disk into Photoshop with all dialogs suppressed (uses last-used Camera Raw settings for raw/HEIC). Returns document name, dimensions, color mode, and whether the source was a raw format. Use this in the pipeline to load Inbox files for editing. If the file is ALREADY open, its existing document is activated rather than opened a second time — `already_open: true` says so, and any edits made to it are still there (Photoshop would otherwise open a duplicate with a fresh Background, which silently strands prior work).',
                 inputSchema: openDocumentSchema,
                 outputSchema: {
                     type: 'object',
@@ -208,6 +218,7 @@ export function createDocumentTools(connection, snippetClient) {
                         color_mode: { type: 'string' },
                         bits_per_channel: { type: 'number' },
                         is_raw_source: { type: 'boolean' },
+                        already_open: { type: 'boolean' },
                         file_path: { type: 'string' },
                         context: { type: 'object' },
                     },
@@ -297,50 +308,34 @@ async function exportImage(connection, snippetClient, rawArgs) {
     }
 }
 async function createDocument(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(createDocumentSchema, rawArgs);
-        const width = args.width;
-        const height = args.height;
-        const resolution = args.resolution;
-        const colorMode = args.color_mode;
-        const colorModeMap = {
-            RGB: 'NewDocumentMode.RGB',
-            CMYK: 'NewDocumentMode.CMYK',
-            Grayscale: 'NewDocumentMode.GRAYSCALE',
-        };
-        const mappedMode = colorModeMap[colorMode];
-        if (!mappedMode) {
-            throw new Error(`colorModeMap missing entry for "${colorMode}" — schema enum and ` +
-                `internal mapping have drifted. Update src/tools/document-tools.ts.`);
-        }
-        const script = await snippetClient.build('newDocument', {
-            width,
-            height,
-            resolution,
-            colorMode: mappedMode,
-        });
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Document created: ${width}x${height}px at ${resolution}dpi (${colorMode})`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error creating document: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: createDocumentSchema,
+        snippet: 'newDocument',
+        errorPrefix: 'Error creating document',
+        params: (args) => {
+            const colorMode = args.color_mode;
+            const colorModeMap = {
+                RGB: 'NewDocumentMode.RGB',
+                CMYK: 'NewDocumentMode.CMYK',
+                Grayscale: 'NewDocumentMode.GRAYSCALE',
+            };
+            const mappedMode = colorModeMap[colorMode];
+            if (!mappedMode) {
+                throw new Error(`colorModeMap missing entry for "${colorMode}" — schema enum and ` +
+                    `internal mapping have drifted. Update src/tools/document-tools.ts.`);
+            }
+            return {
+                width: args.width,
+                height: args.height,
+                resolution: args.resolution,
+                colorMode: mappedMode,
+            };
+        },
+        successText: (_result, args) => `Document created: ${args.width}x${args.height}px at ${args.resolution}dpi (${args.color_mode})`,
+    });
 }
 async function closeDocument(connection, snippetClient, rawArgs) {
     try {
@@ -364,24 +359,30 @@ async function closeDocument(connection, snippetClient, rawArgs) {
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error closing document: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+        return toolErrorResult('Error closing document', error);
+    }
+}
+function isScriptTimeoutError(message) {
+    return /Script execution timeout|AppleEvent timed out|(?:^|[\s(])-1712(?:[\s)]|$)/i.test(message);
+}
+async function reprobeOpenDocument(connection, snippetClient, filePath) {
+    try {
+        const probeScript = await snippetClient.build('probeOpenDocument', { filePath });
+        const result = (await runScript(connection, probeScript, OPEN_DOCUMENT_REPROBE_TIMEOUT_MS));
+        return result.success ? result : null;
+    }
+    catch {
+        return null;
     }
 }
 async function openDocumentPipeline(connection, snippetClient, rawArgs) {
+    let filePath;
     try {
         const args = validateArgs(openDocumentSchema, rawArgs);
-        const filePath = args.file_path;
+        filePath = args.file_path;
         const suppressDialogs = args.suppress_dialogs;
         const script = await snippetClient.build('openDocumentPipeline', { filePath, suppressDialogs });
-        const result = await runScript(connection, script);
+        const result = await runScript(connection, script, OPEN_DOCUMENT_TIMEOUT_MS);
         return {
             content: [
                 {
@@ -393,45 +394,54 @@ async function openDocumentPipeline(connection, snippetClient, rawArgs) {
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error opening document: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+        const message = error instanceof Error ? error.message : String(error);
+        if (filePath !== undefined && isScriptTimeoutError(message)) {
+            const reprobed = await reprobeOpenDocument(connection, snippetClient, filePath);
+            if (reprobed) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Document opened (the open exceeded the ${OPEN_DOCUMENT_TIMEOUT_MS}ms budget and was ` +
+                                `reported as a timeout, but a post-timeout check confirmed it actually completed):\n` +
+                                JSON.stringify(reprobed, null, 2),
+                        },
+                    ],
+                    structuredContent: reprobed,
+                };
+            }
+        }
+        return toolErrorResult('Error opening document', error);
     }
 }
 async function savePsdPipeline(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(savePsdSchema, rawArgs);
-        const outputPath = args.output_path;
-        const maximizeCompat = args.maximize_compatibility;
-        const script = await snippetClient.build('savePsdAsCopy', { outputPath, maximizeCompat });
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `PSD saved:\n${JSON.stringify(result, null, 2)}`,
-                },
-            ],
-            structuredContent: result,
-        };
+    let purged = 0;
+    if (rawArgs.keep_scene_channels !== true) {
+        try {
+            purged = await purgeSceneChannels(connection);
+        }
+        catch (err) {
+            logger.debug(`save_psd: scene-channel purge failed, saving anyway — ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        }
     }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error saving PSD: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+    const res = await runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: savePsdSchema,
+        snippet: 'savePsdAsCopy',
+        errorPrefix: 'Error saving PSD',
+        params: (args) => ({
+            outputPath: args.output_path,
+            maximizeCompat: args.maximize_compatibility,
+        }),
+        successText: (result) => `PSD saved:\n${JSON.stringify(result, null, 2)}`,
+    });
+    if (!res.isError && typeof res.structuredContent === 'object' && res.structuredContent !== null) {
+        res.structuredContent.scene_channels_purged = purged;
     }
+    return res;
 }
 async function exportJpegPipeline(connection, snippetClient, rawArgs) {
     try {
@@ -459,48 +469,28 @@ async function exportJpegPipeline(connection, snippetClient, rawArgs) {
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error exporting JPEG: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+        return toolErrorResult('Error exporting JPEG', error);
     }
 }
 async function exportPngPipeline(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(exportPngSchema, rawArgs);
-        const outputPath = args.output_path;
-        const transparentBg = args.transparent_background;
-        const longEdgePx = args.long_edge_px;
-        const compression = args.compression;
-        const params = { outputPath, transparentBg, compression };
-        if (longEdgePx !== undefined)
-            params.longEdgePx = longEdgePx;
-        const script = await snippetClient.build('exportPngPipeline', params);
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `PNG exported:\n${JSON.stringify(result, null, 2)}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error exporting PNG: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: exportPngSchema,
+        snippet: 'exportPngPipeline',
+        errorPrefix: 'Error exporting PNG',
+        params: (args) => {
+            const longEdgePx = args.long_edge_px;
+            const params = {
+                outputPath: args.output_path,
+                transparentBg: args.transparent_background,
+                compression: args.compression,
+            };
+            if (longEdgePx !== undefined)
+                params.longEdgePx = longEdgePx;
+            return params;
+        },
+        successText: (result) => `PNG exported:\n${JSON.stringify(result, null, 2)}`,
+    });
 }