editmamei 0.19.0 → 0.22.0

package/dist/modules/ce/index.js

@@ -17,17 +17,18 @@ import { createLayerOrderingTools } from '../../tools/layer-ordering-tools.js';
 import { createPreviewTools } from '../../tools/preview-tools.js';
 import { createInspectTools } from '../../tools/inspect-tools.js';
 import { createOverviewTools } from '../../tools/overview-tools.js';
+import { createDiagnosticsTools } from '../../tools/diagnostics-tools.js';
 import { createRetouchTools } from '../../tools/retouch-tools.js';
 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,
@@ -45,16 +46,17 @@ const ceFactories = [
     createPreviewTools,
     createInspectTools,
     createOverviewTools,
+    createDiagnosticsTools,
     createRetouchTools,
     createBrushTools,
     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 };
+}

package/dist/perception/grounding-gate.js

@@ -0,0 +1,154 @@
+import { boundsOf, dist, minSignedGap, polygonArea, pointInBox, polylineIntersectsRegion, } from './grounding-geometry.js';
+const inCanvas = (p, c) => p.x >= 0 && p.x <= c.width && p.y >= 0 && p.y <= c.height;
+function gatePoint(spec) {
+    const { point: p, canvas, withinBounds, anchors } = spec;
+    const minSep = spec.minAnchorSeparation ?? 2;
+    const sep = anchors ? dist(anchors[0], anchors[1]) : undefined;
+    const measured = { x: p.x, y: p.y };
+    if (sep !== undefined)
+        measured.anchorSeparation = sep;
+    if (!inCanvas(p, canvas)) {
+        return {
+            pass: false,
+            reason: `point (${Math.round(p.x)},${Math.round(p.y)}) outside canvas ${canvas.width}x${canvas.height}`,
+            measured,
+        };
+    }
+    if (sep !== undefined && sep < minSep) {
+        return {
+            pass: false,
+            reason: `degenerate relation — anchors ${sep.toFixed(1)}px apart (< ${minSep}px)`,
+            measured,
+        };
+    }
+    if (withinBounds && !pointInBox(p, withinBounds)) {
+        return { pass: false, reason: 'point outside the expected region for this relation', measured };
+    }
+    return { pass: true, measured };
+}
+function gateOffsetCurve(spec) {
+    const { curve, source, side, requiredMargin, exclusion, canvas } = spec;
+    const minMargin = minSignedGap(curve, source, side);
+    const sideOk = minMargin > 0;
+    const intersects = exclusion ? polylineIntersectsRegion(curve, exclusion) : false;
+    const outOfCanvas = curve.some((p) => !inCanvas(p, canvas));
+    const measured = {
+        minMargin: Math.round(minMargin * 100) / 100,
+        requiredMargin,
+        side,
+        sideOk,
+        intersectsExclusion: intersects,
+    };
+    if (!sideOk) {
+        return {
+            pass: false,
+            reason: `offset-curve on the wrong side of the source (worst gap ${minMargin.toFixed(1)}px on '${side}')`,
+            measured,
+        };
+    }
+    if (minMargin < requiredMargin) {
+        return {
+            pass: false,
+            reason: `offset-curve clearance ${minMargin.toFixed(1)}px < required ${requiredMargin}px (overlaps feature)`,
+            measured,
+        };
+    }
+    if (intersects) {
+        return { pass: false, reason: 'offset-curve enters the exclusion region', measured };
+    }
+    if (outOfCanvas) {
+        return { pass: false, reason: 'offset-curve runs off canvas', measured };
+    }
+    return { pass: true, measured };
+}
+function gateEdge(spec) {
+    const { curve, confidences, minConfidence, canvas } = spec;
+    const minConf = confidences.length ? Math.min(...confidences) : 0;
+    const outOfCanvas = curve.some((p) => !inCanvas(p, canvas));
+    const measured = { minConfidence: minConf, required: minConfidence };
+    if (confidences.length !== curve.length) {
+        return {
+            pass: false,
+            reason: `confidence count ${confidences.length} != curve points ${curve.length}`,
+            measured,
+        };
+    }
+    if (minConf < minConfidence) {
+        return {
+            pass: false,
+            reason: `edge confidence ${minConf} < required ${minConfidence} (weak/absent boundary)`,
+            measured,
+        };
+    }
+    if (outOfCanvas) {
+        return { pass: false, reason: 'edge runs off canvas', measured };
+    }
+    return { pass: true, measured };
+}
+function gateCurve(spec) {
+    const { curve, canvas } = spec;
+    const minLength = spec.minLength ?? 2;
+    let length = 0;
+    for (let k = 0; k < curve.length - 1; k++)
+        length += Math.hypot(curve[k + 1].x - curve[k].x, curve[k + 1].y - curve[k].y);
+    const outOfCanvas = curve.some((p) => !inCanvas(p, canvas));
+    const measured = {
+        points: curve.length,
+        length: Math.round(length),
+        on_canvas: !outOfCanvas,
+    };
+    if (curve.length < 2)
+        return { pass: false, reason: 'curve has fewer than 2 points', measured };
+    if (length < minLength)
+        return {
+            pass: false,
+            reason: `curve length ${Math.round(length)} < required ${minLength} (degenerate)`,
+            measured,
+        };
+    if (outOfCanvas)
+        return { pass: false, reason: 'curve runs off canvas', measured };
+    return { pass: true, measured };
+}
+function gateRegion(spec) {
+    const { polygon, canvas } = spec;
+    const maxFrac = spec.maxAreaFraction ?? 0.9;
+    const area = polygonArea(polygon);
+    const frameArea = canvas.width * canvas.height;
+    const areaFraction = frameArea > 0 ? area / frameArea : 0;
+    const b = polygon.length ? boundsOf(polygon) : undefined;
+    const outOfCanvas = b
+        ? b.left < 0 || b.top < 0 || b.right > canvas.width || b.bottom > canvas.height
+        : true;
+    const measured = {
+        area: Math.round(area),
+        areaFraction: Math.round(areaFraction * 1000) / 1000,
+    };
+    if (area <= 0) {
+        return { pass: false, reason: 'empty region', measured };
+    }
+    if (outOfCanvas) {
+        return { pass: false, reason: 'region extends off canvas', measured };
+    }
+    if (areaFraction > maxFrac) {
+        return {
+            pass: false,
+            reason: `region ${(areaFraction * 100).toFixed(0)}% of frame — implausibly large for the relation`,
+            measured,
+        };
+    }
+    return { pass: true, measured };
+}
+export function runGate(spec) {
+    switch (spec.target) {
+        case 'point':
+            return gatePoint(spec);
+        case 'region':
+            return gateRegion(spec);
+        case 'path':
+            return spec.kind === 'offset-curve'
+                ? gateOffsetCurve(spec)
+                : spec.kind === 'edge'
+                    ? gateEdge(spec)
+                    : gateCurve(spec);
+    }
+}

