editmamei 0.23.0 → 0.24.1

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 };
 }

package/dist/detection/sam-segmenter.js

@@ -37,40 +37,83 @@ export function thresholdMask(maskData, n) {
         mask[i] = maskData[i] > 0 ? 1 : 0;
     return mask;
 }
+const HASH_SAMPLE_BYTES = 4096;
+const HASH_STRIDE_SAMPLES = 1024;
+function fnv1a(data, start, end, seed) {
+    let h = seed;
+    for (let i = start; i < end; i++) {
+        h = Math.imul(h ^ data[i], 0x01000193) >>> 0;
+    }
+    return h;
+}
+function computeImageKey(img) {
+    const { width, height, data } = img;
+    const n = data.length;
+    let h = fnv1a(data, 0, Math.min(HASH_SAMPLE_BYTES, n), 0x811c9dc5);
+    h = fnv1a(data, Math.max(0, n - HASH_SAMPLE_BYTES), n, h);
+    const stride = Math.max(1, Math.floor(n / HASH_STRIDE_SAMPLES));
+    for (let i = 0; i < n; i += stride) {
+        h = Math.imul(h ^ data[i], 0x01000193) >>> 0;
+    }
+    return { width, height, byteLength: n, hash: h };
+}
+function sameImageKey(a, b) {
+    return (a.width === b.width &&
+        a.height === b.height &&
+        a.byteLength === b.byteLength &&
+        a.hash === b.hash);
+}
+async function realRunEncoder(img) {
+    const session = await loadModel(resolveModelPath(MODEL_ENCODER));
+    const input = new ort.Tensor('float32', toEncoderInput(img), [img.height, img.width, 3]);
+    const out = await session.run({ input_image: input });
+    return out.image_embeddings;
+}
+async function realRunDecoder(embedding, coords, labels, imgW, imgH) {
+    const session = await loadModel(resolveModelPath(MODEL_DECODER));
+    const nPts = labels.length;
+    const out = await session.run({
+        image_embeddings: embedding,
+        point_coords: new ort.Tensor('float32', coords, [1, nPts, 2]),
+        point_labels: new ort.Tensor('float32', labels, [1, nPts]),
+        mask_input: new ort.Tensor('float32', new Float32Array(256 * 256), [1, 1, 256, 256]),
+        has_mask_input: new ort.Tensor('float32', Float32Array.from([0]), [1]),
+        orig_im_size: new ort.Tensor('float32', Float32Array.from([imgH, imgW]), [2]),
+    });
+    const masks = out.masks;
+    const [, , mh, mw] = masks.dims;
+    return {
+        mask: thresholdMask(masks.data, mh * mw),
+        width: mw,
+        height: mh,
+        iou: out.iou_predictions.data[0] ?? 0,
+    };
+}
 export class OnnxSamSegmenter {
-    async encodeImage(img) {
-        const session = await loadModel(resolveModelPath(MODEL_ENCODER));
-        const input = new ort.Tensor('float32', toEncoderInput(img), [img.height, img.width, 3]);
-        const out = await session.run({ input_image: input });
-        return out.image_embeddings;
+    runEncoderImpl;
+    runDecoderImpl;
+    cachedKey = null;
+    cachedEmbedding = null;
+    constructor(deps = {}) {
+        this.runEncoderImpl = deps.runEncoder ?? realRunEncoder;
+        this.runDecoderImpl = deps.runDecoder ?? realRunDecoder;
     }
-    async runDecoder(embedding, coords, labels, imgW, imgH) {
-        const session = await loadModel(resolveModelPath(MODEL_DECODER));
-        const nPts = labels.length;
-        const out = await session.run({
-            image_embeddings: embedding,
-            point_coords: new ort.Tensor('float32', coords, [1, nPts, 2]),
-            point_labels: new ort.Tensor('float32', labels, [1, nPts]),
-            mask_input: new ort.Tensor('float32', new Float32Array(256 * 256), [1, 1, 256, 256]),
-            has_mask_input: new ort.Tensor('float32', Float32Array.from([0]), [1]),
-            orig_im_size: new ort.Tensor('float32', Float32Array.from([imgH, imgW]), [2]),
-        });
-        const masks = out.masks;
-        const [, , mh, mw] = masks.dims;
-        return {
-            mask: thresholdMask(masks.data, mh * mw),
-            width: mw,
-            height: mh,
-            iou: out.iou_predictions.data[0] ?? 0,
-        };
+    async encodeImage(img) {
+        const key = computeImageKey(img);
+        if (this.cachedKey && sameImageKey(this.cachedKey, key))
+            return this.cachedEmbedding;
+        const embedding = await this.runEncoderImpl(img);
+        this.cachedKey = key;
+        this.cachedEmbedding = embedding;
+        return embedding;
     }
     async segmentBox(embedding, box, imgW, imgH) {
         const { coords, labels } = boxToPromptCoords(box, imgW, imgH);
-        return this.runDecoder(embedding, coords, labels, imgW, imgH);
+        return this.runDecoderImpl(embedding, coords, labels, imgW, imgH);
     }
     async segmentPointsAt(embedding, fg, bg, imgW, imgH) {
         const { coords, labels } = pointsToPromptCoords(fg, bg, imgW, imgH);
-        return this.runDecoder(embedding, coords, labels, imgW, imgH);
+        return this.runDecoderImpl(embedding, coords, labels, imgW, imgH);
     }
     async segment(img, box) {
         const embedding = await this.encodeImage(img);

package/dist/kernel/kernel.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { CompositeSnippetClient } from '../api/snippet-client.js';
 import { Logger } from '../utils/logger.js';
 import { runScript } from '../utils/run-script.js';
@@ -10,7 +11,7 @@ export class Kernel {
     detection;
     sessionId;
     logger;
-    invokeDepth = 0;
+    invokeDepth = new AsyncLocalStorage();
     static MAX_INVOKE_DEPTH = 8;
     constructor(deps) {
         this.registry = deps.registry;
@@ -43,16 +44,11 @@ export class Kernel {
         };
     }
     async invokeTool(name, args) {
-        if (this.invokeDepth >= Kernel.MAX_INVOKE_DEPTH) {
+        const depth = this.invokeDepth.getStore() ?? 0;
+        if (depth >= Kernel.MAX_INVOKE_DEPTH) {
             throw new Error(`invokeTool recursion limit (${Kernel.MAX_INVOKE_DEPTH}) exceeded invoking '${name}'`);
         }
-        this.invokeDepth++;
-        try {
-            return await this.registry.execute(name, args);
-        }
-        finally {
-            this.invokeDepth--;
-        }
+        return this.invokeDepth.run(depth + 1, () => this.registry.execute(name, args));
     }
     abiTooNew(manifest) {
         if (manifest.abi > KERNEL_ABI) {