editmamei 0.22.4 → 0.24.1

package/dist/delivery/client.js

@@ -11,6 +11,7 @@ export class DeliveryError extends Error {
         this.name = 'DeliveryError';
     }
 }
+const MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
 const USER_AGENT = 'editmamei-delivery-client/1';
 const HEADER_KEY = 'x-editmamei-license-key';
 const defaultFetch = (url, init) => fetch(url, init);
@@ -23,6 +24,7 @@ export class DeliveryClient {
     retry;
     sleep;
     minIntervalMs;
+    maxArtifactBytes;
     lastRequestAt = 0;
     constructor(opts = {}) {
         this.cfg = opts.config ?? resolveDeliveryConfig();
@@ -30,6 +32,7 @@ export class DeliveryClient {
         this.retry = { ...DEFAULT_RETRY, ...opts.retry };
         this.sleep = opts.sleep ?? defaultSleep;
         this.minIntervalMs = opts.minRequestIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+        this.maxArtifactBytes = opts.maxArtifactBytes ?? MAX_ARTIFACT_BYTES;
         if (!this.cfg.baseUrl) {
             throw new DeliveryError('Delivery endpoint is not configured. Set EDITMAMEI_DELIVERY_URL ' +
                 '(e.g. http://localhost:8787 for a local wrangler dev Worker).', 0, 'not_configured');
@@ -52,9 +55,55 @@ export class DeliveryClient {
             const res = await this.get(`/v1/modules/${sku}/${version}`, key);
             if (!res.ok)
                 throw this.errorFor(res.status, await safeText(res), this.retryAfterMsOf(res));
-            return new Uint8Array(await res.arrayBuffer());
+            const declared = Number(res.headers?.get('content-length'));
+            if (Number.isFinite(declared) && declared > this.maxArtifactBytes) {
+                throw this.oversizeError(res.status, declared);
+            }
+            const body = res.body;
+            if (!body) {
+                const buf = new Uint8Array(await res.arrayBuffer());
+                if (buf.length > this.maxArtifactBytes)
+                    throw this.oversizeError(res.status, buf.length);
+                return buf;
+            }
+            return await this.readCapped(body, res.status);
         });
     }
+    async readCapped(body, status) {
+        const reader = body.getReader();
+        const chunks = [];
+        let total = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                total += value.byteLength;
+                if (total > this.maxArtifactBytes) {
+                    try {
+                        await reader.cancel('artifact exceeds byte cap');
+                    }
+                    catch {
+                    }
+                    throw this.oversizeError(status, total);
+                }
+                chunks.push(value);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        const out = new Uint8Array(total);
+        let offset = 0;
+        for (const chunk of chunks) {
+            out.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return out;
+    }
+    oversizeError(status, sizeBytes) {
+        return new DeliveryError(`Artifact exceeds the ${this.maxArtifactBytes}-byte cap (${sizeBytes} bytes) — refusing to buffer further.`, status, 'oversize');
+    }
     async withRetry(fn) {
         let lastErr;
         for (let attempt = 1; attempt <= this.retry.attempts; attempt++) {

package/dist/delivery/provision.js

@@ -1,7 +1,9 @@
 import { DeliveryClient, DeliveryError } from './client.js';
 import { sha256Hex } from './crypto.js';
-import { verifyModuleSignature } from './signing.js';
+import { verifyModuleSignature, verifyModuleSignatureV2, digestsRootSha256Hex, isModuleFileDigestArray, } from './signing.js';
 import { installModule, readInstalledModule } from './store.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('Modules');
 const SKU_RE = /^[a-z0-9-]{2,32}$/;
 const VERSION_RE = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
 const MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
@@ -99,6 +101,20 @@ export async function provisionModules(key, opts = {}) {
                 });
                 continue;
             }
+            let filesForRec;
+            let sigV2ForRec;
+            if (vEntry.files !== undefined || vEntry.sig_v2 !== undefined) {
+                if (isModuleFileDigestArray(vEntry.files) &&
+                    typeof vEntry.sig_v2 === 'string' &&
+                    verifyModuleSignatureV2(sku, latest, digest, digestsRootSha256Hex(vEntry.files), vEntry.sig_v2, opts.signingKeys)) {
+                    filesForRec = vEntry.files;
+                    sigV2ForRec = vEntry.sig_v2;
+                }
+                else {
+                    logger.warn(`${sku} v${latest} manifest carried v2 fast-boot fields that failed verification — ` +
+                        `installing via v1 trust only (boot will keep doing the full regen for this module)`);
+                }
+            }
             const contentKey = await client.fetchKey(key, sku);
             installModule({
                 sku,
@@ -108,6 +124,7 @@ export async function provisionModules(key, opts = {}) {
                 alg: contentKey.alg,
                 content_key: contentKey.key,
                 sig: sig,
+                ...(filesForRec && sigV2ForRec ? { files: filesForRec, sig_v2: sigV2ForRec } : {}),
             }, blob, opts);
             result.installed.push({ sku, version: latest });
         }

package/dist/delivery/signing.js

@@ -1,4 +1,4 @@
-import { createPublicKey, verify } from 'node:crypto';
+import { createHash, createPublicKey, verify } from 'node:crypto';
 export const DEV_MODULE_SIGNING_PUBLIC_KEY = 'MCowBQYDK2VwAyEA0DfcGMets2SlBofK4iFzLddKZB6mJF/E3beKFpLRN2o=';
 const PROD_MODULE_SIGNING_PUBLIC_KEY = 'MCowBQYDK2VwAyEAweoGOWvtf+aukiAD0FpuECSbCdZMeFzF2XYzbFWwfwo=';
 export const MODULE_SIGNING_PUBLIC_KEYS = [PROD_MODULE_SIGNING_PUBLIC_KEY];
@@ -33,3 +33,40 @@ export function verifyModuleSignature(sku, version, sha256Hex, sigB64, pubKeys =
     }
     return false;
 }
+export function isModuleFileDigestArray(v) {
+    return (Array.isArray(v) &&
+        v.every((e) => typeof e === 'object' &&
+            e !== null &&
+            typeof e.path === 'string' &&
+            typeof e.sha256 === 'string'));
+}
+export function canonicalDigestListString(files) {
+    const sorted = [...files].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+    return JSON.stringify(sorted.map((f) => ({ path: f.path, sha256: f.sha256 })));
+}
+export function digestsRootSha256Hex(files) {
+    return createHash('sha256').update(canonicalDigestListString(files), 'utf8').digest('hex');
+}
+export function moduleSigV2Message(sku, version, artifactSha256Hex, digestsRootHex) {
+    return Buffer.from(`editmamei-module-sig-v2\n${sku}\n${version}\n${artifactSha256Hex}\n${digestsRootHex}`, 'utf8');
+}
+export function verifyModuleSignatureV2(sku, version, artifactSha256Hex, digestsRootHex, sigB64, pubKeys = MODULE_SIGNING_PUBLIC_KEYS) {
+    if (!sigB64)
+        return false;
+    const sig = Buffer.from(sigB64, 'base64');
+    if (sig.length === 0)
+        return false;
+    const msg = moduleSigV2Message(sku, version, artifactSha256Hex, digestsRootHex);
+    for (const b64 of pubKeys) {
+        const key = importSpki(b64);
+        if (!key)
+            continue;
+        try {
+            if (verify(null, msg, key, sig))
+                return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}

package/dist/delivery/store.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, readdir
 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 { verifyModuleSignature, verifyModuleSignatureV2, digestsRootSha256Hex, isModuleFileDigestArray, MODULE_SIGNING_PUBLIC_KEYS, } from './signing.js';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('Modules');
 const INSTALLED_FILENAME = 'installed.json';
@@ -31,7 +31,7 @@ export function moduleBinDir(sku, version, opts = {}) {
 export function moduleArtifactPath(sku, version, opts = {}) {
     return join(installedModuleDir(sku, version, opts), MODULE_ARTIFACT);
 }
-function isInstalledModule(v) {
+function isInstalledModuleBase(v) {
     if (typeof v !== 'object' || v === null)
         return false;
     const r = v;
@@ -50,16 +50,27 @@ export function readInstalledModule(sku, opts = {}) {
         return null;
     try {
         const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        if (!isInstalledModule(parsed)) {
+        if (!isInstalledModuleBase(parsed)) {
             logger.warn(`installed.json for '${sku}' malformed — ignoring`);
             return null;
         }
-        const manifest = join(installedModuleDir(sku, parsed.version, opts), MODULE_MANIFEST);
+        const filesOk = parsed.files === undefined || isModuleFileDigestArray(parsed.files);
+        const sigV2Ok = parsed.sig_v2 === undefined || typeof parsed.sig_v2 === 'string';
+        const bothPresent = parsed.files !== undefined && parsed.sig_v2 !== undefined;
+        const bothAbsent = parsed.files === undefined && parsed.sig_v2 === undefined;
+        if (!filesOk || !sigV2Ok || !(bothPresent || bothAbsent)) {
+            logger.warn(`installed.json for '${sku}' carried malformed v2 fast-boot fields — dropping ` +
+                `them and falling back to the v1 path`);
+            delete parsed.files;
+            delete parsed.sig_v2;
+        }
+        const rec = parsed;
+        const manifest = join(installedModuleDir(sku, rec.version, opts), MODULE_MANIFEST);
         if (!existsSync(manifest)) {
-            logger.warn(`module '${sku}' v${parsed.version} install incomplete — ignoring pointer`);
+            logger.warn(`module '${sku}' v${rec.version} install incomplete — ignoring pointer`);
             return null;
         }
-        return parsed;
+        return rec;
     }
     catch (err) {
         logger.warn(`installed.json for '${sku}' unreadable: ${err instanceof Error ? err.message : String(err)}`);
@@ -73,6 +84,9 @@ function writeFileAtomic(path, data) {
     writeFileSync(tmp, data, { mode: 0o600 });
     renameSync(tmp, path);
 }
+function writeInstalledModule(rec, opts = {}) {
+    writeFileAtomic(installedPath(rec.sku, opts), JSON.stringify(rec, null, 2) + '\n');
+}
 export function installModule(rec, blob, opts = {}) {
     const finalDir = installedModuleDir(rec.sku, rec.version, opts);
     const skuDir = dirname(finalDir);
@@ -87,19 +101,37 @@ export function installModule(rec, blob, opts = {}) {
         throw err;
     }
     if (opts.force && existsSync(finalDir)) {
-        rmSync(finalDir, { recursive: true, force: true });
-    }
-    try {
-        renameSync(tmpDir, finalDir);
+        const oldDir = join(skuDir, `${TMP_PREFIX}old-${rec.version}-${process.pid}`);
+        rmSync(oldDir, { recursive: true, force: true });
+        renameSync(finalDir, oldDir);
+        try {
+            renameSync(tmpDir, finalDir);
+            rmSync(oldDir, { recursive: true, force: true });
+        }
+        catch (err) {
+            rmSync(tmpDir, { recursive: true, force: true });
+            if (existsSync(finalDir)) {
+                rmSync(oldDir, { recursive: true, force: true });
+            }
+            else {
+                renameSync(oldDir, finalDir);
+                throw err;
+            }
+        }
     }
-    catch (err) {
-        rmSync(tmpDir, { recursive: true, force: true });
-        if (!existsSync(finalDir))
-            throw err;
+    else {
+        try {
+            renameSync(tmpDir, finalDir);
+        }
+        catch (err) {
+            rmSync(tmpDir, { recursive: true, force: true });
+            if (!existsSync(finalDir))
+                throw err;
+        }
     }
     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');
+    writeInstalledModule(installed, opts);
     pruneOldModuleVersions(rec.sku, rec.version, opts);
     return installed;
 }
@@ -139,12 +171,72 @@ export function pruneOldModuleVersions(sku, keepVersion, opts = {}) {
         }
     }
 }
+function verifyFastPath(sku, version, dir, artifactSha256Hex, files, sigV2, pubKeys) {
+    const digestsRoot = digestsRootSha256Hex(files);
+    if (!verifyModuleSignatureV2(sku, version, artifactSha256Hex, digestsRoot, sigV2, pubKeys)) {
+        return { ok: false, reason: 'sig_v2 did not verify against the pinned key' };
+    }
+    const expected = new Set(files.map((f) => f.path));
+    expected.add(MODULE_ARTIFACT);
+    let onDisk;
+    try {
+        onDisk = listFilesRecursive(dir);
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: `tree enumeration failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const onDiskSet = new Set(onDisk);
+    for (const p of expected) {
+        if (!onDiskSet.has(p))
+            return { ok: false, reason: `missing file '${p}'` };
+    }
+    for (const p of onDisk) {
+        if (!expected.has(p))
+            return { ok: false, reason: `unexpected file '${p}'` };
+    }
+    for (const f of files) {
+        let bytes;
+        try {
+            bytes = readFileSync(join(dir, f.path));
+        }
+        catch (err) {
+            return {
+                ok: false,
+                reason: `could not read '${f.path}': ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        if (sha256Hex(bytes) !== f.sha256) {
+            return { ok: false, reason: `content mismatch on '${f.path}'` };
+        }
+    }
+    return { ok: true };
+}
+function listFilesRecursive(dir) {
+    const out = [];
+    const walk = (sub) => {
+        for (const entry of readdirSync(join(dir, sub), { withFileTypes: true })) {
+            const relPath = sub ? `${sub}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                walk(relPath);
+            }
+            else {
+                out.push(relPath);
+            }
+        }
+    };
+    walk('');
+    return out;
+}
 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);
+    const skuDir = dirname(dir);
     try {
         const blob = readFileSync(moduleArtifactPath(sku, version, opts));
         const digest = sha256Hex(blob);
@@ -156,12 +248,53 @@ export function loadVerifiedModule(sku, opts = {}, pubKeys = MODULE_SIGNING_PUBL
             logger.warn(`module '${sku}' v${version} signature did not verify at boot — refusing to load`);
             return null;
         }
-        installBundle(blob, rec.content_key, dir);
+        if (rec.files && rec.sig_v2) {
+            const fast = verifyFastPath(sku, version, dir, digest, rec.files, rec.sig_v2, pubKeys);
+            if (fast.ok) {
+                return {
+                    version,
+                    dir,
+                    handlersPath: moduleHandlersPath(sku, version, opts),
+                    binDir: moduleBinDir(sku, version, opts),
+                    regenerated: false,
+                };
+            }
+            logger.warn(`module '${sku}' v${version} fast-path check failed (${fast.reason}) — ` +
+                `regenerating from the verified artifact`);
+        }
+        const regenDir = join(skuDir, `${TMP_PREFIX}regen-${version}-${process.pid}`);
+        rmSync(regenDir, { recursive: true, force: true });
+        try {
+            installBundle(blob, rec.content_key, regenDir);
+            writeFileSync(join(regenDir, MODULE_ARTIFACT), Buffer.from(blob), { mode: 0o600 });
+        }
+        catch (err) {
+            rmSync(regenDir, { recursive: true, force: true });
+            throw err;
+        }
+        const oldDir = join(skuDir, `${TMP_PREFIX}regen-old-${version}-${process.pid}`);
+        rmSync(oldDir, { recursive: true, force: true });
+        renameSync(dir, oldDir);
+        try {
+            renameSync(regenDir, dir);
+            rmSync(oldDir, { recursive: true, force: true });
+        }
+        catch (err) {
+            rmSync(regenDir, { recursive: true, force: true });
+            if (existsSync(dir)) {
+                rmSync(oldDir, { recursive: true, force: true });
+            }
+            else {
+                renameSync(oldDir, dir);
+                throw err;
+            }
+        }
         return {
             version,
             dir,
             handlersPath: moduleHandlersPath(sku, version, opts),
             binDir: moduleBinDir(sku, version, opts),
+            regenerated: true,
         };
     }
     catch (err) {

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

@@ -3,8 +3,13 @@ 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 { decodeJpegBuffer } from './runtime.js';
 import { mapDetectionToDoc, } from './detection-client.js';
-export async function detectActiveDoc(connection, client, opts) {
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('detect-active-doc');
+export async function detectActiveDoc(connection, client, opts, deps = {}) {
+    const readFileFn = deps.readFile ?? readFile;
+    const decodeFn = deps.decode ?? decodeJpegBuffer;
     const maxDimension = opts.maxDimension ?? 1024;
     const dir = process.platform === 'darwin'
         ? await TempDir.createWithRoot(userOwnedTempRoot(), 'editmamei-detect-')
@@ -62,21 +67,47 @@ export async function detectActiveDoc(connection, client, opts) {
         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);
+        let decoded;
         try {
-            exportBytes = await readFile(tempPath);
+            exportBytes = await readFileFn(tempPath);
         }
         catch {
         }
+        if (exportBytes.length > 0) {
+            try {
+                decoded = decodeFn(exportBytes);
+            }
+            catch {
+            }
+        }
+        let doDetect = true;
+        if (opts.shouldDetect) {
+            try {
+                doDetect = opts.shouldDetect({ decoded, context: exp.context, docWidth, docHeight });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.debug(`shouldDetect threw (${msg}) — degrading to detect normally`);
+                doDetect = true;
+            }
+        }
+        const raw = doDetect
+            ? await client.detect(tempPath, {
+                faces: opts.faces,
+                objects: opts.objects,
+                faceThreshold: opts.faceThreshold,
+                objectThreshold: opts.objectThreshold,
+                maxObjects: opts.maxObjects,
+            }, decoded)
+            : {
+                image: decoded
+                    ? { width: decoded.width, height: decoded.height }
+                    : { width: 0, height: 0 },
+                backends: {},
+            };
         const result = mapDetectionToDoc(raw, docWidth, docHeight);
-        return { docWidth, docHeight, result, raw, context: exp.context, exportBytes };
+        return { docWidth, docHeight, result, raw, context: exp.context, exportBytes, decoded };
     }
     finally {
         await dir.cleanup();

package/dist/detection/detection-client.js

@@ -1,13 +1,13 @@
 import { detectFaces } from './face-detector.js';
 import { detectObjects } from './object-detector.js';
 export class OnnxDetectionClient {
-    async detect(imagePath, opts) {
+    async detect(imagePath, opts, decoded) {
         const wantFaces = opts.faces ?? false;
         const wantObjects = opts.objects ?? false;
         const [faceRes, objRes] = await Promise.all([
-            wantFaces ? detectFaces(imagePath, opts.faceThreshold) : Promise.resolve(null),
+            wantFaces ? detectFaces(imagePath, opts.faceThreshold, decoded) : Promise.resolve(null),
             wantObjects
-                ? detectObjects(imagePath, { threshold: opts.objectThreshold, maxObjects: opts.maxObjects })
+                ? detectObjects(imagePath, { threshold: opts.objectThreshold, maxObjects: opts.maxObjects }, decoded)
                 : Promise.resolve(null),
         ]);
         const dims = faceRes ?? objRes;

package/dist/detection/face-detector.js

@@ -5,8 +5,8 @@ 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);
+export async function detectFaces(imagePath, threshold = DEFAULT_THRESHOLD, decoded) {
+    const img = decoded ?? 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]) };

package/dist/detection/geometry.js

@@ -7,6 +7,20 @@ export function iou(a, b) {
     const ua = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter;
     return inter / (ua + 1e-9);
 }
+const cx = (b) => (b[0] + b[2]) / 2;
+const cy = (b) => (b[1] + b[3]) / 2;
+const boxArea = (b) => (b[2] - b[0]) * (b[3] - b[1]);
+export function orderBySpatialPick(items, pick) {
+    const cmp = {
+        leftmost: (a, b) => cx(a.bbox) - cx(b.bbox),
+        rightmost: (a, b) => cx(b.bbox) - cx(a.bbox),
+        topmost: (a, b) => cy(a.bbox) - cy(b.bbox),
+        bottommost: (a, b) => cy(b.bbox) - cy(a.bbox),
+        largest: (a, b) => boxArea(b.bbox) - boxArea(a.bbox),
+        smallest: (a, b) => boxArea(a.bbox) - boxArea(b.bbox),
+    };
+    return [...items].sort(cmp[pick]);
+}
 export function greedyNms(items, iouThreshold, sameGroup) {
     const keep = [];
     for (const item of items) {

package/dist/detection/landmark-detection-client.js

@@ -14,11 +14,11 @@ export class OnnxLandmarkDetectionClient {
         this.detectLandmarks = deps.detectLandmarks ?? realDetectLandmarks;
         this.decodeJpeg = deps.decodeJpeg ?? realDecodeJpeg;
     }
-    async detect(imagePath, opts) {
-        const result = await this.base.detect(imagePath, opts);
+    async detect(imagePath, opts, decoded) {
+        const result = await this.base.detect(imagePath, opts, decoded);
         if (!opts.faces || !result.faces || result.faces.length === 0)
             return result;
-        const img = this.decodeJpeg(imagePath);
+        const img = decoded ?? this.decodeJpeg(imagePath);
         const minScore = this.opts.minScore ?? 0.5;
         const lmOpts = { margin: this.opts.margin };
         const correctEyes = this.opts.correctEyes ?? true;

package/dist/detection/mesh-face.js

@@ -1,3 +1,4 @@
+import { orderBySpatialPick } from './geometry.js';
 export function meshFaces(faces) {
     const out = [];
     for (const f of faces) {
@@ -21,11 +22,9 @@ export function pickFace(faces, which) {
         case 'best':
             return [...faces].sort((a, b) => b.score - a.score || area(b) - area(a))[0];
         case 'leftmost':
-            return byLeft[0];
         case 'rightmost':
-            return byLeft[byLeft.length - 1];
         case 'largest':
-            return [...faces].sort((a, b) => area(b) - area(a))[0];
+            return orderBySpatialPick(faces, which)[0];
         default: {
             const idx = Number.parseInt(which, 10);
             if (String(idx) === which.trim() && idx >= 0 && idx < byLeft.length)

package/dist/detection/object-detector.js

@@ -90,10 +90,10 @@ export const COCO_LABELS = [
     'toothbrush',
 ];
 const sigmoid = (x) => 1 / (1 + Math.exp(-x));
-export async function detectObjects(imagePath, opts = {}) {
+export async function detectObjects(imagePath, opts = {}, decoded) {
     const threshold = opts.threshold ?? DEFAULT_THRESHOLD;
     const maxObjects = opts.maxObjects ?? DEFAULT_MAX;
-    const img = decodeJpeg(imagePath);
+    const img = decoded ?? decodeJpeg(imagePath);
     const session = await loadModel(resolveModelPath(MODEL_FILE));
     const input = resizeToCHW(img, IN_SIZE, IN_SIZE, (v) => v / 255);
     const feeds = { pixel_values: new ort.Tensor('float32', input, [1, 3, IN_SIZE, IN_SIZE]) };

package/dist/detection/runtime.js

@@ -57,14 +57,25 @@ export function resolveModelPath(filename) {
     }
     return join(hostModelsDir(), filename);
 }
+function decodeJpegBytes(bytes) {
+    const img = decode(bytes, { useTArray: true, formatAsRGBA: true });
+    return { width: img.width, height: img.height, data: img.data };
+}
+export function decodeJpegBuffer(bytes) {
+    try {
+        return decodeJpegBytes(bytes);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`failed to decode JPEG buffer: ${msg}`);
+    }
+}
 export function decodeJpeg(path) {
-    let img;
     try {
-        img = decode(readFileSync(path), { useTArray: true, formatAsRGBA: true });
+        return decodeJpegBytes(readFileSync(path));
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         throw new Error(`failed to decode JPEG at ${path}: ${msg}`);
     }
-    return { width: img.width, height: img.height, data: img.data };
 }