editmamei 0.23.0 → 1.0.0

package/dist/tools/scene-tools.js

@@ -1,9 +1,17 @@
-import { decode, encode } from 'jpeg-js';
+import { encode } from 'jpeg-js';
 import { validateArgs } from '../utils/validate.js';
 import { OnnxDetectionClient } from '../detection/detection-client.js';
+import { ANNOTATED_PREVIEW_JPEG_QUALITY } from '../utils/jpeg-quality.js';
 import { buildSceneModel } from '../perception/scene-model.js';
 import { resolveSelection, SELECT_REFERENCE_TARGETS, } from '../perception/select-recipes.js';
-import { precomputeRegions, loadPrecomputedRegion, } from '../perception/region-precompute.js';
+import { precomputeRegions, loadPrecomputedRegion, saveSelectionAsSceneChannel, CHANNEL_PREFIX, } from '../perception/region-precompute.js';
+import { toolErrorResult } from '../utils/tool-helpers.js';
+import { Logger } from '../utils/logger.js';
+import { isProEntitled } from '../license/entitlement.js';
+import { EDITION } from '../edition.js';
+import { isToolAllowedInEdition } from '../core/tool-tiers.js';
+import { ANNOTATION_RGB, annotationThickness, drawBoxOutline, drawHLine, } from '../perception/overlay.js';
+const logger = new Logger('scene-tools');
 function makeProRefine(invokeTool) {
     return async (req) => {
         try {
@@ -29,29 +37,31 @@ function makeProRefine(invokeTool) {
         }
     };
 }
-function makePrecomputeFace(invokeTool) {
-    return async () => {
-        try {
-            const res = await invokeTool('ps_select_face_feature', { precompute_all: true });
-            if (res.isError)
-                return [];
-            const saved = res.structuredContent?.saved ?? [];
-            return saved.map((s) => ({
-                key: s.key,
-                target: `face_${s.feature}`,
-                method: 'face_mesh',
-                confidence: 1,
-                bounds: null,
-            }));
-        }
-        catch {
-            return [];
-        }
-    };
+export const FACE_MENU_TARGETS = [
+    'face_skin',
+    'face_eyes',
+    'face_brows',
+    'face_lips',
+    'face_teeth',
+    'face_nose',
+    'face_under_eye',
+    'face_cheeks',
+];
+function faceMenuFor(model, hasPro) {
+    if (!hasPro || model.faces.length === 0)
+        return [];
+    return FACE_MENU_TARGETS.map((target) => ({
+        key: `${CHANNEL_PREFIX}${target}`,
+        target,
+        method: 'face_mesh',
+        confidence: 1,
+        bounds: null,
+        on_demand: true,
+    }));
 }
 function skyCtxFrom(built) {
     return {
-        exportBytes: built.exportBytes,
+        decoded: built.decoded,
         boxes: built.rawObjects.map((o) => o.bbox),
         docW: built.model.doc.width,
         docH: built.model.doc.height,
@@ -73,7 +83,7 @@ const sceneSchema = {
         save_regions: {
             type: 'boolean',
             default: true,
-            description: 'Precompute every confident region (sky/ground/shadows/highlights/skin/subject/face — and, on a Pro host with a face, the face-feature set scene:face_skin/_eyes/_brows/_lips/_teeth/_nose/_under_eye/_cheeks) and SAVE each as a managed `scene:*` alpha channel, returning the `regions` MENU of what is confidently selectable (each with its method + confidence). ps_select_by_reference then loads the saved channel instantly. Set false for a light read with no channels.',
+            description: 'Precompute every confident region (sky/ground/shadows/highlights/skin/subject/face — and, on a Pro host with a face, the face-feature set scene:face_skin/_eyes/_brows/_lips/_teeth/_nose/_under_eye/_cheeks) and SAVE each as a managed `scene:*` alpha channel, returning the `regions` MENU of what is confidently selectable (each with its method + confidence). ps_select_by_reference then loads the saved channel instantly. Set false for a light read with no channels. The `scene:` channel-name prefix is RESERVED: channels matching it are treated as derived and are deleted on the next scene read and on ps_save_psd, so do not give a channel you want to keep a `scene:`-prefixed name.',
         },
         composition_context: {
             type: 'object',
@@ -97,42 +107,19 @@ const sceneSchema = {
         },
     },
 };
-function annotateScene(bytes, faces, objects, horizonY) {
-    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;
-    };
-    const drawBox = (box, rgb) => {
-        const [x1, y1, x2, y2] = box.map(Math.round);
-        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]);
-            }
-    };
+export function annotateScene(img, faces, objects, horizonY) {
+    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 o of objects)
-        drawBox(o, [255, 0, 220]);
+        drawBoxOutline(out, o, ANNOTATION_RGB.object, thickness);
     for (const f of faces)
-        drawBox(f, [0, 220, 255]);
+        drawBoxOutline(out, f, ANNOTATION_RGB.face, thickness);
     if (horizonY !== null && horizonY >= 0 && horizonY < h) {
-        for (let x = 0; x < w; x++)
-            for (let k = 0; k < thickness; k++)
-                setPx(x, horizonY + k, 255, 230, 0);
+        drawHLine(out, horizonY, ANNOTATION_RGB.horizon, thickness);
     }
-    return encode({ data, width: w, height: h }, 88).data;
+    return encode({ data, width: w, height: h }, ANNOTATED_PREVIEW_JPEG_QUALITY).data;
 }
 function summarizeScene(model) {
     const subjLabels = new Map();
@@ -151,7 +138,7 @@ function summarizeScene(model) {
         parts.push(`main subject in the ${cell.row}-${cell.col} third`);
     return `Scene (${model.doc.width}×${model.doc.height}): ${parts.join('; ')}. Select named regions with ps_select_by_reference.`;
 }
-async function scene(connection, snippet, client, rawArgs, proRefine, precomputeFace) {
+async function scene(connection, snippet, client, rawArgs, proRefine, hasPro = false, detectDeps) {
     try {
         const args = validateArgs(sceneSchema, rawArgs);
         const annotate = args.annotate ?? true;
@@ -160,23 +147,31 @@ async function scene(connection, snippet, client, rawArgs, proRefine, precompute
         const built = await buildSceneModel(connection, snippet, client, {
             useCache: !refresh,
             maxDimension: args.max_dimension,
+            detectDeps,
         });
         const model = built.model;
         let regions = [];
+        let precomputeOk = true;
         if (saveRegions) {
             try {
-                regions = await precomputeRegions(connection, snippet, model, toCompositionContext(args.composition_context), { force: refresh, proRefine, skyCtx: skyCtxFrom(built), precomputeFace });
+                regions = await precomputeRegions(connection, snippet, model, toCompositionContext(args.composition_context), {
+                    force: refresh,
+                    proRefine,
+                    skyCtx: skyCtxFrom(built),
+                    faceMenu: faceMenuFor(model, hasPro),
+                });
             }
             catch {
+                precomputeOk = false;
             }
         }
         const content = [];
-        if (annotate) {
+        if (annotate && built.decoded) {
             try {
                 const exportH = built.exportImage.height || 0;
                 const sy = model.doc.height > 0 ? exportH / model.doc.height : 1;
                 const horizonExportY = Math.round(model.horizon.y * sy);
-                const annotated = annotateScene(built.exportBytes, built.rawFaces, built.rawObjects.map((o) => o.bbox), horizonExportY);
+                const annotated = annotateScene(built.decoded, built.rawFaces, built.rawObjects.map((o) => o.bbox), horizonExportY);
                 content.push({
                     type: 'image',
                     data: annotated.toString('base64'),
@@ -198,17 +193,35 @@ async function scene(connection, snippet, client, rawArgs, proRefine, precompute
             content,
             structuredContent: {
                 ...model,
+                regions: reconcileRegions(model, regions, saveRegions && precomputeOk),
                 region_menu: regions,
             },
         };
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        return toolErrorResult('Error reading scene', error);
+    }
+}
+function reconcileRegions(model, menu, resolved) {
+    return model.regions.map((r) => {
+        const base = r;
+        if (!resolved) {
+            return {
+                ...base,
+                coverage_is_estimate: true,
+                selectable: null,
+                selectable_state: 'not_resolved',
+            };
+        }
+        const hit = menu.find((m) => m.target === r.kind);
         return {
-            content: [{ type: 'text', text: `Error reading scene: ${msg}` }],
-            isError: true,
+            ...base,
+            coverage_is_estimate: true,
+            selectable: hit !== undefined,
+            selectable_state: hit !== undefined ? 'selectable' : 'not_selectable',
+            ...(hit ? { selectable_via: hit.method, selectable_confidence: hit.confidence } : {}),
         };
-    }
+    });
 }
 const selectByReferenceSchema = {
     type: 'object',
@@ -272,7 +285,7 @@ function toCompositionContext(raw) {
         ctx.passThreshold = r.pass_threshold;
     return Object.keys(ctx).length ? ctx : undefined;
 }
-async function selectByReference(connection, snippet, client, rawArgs, proRefine) {
+async function selectByReference(connection, snippet, client, rawArgs, proRefine, detectDeps) {
     try {
         const args = validateArgs(selectByReferenceSchema, rawArgs);
         const target = args.target;
@@ -294,7 +307,7 @@ async function selectByReference(connection, snippet, client, rawArgs, proRefine
                         passed: true,
                         confidence: 1,
                         reasons: ['loaded the saved scene:* channel by name'],
-                        selection_info: null,
+                        selection_info: loaded.selection_info,
                         detail: { from: 'precompute' },
                         doc: { width: loaded.width, height: loaded.height },
                     },
@@ -304,6 +317,7 @@ async function selectByReference(connection, snippet, client, rawArgs, proRefine
         const built = await buildSceneModel(connection, snippet, client, {
             useCache: !refresh,
             maxDimension: args.max_dimension,
+            detectDeps,
         });
         const res = await resolveSelection(connection, snippet, built.model, target, {
             label: args.label,
@@ -312,6 +326,15 @@ async function selectByReference(connection, snippet, client, rawArgs, proRefine
             proRefine,
             skyCtx: skyCtxFrom(built),
         });
+        if (res.passed && target.startsWith('face_')) {
+            try {
+                await saveSelectionAsSceneChannel(connection, target);
+            }
+            catch (err) {
+                logger.debug(`select_by_reference: could not persist ${CHANNEL_PREFIX}${target} — ` +
+                    `${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
         const conf = res.confidence.toFixed(2);
         const summary = res.passed
             ? `Selected "${target}" via ${res.method} (confidence ${conf}). Verify with ps_get_selection_preview.`
@@ -332,16 +355,14 @@ async function selectByReference(connection, snippet, client, rawArgs, proRefine
         };
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error in ps_select_by_reference: ${msg}` }],
-            isError: true,
-        };
+        return toolErrorResult('Error in ps_select_by_reference', error);
     }
 }
-export function createSceneTools(connection, snippetClient, client = new OnnxDetectionClient(), invokeTool) {
+export function createSceneTools(connection, snippetClient, opts = {}) {
+    const { client = new OnnxDetectionClient(), invokeTool, detectDeps } = opts;
     const proRefine = invokeTool ? makeProRefine(invokeTool) : undefined;
-    const precomputeFace = invokeTool ? makePrecomputeFace(invokeTool) : undefined;
+    const proMeshReachable = isToolAllowedInEdition('ps_select_face_feature', EDITION) || isProEntitled();
+    const hasPro = invokeTool !== undefined && proMeshReachable;
     return [
         {
             tool: {
@@ -354,7 +375,34 @@ export function createSceneTools(connection, snippetClient, client = new OnnxDet
                         doc: { type: 'object' },
                         subjects: { type: 'array', items: { type: 'object' } },
                         faces: { type: 'array', items: { type: 'object' } },
-                        regions: { type: 'array', items: { type: 'object' } },
+                        regions: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    kind: { type: 'string' },
+                                    coverage: { type: 'number' },
+                                    coverage_is_estimate: {
+                                        type: 'boolean',
+                                        description: 'Always true today: `coverage` is the coarse histogram split, never a measured mask. It and the real selection routinely disagree (a night shot read sky at 0.08 while the gated selection found a real sky at 0.83) — trust `selectable_confidence` and the precomputed channel over this number. Carried as a field rather than left implicit so a future measured-coverage path can report false.',
+                                    },
+                                    selectable: {
+                                        type: ['boolean', 'null'],
+                                        description: 'Tristate as null when the region was never resolved — never read this as a plain boolean; branch on `selectable_state`.',
+                                    },
+                                    selectable_state: {
+                                        type: 'string',
+                                        enum: ['selectable', 'not_selectable', 'not_resolved'],
+                                        description: '`selectable`: a precomputed channel is ready to load. `not_selectable`: resolution ran and this region did not pass the confidence gate. `not_resolved`: precompute did not run or failed, so absence here is NOT evidence the region is unavailable.',
+                                    },
+                                    selectable_via: {
+                                        type: 'string',
+                                        description: 'The method that resolved it (only when selectable).',
+                                    },
+                                    selectable_confidence: { type: 'number' },
+                                },
+                            },
+                        },
                         region_menu: { type: 'array', items: { type: 'object' } },
                         horizon: { type: 'object' },
                         tonal_zones: { type: 'object' },
@@ -368,7 +416,7 @@ export function createSceneTools(connection, snippetClient, client = new OnnxDet
                     idempotentHint: true,
                 },
             },
-            handler: async (args) => scene(connection, snippetClient, client, args, proRefine, precomputeFace),
+            handler: async (args) => scene(connection, snippetClient, client, args, proRefine, hasPro, detectDeps),
         },
         {
             tool: {
@@ -395,7 +443,7 @@ export function createSceneTools(connection, snippetClient, client = new OnnxDet
                     openWorldHint: false,
                 },
             },
-            handler: async (args) => selectByReference(connection, snippetClient, client, args, proRefine),
+            handler: async (args) => selectByReference(connection, snippetClient, client, args, proRefine, detectDeps),
         },
     ];
 }