@pixerate/editor 0.246.0 → 0.248.0

package/dist/image-editor/index.js

@@ -8,7 +8,7 @@ import {
   parseOpenTypeFont,
   removeAnchorsKeepingShape,
   traceField
-} from "../chunk-DQWPMGH2.js";
+} from "../chunk-5GLYUSNT.js";
 import {
   ColorGmm,
   GAMMA,
@@ -153,6 +153,8 @@ import {
   copySmartObject,
   cornersFromMatrix,
   createAdjustmentLayer,
+  createImageEffectTools,
+  createLayerEffectTools,
   createShapeLayer,
   createTypeLayer,
   curveLutFromLevels,
@@ -167,6 +169,7 @@ import {
   defaultShapeName,
   depthMaskAlpha,
   depthRasterMask,
+  describeLayerEffects,
   describeTransform,
   deserializeEffects,
   deserializeLayer,
@@ -410,7 +413,7 @@ import {
   writePsd,
   xyToTempTint,
   xyToUv
-} from "../chunk-4PMCMWQS.js";
+} from "../chunk-ZFSLEOSQ.js";
 import {
   parseCssColor
 } from "../chunk-3CI7FRMK.js";
@@ -465,6 +468,13 @@ import {
 import {
   createCaptureTool
 } from "../chunk-5ED73EC6.js";
+import {
+  LAYER_EFFECT_MENU,
+  effectControlChange,
+  layerEffectControls,
+  layerEffectsBadge,
+  layerEffectsPanel
+} from "../chunk-SC2RZ5EF.js";
 import {
   DEFAULT_GLOBAL_LIGHT,
   INTERPOLATIONS,
@@ -733,8 +743,8 @@ import {
   warpMeshParamAt,
   warpMeshRows,
   warpPresetMesh
-} from "../chunk-N6WUB3Y5.js";
-import "../chunk-VDAWA546.js";
+} from "../chunk-Q2HA52V4.js";
+import "../chunk-VNBUDVD4.js";
 import "../chunk-M6DNZNVY.js";
 import {
   bezierPathToSvg,
@@ -1686,13 +1696,13 @@ var ImageEditorRenderer = class {
       ctx.save();
       try {
         applyImageProjectionToContext(ctx, projection);
-        const px2 = u / (projection.scale || 1);
+        const px = u / (projection.scale || 1);
         ctx.beginPath();
-        ctx.arc(b.x, b.y, Math.max(px2, b.diameter / 2), 0, Math.PI * 2);
-        ctx.lineWidth = 2 * px2;
+        ctx.arc(b.x, b.y, Math.max(px, b.diameter / 2), 0, Math.PI * 2);
+        ctx.lineWidth = 2 * px;
         ctx.strokeStyle = "rgba(0,0,0,0.6)";
         ctx.stroke();
-        ctx.lineWidth = px2;
+        ctx.lineWidth = px;
         ctx.strokeStyle = "#ffffff";
         ctx.stroke();
       } catch {
@@ -2239,32 +2249,32 @@ var ImageEditorRenderer = class {
       this.outlineCache.set(selection, paths);
     }
     if (!paths.length) return;
-    const px2 = 1 / (scale || 1);
+    const px = 1 / (scale || 1);
     ctx.beginPath();
     for (const p of paths) {
       ctx.moveTo(p[0], p[1]);
       for (let i = 2; i < p.length; i += 2) ctx.lineTo(p[i], p[i + 1]);
     }
-    ctx.lineWidth = px2;
+    ctx.lineWidth = px;
     ctx.strokeStyle = "#ffffff";
     ctx.stroke();
     if (typeof ctx.setLineDash === "function") {
-      ctx.setLineDash([4 * px2, 4 * px2]);
-      ctx.lineDashOffset = -offset * px2;
+      ctx.setLineDash([4 * px, 4 * px]);
+      ctx.lineDashOffset = -offset * px;
     }
     ctx.strokeStyle = "#000000";
     ctx.stroke();
     if (typeof ctx.setLineDash === "function") ctx.setLineDash([]);
   }
   drawDraftPath(ctx, points, scale) {
-    const px2 = 1 / (scale || 1);
+    const px = 1 / (scale || 1);
     ctx.beginPath();
     points.forEach((p, i) => i === 0 ? ctx.moveTo(p.x, p.y) : ctx.lineTo(p.x, p.y));
     ctx.closePath();
-    ctx.lineWidth = px2;
+    ctx.lineWidth = px;
     ctx.strokeStyle = "#ffffff";
     ctx.stroke();
-    if (typeof ctx.setLineDash === "function") ctx.setLineDash([4 * px2, 4 * px2]);
+    if (typeof ctx.setLineDash === "function") ctx.setLineDash([4 * px, 4 * px]);
     ctx.strokeStyle = "#000000";
     ctx.stroke();
     if (typeof ctx.setLineDash === "function") ctx.setLineDash([]);
@@ -2929,9 +2939,9 @@ function inspectMaskEdge(mask, image, options = {}) {
     turnExcess += Math.max(0, total - closure);
     outline += L;
     for (let i = 0; i < n; i++) {
-      const [px2, py] = pts[i];
-      if (px2 < 0 || py < 0 || px2 >= W || py >= H) continue;
-      const blk = block(Math.floor(px2), Math.floor(py));
+      const [px, py] = pts[i];
+      if (px < 0 || py < 0 || px >= W || py >= H) continue;
+      const blk = block(Math.floor(px), Math.floor(py));
       blk.turn += Math.abs(turns[i]) - closure / n;
       blk.len += 2;
     }
@@ -4118,10 +4128,10 @@ function liveWire(map, from, to, band) {
   const uy = (by - ay) / len;
   for (let y = 0; y < h; y++) {
     for (let x = 0; x < w; x++) {
-      const px2 = rx0 + x - ax;
+      const px = rx0 + x - ax;
       const py = ry0 + y - ay;
-      const t = Math.min(len, Math.max(0, px2 * ux + py * uy));
-      if (Math.hypot(px2 - t * ux, py - t * uy) > half) continue;
+      const t = Math.min(len, Math.max(0, px * ux + py * uy));
+      if (Math.hypot(px - t * ux, py - t * uy) > half) continue;
       const i = y * w + x;
       inside[i] = 1;
       const f = map.features(rx0 + x, ry0 + y);
@@ -5015,43 +5025,43 @@ function liftPixels(surface, sel, o) {
   const area = { x: sb.x - o.x, y: sb.y - o.y, width: sb.width, height: sb.height };
   const depth = surfaceDepth(surface);
   if (depth !== 8) {
-    const px3 = readDeepRegion(surface, area, depth);
-    const kept2 = px3.slice();
+    const px2 = readDeepRegion(surface, area, depth);
+    const kept2 = px2.slice();
     const r16 = depth === 16;
     for (let y = 0; y < area.height; y++) {
       for (let x = 0; x < area.width; x++) {
         const k = sel.data[(sb.y + y) * sel.width + sb.x + x] / 255;
         const i = (y * area.width + x) * 4;
         if (k <= 0) {
-          px3[i] = px3[i + 1] = px3[i + 2] = px3[i + 3] = 0;
+          px2[i] = px2[i + 1] = px2[i + 2] = px2[i + 3] = 0;
           continue;
         }
-        px3[i + 3] = r16 ? Math.round(px3[i + 3] * k) : px3[i + 3] * k;
-        if (!px3[i + 3]) px3[i] = px3[i + 1] = px3[i + 2] = 0;
+        px2[i + 3] = r16 ? Math.round(px2[i + 3] * k) : px2[i + 3] * k;
+        if (!px2[i + 3]) px2[i] = px2[i + 1] = px2[i + 2] = 0;
         kept2[i + 3] = r16 ? Math.round(kept2[i + 3] * (1 - k)) : kept2[i + 3] * (1 - k);
         if (!kept2[i + 3]) kept2[i] = kept2[i + 1] = kept2[i + 2] = 0;
       }
     }
-    const lifted = writeDeepRegion(new TiledSurface(4, /* @__PURE__ */ new Map(), 0), area, px3);
+    const lifted = writeDeepRegion(new TiledSurface(4, /* @__PURE__ */ new Map(), 0), area, px2);
     return { lifted, rest: writeDeepRegion(surface, area, kept2) };
   }
-  const px2 = readRegion(surface, area);
-  const kept = new Uint8ClampedArray(px2);
+  const px = readRegion(surface, area);
+  const kept = new Uint8ClampedArray(px);
   for (let y = 0; y < area.height; y++) {
     for (let x = 0; x < area.width; x++) {
       const k = sel.data[(sb.y + y) * sel.width + sb.x + x] / 255;
       const i = (y * area.width + x) * 4;
       if (k <= 0) {
-        px2[i] = px2[i + 1] = px2[i + 2] = px2[i + 3] = 0;
+        px[i] = px[i + 1] = px[i + 2] = px[i + 3] = 0;
         continue;
       }
-      px2[i + 3] = px2[i + 3] * k;
-      if (!px2[i + 3]) px2[i] = px2[i + 1] = px2[i + 2] = 0;
+      px[i + 3] = px[i + 3] * k;
+      if (!px[i + 3]) px[i] = px[i + 1] = px[i + 2] = 0;
       kept[i + 3] = kept[i + 3] * (1 - k);
       if (!kept[i + 3]) kept[i] = kept[i + 1] = kept[i + 2] = 0;
     }
   }
-  return { lifted: surfaceFromPixels({ width: area.width, height: area.height, data: px2 }, 4, area.x, area.y), rest: writeRegion(surface, area, kept) };
+  return { lifted: surfaceFromPixels({ width: area.width, height: area.height, data: px }, 4, area.x, area.y), rest: writeRegion(surface, area, kept) };
 }
 function liftMask(mask, sel, o) {
   const sb = sel.bounds;
@@ -5642,14 +5652,14 @@ function displayTransform(doc, proof) {
   const g = gamut;
   return (rgba) => {
     if (g) {
-      const px2 = [0, 0, 0];
+      const px = [0, 0, 0];
       const flags = new Uint8Array(rgba.length >> 2);
       for (let i = 0, p = 0; i < rgba.length; i += 4, p++) {
         if (rgba[i + 3] === 0) continue;
-        px2[0] = rgba[i] / 255;
-        px2[1] = rgba[i + 1] / 255;
-        px2[2] = rgba[i + 2] / 255;
-        if (g.outOfGamut(px2)) flags[p] = 1;
+        px[0] = rgba[i] / 255;
+        px[1] = rgba[i + 1] / 255;
+        px[2] = rgba[i + 2] / 255;
+        if (g.outOfGamut(px)) flags[p] = 1;
       }
       tr.convert8(rgba, 4, rgba, 4);
       for (let i = 0, p = 0; i < rgba.length; i += 4, p++) if (flags[p]) rgba[i] = rgba[i + 1] = rgba[i + 2] = 128;
@@ -6453,12 +6463,12 @@ var ImageEditorController = class {
     } else {
       const sb = sel.bounds;
       const src = { x: sb.x - layer.offset.x, y: sb.y - layer.offset.y, width: sb.width, height: sb.height };
-      const px2 = readRegion(surface, src);
+      const px = readRegion(surface, src);
       const data = sel.data;
       for (let y = 0; y < sb.height; y++) {
-        for (let x = 0; x < sb.width; x++) px2[(y * sb.width + x) * 4 + 3] = Math.round(px2[(y * sb.width + x) * 4 + 3] * (data[(sb.y + y) * width + sb.x + x] / 255));
+        for (let x = 0; x < sb.width; x++) px[(y * sb.width + x) * 4 + 3] = Math.round(px[(y * sb.width + x) * 4 + 3] * (data[(sb.y + y) * width + sb.x + x] / 255));
       }
-      copy = { ...layer, id: newLayerId(), surface: surfaceFromPixels({ width: src.width, height: src.height, data: px2 }, 4, src.x, src.y) };
+      copy = { ...layer, id: newLayerId(), surface: surfaceFromPixels({ width: src.width, height: src.height, data: px }, 4, src.x, src.y) };
       delete copy.mask;
     }
     delete copy.source;
@@ -7109,9 +7119,9 @@ var ImageEditorController = class {
         const bounds = this.getLayerBounds(layer.id);
         if (bounds && point2.x >= bounds.x && point2.x <= bounds.x + bounds.width && point2.y >= bounds.y && point2.y <= bounds.y + bounds.height) {
           const surface = this.surfaceOf(layer);
-          const px2 = Math.floor(point2.x - layer.offset.x);
+          const px = Math.floor(point2.x - layer.offset.x);
           const py = Math.floor(point2.y - layer.offset.y);
-          const pixel = readPixel(surface, px2, py);
+          const pixel = readPixel(surface, px, py);
           if (pixel.length >= 4 && pixel[3] >= alphaThreshold) return layer.id;
         }
         return null;
@@ -7123,9 +7133,9 @@ var ImageEditorController = class {
           return null;
         }
         const surface = this.surfaceOf(layer);
-        const px2 = Math.floor(point2.x - layer.offset.x);
+        const px = Math.floor(point2.x - layer.offset.x);
         const py = Math.floor(point2.y - layer.offset.y);
-        const pixel = readPixel(surface, px2, py);
+        const pixel = readPixel(surface, px, py);
         if (pixel.length >= 4 && pixel[3] >= alphaThreshold) {
           return layer.id;
         }
@@ -7276,17 +7286,17 @@ var ImageEditorController = class {
    */
   sourceSurface() {
     const { width, height } = this.naturalSize;
-    const fromPixels = (px3) => {
-      let s = this.sourceSurfaces.get(px3);
+    const fromPixels = (px2) => {
+      let s = this.sourceSurfaces.get(px2);
       if (!s) {
-        s = surfaceFromPixels(px3, 4);
-        this.sourceSurfaces.set(px3, s);
+        s = surfaceFromPixels(px2, 4);
+        this.sourceSurfaces.set(px2, s);
       }
       return s;
     };
-    const px2 = this.samplePixels;
-    const fits = Boolean(px2 && px2.width === width && px2.height === height);
-    if (this.samplePixelsOverride && fits) return fromPixels(px2);
+    const px = this.samplePixels;
+    const fits = Boolean(px && px.width === width && px.height === height);
+    if (this.samplePixelsOverride && fits) return fromPixels(px);
     const el = this.imageElement;
     if (el) {
       const cached = this.sourceSurfaces.get(el);
@@ -7300,7 +7310,7 @@ var ImageEditorController = class {
         return s;
       }
     }
-    return fits ? fromPixels(px2) : null;
+    return fits ? fromPixels(px) : null;
   }
   opaqueCache = /* @__PURE__ */ new WeakMap();
   /** Whether every source pixel is opaque (some legacy renders depend on it). */
@@ -7362,11 +7372,11 @@ var ImageEditorController = class {
     const { width, height } = this.naturalSize;
     let surface = emptySurface(4);
     if (init.pixels) {
-      const px2 = init.pixels;
-      if (!(px2.width > 0 && px2.height > 0) || px2.data.length < px2.width * px2.height * 4) {
+      const px = init.pixels;
+      if (!(px.width > 0 && px.height > 0) || px.data.length < px.width * px.height * 4) {
         throw new LayerOperationError("pixels must be RGBA with width \xD7 height \xD7 4 bytes.");
       }
-      surface = surfaceFromPixels(px2, 4);
+      surface = surfaceFromPixels(px, 4);
     } else if (init.color !== void 0) {
       const c = parseColor(init.color);
       surface = solidSurface(4, { x: 0, y: 0, width, height }, packRgba(c[0], c[1], c[2], c[3]));
@@ -7470,9 +7480,9 @@ var ImageEditorController = class {
   getEdgeColor(id) {
     const layer = this.requireEdgeLayer(id);
     const e = layer.edge ?? {};
-    const pct2 = (v) => Math.round((v ?? 0) * 1e3) / 10;
+    const pct = (v) => Math.round((v ?? 0) * 1e3) / 10;
     const hex = (c) => "#" + c.map((v) => v.toString(16).padStart(2, "0")).join("");
-    return { layerId: layer.id, decontaminate: pct2(e.decontaminate), despill: pct2(e.despill), ambient: pct2(e.ambient), ambientSource: e.ambientColor ? hex(e.ambientColor) : "auto" };
+    return { layerId: layer.id, decontaminate: pct(e.decontaminate), despill: pct(e.despill), ambient: pct(e.ambient), ambientSource: e.ambientColor ? hex(e.ambientColor) : "auto" };
   }
   requireEdgeLayer(id) {
     const layer = this.getLayer(id);
@@ -7527,9 +7537,9 @@ var ImageEditorController = class {
         throw new LayerOperationError(`"${name}" has no mask with a soft edge: decontamination and despill work in the partly hidden band of a layer mask. Add one with add_layer_mask from a refined selection (refine_selection), or feather the mask (set_layer_mask_properties feather).`);
     }
     if (turningOn("ambient") && !this.maskHasSoftBand(layer) && layer.type === "pixel") {
-      const px2 = this.getLayerPixels(layer.id);
+      const px = this.getLayerPixels(layer.id);
       let soft = false;
-      if (px2) for (let i = 3; i < px2.data.length && !soft; i += 4) soft = px2.data[i] > 5 && px2.data[i] < 250;
+      if (px) for (let i = 3; i < px.data.length && !soft; i += 4) soft = px.data[i] > 5 && px.data[i] < 250;
       if (!soft) throw new LayerOperationError(`"${name}" has no soft edge (no soft-edged mask and no partly transparent pixels) for the edge cast to work on.`);
     }
     const edge = next.decontaminate || next.despill || next.ambient || next.ambientColor ? next : void 0;
@@ -8155,14 +8165,14 @@ var ImageEditorController = class {
     const surface = this.surfaceOf(layer);
     const sb = sel.bounds;
     const src = { x: sb.x - layer.offset.x, y: sb.y - layer.offset.y, width: sb.width, height: sb.height };
-    const px2 = readRegion(surface, src);
-    const kept = options.cut ? new Uint8ClampedArray(px2) : null;
+    const px = readRegion(surface, src);
+    const kept = options.cut ? new Uint8ClampedArray(px) : null;
     for (let y = 0; y < sb.height; y++) {
       for (let x = 0; x < sb.width; x++) {
         const c = sel.data[(sb.y + y) * sel.width + sb.x + x];
         const i = (y * sb.width + x) * 4 + 3;
         if (kept) kept[i] = Math.round(kept[i] * (1 - c / 255));
-        px2[i] = Math.round(px2[i] * (c / 255));
+        px[i] = Math.round(px[i] * (c / 255));
       }
     }
     const copy = {
@@ -8172,7 +8182,7 @@ var ImageEditorController = class {
       visible: true,
       opacity: 1,
       blend: "normal",
-      surface: surfaceFromPixels({ width: src.width, height: src.height, data: px2 }, 4, src.x, src.y),
+      surface: surfaceFromPixels({ width: src.width, height: src.height, data: px }, 4, src.x, src.y),
       offset: { ...layer.offset }
     };
     let next = insertLayer(this.state.layers, copy, loc.parent?.id ?? null, loc.index + 1);
@@ -8609,8 +8619,8 @@ var ImageEditorController = class {
     for (const [cid, c] of pending) {
       try {
         const url = `data:${BROWSER_IMAGE_TYPES[c.file.type]};base64,${bytesToBase64(c.file.bytes)}`;
-        const px2 = await this.decodeImage(url);
-        const decoded = { ...c, kind: "raster", raster: rasterContents(px2, c.name, cid).raster, width: px2.width, height: px2.height };
+        const px = await this.decodeImage(url);
+        const decoded = { ...c, kind: "raster", raster: rasterContents(px, c.name, cid).raster, width: px.width, height: px.height };
         const swap = (layers) => {
           let out = layers;
           for (const l of flattenLayers(layers)) if (l.type === "smart" && l.contents.id === cid) out = mapLayer(out, l.id, (x) => ({ ...x, contents: decoded }));
@@ -8706,8 +8716,8 @@ var ImageEditorController = class {
       const only = edited.layers.length === 1 ? edited.layers[0] : null;
       const plain3 = only?.type === "pixel" && only.visible && only.opacity === 1 && only.blend === "normal" && !only.mask && !only.effects && !only.filters?.length && !only.clipped && (only.fillOpacity ?? 1) === 1 && only.source !== "document";
       if (old?.kind === "raster" && plain3) {
-        const px2 = readRegion(only.surface, { x: -only.offset.x, y: -only.offset.y, width, height });
-        next = rasterContents({ width, height, data: px2 }, old.name, old.id);
+        const px = readRegion(only.surface, { x: -only.offset.x, y: -only.offset.y, width, height });
+        next = rasterContents({ width, height, data: px }, old.name, old.id);
       } else {
         const doc = { layers: edited.layers, globalLight: edited.globalLight, patterns: edited.patterns };
         next = documentContents(doc, width, height, old?.kind === "document" ? old.name : `${(old?.name ?? "Contents").replace(/\.\w+$/, "")}.psb`, top.contentsId);
@@ -11499,9 +11509,9 @@ var ImageEditorController = class {
       return;
     }
     const { width, height } = this.naturalSize;
-    let px2 = await this.decodeImage(newDataUrl);
-    if (px2.width !== width || px2.height !== height) px2 = resizePixels(px2, width, height);
-    const data = new Uint8ClampedArray(px2.data);
+    let px = await this.decodeImage(newDataUrl);
+    if (px.width !== width || px.height !== height) px = resizePixels(px, width, height);
+    const data = new Uint8ClampedArray(px.data);
     const sel = this.state.selection?.bounds ? this.state.selection : null;
     if (sel) for (let p = 0, i = 3; p < width * height; p++, i += 4) data[i] = Math.round(data[i] * sel.data[p] / 255);
     return this.addPixelLayer({ name: "Inpaint", pixels: { width, height, data } });
@@ -11522,10 +11532,10 @@ var ImageEditorController = class {
     if (!target) throw new LayerOperationError("There is no pixel layer to mask.");
     requireUnlocked(target, "all", "mask it");
     const { width, height } = this.naturalSize;
-    let px2 = await this.decodeImage(newDataUrl);
-    if (px2.width !== width || px2.height !== height) px2 = resizePixels(px2, width, height);
+    let px = await this.decodeImage(newDataUrl);
+    if (px.width !== width || px.height !== height) px = resizePixels(px, width, height);
     const alpha = new Uint8ClampedArray(width * height);
-    for (let p = 0; p < alpha.length; p++) alpha[p] = px2.data[p * 4 + 3];
+    for (let p = 0; p < alpha.length; p++) alpha[p] = px.data[p * 4 + 3];
     let surface = surfaceFromPixels({ width, height, data: alpha }, 1, 0, 0, 0);
     if (target.offset.x || target.offset.y) surface = translateSurface(surface, -target.offset.x, -target.offset.y);
     this.commitLayers(setLayerMask(this.state.layers, target.id, { surface, defaultValue: 0 }));
@@ -12098,14 +12108,14 @@ var ImageEditorController = class {
     const converted = [];
     const unconverted = [];
     const memo = /* @__PURE__ */ new Map();
-    const px2 = new Float32Array(4);
+    const px = new Float32Array(4);
     const hex = (h) => {
       let out = memo.get(h.toLowerCase());
       if (out === void 0) {
         const n = parseInt(h.slice(1), 16);
-        t.eval([(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255], px2);
+        t.eval([(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255], px);
         const c = (v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0");
-        out = `#${c(px2[0])}${c(px2[1])}${c(px2[2])}`;
+        out = `#${c(px[0])}${c(px[1])}${c(px[2])}`;
         memo.set(h.toLowerCase(), out);
       }
       return out;
@@ -12914,24 +12924,24 @@ function pixelsOnly(layers) {
   }
   return out;
 }
-function resizePixels(px2, width, height) {
-  const src = px2.data;
+function resizePixels(px, width, height) {
+  const src = px.data;
   const out = new Uint8ClampedArray(width * height * 4);
-  const kx = px2.width / width;
-  const ky = px2.height / height;
+  const kx = px.width / width;
+  const ky = px.height / height;
   for (let y = 0; y < height; y++) {
-    const fy = Math.min(px2.height - 1, Math.max(0, (y + 0.5) * ky - 0.5));
+    const fy = Math.min(px.height - 1, Math.max(0, (y + 0.5) * ky - 0.5));
     const y0 = Math.floor(fy);
-    const y1 = Math.min(px2.height - 1, y0 + 1);
+    const y1 = Math.min(px.height - 1, y0 + 1);
     const ty = fy - y0;
     for (let x = 0; x < width; x++) {
-      const fx = Math.min(px2.width - 1, Math.max(0, (x + 0.5) * kx - 0.5));
+      const fx = Math.min(px.width - 1, Math.max(0, (x + 0.5) * kx - 0.5));
       const x0 = Math.floor(fx);
-      const x1 = Math.min(px2.width - 1, x0 + 1);
+      const x1 = Math.min(px.width - 1, x0 + 1);
       const tx = fx - x0;
       for (let c = 0; c < 4; c++) {
-        const a = src[(y0 * px2.width + x0) * 4 + c] * (1 - tx) + src[(y0 * px2.width + x1) * 4 + c] * tx;
-        const b = src[(y1 * px2.width + x0) * 4 + c] * (1 - tx) + src[(y1 * px2.width + x1) * 4 + c] * tx;
+        const a = src[(y0 * px.width + x0) * 4 + c] * (1 - tx) + src[(y0 * px.width + x1) * 4 + c] * tx;
+        const b = src[(y1 * px.width + x0) * 4 + c] * (1 - tx) + src[(y1 * px.width + x1) * 4 + c] * tx;
         out[(y * width + x) * 4 + c] = a * (1 - ty) + b * ty;
       }
     }
@@ -13803,8 +13813,8 @@ var REFINE_OUTPUTS = [
 ];
 function describeSelection(mask) {
   if (!mask || !mask.bounds) return "No selection";
-  const pct2 = selectionArea(mask) / (mask.width * mask.height) * 100;
-  const shown = pct2 >= 10 ? Math.round(pct2) : Math.round(pct2 * 10) / 10;
+  const pct = selectionArea(mask) / (mask.width * mask.height) * 100;
+  const shown = pct >= 10 ? Math.round(pct) : Math.round(pct * 10) / 10;
   return `${mask.bounds.width} \xD7 ${mask.bounds.height} px selected (${shown}% of the image)`;
 }
 
@@ -15341,14 +15351,14 @@ function rebin(bins, count) {
   return out;
 }
 function histogramSummary(h, bins) {
-  const pct2 = (n) => h.samples ? round(n / h.samples * 100) : 0;
+  const pct = (n) => h.samples ? round(n / h.samples * 100) : 0;
   const channels = { red: h.red, green: h.green, blue: h.blue, luminance: h.luminance };
   return {
     samples: h.samples,
     transparent: h.transparent,
     clipping: {
-      shadowsPercent: { red: pct2(h.shadows[0]), green: pct2(h.shadows[1]), blue: pct2(h.shadows[2]) },
-      highlightsPercent: { red: pct2(h.highlights[0]), green: pct2(h.highlights[1]), blue: pct2(h.highlights[2]) }
+      shadowsPercent: { red: pct(h.shadows[0]), green: pct(h.shadows[1]), blue: pct(h.shadows[2]) },
+      highlightsPercent: { red: pct(h.highlights[0]), green: pct(h.highlights[1]), blue: pct(h.highlights[2]) }
     },
     stats: Object.fromEntries(Object.entries(channels).map(([k, v]) => [k, binStats(v, h.samples)])),
     ...bins ? { bins: Object.fromEntries(Object.entries(channels).map(([k, v]) => [k, rebin(v, bins)])) } : {}
@@ -16249,337 +16259,6 @@ function createImageLayerTools(controller) {
   ];
 }
 
-// src/image-editor/effect-tools.ts
-var READ3 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE3 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
-var WRITE_IDEMPOTENT3 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var DESTRUCTIVE2 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
-var LAYER_ID3 = { type: "string", description: "Layer id from list_layers (a pixel, shape, smart object, annotation or group layer)." };
-var EFFECT_ID = { type: "string", description: "Effect id from list_layer_effects or add_layer_effect." };
-var BLEND_IDS = BLEND_MODES.map((m) => m.id).filter((id) => id !== "pigment");
-var DEFS = {
-  color: { type: "string", pattern: "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$", description: "Colour as #rrggbb." },
-  contour: {
-    type: "object",
-    description: "A transfer curve over the effect coverage: points { input, output } from 0 to 1 (at least 2), sorted by input. Linear is [{0,0},{1,1}].",
-    properties: {
-      name: { type: "string", description: 'Display name (e.g. "Cone", "Gaussian").' },
-      points: {
-        type: "array",
-        minItems: 2,
-        description: "Curve points.",
-        items: {
-          type: "object",
-          properties: {
-            input: { type: "number", minimum: 0, maximum: 1, description: "Coverage in (0..1)." },
-            output: { type: "number", minimum: 0, maximum: 1, description: "Coverage out (0..1)." },
-            corner: { type: "boolean", description: "Sharp corner instead of a smooth point (default false)." }
-          },
-          required: ["input", "output"],
-          additionalProperties: false
-        }
-      }
-    },
-    required: ["name", "points"],
-    additionalProperties: false
-  },
-  gradient: {
-    type: "object",
-    description: "A gradient: colour stops, optional opacity stops and its layout.",
-    properties: {
-      stops: {
-        type: "array",
-        minItems: 1,
-        description: "Colour stops { position 0..1, color #rrggbb }.",
-        items: {
-          type: "object",
-          properties: { position: { type: "number", minimum: 0, maximum: 1, description: "0..1 along the gradient." }, color: { $ref: "#/$defs/color" } },
-          required: ["position", "color"],
-          additionalProperties: false
-        }
-      },
-      opacityStops: {
-        type: "array",
-        description: "Opacity stops { position 0..1, opacity 0..1 } (default opaque).",
-        items: {
-          type: "object",
-          properties: {
-            position: { type: "number", minimum: 0, maximum: 1, description: "0..1 along the gradient." },
-            opacity: { type: "number", minimum: 0, maximum: 1, description: "0..1." }
-          },
-          required: ["position", "opacity"],
-          additionalProperties: false
-        }
-      },
-      style: { type: "string", enum: ["linear", "radial", "angle", "reflected", "diamond"], description: "Geometry." },
-      angle: { type: "number", minimum: -360, maximum: 360, description: "Degrees, 90 = bottom to top." },
-      scale: { type: "number", minimum: 0.1, maximum: 1.5, description: "1 = 100 %." },
-      reverse: { type: "boolean", description: "Swap the ends." },
-      align: { type: "boolean", description: "Lay out over the layer bounds (true) or the canvas." },
-      offset: {
-        type: "object",
-        description: "Centre offset as fractions of the bounds.",
-        properties: { x: { type: "number", minimum: -1, maximum: 1, description: "Fraction of the width." }, y: { type: "number", minimum: -1, maximum: 1, description: "Fraction of the height." } },
-        required: ["x", "y"],
-        additionalProperties: false
-      }
-    },
-    required: ["stops", "style", "angle", "scale", "reverse", "align", "offset"],
-    additionalProperties: false
-  },
-  phase: {
-    type: "object",
-    description: "Pattern origin offset in px.",
-    properties: { x: { type: "number", description: "px." }, y: { type: "number", description: "px." } },
-    required: ["x", "y"],
-    additionalProperties: false
-  },
-  fill: {
-    description: "What a stroke or glow paints with. Glows take color or gradient only.",
-    anyOf: [
-      {
-        type: "object",
-        properties: { type: { const: "color", description: "Solid colour." }, color: { $ref: "#/$defs/color" } },
-        required: ["type", "color"],
-        additionalProperties: false
-      },
-      {
-        type: "object",
-        properties: { type: { const: "gradient", description: "Gradient." }, gradient: { $ref: "#/$defs/gradient" } },
-        required: ["type", "gradient"],
-        additionalProperties: false
-      },
-      {
-        type: "object",
-        properties: {
-          type: { const: "pattern", description: "Pattern (strokes only)." },
-          patternId: { type: "string", description: "Pattern id from list_layer_effects.patterns." },
-          name: { type: "string", description: "Display name." },
-          scale: { type: "number", minimum: 0.01, maximum: 10, description: "1 = 100 %." },
-          angle: { type: "number", minimum: -360, maximum: 360, description: "Rotation in degrees (default 0)." },
-          link: { type: "boolean", description: "Tile from the layer (default true) or the canvas origin." },
-          phase: { $ref: "#/$defs/phase" }
-        },
-        required: ["type", "patternId", "scale"],
-        additionalProperties: false
-      }
-    ]
-  }
-};
-var nullable = (schema, description) => ({ anyOf: [schema, { type: "null" }], description });
-function settingsSchema(forUpdate) {
-  const opt2 = (schema, description) => forUpdate ? nullable(schema, `${description} null removes it.`) : { ...schema, description };
-  return {
-    type: "object",
-    description: forUpdate ? "Settings to change (only these; nested objects are replaced whole). Which settings a kind takes: see add_layer_effect." : "Settings to change from Photoshop's defaults (all optional). Unknown settings for the kind are refused with the list of its settings.",
-    properties: {
-      enabled: { type: "boolean", description: "All kinds: false keeps the effect but hides it (default true)." },
-      blend: { type: "string", enum: BLEND_IDS, description: "All but bevel-emboss: blend mode (shadows multiply, glows screen, others normal)." },
-      opacity: { type: "number", minimum: 0, maximum: 1, description: "All but bevel-emboss: 0..1 (shadows / glows 0.75, satin 0.5, others 1)." },
-      color: { $ref: "#/$defs/color", description: "drop-shadow, inner-shadow, satin, color-overlay: #rrggbb." },
-      angle: { type: "number", minimum: -360, maximum: 360, description: "Shadows, satin, bevel-emboss: light direction in degrees, counter-clockwise from 3 o'clock (default 120; satin 19)." },
-      useGlobalLight: { type: "boolean", description: "Shadows, bevel-emboss: follow the document global light instead of angle (default true)." },
-      distance: { type: "number", minimum: 0, maximum: 3e4, description: "Shadows, satin: offset in px (default 5; satin 11)." },
-      spread: { type: "number", minimum: 0, maximum: 1, description: "drop-shadow, outer-glow: 0..1 of the size made solid (default 0)." },
-      choke: { type: "number", minimum: 0, maximum: 1, description: "inner-shadow, inner-glow: 0..1 of the size made solid (default 0)." },
-      size: { type: "number", minimum: 0, maximum: 250, description: "Shadows, glows, satin, bevel-emboss: blur / size in px (default 5; satin 14); stroke: width in px (default 3)." },
-      contour: opt2({ $ref: "#/$defs/contour" }, "Shadows, glows, satin: coverage contour (default linear)."),
-      antiAlias: { type: "boolean", description: "Shadows, glows, satin: smooth the contour (default false; satin true)." },
-      noise: { type: "number", minimum: 0, maximum: 1, description: "Shadows, glows: speckle 0..1 (default 0)." },
-      knocksOut: { type: "boolean", description: "drop-shadow: the layer hides the shadow beneath its see-through fill (default true)." },
-      fill: { $ref: "#/$defs/fill", description: "outer-glow, inner-glow (color or gradient), stroke (color, gradient or pattern)." },
-      technique: { type: "string", enum: ["softer", "precise", "smooth", "chisel-hard", "chisel-soft"], description: "Glows: softer | precise (default softer); bevel-emboss: smooth | chisel-hard | chisel-soft (default smooth)." },
-      range: { type: "number", minimum: 0.01, maximum: 1, description: "Glows: the part of the glow the contour spans (default 0.5)." },
-      jitter: { type: "number", minimum: 0, maximum: 1, description: "Glows: gradient jitter 0..1 (stored, not rendered; default 0)." },
-      source: { type: "string", enum: ["edge", "center"], description: "inner-glow: glow from the edge (default) or the centre." },
-      style: { type: "string", enum: ["inner-bevel", "outer-bevel", "emboss", "pillow-emboss", "stroke-emboss"], description: "bevel-emboss: style (default inner-bevel)." },
-      depth: { type: "number", minimum: 0, maximum: 10, description: "bevel-emboss: depth, 1 = 100 % (default 1)." },
-      direction: { type: "string", enum: ["up", "down"], description: "bevel-emboss: raised (up, default) or sunk (down)." },
-      soften: { type: "number", minimum: 0, maximum: 16, description: "bevel-emboss: blur of the height in px (default 0)." },
-      altitude: { type: "number", minimum: 0, maximum: 90, description: "bevel-emboss: light altitude in degrees (default 30)." },
-      glossContour: opt2({ $ref: "#/$defs/contour" }, "bevel-emboss: gloss contour over the shading (default linear)."),
-      highlightColor: { $ref: "#/$defs/color", description: "bevel-emboss: highlight colour (default #ffffff)." },
-      highlightBlend: { type: "string", enum: BLEND_IDS, description: "bevel-emboss: highlight mode (default screen)." },
-      highlightOpacity: { type: "number", minimum: 0, maximum: 1, description: "bevel-emboss: highlight opacity (default 0.75)." },
-      shadowColor: { $ref: "#/$defs/color", description: "bevel-emboss: shadow colour (default #000000)." },
-      shadowBlend: { type: "string", enum: BLEND_IDS, description: "bevel-emboss: shadow mode (default multiply)." },
-      shadowOpacity: { type: "number", minimum: 0, maximum: 1, description: "bevel-emboss: shadow opacity (default 0.75)." },
-      contourElement: opt2(
-        {
-          type: "object",
-          properties: {
-            contour: { $ref: "#/$defs/contour" },
-            range: { type: "number", minimum: 0, maximum: 1, description: "Stored range (default 0.5)." },
-            antiAlias: { type: "boolean", description: "Smooth the contour." }
-          },
-          required: ["contour", "range", "antiAlias"],
-          additionalProperties: false
-        },
-        "bevel-emboss: the Contour element, shaping the bevel's height profile (default off)."
-      ),
-      texture: opt2(
-        {
-          type: "object",
-          properties: {
-            patternId: { type: "string", description: "Pattern id from list_layer_effects.patterns." },
-            name: { type: "string", description: "Display name." },
-            scale: { type: "number", minimum: 0.01, maximum: 10, description: "1 = 100 %." },
-            depth: { type: "number", minimum: -10, maximum: 10, description: "1 = +100 %; negative carves the pattern in." },
-            invert: { type: "boolean", description: "Invert the pattern." },
-            link: { type: "boolean", description: "Tile from the layer (default true)." },
-            phase: { $ref: "#/$defs/phase" }
-          },
-          required: ["patternId", "scale", "depth", "invert"],
-          additionalProperties: false
-        },
-        "bevel-emboss: the Texture element, a pattern's luminance as extra height (default off)."
-      ),
-      invert: { type: "boolean", description: "satin: invert (default true)." },
-      gradient: { $ref: "#/$defs/gradient", description: "gradient-overlay: the gradient (default black to white, 90\xB0)." },
-      dither: { type: "boolean", description: "gradient-overlay: dither (stored; default false)." },
-      patternId: { type: "string", description: "pattern-overlay: pattern id from list_layer_effects.patterns (default checker)." },
-      name: { type: "string", description: "pattern-overlay: pattern display name." },
-      scale: { type: "number", minimum: 0.01, maximum: 10, description: "pattern-overlay: 1 = 100 % (default 1)." },
-      link: { type: "boolean", description: "pattern-overlay: tile from the layer (default true) or the canvas origin." },
-      phase: { $ref: "#/$defs/phase", description: "pattern-overlay: origin offset in px (default 0, 0)." },
-      position: { type: "string", enum: ["outside", "inside", "center"], description: "stroke: where the stroke sits on the edge (default outside)." }
-    },
-    additionalProperties: false
-  };
-}
-function patternList(controller) {
-  const doc = controller.getDocumentPatterns().map((p) => ({ id: p.id, name: p.name, width: p.width, height: p.height, builtin: false }));
-  const builtins = builtinPatternIds().map((id) => {
-    const p = builtinPattern(id);
-    return { id, name: p.name, width: p.width, height: p.height, builtin: true };
-  });
-  return [...doc, ...builtins];
-}
-function describeLayerEffects(effects) {
-  return {
-    enabled: effects.enabled,
-    scale: effects.scale ?? 1,
-    margin: effectsMargin(effects),
-    fromPsd: Boolean(effects.psd),
-    effects: effects.items.map((e) => ({ ...JSON.parse(JSON.stringify(e)), label: layerEffectLabel(e.kind) }))
-  };
-}
-function createImageEffectTools(controller) {
-  const layerArg = (id) => {
-    if (typeof id !== "string" || !id) throw new LayerOperationError("layerId is required (a layer id from list_layers).");
-    requireLayer(controller.getLayers(), id);
-    return id;
-  };
-  const result = (layerId, extra = {}) => ({ layerId, ...extra, ...describeLayerEffects(controller.getLayerEffects(layerId)) });
-  const list = {
-    name: "list_layer_effects",
-    title: "List layer effects",
-    description: "Returns a layer's effects: the master switch (enabled), Scale Effects (scale, 1 = 100 %), margin (px the effects reach beyond the shape), whether they came from a PSD, and every effect with its id, kind, label and all settings. Also returns the document global light and the pattern ids pattern effects can use.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "List layer effects", ...READ3 },
-    handler: ({ layerId }) => result(layerArg(layerId), { globalLight: controller.getGlobalLight(), patterns: patternList(controller), kinds: [...LAYER_EFFECT_KINDS] })
-  };
-  const add2 = {
-    name: "add_layer_effect",
-    title: "Add a layer effect",
-    description: "Adds a live effect to a pixel, shape, type, smart object, annotation or group layer with Photoshop's defaults, changed by settings: drop-shadow, inner-shadow, outer-glow, inner-glow, bevel-emboss, satin, color-overlay, gradient-overlay, pattern-overlay or stroke. Several of one kind are allowed (the first listed is on top). One undo step. Returns the new effect's id and the layer's effects.",
-    inputSchema: {
-      type: "object",
-      $defs: DEFS,
-      properties: {
-        layerId: LAYER_ID3,
-        kind: { type: "string", enum: [...LAYER_EFFECT_KINDS], description: "Effect kind." },
-        settings: settingsSchema(false),
-        index: { type: "integer", minimum: 0, description: "Position in the layer's effect list (default the end)." }
-      },
-      required: ["layerId", "kind"],
-      additionalProperties: false
-    },
-    annotations: { title: "Add a layer effect", ...WRITE3 },
-    handler: ({ layerId, kind, settings, index }) => {
-      const id = layerArg(layerId);
-      if (!isLayerEffectKind(kind)) throw new LayerOperationError(`kind must be one of ${LAYER_EFFECT_KINDS.join(", ")}.`);
-      const { effect } = controller.addLayerEffect(id, kind, settings ?? {}, index);
-      return result(id, { effectId: effect.id });
-    }
-  };
-  const update = {
-    name: "update_layer_effect",
-    title: "Change a layer effect",
-    description: "Changes settings of one effect (only the given ones; fill, gradient, contour and texture objects are replaced whole, null removes an optional contour or texture). The kind cannot change. Validates everything before changing anything. One undo step. Returns the layer's effects.",
-    inputSchema: {
-      type: "object",
-      $defs: DEFS,
-      properties: { layerId: LAYER_ID3, effectId: EFFECT_ID, settings: settingsSchema(true) },
-      required: ["layerId", "effectId", "settings"],
-      additionalProperties: false
-    },
-    annotations: { title: "Change a layer effect", ...WRITE_IDEMPOTENT3 },
-    handler: ({ layerId, effectId, settings }) => {
-      const id = layerArg(layerId);
-      const changes = settings ?? {};
-      if (!Object.keys(changes).length) throw new LayerOperationError("Give at least one setting to change.");
-      controller.updateLayerEffect(id, effectId, changes);
-      return result(id);
-    }
-  };
-  const remove = {
-    name: "remove_layer_effect",
-    title: "Remove a layer effect",
-    description: "Removes one effect from a layer (to hide it but keep its settings, set enabled false with update_layer_effect instead). One undo step. Returns the layer's remaining effects.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID3, effectId: EFFECT_ID }, required: ["layerId", "effectId"], additionalProperties: false },
-    annotations: { title: "Remove a layer effect", ...DESTRUCTIVE2 },
-    handler: ({ layerId, effectId }) => {
-      const id = layerArg(layerId);
-      controller.removeLayerEffect(id, effectId);
-      return result(id);
-    }
-  };
-  const setEnabled = {
-    name: "set_layer_effects_enabled",
-    title: "Switch layer effects on or off",
-    description: "Turns all of a layer's effects on or off at once (the master switch; each effect keeps its own enabled flag) and optionally sets Scale Effects, which multiplies every size, distance and pattern scale. One undo step. Returns the layer's effects.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        layerId: LAYER_ID3,
-        enabled: { type: "boolean", description: "true renders the enabled effects; false hides them all." },
-        scale: { type: "number", minimum: 0.01, maximum: 10, description: "Scale Effects, 1 = 100 % (unchanged when left out)." }
-      },
-      required: ["layerId", "enabled"],
-      additionalProperties: false
-    },
-    annotations: { title: "Switch layer effects on or off", ...WRITE_IDEMPOTENT3 },
-    handler: ({ layerId, enabled, scale }) => {
-      const id = layerArg(layerId);
-      controller.setLayerEffectsEnabled(id, enabled, scale);
-      return result(id);
-    }
-  };
-  const light = {
-    name: "set_global_light",
-    title: "Set the global light",
-    description: "Sets the document global light that shadows and bevels with useGlobalLight follow (Photoshop default: angle 120\xB0, altitude 30\xB0). One undo step. Returns the light.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        angle: { type: "number", minimum: -360, maximum: 360, description: "Degrees, counter-clockwise from 3 o'clock: where the light comes from (unchanged when left out)." },
-        altitude: { type: "number", minimum: 0, maximum: 90, description: "Degrees above the canvas, for bevels (unchanged when left out)." }
-      },
-      additionalProperties: false
-    },
-    annotations: { title: "Set the global light", ...WRITE_IDEMPOTENT3 },
-    handler: ({ angle, altitude }) => {
-      if (angle === void 0 && altitude === void 0) throw new LayerOperationError("Give angle, altitude or both.");
-      const next = {};
-      if (angle !== void 0) next.angle = angle;
-      if (altitude !== void 0) next.altitude = altitude;
-      return { globalLight: controller.setGlobalLight(next) };
-    }
-  };
-  return [list, add2, update, remove, setEnabled, light];
-}
-
 // src/image-editor/selection/gesture.ts
 function snapTo45(from, point2) {
   const dx = point2.x - from.x;
@@ -17315,10 +16994,10 @@ var PaintGesture = class {
 };
 
 // src/image-editor/paint-tools.ts
-var READ4 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var READ3 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE3 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var SET = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var DESTRUCTIVE2 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var TARGET = {
   layerId: { type: "string", description: "Layer to paint (default the active layer; see list_layers)." },
   channel: {
@@ -17408,7 +17087,7 @@ function createImagePaintTools(controller) {
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "Paint a brush stroke", ...WRITE4 },
+    annotations: { title: "Paint a brush stroke", ...WRITE3 },
     handler: (args) => {
       const tool = args.tool;
       if (args.mixer !== void 0 && tool !== "mixer") throw new LayerOperationError('mixer settings apply to the Mixer Brush only; pass tool "mixer", or drop mixer.');
@@ -17431,7 +17110,7 @@ function createImagePaintTools(controller) {
     title: "Get the Mixer Brush",
     description: "Reads the Mixer Brush: its settings (wet, load, mix, loadEachStroke, cleanEachStroke, mixing) and what it carries now (reservoir #rrggbb or null, amount 0..1 left, pickup #rrggbb or null). Call it before a paint_stroke with tool mixer and loadEachStroke false, to know the brush's starting paint.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "Get the Mixer Brush", ...READ4 },
+    annotations: { title: "Get the Mixer Brush", ...READ3 },
     handler: () => {
       const { mixer, mixerLoad } = controller.getState().paint;
       return { settings: { ...mixer }, load: mixerLoadResult(mixerLoad) };
@@ -17446,7 +17125,7 @@ function createImagePaintTools(controller) {
       properties: { color: { type: "string", description: "Paint colour #rrggbb (default the foreground)." } },
       additionalProperties: false
     },
-    annotations: { title: "Load the Mixer Brush", ...WRITE4, idempotentHint: true },
+    annotations: { title: "Load the Mixer Brush", ...WRITE3, idempotentHint: true },
     handler: (args) => mixerLoadResult(controller.loadMixerBrush(args.color))
   };
   const cleanMixerTool = {
@@ -17458,7 +17137,7 @@ function createImagePaintTools(controller) {
       properties: { emptyReservoir: { type: "boolean", description: "Also drop the reservoir (default false)." } },
       additionalProperties: false
     },
-    annotations: { title: "Clean the Mixer Brush", ...WRITE4, idempotentHint: true },
+    annotations: { title: "Clean the Mixer Brush", ...WRITE3, idempotentHint: true },
     handler: (args) => mixerLoadResult(args.emptyReservoir === true ? controller.emptyMixerBrush() : controller.cleanMixerBrush())
   };
   const fill = {
@@ -17476,7 +17155,7 @@ function createImagePaintTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Fill pixels", ...WRITE4 },
+    annotations: { title: "Fill pixels", ...WRITE3 },
     handler: (args) => controller.fillPixels({
       color: args.color,
       opacity: args.opacity,
@@ -17498,7 +17177,7 @@ function createImagePaintTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Clear pixels", ...DESTRUCTIVE3 },
+    annotations: { title: "Clear pixels", ...DESTRUCTIVE2 },
     handler: (args) => controller.clearPixels({ opacity: args.opacity, useSelection: args.useSelection, ...readTarget(args) })
   };
   const paintView = () => {
@@ -17521,7 +17200,7 @@ function createImagePaintTools(controller) {
     title: "Get the paint",
     description: "Reads what the brush paints (paint: the foreground colour or gradient paint), the foreground and background colours and the brush settings (size, hardness, spacing, opacity, flow \u2026). Changes nothing.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "Get the paint", ...READ4 },
+    annotations: { title: "Get the paint", ...READ3 },
     handler: () => paintView()
   };
   const sampleColor2 = {
@@ -17564,7 +17243,7 @@ function createImagePaintTools(controller) {
       required: ["start", "end"],
       additionalProperties: false
     },
-    annotations: { title: "Sample a gradient along a line", ...READ4 },
+    annotations: { title: "Sample a gradient along a line", ...READ3 },
     handler: (args) => {
       const start = args.start;
       const end = args.end;
@@ -17593,7 +17272,7 @@ function createImagePaintTools(controller) {
 }
 
 // src/image-editor/color-tools.ts
-var READ5 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var READ4 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var PROFILE = {
   type: "string",
   description: `A built-in profile id (${BUILTIN_PROFILES.map((b) => b.id).join(", ")}; names like "Adobe RGB (1998)" work too), or "icc:<base64>" for ICC profile bytes.`
@@ -17620,7 +17299,7 @@ function createImageColorTools(controller) {
     title: "Get the colour profile",
     description: "Reads the document's colour profile (its working space: name, builtin id or null for an embedded profile, colorSpace, srgb true when it means sRGB, mode rgb / cmyk / lab and, for cmyk, cmykProfile), the Proof Setup (profile, intent, bpc, simulatePaper, gamutWarning, or null) and the built-in profiles you can assign, convert to or proof with ({id, description, colorSpace}).",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "Get the colour profile", ...READ5 },
+    annotations: { title: "Get the colour profile", ...READ4 },
     handler: () => {
       const proof2 = controller.getState().proofSetup;
       return {
@@ -17704,7 +17383,7 @@ function createImageColorTools(controller) {
       required: ["colors", "to"],
       additionalProperties: false
     },
-    annotations: { title: "Convert colours between profiles", ...READ5 },
+    annotations: { title: "Convert colours between profiles", ...READ4 },
     handler: (args) => ({
       colors: controller.convertColors(args.colors, profileArg(args.to), {
         ...args.from !== void 0 ? { from: profileArg(args.from) } : {},
@@ -17740,8 +17419,8 @@ function createImageColorTools(controller) {
 }
 
 // src/image-editor/retouch-tools.ts
-var READ6 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var READ5 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var POINTS = {
   type: "array",
   minItems: 1,
@@ -17831,7 +17510,7 @@ function createImageRetouchTools(controller) {
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "Clone Stamp stroke", ...WRITE5 },
+    annotations: { title: "Clone Stamp stroke", ...WRITE4 },
     handler: (args) => stroke("clone", args, pick(args, ["aligned", "sample"]))
   };
   const healBrush = {
@@ -17851,7 +17530,7 @@ function createImageRetouchTools(controller) {
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "Healing Brush stroke", ...WRITE5 },
+    annotations: { title: "Healing Brush stroke", ...WRITE4 },
     handler: (args) => stroke("heal", args, pick(args, ["aligned", "sample"]))
   };
   const spotHeal = {
@@ -17870,7 +17549,7 @@ function createImageRetouchTools(controller) {
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "Spot Healing stroke", ...WRITE5 },
+    annotations: { title: "Spot Healing stroke", ...WRITE4 },
     handler: (args) => stroke("spot-heal", args, { ...pick(args, ["sample"]), ...args.type !== void 0 ? { spotType: args.type } : {} })
   };
   const smudge = {
@@ -17888,7 +17567,7 @@ function createImageRetouchTools(controller) {
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "Smudge stroke", ...WRITE5 },
+    annotations: { title: "Smudge stroke", ...WRITE4 },
     handler: (args) => stroke("smudge", args, pick(args, ["strength"]))
   };
   const toneSchema = (verb) => ({
@@ -17909,7 +17588,7 @@ function createImageRetouchTools(controller) {
     title: "Dodge stroke",
     description: "Lightens the pixels a stroke covers (Photoshop's Dodge), most in the chosen tonal range. Alpha is kept. One undo step. Returns the layerId, channel, changed bounds and dab count. Inspect the result with capture_view or get_histogram; several light strokes look more natural than one strong one.",
     inputSchema: toneSchema("lighten"),
-    annotations: { title: "Dodge stroke", ...WRITE5 },
+    annotations: { title: "Dodge stroke", ...WRITE4 },
     handler: (args) => stroke("dodge", args, pick(args, ["range", "exposure", "protectTones"]))
   };
   const burn = {
@@ -17917,7 +17596,7 @@ function createImageRetouchTools(controller) {
     title: "Burn stroke",
     description: "Darkens the pixels a stroke covers (Photoshop's Burn), most in the chosen tonal range. Alpha is kept. One undo step. Returns the layerId, channel, changed bounds and dab count.",
     inputSchema: toneSchema("darken"),
-    annotations: { title: "Burn stroke", ...WRITE5 },
+    annotations: { title: "Burn stroke", ...WRITE4 },
     handler: (args) => stroke("burn", args, pick(args, ["range", "exposure", "protectTones"]))
   };
   const spongeTool = {
@@ -17936,7 +17615,7 @@ function createImageRetouchTools(controller) {
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "Sponge stroke", ...WRITE5 },
+    annotations: { title: "Sponge stroke", ...WRITE4 },
     handler: (args) => stroke("sponge", { ...args, channel: "pixels" }, { ...pick(args, ["vibrance"]), ...args.mode !== void 0 ? { spongeMode: args.mode } : {} })
   };
   const filterSchema = (verb) => ({
@@ -17955,7 +17634,7 @@ function createImageRetouchTools(controller) {
     title: "Blur stroke",
     description: "Softens the pixels a stroke covers (Photoshop's Blur tool): a soft blur of the layer laid through the brush at `strength`. Overlapping dabs in one stroke do not compound; another stroke blurs further. Works on pixels and masks, at any bit depth. One undo step. Returns the layerId, channel, changed bounds and dab count.",
     inputSchema: filterSchema("blur"),
-    annotations: { title: "Blur stroke", ...WRITE5 },
+    annotations: { title: "Blur stroke", ...WRITE4 },
     handler: (args) => stroke("blur", args, pick(args, ["strength"]))
   };
   const sharpenTool = {
@@ -17963,7 +17642,7 @@ function createImageRetouchTools(controller) {
     title: "Sharpen stroke",
     description: "Crisps the pixels a stroke covers (Photoshop's Sharpen tool): an unsharp mask of the layer laid through the brush at `strength`. Keep strength low (0.2..0.5) and inspect with capture_view; strong sharpening shows halos and noise. One undo step. Returns the layerId, channel, changed bounds and dab count.",
     inputSchema: filterSchema("sharpen"),
-    annotations: { title: "Sharpen stroke", ...WRITE5 },
+    annotations: { title: "Sharpen stroke", ...WRITE4 },
     handler: (args) => stroke("sharpen", args, pick(args, ["strength"]))
   };
   const historyBrush = {
@@ -17981,7 +17660,7 @@ function createImageRetouchTools(controller) {
       required: ["points"],
       additionalProperties: false
     },
-    annotations: { title: "History Brush stroke", ...WRITE5 },
+    annotations: { title: "History Brush stroke", ...WRITE4 },
     handler: (args) => stroke("history", args, pick(args, ["historySteps"]))
   };
   const getOptions = {
@@ -17989,7 +17668,7 @@ function createImageRetouchTools(controller) {
     title: "Get retouch options",
     description: "Reads the retouching tools' options (aligned, sample, spotType, range, exposure, protectTones, spongeMode, vibrance, strength, historySteps), the Clone Source transform ({scaleX, scaleY, rotate}) and the clone source ({x, y, offset} or null; offset is the aligned offset the last clone or heal stroke fixed: an aligned stroke samples at the brush plus offset, which the editors show as a crosshair). Call it before clone_stamp or heal_brush without a source to see where they will sample.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "Get retouch options", ...READ6 },
+    annotations: { title: "Get retouch options", ...READ5 },
     handler: () => {
       const { retouch, cloneSource, cloneTransform } = controller.getState().paint;
       return { options: { ...retouch }, cloneSource: cloneSource ? { ...cloneSource } : null, cloneTransform: { ...cloneTransform } };
@@ -18015,7 +17694,7 @@ function createImageRetouchTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Set retouch options", ...WRITE5, idempotentHint: true },
+    annotations: { title: "Set retouch options", ...WRITE4, idempotentHint: true },
     handler: (args) => ({ ...controller.setPaintOptions({ retouch: args }).retouch })
   };
   const setSource = {
@@ -18031,7 +17710,7 @@ function createImageRetouchTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Set the clone source", ...WRITE5, idempotentHint: true },
+    annotations: { title: "Set the clone source", ...WRITE4, idempotentHint: true },
     handler: (args) => {
       if (args.clear === true) {
         if (args.x !== void 0 || args.y !== void 0) throw new LayerOperationError("Give either clear true or x and y, not both.");
@@ -18057,7 +17736,7 @@ function createImageRetouchTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Transform the clone source", ...WRITE5, idempotentHint: false },
+    annotations: { title: "Transform the clone source", ...WRITE4, idempotentHint: false },
     handler: (args) => {
       if (args.reset === true) {
         if (Object.keys(args).some((k) => k !== "reset")) throw new LayerOperationError("Give either reset true or transform values, not both.");
@@ -18083,8 +17762,8 @@ function pick(args, keys) {
 }
 
 // src/image-editor/psd-tools.ts
-var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var DESTRUCTIVE4 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var READ6 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var DATA = {
   type: "string",
   minLength: 1,
@@ -18104,7 +17783,7 @@ function createImagePsdTools(controller) {
     title: "Inspect a PSD",
     description: "Reads a PSD / PSB without opening it: size, bit depth, colour mode, resolution, and every layer (bottom first, a group before its children) with its PSD kind, the layer type it would become and its status (mapped, approximated or dropped, with notes), plus the import warnings. Changes nothing. Call before import_psd to see what would be lost.",
     inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
-    annotations: { title: "Inspect a PSD", ...READ7 },
+    annotations: { title: "Inspect a PSD", ...READ6 },
     handler: ({ data }) => {
       const res = importPsd(psdBytesFromBase64(data), { skipPixels: true });
       return {
@@ -18122,7 +17801,7 @@ function createImagePsdTools(controller) {
     title: "Open a PSD as the document",
     description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility, locks, layer effects (with the patterns and global light of the file) map directly; smart objects come in as smart objects (embedded contents, placement and warp, smart filters: Box Blur is drawn, other Photoshop filters are kept but not drawn, filter mask; linked contents as their stored pixels); shape layers come in as live shapes (paths, path operations, fill, stroke, live rectangles, ellipses and lines); type layers come in as live text (runs, paragraphs, frame, transform) showing Photoshop\u2019s pixels until edited, with a warning for fonts missing here; fill layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
     inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
-    annotations: { title: "Open a PSD as the document", ...DESTRUCTIVE4 },
+    annotations: { title: "Open a PSD as the document", ...DESTRUCTIVE3 },
     handler: ({ data }) => {
       const res = controller.loadPsd(psdBytesFromBase64(data));
       const s = controller.getState();
@@ -18141,7 +17820,7 @@ function createImagePsdTools(controller) {
     title: "Export the document as a PSD",
     description: "Writes the document as an RGB PSD at its bit depth (8, 16 or 32; see set_bit_depth; a PSB above 30000 px) with real layers, groups, adjustment layers, masks and layer effects (an effects block opened from a PSD is written back unchanged while its effects are; the patterns effects use are embedded), in the source frame (crop and rotation are not applied). Smart objects are written as Photoshop smart objects (contents embedded once per linked set, placement, warp, smart filters and filter mask; a Develop smart filter has no Photoshop filter and is left out of the list). Shape layers are written as Photoshop shape layers (path, fill, stroke, live shapes) and type layers as Photoshop type layers (text, runs, paragraphs, frame; blocks opened from a PSD are written back unchanged while the layer is). Layer filters and depth masks are baked, annotation layers are rasterized (in a browser; elsewhere left out), and the merged image is the editor's composite. Changes nothing. Returns the file as base64, its size in bytes, whether it is a PSB, and warnings for everything that was changed or left out.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "Export the document as a PSD", ...READ7 },
+    annotations: { title: "Export the document as a PSD", ...READ6 },
     handler: async () => {
       const res = await controller.toPsd();
       return {
@@ -18159,8 +17838,8 @@ function createImagePsdTools(controller) {
 }
 
 // src/image-editor/transform-tools.ts
-var READ8 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var READ7 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var round4 = (n, digits = 3) => Math.round(n * 10 ** digits) / 10 ** digits;
 var roundPoint = (p) => ({ x: round4(p.x), y: round4(p.y) });
 var POINT = {
@@ -18259,7 +17938,7 @@ function createImageTransformTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Get the Free Transform frame", ...READ8 },
+    annotations: { title: "Get the Free Transform frame", ...READ7 },
     handler: (args) => {
       const init = targetFrom(args);
       if (init.content === "selection-copy") init.content = "selection";
@@ -18292,7 +17971,7 @@ function createImageTransformTools(controller) {
       properties: { ...TARGET3, ...GEOMETRY },
       additionalProperties: false
     },
-    annotations: { title: "Free Transform a layer", ...WRITE6 },
+    annotations: { title: "Free Transform a layer", ...WRITE5 },
     handler: (args) => summary2(controller.transformLayer({ ...targetFrom(args), ...geometryFrom(args) }))
   };
   const warpLayer = {
@@ -18322,7 +18001,7 @@ function createImageTransformTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Warp a layer", ...WRITE6 },
+    annotations: { title: "Warp a layer", ...WRITE5 },
     handler: (args) => {
       const hasPreset = ["style", "bend", "horizontal", "vertical", "orientation"].some((k) => args[k] !== void 0);
       if (hasPreset && args.mesh !== void 0) throw new LayerOperationError("Give a preset (style, bend, horizontal, vertical, orientation) or a mesh, not both.");
@@ -18356,7 +18035,7 @@ function createImageTransformTools(controller) {
       properties: { interpolation: { ...TARGET3.interpolation, description: "Resampling of soft edges: nearest, bilinear or bicubic (default)." }, ...GEOMETRY },
       additionalProperties: false
     },
-    annotations: { title: "Transform the selection outline", ...WRITE6 },
+    annotations: { title: "Transform the selection outline", ...WRITE5 },
     handler: (args) => {
       const res = controller.transformLayer({ content: "selection-outline", interpolation: args.interpolation, ...geometryFrom(args) });
       return { changed: res.changed, frame: { ...res.box }, corners: res.corners.map(roundPoint), bounds: res.bounds };
@@ -18377,7 +18056,7 @@ function createImageTransformTools(controller) {
       required: ["axis"],
       additionalProperties: false
     },
-    annotations: { title: "Flip a layer", ...WRITE6 },
+    annotations: { title: "Flip a layer", ...WRITE5 },
     handler: (args) => summary2(controller.flipLayer(args.axis, targetFrom(args)))
   };
   const rotate90 = {
@@ -18395,20 +18074,20 @@ function createImageTransformTools(controller) {
       required: ["turn"],
       additionalProperties: false
     },
-    annotations: { title: "Rotate a layer by quarter turns", ...WRITE6 },
+    annotations: { title: "Rotate a layer by quarter turns", ...WRITE5 },
     handler: (args) => summary2(controller.rotateLayer90(args.turn, targetFrom(args)))
   };
   return [getFrame, transformLayer, warpLayer, transformSelection, flipLayer, rotate90];
 }
 
 // src/image-editor/smart-tools.ts
-var READ9 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE7 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
-var WRITE_IDEMPOTENT4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var DESTRUCTIVE5 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var READ8 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT3 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE4 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var round5 = (n, digits = 3) => Math.round(n * 10 ** digits) / 10 ** digits;
 var roundPoint2 = (p) => ({ x: round5(p.x), y: round5(p.y) });
-var LAYER_ID4 = { type: "string", description: "Smart object layer id from list_layers (type smart)." };
+var LAYER_ID3 = { type: "string", description: "Smart object layer id from list_layers (type smart)." };
 var FILTER_ID = { type: "string", description: "Smart filter id from get_smart_object or add_smart_filter." };
 var POINT2 = {
   type: "object",
@@ -18460,8 +18139,8 @@ function createImageSmartObjectTools(controller) {
     name: "get_smart_object",
     title: "Read a smart object",
     description: "Returns a smart object\u2019s contents (id shared by linked instances, name, kind raster or document, pixel size, the file type it came from, the instances placed from it), its placement (corners in document pixels, warp mesh in contents pixels, interpolation, and scale / rotate / skew in percent and degrees of the contents\u2019 own size when affine), its smart filters bottom to top (ids, kind, settings, enabled, blend, opacity; kind psd marks a Photoshop filter kept but not drawn) with the filter mask, and the rendered bounds. Changes nothing.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Read a smart object", ...READ9 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Read a smart object", ...READ8 },
     handler: ({ layerId }) => info(smartId(layerId))
   };
   const convert = {
@@ -18476,7 +18155,7 @@ function createImageSmartObjectTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Convert to Smart Object", ...WRITE7 },
+    annotations: { title: "Convert to Smart Object", ...WRITE6 },
     handler: ({ layerIds, name }) => {
       for (const id2 of layerIds ?? []) requireLayer(controller.getLayers(), id2);
       const id = controller.convertToSmartObject(layerIds, { name });
@@ -18487,8 +18166,8 @@ function createImageSmartObjectTools(controller) {
     name: "rasterize_smart_object",
     title: "Rasterize a smart object",
     description: "Layer \u203A Smart Objects \u203A Rasterize: the smart object becomes a pixel layer holding what it shows now (smart filters baked; same id, mask, effects, opacity, blend and fill). The contents, placement and filters are gone, so later transforms resample the pixels. One undo step. Returns the layer.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Rasterize a smart object", ...DESTRUCTIVE5 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Rasterize a smart object", ...DESTRUCTIVE4 },
     handler: ({ layerId }) => ({ layer: layerSummary(controller.rasterizeSmartObject(smartId(layerId))) })
   };
   const setTransform = {
@@ -18498,7 +18177,7 @@ function createImageSmartObjectTools(controller) {
     inputSchema: {
       type: "object",
       properties: {
-        layerId: LAYER_ID4,
+        layerId: LAYER_ID3,
         corners: { type: "array", items: POINT2, minItems: 4, maxItems: 4, description: "Where the contents\u2019 corners land: [top-left, top-right, bottom-right, bottom-left] in document pixels. The quad must stay convex." },
         matrix: { type: "array", items: { type: "number" }, minItems: 6, maxItems: 6, description: "Affine map from contents pixels to document pixels [a, b, c, d, e, f] (x' = a\xB7x + c\xB7y + e, y' = b\xB7x + d\xB7y + f)." },
         scaleX: { type: "number", description: "Width in percent of the contents\u2019 own width (negative flips)." },
@@ -18541,7 +18220,7 @@ function createImageSmartObjectTools(controller) {
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Set a smart object\u2019s transform", ...WRITE_IDEMPOTENT4 },
+    annotations: { title: "Set a smart object\u2019s transform", ...WRITE_IDEMPOTENT3 },
     handler: (args) => {
       const id = smartId(args.layerId);
       let warp;
@@ -18580,22 +18259,22 @@ function createImageSmartObjectTools(controller) {
     inputSchema: {
       type: "object",
       properties: {
-        layerId: LAYER_ID4,
+        layerId: LAYER_ID3,
         image: { type: "string", description: "The new contents: a PNG as a data URL or base64 (other formats and URLs need a browser)." },
         name: { type: "string", description: "File name of the contents (default the old name with .png)." }
       },
       required: ["layerId", "image"],
       additionalProperties: false
     },
-    annotations: { title: "Replace a smart object\u2019s contents", ...DESTRUCTIVE5 },
+    annotations: { title: "Replace a smart object\u2019s contents", ...DESTRUCTIVE4 },
     handler: async ({ layerId, image, name }) => controller.replaceSmartObjectContentsFromImage(smartId(layerId), imageArg(image), name)
   };
   const exportContents = {
     name: "export_smart_object_contents",
     title: "Export a smart object\u2019s contents",
     description: "Layer \u203A Smart Objects \u203A Export Contents: the contents as a file, base64: the file they came from while unedited (a PSB, PNG, JPEG\u2026), else a PNG for raster contents or a PSD / PSB of a nested document. Returns name, mimeType, byteLength and base64. Changes nothing.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Export a smart object\u2019s contents", ...READ9 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Export a smart object\u2019s contents", ...READ8 },
     handler: ({ layerId }) => {
       const f = controller.exportSmartObjectContents(smartId(layerId));
       return { name: f.name, mimeType: f.mimeType, byteLength: f.bytes.length, base64: bytesToBase64(f.bytes) };
@@ -18608,14 +18287,14 @@ function createImageSmartObjectTools(controller) {
     inputSchema: {
       type: "object",
       properties: {
-        layerId: LAYER_ID4,
+        layerId: LAYER_ID3,
         linked: { type: "boolean", description: "true shares the contents with the original; false (default) makes independent contents." },
         name: { type: "string", description: 'Name of the copy (default "<name> copy").' }
       },
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Copy a smart object", ...WRITE7 },
+    annotations: { title: "Copy a smart object", ...WRITE6 },
     handler: ({ layerId, linked, name }) => {
       const id = controller.copySmartObject(smartId(layerId), linked === true, name);
       return { layer: layerSummary(id), contentsId: controller.getSmartObject(id).contents.id };
@@ -18625,8 +18304,8 @@ function createImageSmartObjectTools(controller) {
     name: "edit_smart_object_contents",
     title: "Edit a smart object\u2019s contents",
     description: 'Layer \u203A Smart Objects \u203A Edit Contents: opens the contents as a document of their own (a layer document, or raster contents as one pixel layer "Layer 0") with their own undo history. Every other tool (list_layers, paint, adjustments\u2026) then works inside the contents until close_smart_object_contents saves them back. Contents can nest. Returns the contents\u2019 size and layers.',
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Edit a smart object\u2019s contents", ...WRITE7 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Edit a smart object\u2019s contents", ...WRITE6 },
     handler: ({ layerId }) => {
       const res = controller.editSmartObjectContents(smartId(layerId));
       const s = controller.getState();
@@ -18642,7 +18321,7 @@ function createImageSmartObjectTools(controller) {
       properties: { save: { type: "boolean", description: "true (default) saves the edits into the smart object; false discards them." } },
       additionalProperties: false
     },
-    annotations: { title: "Close a smart object\u2019s contents", ...WRITE7 },
+    annotations: { title: "Close a smart object\u2019s contents", ...WRITE6 },
     handler: ({ save }) => ({ ...controller.closeSmartObjectContents(save !== false), editing: controller.getEditingContents() })
   };
   const addFilter = {
@@ -18652,7 +18331,7 @@ function createImageSmartObjectTools(controller) {
     inputSchema: {
       type: "object",
       properties: {
-        layerId: LAYER_ID4,
+        layerId: LAYER_ID3,
         kind: { type: "string", enum: ["develop", "blur"], description: "Filter kind." },
         index: { type: "integer", minimum: 0, description: "Position in the stack, 0 = bottom, applied first (default the top)." },
         useSelection: { type: "boolean", description: "With a selection, set the filter mask from it so the filter only changes the selected area (default true)." },
@@ -18661,7 +18340,7 @@ function createImageSmartObjectTools(controller) {
       required: ["layerId", "kind"],
       additionalProperties: false
     },
-    annotations: { title: "Add a smart filter", ...WRITE7 },
+    annotations: { title: "Add a smart filter", ...WRITE6 },
     handler: (args) => {
       const id = smartId(args.layerId);
       const masked = args.useSelection !== false && controller.hasSelection;
@@ -18675,11 +18354,11 @@ function createImageSmartObjectTools(controller) {
     description: "Changes one smart filter: its settings, enabled, blend or opacity (only the given values; the kind cannot change). A Photoshop filter kept from a PSD (kind psd) only takes enabled, blend and opacity. One undo step. Returns the filter and the stack.",
     inputSchema: {
       type: "object",
-      properties: { layerId: LAYER_ID4, filterId: FILTER_ID, ...FILTER_SETTINGS },
+      properties: { layerId: LAYER_ID3, filterId: FILTER_ID, ...FILTER_SETTINGS },
       required: ["layerId", "filterId"],
       additionalProperties: false
     },
-    annotations: { title: "Change a smart filter", ...WRITE_IDEMPOTENT4 },
+    annotations: { title: "Change a smart filter", ...WRITE_IDEMPOTENT3 },
     handler: (args) => {
       const id = smartId(args.layerId);
       const changes = settingsFrom(args);
@@ -18692,8 +18371,8 @@ function createImageSmartObjectTools(controller) {
     name: "remove_smart_filter",
     title: "Remove a smart filter",
     description: "Removes one smart filter (the filter mask goes with the last one). One undo step. Returns the remaining stack.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID4, filterId: FILTER_ID }, required: ["layerId", "filterId"], additionalProperties: false },
-    annotations: { title: "Remove a smart filter", ...DESTRUCTIVE5 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID3, filterId: FILTER_ID }, required: ["layerId", "filterId"], additionalProperties: false },
+    annotations: { title: "Remove a smart filter", ...DESTRUCTIVE4 },
     handler: ({ layerId, filterId }) => {
       const id = smartId(layerId);
       controller.removeSmartFilter(id, filterId);
@@ -18706,11 +18385,11 @@ function createImageSmartObjectTools(controller) {
     description: "Moves one smart filter to a position in the stack (0 = bottom, applied first), as dragging it in the Layers panel. One undo step. Returns the stack in its new order.",
     inputSchema: {
       type: "object",
-      properties: { layerId: LAYER_ID4, filterId: FILTER_ID, index: { type: "integer", minimum: 0, description: "New position, 0 = bottom (applied first)." } },
+      properties: { layerId: LAYER_ID3, filterId: FILTER_ID, index: { type: "integer", minimum: 0, description: "New position, 0 = bottom (applied first)." } },
       required: ["layerId", "filterId", "index"],
       additionalProperties: false
     },
-    annotations: { title: "Reorder a smart filter", ...WRITE_IDEMPOTENT4 },
+    annotations: { title: "Reorder a smart filter", ...WRITE_IDEMPOTENT3 },
     handler: ({ layerId, filterId, index }) => {
       const id = smartId(layerId);
       controller.moveSmartFilter(id, filterId, index);
@@ -18723,11 +18402,11 @@ function createImageSmartObjectTools(controller) {
     description: "Layer \u203A Smart Filter \u203A Disable / Enable Smart Filters: switches the whole stack; each filter keeps its own enabled flag. One undo step. Returns the stack.",
     inputSchema: {
       type: "object",
-      properties: { layerId: LAYER_ID4, enabled: { type: "boolean", description: "false hides every smart filter; true shows them again." } },
+      properties: { layerId: LAYER_ID3, enabled: { type: "boolean", description: "false hides every smart filter; true shows them again." } },
       required: ["layerId", "enabled"],
       additionalProperties: false
     },
-    annotations: { title: "Turn smart filters on or off", ...WRITE_IDEMPOTENT4 },
+    annotations: { title: "Turn smart filters on or off", ...WRITE_IDEMPOTENT3 },
     handler: ({ layerId, enabled }) => {
       const id = smartId(layerId);
       controller.setSmartFiltersEnabled(id, enabled === true);
@@ -18741,7 +18420,7 @@ function createImageSmartObjectTools(controller) {
     inputSchema: {
       type: "object",
       properties: {
-        layerId: LAYER_ID4,
+        layerId: LAYER_ID3,
         from: { type: "string", enum: ["reveal-all", "hide-all", "selection", "none", "keep"], description: "What the mask starts from; none removes it; keep only changes the properties below." },
         density: { type: "number", minimum: 0, maximum: 1, description: "How much hidden areas hide, 0..1 (default 1)." },
         feather: { type: "number", minimum: 0, maximum: 1e3, description: "Gaussian softening in px (default 0)." },
@@ -18751,7 +18430,7 @@ function createImageSmartObjectTools(controller) {
       required: ["layerId", "from"],
       additionalProperties: false
     },
-    annotations: { title: "Set the smart filter mask", ...WRITE7 },
+    annotations: { title: "Set the smart filter mask", ...WRITE6 },
     handler: (args) => {
       const id = smartId(args.layerId);
       const props = {};
@@ -18764,11 +18443,11 @@ function createImageSmartObjectTools(controller) {
 }
 
 // src/image-editor/shape-tools.ts
-var READ10 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE8 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
-var WRITE_IDEMPOTENT5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var DESTRUCTIVE6 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
-var LAYER_ID5 = { type: "string", description: "Shape layer id from list_layers (type shape) or add_shape_layer." };
+var READ9 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE7 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE5 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var LAYER_ID4 = { type: "string", description: "Shape layer id from list_layers (type shape) or add_shape_layer." };
 var COMPONENT_INDEX = { type: "integer", minimum: 0, description: "Component index from get_shape_layer (0 = bottom component)." };
 var OP = {
   type: "string",
@@ -18790,7 +18469,7 @@ var BOX = {
   height: NUM("Height in pixels."),
   transform: { $ref: "#/$defs/matrix" }
 };
-var DEFS2 = {
+var DEFS = {
   matrix: MATRIX,
   point: {
     type: "object",
@@ -19017,8 +18696,8 @@ function createImageShapeTools(controller) {
     name: "get_shape_layer",
     title: "Read a shape layer",
     description: "Returns a shape layer\u2019s components bottom to top (index, path operation, the live shape it was drawn as or null, its subpaths with absolute anchors and handles, bounds), the fill rule, fill and stroke paints and settings, the path bounds and the rendered bounds (stroke included). Changes nothing.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID5 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Read a shape layer", ...READ10 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Read a shape layer", ...READ9 },
     handler: ({ layerId }) => controller.getShapeLayer(shapeId(layerId))
   };
   const add2 = {
@@ -19027,7 +18706,7 @@ function createImageShapeTools(controller) {
     description: "Adds a vector shape layer and makes it active: a live shape (rect, ellipse, polygon, star, line), a free path (SVG path data or anchors), or several components combined with path operations. fill defaults to the foreground colour (none for an open path with a stroke); give stroke for an outline. It renders sharp at any size, can be moved and transformed without losing quality, and takes masks, effects, clipping and blend modes like any layer. Goes above the active layer unless placed. One undo step. Returns the layer and the shape.",
     inputSchema: {
       type: "object",
-      $defs: DEFS2,
+      $defs: DEFS,
       properties: {
         ...GEOMETRY2,
         components: {
@@ -19049,7 +18728,7 @@ function createImageShapeTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Add a shape layer", ...WRITE8 },
+    annotations: { title: "Add a shape layer", ...WRITE7 },
     handler: (args) => {
       const init = { ...geometry(args) };
       if (args.components !== void 0) init.components = args.components.map(geometry);
@@ -19067,9 +18746,9 @@ function createImageShapeTools(controller) {
     description: "Changes a shape layer\u2019s fill, stroke or fill rule and renders it again: fill replaces the fill (null removes it); stroke changes only the settings given (null removes the stroke; a new stroke needs width and paint). Geometry is untouched (set_shape_component edits paths). One undo step. Returns the shape.",
     inputSchema: {
       type: "object",
-      $defs: DEFS2,
+      $defs: DEFS,
       properties: {
-        layerId: LAYER_ID5,
+        layerId: LAYER_ID4,
         fill: { anyOf: [{ $ref: "#/$defs/paint" }, { type: "null", description: "No fill." }], description: "New fill paint, or null for none." },
         stroke: { anyOf: [{ $ref: "#/$defs/stroke" }, { type: "null", description: "No stroke." }], description: "Stroke settings to change, or null to remove the stroke." },
         fillRule: { type: "string", enum: ["nonzero", "evenodd"], description: "Winding rule within a component." }
@@ -19077,7 +18756,7 @@ function createImageShapeTools(controller) {
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Restyle a shape", ...WRITE_IDEMPOTENT5 },
+    annotations: { title: "Restyle a shape", ...WRITE_IDEMPOTENT4 },
     handler: ({ layerId, fill, stroke, fillRule }) => {
       const id = shapeId(layerId);
       if (fill === void 0 && stroke === void 0 && fillRule === void 0) throw new LayerOperationError("Give fill, stroke or fillRule to change.");
@@ -19090,9 +18769,9 @@ function createImageShapeTools(controller) {
     description: "Changes one component of a shape layer: shape sets its live shape (fields you leave out keep their values when the kind stays the same, e.g. only radii), subpaths replaces its path (which ends the live shape), op changes its path operation. Positions are document pixels. One undo step. Returns the shape.",
     inputSchema: {
       type: "object",
-      $defs: DEFS2,
+      $defs: DEFS,
       properties: {
-        layerId: LAYER_ID5,
+        layerId: LAYER_ID4,
         componentIndex: COMPONENT_INDEX,
         shape: {
           type: "object",
@@ -19125,7 +18804,7 @@ function createImageShapeTools(controller) {
       required: ["layerId", "componentIndex"],
       additionalProperties: false
     },
-    annotations: { title: "Edit a shape component", ...WRITE_IDEMPOTENT5 },
+    annotations: { title: "Edit a shape component", ...WRITE_IDEMPOTENT4 },
     handler: ({ layerId, componentIndex, ...rest }) => {
       const id = shapeId(layerId);
       const change = geometry(rest);
@@ -19139,28 +18818,28 @@ function createImageShapeTools(controller) {
     description: "Adds a component to a shape layer and combines it with the components below it by op: combine (union), subtract, intersect or exclude, as Photoshop\u2019s path operations. Goes on top unless index is given. One undo step. Returns the shape.",
     inputSchema: {
       type: "object",
-      $defs: DEFS2,
-      properties: { layerId: LAYER_ID5, ...GEOMETRY2, op: OP, index: { type: "integer", minimum: 0, description: "Position among the components, 0 = bottom (default the top)." } },
+      $defs: DEFS,
+      properties: { layerId: LAYER_ID4, ...GEOMETRY2, op: OP, index: { type: "integer", minimum: 0, description: "Position among the components, 0 = bottom (default the top)." } },
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Add a shape component", ...WRITE8 },
+    annotations: { title: "Add a shape component", ...WRITE7 },
     handler: ({ layerId, index, ...rest }) => controller.addShapeComponent(shapeId(layerId), geometry(rest), index)
   };
   const removeComponent = {
     name: "remove_shape_component",
     title: "Delete a shape component",
     description: "Deletes one component of a shape layer (the last one cannot go: delete the layer instead). One undo step. Returns the shape.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID5, componentIndex: COMPONENT_INDEX }, required: ["layerId", "componentIndex"], additionalProperties: false },
-    annotations: { title: "Delete a shape component", ...DESTRUCTIVE6 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID4, componentIndex: COMPONENT_INDEX }, required: ["layerId", "componentIndex"], additionalProperties: false },
+    annotations: { title: "Delete a shape component", ...DESTRUCTIVE5 },
     handler: ({ layerId, componentIndex }) => controller.removeShapeComponent(shapeId(layerId), componentIndex)
   };
   const merge = {
     name: "merge_shape_components",
     title: "Merge shape components",
     description: "Merge Shape Components: the area a shape\u2019s components combine to (after their path operations) becomes one plain component; live shapes become paths. The look is unchanged. One undo step. Returns the shape.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID5 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Merge shape components", ...DESTRUCTIVE6 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID4 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Merge shape components", ...DESTRUCTIVE5 },
     handler: ({ layerId }) => controller.mergeShapeComponents(shapeId(layerId))
   };
   const layerArg = (v) => {
@@ -19214,7 +18893,7 @@ function createImageShapeTools(controller) {
     title: "Make a path from the selection",
     description: "Make Work Path: traces the selection's outline (where it is at least half selected) into closed B\xE9zier subpaths in document pixels, holes included, within tolerance px. Changes nothing. Returns svg (compact SVG path data) and fillRule evenodd, ready for add_vector_mask, set_vector_mask_path or add_shape_layer (pass the svg as subpaths and fillRule evenodd), plus bounds and the anchor count. Use add_vector_mask from selection to do it in one step.",
     inputSchema: { type: "object", properties: { ...TRACE_PROPS, anchors: { type: "boolean", description: "Also return the subpaths as anchors with handles (default false: svg only)." } }, additionalProperties: false },
-    annotations: { title: "Make a path from the selection", ...READ10 },
+    annotations: { title: "Make a path from the selection", ...READ9 },
     handler: (args) => {
       const out = controller.selectionToPath(traceOptions(args));
       const { subpaths, ...rest } = out;
@@ -19227,7 +18906,7 @@ function createImageShapeTools(controller) {
     description: "Make Selection: fills a path (a live shape, free subpaths or SVG path data, or components, in document pixels, as add_shape_layer takes) into a selection, combined with the current one by mode, with feather px and antiAlias. Use it to select along B\xE9zier curves, or to turn a path from selection_to_path or get_vector_mask back into a selection. One undo step. Returns the selection.",
     inputSchema: {
       type: "object",
-      $defs: DEFS2,
+      $defs: DEFS,
       properties: {
         pathId: { ...PATH_ID, description: "A document path from list_paths, instead of shape / subpaths / components." },
         ...PATH_PROPS,
@@ -19237,7 +18916,7 @@ function createImageShapeTools(controller) {
       },
       additionalProperties: false
     },
-    annotations: { title: "Make a selection from a path", ...WRITE8 },
+    annotations: { title: "Make a selection from a path", ...WRITE7 },
     handler: (args) => {
       const mode = args.mode;
       controller.pathToSelection(fromPathId(args) ?? pathSpec(args), { feather: args.feather, antiAlias: args.antiAlias, mode });
@@ -19250,7 +18929,7 @@ function createImageShapeTools(controller) {
     title: "Read a vector mask",
     description: "Reads a layer's vector mask: enabled, linked, inverted, fill rule, density, feather, the bounds of its path and its components (op, live shape, subpaths in document pixels). Use it before set_vector_mask_path to edit the path. Returns null when the layer has none.",
     inputSchema: { type: "object", properties: { layerId: LAYER }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Read a vector mask", ...READ10 },
+    annotations: { title: "Read a vector mask", ...READ9 },
     handler: ({ layerId }) => ({ vectorMask: controller.getVectorMask(layerArg(layerId)) })
   };
   const addVectorMask = {
@@ -19259,7 +18938,7 @@ function createImageShapeTools(controller) {
     description: "Layer \u203A Vector Mask: a path that reveals the layer inside it and stays sharp at any size, on top of any raster mask (both apply). from path takes a live shape, free subpaths or components like add_shape_layer; from selection traces the current selection (within tolerance px); reveal-all and hide-all start with an empty path. Use it for hard-edged geometric or traced cutouts that must stay editable; use add_layer_mask for soft or painted ones. A linked vector mask moves and transforms with the layer. Replaces an existing vector mask. One undo step. Returns the vector mask.",
     inputSchema: {
       type: "object",
-      $defs: DEFS2,
+      $defs: DEFS,
       properties: {
         layerId: LAYER,
         from: { type: "string", enum: ["path", "selection", "reveal-all", "hide-all"], description: "path (default when a shape, subpaths, components or pathId are given), selection (trace the current selection), reveal-all or hide-all (an empty path)." },
@@ -19270,7 +18949,7 @@ function createImageShapeTools(controller) {
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Add a vector mask", ...WRITE8 },
+    annotations: { title: "Add a vector mask", ...WRITE7 },
     handler: (args) => {
       const id = layerArg(args.layerId);
       const spec = fromPathId(args) ?? pathSpec(args);
@@ -19285,8 +18964,8 @@ function createImageShapeTools(controller) {
     name: "set_vector_mask_path",
     title: "Replace a vector mask path",
     description: "Replaces the path of a layer's vector mask (shape, subpaths or components, document pixels); enabled, linked, inverted, density and feather are kept. Read the current path with get_vector_mask first to change part of it. One undo step. Returns the vector mask.",
-    inputSchema: { type: "object", $defs: DEFS2, properties: { layerId: LAYER, ...PATH_PROPS }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Replace a vector mask path", ...WRITE_IDEMPOTENT5 },
+    inputSchema: { type: "object", $defs: DEFS, properties: { layerId: LAYER, ...PATH_PROPS }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Replace a vector mask path", ...WRITE_IDEMPOTENT4 },
     handler: (args) => {
       const id = layerArg(args.layerId);
       controller.setVectorMaskPath(id, pathSpec(args));
@@ -19310,7 +18989,7 @@ function createImageShapeTools(controller) {
       required: ["layerId"],
       additionalProperties: false
     },
-    annotations: { title: "Set vector mask properties", ...WRITE_IDEMPOTENT5 },
+    annotations: { title: "Set vector mask properties", ...WRITE_IDEMPOTENT4 },
     handler: ({ layerId, ...props }) => {
       const id = layerArg(layerId);
       controller.setVectorMaskProps(id, props);
@@ -19336,7 +19015,7 @@ function createImageShapeTools(controller) {
       required: ["layerId", "component", "subpath", "segment", "mode"],
       additionalProperties: false
     },
-    annotations: { title: "Set a vector mask segment's edge", ...WRITE_IDEMPOTENT5 },
+    annotations: { title: "Set a vector mask segment's edge", ...WRITE_IDEMPOTENT4 },
     handler: ({ layerId, component, subpath, segment, mode, radius, inner, outer }) => {
       const id = layerArg(layerId);
       const vectorMask = controller.setVectorMaskEdge(
@@ -19353,7 +19032,7 @@ function createImageShapeTools(controller) {
     title: "Rasterize a vector mask",
     description: "Layer \u203A Rasterize \u203A Vector Mask: multiplies the path (with its density and feather) into the layer's raster mask, adding one if needed, and removes the vector mask, so the mask can be painted. The path can no longer be edited (undo_image brings it back). One undo step. Returns the layer's raster mask summary.",
     inputSchema: { type: "object", properties: { layerId: LAYER }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Rasterize a vector mask", ...DESTRUCTIVE6 },
+    annotations: { title: "Rasterize a vector mask", ...DESTRUCTIVE5 },
     handler: ({ layerId }) => {
       const id = layerArg(layerId);
       const mask = controller.rasterizeVectorMask(id);
@@ -19365,7 +19044,7 @@ function createImageShapeTools(controller) {
     title: "Delete a vector mask",
     description: "Deletes a layer's vector mask without applying it (the raster mask, if any, stays). Disable it instead with set_vector_mask_properties enabled false to keep it. One undo step. Returns the layer id.",
     inputSchema: { type: "object", properties: { layerId: LAYER }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Delete a vector mask", ...DESTRUCTIVE6 },
+    annotations: { title: "Delete a vector mask", ...DESTRUCTIVE5 },
     handler: ({ layerId }) => {
       const id = layerArg(layerId);
       controller.removeVectorMask(id);
@@ -19377,15 +19056,15 @@ function createImageShapeTools(controller) {
     title: "List document paths",
     description: "Paths panel: the document's saved paths and its Work Path (paths kept with the document, on no layer), each with id, name, work (true for the Work Path, which the next make_work_path replaces), fill rule, anchor count and bounds, and which is active. Use the ids with path_to_selection, add_vector_mask, fill_path, stroke_path and the other path tools.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "List document paths", ...READ10 },
+    annotations: { title: "List document paths", ...READ9 },
     handler: () => ({ paths: controller.getPaths().map((p) => pathSummary(p.id)), activePathId: controller.getState().activePathId ?? null })
   };
-  const getPath2 = {
+  const getPath = {
     name: "get_path",
     title: "Read a document path",
     description: "Reads a document path: its summary, svg (compact SVG path data) and components (op, subpaths of anchors with handles, in document pixels), ready to edit and pass back to set_path_geometry.",
     inputSchema: { type: "object", properties: { pathId: PATH_ID }, required: ["pathId"], additionalProperties: false },
-    annotations: { title: "Read a document path", ...READ10 },
+    annotations: { title: "Read a document path", ...READ9 },
     handler: ({ pathId }) => {
       const p = controller.getPath(String(pathId));
       if (!p) throw new Error(`No path "${String(pathId)}". Call list_paths for ids.`);
@@ -19397,7 +19076,7 @@ function createImageShapeTools(controller) {
     title: "Make a work path from the selection",
     description: "Paths \u203A Make Work Path: traces the selection's outline (within tolerance px) into the Work Path, replacing the last Work Path unless it was saved (rename_path saves it). Use it to keep a selection as an editable, resolution-independent outline. One undo step. Returns the path.",
     inputSchema: { type: "object", properties: { ...TRACE_PROPS }, additionalProperties: false },
-    annotations: { title: "Make a work path from the selection", ...WRITE8 },
+    annotations: { title: "Make a work path from the selection", ...WRITE7 },
     handler: (args) => ({ path: pathSummary(controller.makeWorkPath(traceOptions(args)).id) })
   };
   const addPath = {
@@ -19406,11 +19085,11 @@ function createImageShapeTools(controller) {
     description: "Adds a saved document path from a live shape, free subpaths or SVG path data, or components (document pixels), as add_shape_layer takes them. One undo step. Returns the path.",
     inputSchema: {
       type: "object",
-      $defs: DEFS2,
+      $defs: DEFS,
       properties: { name: { type: "string", description: 'The path name (default "Path n").' }, ...PATH_PROPS },
       additionalProperties: false
     },
-    annotations: { title: "Add a document path", ...WRITE8 },
+    annotations: { title: "Add a document path", ...WRITE7 },
     handler: (args) => {
       const spec = pathSpec(args);
       if (!spec.components?.length && spec.shape === void 0 && spec.subpaths === void 0) throw new Error("Give the path as shape, subpaths or components.");
@@ -19421,8 +19100,8 @@ function createImageShapeTools(controller) {
     name: "set_path_geometry",
     title: "Replace a document path",
     description: "Replaces a document path's geometry (shape, subpaths or components, document pixels); its name is kept. Read it with get_path first to change part of it. One undo step. Returns the path.",
-    inputSchema: { type: "object", $defs: DEFS2, properties: { pathId: PATH_ID, ...PATH_PROPS }, required: ["pathId"], additionalProperties: false },
-    annotations: { title: "Replace a document path", ...WRITE_IDEMPOTENT5 },
+    inputSchema: { type: "object", $defs: DEFS, properties: { pathId: PATH_ID, ...PATH_PROPS }, required: ["pathId"], additionalProperties: false },
+    annotations: { title: "Replace a document path", ...WRITE_IDEMPOTENT4 },
     handler: (args) => ({ path: pathSummary(controller.setPathGeometry(String(args.pathId), pathSpec(args)).id) })
   };
   const renamePath = {
@@ -19430,7 +19109,7 @@ function createImageShapeTools(controller) {
     title: "Rename or save a path",
     description: "Renames a document path. Renaming the Work Path saves it (Paths \u203A Save Path), so make_work_path no longer replaces it. One undo step. Returns the path.",
     inputSchema: { type: "object", properties: { pathId: PATH_ID, name: { type: "string", minLength: 1, description: "The new name." } }, required: ["pathId", "name"], additionalProperties: false },
-    annotations: { title: "Rename or save a path", ...WRITE_IDEMPOTENT5 },
+    annotations: { title: "Rename or save a path", ...WRITE_IDEMPOTENT4 },
     handler: ({ pathId, name }) => ({ path: pathSummary(controller.renamePath(String(pathId), String(name)).id) })
   };
   const duplicatePath = {
@@ -19438,7 +19117,7 @@ function createImageShapeTools(controller) {
     title: "Duplicate a path",
     description: 'Duplicates a document path as a saved path (default name "<name> copy"). One undo step. Returns the new path.',
     inputSchema: { type: "object", properties: { pathId: PATH_ID, name: { type: "string", description: "The copy's name." } }, required: ["pathId"], additionalProperties: false },
-    annotations: { title: "Duplicate a path", ...WRITE8 },
+    annotations: { title: "Duplicate a path", ...WRITE7 },
     handler: ({ pathId, name }) => ({ path: pathSummary(controller.duplicatePath(String(pathId), name).id) })
   };
   const deletePath = {
@@ -19446,7 +19125,7 @@ function createImageShapeTools(controller) {
     title: "Delete a path",
     description: "Deletes a document path (undo_image brings it back). Returns the remaining paths.",
     inputSchema: { type: "object", properties: { pathId: PATH_ID }, required: ["pathId"], additionalProperties: false },
-    annotations: { title: "Delete a path", ...DESTRUCTIVE6 },
+    annotations: { title: "Delete a path", ...DESTRUCTIVE5 },
     handler: ({ pathId }) => {
       controller.deletePath(String(pathId));
       return { paths: controller.getPaths().map((p) => pathSummary(p.id)) };
@@ -19462,7 +19141,7 @@ function createImageShapeTools(controller) {
     title: "Fill a path",
     description: "Paths \u203A Fill Path: fills the area a document path encloses on a pixel layer with a colour. The selection is not changed. One undo step. Returns what was painted.",
     inputSchema: { type: "object", properties: { pathId: PATH_ID, ...PAINT_PROPS }, required: ["pathId"], additionalProperties: false },
-    annotations: { title: "Fill a path", ...WRITE8 },
+    annotations: { title: "Fill a path", ...WRITE7 },
     handler: (args) => controller.fillPath(String(args.pathId), { layerId: args.layerId, color: args.color, opacity: args.opacity })
   };
   const strokePath = {
@@ -19475,7 +19154,7 @@ function createImageShapeTools(controller) {
       required: ["pathId", "width"],
       additionalProperties: false
     },
-    annotations: { title: "Stroke a path", ...WRITE8 },
+    annotations: { title: "Stroke a path", ...WRITE7 },
     handler: (args) => controller.strokePath(String(args.pathId), { width: args.width, layerId: args.layerId, color: args.color, opacity: args.opacity })
   };
   return [
@@ -19496,7 +19175,7 @@ function createImageShapeTools(controller) {
     selectionToPath,
     pathToSelection2,
     listPaths,
-    getPath2,
+    getPath,
     makeWorkPath,
     addPath,
     setPathGeometry,
@@ -19509,11 +19188,11 @@ function createImageShapeTools(controller) {
 }
 
 // src/image-editor/type-tools.ts
-var READ11 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var WRITE9 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
-var WRITE_IDEMPOTENT6 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
-var DESTRUCTIVE7 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
-var LAYER_ID6 = { type: "string", description: "Type layer id from list_layers (type type) or add_text_layer." };
+var READ10 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE8 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT5 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE6 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var LAYER_ID5 = { type: "string", description: "Type layer id from list_layers (type type) or add_text_layer." };
 var START = { type: "integer", minimum: 0, description: "Start of the range in UTF-16 code units, as get_text_layer counts them (default 0)." };
 var END = { type: "integer", minimum: 0, description: "End of the range, exclusive (default the end of the text)." };
 var STYLE = {
@@ -19566,15 +19245,15 @@ function createImageTypeTools(controller) {
     title: "List fonts",
     description: "Returns the font families type layers can use here (generic families such as sans-serif always work). Changes nothing.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "List fonts", ...READ11 },
+    annotations: { title: "List fonts", ...READ10 },
     handler: () => ({ families: controller.listFonts(), shaper: controller.getTextShaper()?.id ?? null })
   };
   const get = {
     name: "get_text_layer",
     title: "Read a type layer",
     description: "Returns a type layer\u2019s text, its character runs and paragraphs as [start, end) ranges in UTF-16 code units with their styles, the frame (point text, or a paragraph box with its size), the orientation (horizontal or vertical), the text-to-document transform, the laid-out lines (range, baseline, width), the rendered bounds, missing fonts and whether the pixels are live or stored from a file. Call before editing text you did not write, to get the ranges. Changes nothing.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID6 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Read a type layer", ...READ11 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID5 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Read a type layer", ...READ10 },
     handler: ({ layerId }) => controller.getTextLayer(typeId(layerId))
   };
   const add2 = {
@@ -19609,7 +19288,7 @@ function createImageTypeTools(controller) {
       required: ["text", "x", "y"],
       additionalProperties: false
     },
-    annotations: { title: "Add a type layer", ...WRITE9 },
+    annotations: { title: "Add a type layer", ...WRITE8 },
     handler: (args) => {
       const init = pick2(args, ["text", "x", "y", "box", "style", "paragraph", "orientation", "rotation", "name", "opacity", "blend", "aboveId", "belowId", "parentId", "index"]);
       if (init.blend !== void 0) init.blend = init.blend;
@@ -19621,16 +19300,16 @@ function createImageTypeTools(controller) {
     name: "set_text",
     title: "Edit text",
     description: "Replaces the text in [start, end) (default all of it) with text; inserted text takes the style of the character at start. Use start = end to insert. Returns the text layer with its new runs.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID6, text: { type: "string", description: "Replacement text (\\n starts a paragraph; empty deletes the range)." }, start: START, end: END }, required: ["layerId", "text"], additionalProperties: false },
-    annotations: { title: "Edit text", ...WRITE9 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID5, text: { type: "string", description: "Replacement text (\\n starts a paragraph; empty deletes the range)." }, start: START, end: END }, required: ["layerId", "text"], additionalProperties: false },
+    annotations: { title: "Edit text", ...WRITE8 },
     handler: (args) => controller.setText(typeId(args.layerId), args.text, range(args))
   };
   const setStyle = {
     name: "set_text_style",
     title: "Style a range of text",
     description: "Sets character style fields (font, weight, italic, size, colour, tracking, leading, baseline shift, underline, strike-through) over [start, end) of a type layer (default all of it); fields not given keep their values per run. Returns the text layer with its runs and missingFonts.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID6, start: START, end: END, ...STYLE }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Style a range of text", ...WRITE_IDEMPOTENT6 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID5, start: START, end: END, ...STYLE }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Style a range of text", ...WRITE_IDEMPOTENT5 },
     handler: (args) => {
       const style = pick2(args, Object.keys(STYLE));
       if (!Object.keys(style).length) throw new LayerOperationError(`Give at least one style field: ${Object.keys(STYLE).join(", ")}.`);
@@ -19641,8 +19320,8 @@ function createImageTypeTools(controller) {
     name: "set_paragraph_style",
     title: "Style paragraphs",
     description: "Sets paragraph fields (alignment, auto leading, indents, spacing) on every paragraph that [start, end) touches (default all). Returns the text layer.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID6, start: START, end: END, ...PARAGRAPH }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Style paragraphs", ...WRITE_IDEMPOTENT6 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID5, start: START, end: END, ...PARAGRAPH }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Style paragraphs", ...WRITE_IDEMPOTENT5 },
     handler: (args) => {
       const style = pick2(args, Object.keys(PARAGRAPH));
       if (!Object.keys(style).length) throw new LayerOperationError(`Give at least one paragraph field: ${Object.keys(PARAGRAPH).join(", ")}.`);
@@ -19656,7 +19335,7 @@ function createImageTypeTools(controller) {
     inputSchema: {
       type: "object",
       properties: {
-        layerId: LAYER_ID6,
+        layerId: LAYER_ID5,
         kind: { type: "string", enum: ["point", "box"], description: "point or box." },
         width: { type: "number", minimum: 1, description: "Box width in pixels (kind box)." },
         height: { type: "number", minimum: 1, description: "Box height in pixels (kind box)." }
@@ -19664,7 +19343,7 @@ function createImageTypeTools(controller) {
       required: ["layerId", "kind"],
       additionalProperties: false
     },
-    annotations: { title: "Point or paragraph text", ...WRITE_IDEMPOTENT6 },
+    annotations: { title: "Point or paragraph text", ...WRITE_IDEMPOTENT5 },
     handler: ({ layerId, kind, width, height }) => {
       const id = typeId(layerId);
       if (kind === "box" && (width === void 0 || height === void 0)) throw new LayerOperationError("kind box needs width and height in pixels.");
@@ -19675,16 +19354,16 @@ function createImageTypeTools(controller) {
     name: "set_text_orientation",
     title: "Horizontal or vertical type",
     description: "Type \u203A Orientation: sets a type layer horizontal (lines left to right) or vertical (columns top to bottom, right to left). The text, styles, frame and origin stay. One undo step. Returns the text layer with its orientation and new lines (columns).",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID6, orientation: { ...ORIENTATION, description: "horizontal or vertical." } }, required: ["layerId", "orientation"], additionalProperties: false },
-    annotations: { title: "Horizontal or vertical type", ...WRITE_IDEMPOTENT6 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID5, orientation: { ...ORIENTATION, description: "horizontal or vertical." } }, required: ["layerId", "orientation"], additionalProperties: false },
+    annotations: { title: "Horizontal or vertical type", ...WRITE_IDEMPOTENT5 },
     handler: ({ layerId, orientation }) => controller.setTextOrientation(typeId(layerId), orientation)
   };
   const toShape = {
     name: "convert_text_to_shape",
     title: "Convert text to a shape",
     description: "Type \u203A Convert to Shape: the text\u2019s glyph outlines become a shape layer (same id, name, mask, effects, opacity, blend) that can be edited with the shape tools; the text is no longer editable. Needs a font shaper that gives outlines (the browser\u2019s canvas cannot). The fill is the first run\u2019s colour. One undo step. Returns the layer and warnings.",
-    inputSchema: { type: "object", properties: { layerId: LAYER_ID6 }, required: ["layerId"], additionalProperties: false },
-    annotations: { title: "Convert text to a shape", ...DESTRUCTIVE7 },
+    inputSchema: { type: "object", properties: { layerId: LAYER_ID5 }, required: ["layerId"], additionalProperties: false },
+    annotations: { title: "Convert text to a shape", ...DESTRUCTIVE6 },
     handler: ({ layerId }) => {
       const { layerId: id, warnings } = controller.convertTextToShape(typeId(layerId));
       return { layer: layerSummary(id), shape: controller.getShapeLayer(id), warnings };
@@ -19718,7 +19397,7 @@ function createImageTypeTools(controller) {
       required: ["text", "x", "y"],
       additionalProperties: false
     },
-    annotations: { title: "Select the shape of text", ...WRITE9 },
+    annotations: { title: "Select the shape of text", ...WRITE8 },
     handler: (args) => {
       const init = pick2(args, ["text", "x", "y", "orientation", "box", "style", "paragraph", "rotation", "mode", "feather", "antiAlias"]);
       controller.selectTextShape(init);
@@ -20231,12 +19910,12 @@ var SelectAndMaskSession = class {
     this.recompute();
   }
   rescale() {
-    const px2 = this.pixels;
-    if (!px2) return;
-    const s = this.settingsValue.highQuality ? 1 : Math.min(1, PREVIEW_SIZE / Math.max(px2.width, px2.height));
-    const w = Math.max(1, Math.round(px2.width * s));
-    const h = Math.max(1, Math.round(px2.height * s));
-    this.previewPixels = scalePixels(px2, w, h);
+    const px = this.pixels;
+    if (!px) return;
+    const s = this.settingsValue.highQuality ? 1 : Math.min(1, PREVIEW_SIZE / Math.max(px.width, px.height));
+    const w = Math.max(1, Math.round(px.width * s));
+    const h = Math.max(1, Math.round(px.height * s));
+    this.previewPixels = scalePixels(px, w, h);
     this.belowPreview = this.below ? scalePixels(this.below, w, h) : null;
     this.baseMask = this.base?.bounds ? s === 1 ? this.base : resizeSelection(this.base, w, h) : null;
   }
@@ -20245,8 +19924,8 @@ var SelectAndMaskSession = class {
    * the page, or in the worker, where one job runs at a time and the newest state follows it.
    */
   recompute() {
-    const px2 = this.previewPixels;
-    if (!px2) return;
+    const px = this.previewPixels;
+    if (!px) return;
     this.note = this.settingsValue.refineMode === "object" ? "Object aware refinement asks the segmentation model on OK; the preview refines by colour." : null;
     if (this.controller.hasSelectionWorker) {
       void this.recomputeInWorker();
@@ -20255,8 +19934,8 @@ var SelectAndMaskSession = class {
     const { scale } = this.previewSize;
     const edits = [...this.editsList, ...this.live ? [this.live] : []].map((e) => scaleEdit(e, scale));
     try {
-      const { selection, refineBrush } = applyRefineEdits(px2, this.baseMask, edits, px2.width, px2.height);
-      this.previewMask = selection?.bounds ? refineSelection(px2, selection, scaleParams(this.settingsValue.params, scale), refineBrush) : null;
+      const { selection, refineBrush } = applyRefineEdits(px, this.baseMask, edits, px.width, px.height);
+      this.previewMask = selection?.bounds ? refineSelection(px, selection, scaleParams(this.settingsValue.params, scale), refineBrush) : null;
       this.error = null;
     } catch (err) {
       this.previewMask = null;
@@ -20272,13 +19951,13 @@ var SelectAndMaskSession = class {
     this.computing = true;
     do {
       this.dirty = false;
-      const px2 = this.previewPixels;
+      const px = this.previewPixels;
       const { scale } = this.previewSize;
       const edits = [...this.editsList, ...this.live ? [this.live] : []].map((e) => scaleEdit(e, scale));
       try {
         const { mask } = await this.controller.runSelectionJob(
           { op: "refine-preview", base: this.baseMask ? serializeMask(this.baseMask) : null, edits, params: scaleParams(this.settingsValue.params, scale) },
-          px2
+          px
         );
         this.previewMask = mask.bounds ? mask : null;
         this.error = null;
@@ -20306,9 +19985,9 @@ var SelectAndMaskSession = class {
   }
   /** The preview drawn in the current view mode: RGBA at {@link previewSize}. */
   render() {
-    const px2 = this.previewPixels;
-    if (!px2) return new Uint8ClampedArray(0);
-    const { width: w, height: h } = px2;
+    const px = this.previewPixels;
+    if (!px) return new Uint8ClampedArray(0);
+    const { width: w, height: h } = px;
     const n = w * h;
     const s = this.settingsValue;
     const mask = (s.showOriginal ? this.baseMask : this.previewMask) ?? createSelectionMask(w, h);
@@ -20330,9 +20009,9 @@ var SelectAndMaskSession = class {
     for (let i = 0; i < n; i++) {
       const a = m[i] / 255;
       const p = i * 4;
-      const r = px2.data[p];
-      const g = px2.data[p + 1];
-      const b = px2.data[p + 2];
+      const r = px.data[p];
+      const g = px.data[p + 1];
+      const b = px.data[p + 2];
       let o;
       const x = i % w;
       const y = (i - x) / w;
@@ -20559,8 +20238,8 @@ function applyRegionMosaic(imageData, regions2, blockSize = 12) {
         const count = bw * bh;
         for (let py = by; py < by + bh; py++) {
           const rowOffset = py * width;
-          for (let px2 = bx; px2 < bx + bw; px2++) {
-            const idx = (rowOffset + px2) * 4;
+          for (let px = bx; px < bx + bw; px++) {
+            const idx = (rowOffset + px) * 4;
             rSum += data[idx];
             gSum += data[idx + 1];
             bSum += data[idx + 2];
@@ -20573,8 +20252,8 @@ function applyRegionMosaic(imageData, regions2, blockSize = 12) {
         const aAvg = Math.round(aSum / count);
         for (let py = by; py < by + bh; py++) {
           const rowOffset = py * width;
-          for (let px2 = bx; px2 < bx + bw; px2++) {
-            const idx = (rowOffset + px2) * 4;
+          for (let px = bx; px < bx + bw; px++) {
+            const idx = (rowOffset + px) * 4;
             data[idx] = rAvg;
             data[idx + 1] = gAvg;
             data[idx + 2] = bAvg;
@@ -21074,179 +20753,6 @@ function layerPanels(layer, options = {}) {
   return panels;
 }
 
-// src/image-editor/layers/effects-ui.ts
-function layerEffectsPanel(layer) {
-  const empty = { readOnly: true, enabled: true, scale: 1, rows: [] };
-  if (!layer) return { ...empty, available: false, reason: "Select a layer to add a layer style." };
-  if (layer.type === "adjustment") return { ...empty, available: false, reason: "Adjustment layers cannot have a layer style." };
-  const fx = layer.effects;
-  const readOnly = Boolean(layer.locks?.all);
-  return {
-    available: true,
-    readOnly,
-    reason: readOnly ? "The layer is locked; unlock it to change its layer style." : void 0,
-    enabled: fx?.enabled ?? true,
-    scale: fx?.scale ?? 1,
-    rows: (fx?.items ?? []).map((e) => ({ id: e.id, kind: e.kind, label: layerEffectLabel(e.kind), enabled: e.enabled }))
-  };
-}
-function layerEffectsBadge(layer) {
-  if (!layer.effects?.items.length) return null;
-  return hasActiveEffects(layer.effects) ? "on" : "off";
-}
-var LAYER_EFFECT_MENU = LAYER_EFFECT_KINDS.map((kind) => ({ kind, label: layerEffectLabel(kind) }));
-var BLENDS = BLEND_MODES.filter((m) => m.id !== "pigment").map((m) => ({ value: m.id, label: m.label }));
-var opt = (...pairs) => pairs.map(([value, label]) => ({ value, label }));
-function patternOptions(patterns) {
-  return [...patterns.map((p) => ({ value: p.id, label: p.name || p.id })), ...builtinPatternIds().map((id) => ({ value: id, label: builtinPattern(id).name }))];
-}
-function getPath(o, path) {
-  let v = o;
-  for (const p of path.split(".")) {
-    if (v === null || v === void 0) return void 0;
-    if (Array.isArray(v)) v = p === "last" ? v[v.length - 1] : v[Number(p)];
-    else v = v[p];
-  }
-  return v;
-}
-function setPath(o, parts, value) {
-  if (!parts.length) return value;
-  const [p, ...rest] = parts;
-  if (Array.isArray(o)) {
-    const i = p === "last" ? o.length - 1 : Number(p);
-    const out = [...o];
-    out[i] = setPath(o[i], rest, value);
-    return out;
-  }
-  const r = o ?? {};
-  return { ...r, [p]: setPath(r[p], rest, value) };
-}
-function fillControls(f, allowPattern, patterns) {
-  const types = allowPattern ? opt(["color", "Color"], ["gradient", "Gradient"], ["pattern", "Pattern"]) : opt(["color", "Color"], ["gradient", "Gradient"]);
-  const out = [{ key: "fill.type", label: "Fill", type: "select", value: f.type, options: types }];
-  if (f.type === "color") out.push({ key: "fill.color", label: "Color", type: "color", value: f.color });
-  else if (f.type === "gradient") out.push(...gradientControls("fill.gradient", f.gradient));
-  else {
-    out.push(
-      { key: "fill.patternId", label: "Pattern", type: "select", value: f.patternId, options: patternOptions(patterns) },
-      { key: "fill.scale", label: "Scale", type: "range", min: 0.01, max: 10, step: 0.01, value: f.scale, percent: true, unit: "%" }
-    );
-  }
-  return out;
-}
-function gradientControls(prefix, g) {
-  return [
-    { key: `${prefix}.stops.0.color`, label: "Start colour", type: "color", value: g.stops[0]?.color ?? "#000000" },
-    { key: `${prefix}.stops.last.color`, label: "End colour", type: "color", value: g.stops[g.stops.length - 1]?.color ?? "#ffffff" },
-    { key: `${prefix}.style`, label: "Style", type: "select", value: g.style, options: opt(["linear", "Linear"], ["radial", "Radial"], ["angle", "Angle"], ["reflected", "Reflected"], ["diamond", "Diamond"]) },
-    { key: `${prefix}.angle`, label: "Angle", type: "range", min: -180, max: 180, step: 1, value: g.angle, unit: "\xB0" },
-    { key: `${prefix}.scale`, label: "Scale", type: "range", min: 0.1, max: 1.5, step: 0.01, value: g.scale, percent: true, unit: "%" },
-    { key: `${prefix}.reverse`, label: "Reverse", type: "checkbox", value: g.reverse },
-    { key: `${prefix}.align`, label: "Align with layer", type: "checkbox", value: g.align }
-  ];
-}
-var px = (key2, label, value, max = 250) => ({ key: key2, label, type: "range", min: 0, max, step: 1, value, unit: "px" });
-var pct = (key2, label, value, min = 0, max = 1) => ({ key: key2, label, type: "range", min, max, step: 0.01, value, percent: true, unit: "%" });
-var deg = (key2, label, value, min = -180, max = 180) => ({ key: key2, label, type: "range", min, max, step: 1, value, unit: "\xB0" });
-function layerEffectControls(e, patterns = []) {
-  const blended = e.kind === "bevel-emboss" ? [] : [
-    { key: "blend", label: "Blend mode", type: "select", value: e.blend, options: BLENDS },
-    pct("opacity", "Opacity", e.opacity)
-  ];
-  switch (e.kind) {
-    case "drop-shadow":
-    case "inner-shadow":
-      return [
-        ...blended,
-        { key: "color", label: "Color", type: "color", value: e.color },
-        { key: "useGlobalLight", label: "Use global light", type: "checkbox", value: e.useGlobalLight },
-        deg("angle", "Angle", e.angle),
-        px("distance", "Distance", e.distance, 500),
-        e.kind === "drop-shadow" ? pct("spread", "Spread", e.spread) : pct("choke", "Choke", e.choke),
-        px("size", "Size", e.size),
-        pct("noise", "Noise", e.noise),
-        ...e.kind === "drop-shadow" ? [{ key: "knocksOut", label: "Layer knocks out shadow", type: "checkbox", value: e.knocksOut }] : []
-      ];
-    case "outer-glow":
-    case "inner-glow":
-      return [
-        ...blended,
-        ...fillControls(e.fill, false, patterns),
-        { key: "technique", label: "Technique", type: "select", value: e.technique, options: opt(["softer", "Softer"], ["precise", "Precise"]) },
-        ...e.kind === "inner-glow" ? [{ key: "source", label: "Source", type: "select", value: e.source, options: opt(["edge", "Edge"], ["center", "Center"]) }] : [],
-        e.kind === "outer-glow" ? pct("spread", "Spread", e.spread) : pct("choke", "Choke", e.choke),
-        px("size", "Size", e.size),
-        pct("range", "Range", e.range, 0.01, 1),
-        pct("noise", "Noise", e.noise)
-      ];
-    case "bevel-emboss":
-      return [
-        { key: "style", label: "Style", type: "select", value: e.style, options: opt(["inner-bevel", "Inner Bevel"], ["outer-bevel", "Outer Bevel"], ["emboss", "Emboss"], ["pillow-emboss", "Pillow Emboss"], ["stroke-emboss", "Stroke Emboss"]) },
-        { key: "technique", label: "Technique", type: "select", value: e.technique, options: opt(["smooth", "Smooth"], ["chisel-hard", "Chisel Hard"], ["chisel-soft", "Chisel Soft"]) },
-        pct("depth", "Depth", e.depth, 0, 10),
-        { key: "direction", label: "Direction", type: "select", value: e.direction, options: opt(["up", "Up"], ["down", "Down"]) },
-        px("size", "Size", e.size),
-        px("soften", "Soften", e.soften, 16),
-        { key: "useGlobalLight", label: "Use global light", type: "checkbox", value: e.useGlobalLight },
-        deg("angle", "Angle", e.angle),
-        deg("altitude", "Altitude", e.altitude, 0, 90),
-        { key: "highlightColor", label: "Highlight", type: "color", value: e.highlightColor },
-        { key: "highlightBlend", label: "Highlight mode", type: "select", value: e.highlightBlend, options: BLENDS },
-        pct("highlightOpacity", "Highlight opacity", e.highlightOpacity),
-        { key: "shadowColor", label: "Shadow", type: "color", value: e.shadowColor },
-        { key: "shadowBlend", label: "Shadow mode", type: "select", value: e.shadowBlend, options: BLENDS },
-        pct("shadowOpacity", "Shadow opacity", e.shadowOpacity)
-      ];
-    case "satin":
-      return [
-        ...blended,
-        { key: "color", label: "Color", type: "color", value: e.color },
-        deg("angle", "Angle", e.angle),
-        px("distance", "Distance", e.distance),
-        px("size", "Size", e.size),
-        { key: "invert", label: "Invert", type: "checkbox", value: e.invert }
-      ];
-    case "color-overlay":
-      return [...blended, { key: "color", label: "Color", type: "color", value: e.color }];
-    case "gradient-overlay":
-      return [...blended, ...gradientControls("gradient", e.gradient)];
-    case "pattern-overlay":
-      return [
-        ...blended,
-        { key: "patternId", label: "Pattern", type: "select", value: e.patternId, options: patternOptions(patterns) },
-        pct("scale", "Scale", e.scale, 0.01, 10),
-        deg("angle", "Angle", e.angle ?? 0),
-        { key: "link", label: "Link with layer", type: "checkbox", value: e.link ?? true }
-      ];
-    case "stroke":
-      return [
-        ...blended,
-        px("size", "Size", e.size),
-        { key: "position", label: "Position", type: "select", value: e.position, options: opt(["outside", "Outside"], ["inside", "Inside"], ["center", "Center"]) },
-        ...fillControls(e.fill, true, patterns)
-      ];
-  }
-}
-function fillOfType(current, type, patterns) {
-  if (type === "gradient") return { type: "gradient", gradient: defaultEffectGradient() };
-  if (type === "pattern") return { type: "pattern", patternId: patterns[0]?.id ?? "checker", scale: 1 };
-  return { type: "color", color: current.type === "color" ? current.color : "#000000" };
-}
-function effectControlChange(effect, key2, value, patterns = []) {
-  const [top, ...rest] = key2.split(".");
-  if (top === "fill" && rest[0] === "type") return { fill: fillOfType(effect.fill, String(value), patterns) };
-  if (top === "patternId" && !rest.length) {
-    const name = patternOptions(patterns).find((o) => o.value === value)?.label;
-    return name ? { patternId: value, name } : { patternId: value };
-  }
-  if (!rest.length) return { [top]: value };
-  if (top === "fill" && rest[0] === "patternId") {
-    const name = patternOptions(patterns).find((o) => o.value === value)?.label;
-    return { fill: { ...effect.fill, patternId: value, ...name ? { name } : {} } };
-  }
-  return { [top]: setPath(getPath(effect, top), rest, value) };
-}
-
 // src/image-editor/layers/color-ui.ts
 var WORKING_SPACE_OPTIONS = BUILTIN_PROFILES.filter((b) => b.colorSpace === "rgb").map((b) => ({ id: b.id, label: b.description }));
 var PROOF_PROFILE_OPTIONS = BUILTIN_PROFILES.map((b) => ({ id: b.id, label: b.description }));
@@ -22846,10 +22352,10 @@ var ContentAwareFillSession = class _ContentAwareFillSession {
     const len2 = dx * dx + dy * dy;
     for (let y = y0; y <= y1; y++) {
       for (let x = x0; x <= x1; x++) {
-        const px2 = win.x + x + 0.5 - from.x;
+        const px = win.x + x + 0.5 - from.x;
         const py = win.y + y + 0.5 - from.y;
-        const t = len2 > 0 ? Math.min(1, Math.max(0, (px2 * dx + py * dy) / len2)) : 0;
-        if ((px2 - t * dx) ** 2 + (py - t * dy) ** 2 > r * r) continue;
+        const t = len2 > 0 ? Math.min(1, Math.max(0, (px * dx + py * dy) / len2)) : 0;
+        if ((px - t * dx) ** 2 + (py - t * dy) ** 2 > r * r) continue;
         const i = y * win.width + x;
         area[i] = add2 && !hole[i] ? 1 : 0;
       }
@@ -23414,6 +22920,7 @@ export {
   createImageSubjectSelectionTool,
   createImageTransformTools,
   createImageTypeTools,
+  createLayerEffectTools,
   createMetricTextShaper,
   createOutlineTextShaper,
   createPigment,