editmamei 0.17.4 → 0.18.0

package/dist/perception/sky-ground-flood.js

@@ -0,0 +1,234 @@
+import { decode } from 'jpeg-js';
+const GREEN_SCALE = 35;
+const DARK_LUM = 60;
+const DARK_SCALE = 45;
+const DARK2 = 145;
+const DARK2_RANGE = 90;
+const BLUE_PROTECT = 22;
+const TEX_SCALE = 0.085;
+const TEX_LUM_MAX = 178;
+const GROUND_BIN = 0.45;
+const OPEN_R = 1;
+const CLOSE_R = 1;
+const SKY_CLOSE_R = 8;
+const clamp = (v, a, b) => (v < a ? a : v > b ? b : v);
+export function computeSkyMask(rgba, srcW, srcH, boxes, opts = {}) {
+    const targetWidth = opts.targetWidth ?? 520;
+    const F = Math.max(1, Math.round(srcW / targetWidth));
+    const W = Math.max(1, Math.floor(srcW / F));
+    const H = Math.max(1, Math.floor(srcH / F));
+    const N = W * H;
+    const R = new Float64Array(N);
+    const G = new Float64Array(N);
+    const B = new Float64Array(N);
+    for (let y = 0; y < H; y++)
+        for (let x = 0; x < W; x++) {
+            let r = 0, g = 0, b = 0, n = 0;
+            for (let dy = 0; dy < F; dy++)
+                for (let dx = 0; dx < F; dx++) {
+                    const i = ((y * F + dy) * srcW + (x * F + dx)) * 4;
+                    r += rgba[i];
+                    g += rgba[i + 1];
+                    b += rgba[i + 2];
+                    n++;
+                }
+            const o = y * W + x;
+            R[o] = r / n;
+            G[o] = g / n;
+            B[o] = b / n;
+        }
+    const lum = new Float64Array(N);
+    const greenness = new Float64Array(N);
+    for (let i = 0; i < N; i++) {
+        lum[i] = 0.299 * R[i] + 0.587 * G[i] + 0.114 * B[i];
+        greenness[i] = clamp((G[i] - Math.max(R[i], B[i])) / GREEN_SCALE, 0, 1);
+    }
+    const edge = new Float64Array(N);
+    for (let y = 1; y < H - 1; y++)
+        for (let x = 1; x < W - 1; x++) {
+            const gx = lum[(y - 1) * W + x + 1] +
+                2 * lum[y * W + x + 1] +
+                lum[(y + 1) * W + x + 1] -
+                (lum[(y - 1) * W + x - 1] + 2 * lum[y * W + x - 1] + lum[(y + 1) * W + x - 1]);
+            const gy = lum[(y + 1) * W + x - 1] +
+                2 * lum[(y + 1) * W + x] +
+                lum[(y + 1) * W + x + 1] -
+                (lum[(y - 1) * W + x - 1] + 2 * lum[(y - 1) * W + x] + lum[(y - 1) * W + x + 1]);
+            edge[y * W + x] = Math.min(1, Math.hypot(gx, gy) / 600);
+        }
+    const textureDensity = boxBlur(edge, W, H, 2);
+    const notSky = new Uint8Array(N);
+    for (let i = 0; i < N; i++) {
+        const darkSolid = lum[i] < DARK_LUM ? clamp((DARK_LUM - lum[i]) / DARK_SCALE, 0, 1) : 0;
+        const texturedNonSky = lum[i] < TEX_LUM_MAX ? clamp(textureDensity[i] / TEX_SCALE, 0, 1) : 0;
+        const blueDom = B[i] - Math.max(R[i], G[i]);
+        const darkNotBlue = clamp((DARK2 - lum[i]) / DARK2_RANGE, 0, 1) * (1 - clamp(blueDom / BLUE_PROTECT, 0, 1));
+        const ground = Math.max(greenness[i], darkSolid, 0.85 * texturedNonSky, darkNotBlue);
+        if (ground >= GROUND_BIN)
+            notSky[i] = 1;
+    }
+    const solidGroundRaw = open(notSky, W, H, OPEN_R);
+    const landmass = floodFromBottom(solidGroundRaw, W, H);
+    const skyFill = floodTop((i) => landmass[i] === 0, W, H);
+    const objMask = rasterizeBoxes(boxes, W, H, F);
+    const closed = close(skyFill, W, H, SKY_CLOSE_R);
+    const mask = new Uint8Array(N);
+    for (let i = 0; i < N; i++)
+        mask[i] = skyFill[i] || (closed[i] && !objMask[i]) ? 1 : 0;
+    fillEnclosedHoles(mask, W, H);
+    const finalMask = close(mask, W, H, CLOSE_R);
+    return { mask: finalMask, width: W, height: H };
+}
+export function computeSkyMaskFromJpeg(jpegBytes, boxes, opts = {}) {
+    const img = decode(jpegBytes, { useTArray: true, formatAsRGBA: true });
+    return computeSkyMask(img.data, img.width, img.height, boxes, opts);
+}
+function rasterizeBoxes(boxes, W, H, F) {
+    const m = new Uint8Array(W * H);
+    for (const b of boxes) {
+        const x1 = Math.max(0, Math.floor(b[0] / F));
+        const y1 = Math.max(0, Math.floor(b[1] / F));
+        const x2 = Math.min(W, Math.ceil(b[2] / F));
+        const y2 = Math.min(H, Math.ceil(b[3] / F));
+        for (let y = y1; y < y2; y++)
+            for (let x = x1; x < x2; x++)
+                m[y * W + x] = 1;
+    }
+    return m;
+}
+function floodTop(passable, W, H) {
+    const vis = new Uint8Array(W * H);
+    const st = [];
+    for (let x = 0; x < W; x++)
+        if (passable(x)) {
+            vis[x] = 1;
+            st.push(x);
+        }
+    pushNeighbors(st, vis, passable, W, H);
+    return vis;
+}
+function floodFromBottom(mask, W, H) {
+    const vis = new Uint8Array(W * H);
+    const st = [];
+    for (let x = 0; x < W; x++) {
+        const i = (H - 1) * W + x;
+        if (mask[i]) {
+            vis[i] = 1;
+            st.push(i);
+        }
+    }
+    pushNeighbors(st, vis, (i) => mask[i] === 1, W, H);
+    return vis;
+}
+function pushNeighbors(st, vis, passable, W, H) {
+    while (st.length) {
+        const p = st.pop();
+        const x = p % W;
+        const y = (p - x) / W;
+        if (x + 1 < W && !vis[p + 1] && passable(p + 1)) {
+            vis[p + 1] = 1;
+            st.push(p + 1);
+        }
+        if (x - 1 >= 0 && !vis[p - 1] && passable(p - 1)) {
+            vis[p - 1] = 1;
+            st.push(p - 1);
+        }
+        if (y + 1 < H && !vis[p + W] && passable(p + W)) {
+            vis[p + W] = 1;
+            st.push(p + W);
+        }
+        if (y - 1 >= 0 && !vis[p - W] && passable(p - W)) {
+            vis[p - W] = 1;
+            st.push(p - W);
+        }
+    }
+}
+export function fillEnclosedHoles(mask, W, H) {
+    const reach = new Uint8Array(W * H);
+    const st = [];
+    const seed = (i) => {
+        if (!mask[i] && !reach[i]) {
+            reach[i] = 1;
+            st.push(i);
+        }
+    };
+    for (let x = 0; x < W; x++) {
+        seed(x);
+        seed((H - 1) * W + x);
+    }
+    for (let y = 0; y < H; y++) {
+        seed(y * W);
+        seed(y * W + W - 1);
+    }
+    pushNeighbors(st, reach, (i) => mask[i] === 0, W, H);
+    for (let i = 0; i < W * H; i++)
+        if (!mask[i] && !reach[i])
+            mask[i] = 1;
+}
+function dilate(mask, W, H, r) {
+    const out = new Uint8Array(W * H);
+    for (let y = 0; y < H; y++)
+        for (let x = 0; x < W; x++) {
+            let v = 0;
+            for (let dy = -r; dy <= r && !v; dy++)
+                for (let dx = -r; dx <= r && !v; dx++) {
+                    const xx = x + dx;
+                    const yy = y + dy;
+                    if (xx < 0 || yy < 0 || xx >= W || yy >= H)
+                        continue;
+                    if (mask[yy * W + xx])
+                        v = 1;
+                }
+            out[y * W + x] = v;
+        }
+    return out;
+}
+function erode(mask, W, H, r) {
+    const out = new Uint8Array(W * H);
+    for (let y = 0; y < H; y++)
+        for (let x = 0; x < W; x++) {
+            let v = 1;
+            for (let dy = -r; dy <= r && v; dy++)
+                for (let dx = -r; dx <= r && v; dx++) {
+                    const xx = x + dx;
+                    const yy = y + dy;
+                    if (xx < 0 || yy < 0 || xx >= W || yy >= H)
+                        continue;
+                    if (!mask[yy * W + xx])
+                        v = 0;
+                }
+            out[y * W + x] = v;
+        }
+    return out;
+}
+function open(mask, W, H, r) {
+    return dilate(erode(mask, W, H, r), W, H, r);
+}
+function close(mask, W, H, r) {
+    return erode(dilate(mask, W, H, r), W, H, r);
+}
+function boxBlur(src, W, H, iters) {
+    let a = Float64Array.from(src);
+    let b = new Float64Array(W * H);
+    for (let it = 0; it < iters; it++) {
+        for (let y = 0; y < H; y++)
+            for (let x = 0; x < W; x++) {
+                let s = 0;
+                let n = 0;
+                for (let dy = -1; dy <= 1; dy++)
+                    for (let dx = -1; dx <= 1; dx++) {
+                        const xx = x + dx;
+                        const yy = y + dy;
+                        if (xx < 0 || yy < 0 || xx >= W || yy >= H)
+                            continue;
+                        s += a[yy * W + xx];
+                        n++;
+                    }
+                b[y * W + x] = s / n;
+            }
+        const t = a;
+        a = b;
+        b = t;
+    }
+    return a;
+}

