editmamei 0.19.0 → 0.22.0

package/dist/preview/coordinate-grid.js

@@ -1,250 +0,0 @@
-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/tools/object-tools.js

@@ -1,193 +0,0 @@
-import { runScript } from '../utils/run-script.js';
-import { validateArgs } from '../utils/validate.js';
-import { detectActiveDoc } from '../detection/detect-active-doc.js';
-import { OnnxDetectionClient, } from '../detection/detection-client.js';
-const OBJECT_OPS = ['remove', 'blur_background', 'spotlight'];
-const objectSchema = {
-    type: 'object',
-    properties: {
-        op: {
-            type: 'string',
-            enum: [...OBJECT_OPS],
-            description: 'remove: erase the matched object(s) via Content-Aware Fill (background person, photobomber, sign). blur_background: keep the matched object(s) sharp, blur everything else (fake depth of field). spotlight: keep the matched object(s) lit, darken everything else.',
-        },
-        label: {
-            type: 'string',
-            description: "COCO class to target (e.g. 'person', 'dog', 'car', 'chair'). For remove this is what gets erased; for blur_background/spotlight it is the SUBJECT to keep.",
-        },
-        all: {
-            type: 'boolean',
-            default: false,
-            description: 'Act on ALL detected instances of the label. Default false = the single highest-confidence one.',
-        },
-        amount: {
-            type: 'number',
-            minimum: 1,
-            maximum: 250,
-            description: 'blur_background: blur radius in px (default 25). spotlight: darken strength 1–100 (default 45). Ignored by remove.',
-        },
-        object_threshold: {
-            type: 'number',
-            default: 0.4,
-            minimum: 0,
-            maximum: 1,
-            description: 'Minimum detection confidence (0–1).',
-        },
-        max_dimension: {
-            type: 'number',
-            default: 1024,
-            minimum: 256,
-            maximum: 4096,
-            description: 'Long-edge px of the detection export. Coordinates always return in document px.',
-        },
-    },
-    required: ['op', 'label'],
-};
-function pickObjects(objects, label, all) {
-    const matches = objects
-        .filter((o) => o.label === label)
-        .sort((a, b) => b.confidence - a.confidence);
-    if (matches.length === 0)
-        return [];
-    return all ? matches : [matches[0]];
-}
-function subjectFeather(targets) {
-    const minDim = Math.min(...targets.map((t) => Math.min(t.bbox[2] - t.bbox[0], t.bbox[3] - t.bbox[1])));
-    return Math.max(8, Math.round(minDim * 0.03));
-}
-async function selectBoxes(connection, snippet, targets, featherPx) {
-    for (let i = 0; i < targets.length; i++) {
-        const [l, t, r, b] = targets[i].bbox;
-        await runScript(connection, await snippet.build('selectRectangle', {
-            left: l,
-            top: t,
-            right: r,
-            bottom: b,
-            featherPx,
-            selectionType: i === 0 ? 'replace' : 'add',
-        }));
-    }
-}
-async function runObjectOp(connection, snippet, client, rawArgs) {
-    try {
-        const args = validateArgs(objectSchema, rawArgs);
-        const op = args.op;
-        const label = args.label;
-        const all = args.all ?? false;
-        const det = await detectActiveDoc(connection, client, {
-            objects: true,
-            maxDimension: args.max_dimension,
-            objectThreshold: args.object_threshold,
-        });
-        const targets = pickObjects(det.result.objects ?? [], label, all);
-        if (targets.length === 0) {
-            const seen = [...new Set((det.result.objects ?? []).map((o) => o.label))].sort();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No "${label}" detected. Found: ${seen.length ? seen.join(', ') : '(nothing)'}. Try a different label or lower object_threshold.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        let summary = '';
-        try {
-            if (op === 'remove') {
-                await selectBoxes(connection, snippet, targets, 0);
-                const minDim = Math.min(...targets.map((t) => Math.min(t.bbox[2] - t.bbox[0], t.bbox[3] - t.bbox[1])));
-                const expand = Math.max(8, Math.round(minDim * 0.02));
-                await runScript(connection, await snippet.build('modifySelectionEdge', {
-                    mode: 'expand',
-                    amount: expand,
-                    atCanvasBounds: false,
-                }));
-                const r = (await runScript(connection, await snippet.build('applyContentAwareFill', {
-                    colorAdaptation: true,
-                    rotate: false,
-                    scale: false,
-                    mirror: false,
-                    opacity: 100,
-                    blendMode: 'normal',
-                    applyToActiveLayer: false,
-                })));
-                summary = `Removed ${targets.length} "${label}" via Content-Aware Fill on a new layer (${r.target_layer_name ?? 'copy'}). Original preserved.`;
-            }
-            else if (op === 'blur_background') {
-                const radius = args.amount ?? 25;
-                await selectBoxes(connection, snippet, targets, subjectFeather(targets));
-                await runScript(connection, await snippet.build('invertSelection'));
-                const r = (await runScript(connection, await snippet.build('applyGaussianBlur', { radius, applyToActiveLayer: false })));
-                summary = `Blurred the background (radius ${radius}px) behind ${targets.length} "${label}" on a new layer (${r.target_layer_name ?? 'copy'}).`;
-            }
-            else {
-                const strength = args.amount ?? 45;
-                await selectBoxes(connection, snippet, targets, subjectFeather(targets));
-                await runScript(connection, await snippet.build('invertSelection'));
-                await runScript(connection, await snippet.build('addAdjustmentLayer', {
-                    type: 'brightness_contrast',
-                    brightness: -Math.abs(strength),
-                    mask_from_selection: true,
-                    mask_inverted: false,
-                    clip_to_below: false,
-                    name: 'Spotlight',
-                }));
-                summary = `Darkened the background (−${Math.abs(strength)}) around ${targets.length} "${label}" with a masked adjustment layer.`;
-            }
-        }
-        finally {
-            try {
-                await runScript(connection, await snippet.build('deselect'));
-            }
-            catch {
-            }
-        }
-        return {
-            content: [{ type: 'text', text: summary }],
-            structuredContent: {
-                op,
-                label,
-                targeted: targets.length,
-                boxes: targets.map((t) => t.bbox),
-                image: det.result.image,
-                context: det.context,
-            },
-        };
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error in photoshop_object: ${msg}` }],
-            isError: true,
-        };
-    }
-}
-export function createObjectTools(connection, snippetClient, client = new OnnxDetectionClient()) {
-    return [
-        {
-            tool: {
-                name: 'photoshop_object',
-                description: 'Detection-driven object edits keyed on a COCO label (person, dog, car, chair, …), using LOCAL on-device vision. op=remove erases the matched object(s) with Content-Aware Fill (great for a background person / photobomber / sign on a reconstructable background like sky, water, wall, foliage; the original layer is preserved). op=blur_background keeps the matched subject sharp and blurs everything else (fake depth of field). op=spotlight keeps the subject lit and darkens the rest. All ops work from the detection bounding box. Pair with photoshop_detect first if you want to see what is detectable.',
-                inputSchema: objectSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        op: { type: 'string' },
-                        label: { type: 'string' },
-                        targeted: { type: 'number' },
-                        boxes: { type: 'array', items: { type: 'array', items: { type: 'number' } } },
-                        image: { type: 'object' },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Object Edit (detection-driven)',
-                    destructiveHint: true,
-                    openWorldHint: false,
-                },
-            },
-            handler: async (args) => runObjectOp(connection, snippetClient, client, args),
-        },
-    ];
-}

package/dist/tools/text-on-object-tools.js

@@ -1,225 +0,0 @@
-import { runScript } from '../utils/run-script.js';
-import { validateArgs } from '../utils/validate.js';
-import { detectActiveDoc } from '../detection/detect-active-doc.js';
-import { OnnxDetectionClient, } from '../detection/detection-client.js';
-const TEXT_WARP_STYLES = [
-    'warpArc',
-    'warpArcUpper',
-    'warpArcLower',
-    'warpArch',
-    'warpFlag',
-    'warpWave',
-    'warpRise',
-    'warpBulge',
-    'warpInflate',
-    'none',
-];
-const NOMINAL_FONT_PT = 72;
-const SCALE_MIN_PCT = 10;
-const SCALE_MAX_PCT = 1000;
-const textOnObjectSchema = {
-    type: 'object',
-    properties: {
-        text: {
-            type: 'string',
-            description: 'The words to place on the object (e.g. "GOOD DOG").',
-        },
-        label: {
-            type: 'string',
-            description: "COCO class to anchor the text on (e.g. 'person', 'dog', 'car', 'chair'). The text is fitted to this object's bounding box.",
-        },
-        warp_style: {
-            type: 'string',
-            enum: [...TEXT_WARP_STYLES],
-            default: 'warpArc',
-            description: "Arc/warp shape applied to the editable text. 'none' = flat text fitted to the box (no warp).",
-        },
-        bend: {
-            type: 'number',
-            default: 30,
-            minimum: -100,
-            maximum: 100,
-            description: 'Warp bend amount, roughly -100..100. Positive arcs one way, negative the other.',
-        },
-        fill: {
-            type: 'number',
-            default: 0.9,
-            minimum: 0.1,
-            maximum: 1,
-            description: 'Fraction of the object box WIDTH the text should span (default 0.9).',
-        },
-        font: {
-            type: 'string',
-            description: 'Optional font family ("Arial") or PostScript name ("ArialMT"). Throws clearly if no installed font matches.',
-        },
-        color: {
-            type: 'object',
-            description: 'Optional RGB text color, each component 0–255.',
-            properties: {
-                red: { type: 'integer', minimum: 0, maximum: 255 },
-                green: { type: 'integer', minimum: 0, maximum: 255 },
-                blue: { type: 'integer', minimum: 0, maximum: 255 },
-            },
-            required: ['red', 'green', 'blue'],
-        },
-        object_threshold: {
-            type: 'number',
-            default: 0.4,
-            minimum: 0,
-            maximum: 1,
-            description: 'Minimum detection confidence (0–1).',
-        },
-        max_dimension: {
-            type: 'number',
-            default: 1024,
-            minimum: 256,
-            maximum: 4096,
-            description: 'Long-edge px of the detection export. Coordinates always return in document px.',
-        },
-    },
-    required: ['text', 'label'],
-};
-function pickObject(objects, label) {
-    return objects.filter((o) => o.label === label).sort((a, b) => b.confidence - a.confidence)[0];
-}
-function readBounds(result) {
-    const nb = result?.new_bounds;
-    if (!nb ||
-        typeof nb.left !== 'number' ||
-        typeof nb.right !== 'number' ||
-        typeof nb.top !== 'number' ||
-        typeof nb.bottom !== 'number') {
-        return undefined;
-    }
-    return { left: nb.left, top: nb.top, right: nb.right, bottom: nb.bottom };
-}
-async function runTextOnObject(connection, snippet, client, rawArgs) {
-    try {
-        const args = validateArgs(textOnObjectSchema, rawArgs);
-        const text = args.text;
-        const label = args.label;
-        const warpStyle = args.warp_style ?? 'warpArc';
-        const bend = args.bend ?? 30;
-        const fill = args.fill ?? 0.9;
-        const font = args.font;
-        const color = args.color;
-        const det = await detectActiveDoc(connection, client, {
-            objects: true,
-            maxDimension: args.max_dimension,
-            objectThreshold: args.object_threshold,
-        });
-        const target = pickObject(det.result.objects ?? [], label);
-        if (!target) {
-            const seen = [...new Set((det.result.objects ?? []).map((o) => o.label))].sort();
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `No "${label}" detected. Found: ${seen.length ? seen.join(', ') : '(nothing)'}. Try a different label or lower object_threshold.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        const [l, t, r, b] = target.bbox;
-        const cx = Math.round((l + r) / 2);
-        const cy = Math.round((t + b) / 2);
-        const boxW = r - l;
-        await runScript(connection, await snippet.build('createTextLayer', { text, x: cx, y: cy, fontSize: NOMINAL_FONT_PT }));
-        await runScript(connection, await snippet.build('setTextAlignment', { alignment: 'CENTER' }));
-        if (font) {
-            await runScript(connection, await snippet.build('setTextFont', { fontName: font }));
-        }
-        if (color) {
-            await runScript(connection, await snippet.build('setTextColor', {
-                red: color.red,
-                green: color.green,
-                blue: color.blue,
-            }));
-        }
-        const moved = await runScript(connection, await snippet.build('moveLayer', {
-            deltaX: 0,
-            deltaY: 0,
-            mode: 'center',
-            centerOnX: cx,
-            centerOnY: cy,
-        }));
-        const bounds = readBounds(moved);
-        let scalePercent = null;
-        if (bounds) {
-            const textW = bounds.right - bounds.left;
-            if (textW > 0) {
-                const raw = ((boxW * fill) / textW) * 100;
-                scalePercent = Math.max(SCALE_MIN_PCT, Math.min(SCALE_MAX_PCT, raw));
-                await runScript(connection, await snippet.build('scaleLayer', { scalePercent, centerAnchor: true }));
-            }
-        }
-        if (warpStyle !== 'none') {
-            await runScript(connection, await snippet.build('warpLayer', {
-                style: warpStyle,
-                bend,
-                hDistort: 0,
-                vDistort: 0,
-                orientation: 'horizontal',
-            }));
-        }
-        const warpNote = warpStyle === 'none' ? 'flat' : `warped (${warpStyle}, bend ${bend})`;
-        const summary = `Placed editable text "${text}" ${warpNote} over the "${label}" (confidence ${target.confidence.toFixed(2)}), fitted to ${Math.round(fill * 100)}% of its width.`;
-        return {
-            content: [{ type: 'text', text: summary }],
-            structuredContent: {
-                op: 'text_on_object',
-                label,
-                text,
-                warp_style: warpStyle,
-                bend,
-                fill,
-                box: target.bbox,
-                confidence: target.confidence,
-                scale_percent: scalePercent,
-                image: det.result.image,
-                context: det.context,
-            },
-        };
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: 'text', text: `Error in photoshop_text_on_object: ${msg}` }],
-            isError: true,
-        };
-    }
-}
-export function createTextOnObjectTools(connection, snippetClient, client = new OnnxDetectionClient()) {
-    return [
-        {
-            tool: {
-                name: 'photoshop_text_on_object',
-                description: 'Place editable text on a detected object using LOCAL on-device vision. Detects the object by COCO label (person, dog, car, chair, …), drops a TEXT layer fitted to its bounding box, and arcs it (warp_style, default warpArc; use "none" for flat fitted text). The text stays a fully editable type layer. Adds a layer — never edits the object\'s pixels. Anchors to the bounding box (precise text-on-shape via segmentation is a Pro feature). Pair with photoshop_detect first to see what is detectable.',
-                inputSchema: textOnObjectSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        op: { type: 'string' },
-                        label: { type: 'string' },
-                        text: { type: 'string' },
-                        warp_style: { type: 'string' },
-                        bend: { type: 'number' },
-                        fill: { type: 'number' },
-                        box: { type: 'array', items: { type: 'number' } },
-                        confidence: { type: 'number' },
-                        scale_percent: { type: ['number', 'null'] },
-                        image: { type: 'object' },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Text on Object (detection-driven)',
-                    destructiveHint: false,
-                    openWorldHint: false,
-                },
-            },
-            handler: async (args) => runTextOnObject(connection, snippetClient, client, args),
-        },
-    ];
-}