editmamei 0.23.0 → 1.0.0

package/dist/perception/region-precompute.js

@@ -1,7 +1,10 @@
 import { runScript } from '../utils/run-script.js';
+import { SCENE_CHANNEL_TIMEOUT_MS } from '../utils/operation-timeouts.js';
 import { jsLit } from '../utils/jsx.js';
-import { restoreCompositeChannel } from '../api/extendscript/_helpers.js';
+import { restoreCompositeChannel, getSelectionInfo } from '../api/extendscript/_helpers.js';
+import { Logger } from '../utils/logger.js';
 import { resolveSelection, } from './select-recipes.js';
+const logger = new Logger('region-precompute');
 let lastPrecomputedKey = null;
 let cachedMenu = [];
 export function __resetPrecompute() {
@@ -10,7 +13,7 @@ export function __resetPrecompute() {
 }
 export const CHANNEL_PREFIX = 'scene:';
 export async function saveSelectionAsSceneChannel(connection, target) {
-    await runScript(connection, saveSelectionToNamedChannelScript(`${CHANNEL_PREFIX}${target}`));
+    await runScript(connection, saveSelectionToNamedChannelScript(`${CHANNEL_PREFIX}${target}`), SCENE_CHANNEL_TIMEOUT_MS);
 }
 const PRECOMPUTE_TARGETS = [
     'sky',
@@ -23,7 +26,7 @@ const PRECOMPUTE_TARGETS = [
 ];
 function deleteSceneChannelsScript() {
     return `
-    if (app.documents.length === 0) { throw new Error('No active document'); }
+    if (app.documents.length === 0) { throw new Error('No document is open in Photoshop'); }
     var doc = app.activeDocument;
     var removed = 0;
     for (var i = doc.channels.length - 1; i >= 0; i--) {
@@ -36,6 +39,12 @@ function deleteSceneChannelsScript() {
     return { removed: removed };
   `;
 }
+export async function purgeSceneChannels(connection) {
+    const r = (await runScript(connection, deleteSceneChannelsScript(), SCENE_CHANNEL_TIMEOUT_MS));
+    lastPrecomputedKey = null;
+    cachedMenu = [];
+    return r.removed ?? 0;
+}
 function saveSelectionToNamedChannelScript(name) {
     return `
     var doc = app.activeDocument;
@@ -50,9 +59,50 @@ function saveSelectionToNamedChannelScript(name) {
     return { saved: true, name: ${jsLit(name)} };
   `;
 }
+function channelsExistScript(names) {
+    const namesLit = `[${names.map((n) => jsLit(n)).join(', ')}]`;
+    return `
+    // __mcp_scene_chk__ cheap existence check for previously-saved scene:* channels
+    if (app.documents.length === 0) { throw new Error('No document is open in Photoshop'); }
+    var doc = app.activeDocument;
+    var have = {};
+    for (var i = 0; i < doc.channels.length; i++) {
+      have[String(doc.channels[i].name)] = true;
+    }
+    var names = ${namesLit};
+    var allPresent = true;
+    for (var j = 0; j < names.length; j++) {
+      if (!have[names[j]]) { allPresent = false; break; }
+    }
+    return { all_present: allPresent };
+  `;
+}
+async function channelsExist(connection, names) {
+    if (names.length === 0)
+        return true;
+    try {
+        const r = (await runScript(connection, channelsExistScript(names)));
+        return r.all_present === true;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.debug(`region-precompute: channelsExist check failed (${msg}) — treating as stale, rebuilding`);
+        return false;
+    }
+}
 function loadNamedChannelScript(name) {
     return `
-    if (app.documents.length === 0) { throw new Error('No active document'); }
+    // getSelectionInfo's own source begins with the restoreCompositeChannel
+    // definition (see _helpers.ts), so interpolating it here brings BOTH into
+    // scope. Interpolating restoreCompositeChannel separately as well emitted a
+    // second, byte-identical copy of that function body into every load script —
+    // legal (a later function declaration just wins) but pure waste in a string
+    // that crosses the COM/AppleScript boundary on every select_by_reference.
+    // Hoisted to the TOP so the restoreCompositeChannel(doc) call below sits
+    // after its definition textually, rather than relying on hoisting across an
+    // interpolation boundary.
+    ${getSelectionInfo}
+    if (app.documents.length === 0) { throw new Error('No document is open in Photoshop'); }
     var doc = app.activeDocument;
     var ch = null;
     for (var i = 0; i < doc.channels.length; i++) {
@@ -60,29 +110,52 @@ function loadNamedChannelScript(name) {
     }
     if (!ch) { return { loaded: false }; }
     doc.selection.load(ch, SelectionType.REPLACE);
-    ${restoreCompositeChannel}
     restoreCompositeChannel(doc);
-    return { loaded: true, width: doc.width.as('px'), height: doc.height.as('px') };
+    // Measure in the SAME round trip. The fast path used to return
+    // selection_info:null, which forced any caller that wanted to verify the mask
+    // into a second PS call — the one thing this path exists to avoid.
+    return {
+      loaded: true,
+      width: doc.width.as('px'),
+      height: doc.height.as('px'),
+      selection_info: getSelectionInfo()
+    };
   `;
 }
+function countingConnection(connection, tally) {
+    return new Proxy(connection, {
+        get(target, prop, receiver) {
+            if (prop === 'executeScript') {
+                return (script, timeoutMs) => {
+                    tally.scripts++;
+                    return target.executeScript(script, timeoutMs);
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
 export async function precomputeRegions(connection, snippet, model, composition, opts = {}) {
     if (!opts.force &&
         lastPrecomputedKey !== null &&
-        lastPrecomputedKey === model.provenance.cache_key) {
+        lastPrecomputedKey === model.provenance.cache_key &&
+        (await channelsExist(connection, cachedMenu.filter((m) => !m.on_demand).map((m) => m.key)))) {
         return cachedMenu;
     }
-    await runScript(connection, deleteSceneChannelsScript());
+    const tally = { scripts: 0 };
+    const countedConnection = countingConnection(connection, tally);
+    await runScript(countedConnection, deleteSceneChannelsScript(), SCENE_CHANNEL_TIMEOUT_MS);
     const menu = [];
     for (const target of PRECOMPUTE_TARGETS) {
         try {
-            const res = await resolveSelection(connection, snippet, model, target, {
+            const res = await resolveSelection(countedConnection, snippet, model, target, {
                 composition,
                 proRefine: opts.proRefine,
                 skyCtx: opts.skyCtx,
             });
             if (res.passed) {
                 const key = `${CHANNEL_PREFIX}${target}`;
-                await runScript(connection, saveSelectionToNamedChannelScript(key));
+                await runScript(countedConnection, saveSelectionToNamedChannelScript(key), SCENE_CHANNEL_TIMEOUT_MS);
                 menu.push({
                     key,
                     target,
@@ -97,26 +170,29 @@ export async function precomputeRegions(connection, snippet, model, composition,
             continue;
         }
     }
-    if (opts.precomputeFace) {
-        try {
-            const faceItems = await opts.precomputeFace();
-            menu.push(...faceItems);
-        }
-        catch {
-        }
+    if (opts.faceMenu?.length) {
+        menu.push(...opts.faceMenu);
     }
     try {
-        await runScript(connection, await snippet.build('deselect'));
+        await runScript(countedConnection, await snippet.build('deselect'));
     }
     catch {
     }
+    logger.debug(`precompute: ${PRECOMPUTE_TARGETS.length} targets, ${tally.scripts} scripts` +
+        ` (7 CE targets ≈ 21 scripts before the 2026-07-29 derive+measure merge → 15 after, ` +
+        ` then 14 once skin short-circuits with no person/face (2026-08-01), ` +
+        `on the all-fail path; production pass-paths differ)`);
     lastPrecomputedKey = model.provenance.cache_key;
     cachedMenu = menu;
     return menu;
 }
 export async function loadPrecomputedRegion(connection, target) {
-    const r = (await runScript(connection, loadNamedChannelScript(`${CHANNEL_PREFIX}${target}`)));
+    const r = (await runScript(connection, loadNamedChannelScript(`${CHANNEL_PREFIX}${target}`), SCENE_CHANNEL_TIMEOUT_MS));
     if (r.loaded !== true)
         return null;
-    return { width: r.width ?? 0, height: r.height ?? 0 };
+    return {
+        width: r.width ?? 0,
+        height: r.height ?? 0,
+        selection_info: r.selection_info ?? null,
+    };
 }

package/dist/perception/scene-model.js

@@ -1,36 +1,24 @@
-import { decode } from 'jpeg-js';
 import { runScript } from '../utils/run-script.js';
 import { getContextInfo } from '../api/extendscript/_helpers.js';
 import { detectActiveDoc } from '../detection/detect-active-doc.js';
+import { computePixelIdentity, docKeyFrom, identityKeyString, samePixelIdentity, } from './pixel-identity.js';
+import { Logger } from '../utils/logger.js';
 import { computeComposition, computeTonalZones, estimateHorizon, pickThresholdLevel, boxArea, toLumaHistogram, } from './facets.js';
+const logger = new Logger('scene-model');
 let cache = null;
+const NO_PIXEL_IDENTITY_COUNTER_WRAP = 1_000_000_000;
+let noPixelIdentityCounter = 0;
+function nextNoPixelIdentityId() {
+    noPixelIdentityCounter = (noPixelIdentityCounter + 1) % NO_PIXEL_IDENTITY_COUNTER_WRAP;
+    return noPixelIdentityCounter;
+}
 export function __clearSceneCache() {
     cache = null;
 }
-async function readCacheKey(connection) {
-    const script = `
-    if (app.documents.length === 0) { throw new Error('No active document'); }
-    var doc = app.activeDocument;
-    var id = -1;
-    try { id = doc.id; } catch (eId) {}
-    var hs = -1;
-    try { hs = doc.historyStates.length; } catch (eHs) {}
-    return { doc_id: id, history_states: hs };
-  `;
-    const r = (await runScript(connection, script));
-    return `${r.doc_id ?? -1}:${r.history_states ?? -1}`;
-}
-export function rowBrightnessProfile(exportBytes, strips = 64) {
-    if (!exportBytes || exportBytes.length === 0)
-        return undefined;
-    let img;
-    try {
-        img = decode(exportBytes, { useTArray: true, formatAsRGBA: true });
-    }
-    catch {
+export function rowBrightnessProfile(decoded, strips = 64) {
+    if (!decoded)
         return undefined;
-    }
-    const { width: w, height: h, data } = img;
+    const { width: w, height: h, data } = decoded;
     if (w <= 0 || h <= 0)
         return undefined;
     const R = Math.max(1, Math.min(strips, h));
@@ -50,24 +38,55 @@ export function rowBrightnessProfile(exportBytes, strips = 64) {
 }
 export async function buildSceneModel(connection, snippet, client, opts = {}) {
     const useCache = opts.useCache ?? true;
-    const key = await readCacheKey(connection);
-    if (useCache && cache && cache.key === key) {
-        const cached = cache.result;
-        return {
-            ...cached,
-            model: {
-                ...cached.model,
-                provenance: { ...cached.model.provenance, cached: true },
-            },
-        };
-    }
+    let hit = null;
+    let freshIdentity = null;
     const det = await detectActiveDoc(connection, client, {
         faces: true,
         objects: true,
         maxDimension: opts.maxDimension,
         objectThreshold: opts.objectThreshold,
         faceThreshold: opts.faceThreshold,
-    });
+        shouldDetect: ({ decoded, context, docWidth, docHeight }) => {
+            if (!decoded)
+                return true;
+            const identity = computePixelIdentity(decoded, docKeyFrom(context, docWidth, docHeight));
+            freshIdentity = identity;
+            if (useCache && cache && samePixelIdentity(cache.identity, identity)) {
+                hit = cache;
+                return false;
+            }
+            return true;
+        },
+    }, opts.detectDeps);
+    if (hit) {
+        const cached = hit;
+        logger.debug(`scene-model: pixel-identity cache HIT (${cached.cacheKey}) — reusing detection + ` +
+            `facets, skipping ONNX + histogram + facet rebuild`);
+        const model = {
+            doc: { width: det.docWidth, height: det.docHeight },
+            subjects: cached.subjects,
+            faces: cached.faces,
+            regions: cached.regions,
+            horizon: cached.horizon,
+            tonal_zones: cached.tonalZones,
+            composition: cached.composition,
+            provenance: {
+                backends: cached.backends,
+                edition: 'ce',
+                cache_key: cached.cacheKey,
+                cached: true,
+            },
+        };
+        return {
+            model,
+            exportBytes: det.exportBytes,
+            decoded: det.decoded,
+            context: det.context,
+            rawFaces: cached.rawFaces,
+            rawObjects: cached.rawObjects,
+            exportImage: cached.exportImage,
+        };
+    }
     const docW = det.docWidth;
     const docH = det.docHeight;
     const objects = det.result.objects ?? [];
@@ -105,8 +124,11 @@ export async function buildSceneModel(connection, snippet, client, opts = {}) {
     const hist = toLumaHistogram(histRaw);
     const pick = pickThresholdLevel(hist);
     const tonalZones = computeTonalZones(hist);
-    const rowMeans = rowBrightnessProfile(det.exportBytes);
-    const horizon = estimateHorizon(rowMeans, docH, pick);
+    const allBoxes = objects.map((o) => o.bbox);
+    const mainBox = mainIdx >= 0 ? objects[mainIdx].bbox : null;
+    const primaryFaceBox = faces.find((f) => f.is_primary)?.bbox ?? faces[0]?.bbox ?? null;
+    const rowMeans = rowBrightnessProfile(det.decoded);
+    const horizon = estimateHorizon(rowMeans, docH, pick, mainBox, primaryFaceBox);
     const skyCoverage = pick.bright_fraction;
     const regions = [
         {
@@ -120,9 +142,18 @@ export async function buildSceneModel(connection, snippet, client, opts = {}) {
             recipe: { kind: 'posterize_region', levels: 3, sample: 'below_horizon' },
         },
     ];
-    const allBoxes = objects.map((o) => o.bbox);
-    const mainBox = mainIdx >= 0 ? objects[mainIdx].bbox : null;
     const composition = computeComposition(mainBox, allBoxes, docW, docH, horizon.placement);
+    const backends = {
+        faces: det.result.backends.faces,
+        objects: det.result.backends.objects,
+        regions: 'heuristic',
+    };
+    const rawFaces = (det.raw.faces ?? []).map((f) => f.bbox);
+    const rawObjects = (det.raw.objects ?? []).map((o) => ({ label: o.label, bbox: o.bbox }));
+    const exportImage = det.raw.image;
+    const cacheKey = freshIdentity
+        ? identityKeyString(freshIdentity)
+        : `nopixel-${nextNoPixelIdentityId()}`;
     const model = {
         doc: { width: docW, height: docH },
         subjects,
@@ -132,25 +163,37 @@ export async function buildSceneModel(connection, snippet, client, opts = {}) {
         tonal_zones: tonalZones,
         composition,
         provenance: {
-            backends: {
-                faces: det.result.backends.faces,
-                objects: det.result.backends.objects,
-                regions: 'heuristic',
-            },
+            backends,
             edition: 'ce',
-            cache_key: key,
+            cache_key: cacheKey,
             cached: false,
         },
     };
     const result = {
         model,
         exportBytes: det.exportBytes,
-        rawFaces: (det.raw.faces ?? []).map((f) => f.bbox),
-        rawObjects: (det.raw.objects ?? []).map((o) => ({ label: o.label, bbox: o.bbox })),
-        exportImage: det.raw.image,
+        decoded: det.decoded,
+        rawFaces,
+        rawObjects,
+        exportImage,
         context: det.context,
     };
-    cache = { key, result };
+    if (freshIdentity) {
+        cache = {
+            identity: freshIdentity,
+            cacheKey,
+            subjects,
+            faces,
+            regions,
+            horizon,
+            tonalZones,
+            composition,
+            backends,
+            rawFaces,
+            rawObjects,
+            exportImage,
+        };
+    }
     return result;
 }
 export { getContextInfo };