editmamei 0.17.4 → 0.18.0

package/dist/modules/ce/index.js

@@ -15,10 +15,19 @@ import { createSelectionTools } from '../../tools/selection-tools.js';
 import { createHistoryTools } from '../../tools/history-tools.js';
 import { createLayerOrderingTools } from '../../tools/layer-ordering-tools.js';
 import { createPreviewTools } from '../../tools/preview-tools.js';
-import { createMetadataTools } from '../../tools/metadata-tools.js';
+import { createInspectTools } from '../../tools/inspect-tools.js';
 import { createOverviewTools } from '../../tools/overview-tools.js';
 import { createRetouchTools } from '../../tools/retouch-tools.js';
 import { createBrushTools } from '../../tools/brush-tools.js';
+import { createTransformCanvasTools } from '../../tools/transform-canvas-tools.js';
+import { createGuideTools } from '../../tools/guide-tools.js';
+import { createDetectionTools } from '../../tools/detection-tools.js';
+import { createObjectTools } from '../../tools/object-tools.js';
+import { createPortraitTools } from '../../tools/portrait-tools.js';
+import { createTextOnObjectTools } from '../../tools/text-on-object-tools.js';
+import { createSceneTools } from '../../tools/scene-tools.js';
+import { createPathTools } from '../../tools/path-tools.js';
+import { createVectorMaskTools } from '../../tools/vector-mask-tools.js';
 const ceFactories = [
     createDocumentTools,
     createLayerTools,
@@ -34,18 +43,27 @@ const ceFactories = [
     createHistoryTools,
     createLayerOrderingTools,
     createPreviewTools,
-    createMetadataTools,
+    createInspectTools,
     createOverviewTools,
     createRetouchTools,
     createBrushTools,
+    createTransformCanvasTools,
+    createGuideTools,
+    createDetectionTools,
+    createObjectTools,
+    createPortraitTools,
+    createTextOnObjectTools,
+    createPathTools,
+    createVectorMaskTools,
 ];
 export const ceModule = {
     manifest: { id: 'ce', name: 'Editmamei Community Tools', abi: KERNEL_ABI },
     register(host) {
         const { connection, snippet } = host;
-        const defs = ceFactories
-            .flatMap((f) => f(connection, snippet))
-            .filter((def) => isToolAllowedInEdition(def.tool.name, EDITION));
+        const defs = [
+            ...ceFactories.flatMap((f) => f(connection, snippet)),
+            ...createSceneTools(connection, snippet, undefined, host.invokeTool),
+        ].filter((def) => isToolAllowedInEdition(def.tool.name, EDITION));
         host.registerTools(defs);
     },
 };

package/dist/perception/facets.js

@@ -0,0 +1,148 @@
+export function pickThresholdLevel(hist) {
+    const { bins } = hist;
+    const total = hist.total || bins.reduce((a, b) => a + b, 0);
+    if (total <= 0)
+        return { level: 128, bright_fraction: 0 };
+    let sumAll = 0;
+    for (let i = 0; i < 256; i++)
+        sumAll += i * bins[i];
+    let wB = 0;
+    let sumB = 0;
+    let bestFirst = 128;
+    let bestLast = 128;
+    let bestVar = -1;
+    for (let t = 0; t < 256; t++) {
+        wB += bins[t];
+        if (wB === 0)
+            continue;
+        const wF = total - wB;
+        if (wF === 0)
+            break;
+        sumB += t * bins[t];
+        const meanB = sumB / wB;
+        const meanF = (sumAll - sumB) / wF;
+        const between = wB * wF * (meanB - meanF) * (meanB - meanF);
+        if (between > bestVar) {
+            bestVar = between;
+            bestFirst = t;
+            bestLast = t;
+        }
+        else if (between === bestVar) {
+            bestLast = t;
+        }
+    }
+    const level = Math.round((bestFirst + bestLast) / 2);
+    let bright = 0;
+    for (let i = level + 1; i < 256; i++)
+        bright += bins[i];
+    return { level, bright_fraction: bright / total };
+}
+export function estimateHorizon(rowMeans, docHeight, pick) {
+    const split = pick.bright_fraction;
+    const splitConfidence = Math.max(0, Math.min(1, 1 - Math.abs(0.5 - split) * 2)) * 0.6 + 0.2;
+    if (!rowMeans || rowMeans.length === 0) {
+        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+    }
+    const R = rowMeans.length;
+    let crossRow = -1;
+    for (let r = 0; r < R; r++) {
+        if (rowMeans[r] < pick.level) {
+            crossRow = r;
+            break;
+        }
+    }
+    if (crossRow <= 0) {
+        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+    }
+    const y = Math.round((crossRow / R) * docHeight);
+    return {
+        y,
+        placement: y / docHeight,
+        confidence: Math.max(0, Math.min(1, splitConfidence)),
+    };
+}
+export function computeTonalZones(hist) {
+    const { bins } = hist;
+    const total = hist.total || bins.reduce((a, b) => a + b, 0);
+    const coverageBetween = (lo, hi) => {
+        if (total <= 0)
+            return 0;
+        let c = 0;
+        for (let i = lo; i <= hi; i++)
+            c += bins[i];
+        return c / total;
+    };
+    let cum = 0;
+    let cut1 = 85;
+    let cut2 = 170;
+    let found1 = false;
+    if (total > 0) {
+        for (let i = 0; i < 256; i++) {
+            cum += bins[i];
+            const frac = cum / total;
+            if (!found1 && frac >= 1 / 3) {
+                cut1 = i;
+                found1 = true;
+            }
+            if (frac >= 2 / 3) {
+                cut2 = i;
+                break;
+            }
+        }
+    }
+    cut1 = Math.max(20, Math.min(120, cut1));
+    cut2 = Math.max(cut1 + 20, Math.min(235, cut2));
+    return {
+        shadows: { lower: 0, upper: cut1, coverage: coverageBetween(0, cut1) },
+        midtones: { lower: cut1 + 1, upper: cut2, coverage: coverageBetween(cut1 + 1, cut2) },
+        highlights: { lower: cut2 + 1, upper: 255, coverage: coverageBetween(cut2 + 1, 255) },
+    };
+}
+function boxCenter(b) {
+    return { x: (b[0] + b[2]) / 2, y: (b[1] + b[3]) / 2 };
+}
+export function boxArea(b) {
+    return Math.max(0, b[2] - b[0]) * Math.max(0, b[3] - b[1]);
+}
+export function computeComposition(mainBox, allBoxes, docWidth, docHeight, horizonPlacement) {
+    let cell = null;
+    let headroom = null;
+    if (mainBox && docWidth > 0 && docHeight > 0) {
+        const c = boxCenter(mainBox);
+        const col = c.x < docWidth / 3 ? 'left' : c.x < (2 * docWidth) / 3 ? 'center' : 'right';
+        const row = c.y < docHeight / 3 ? 'top' : c.y < (2 * docHeight) / 3 ? 'middle' : 'bottom';
+        cell = { col, row };
+        const top = Math.min(...allBoxes.map((b) => b[1]), mainBox[1]);
+        headroom = Math.max(0, Math.min(1, top / docHeight));
+    }
+    let balance = 'unknown';
+    if (allBoxes.length > 0 && docWidth > 0) {
+        let wsum = 0;
+        let xsum = 0;
+        for (const b of allBoxes) {
+            const a = boxArea(b);
+            wsum += a;
+            xsum += a * boxCenter(b).x;
+        }
+        if (wsum > 0) {
+            const cx = xsum / wsum / docWidth;
+            balance = cx < 0.42 ? 'left-weighted' : cx > 0.58 ? 'right-weighted' : 'balanced';
+        }
+    }
+    return {
+        main_subject_cell: cell,
+        balance,
+        headroom,
+        horizon_placement: horizonPlacement,
+    };
+}
+export function toLumaHistogram(raw) {
+    const bins = Array.isArray(raw.bins) && raw.bins.length === 256 ? raw.bins : new Array(256).fill(0);
+    const total = typeof raw.total_pixels === 'number' ? raw.total_pixels : bins.reduce((a, b) => a + b, 0);
+    return {
+        bins,
+        total,
+        mean: typeof raw.mean === 'number' ? raw.mean : 0,
+        median: typeof raw.median === 'number' ? raw.median : 0,
+    };
+}

package/dist/perception/region-precompute.js

@@ -0,0 +1,122 @@
+import { runScript } from '../utils/run-script.js';
+import { jsLit } from '../utils/jsx.js';
+import { restoreCompositeChannel } from '../api/extendscript/_helpers.js';
+import { resolveSelection, } from './select-recipes.js';
+let lastPrecomputedKey = null;
+let cachedMenu = [];
+export function __resetPrecompute() {
+    lastPrecomputedKey = null;
+    cachedMenu = [];
+}
+export const CHANNEL_PREFIX = 'scene:';
+export async function saveSelectionAsSceneChannel(connection, target) {
+    await runScript(connection, saveSelectionToNamedChannelScript(`${CHANNEL_PREFIX}${target}`));
+}
+const PRECOMPUTE_TARGETS = [
+    'sky',
+    'ground',
+    'shadows',
+    'highlights',
+    'skin',
+    'subject',
+    'face',
+];
+function deleteSceneChannelsScript() {
+    return `
+    if (app.documents.length === 0) { throw new Error('No active document'); }
+    var doc = app.activeDocument;
+    var removed = 0;
+    for (var i = doc.channels.length - 1; i >= 0; i--) {
+      if (String(doc.channels[i].name).indexOf(${jsLit(CHANNEL_PREFIX)}) === 0) {
+        try { doc.channels[i].remove(); removed++; } catch (e) {}
+      }
+    }
+    ${restoreCompositeChannel}
+    restoreCompositeChannel(doc);
+    return { removed: removed };
+  `;
+}
+function saveSelectionToNamedChannelScript(name) {
+    return `
+    var doc = app.activeDocument;
+    for (var i = doc.channels.length - 1; i >= 0; i--) {
+      if (String(doc.channels[i].name) === ${jsLit(name)}) { try { doc.channels[i].remove(); } catch (e) {} }
+    }
+    var ch = doc.channels.add();
+    doc.selection.store(ch, SelectionType.REPLACE);
+    ch.name = ${jsLit(name)};
+    ${restoreCompositeChannel}
+    restoreCompositeChannel(doc);
+    return { saved: true, name: ${jsLit(name)} };
+  `;
+}
+function loadNamedChannelScript(name) {
+    return `
+    if (app.documents.length === 0) { throw new Error('No active document'); }
+    var doc = app.activeDocument;
+    var ch = null;
+    for (var i = 0; i < doc.channels.length; i++) {
+      if (String(doc.channels[i].name) === ${jsLit(name)}) { ch = doc.channels[i]; break; }
+    }
+    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') };
+  `;
+}
+export async function precomputeRegions(connection, snippet, model, composition, opts = {}) {
+    if (!opts.force &&
+        lastPrecomputedKey !== null &&
+        lastPrecomputedKey === model.provenance.cache_key) {
+        return cachedMenu;
+    }
+    await runScript(connection, deleteSceneChannelsScript());
+    const menu = [];
+    for (const target of PRECOMPUTE_TARGETS) {
+        try {
+            const res = await resolveSelection(connection, snippet, model, target, {
+                composition,
+                proRefine: opts.proRefine,
+                skyCtx: opts.skyCtx,
+            });
+            if (res.passed) {
+                const key = `${CHANNEL_PREFIX}${target}`;
+                await runScript(connection, saveSelectionToNamedChannelScript(key));
+                menu.push({
+                    key,
+                    target,
+                    method: res.method,
+                    confidence: res.confidence,
+                    label: res.detail?.label,
+                    bounds: (res.selection_info?.bounds ?? null),
+                });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (opts.precomputeFace) {
+        try {
+            const faceItems = await opts.precomputeFace();
+            menu.push(...faceItems);
+        }
+        catch {
+        }
+    }
+    try {
+        await runScript(connection, await snippet.build('deselect'));
+    }
+    catch {
+    }
+    lastPrecomputedKey = model.provenance.cache_key;
+    cachedMenu = menu;
+    return menu;
+}
+export async function loadPrecomputedRegion(connection, target) {
+    const r = (await runScript(connection, loadNamedChannelScript(`${CHANNEL_PREFIX}${target}`)));
+    if (r.loaded !== true)
+        return null;
+    return { width: r.width ?? 0, height: r.height ?? 0 };
+}

package/dist/perception/region-scorer.js

@@ -0,0 +1,151 @@
+const DEFAULTS = {
+    skyCoverageMax: 0.55,
+    groundCoverageMax: 0.92,
+    passThreshold: 0.6,
+};
+function resolvePriors(ctx) {
+    let skyMax = DEFAULTS.skyCoverageMax;
+    let groundMax = DEFAULTS.groundCoverageMax;
+    switch (ctx?.profile) {
+        case 'big_sky':
+        case 'minimal':
+            skyMax = 0.9;
+            break;
+        case 'big_foreground':
+            skyMax = 0.4;
+            break;
+        case 'tight_subject':
+        case 'balanced':
+        default:
+            break;
+    }
+    if (typeof ctx?.skyCoverageMax === 'number')
+        skyMax = ctx.skyCoverageMax;
+    if (typeof ctx?.groundCoverageMax === 'number')
+        groundMax = ctx.groundCoverageMax;
+    const passThreshold = typeof ctx?.passThreshold === 'number' ? ctx.passThreshold : DEFAULTS.passThreshold;
+    return { skyCoverageMax: skyMax, groundCoverageMax: groundMax, passThreshold };
+}
+function rampDown(v, good, bad) {
+    if (v <= good)
+        return 1;
+    if (v >= bad)
+        return 0;
+    return 1 - (v - good) / (bad - good);
+}
+export function buildRegionSignals(info, scene) {
+    const hasSelection = info?.has_selection ?? (info?.bounds ? true : false);
+    const bounds = info?.bounds ?? null;
+    const docH = scene.docH > 0 ? scene.docH : 1;
+    const coverage = Math.max(0, Math.min(1, (info?.area_percent ?? 0) / 100));
+    const edgeComplexity = Math.max(0, Math.min(1, info?.edge_complexity ?? 0));
+    const fillRatio = Math.max(0, Math.min(1, info?.bounds_fill_ratio ?? 0));
+    let centroidY = 0.5;
+    let touchesBottom = false;
+    let touchesTop = false;
+    let lowerEdgeAlign = null;
+    let upperEdgeAlign = null;
+    if (bounds) {
+        centroidY = (bounds.top + bounds.bottom) / 2 / docH;
+        touchesBottom = bounds.bottom >= docH * 0.97;
+        touchesTop = bounds.top <= docH * 0.03;
+        if (scene.horizonConfidence > 0) {
+            lowerEdgeAlign = 1 - Math.min(1, Math.abs(bounds.bottom - scene.horizonY) / docH);
+            upperEdgeAlign = 1 - Math.min(1, Math.abs(bounds.top - scene.horizonY) / docH);
+        }
+    }
+    return {
+        coverage,
+        edgeComplexity,
+        fillRatio,
+        bounds,
+        centroidY,
+        touchesBottom,
+        touchesTop,
+        horizonAlignment: lowerEdgeAlign,
+        upperEdgeAlignment: upperEdgeAlign,
+        horizonConfidence: Math.max(0, Math.min(1, scene.horizonConfidence)),
+        indoorness: Math.max(0, Math.min(1, (scene.indoorObjectCount ?? 0) / 2)),
+        hasSelection,
+    };
+}
+export function scoreRegion(kind, signals, ctx) {
+    const priors = resolvePriors(ctx);
+    const reasons = [];
+    if (!signals.hasSelection || signals.coverage <= 0) {
+        return {
+            kind,
+            confidence: 0,
+            passed: false,
+            reasons: ['empty selection'],
+            signals,
+        };
+    }
+    let confidence = 0;
+    switch (kind) {
+        case 'sky': {
+            const upper = rampDown(signals.centroidY, 0.35, 0.65);
+            const notBottom = signals.touchesBottom ? 0 : 1;
+            const align = signals.horizonAlignment ?? 0.5;
+            const floor = 0.34 * upper + 0.3 * notBottom + 0.22 * align + 0.14 * signals.horizonConfidence;
+            const coverageGate = rampDown(signals.coverage, priors.skyCoverageMax, priors.skyCoverageMax + 0.3);
+            const indoorPenalty = 1 - 0.7 * signals.indoorness;
+            confidence = floor * coverageGate * indoorPenalty;
+            reasons.push(`floor=${floor.toFixed(2)}`, `upper=${upper.toFixed(2)}`, `notBottom=${notBottom}`, `align=${align.toFixed(2)}`, `coverageGate=${coverageGate.toFixed(2)}(cov=${signals.coverage.toFixed(2)}/${priors.skyCoverageMax})`, `indoorPenalty=${indoorPenalty.toFixed(2)}(indoor=${signals.indoorness.toFixed(2)})`);
+            break;
+        }
+        case 'ground': {
+            const lower = rampDown(1 - signals.centroidY, 0.35, 0.65);
+            const align = signals.upperEdgeAlignment ?? signals.horizonAlignment ?? 0.5;
+            const floor = 0.35 + 0.3 * lower + 0.2 * align + 0.15 * signals.horizonConfidence;
+            const coverageGate = rampDown(signals.coverage, priors.groundCoverageMax, 0.99);
+            confidence = floor * coverageGate;
+            reasons.push(`floor=${floor.toFixed(2)}`, `lower=${lower.toFixed(2)}`, `upperAlign=${align.toFixed(2)}`, `coverageGate=${coverageGate.toFixed(2)}`);
+            break;
+        }
+        case 'foliage': {
+            const sized = rampDown(Math.abs(signals.coverage - 0.3), 0.25, 0.6);
+            const notAll = signals.coverage < 0.85 ? 1 : 0;
+            confidence = 0.6 * sized + 0.4 * notAll;
+            reasons.push(`coverage=${signals.coverage.toFixed(2)}`, `notAll=${notAll}`);
+            break;
+        }
+        case 'shadows':
+        case 'highlights': {
+            const sized = signals.coverage >= 0.03 && signals.coverage <= 0.95 ? 1 : 0.3;
+            confidence = 0.85 * sized + 0.15;
+            reasons.push(`coverage=${signals.coverage.toFixed(2)}`);
+            break;
+        }
+        case 'skin': {
+            const present = signals.coverage >= 0.01 ? 1 : 0;
+            const solid = Math.min(1, signals.fillRatio * 2);
+            confidence = 0.6 * present + 0.4 * solid;
+            reasons.push(`coverage=${signals.coverage.toFixed(2)}`, `fill=${signals.fillRatio.toFixed(2)}`);
+            break;
+        }
+        case 'subject':
+        case 'face': {
+            const present = signals.coverage >= 0.005 ? 1 : 0;
+            const solid = signals.fillRatio >= 0.15 ? 1 : signals.fillRatio / 0.15;
+            confidence = present * (0.55 + 0.45 * solid);
+            reasons.push(`coverage=${signals.coverage.toFixed(2)}`, `fill=${signals.fillRatio.toFixed(2)}`);
+            break;
+        }
+        case 'above_horizon': {
+            confidence = signals.horizonConfidence > 0 ? 0.8 : 0.5;
+            reasons.push(`horizonConf=${signals.horizonConfidence.toFixed(2)}`);
+            break;
+        }
+        default:
+            confidence = 0.5;
+    }
+    confidence = Math.max(0, Math.min(1, confidence));
+    return {
+        kind,
+        confidence,
+        passed: confidence >= priors.passThreshold,
+        reasons,
+        signals,
+    };
+}

package/dist/perception/scene-model.js

@@ -0,0 +1,156 @@
+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 { computeComposition, computeTonalZones, estimateHorizon, pickThresholdLevel, boxArea, toLumaHistogram, } from './facets.js';
+let cache = null;
+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 {
+        return undefined;
+    }
+    const { width: w, height: h, data } = img;
+    if (w <= 0 || h <= 0)
+        return undefined;
+    const R = Math.max(1, Math.min(strips, h));
+    const sums = new Array(R).fill(0);
+    const counts = new Array(R).fill(0);
+    for (let y = 0; y < h; y++) {
+        const strip = Math.min(R - 1, Math.floor((y / h) * R));
+        let rowSum = 0;
+        for (let x = 0; x < w; x++) {
+            const i = (y * w + x) * 4;
+            rowSum += 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+        }
+        sums[strip] += rowSum;
+        counts[strip] += w;
+    }
+    return sums.map((s, i) => (counts[i] > 0 ? s / counts[i] : 0));
+}
+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 },
+            },
+        };
+    }
+    const det = await detectActiveDoc(connection, client, {
+        faces: true,
+        objects: true,
+        maxDimension: opts.maxDimension,
+        objectThreshold: opts.objectThreshold,
+        faceThreshold: opts.faceThreshold,
+    });
+    const docW = det.docWidth;
+    const docH = det.docHeight;
+    const objects = det.result.objects ?? [];
+    let mainIdx = -1;
+    let mainArea = -1;
+    objects.forEach((o, i) => {
+        const a = boxArea(o.bbox);
+        if (a > mainArea) {
+            mainArea = a;
+            mainIdx = i;
+        }
+    });
+    const subjects = objects.map((o, i) => ({
+        id: `s${i + 1}`,
+        label: o.label,
+        bbox: o.bbox,
+        confidence: o.confidence,
+        is_main: i === mainIdx,
+    }));
+    const detFaces = det.result.faces ?? [];
+    let primaryFaceIdx = -1;
+    let bestFaceConf = -1;
+    detFaces.forEach((f, i) => {
+        if (f.confidence > bestFaceConf) {
+            bestFaceConf = f.confidence;
+            primaryFaceIdx = i;
+        }
+    });
+    const faces = detFaces.map((f, i) => ({
+        bbox: f.bbox,
+        confidence: f.confidence,
+        is_primary: i === primaryFaceIdx,
+    }));
+    const histRaw = (await runScript(connection, await snippet.build('getHistogram', { channel: 'luminosity' })));
+    const hist = toLumaHistogram(histRaw);
+    const pick = pickThresholdLevel(hist);
+    const tonalZones = computeTonalZones(hist);
+    const rowMeans = rowBrightnessProfile(det.exportBytes);
+    const horizon = estimateHorizon(rowMeans, docH, pick);
+    const skyCoverage = pick.bright_fraction;
+    const regions = [
+        {
+            kind: 'sky',
+            coverage: skyCoverage,
+            recipe: { kind: 'threshold_white', level: pick.level },
+        },
+        {
+            kind: 'ground',
+            coverage: Math.max(0, 1 - skyCoverage),
+            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 model = {
+        doc: { width: docW, height: docH },
+        subjects,
+        faces,
+        regions,
+        horizon,
+        tonal_zones: tonalZones,
+        composition,
+        provenance: {
+            backends: {
+                faces: det.result.backends.faces,
+                objects: det.result.backends.objects,
+                regions: 'heuristic',
+            },
+            edition: 'ce',
+            cache_key: key,
+            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,
+        context: det.context,
+    };
+    cache = { key, result };
+    return result;
+}
+export { getContextInfo };