editmamei 0.20.0 → 0.22.0

package/dist/detection/mesh-eye-correction.js

@@ -0,0 +1,126 @@
+import { LANDMARK_GROUPS, LANDMARK_COUNT } from './landmark-spec.js';
+const EYE_RIGID_GROUPS = ['leftEye', 'rightEye', 'leftEyebrow', 'rightEyebrow', 'nose'];
+const EYE_RIGID_INDICES = new Set();
+for (const g of EYE_RIGID_GROUPS)
+    for (const i of LANDMARK_GROUPS[g])
+        EYE_RIGID_INDICES.add(i);
+const centroid = (pts) => ({
+    x: pts.reduce((s, p) => s + p.x, 0) / pts.length,
+    y: pts.reduce((s, p) => s + p.y, 0) / pts.length,
+});
+const bbox = (pts) => ({
+    x0: Math.min(...pts.map((p) => p.x)),
+    y0: Math.min(...pts.map((p) => p.y)),
+    x1: Math.max(...pts.map((p) => p.x)),
+    y1: Math.max(...pts.map((p) => p.y)),
+});
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function makeCtx(img) {
+    const { width: W, height: H, data } = img;
+    const luma = (x, y) => {
+        const i = (y * W + x) * 4;
+        return 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+    };
+    const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+    const blur = (x, y, r) => {
+        let s = 0, n = 0;
+        for (let dy = -r; dy <= r; dy++)
+            for (let dx = -r; dx <= r; dx++) {
+                s += luma(clamp(x + dx, 0, W - 1), clamp(y + dy, 0, H - 1));
+                n++;
+            }
+        return s / n;
+    };
+    return { W, H, luma, clamp, blur };
+}
+function findEyeCenter(ctx, center, ring) {
+    const { W, H, luma, clamp, blur } = ctx;
+    const rw = ring.x1 - ring.x0, rh = ring.y1 - ring.y0;
+    const x0 = clamp(Math.round(center.x - 0.55 * rw), 0, W - 1);
+    const x1 = clamp(Math.round(center.x + 0.55 * rw), 0, W - 1);
+    const y0 = clamp(Math.round(center.y - 0.5 * rh), 0, H - 1);
+    const y1 = clamp(Math.round(center.y + 2.0 * rh), 0, H - 1);
+    const ww = x1 - x0 + 1, wh = y1 - y0 + 1;
+    if (ww < 5 || wh < 5)
+        return { x: center.x, y: center.y, atEdge: false };
+    const L = new Float32Array(ww * wh);
+    for (let y = 0; y < wh; y++)
+        for (let x = 0; x < ww; x++)
+            L[y * ww + x] = luma(x0 + x, y0 + y);
+    const edges = [];
+    const gg = [];
+    let magSum = 0;
+    for (let y = 1; y < wh - 1; y++)
+        for (let x = 1; x < ww - 1; x++) {
+            const gx = (L[y * ww + x + 1] - L[y * ww + x - 1]) / 2;
+            const gy = (L[(y + 1) * ww + x] - L[(y - 1) * ww + x]) / 2;
+            const m = Math.hypot(gx, gy);
+            gg.push({ m, x, y, gx, gy });
+            magSum += m;
+        }
+    const mean = magSum / (gg.length || 1);
+    let v = 0;
+    for (const g of gg)
+        v += (g.m - mean) ** 2;
+    const std = Math.sqrt(v / (gg.length || 1));
+    const thr = mean + 0.3 * std;
+    for (const g of gg)
+        if (g.m > thr)
+            edges.push({ x: g.x, y: g.y, gx: g.gx / g.m, gy: g.gy / g.m });
+    let best = -Infinity, bx = Math.round(center.x - x0), by = Math.round(center.y - y0);
+    for (let cy = 2; cy < wh - 2; cy += 2)
+        for (let cx = 2; cx < ww - 2; cx += 2) {
+            let s = 0;
+            for (const e of edges) {
+                const dx = e.x - cx, dy = e.y - cy, l = Math.hypot(dx, dy);
+                if (l < 3)
+                    continue;
+                const dot = (dx / l) * e.gx + (dy / l) * e.gy;
+                if (dot > 0)
+                    s += dot * dot;
+            }
+            s *= 255 - blur(x0 + cx, y0 + cy, 3);
+            if (s > best) {
+                best = s;
+                bx = cx;
+                by = cy;
+            }
+        }
+    const atEdge = bx <= 3 || bx >= ww - 4 || by >= wh - 4;
+    return { x: x0 + bx, y: y0 + by, atEdge };
+}
+function similarity(m1, m2, t1, t2) {
+    const dmx = m2.x - m1.x, dmy = m2.y - m1.y, dtx = t2.x - t1.x, dty = t2.y - t1.y;
+    const s = Math.hypot(dtx, dty) / (Math.hypot(dmx, dmy) || 1);
+    const th = Math.atan2(dty, dtx) - Math.atan2(dmy, dmx);
+    const c = Math.cos(th) * s, sn = Math.sin(th) * s;
+    return (p) => ({
+        x: t1.x + c * (p.x - m1.x) - sn * (p.y - m1.y),
+        y: t1.y + sn * (p.x - m1.x) + c * (p.y - m1.y),
+    });
+}
+export function correctMeshEyes(img, points) {
+    if (!points || points.length < LANDMARK_COUNT)
+        return { points, correction: null };
+    if (!img || !img.data || img.data.length < img.width * img.height * 4) {
+        return { points, correction: null };
+    }
+    const ctx = makeCtx(img);
+    const leftEye = LANDMARK_GROUPS.leftEye.map((i) => points[i]);
+    const rightEye = LANDMARK_GROUPS.rightEye.map((i) => points[i]);
+    const eyeLm = centroid(leftEye), eyeRm = centroid(rightEye);
+    if (dist(eyeLm, eyeRm) < 4)
+        return { points, correction: null };
+    const eyeLc = findEyeCenter(ctx, eyeLm, bbox(leftEye));
+    const eyeRc = findEyeCenter(ctx, eyeRm, bbox(rightEye));
+    const T = similarity(eyeLm, eyeRm, eyeLc, eyeRc);
+    const corrected = points.map((p, i) => (EYE_RIGID_INDICES.has(i) ? { ...T(p), z: p.z } : p));
+    return {
+        points: corrected,
+        correction: {
+            drift_left: Math.round(dist(eyeLc, eyeLm)),
+            drift_right: Math.round(dist(eyeRc, eyeRm)),
+            low_confidence: eyeLc.atEdge || eyeRc.atEdge,
+        },
+    };
+}

