editmamei 0.17.4 → 0.18.0

package/dist/core/tool-tiers.js

@@ -1,26 +1,17 @@
 export const TOOL_TIERS = {
     photoshop_ping: 'community',
+    photoshop_list_capabilities: 'community',
     photoshop_list_actions: 'pro',
     photoshop_play_action: 'pro',
     photoshop_execute_script: 'pro',
     photoshop_add_adjustment_layer: 'community',
-    photoshop_apply_shadows_highlights: 'community',
-    photoshop_apply_equalize: 'community',
-    photoshop_apply_color_lookup: 'community',
+    photoshop_apply_adjustment: 'community',
     photoshop_create_document: 'community',
     photoshop_close_document: 'community',
     photoshop_open_document: 'community',
     photoshop_save_psd: 'community',
-    photoshop_export_jpeg: 'community',
-    photoshop_export_png: 'community',
-    photoshop_apply_gaussian_blur: 'community',
-    photoshop_apply_sharpen: 'community',
-    photoshop_apply_noise: 'community',
-    photoshop_apply_motion_blur: 'community',
-    photoshop_apply_lens_blur: 'community',
-    photoshop_apply_smart_sharpen: 'community',
-    photoshop_apply_reduce_noise: 'community',
-    photoshop_apply_high_pass: 'community',
+    photoshop_export: 'community',
+    photoshop_apply_filter: 'community',
     photoshop_create_group: 'community',
     photoshop_move_layer_to_group: 'community',
     photoshop_set_group_blend_mode: 'community',
@@ -30,59 +21,57 @@ export const TOOL_TIERS = {
     photoshop_release_clipping_mask: 'dev',
     photoshop_undo: 'community',
     photoshop_redo: 'community',
-    photoshop_get_history: 'community',
     photoshop_place_image: 'community',
     photoshop_resize_image: 'community',
     photoshop_crop_document: 'community',
+    photoshop_convert_image_mode: 'community',
     photoshop_move_layer_to_position: 'community',
     photoshop_convert_to_smart_object: 'community',
     photoshop_rasterize_layer: 'community',
-    photoshop_set_layer_opacity: 'community',
-    photoshop_set_layer_blend_mode: 'community',
-    photoshop_set_layer_visibility: 'community',
-    photoshop_set_layer_locked: 'community',
-    photoshop_rename_layer: 'community',
+    photoshop_set_layer: 'community',
     photoshop_duplicate_layer: 'community',
-    photoshop_merge_visible_layers: 'community',
-    photoshop_stamp_visible: 'community',
-    photoshop_flatten_image: 'community',
+    photoshop_layer_via_copy: 'community',
+    photoshop_merge: 'community',
+    photoshop_bake_layer: 'community',
     photoshop_add_layer_style: 'community',
     photoshop_create_layer: 'community',
     photoshop_delete_layer: 'community',
     photoshop_create_text_layer: 'community',
     photoshop_fill_layer: 'community',
-    photoshop_get_layer_tree: 'community',
+    photoshop_add_fill_layer: 'community',
     photoshop_select_layer: 'community',
-    photoshop_fit_layer_to_document: 'community',
-    photoshop_scale_layer: 'community',
-    photoshop_move_layer: 'community',
-    photoshop_rotate_layer: 'community',
-    photoshop_get_metadata: 'community',
+    photoshop_transform_layer: 'community',
+    photoshop_warp_layer: 'pro',
+    photoshop_warp_layer_mesh: 'pro',
+    photoshop_transform_canvas: 'community',
+    photoshop_guides: 'community',
+    photoshop_inspect: 'community',
     photoshop_overview: 'community',
     photoshop_get_preview: 'community',
     photoshop_get_layer_bounds_diff: 'community',
     photoshop_compare_regions: 'community',
     photoshop_get_histogram: 'community',
-    photoshop_apply_content_aware_fill: 'community',
-    photoshop_apply_patch: 'community',
-    photoshop_apply_content_aware_move: 'community',
+    photoshop_retouch: 'community',
     photoshop_apply_brush_stroke: 'dev',
-    photoshop_select_rectangle: 'community',
+    photoshop_detect: 'community',
+    photoshop_object: 'dev',
+    photoshop_portrait_touchup: 'dev',
+    photoshop_text_on_object: 'dev',
+    photoshop_detect_landmarks: 'pro',
+    photoshop_select_face_feature: 'pro',
+    photoshop_stroke_face_contour: 'dev',
+    photoshop_scene: 'community',
+    photoshop_select_by_reference: 'community',
+    photoshop_select: 'community',
     photoshop_select_subject: 'pro',
     photoshop_select_sky: 'pro',
-    photoshop_select_color_range: 'community',
-    photoshop_magic_wand: 'community',
-    photoshop_get_selection_info: 'community',
+    photoshop_select_subject_instance: 'pro',
+    photoshop_modify_selection: 'community',
     photoshop_get_selection_preview: 'community',
-    photoshop_feather_selection: 'community',
-    photoshop_select_all: 'community',
-    photoshop_deselect: 'community',
-    photoshop_invert_selection: 'community',
-    photoshop_save_selection_to_channel: 'community',
-    photoshop_load_selection_from_channel: 'community',
-    photoshop_create_layer_mask: 'community',
-    photoshop_delete_layer_mask: 'community',
-    photoshop_apply_layer_mask: 'community',
+    photoshop_selection_channel: 'community',
+    photoshop_layer_mask: 'community',
+    photoshop_path: 'community',
+    photoshop_vector_mask: 'community',
     photoshop_template_create_evidence: 'pro',
     photoshop_template_save: 'pro',
     photoshop_template_list: 'pro',
@@ -90,10 +79,7 @@ export const TOOL_TIERS = {
     photoshop_template_verify: 'pro',
     photoshop_template_recall: 'pro',
     photoshop_template_delete: 'pro',
-    photoshop_set_text_font: 'community',
-    photoshop_set_text_color: 'community',
-    photoshop_set_text_alignment: 'community',
-    photoshop_update_text_content: 'community',
+    photoshop_set_text: 'community',
 };
 export function tierOf(toolName) {
     const tier = TOOL_TIERS[toolName];

package/dist/delivery/bundle.js

@@ -27,6 +27,9 @@ export function unzipBundle(container) {
     const out = [];
     let total = 0;
     for (const e of entries) {
+        if (isUnsafeEntryName(e.entryName)) {
+            throw new BundleError(`bundle entry '${e.entryName}' escapes the install directory`);
+        }
         const declared = e.header?.size ?? 0;
         if (declared > MAX_ENTRY_BYTES) {
             throw new BundleError(`bundle entry '${e.entryName}' is too large (${declared} bytes)`);
@@ -68,6 +71,11 @@ export function safeResolve(root, name) {
     }
     return out;
 }
+export function isUnsafeEntryName(name) {
+    if (isAbsolute(name) || /^[A-Za-z]:[\\/]/.test(name) || /^[\\/]{2}/.test(name))
+        return true;
+    return name.split(/[\\/]/).some((seg) => seg === '..');
+}
 function isCoreBinary(name) {
     const base = name.split('/').pop() ?? name;
     return base.startsWith('editmamei-core-');

package/dist/delivery/config.js

@@ -1,5 +1,28 @@
 const DEFAULT_BASE_URL = 'https://editmamei-delivery.editmamei.workers.dev';
 export function resolveDeliveryConfig(url = process.env.EDITMAMEI_DELIVERY_URL) {
     const baseUrl = (url ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+    assertSecureEndpoint(baseUrl);
     return { baseUrl };
 }
+function assertSecureEndpoint(baseUrl) {
+    if (!baseUrl)
+        return;
+    let u;
+    try {
+        u = new URL(baseUrl);
+    }
+    catch {
+        throw new Error(`EDITMAMEI_DELIVERY_URL is not a valid URL: ${baseUrl}`);
+    }
+    if (u.protocol === 'https:')
+        return;
+    const host = u.hostname;
+    const isLoopback = host === 'localhost' ||
+        host === '::1' ||
+        host === '[::1]' ||
+        /^127(?:\.\d{1,3}){3}$/.test(host);
+    if (u.protocol === 'http:' && isLoopback)
+        return;
+    throw new Error(`EDITMAMEI_DELIVERY_URL must use https (got ${u.protocol}//${host}); ` +
+        'plaintext http is allowed only for localhost during local development.');
+}

package/dist/delivery/provision.js

@@ -25,7 +25,8 @@ export async function provisionModules(key, opts = {}) {
             result.notConfigured = true;
             return result;
         }
-        throw e;
+        result.errors.push({ sku: '*', message: errMsg(e) });
+        return result;
     }
     let manifest;
     try {
@@ -54,6 +55,14 @@ export async function provisionModules(key, opts = {}) {
                 result.skipped.push({ sku, version: latest, reason: 'up-to-date' });
                 continue;
             }
+            if (installed && compareVersions(latest, installed.version) < 0) {
+                result.skipped.push({
+                    sku,
+                    version: latest,
+                    reason: `rollback-blocked (installed v${installed.version} is newer than manifest latest v${latest})`,
+                });
+                continue;
+            }
             const vEntry = entry.versions[latest];
             if (!vEntry) {
                 result.errors.push({ sku, message: `manifest has no descriptor for ${sku} v${latest}` });
@@ -82,7 +91,8 @@ export async function provisionModules(key, opts = {}) {
                 });
                 continue;
             }
-            if (!verifyModuleSignature(sku, latest, digest, vEntry.sig, opts.signingKeys)) {
+            const sig = vEntry.sig;
+            if (!verifyModuleSignature(sku, latest, digest, sig, opts.signingKeys)) {
                 result.errors.push({
                     sku,
                     message: `signature verification failed for ${sku} v${latest} — refusing to install unverified module code`,
@@ -97,6 +107,7 @@ export async function provisionModules(key, opts = {}) {
                 sha256: digest,
                 alg: contentKey.alg,
                 content_key: contentKey.key,
+                sig: sig,
             }, blob, opts);
             result.installed.push({ sku, version: latest });
         }
@@ -109,3 +120,20 @@ export async function provisionModules(key, opts = {}) {
 function errMsg(e) {
     return e instanceof Error ? e.message : String(e);
 }
+function compareVersions(a, b) {
+    const [aCore, aPre] = a.split('-', 2);
+    const [bCore, bPre] = b.split('-', 2);
+    const ap = aCore.split('.').map(Number);
+    const bp = bCore.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (ap[i] !== bp[i])
+            return ap[i] - bp[i];
+    }
+    if (aPre === bPre)
+        return 0;
+    if (aPre === undefined)
+        return 1;
+    if (bPre === undefined)
+        return -1;
+    return aPre < bPre ? -1 : 1;
+}

package/dist/delivery/store.js

@@ -2,12 +2,15 @@ import { join, dirname } from 'node:path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { settingsDir } from '../core/settings.js';
 import { installBundle } from './bundle.js';
+import { sha256Hex } from './crypto.js';
+import { verifyModuleSignature, MODULE_SIGNING_PUBLIC_KEYS } from './signing.js';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('Modules');
 const INSTALLED_FILENAME = 'installed.json';
 export const PRO_SKU = 'pro';
 export const PRO_HANDLERS_ENTRY = 'pro-handlers.mjs';
 const MODULE_MANIFEST = 'manifest.json';
+const MODULE_ARTIFACT = 'artifact.enc';
 export function modulesRoot(opts = {}) {
     return join(settingsDir(opts), 'modules');
 }
@@ -23,6 +26,9 @@ export function moduleHandlersPath(sku, version, opts = {}) {
 export function moduleBinDir(sku, version, opts = {}) {
     return join(installedModuleDir(sku, version, opts), 'bin');
 }
+export function moduleArtifactPath(sku, version, opts = {}) {
+    return join(installedModuleDir(sku, version, opts), MODULE_ARTIFACT);
+}
 function isInstalledModule(v) {
     if (typeof v !== 'object' || v === null)
         return false;
@@ -33,6 +39,7 @@ function isInstalledModule(v) {
         typeof r.sha256 === 'string' &&
         typeof r.alg === 'string' &&
         typeof r.content_key === 'string' &&
+        typeof r.sig === 'string' &&
         typeof r.installed_at === 'string');
 }
 export function readInstalledModule(sku, opts = {}) {
@@ -65,9 +72,41 @@ function writeFileAtomic(path, data) {
     renameSync(tmp, path);
 }
 export function installModule(rec, blob, opts = {}) {
-    installBundle(blob, rec.content_key, installedModuleDir(rec.sku, rec.version, opts));
+    const dir = installedModuleDir(rec.sku, rec.version, opts);
+    installBundle(blob, rec.content_key, dir);
+    writeFileSync(moduleArtifactPath(rec.sku, rec.version, opts), Buffer.from(blob), { mode: 0o600 });
     const now = opts.now ?? Date.now;
     const installed = { ...rec, installed_at: new Date(now()).toISOString() };
     writeFileAtomic(installedPath(rec.sku, opts), JSON.stringify(installed, null, 2) + '\n');
     return installed;
 }
+export function loadVerifiedModule(sku, opts = {}, pubKeys = MODULE_SIGNING_PUBLIC_KEYS) {
+    const rec = readInstalledModule(sku, opts);
+    if (!rec)
+        return null;
+    const version = rec.version;
+    const dir = installedModuleDir(sku, version, opts);
+    try {
+        const blob = readFileSync(moduleArtifactPath(sku, version, opts));
+        const digest = sha256Hex(blob);
+        if (digest !== rec.sha256) {
+            logger.warn(`module '${sku}' v${version} artifact hash changed since install — refusing to load`);
+            return null;
+        }
+        if (!verifyModuleSignature(sku, version, digest, rec.sig, pubKeys)) {
+            logger.warn(`module '${sku}' v${version} signature did not verify at boot — refusing to load`);
+            return null;
+        }
+        installBundle(blob, rec.content_key, dir);
+        return {
+            version,
+            dir,
+            handlersPath: moduleHandlersPath(sku, version, opts),
+            binDir: moduleBinDir(sku, version, opts),
+        };
+    }
+    catch (err) {
+        logger.warn(`module '${sku}' v${version} failed boot verification: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

package/dist/detection/detect-active-doc.js

@@ -0,0 +1,84 @@
+import { readFile } from 'node:fs/promises';
+import { getContextInfo } from '../api/extendscript/_helpers.js';
+import { jsLit, jsNum } from '../utils/jsx.js';
+import { runScript } from '../utils/run-script.js';
+import { TempDir, userOwnedTempRoot } from '../utils/temp.js';
+import { mapDetectionToDoc, } from './detection-client.js';
+export async function detectActiveDoc(connection, client, opts) {
+    const maxDimension = opts.maxDimension ?? 1024;
+    const dir = process.platform === 'darwin'
+        ? await TempDir.createWithRoot(userOwnedTempRoot(), 'editmamei-detect-')
+        : await TempDir.create('editmamei-detect-');
+    try {
+        const tempPath = dir.path('detect.jpg');
+        const script = `
+      ${getContextInfo}
+      if (app.documents.length === 0) { throw new Error('No active document'); }
+      for (var __pi = app.documents.length - 1; __pi >= 0; __pi--) {
+        try {
+          var __pd = app.documents[__pi];
+          if (String(__pd.name).indexOf('__mcp_detect__') !== -1) {
+            try { __pd.close(SaveOptions.DONOTSAVECHANGES); } catch (e0) {}
+          }
+        } catch (e1) {}
+      }
+      var orig = app.activeDocument;
+      var origW = orig.width.as('px');
+      var origH = orig.height.as('px');
+      var dup = orig.duplicate(orig.name + ' __mcp_detect__');
+      try {
+        var w = dup.width.as('px');
+        var h = dup.height.as('px');
+        var longEdge = (w > h) ? w : h;
+        if (longEdge > ${jsNum(maxDimension, 1024)}) {
+          var scale = ${jsNum(maxDimension, 1024)} / longEdge;
+          dup.resizeImage(
+            UnitValue(Math.round(w * scale), 'px'),
+            UnitValue(Math.round(h * scale), 'px'),
+            null,
+            ResampleMethod.BICUBIC
+          );
+        }
+        var outFile = new File(${jsLit(tempPath)});
+        var opts = new JPEGSaveOptions();
+        opts.quality = 8;
+        opts.embedColorProfile = true;
+        opts.formatOptions = FormatOptions.STANDARDBASELINE;
+        dup.saveAs(outFile, opts, true, Extension.LOWERCASE);
+        if (!outFile.exists) {
+          try { dup.close(SaveOptions.DONOTSAVECHANGES); } catch (eD) {}
+          try { app.activeDocument = orig; } catch (eA) {}
+          throw new Error('JPEG saveAs reported success but no file at ' + outFile.fsName);
+        }
+        dup.close(SaveOptions.DONOTSAVECHANGES);
+        app.activeDocument = orig;
+        return { ok: true, doc_width: origW, doc_height: origH, context: getContextInfo() };
+      } catch (e) {
+        try { dup.close(SaveOptions.DONOTSAVECHANGES); } catch (e2) {}
+        try { app.activeDocument = orig; } catch (e3) {}
+        throw e;
+      }
+    `;
+        const exp = (await runScript(connection, script));
+        const docWidth = exp.doc_width ?? 0;
+        const docHeight = exp.doc_height ?? 0;
+        const raw = await client.detect(tempPath, {
+            faces: opts.faces,
+            objects: opts.objects,
+            faceThreshold: opts.faceThreshold,
+            objectThreshold: opts.objectThreshold,
+            maxObjects: opts.maxObjects,
+        });
+        let exportBytes = Buffer.alloc(0);
+        try {
+            exportBytes = await readFile(tempPath);
+        }
+        catch {
+        }
+        const result = mapDetectionToDoc(raw, docWidth, docHeight);
+        return { docWidth, docHeight, result, raw, context: exp.context, exportBytes };
+    }
+    finally {
+        await dir.cleanup();
+    }
+}

package/dist/detection/detection-client.js

@@ -0,0 +1,62 @@
+import { detectFaces } from './face-detector.js';
+import { detectObjects } from './object-detector.js';
+export class OnnxDetectionClient {
+    async detect(imagePath, opts) {
+        const wantFaces = opts.faces ?? false;
+        const wantObjects = opts.objects ?? false;
+        const [faceRes, objRes] = await Promise.all([
+            wantFaces ? detectFaces(imagePath, opts.faceThreshold) : Promise.resolve(null),
+            wantObjects
+                ? detectObjects(imagePath, { threshold: opts.objectThreshold, maxObjects: opts.maxObjects })
+                : Promise.resolve(null),
+        ]);
+        const dims = faceRes ?? objRes;
+        const result = {
+            image: { width: dims?.width ?? 0, height: dims?.height ?? 0 },
+            backends: {},
+        };
+        if (faceRes) {
+            result.faces = faceRes.faces.map((f) => ({ bbox: f.bbox, confidence: f.confidence }));
+            result.backends.faces = 'ultraface';
+        }
+        if (objRes) {
+            result.objects = objRes.objects.map((o) => ({
+                label: o.label,
+                class_id: o.class_id,
+                bbox: o.bbox,
+                confidence: o.confidence,
+            }));
+            result.backends.objects = 'dfine-s';
+        }
+        return result;
+    }
+}
+export function mapDetectionToDoc(result, docWidth, docHeight) {
+    const sx = result.image.width ? docWidth / result.image.width : 1;
+    const sy = result.image.height ? docHeight / result.image.height : 1;
+    const clamp = (v, max) => Math.min(Math.max(v, 0), max);
+    const rect = (r) => {
+        const x1 = clamp(Math.round(r[0] * sx), docWidth);
+        const y1 = clamp(Math.round(r[1] * sy), docHeight);
+        const x2 = clamp(Math.round(r[2] * sx), docWidth);
+        const y2 = clamp(Math.round(r[3] * sy), docHeight);
+        return [Math.min(x1, x2), Math.min(y1, y2), Math.max(x1, x2), Math.max(y1, y2)];
+    };
+    const scaleFeatures = (feat) => ({
+        ...feat,
+        points: feat.points.map((p) => ({ x: p.x * sx, y: p.y * sy, z: p.z })),
+    });
+    const mapFace = (f) => ({
+        ...f,
+        bbox: rect(f.bbox),
+        ...(f.features ? { features: scaleFeatures(f.features) } : {}),
+    });
+    return {
+        image: { width: docWidth, height: docHeight },
+        backends: result.backends,
+        ...(result.faces ? { faces: result.faces.map(mapFace) } : {}),
+        ...(result.objects
+            ? { objects: result.objects.map((o) => ({ ...o, bbox: rect(o.bbox) })) }
+            : {}),
+    };
+}

package/dist/detection/face-contour-geometry.js

@@ -0,0 +1,137 @@
+import { LANDMARK_GROUPS } from './landmark-spec.js';
+export const FACE_CONTOURS = [
+    'jawline',
+    'nose_bridge',
+    'cheekbone_left',
+    'cheekbone_right',
+    'cheekbones',
+    'under_eye_left',
+    'under_eye_right',
+    'under_eyes',
+];
+const JAWLINE_IDX = [
+    234, 93, 132, 58, 172, 136, 150, 149, 176, 148, 152, 377, 400, 378, 379, 365, 397, 288, 361, 454,
+];
+const NOSE_BRIDGE_IDX = [168, 6, 197, 195, 5, 4, 1];
+const ALA_LEFT = 358;
+const ALA_RIGHT = 129;
+function poly(points, idx) {
+    const out = [];
+    for (const i of idx) {
+        const p = points[i];
+        if (p)
+            out.push([p.x, p.y]);
+    }
+    return out;
+}
+function midY(pts) {
+    if (pts.length === 0)
+        return 0;
+    return pts.reduce((s, p) => s + p[1], 0) / pts.length;
+}
+function lowerLid(points, idx) {
+    const ring = poly(points, idx);
+    if (ring.length < 3)
+        return [];
+    const cy = midY(ring);
+    const lower = ring.filter((p) => p[1] >= cy);
+    lower.sort((a, b) => a[0] - b[0]);
+    return lower;
+}
+function cheekbone(points, eyeIdx, alaIdx) {
+    const ring = poly(points, eyeIdx);
+    if (ring.length < 3)
+        return [];
+    const ala = points[alaIdx];
+    if (!ala)
+        return [];
+    let minX = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const [x, y] of ring) {
+        if (x < minX)
+            minX = x;
+        if (x > maxX)
+            maxX = x;
+        if (y > maxY)
+            maxY = y;
+    }
+    const outerX = Math.abs(minX - ala.x) > Math.abs(maxX - ala.x) ? minX : maxX;
+    const cy = midY(ring);
+    const innerX = outerX === minX ? maxX : minX;
+    const apple = [(innerX + ala.x) / 2, (maxY + ala.y) / 2];
+    const mid = [(apple[0] + outerX) / 2, (apple[1] + cy) / 2];
+    const temple = [outerX, cy];
+    return [apple, mid, temple];
+}
+export function catmullRomAnchors(line) {
+    const n = line.length;
+    if (n === 0)
+        return [];
+    if (n === 1)
+        return [{ x: line[0][0], y: line[0][1] }];
+    if (n === 2) {
+        return [
+            { x: line[0][0], y: line[0][1] },
+            { x: line[1][0], y: line[1][1] },
+        ];
+    }
+    const anchors = [];
+    for (let i = 0; i < n; i++) {
+        const [x, y] = line[i];
+        const prev = line[i - 1] ?? line[i];
+        const next = line[i + 1] ?? line[i];
+        const tx = (next[0] - prev[0]) / 6;
+        const ty = (next[1] - prev[1]) / 6;
+        const anchor = { x, y };
+        if (i > 0)
+            anchor.in = [x - tx, y - ty];
+        if (i < n - 1)
+            anchor.out = [x + tx, y + ty];
+        anchors.push(anchor);
+    }
+    return anchors;
+}
+function roundAnchor(a) {
+    const r = { x: Math.round(a.x), y: Math.round(a.y) };
+    if (a.in)
+        r.in = [Math.round(a.in[0]), Math.round(a.in[1])];
+    if (a.out)
+        r.out = [Math.round(a.out[0]), Math.round(a.out[1])];
+    return r;
+}
+export function buildContourAnchors(points, contour) {
+    const line = contourPolyline(points, contour);
+    if (!line || line.length < 2)
+        return null;
+    return catmullRomAnchors(line).map(roundAnchor);
+}
+function contourPolyline(points, contour) {
+    switch (contour) {
+        case 'jawline':
+            return orNull(poly(points, JAWLINE_IDX));
+        case 'nose_bridge':
+            return orNull(poly(points, NOSE_BRIDGE_IDX));
+        case 'cheekbone_left':
+            return orNull(cheekbone(points, LANDMARK_GROUPS.leftEye, ALA_LEFT));
+        case 'cheekbone_right':
+            return orNull(cheekbone(points, LANDMARK_GROUPS.rightEye, ALA_RIGHT));
+        case 'under_eye_left':
+            return orNull(lowerLid(points, LANDMARK_GROUPS.leftEye));
+        case 'under_eye_right':
+            return orNull(lowerLid(points, LANDMARK_GROUPS.rightEye));
+        case 'cheekbones':
+        case 'under_eyes':
+            return null;
+        default:
+            return null;
+    }
+}
+function orNull(p) {
+    return p.length >= 2 ? p : null;
+}
+export function contourSides(contour) {
+    if (contour === 'cheekbones')
+        return ['cheekbone_left', 'cheekbone_right'];
+    if (contour === 'under_eyes')
+        return ['under_eye_left', 'under_eye_right'];
+    return [contour];
+}

package/dist/detection/face-detector.js

@@ -0,0 +1,34 @@
+import { loadModel, resolveModelPath, decodeJpeg, ort } from './runtime.js';
+import { greedyNms, resizeToCHW } from './geometry.js';
+const MODEL_FILE = 'ultraface-rfb-320.onnx';
+const IN_W = 320;
+const IN_H = 240;
+const DEFAULT_THRESHOLD = 0.7;
+const IOU_THRESHOLD = 0.4;
+export async function detectFaces(imagePath, threshold = DEFAULT_THRESHOLD) {
+    const img = decodeJpeg(imagePath);
+    const session = await loadModel(resolveModelPath(MODEL_FILE));
+    const input = resizeToCHW(img, IN_W, IN_H, (v) => (v - 127) / 128);
+    const feeds = { input: new ort.Tensor('float32', input, [1, 3, IN_H, IN_W]) };
+    const out = await session.run(feeds);
+    const scores = out.scores.data;
+    const boxes = out.boxes.data;
+    const n = out.scores.dims[1];
+    const cand = [];
+    for (let i = 0; i < n; i++) {
+        const faceProb = scores[i * 2 + 1];
+        if (faceProb > threshold) {
+            cand.push({
+                confidence: faceProb,
+                bbox: [
+                    boxes[i * 4] * img.width,
+                    boxes[i * 4 + 1] * img.height,
+                    boxes[i * 4 + 2] * img.width,
+                    boxes[i * 4 + 3] * img.height,
+                ],
+            });
+        }
+    }
+    cand.sort((p, q) => q.confidence - p.confidence);
+    return { width: img.width, height: img.height, faces: greedyNms(cand, IOU_THRESHOLD) };
+}