package/dist/perception/sky-mask-transfer.js

@@ -0,0 +1,77 @@
+import * as fs from 'node:fs/promises';
+import { encode } from 'jpeg-js';
+import { runScript } from '../utils/run-script.js';
+import { TempDir, userOwnedTempRoot } from '../utils/temp.js';
+import { getContextInfo } from '../api/extendscript/_helpers.js';
+import { jsLit, jsNum } from '../utils/jsx.js';
+function encodeMaskJpeg(mask, w, h) {
+    const rgba = Buffer.alloc(w * h * 4);
+    for (let i = 0; i < w * h; i++) {
+        const v = mask[i] ? 255 : 0;
+        rgba[i * 4] = v;
+        rgba[i * 4 + 1] = v;
+        rgba[i * 4 + 2] = v;
+        rgba[i * 4 + 3] = 255;
+    }
+    return encode({ data: rgba, width: w, height: h }, 92).data;
+}
+function buildLoadScript(maskPath, docW, docH) {
+    return `
+    ${getContextInfo}
+    function __skyRestoreComposite(d) {
+      try {
+        app.activeDocument = d;
+        var ref = new ActionReference();
+        ref.putEnumerated(app.charIDToTypeID('Chnl'), app.charIDToTypeID('Chnl'), app.charIDToTypeID('RGB '));
+        var desc = new ActionDescriptor();
+        desc.putReference(app.charIDToTypeID('null'), ref);
+        app.executeAction(app.charIDToTypeID('slct'), desc, DialogModes.NO);
+      } catch (eRC) {}
+    }
+    if (app.documents.length === 0) { throw new Error('No active document'); }
+    var orig = app.activeDocument;
+
+    // Bring the upscaled mask onto the clipboard FIRST, so no document switch sits
+    // between the channel setup and the paste below.
+    var maskDoc = app.open(new File(${jsLit(maskPath)}));
+    maskDoc.resizeImage(
+      UnitValue(${jsNum(docW, 1)}, 'px'),
+      UnitValue(${jsNum(docH, 1)}, 'px'),
+      null,
+      ResampleMethod.BICUBIC
+    );
+    maskDoc.selection.selectAll();
+    maskDoc.selection.copy();
+    maskDoc.close(SaveOptions.DONOTSAVECHANGES);
+
+    // Paste the doc-sized mask INTO a full-canvas alpha channel on the original. With
+    // the alpha channel the explicit active channel, paste writes grayscale into it (no
+    // new layer). selectAll + paste-into keeps the doc-sized clipboard aligned to canvas.
+    app.activeDocument = orig;
+    var ch = orig.channels.add();
+    orig.activeChannels = [ch];
+    orig.selection.selectAll();
+    orig.paste(true);
+    orig.selection.deselect();
+
+    // Load the channel as the working selection (white = sky), then drop the temp channel.
+    orig.selection.load(ch, SelectionType.REPLACE);
+    try { ch.remove(); } catch (eRm) {}
+    __skyRestoreComposite(orig);
+    return { ok: true };
+  `;
+}
+export async function loadSkyMaskAsSelection(connection, mask, maskW, maskH, docW, docH) {
+    const jpg = encodeMaskJpeg(mask, maskW, maskH);
+    const dir = process.platform === 'darwin'
+        ? await TempDir.createWithRoot(userOwnedTempRoot(), 'editmamei-sky-')
+        : await TempDir.create('editmamei-sky-');
+    try {
+        const maskPath = dir.path('skymask.jpg');
+        await fs.writeFile(maskPath, jpg);
+        await runScript(connection, buildLoadScript(maskPath, docW, docH));
+    }
+    finally {
+        await dir.cleanup();
+    }
+}