package/dist/perception/grounding-geometry.js

@@ -0,0 +1,132 @@
+export function dist(a, b) {
+    return Math.hypot(a.x - b.x, a.y - b.y);
+}
+export function boundsOf(poly) {
+    if (poly.length === 0)
+        throw new Error('boundsOf: empty polyline');
+    let left = Infinity, top = Infinity, right = -Infinity, bottom = -Infinity;
+    for (const p of poly) {
+        if (p.x < left)
+            left = p.x;
+        if (p.x > right)
+            right = p.x;
+        if (p.y < top)
+            top = p.y;
+        if (p.y > bottom)
+            bottom = p.y;
+    }
+    return { left, top, right, bottom };
+}
+export function interpolateCurveAt(curve, at, axis) {
+    if (curve.length === 0)
+        throw new Error('interpolateCurveAt: empty curve');
+    const other = axis === 'x' ? 'y' : 'x';
+    if (curve.length === 1)
+        return curve[0][other];
+    const sorted = [...curve].sort((a, b) => a[axis] - b[axis]);
+    if (at <= sorted[0][axis])
+        return sorted[0][other];
+    const last = sorted[sorted.length - 1];
+    if (at >= last[axis])
+        return last[other];
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const a = sorted[i], b = sorted[i + 1];
+        if (at >= a[axis] && at <= b[axis]) {
+            const span = b[axis] - a[axis];
+            if (span === 0)
+                return a[other];
+            const t = (at - a[axis]) / span;
+            return a[other] + t * (b[other] - a[other]);
+        }
+    }
+    return last[other];
+}
+export function signedGapToCurve(point, curve, side) {
+    switch (side) {
+        case 'down':
+            return point.y - interpolateCurveAt(curve, point.x, 'x');
+        case 'up':
+            return interpolateCurveAt(curve, point.x, 'x') - point.y;
+        case 'right':
+            return point.x - interpolateCurveAt(curve, point.y, 'y');
+        case 'left':
+            return interpolateCurveAt(curve, point.y, 'y') - point.x;
+    }
+}
+export function minSignedGap(offset, source, side) {
+    if (offset.length === 0)
+        throw new Error('minSignedGap: empty offset curve');
+    let min = Infinity;
+    for (const p of offset) {
+        const g = signedGapToCurve(p, source, side);
+        if (g < min)
+            min = g;
+    }
+    return min;
+}
+export function polygonArea(poly) {
+    if (poly.length < 3)
+        return 0;
+    let sum = 0;
+    for (let i = 0; i < poly.length; i++) {
+        const a = poly[i], b = poly[(i + 1) % poly.length];
+        sum += a.x * b.y - b.x * a.y;
+    }
+    return Math.abs(sum) / 2;
+}
+export function pointInBox(p, box) {
+    return p.x >= box.left && p.x <= box.right && p.y >= box.top && p.y <= box.bottom;
+}
+export function pointInPolygon(p, poly) {
+    let inside = false;
+    for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+        const a = poly[i], b = poly[j];
+        const intersects = a.y > p.y !== b.y > p.y && p.x < ((b.x - a.x) * (p.y - a.y)) / (b.y - a.y) + a.x;
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function pointInRegion(p, region) {
+    return region.kind === 'box' ? pointInBox(p, region.box) : pointInPolygon(p, region.polygon);
+}
+export function segmentsIntersect(p1, p2, p3, p4) {
+    const o = (a, b, c) => Math.sign((b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x));
+    const o1 = o(p1, p2, p3), o2 = o(p1, p2, p4), o3 = o(p3, p4, p1), o4 = o(p3, p4, p2);
+    return o1 !== o2 && o3 !== o4;
+}
+function regionEdges(region) {
+    if (region.kind === 'box') {
+        const { left: l, top: t, right: r, bottom: b } = region.box;
+        const c = [
+            { x: l, y: t },
+            { x: r, y: t },
+            { x: r, y: b },
+            { x: l, y: b },
+        ];
+        return [
+            [c[0], c[1]],
+            [c[1], c[2]],
+            [c[2], c[3]],
+            [c[3], c[0]],
+        ];
+    }
+    const poly = region.polygon;
+    const edges = [];
+    for (let i = 0; i < poly.length; i++)
+        edges.push([poly[i], poly[(i + 1) % poly.length]]);
+    return edges;
+}
+export function polylineIntersectsRegion(poly, region) {
+    for (const p of poly)
+        if (pointInRegion(p, region))
+            return true;
+    const edges = regionEdges(region);
+    for (let i = 0; i < poly.length - 1; i++) {
+        for (const [e1, e2] of edges) {
+            if (segmentsIntersect(poly[i], poly[i + 1], e1, e2))
+                return true;
+        }
+    }
+    return false;
+}

package/dist/perception/grounding-grid.js

@@ -0,0 +1,34 @@
+const NAMED = {
+    center: [0.5, 0.5],
+    'upper-left': [1 / 3, 1 / 3],
+    'upper-center': [0.5, 1 / 3],
+    'upper-right': [2 / 3, 1 / 3],
+    'center-left': [1 / 3, 0.5],
+    'center-right': [2 / 3, 0.5],
+    'lower-left': [1 / 3, 2 / 3],
+    'lower-center': [0.5, 2 / 3],
+    'lower-right': [2 / 3, 2 / 3],
+};
+export function frameBox(width, height) {
+    return { left: 0, top: 0, right: width, bottom: height };
+}
+export function gridPoint(box, name) {
+    let fx, fy;
+    if (name.startsWith('frac:')) {
+        const [a, b] = name.slice('frac:'.length).split(',');
+        fx = Number(a);
+        fy = Number(b);
+        if (Number.isNaN(fx) || Number.isNaN(fy))
+            throw new Error(`gridPoint: malformed '${name}' (want frac:fx,fy)`);
+    }
+    else {
+        const f = NAMED[name];
+        if (!f)
+            throw new Error(`gridPoint: unknown position '${name}' (want ${Object.keys(NAMED).join('|')} or frac:fx,fy)`);
+        [fx, fy] = f;
+    }
+    return { x: box.left + fx * (box.right - box.left), y: box.top + fy * (box.bottom - box.top) };
+}
+export function gridAnchor(box, name) {
+    return { kind: 'point', point: gridPoint(box, name) };
+}

package/dist/perception/grounding-landmarks.js

@@ -0,0 +1,40 @@
+import { LANDMARK_GROUPS, LANDMARK_ANCHORS, LANDMARK_COUNT } from '../detection/landmark-spec.js';
+const LEFT_EYE_LOWER = [263, 249, 390, 373, 374, 380, 381, 382, 362];
+const RIGHT_EYE_LOWER = [33, 7, 163, 144, 145, 153, 154, 155, 133];
+const LANDMARK_FEATURES = {
+    left_eye_lower: { as: 'polyline', indices: LEFT_EYE_LOWER },
+    right_eye_lower: { as: 'polyline', indices: RIGHT_EYE_LOWER },
+    left_eye: { as: 'polyline', indices: LANDMARK_GROUPS.leftEye },
+    right_eye: { as: 'polyline', indices: LANDMARK_GROUPS.rightEye },
+    lips_outer: { as: 'polyline', indices: LANDMARK_GROUPS.lipsOuter },
+    nose_tip: { as: 'point', index: LANDMARK_ANCHORS.noseTip },
+    chin: { as: 'point', index: LANDMARK_ANCHORS.chin },
+    between_eyes: { as: 'point', index: LANDMARK_ANCHORS.betweenEyes },
+    upper_lip_top: { as: 'point', index: LANDMARK_ANCHORS.upperLipTop },
+    lower_lip_bottom: { as: 'point', index: LANDMARK_ANCHORS.lowerLipBottom },
+};
+export const LANDMARK_FEATURE_NAMES = Object.keys(LANDMARK_FEATURES);
+export function isLandmarkFeature(feature) {
+    return feature in LANDMARK_FEATURES;
+}
+export function landmarkAnchor(det, sel) {
+    const spec = LANDMARK_FEATURES[sel.feature];
+    if (!spec)
+        return null;
+    const meshed = (det.faces ?? []).filter((f) => f.features && f.features.points.length >= LANDMARK_COUNT);
+    const face = meshed[sel.face ?? 0];
+    if (!face || !face.features)
+        return null;
+    const pts = face.features.points;
+    if (spec.as === 'point') {
+        const p = pts[spec.index];
+        return p ? { kind: 'point', point: { x: p.x, y: p.y } } : null;
+    }
+    const polyline = [];
+    for (const i of spec.indices) {
+        const p = pts[i];
+        if (p)
+            polyline.push({ x: p.x, y: p.y });
+    }
+    return polyline.length >= 2 ? { kind: 'polyline', polyline } : null;
+}