editmamei 1.8.0 → 1.9.0

package/dist/tools/gimp-effect-tools.js

@@ -8,6 +8,9 @@ const EFFECT_TYPES = [
     'lens_blur',
     'add_noise',
     'drop_shadow',
+    'outline',
+    'outer_glow',
+    'surface_blur',
 ];
 const effectSchema = {
     type: 'object',
@@ -67,8 +70,11 @@ const effectSchema = {
                 '(default 25 when creating) — capped much lower than the other two effects here (measured ' +
                 'live: expensive at full resolution). drop_shadow: blur radius in pixels at full ' +
                 'resolution, 0..1500 (default 10 when creating), clipped to the layer bounds rather than ' +
-                'growing it. Both lens_blur and drop_shadow are SPATIAL (radius-scaled on the proxy ' +
-                'preview, see gimp_overview). The bridge enforces the precise range for whichever ' +
+                'growing it. outer_glow: glow blur in pixels, 1..250 (default 20 when creating). ' +
+                'surface_blur: smoothing radius in pixels, 1..6 (default 4 when creating) — capped low ' +
+                'because its cost grows with the square of the radius (a 24 MP export takes ~17 s at 6). ' +
+                'lens_blur, drop_shadow, outer_glow and surface_blur are SPATIAL (radius-scaled on the ' +
+                'proxy preview, see gimp_overview). The bridge enforces the precise range for whichever ' +
                 '`type` you gave.',
         },
         softness: {
@@ -189,8 +195,38 @@ const effectSchema = {
             type: 'number',
             minimum: 0,
             maximum: 1,
-            description: 'drop_shadow only. Default (when creating): 0.5. The shadow color is black and not ' +
-                'configurable yet.',
+            description: 'drop_shadow: default (when creating) 0.5. The shadow color is black and not ' +
+                'configurable yet. outer_glow: default 0.75 (its color is the `color` field).',
+        },
+        width: {
+            type: 'number',
+            minimum: 1,
+            maximum: 50,
+            description: 'outline only. Stroke thickness in pixels at full resolution, 1..50. Default (when ' +
+                "creating): 4. SPATIAL. The stroke grows outward from the layer's alpha edge (round " +
+                "corners) and the layer's own pixels are untouched.",
+        },
+        spread: {
+            type: 'number',
+            minimum: 0,
+            maximum: 50,
+            description: "outer_glow only. Pixels the glow's solid core grows past the alpha edge before it " +
+                'blurs, 0..50. Default (when creating): 4. SPATIAL.',
+        },
+        color: {
+            type: 'string',
+            pattern: '^#[0-9a-fA-F]{6}$',
+            description: 'outline and outer_glow only. "#rrggbb" hex. Default (when creating): "#000000" for ' +
+                'outline, "#ffffff" for outer_glow.',
+        },
+        edge_preservation: {
+            type: 'number',
+            minimum: 0,
+            maximum: 1,
+            description: 'surface_blur only. How much edge contrast survives, 0..1: LOWER smooths harder (near 0 ' +
+                'starts to soften the edges too), HIGHER leaves more detail and noise. Default (when ' +
+                'creating): 0.08, which flattens fine noise and skin texture while keeping hard edges ' +
+                'sharp.',
         },
     },
     required: ['image', 'type'],
@@ -222,7 +258,7 @@ export function createGimpEffectTools(gimp) {
                 name: 'gimp_add_effect',
                 description: 'Headless GIMP: append (or, with filter_id, re-edit in place) one of a small ' +
                     'allow-listed set of GEGL effect filters — vignette, black_white, motion_blur, ' +
-                    'lens_blur, add_noise, drop_shadow — the same non-destructive, re-editable, maskable ' +
+                    'lens_blur, add_noise, drop_shadow, outline, outer_glow, surface_blur — the same non-destructive, re-editable, maskable ' +
                     "filter mechanism gimp_add_adjustment uses, sharing the SAME stack: gimp_filter's " +
                     "op=list/set_visibility/delete manage this tool's filters exactly as it manages " +
                     "gimp_add_adjustment's. `type` picks the effect; a field another effect uses is " +
@@ -237,9 +273,19 @@ export function createGimpEffectTools(gimp) {
                     'created by Editmamei. vignette, motion_blur, and drop_shadow stay locked to the ' +
                     'content through flip, resize, and an exact 90/180/270-degree rotate (their center/' +
                     'angle/offset fields are updated automatically, and gimp_filter op=list reflects the ' +
-                    'new values afterward) — rotating by any OTHER angle is refused while one of these ' +
-                    'three is present, rather than letting it drift out of alignment. lens_blur is a ' +
-                    'uniform soft-focus blur, not a depth-of-field falloff. For a plain blur with no bokeh ' +
+                    'new values afterward) — rotating by any OTHER angle is refused while a vignette, a ' +
+                    'motion_blur, or a drop_shadow with a non-zero offset is present, rather than letting ' +
+                    'it drift out of alignment. outline, outer_glow, surface_blur, lens_blur and a ' +
+                    'zero-offset drop_shadow have no direction, so they survive any rotation. Resizing ' +
+                    'scales their pixel sizes with the image (never below the 1 px minimum of outline ' +
+                    'width, outer_glow radius and surface_blur radius). lens_blur is a ' +
+                    'uniform soft-focus blur, not a depth-of-field falloff. outline puts a solid stroke ' +
+                    "around a layer's transparent edge (meme text, sticker cut-outs); outer_glow adds a " +
+                    'soft glow around it (glowing text); surface_blur smooths skin and other texture ' +
+                    'while keeping hard edges. outline and outer_glow need a layer with transparency, ' +
+                    'and attach to a text layer without rasterizing it: the text stays editable and the ' +
+                    'effect follows each edit. For a plain ' +
+                    'blur with no bokeh ' +
                     'highlight boost, use gimp_add_adjustment type=gaussian_blur instead. Check the stack ' +
                     'afterward with gimp_filter (op=list).',
                 inputSchema: effectSchema,

package/dist/tools/gimp-fill-tools.js

@@ -0,0 +1,256 @@
+import { GimpError } from '../backends/gimp/errors.js';
+import { GIMP_IMAGE_PROP, GIMP_LAYER_ID_PROP, GIMP_LAYER_PROP, pickSchemaDeclaredKeys, runGimpTool, } from './gimp-shared.js';
+export const FILL_MIN_STOPS = 2;
+export const FILL_MAX_STOPS = 8;
+const OPS = ['solid', 'linear_gradient', 'radial_gradient'];
+export const FILL_MODE_NAMES = [
+    'normal',
+    'multiply',
+    'screen',
+    'overlay',
+    'soft_light',
+    'hard_light',
+    'darken',
+    'lighten',
+    'difference',
+    'exclusion',
+    'addition',
+    'subtract',
+    'divide',
+    'dodge',
+    'burn',
+    'hue',
+    'saturation',
+    'color',
+    'luminosity',
+    'grain_extract',
+    'grain_merge',
+    'lch_color',
+];
+export const FILL_MAX_COORD_PX = 300_000;
+export const FILL_MAX_STRING_LEN = 255;
+const MIN_AXIS_PX = 1;
+const HEX = /^#[0-9a-fA-F]{6}$/;
+const POINT_PROP = {
+    type: 'object',
+    properties: {
+        x: { type: 'number', minimum: -FILL_MAX_COORD_PX, maximum: FILL_MAX_COORD_PX },
+        y: { type: 'number', minimum: -FILL_MAX_COORD_PX, maximum: FILL_MAX_COORD_PX },
+    },
+    required: ['x', 'y'],
+};
+const fillSchema = {
+    type: 'object',
+    properties: {
+        image: GIMP_IMAGE_PROP,
+        op: {
+            type: 'string',
+            enum: OPS,
+            description: "'solid': one flat color. 'linear_gradient': a ramp from start to end. " +
+                "'radial_gradient': a ramp from a center out to a radius.",
+        },
+        layer: {
+            ...GIMP_LAYER_PROP,
+            description: 'Name of the layer the new fill layer goes directly above (inside its group). Defaults ' +
+                'to the selected layer, or the topmost layer if none is selected.',
+        },
+        layer_id: GIMP_LAYER_ID_PROP,
+        name: {
+            type: 'string',
+            description: "New layer's name. Default 'Fill' for solid, 'Gradient' for a gradient.",
+        },
+        color: {
+            type: 'string',
+            pattern: '^#[0-9a-fA-F]{6}$',
+            description: 'solid only: the color as #rrggbb.',
+        },
+        stops: {
+            type: 'array',
+            minItems: FILL_MIN_STOPS,
+            maxItems: FILL_MAX_STOPS,
+            items: {
+                type: 'object',
+                properties: {
+                    offset: { type: 'number', minimum: 0, maximum: 1 },
+                    color: { type: 'string', pattern: '^#[0-9a-fA-F]{6}$' },
+                    opacity: { type: 'number', minimum: 0, maximum: 100, default: 100 },
+                },
+                required: ['offset', 'color'],
+            },
+            description: 'Gradient only: 2-8 color stops {offset 0..1, color #rrggbb, opacity 0..100}, sorted by ' +
+                'offset. Colors blend in sRGB (a black to white stop pair reads 128 at the midpoint). ' +
+                'Before the first stop and after the last, the end colors hold.',
+        },
+        start: {
+            ...POINT_PROP,
+            description: 'linear_gradient: where offset 0 sits, in image pixels. Default top center of the canvas.',
+        },
+        end: {
+            ...POINT_PROP,
+            description: 'linear_gradient: where offset 1 sits, in image pixels. Default bottom center of the canvas.',
+        },
+        center: {
+            ...POINT_PROP,
+            description: 'radial_gradient: where offset 0 sits, in image pixels. Default canvas center.',
+        },
+        radius: {
+            type: 'number',
+            minimum: 1,
+            maximum: FILL_MAX_COORD_PX,
+            description: 'radial_gradient: the distance in pixels at which offset 1 is reached. Default half the ' +
+                'canvas diagonal.',
+        },
+        mode: {
+            type: 'string',
+            enum: FILL_MODE_NAMES,
+            default: 'normal',
+            description: "The new layer's blend mode: gimp_layer's list plus 'lch_color'. 'color' is HSL Color; " +
+                "'lch_color' (LCh Color) keeps the lightness underneath exactly and swaps only hue and " +
+                'chroma, the better choice for recoloring.',
+        },
+        opacity: {
+            type: 'number',
+            minimum: 0,
+            maximum: 100,
+            default: 100,
+            description: "The new layer's opacity, 0-100.",
+        },
+        mask: {
+            type: 'string',
+            description: "The name of a selection channel: becomes the new layer's layer mask, white " +
+                'where the channel is selected, so the fill shows only there.',
+        },
+    },
+    required: ['image', 'op'],
+};
+const bad = (message) => {
+    throw new GimpError('invalid_argument', message);
+};
+function isNum(v) {
+    return typeof v === 'number' && Number.isFinite(v);
+}
+function checkPoint(name, v) {
+    const o = v;
+    if (!o || typeof o !== 'object' || !isNum(o['x']) || !isNum(o['y'])) {
+        return bad(`${name} must be {x, y} with finite numbers`);
+    }
+    if (Math.abs(o['x']) > FILL_MAX_COORD_PX || Math.abs(o['y']) > FILL_MAX_COORD_PX) {
+        bad(`${name} must be within +/-${FILL_MAX_COORD_PX} px`);
+    }
+    return { x: o['x'], y: o['y'] };
+}
+export function validateFillArgs(args) {
+    const op = args['op'];
+    for (const k of ['name', 'mask']) {
+        const v = args[k];
+        if (typeof v === 'string' && v.length > FILL_MAX_STRING_LEN) {
+            bad(`${k} must be at most ${FILL_MAX_STRING_LEN} characters`);
+        }
+    }
+    const only = (keys, why) => {
+        for (const k of keys)
+            if (args[k] !== undefined)
+                bad(`${k} does not apply to ${why}`);
+    };
+    if (op === 'solid') {
+        if (typeof args['color'] !== 'string' || !HEX.test(args['color'])) {
+            bad('color must be a color like #rrggbb for op solid');
+        }
+        only(['stops', 'start', 'end', 'center', 'radius'], 'op solid');
+        return;
+    }
+    only(['color'], 'a gradient (give stops)');
+    const stops = args['stops'];
+    if (!Array.isArray(stops) || stops.length < FILL_MIN_STOPS || stops.length > FILL_MAX_STOPS) {
+        bad(`stops must be a list of ${FILL_MIN_STOPS}..${FILL_MAX_STOPS} stops for op ${String(op)}`);
+    }
+    let previous = -1;
+    stops.forEach((s, i) => {
+        const o = s;
+        if (!o || typeof o !== 'object' || !isNum(o['offset']) || typeof o['color'] !== 'string') {
+            return bad(`stops[${i}] must be {offset, color, opacity?}`);
+        }
+        if (!HEX.test(o['color']))
+            bad(`stops[${i}].color must be a color like #rrggbb`);
+        if (o['offset'] < 0 || o['offset'] > 1)
+            bad(`stops[${i}].offset must be within 0..1`);
+        const opacity = o['opacity'];
+        if (opacity !== undefined && (!isNum(opacity) || opacity < 0 || opacity > 100)) {
+            bad(`stops[${i}].opacity must be within 0..100`);
+        }
+        if (o['offset'] < previous)
+            bad(`stops must be sorted by offset: stops[${i}] is out of order`);
+        previous = o['offset'];
+    });
+    if (op === 'linear_gradient') {
+        only(['center', 'radius'], 'op linear_gradient');
+        const start = args['start'] === undefined ? undefined : checkPoint('start', args['start']);
+        const end = args['end'] === undefined ? undefined : checkPoint('end', args['end']);
+        if (start && end && Math.hypot(end.x - start.x, end.y - start.y) < MIN_AXIS_PX) {
+            bad(`start and end must be at least ${MIN_AXIS_PX} pixel apart`);
+        }
+    }
+    else {
+        only(['start', 'end'], 'op radial_gradient');
+        if (args['center'] !== undefined)
+            checkPoint('center', args['center']);
+        const radius = args['radius'];
+        if (radius !== undefined && (!isNum(radius) || radius < 1 || radius > FILL_MAX_COORD_PX)) {
+            bad(`radius must be within 1..${FILL_MAX_COORD_PX} pixels`);
+        }
+    }
+}
+export function createGimpFillTools(gimp) {
+    return [
+        {
+            tool: {
+                name: 'gimp_fill',
+                description: 'Headless GIMP: add a NEW layer, canvas-sized, filled with a solid color (op solid), a ' +
+                    'linear gradient (start to end) or a radial gradient (center and radius) through 2-8 ' +
+                    'color stops. The layer goes directly above the target layer (inside its group), with ' +
+                    'the blend mode and opacity you give; mode lch_color tints without touching lightness, ' +
+                    'the usual choice for recoloring. Pass mask (a channel name) to confine the fill to ' +
+                    'that channel: it becomes the layer mask. Gradients blend in sRGB, are not dithered, ' +
+                    'and use image pixels for every point. The current selection is kept and does not clip ' +
+                    'the fill. Do NOT use for painting strokes or touching up pixels; use gimp_retouch ' +
+                    'for that. Returns layer_id, layer_name, op, mode, opacity and masked.',
+                inputSchema: fillSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        layer_id: { type: 'number' },
+                        layer_name: { type: 'string' },
+                        op: { type: 'string' },
+                        mode: { type: 'string' },
+                        opacity: { type: 'number' },
+                        masked: { type: 'boolean' },
+                    },
+                },
+                annotations: {
+                    title: 'Fill GIMP Layer',
+                    readOnlyHint: false,
+                    destructiveHint: false,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => runGimpTool({
+                gimp,
+                rawArgs: args,
+                schema: fillSchema,
+                op: 'fill',
+                errorPrefix: 'Error filling GIMP layer',
+                params: (validated) => {
+                    validateFillArgs(validated);
+                    return pickSchemaDeclaredKeys(fillSchema, validated);
+                },
+                successText: (result) => {
+                    const r = result;
+                    return (`Fill: ${r.op.replace('_', ' ')} on new layer "${r.layer_name}" (layer ${r.layer_id}), ` +
+                        `${r.mode} at ${r.opacity}%${r.masked ? ', masked' : ''}.`);
+                },
+            }),
+        },
+    ];
+}
+export const FILL_SCHEMA_FOR_TESTS = fillSchema;

package/dist/tools/gimp-filter-tools.js

@@ -1,6 +1,7 @@
 import { validateArgs } from '../utils/validate.js';
 import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
 import { GIMP_IMAGE_PROP, pickSchemaDeclaredKeys } from './gimp-shared.js';
+import { capLines, filterLine } from './gimp-result-text.js';
 const filterSchema = {
     type: 'object',
     properties: {
@@ -41,7 +42,9 @@ async function gimpFilter(gimp, rawArgs) {
         let text;
         if (op === 'list') {
             const filters = result.filters ?? [];
-            text = `${filters.length} filter(s) on image ${args.image}.`;
+            text = `${filters.length} filter(s) on image ${args.image}, top of stack first.`;
+            if (filters.length > 0)
+                text += '\n' + capLines(filters.map(filterLine)).join('\n');
         }
         else if (op === 'set_visibility') {
             text = `Filter ${result.filter_id} visibility set to ${result.visible}.`;

package/dist/tools/gimp-inspect-tools.js

@@ -1,6 +1,7 @@
 import { validateArgs } from '../utils/validate.js';
 import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
 import { pickSchemaDeclaredKeys } from './gimp-shared.js';
+import { capLines, channelsText, filterLine, layerTreeLines } from './gimp-result-text.js';
 const INSPECT_WHATS = ['documents', 'document', 'layers', 'channels', 'filter', 'fonts'];
 const inspectSchema = {
     type: 'object',
@@ -42,28 +43,35 @@ const inspectSchema = {
     },
     required: ['what'],
 };
+function withLayerTree(summary, layers) {
+    const lines = capLines(layerTreeLines(layers));
+    return lines.length > 0 ? `${summary}\n${lines.join('\n')}` : summary;
+}
 function describeSummary(what, args, result) {
     const truncatedSuffix = result.truncated ? ' (truncated at the node cap)' : '';
     if (what === 'filter') {
-        return `Filter ${result.filter_id} ("${result.name}"): ${result.operation}.`;
+        return filterLine(result);
     }
     if (what === 'layers') {
         const layers = result.layers ?? [];
         const topLevelCount = result.top_level_count ?? layers.length;
-        return `${topLevelCount} top-level layer(s) on image ${args.image}${truncatedSuffix}.`;
+        return withLayerTree(`${topLevelCount} top-level layer(s) on image ${args.image}${truncatedSuffix}, top of stack first.`, layers);
     }
     if (what === 'channels') {
         const channels = result.channels ?? [];
         const skipped = result.channels_skipped;
         const stoppedEarlySuffix = result.truncated && skipped ? ` (stopped early, ${skipped} channel(s) skipped)` : '';
-        return `${channels.length} channel(s) on image ${args.image}${stoppedEarlySuffix}.`;
+        return (`${channels.length} channel(s) on image ${args.image}${stoppedEarlySuffix}` +
+            (channels.length > 0 ? `: ${channelsText(channels)}.` : '.'));
     }
     const layers = result.layers ?? [];
     const channels = result.channels ?? [];
     const topLevelCount = result.top_level_count ?? layers.length;
-    return (`Document ${result.image}: ${result.width}x${result.height} ${result.base_type} ` +
+    return withLayerTree(`Document ${result.image}: ${result.width}x${result.height} ${result.base_type} ` +
         `${result.precision}, ${topLevelCount} top-level layer(s)${truncatedSuffix}, ` +
-        `${channels.length} channel(s).`);
+        `${channels.length} channel(s)` +
+        (channels.length > 0 ? `: ${channelsText(channels)}.` : '.') +
+        (layers.length > 0 ? ' Layers, top of stack first:' : ''), layers);
 }
 async function gimpInspect(gimp, rawArgs) {
     try {

package/dist/tools/gimp-layer-tools.js

@@ -128,6 +128,8 @@ const layerSchema = {
                 'saturation',
                 'color',
                 'luminosity',
+                'grain_extract',
+                'grain_merge',
             ],
             description: 'set only. A fixed blend-mode list, not a raw GEGL/GIMP mode name.',
         },

package/dist/tools/gimp-result-text.js

@@ -0,0 +1,104 @@
+export const MAX_LISTED_LINES = 60;
+export const MAX_PARAMS_CHARS = 240;
+export const MAX_NAME_CHARS = 120;
+export const MAX_LISTED_CHANNELS = 30;
+export function quoted(name) {
+    const s = String(name ?? '');
+    return JSON.stringify(s.length > MAX_NAME_CHARS ? `${s.slice(0, MAX_NAME_CHARS)}...` : s);
+}
+function token(s) {
+    return /^[\w.:#+-]+$/.test(s) ? s : quoted(s);
+}
+function valueText(v) {
+    if (typeof v === 'number')
+        return String(Number.isInteger(v) ? v : Number(v.toFixed(3)));
+    if (typeof v === 'string')
+        return token(v);
+    if (typeof v === 'boolean')
+        return String(v);
+    return JSON.stringify(v);
+}
+export function paramsText(params, cap = MAX_PARAMS_CHARS) {
+    if (!params || typeof params !== 'object')
+        return '';
+    const text = Object.entries(params)
+        .filter(([k, v]) => v !== null && v !== undefined && k !== 'mask')
+        .map(([k, v]) => `${token(k)}=${valueText(v)}`)
+        .join(' ');
+    return text.length > cap ? `${text.slice(0, cap)}...` : text;
+}
+export function capLines(lines, max = MAX_LISTED_LINES) {
+    if (lines.length <= max)
+        return lines;
+    return [...lines.slice(0, max), `...and ${lines.length - max} more`];
+}
+export function filterLine(f) {
+    const kind = token(typeof f.type === 'string' && f.type ? f.type : String(f.operation ?? ''));
+    const hidden = f.visible === false ? ', hidden' : '';
+    const mask = f.mask ? `, mask ${quoted(f.mask)}` : '';
+    const source = String(f.source ?? 'unknown');
+    const sourceText = source === 'readback' ? 'readback (GEGL names and units)' : token(source);
+    const params = paramsText(f.params);
+    return (`#${String(f.filter_id)} ${quoted(f.name)} ${kind} on layer ${quoted(f.layer)} ` +
+        `(id ${String(f.layer_id)})${hidden}${mask}, ${sourceText}` +
+        (params ? `: ${params}` : ''));
+}
+function layerFlags(n) {
+    const flags = [];
+    if (n.is_group)
+        flags.push('group');
+    if (n.is_text_layer)
+        flags.push('text');
+    if (n.visible === false)
+        flags.push('hidden');
+    if (typeof n.opacity === 'number' && n.opacity < 100)
+        flags.push(`opacity ${valueText(n.opacity)}`);
+    if (typeof n.mode === 'string' && !n.mode.startsWith('normal'))
+        flags.push(`mode ${token(n.mode)}`);
+    return flags.length ? `, ${flags.join(', ')}` : '';
+}
+export function layerTreeLines(nodes) {
+    const lines = [];
+    const stack = [];
+    const push = (list, depth) => {
+        if (!Array.isArray(list))
+            return;
+        for (let i = list.length - 1; i >= 0; i--)
+            stack.push({ node: list[i], depth });
+    };
+    push(nodes, 0);
+    while (stack.length > 0) {
+        const { node, depth } = stack.pop();
+        lines.push(`${'  '.repeat(depth)}- ${quoted(node.name)} (id ${String(node.layer_id)}${layerFlags(node)})`);
+        push(node.children, depth + 1);
+    }
+    return lines;
+}
+export function channelsText(channels) {
+    if (!Array.isArray(channels) || channels.length === 0)
+        return '(none)';
+    const named = channels
+        .slice(0, MAX_LISTED_CHANNELS)
+        .map((c) => typeof c.fraction === 'number'
+        ? `${quoted(c.name)} (${(c.fraction * 100).toFixed(1)}% selected)`
+        : quoted(c.name))
+        .join(', ');
+    const rest = channels.length - MAX_LISTED_CHANNELS;
+    return rest > 0 ? `${named}, ...and ${rest} more` : named;
+}
+function statsText(s) {
+    if (!s)
+        return 'n/a';
+    return (`mean=${valueText(s.mean)} median=${valueText(s.median)} ` +
+        `p5=${valueText(s.p5)} p95=${valueText(s.p95)}`);
+}
+export function regionStatsLines(a, b) {
+    const channels = Object.keys(a ?? {});
+    return channels.map((ch) => {
+        const sa = a?.[ch];
+        const sb = b?.[ch];
+        const delta = typeof sa?.mean === 'number' && typeof sb?.mean === 'number' ? sb.mean - sa.mean : undefined;
+        const deltaText = delta === undefined ? '' : `; B-A mean ${delta >= 0 ? '+' : ''}${valueText(delta)}`;
+        return `${ch}: A ${statsText(sa)} | B ${statsText(sb)}${deltaText}`;
+    });
+}