package/dist/platform/macos-executor.js

@@ -104,7 +104,6 @@ export class MacOSExecutor {
         }
         return `tell application "${this.appName}"
 \tactivate
-\tset jsxFile to POSIX file "${posixPath}"
 \tdo javascript "$.evalFile(decodeURI('${encodeURI(posixPath)}'))"
 end tell`;
     }

package/dist/platform/windows-executor.js

@@ -104,7 +104,12 @@ If Err.Number <> 0 Then
     WScript.Quit 1
 End If
 
-' Execute the JSX script
+' Execute the JSX script. The path is the mkdtemp temp file (quote-free by the
+' guard above), but its single backslashes must be DOUBLED here: this string is
+' handed to DoJavaScript as ExtendScript SOURCE, and a backslash inside a quoted
+' path there is a JS string-literal escape (a Users/Temp segment would be parsed
+' as an escape sequence and corrupt the path). The VBS Replace doubles each
+' backslash so ExtendScript resolves it back. Load-bearing — NOT a no-op.
 Dim result
 result = photoshopApp.DoJavaScript("$.evalFile(""" & Replace("${jsxPath}", "\\", "\\\\") & """);")
 

package/dist/preview/coordinate-grid.js

@@ -0,0 +1,250 @@
+import { decode, encode } from 'jpeg-js';
+const FONT_5x7 = {
+    '0': [0b01110, 0b10001, 0b10011, 0b10101, 0b11001, 0b10001, 0b01110],
+    '1': [0b00100, 0b01100, 0b00100, 0b00100, 0b00100, 0b00100, 0b01110],
+    '2': [0b01110, 0b10001, 0b00001, 0b00010, 0b00100, 0b01000, 0b11111],
+    '3': [0b11111, 0b00010, 0b00100, 0b00010, 0b00001, 0b10001, 0b01110],
+    '4': [0b00010, 0b00110, 0b01010, 0b10010, 0b11111, 0b00010, 0b00010],
+    '5': [0b11111, 0b10000, 0b11110, 0b00001, 0b00001, 0b10001, 0b01110],
+    '6': [0b00110, 0b01000, 0b10000, 0b11110, 0b10001, 0b10001, 0b01110],
+    '7': [0b11111, 0b00001, 0b00010, 0b00100, 0b01000, 0b01000, 0b01000],
+    '8': [0b01110, 0b10001, 0b10001, 0b01110, 0b10001, 0b10001, 0b01110],
+    '9': [0b01110, 0b10001, 0b10001, 0b01111, 0b00001, 0b00010, 0b01100],
+    '-': [0b00000, 0b00000, 0b00000, 0b11111, 0b00000, 0b00000, 0b00000],
+    '.': [0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b01100, 0b01100],
+    A: [0b01110, 0b10001, 0b10001, 0b11111, 0b10001, 0b10001, 0b10001],
+    B: [0b11110, 0b10001, 0b10001, 0b11110, 0b10001, 0b10001, 0b11110],
+    C: [0b01110, 0b10001, 0b10000, 0b10000, 0b10000, 0b10001, 0b01110],
+    D: [0b11110, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b11110],
+    E: [0b11111, 0b10000, 0b10000, 0b11110, 0b10000, 0b10000, 0b11111],
+    F: [0b11111, 0b10000, 0b10000, 0b11110, 0b10000, 0b10000, 0b10000],
+    G: [0b01110, 0b10001, 0b10000, 0b10111, 0b10001, 0b10001, 0b01111],
+    H: [0b10001, 0b10001, 0b10001, 0b11111, 0b10001, 0b10001, 0b10001],
+    I: [0b01110, 0b00100, 0b00100, 0b00100, 0b00100, 0b00100, 0b01110],
+    J: [0b00111, 0b00010, 0b00010, 0b00010, 0b00010, 0b10010, 0b01100],
+    K: [0b10001, 0b10010, 0b10100, 0b11000, 0b10100, 0b10010, 0b10001],
+    L: [0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b10000, 0b11111],
+    M: [0b10001, 0b11011, 0b10101, 0b10101, 0b10001, 0b10001, 0b10001],
+    N: [0b10001, 0b10001, 0b11001, 0b10101, 0b10011, 0b10001, 0b10001],
+    O: [0b01110, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b01110],
+    P: [0b11110, 0b10001, 0b10001, 0b11110, 0b10000, 0b10000, 0b10000],
+    Q: [0b01110, 0b10001, 0b10001, 0b10001, 0b10101, 0b10010, 0b01101],
+    R: [0b11110, 0b10001, 0b10001, 0b11110, 0b10100, 0b10010, 0b10001],
+    S: [0b01111, 0b10000, 0b10000, 0b01110, 0b00001, 0b00001, 0b11110],
+    T: [0b11111, 0b00100, 0b00100, 0b00100, 0b00100, 0b00100, 0b00100],
+    U: [0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b01110],
+    V: [0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b01010, 0b00100],
+    W: [0b10001, 0b10001, 0b10001, 0b10101, 0b10101, 0b11011, 0b10001],
+    X: [0b10001, 0b10001, 0b01010, 0b00100, 0b01010, 0b10001, 0b10001],
+    Y: [0b10001, 0b10001, 0b01010, 0b00100, 0b00100, 0b00100, 0b00100],
+    Z: [0b11111, 0b00001, 0b00010, 0b00100, 0b01000, 0b10000, 0b11111],
+};
+const GLYPH_W = 5;
+const GLYPH_H = 7;
+function hexToRgb(hex, fallback) {
+    if (!hex || hex[0] !== '#' || hex.length !== 7)
+        return fallback;
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    if ([r, g, b].some((v) => Number.isNaN(v)))
+        return fallback;
+    return { r, g, b };
+}
+const WHITE = { r: 255, g: 255, b: 255 };
+const BLACK = { r: 0, g: 0, b: 0 };
+function setPx(data, w, h, x, y, c) {
+    if (x < 0 || y < 0 || x >= w || y >= h)
+        return;
+    const i = (y * w + x) * 4;
+    data[i] = c.r;
+    data[i + 1] = c.g;
+    data[i + 2] = c.b;
+    data[i + 3] = 255;
+}
+function drawVLine(data, w, h, x, core) {
+    for (let y = 0; y < h; y++) {
+        setPx(data, w, h, x, y, core);
+        setPx(data, w, h, x + 1, y, BLACK);
+    }
+}
+function drawHLine(data, w, h, y, core) {
+    for (let x = 0; x < w; x++) {
+        setPx(data, w, h, x, y, core);
+        setPx(data, w, h, x, y + 1, BLACK);
+    }
+}
+function drawGlyph(data, w, h, glyph, px, py, scale, text) {
+    for (let row = 0; row < GLYPH_H; row++) {
+        const bits = glyph[row];
+        for (let col = 0; col < GLYPH_W; col++) {
+            if (!(bits & (1 << (GLYPH_W - 1 - col))))
+                continue;
+            const bx = px + col * scale;
+            const by = py + row * scale;
+            for (let oy = -1; oy <= scale; oy++) {
+                for (let ox = -1; ox <= scale; ox++) {
+                    setPx(data, w, h, bx + ox, by + oy, BLACK);
+                }
+            }
+            for (let sy = 0; sy < scale; sy++) {
+                for (let sx = 0; sx < scale; sx++) {
+                    setPx(data, w, h, bx + sx, by + sy, text);
+                }
+            }
+        }
+    }
+}
+function textWidth(str, scale) {
+    return str.length * (GLYPH_W + 1) * scale;
+}
+function drawText(data, w, h, str, px, py, scale, text) {
+    let cx = px;
+    for (const ch of str) {
+        const glyph = FONT_5x7[ch];
+        if (glyph)
+            drawGlyph(data, w, h, glyph, cx, py, scale, text);
+        cx += (GLYPH_W + 1) * scale;
+    }
+}
+export function niceStep(target) {
+    if (!(target > 0))
+        return 1;
+    const mag = Math.pow(10, Math.floor(Math.log10(target)));
+    const norm = target / mag;
+    const candidates = [1, 2, 5, 10];
+    let best = 1;
+    let bestDist = Infinity;
+    for (const c of candidates) {
+        const d = Math.abs(norm - c);
+        if (d <= bestDist) {
+            bestDist = d;
+            best = c;
+        }
+    }
+    return Math.max(1, Math.round(best * mag));
+}
+export function colLabel(i) {
+    let n = Math.floor(i) + 1;
+    let s = '';
+    while (n > 0) {
+        const r = (n - 1) % 26;
+        s = String.fromCharCode(65 + r) + s;
+        n = Math.floor((n - 1) / 26);
+    }
+    return s;
+}
+function computeLines(opts) {
+    const { docWidth, docHeight } = opts;
+    const vertical = [];
+    const horizontal = [];
+    if (typeof opts.columns === 'number' && opts.columns >= 2) {
+        for (let i = 1; i < opts.columns; i++)
+            vertical.push(Math.round((docWidth * i) / opts.columns));
+    }
+    if (typeof opts.rows === 'number' && opts.rows >= 2) {
+        for (let j = 1; j < opts.rows; j++)
+            horizontal.push(Math.round((docHeight * j) / opts.rows));
+    }
+    if (vertical.length > 0 || horizontal.length > 0) {
+        return { vertical, horizontal, step: null };
+    }
+    const longEdge = Math.max(docWidth, docHeight);
+    const requested = typeof opts.stepPx === 'number' && opts.stepPx > 0 ? opts.stepPx : niceStep(longEdge / 10);
+    const MAX_LINES_PER_AXIS = 80;
+    const step = Math.max(requested, Math.ceil(longEdge / MAX_LINES_PER_AXIS));
+    for (let x = step; x < docWidth; x += step)
+        vertical.push(x);
+    for (let y = step; y < docHeight; y += step)
+        horizontal.push(y);
+    return { vertical, horizontal, step };
+}
+export function overlayCoordinateGrid(jpegBuffer, opts) {
+    const img = decode(jpegBuffer, { useTArray: true, formatAsRGBA: true });
+    const w = img.width;
+    const h = img.height;
+    const data = img.data;
+    const scaleX = w / opts.docWidth;
+    const scaleY = h / opts.docHeight;
+    const core = hexToRgb(opts.color, WHITE);
+    const labelEvery = Math.max(1, Math.floor(opts.labelEvery ?? 1));
+    const glyphScale = Math.max(2, Math.round(Math.max(w, h) / 600));
+    const labelH = GLYPH_H * glyphScale;
+    if (opts.cellLabels) {
+        const numCols = Math.max(1, Math.floor(opts.columns ?? 8));
+        const numRows = Math.max(1, Math.floor(opts.rows ?? 10));
+        const cellW = opts.docWidth / numCols;
+        const cellH = opts.docHeight / numRows;
+        for (let i = 1; i < numCols; i++)
+            drawVLine(data, w, h, Math.round(i * cellW * scaleX), core);
+        for (let j = 1; j < numRows; j++)
+            drawHLine(data, w, h, Math.round(j * cellH * scaleY), core);
+        for (let i = 0; i < numCols; i++) {
+            for (let j = 0; j < numRows; j++) {
+                const px = Math.round(i * cellW * scaleX) + 3;
+                const py = Math.round(j * cellH * scaleY) + 3;
+                drawText(data, w, h, colLabel(i) + (j + 1), px, py, glyphScale, core);
+            }
+        }
+        const out = encode({ data, width: w, height: h }, 85);
+        const cw = Math.round(cellW);
+        const ch = Math.round(cellH);
+        const legend = `Cell grid: ${numCols} columns (A–${colLabel(numCols - 1)}) × ${numRows} rows (1–${numRows}) ` +
+            `over a ${opts.docWidth}×${opts.docHeight} px document; each cell ≈ ${cw}×${ch} doc px. ` +
+            `Pick the CELL a feature sits in. Cell <Col><Row> covers x=[(col−1)·${cw} … col·${cw}], ` +
+            `y=[(row−1)·${ch} … row·${ch}] (col A=1…${colLabel(numCols - 1)}=${numCols}); ` +
+            `the cell center is x=(col−0.5)·${cw}, y=(row−0.5)·${ch}.`;
+        return {
+            jpeg: out.data,
+            legend,
+            verticalLines: Array.from({ length: numCols - 1 }, (_, i) => Math.round((i + 1) * cellW)),
+            horizontalLines: Array.from({ length: numRows - 1 }, (_, j) => Math.round((j + 1) * cellH)),
+            previewWidth: w,
+            previewHeight: h,
+        };
+    }
+    const { vertical, horizontal, step } = computeLines(opts);
+    for (const docX of vertical)
+        drawVLine(data, w, h, Math.round(docX * scaleX), core);
+    for (const docY of horizontal)
+        drawHLine(data, w, h, Math.round(docY * scaleY), core);
+    for (let i = 0; i < vertical.length; i++) {
+        if (i % labelEvery !== 0)
+            continue;
+        const docX = vertical[i];
+        const px = Math.round(docX * scaleX);
+        drawText(data, w, h, String(docX), px + 3, 2, glyphScale, core);
+        if (opts.normalized) {
+            const frac = (docX / opts.docWidth).toFixed(2);
+            drawText(data, w, h, frac, px + 3, h - labelH - 2, glyphScale, core);
+        }
+    }
+    for (let j = 0; j < horizontal.length; j++) {
+        if (j % labelEvery !== 0)
+            continue;
+        const docY = horizontal[j];
+        const py = Math.round(docY * scaleY);
+        drawText(data, w, h, String(docY), 2, py + 3, glyphScale, core);
+        if (opts.normalized) {
+            const frac = (docY / opts.docHeight).toFixed(2);
+            const s = frac;
+            drawText(data, w, h, s, w - textWidth(s, glyphScale) - 2, py + 3, glyphScale, core);
+        }
+    }
+    const out = encode({ data, width: w, height: h }, 85);
+    const spacingNote = step !== null
+        ? `lines every ${step} px`
+        : `${vertical.length + 1}×${horizontal.length + 1} divisions`;
+    const normNote = opts.normalized ? '; normalized 0–1 labels on bottom/right edges' : '';
+    const legend = `Coordinate grid: ${spacingNote}, labeled in DOCUMENT pixels, top-left origin. ` +
+        `Document is ${opts.docWidth}×${opts.docHeight} px (preview ${w}×${h}). ` +
+        `Read the x/y value off a labeled line and pass it straight to a tool${normNote}.`;
+    return {
+        jpeg: out.data,
+        legend,
+        verticalLines: vertical,
+        horizontalLines: horizontal,
+        previewWidth: w,
+        previewHeight: h,
+    };
+}

package/dist/telemetry/events.js

@@ -77,7 +77,8 @@ export function looksLikeAbsolutePath(value) {
     return (/^[A-Za-z]:[\\/]/.test(value) ||
         /^[\\/]/.test(value) ||
         value.includes('\\') ||
-        /^file:\/\//i.test(value));
+        /^file:\/\//i.test(value) ||
+        /(?:\/[^\s/]+){2,}/.test(value));
 }
 export function isContentSafe(event) {
     for (const value of Object.values(event)) {

package/dist/telemetry/sanitize.js

@@ -22,14 +22,28 @@ function homedirPrefixes() {
     }
     return [...set];
 }
+const SINGLE_SEG_POSIX = /(^|\s)\/[^\s"'/]+(?=$|\s)/;
 function basenamePaths(s) {
-    return s.replace(/[A-Za-z]:[\\/][^\s"']*|\\\\[^\s"']+|file:\/\/[^\s"']*|(?:\/[^\s"'/]+){2,}\/?/gi, (m) => m.split(/[\\/]/).filter(Boolean).pop() ?? '');
+    return s.replace(/[A-Za-z]:[\\/][^\s"']*|\\\\[^\s"']+|file:\/\/[^\s"']*|(?:\/[^\s"'/]+){2,}\/?|(?:^|\s)\/[^\s"'/]+(?=$|\s)/gi, (m) => {
+        const single = SINGLE_SEG_POSIX.exec(m);
+        if (single)
+            return `${single[1]}/…`;
+        return m.split(/[\\/]/).filter(Boolean).pop() ?? '';
+    });
+}
+function redactGenericUserDirs(s) {
+    let out = s.replace(/\bUsers([\\/])[^\\/\s"']+/g, 'Users$1~');
+    if (process.platform !== 'win32') {
+        out = out.replace(/\bhome([\\/])[^\\/\s"']+/g, 'home$1~');
+    }
+    return out;
 }
 export function sanitizeMessage(input, maxLen = MAX_MESSAGE_LEN) {
     let out = input;
     for (const prefix of homedirPrefixes()) {
         out = redactHomedirIn(out, prefix);
     }
+    out = redactGenericUserDirs(out);
     out = basenamePaths(out);
     out = out.replace(/\\/g, '/');
     out = out.replace(/^[/]+/, '');