package/dist/detection/sam-segmenter.js

@@ -0,0 +1,83 @@
+import { loadModel, resolveModelPath, ort } from './runtime.js';
+const MODEL_ENCODER = 'pro/mobile_sam_encoder.onnx';
+const MODEL_DECODER = 'pro/mobile_sam_decoder.onnx';
+const SAM_INPUT = 1024;
+export function boxToPromptCoords(box, imgW, imgH) {
+    const s = SAM_INPUT / Math.max(imgW, imgH);
+    const [x1, y1, x2, y2] = box;
+    return {
+        coords: Float32Array.from([x1 * s, y1 * s, x2 * s, y2 * s]),
+        labels: Float32Array.from([2, 3]),
+    };
+}
+export function pointsToPromptCoords(fg, bg, imgW, imgH) {
+    const s = SAM_INPUT / Math.max(imgW, imgH);
+    const pts = [...fg, ...bg, { x: 0, y: 0 }];
+    const labels = [...fg.map(() => 1), ...bg.map(() => 0), -1];
+    const coords = new Float32Array(pts.length * 2);
+    pts.forEach((p, i) => {
+        coords[i * 2] = p.x * s;
+        coords[i * 2 + 1] = p.y * s;
+    });
+    return { coords, labels: Float32Array.from(labels) };
+}
+export function toEncoderInput(img) {
+    const { width: w, height: h, data } = img;
+    const out = new Float32Array(h * w * 3);
+    for (let p = 0; p < h * w; p++) {
+        out[p * 3] = data[p * 4];
+        out[p * 3 + 1] = data[p * 4 + 1];
+        out[p * 3 + 2] = data[p * 4 + 2];
+    }
+    return out;
+}
+export function thresholdMask(maskData, n) {
+    const mask = new Uint8Array(n);
+    for (let i = 0; i < n; i++)
+        mask[i] = maskData[i] > 0 ? 1 : 0;
+    return mask;
+}
+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;
+    }
+    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 segmentBox(embedding, box, imgW, imgH) {
+        const { coords, labels } = boxToPromptCoords(box, imgW, imgH);
+        return this.runDecoder(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);
+    }
+    async segment(img, box) {
+        const embedding = await this.encodeImage(img);
+        return this.segmentBox(embedding, box, img.width, img.height);
+    }
+    async segmentPoints(img, fg, bg = []) {
+        const embedding = await this.encodeImage(img);
+        return this.segmentPointsAt(embedding, fg, bg, img.width, img.height);
+    }
+}

