editmamei 0.22.4 → 0.24.1

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) {

package/dist/kernel/module-lifecycle.js

@@ -0,0 +1,181 @@
+import { dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { existsSync } from 'node:fs';
+import { EDITION } from '../edition.js';
+import { resolveProBinaryPath } from '../api/snippet-client.js';
+import { isProEntitled } from '../license/entitlement.js';
+import { loadVerifiedModule, readInstalledModule, installedPath, PRO_SKU, } from '../delivery/store.js';
+import { provisionModules } from '../delivery/provision.js';
+import { readLicense } from '../license/store.js';
+import { HOST_MIN_ABI } from './host-api.js';
+export function classifyModuleOutcome(inputs) {
+    if (inputs.proModuleLoaded && inputs.skipReason === null)
+        return 'loaded';
+    if (inputs.skipReason === 'corrupt')
+        return 'skipped_corrupt';
+    if (inputs.skipReason === 'incompatible')
+        return 'skipped_incompatible';
+    return inputs.entitled ? 'absent' : 'lapsed';
+}
+export class ModuleLifecycle {
+    deps;
+    kernel;
+    _proModule = null;
+    _moduleSkipReason = null;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    get proModule() {
+        return this._proModule;
+    }
+    get moduleSkipReason() {
+        return this._moduleSkipReason;
+    }
+    setKernel(kernel) {
+        this.kernel = kernel;
+    }
+    resolveProModule() {
+        if (isProEntitled()) {
+            const verified = loadVerifiedModule(PRO_SKU);
+            if (verified) {
+                const abi = readInstalledModule(PRO_SKU)?.abi ?? null;
+                this._proModule = {
+                    importer: () => import(pathToFileURL(verified.handlersPath).href),
+                    binDir: verified.binDir,
+                    abi,
+                };
+                return this._proModule;
+            }
+            if (EDITION !== 'dev' && existsSync(installedPath(PRO_SKU))) {
+                this._moduleSkipReason = 'corrupt';
+            }
+        }
+        if (EDITION === 'dev') {
+            this._proModule = {
+                importer: () => import('../modules/pro/index.js'),
+                binDir: dirname(resolveProBinaryPath()),
+                abi: null,
+            };
+            return this._proModule;
+        }
+        this._proModule = null;
+        return null;
+    }
+    async loadModules() {
+        if (!this._proModule)
+            return;
+        if (this._proModule.abi !== null && this._proModule.abi < HOST_MIN_ABI) {
+            this.deps.logger.warn(`Pro module (abi ${this._proModule.abi}) is older than this host requires ` +
+                `(min abi ${HOST_MIN_ABI}) — booting Community; will re-provision in the background.`);
+            this._moduleSkipReason = 'incompatible';
+            return;
+        }
+        const snapshot = this.deps.toolRegistry.snapshot();
+        try {
+            await this.kernel.loadDownloaded(this._proModule.importer);
+            this.deps.assertToolsClassified();
+        }
+        catch (err) {
+            const changed = this.deps.toolRegistry.count() - snapshot.size;
+            this.deps.toolRegistry.restore(snapshot);
+            this.deps.logger.warn(`Pro module could not be loaded on this host — booting Community and rolling back ` +
+                `${changed} module tool change(s); will re-provision in the background: ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+            this._moduleSkipReason = 'incompatible';
+        }
+    }
+    computeModuleStatus() {
+        if (!readLicense())
+            return null;
+        const installed = readInstalledModule(PRO_SKU);
+        return {
+            module: PRO_SKU,
+            outcome: classifyModuleOutcome({
+                proModuleLoaded: this._proModule !== null,
+                skipReason: this._moduleSkipReason,
+                entitled: isProEntitled(),
+            }),
+            module_version: installed?.version ?? null,
+            abi: installed?.abi ?? null,
+        };
+    }
+    async reprovisionIfModuleSkipped(delivery = {}) {
+        const reason = this._moduleSkipReason;
+        if (reason === null)
+            return;
+        const license = readLicense();
+        if (!license) {
+            this.deps.logger.warn('A Pro module was skipped but no cached license was found — staying Community. ' +
+                'Run `editmamei activate <key>` to restore Pro.');
+            return;
+        }
+        try {
+            const prov = await provisionModules(license.key, {
+                force: reason === 'corrupt',
+                config: delivery.config,
+                fetchImpl: delivery.fetchImpl,
+                signingKeys: delivery.signingKeys,
+                sleep: delivery.sleep,
+            });
+            if (prov.installed.length > 0) {
+                for (const m of prov.installed) {
+                    this.deps.logger.info(`Pro module updated to v${m.version}, restart to load.`);
+                }
+                return;
+            }
+            if (prov.notConfigured) {
+                this.deps.logger.warn('Module delivery is not configured — staying Community.');
+                return;
+            }
+            for (const e of prov.errors) {
+                this.deps.logger.warn(`Could not re-provision the ${e.sku} module (staying Community): ${e.message}`);
+            }
+            if (prov.errors.length === 0) {
+                if (reason === 'incompatible') {
+                    this.deps.logger.warn('The published Pro module does not yet support this host version — staying ' +
+                        'Community. Update Editmamei when a compatible release ships; ' +
+                        '`editmamei report` files a diagnostic.');
+                }
+                else {
+                    this.deps.logger.warn('Re-provision installed nothing for the corrupt Pro module — staying ' +
+                        'Community. Try `editmamei repair`; `editmamei report` if it persists.');
+                }
+            }
+        }
+        catch (err) {
+            this.deps.logger.warn(`Background Pro-module re-provision failed (staying Community): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async ensureEntitledModuleFresh(delivery = {}) {
+        if (this._moduleSkipReason !== null)
+            return;
+        if (!isProEntitled())
+            return;
+        const underTest = process.env.VITEST !== undefined || process.env.NODE_ENV === 'test';
+        if (underTest && !delivery.fetchImpl)
+            return;
+        const license = readLicense();
+        if (!license)
+            return;
+        try {
+            const prov = await provisionModules(license.key, {
+                config: delivery.config,
+                fetchImpl: delivery.fetchImpl,
+                signingKeys: delivery.signingKeys,
+                sleep: delivery.sleep,
+            });
+            for (const m of prov.installed) {
+                this.deps.logger.info(`Pro module updated to v${m.version} — restart to load.`);
+            }
+            for (const e of prov.errors) {
+                this.deps.logger.warn(`Pro-module freshness check could not provision the ${e.sku} module ` +
+                    `(staying on the installed version): ${e.message}`);
+            }
+        }
+        catch (err) {
+            this.deps.logger.warn(`Background Pro-module freshness check failed (staying on the installed version): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/license/entitlement.js

@@ -1,6 +1,6 @@
 import { resolvePolarConfig } from './config.js';
 import { computeDeviceHash } from './device-hash.js';
-import { readLicense, writeLicense, clearLicense, } from './store.js';
+import { readLicense, writeLicense, clearLicense, nextHighWaterMark, } from './store.js';
 import { PolarLicenseClient, PolarLicenseError } from './polar-client.js';
 import { Logger } from '../utils/logger.js';
 const logger = new Logger('License');
@@ -22,6 +22,12 @@ export function evaluateEntitlement(rec, now) {
     if (!Number.isFinite(last) || now - last > GRACE_MS) {
         return { entitled: false, reason: 'grace-expired' };
     }
+    if (rec.high_water_mark !== undefined) {
+        const hwm = Date.parse(rec.high_water_mark);
+        if (Number.isFinite(hwm) && now < hwm - CLOCK_SKEW_TOLERANCE_MS) {
+            return { entitled: false, reason: 'grace-expired' };
+        }
+    }
     return { entitled: true, reason: 'granted' };
 }
 const defaultFetch = (url, init) => fetch(url, init);
@@ -51,6 +57,7 @@ export async function activate(key, ops = {}) {
     const deviceHash = computeDeviceHash();
     const activation = await polar.activate(trimmed, deviceHash);
     const v = await polar.validate(trimmed);
+    const nowMs = now();
     const rec = {
         key: trimmed,
         organization_id: cfg.organizationId,
@@ -59,7 +66,8 @@ export async function activate(key, ops = {}) {
         activation_id: activation.id,
         device_hash: deviceHash,
         display_key: v.display_key,
-        last_validated_at: new Date(now()).toISOString(),
+        last_validated_at: new Date(nowMs).toISOString(),
+        high_water_mark: nextHighWaterMark(existing, nowMs),
     };
     writeLicense(rec, ops);
     return rec;
@@ -120,12 +128,14 @@ export async function refresh(ops = {}) {
     const { polar } = makeClient(ops);
     const now = ops.now ?? Date.now;
     const v = await polar.validate(rec.key);
+    const nowMs = now();
     const updated = {
         ...rec,
         status: v.status,
         expires_at: v.expires_at,
         display_key: v.display_key,
-        last_validated_at: new Date(now()).toISOString(),
+        last_validated_at: new Date(nowMs).toISOString(),
+        high_water_mark: nextHighWaterMark(rec, nowMs),
     };
     writeLicense(updated, ops);
     return updated;

package/dist/license/store.js

@@ -18,7 +18,8 @@ function isLicenseRecord(v) {
         typeof r.activation_id === 'string' &&
         typeof r.device_hash === 'string' &&
         typeof r.display_key === 'string' &&
-        typeof r.last_validated_at === 'string');
+        typeof r.last_validated_at === 'string' &&
+        (r.high_water_mark === undefined || typeof r.high_water_mark === 'string'));
 }
 export function readLicense(opts = {}) {
     const path = licensePath(opts);
@@ -45,6 +46,12 @@ export function writeLicense(rec, opts = {}) {
     writeFileSync(tmp, JSON.stringify(rec, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
     renameSync(tmp, path);
 }
+export function nextHighWaterMark(existing, ...candidatesMs) {
+    const priorMs = existing?.high_water_mark ? Date.parse(existing.high_water_mark) : NaN;
+    const finite = [priorMs, ...candidatesMs].filter((ms) => Number.isFinite(ms));
+    const hwm = finite.length ? Math.max(...finite) : Date.now();
+    return new Date(hwm).toISOString();
+}
 export function clearLicense(opts = {}) {
     const path = licensePath(opts);
     if (existsSync(path))

package/dist/modules/ce/index.js

@@ -64,7 +64,7 @@ export const ceModule = {
         const { connection, snippet } = host;
         const defs = [
             ...ceFactories.flatMap((f) => f(connection, snippet)),
-            ...createSceneTools(connection, snippet, undefined, host.invokeTool),
+            ...createSceneTools(connection, snippet, { invokeTool: host.invokeTool }),
         ].filter((def) => isToolAllowedInEdition(def.tool.name, EDITION));
         host.registerTools(defs);
     },

package/dist/perception/facets.js

@@ -37,7 +37,7 @@ export function pickThresholdLevel(hist) {
         bright += bins[i];
     return { level, bright_fraction: bright / total };
 }
-export function estimateHorizon(rowMeans, docHeight, pick) {
+export function estimateHorizon(rowMeans, docHeight, pick, mainSubjectBox, primaryFaceBox) {
     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) {
@@ -55,12 +55,30 @@ export function estimateHorizon(rowMeans, docHeight, pick) {
         return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
     }
     const y = Math.round((crossRow / R) * docHeight);
+    if ((mainSubjectBox && isDominantSubjectCrossing(y, docHeight, mainSubjectBox)) ||
+        (primaryFaceBox && isPortraitFaceCrossing(y, docHeight, primaryFaceBox))) {
+        return { y: Math.round(docHeight / 3), placement: 1 / 3, confidence: 0.2 };
+    }
     return {
         y,
         placement: y / docHeight,
         confidence: Math.max(0, Math.min(1, splitConfidence)),
     };
 }
+function isDominantSubjectCrossing(y, docHeight, box) {
+    if (docHeight <= 0)
+        return false;
+    const [, top, , bottom] = box;
+    const spans = (bottom - top) / docHeight;
+    return spans >= 0.6 && y >= top && y <= bottom;
+}
+function isPortraitFaceCrossing(y, docHeight, face) {
+    if (docHeight <= 0)
+        return false;
+    const [, top, , bottom] = face;
+    const spans = (bottom - top) / docHeight;
+    return spans >= 0.25 && y >= top;
+}
 export function computeTonalZones(hist) {
     const { bins } = hist;
     const total = hist.total || bins.reduce((a, b) => a + b, 0);

package/dist/perception/grounding-anchors.js

@@ -1,19 +1,9 @@
+import { orderBySpatialPick } from '../detection/geometry.js';
 export function bboxToBox(b) {
     return { left: b[0], top: b[1], right: b[2], bottom: b[3] };
 }
-const cx = (b) => (b[0] + b[2]) / 2;
-const cy = (b) => (b[1] + b[3]) / 2;
-const area = (b) => (b[2] - b[0]) * (b[3] - b[1]);
 function orderBy(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) => area(b.bbox) - area(a.bbox),
-        smallest: (a, b) => area(a.bbox) - area(b.bbox),
-    };
-    return pick === 'confidence' ? items : [...items].sort(cmp[pick]);
+    return pick === 'confidence' ? items : orderBySpatialPick(items, pick);
 }
 export function localizeAnchor(det, sel) {
     const candidates = sel.kind === 'face'

package/dist/perception/grounding-locate.js

@@ -1,4 +1,3 @@
-import { decode } from 'jpeg-js';
 import { ValidationError } from '../utils/validate.js';
 import { detectActiveDoc } from '../detection/detect-active-doc.js';
 import { localizeAnchor } from './grounding-anchors.js';
@@ -214,14 +213,7 @@ export async function resolveToGeometry(connection, client, input) {
     });
     const docW = det.docWidth;
     const docH = det.docHeight;
-    let exportImg = null;
-    try {
-        if (det.exportBytes.length > 0)
-            exportImg = decode(det.exportBytes, { useTArray: true, formatAsRGBA: true });
-    }
-    catch {
-        exportImg = null;
-    }
+    const exportImg = det.decoded ?? null;
     const s = exportImg ? exportImg.width / docW : 1;
     const anchors = {};
     const anchorMeta = {};

package/dist/perception/grounding-review-crop.js

@@ -1,31 +1,5 @@
 import { boundsOf } from './grounding-geometry.js';
-function setPx(img, x, y, [r, g, b]) {
-    if (x < 0 || y < 0 || x >= img.width || y >= img.height)
-        return;
-    const i = (y * img.width + x) * 4;
-    img.data[i] = r;
-    img.data[i + 1] = g;
-    img.data[i + 2] = b;
-    img.data[i + 3] = 255;
-}
-function drawRing(img, c, radius, thick, color) {
-    const cx = Math.round(c.x), cy = Math.round(c.y);
-    const outer = radius + thick;
-    for (let dy = -outer; dy <= outer; dy++) {
-        for (let dx = -outer; dx <= outer; dx++) {
-            const d = Math.hypot(dx, dy);
-            if (d >= radius - thick && d <= radius + thick)
-                setPx(img, cx + dx, cy + dy, color);
-        }
-    }
-}
-function disc(img, c, radius, color) {
-    const cx = Math.round(c.x), cy = Math.round(c.y);
-    for (let dy = -radius; dy <= radius; dy++)
-        for (let dx = -radius; dx <= radius; dx++)
-            if (dx * dx + dy * dy <= radius * radius)
-                setPx(img, cx + dx, cy + dy, color);
-}
+import { drawRing, fillDisc } from './overlay.js';
 function drawPolyline(img, pts, thick, color, closed = false) {
     const r = Math.max(0, thick - 1);
     const seq = closed && pts.length > 2 ? [...pts, pts[0]] : pts;
@@ -34,7 +8,7 @@ function drawPolyline(img, pts, thick, color, closed = false) {
         const steps = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y)));
         for (let s = 0; s <= steps; s++) {
             const t = s / steps;
-            disc(img, { x: a.x + t * (b.x - a.x), y: a.y + t * (b.y - a.y) }, r, color);
+            fillDisc(img, a.x + t * (b.x - a.x), a.y + t * (b.y - a.y), r, color);
         }
     }
 }
@@ -73,7 +47,8 @@ export function renderReviewCrop(img, placement, opts = {}) {
     }
     const toCrop = (p) => ({ x: p.x - ox, y: p.y - oy });
     if (placement.kind === 'point') {
-        drawRing(out, toCrop(placement.point), opts.ringRadius ?? 13, opts.ringThickness ?? 2, color);
+        const p = toCrop(placement.point);
+        drawRing(out, p.x, p.y, opts.ringRadius ?? 13, opts.ringThickness ?? 2, color);
     }
     else if (placement.kind === 'curve') {
         drawPolyline(out, placement.curve.map(toCrop), opts.strokeThickness ?? 2, color);

package/dist/perception/overlay.js

@@ -0,0 +1,62 @@
+export const ANNOTATION_RGB = {
+    face: [0, 220, 255],
+    object: [255, 0, 220],
+    horizon: [255, 230, 0],
+};
+export function annotationThickness(img) {
+    return Math.max(2, Math.round(Math.max(img.width, img.height) / 400));
+}
+export function setPx(img, x, y, [r, g, b]) {
+    if (x < 0 || y < 0 || x >= img.width || y >= img.height)
+        return;
+    const i = (y * img.width + x) * 4;
+    img.data[i] = r;
+    img.data[i + 1] = g;
+    img.data[i + 2] = b;
+    img.data[i + 3] = 255;
+}
+export function drawBoxOutline(img, box, rgb, thickness) {
+    const [x1, y1, x2, y2] = box.map(Math.round);
+    for (let x = x1; x <= x2; x++)
+        for (let k = 0; k < thickness; k++) {
+            setPx(img, x, y1 + k, rgb);
+            setPx(img, x, y2 - k, rgb);
+        }
+    for (let y = y1; y <= y2; y++)
+        for (let k = 0; k < thickness; k++) {
+            setPx(img, x1 + k, y, rgb);
+            setPx(img, x2 - k, y, rgb);
+        }
+}
+export function drawHLine(img, y, rgb, thickness) {
+    for (let x = 0; x < img.width; x++)
+        for (let k = 0; k < thickness; k++)
+            setPx(img, x, y + k, rgb);
+}
+export function fillSquare(img, cx, cy, radius, rgb) {
+    const x0 = Math.round(cx);
+    const y0 = Math.round(cy);
+    for (let dy = -radius; dy <= radius; dy++)
+        for (let dx = -radius; dx <= radius; dx++)
+            setPx(img, x0 + dx, y0 + dy, rgb);
+}
+export function drawRing(img, cx, cy, radius, thick, rgb) {
+    const x0 = Math.round(cx);
+    const y0 = Math.round(cy);
+    const outer = radius + thick;
+    for (let dy = -outer; dy <= outer; dy++) {
+        for (let dx = -outer; dx <= outer; dx++) {
+            const d = Math.hypot(dx, dy);
+            if (d >= radius - thick && d <= radius + thick)
+                setPx(img, x0 + dx, y0 + dy, rgb);
+        }
+    }
+}
+export function fillDisc(img, cx, cy, radius, rgb) {
+    const x0 = Math.round(cx);
+    const y0 = Math.round(cy);
+    for (let dy = -radius; dy <= radius; dy++)
+        for (let dx = -radius; dx <= radius; dx++)
+            if (dx * dx + dy * dy <= radius * radius)
+                setPx(img, x0 + dx, y0 + dy, rgb);
+}

package/dist/perception/pixel-identity.js

@@ -0,0 +1,41 @@
+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;
+}
+export function docKeyFrom(context, docWidth, docHeight) {
+    const doc = context
+        ?.document;
+    const name = typeof doc?.name === 'string' ? doc.name : null;
+    if (name === null)
+        return null;
+    const sel = doc?.hasSelection === true ? 'S' : 'N';
+    return `${name}:${docWidth}x${docHeight}:${sel}`;
+}
+export function computePixelIdentity(decoded, docKey) {
+    const { width, height, data } = decoded;
+    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 { docKey, width, height, byteLength: n, hash: h };
+}
+export function samePixelIdentity(a, b) {
+    if (a.docKey === null || b.docKey === null)
+        return false;
+    return (a.docKey === b.docKey &&
+        a.width === b.width &&
+        a.height === b.height &&
+        a.byteLength === b.byteLength &&
+        a.hash === b.hash);
+}
+export function identityKeyString(identity) {
+    return `${identity.docKey}:${identity.width}x${identity.height}:${identity.byteLength}:${identity.hash.toString(16)}`;
+}