package/dist/index.js

@@ -4,6 +4,7 @@ import { pathToFileURL } from 'node:url';
 import { EditmameiServer } from './core/server.js';
 import { routeCli } from './cli/router.js';
 import { maybeActivateFromEnv } from './license/env-activation.js';
+import { refreshIfStale } from './license/entitlement.js';
 import { Logger } from './utils/logger.js';
 const logger = new Logger('Main');
 function installProcessHandlers() {
@@ -37,6 +38,7 @@ async function main() {
     try {
         logger.info('Starting Editmamei...');
         await maybeActivateFromEnv();
+        await refreshIfStale();
         const server = new EditmameiServer();
         await server.start();
         let shuttingDown = false;

package/dist/license/entitlement.js

@@ -2,7 +2,11 @@ import { resolvePolarConfig } from './config.js';
 import { computeDeviceHash } from './device-hash.js';
 import { readLicense, writeLicense, clearLicense, } from './store.js';
 import { PolarLicenseClient, PolarLicenseError } from './polar-client.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('License');
 export const GRACE_MS = 30 * 24 * 60 * 60 * 1000;
+export const REFRESH_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
+export const EXPIRED_REFRESH_TIMEOUT_MS = 5_000;
 export function evaluateEntitlement(rec, now) {
     if (!rec)
         return { entitled: false, reason: 'no-license' };
@@ -59,6 +63,54 @@ export async function activate(key, ops = {}) {
     writeLicense(rec, ops);
     return rec;
 }
+export async function refreshIfStale(ops = {}) {
+    const env = ops.env ?? process.env;
+    if (env.VITEST !== undefined || env.NODE_ENV === 'test')
+        return;
+    const rec = readLicense(ops);
+    if (!rec)
+        return;
+    if (rec.status === 'revoked' || rec.status === 'disabled')
+        return;
+    const now = (ops.now ?? Date.now)();
+    if (rec.expires_at !== null && Date.parse(rec.expires_at) <= now)
+        return;
+    const last = Date.parse(rec.last_validated_at);
+    const age = Number.isFinite(last) ? now - last : Infinity;
+    if (age <= REFRESH_AFTER_MS)
+        return;
+    if (age <= GRACE_MS) {
+        refresh(ops).catch((err) => {
+            logger.warn(`Background license refresh failed (grace covers offline use): ` +
+                `${err instanceof Error ? err.message : String(err)}`);
+        });
+        return;
+    }
+    const timeoutMs = ops.expiredRefreshTimeoutMs ?? EXPIRED_REFRESH_TIMEOUT_MS;
+    const attempt = refresh(ops);
+    attempt.catch(() => { });
+    let timer;
+    try {
+        const winner = await Promise.race([
+            attempt,
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve('timeout'), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+        if (winner === 'timeout') {
+            logger.warn('License re-validation timed out past the grace window — continuing as Community; the next boot retries.');
+        }
+    }
+    catch (err) {
+        logger.warn(`License re-validation failed past the grace window (continuing as Community): ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 export async function refresh(ops = {}) {
     const rec = readLicense(ops);
     if (!rec)

package/dist/modules/ce/index.js

@@ -23,12 +23,12 @@ import { createBrushTools } from '../../tools/brush-tools.js';
 import { createTransformCanvasTools } from '../../tools/transform-canvas-tools.js';
 import { createGuideTools } from '../../tools/guide-tools.js';
 import { createDetectionTools } from '../../tools/detection-tools.js';
-import { createObjectTools } from '../../tools/object-tools.js';
 import { createPortraitTools } from '../../tools/portrait-tools.js';
-import { createTextOnObjectTools } from '../../tools/text-on-object-tools.js';
 import { createSceneTools } from '../../tools/scene-tools.js';
 import { createPathTools } from '../../tools/path-tools.js';
 import { createVectorMaskTools } from '../../tools/vector-mask-tools.js';
+import { createChannelComposeTools } from '../../tools/channel-compose-tools.js';
+import { createShapeTools } from '../../tools/shape-tools.js';
 const ceFactories = [
     createDocumentTools,
     createLayerTools,
@@ -52,11 +52,11 @@ const ceFactories = [
     createTransformCanvasTools,
     createGuideTools,
     createDetectionTools,
-    createObjectTools,
     createPortraitTools,
-    createTextOnObjectTools,
     createPathTools,
     createVectorMaskTools,
+    createChannelComposeTools,
+    createShapeTools,
 ];
 export const ceModule = {
     manifest: { id: 'ce', name: 'Editmamei Community Tools', abi: KERNEL_ABI },

package/dist/perception/grounding-anchors.js

@@ -0,0 +1,37 @@
+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]);
+}
+export function localizeAnchor(det, sel) {
+    const candidates = sel.kind === 'face'
+        ? (det.faces ?? []).map((f) => ({ bbox: f.bbox }))
+        : (det.objects ?? []).filter((o) => o.label === sel.label).map((o) => ({ bbox: o.bbox }));
+    const ordered = orderBy(candidates, sel.pick ?? 'confidence');
+    const c = ordered[sel.instance ?? 0];
+    return c ? { kind: 'box', box: bboxToBox(c.bbox) } : null;
+}
+export function localizeAnchors(det, selectors) {
+    const anchors = {};
+    const missing = [];
+    for (const [id, sel] of Object.entries(selectors)) {
+        const prim = localizeAnchor(det, sel);
+        if (prim)
+            anchors[id] = prim;
+        else
+            missing.push(id);
+    }
+    return { anchors, missing };
+}

package/dist/perception/grounding-corners.js

@@ -0,0 +1,93 @@
+import { dist } from './grounding-geometry.js';
+const clampi = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+export function findCorners(img, region, opts = {}) {
+    const k = opts.k ?? 0.05;
+    const wr = Math.max(1, opts.windowRadius ?? 2);
+    const nms = Math.max(1, opts.nmsRadius ?? 3);
+    const relT = opts.relThreshold ?? 0.05;
+    const cap = opts.max ?? 32;
+    const rx0 = clampi(Math.round(region.left), 0, img.width - 1);
+    const ry0 = clampi(Math.round(region.top), 0, img.height - 1);
+    const rx1 = clampi(Math.round(region.right), 0, img.width - 1);
+    const ry1 = clampi(Math.round(region.bottom), 0, img.height - 1);
+    const rw = rx1 - rx0 + 1, rh = ry1 - ry0 + 1;
+    if (rw < 3 || rh < 3)
+        return [];
+    const lum = new Float32Array(rw * rh);
+    for (let y = 0; y < rh; y++)
+        for (let x = 0; x < rw; x++) {
+            const i = ((ry0 + y) * img.width + (rx0 + x)) * 4;
+            lum[y * rw + x] = 0.299 * img.data[i] + 0.587 * img.data[i + 1] + 0.114 * img.data[i + 2];
+        }
+    const L = (x, y) => lum[clampi(y, 0, rh - 1) * rw + clampi(x, 0, rw - 1)];
+    const Ix = new Float32Array(rw * rh), Iy = new Float32Array(rw * rh);
+    for (let y = 0; y < rh; y++)
+        for (let x = 0; x < rw; x++) {
+            Ix[y * rw + x] =
+                -L(x - 1, y - 1) -
+                    2 * L(x - 1, y) -
+                    L(x - 1, y + 1) +
+                    L(x + 1, y - 1) +
+                    2 * L(x + 1, y) +
+                    L(x + 1, y + 1);
+            Iy[y * rw + x] =
+                -L(x - 1, y - 1) -
+                    2 * L(x, y - 1) -
+                    L(x + 1, y - 1) +
+                    L(x - 1, y + 1) +
+                    2 * L(x, y + 1) +
+                    L(x + 1, y + 1);
+        }
+    const R = new Float32Array(rw * rh);
+    let maxR = 0;
+    for (let y = 0; y < rh; y++)
+        for (let x = 0; x < rw; x++) {
+            let a = 0, b = 0, c = 0;
+            for (let dy = -wr; dy <= wr; dy++)
+                for (let dx = -wr; dx <= wr; dx++) {
+                    const xx = clampi(x + dx, 0, rw - 1), yy = clampi(y + dy, 0, rh - 1);
+                    const gx = Ix[yy * rw + xx], gy = Iy[yy * rw + xx];
+                    a += gx * gx;
+                    b += gx * gy;
+                    c += gy * gy;
+                }
+            const r = a * c - b * b - k * (a + c) * (a + c);
+            R[y * rw + x] = r;
+            if (r > maxR)
+                maxR = r;
+        }
+    if (maxR <= 0)
+        return [];
+    const threshold = relT * maxR;
+    const corners = [];
+    for (let y = 0; y < rh; y++)
+        for (let x = 0; x < rw; x++) {
+            const r = R[y * rw + x];
+            if (r < threshold)
+                continue;
+            let isMax = true;
+            for (let dy = -nms; dy <= nms && isMax; dy++)
+                for (let dx = -nms; dx <= nms; dx++) {
+                    const xx = x + dx, yy = y + dy;
+                    if (xx < 0 || yy < 0 || xx >= rw || yy >= rh)
+                        continue;
+                    if (R[yy * rw + xx] > r) {
+                        isMax = false;
+                        break;
+                    }
+                }
+            if (isMax)
+                corners.push({ point: { x: rx0 + x, y: ry0 + y }, response: r });
+        }
+    corners.sort((p, q) => q.response - p.response);
+    return corners.slice(0, cap);
+}
+export function cornerAnchor(img, region, opts = {}) {
+    const corners = findCorners(img, region, opts);
+    if (corners.length === 0)
+        return null;
+    const chosen = opts.near
+        ? corners.reduce((best, c) => dist(c.point, opts.near) < dist(best.point, opts.near) ? c : best)
+        : corners[0];
+    return { kind: 'point', point: chosen.point };
+}

package/dist/perception/grounding-edge-trace.js

@@ -0,0 +1,90 @@
+const lumaAt = (img, x, y) => {
+    const i = (y * img.width + x) * 4;
+    return 0.299 * img.data[i] + 0.587 * img.data[i + 1] + 0.114 * img.data[i + 2];
+};
+function bandDeltaCol(img, x, y, band) {
+    let a = 0, b = 0, na = 0, nb = 0;
+    for (let k = 1; k <= band; k++) {
+        if (y - k >= 0) {
+            a += lumaAt(img, x, y - k);
+            na++;
+        }
+        if (y + k < img.height) {
+            b += lumaAt(img, x, y + k);
+            nb++;
+        }
+    }
+    if (na === 0 || nb === 0)
+        return 0;
+    return Math.abs(a / na - b / nb);
+}
+function bandDeltaRow(img, x, y, band) {
+    let a = 0, b = 0, na = 0, nb = 0;
+    for (let k = 1; k <= band; k++) {
+        if (x - k >= 0) {
+            a += lumaAt(img, x - k, y);
+            na++;
+        }
+        if (x + k < img.width) {
+            b += lumaAt(img, x + k, y);
+            nb++;
+        }
+    }
+    if (na === 0 || nb === 0)
+        return 0;
+    return Math.abs(a / na - b / nb);
+}
+const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+export function traceEdge(img, opts) {
+    const r = opts.region;
+    const left = clamp(Math.round(r.left), 0, img.width - 1);
+    const right = clamp(Math.round(r.right), 0, img.width - 1);
+    const top = clamp(Math.round(r.top), 0, img.height - 1);
+    const bottom = clamp(Math.round(r.bottom), 0, img.height - 1);
+    const samples = Math.max(2, opts.samples ?? 24);
+    const polyline = [];
+    const confidences = [];
+    if (opts.orientation === 'horizontal-edge') {
+        const band = opts.band ?? Math.max(3, Math.round((bottom - top) / 20));
+        for (let i = 0; i < samples; i++) {
+            const x = Math.round(left + ((i + 0.5) / samples) * (right - left));
+            let bestY = -1, best = -1;
+            for (let y = top + band; y <= bottom - band; y++) {
+                const d = bandDeltaCol(img, x, y, band);
+                if (d > best) {
+                    best = d;
+                    bestY = y;
+                }
+            }
+            if (bestY < 0)
+                continue;
+            polyline.push({ x, y: bestY });
+            confidences.push(Math.round(best));
+        }
+    }
+    else {
+        const band = opts.band ?? Math.max(3, Math.round((right - left) / 20));
+        for (let i = 0; i < samples; i++) {
+            const y = Math.round(top + ((i + 0.5) / samples) * (bottom - top));
+            let bestX = -1, best = -1;
+            for (let x = left + band; x <= right - band; x++) {
+                const d = bandDeltaRow(img, x, y, band);
+                if (d > best) {
+                    best = d;
+                    bestX = x;
+                }
+            }
+            if (bestX < 0)
+                continue;
+            polyline.push({ x: bestX, y });
+            confidences.push(Math.round(best));
+        }
+    }
+    const meanConfidence = confidences.length
+        ? confidences.reduce((s, v) => s + v, 0) / confidences.length
+        : 0;
+    return { polyline, confidences, meanConfidence };
+}
+export function edgeAnchor(edge) {
+    return { kind: 'polyline', polyline: edge.polyline };
+}

package/dist/perception/grounding-extrema.js

@@ -0,0 +1,41 @@
+const clampi = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+function windowMean(img, x, y, w, measure) {
+    let sum = 0, n = 0;
+    for (let dy = -w; dy <= w; dy++) {
+        for (let dx = -w; dx <= w; dx++) {
+            const px = clampi(x + dx, 0, img.width - 1), py = clampi(y + dy, 0, img.height - 1);
+            const i = (py * img.width + px) * 4;
+            const r = img.data[i], g = img.data[i + 1], b = img.data[i + 2];
+            const v = measure === 'most-saturated'
+                ? Math.max(r, g, b) - Math.min(r, g, b)
+                : 0.299 * r + 0.587 * g + 0.114 * b;
+            sum += v;
+            n++;
+        }
+    }
+    return sum / n;
+}
+export function findExtremum(img, region, measure, opts = {}) {
+    const stride = Math.max(1, opts.stride ?? 2);
+    const w = Math.max(0, opts.window ?? 1);
+    const left = clampi(Math.round(region.left), 0, img.width - 1);
+    const right = clampi(Math.round(region.right), 0, img.width - 1);
+    const top = clampi(Math.round(region.top), 0, img.height - 1);
+    const bottom = clampi(Math.round(region.bottom), 0, img.height - 1);
+    const minimize = measure === 'darkest';
+    let best = minimize ? Infinity : -Infinity;
+    let bestPt = { x: left, y: top };
+    for (let y = top; y <= bottom; y += stride) {
+        for (let x = left; x <= right; x += stride) {
+            const v = windowMean(img, x, y, w, measure);
+            if (minimize ? v < best : v > best) {
+                best = v;
+                bestPt = { x, y };
+            }
+        }
+    }
+    return { point: bestPt, value: Math.round(best) };
+}
+export function extremumAnchor(img, region, measure, opts) {
+    return { kind: 'point', point: findExtremum(img, region, measure, opts).point };
+}