@pixerate/editor 0.96.0 → 0.98.0

package/dist/image-editor/index.js

@@ -7,12 +7,15 @@ import {
 import {
   DEFAULT_GLOBAL_LIGHT,
   DIRECT_GAUSSIAN_MAX_SIGMA,
+  INTERPOLATIONS,
   LAYER_EFFECT_KINDS,
   LayerEffectError,
   MAX_EFFECT_REACH,
+  MAX_TRANSFORM_PIXELS,
   PatternPlacement,
   PatternTile,
   RasterCompositor,
+  TransformTooLargeError,
   ZlibError,
   adler32,
   base64ToBytes,
@@ -21,6 +24,7 @@ import {
   builtinPatternIds,
   bytesToBase64,
   changedTiles,
+  compositeSurfaceOver,
   curveLut,
   decodePng,
   defaultEffectGradient,
@@ -41,9 +45,11 @@ import {
   inflate,
   inflateRaw,
   insertLayer,
+  isInterpolation,
   isLayerEffectKind,
   isLayerLocked,
   isPng,
+  keysWeight,
   layerEffectFields,
   layerEffectLabel,
   mapLayer,
@@ -53,12 +59,27 @@ import {
   parseDataUrl,
   parseEffectColor,
   pngDataUrl,
+  reduceSurface,
   renderLayerEffects,
   scaleLayerEffect,
+  transformSurface,
+  transformedBounds,
   validateEffectGradient,
   validateLayerEffect,
-  validateLayerEffects
-} from "../chunk-KFTQ2PKP.js";
+  validateLayerEffects,
+  warpSurface
+} from "../chunk-WIR377F6.js";
+import {
+  affineFromHomography,
+  applyHomography,
+  boxQuad,
+  homographyFromAffine,
+  homographyFromPoints,
+  homographyKeepsQuad,
+  invertHomography,
+  multiplyHomographies,
+  rectToQuad
+} from "../chunk-GX332W2C.js";
 import {
   CoverageMap,
   DEFAULT_BRUSH,
@@ -136,6 +157,28 @@ import {
   uniformTile,
   writeRegion
 } from "../chunk-HEW6KDNI.js";
+import {
+  WARP_STYLES,
+  WARP_STYLE_LABELS,
+  applyMatrix,
+  dragWarpMeshPoint,
+  evalWarpMesh,
+  identityWarpMesh,
+  invertMatrix,
+  isValidWarpMesh,
+  matrixAbout,
+  multiplyMatrices,
+  pullWarpMesh,
+  resizeWarpMesh,
+  rotateMatrix,
+  translateMatrix,
+  warpMeshColumns,
+  warpMeshEditPoints,
+  warpMeshGridCurves,
+  warpMeshParamAt,
+  warpMeshRows,
+  warpPresetMesh
+} from "../chunk-KKREERP2.js";
 
 // src/image-editor/color.ts
 var LEGACY_PROCESS_VERSION = 1;
@@ -557,20 +600,20 @@ function hitTestCrop(canvasPt, state, vpWidth, vpHeight, handleThreshold = 14, c
 }
 function hitTestCropRect(canvasPt, rect, handleThreshold) {
   const { x, y, width: w, height: h } = rect;
-  const px = canvasPt.x;
+  const px2 = canvasPt.x;
   const py = canvasPt.y;
   const dist = (x1, y1, x2, y2) => Math.hypot(x1 - x2, y1 - y2);
-  if (dist(px, py, x, y) <= handleThreshold) return "nw";
-  if (dist(px, py, x + w, y) <= handleThreshold) return "ne";
-  if (dist(px, py, x + w, y + h) <= handleThreshold) return "se";
-  if (dist(px, py, x, y + h) <= handleThreshold) return "sw";
-  const nearX = px >= x - handleThreshold && px <= x + w + handleThreshold;
+  if (dist(px2, py, x, y) <= handleThreshold) return "nw";
+  if (dist(px2, py, x + w, y) <= handleThreshold) return "ne";
+  if (dist(px2, py, x + w, y + h) <= handleThreshold) return "se";
+  if (dist(px2, py, x, y + h) <= handleThreshold) return "sw";
+  const nearX = px2 >= x - handleThreshold && px2 <= x + w + handleThreshold;
   const nearY = py >= y - handleThreshold && py <= y + h + handleThreshold;
   if (nearX && Math.abs(py - y) <= handleThreshold) return "n";
   if (nearX && Math.abs(py - (y + h)) <= handleThreshold) return "s";
-  if (nearY && Math.abs(px - x) <= handleThreshold) return "w";
-  if (nearY && Math.abs(px - (x + w)) <= handleThreshold) return "e";
-  if (px >= x && px <= x + w && py >= y && py <= y + h) {
+  if (nearY && Math.abs(px2 - x) <= handleThreshold) return "w";
+  if (nearY && Math.abs(px2 - (x + w)) <= handleThreshold) return "e";
+  if (px2 >= x && px2 <= x + w && py >= y && py <= y + h) {
     return "inside";
   }
   return null;
@@ -1598,13 +1641,13 @@ function hslToRgb(h, s, l) {
   };
   return [f(h + 1 / 3), f(h), f(h - 1 / 3)];
 }
-function hueRangeWeight(range, deg) {
+function hueRangeWeight(range, deg2) {
   const [a, b0, c0, d0] = range.bounds;
   const rel = (x) => Number.isFinite(x) && Number.isFinite(a) ? remEuclid(x - a, 360) : 0;
   const b = rel(b0);
   const c = Math.max(rel(c0), b);
   const d = Math.max(rel(d0), c);
-  const h = rel(deg);
+  const h = rel(deg2);
   if (h <= b) return b <= 0 ? 1 : h / b;
   if (h <= c) return 1;
   if (h <= d) return d <= c ? 1 : (d - h) / (d - c);
@@ -1616,9 +1659,9 @@ function hueRangeTables(ranges) {
   const t = [new Float32Array(n), new Float32Array(n), new Float32Array(n)];
   const active = ranges.filter((r) => !isNeutralRange(r));
   for (let k = 0; k < n; k++) {
-    const deg = k / (n - 1) * 360;
+    const deg2 = k / (n - 1) * 360;
     for (const r of active) {
-      const w = hueRangeWeight(r, deg);
+      const w = hueRangeWeight(r, deg2);
       t[0][k] += w * r.hue;
       t[1][k] += w * r.saturation / 100;
       t[2][k] += w * r.lightness / 100;
@@ -2181,8 +2224,8 @@ function applyFastBoxBlur(imageData, radius) {
       let r = 0, g = 0, b = 0, a = 0;
       let count = 0;
       for (let k = -radius; k <= radius; k++) {
-        const px = Math.min(w - 1, Math.max(0, x + k));
-        const idx = (y * w + px) * 4;
+        const px2 = Math.min(w - 1, Math.max(0, x + k));
+        const idx = (y * w + px2) * 4;
         r += src[idx];
         g += src[idx + 1];
         b += src[idx + 2];
@@ -3137,13 +3180,13 @@ var ImageEditorRenderer = class {
       ctx.save();
       try {
         applyImageProjectionToContext(ctx, projection);
-        const px = 1 / (projection.scale || 1);
+        const px2 = 1 / (projection.scale || 1);
         ctx.beginPath();
-        ctx.arc(b.x, b.y, Math.max(px, b.diameter / 2), 0, Math.PI * 2);
-        ctx.lineWidth = 2 * px;
+        ctx.arc(b.x, b.y, Math.max(px2, b.diameter / 2), 0, Math.PI * 2);
+        ctx.lineWidth = 2 * px2;
         ctx.strokeStyle = "rgba(0,0,0,0.6)";
         ctx.stroke();
-        ctx.lineWidth = px;
+        ctx.lineWidth = px2;
         ctx.strokeStyle = "#ffffff";
         ctx.stroke();
       } catch {
@@ -3426,32 +3469,32 @@ var ImageEditorRenderer = class {
       this.outlineCache.set(selection, segs);
     }
     if (!segs.length) return;
-    const px = 1 / (scale || 1);
+    const px2 = 1 / (scale || 1);
     ctx.beginPath();
     for (let i = 0; i < segs.length; i += 4) {
       ctx.moveTo(segs[i], segs[i + 1]);
       ctx.lineTo(segs[i + 2], segs[i + 3]);
     }
-    ctx.lineWidth = px;
+    ctx.lineWidth = px2;
     ctx.strokeStyle = "#ffffff";
     ctx.stroke();
     if (typeof ctx.setLineDash === "function") {
-      ctx.setLineDash([4 * px, 4 * px]);
-      ctx.lineDashOffset = -offset * px;
+      ctx.setLineDash([4 * px2, 4 * px2]);
+      ctx.lineDashOffset = -offset * px2;
     }
     ctx.strokeStyle = "#000000";
     ctx.stroke();
     if (typeof ctx.setLineDash === "function") ctx.setLineDash([]);
   }
   drawDraftPath(ctx, points, scale) {
-    const px = 1 / (scale || 1);
+    const px2 = 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 = px;
+    ctx.lineWidth = px2;
     ctx.strokeStyle = "#ffffff";
     ctx.stroke();
-    if (typeof ctx.setLineDash === "function") ctx.setLineDash([4 * px, 4 * px]);
+    if (typeof ctx.setLineDash === "function") ctx.setLineDash([4 * px2, 4 * px2]);
     ctx.strokeStyle = "#000000";
     ctx.stroke();
     if (typeof ctx.setLineDash === "function") ctx.setLineDash([]);
@@ -4297,8 +4340,8 @@ var gfRadius = (p) => Math.min(64, Math.max(1, Math.ceil(p.radius)));
 var smoothSigma = (p) => p.smooth / 100 * 4;
 var featherSigma = (p) => p.feather / 2;
 function shiftAmount(p) {
-  const px = p.shiftEdge / 100 * Math.max(p.radius, 4);
-  return Number.isFinite(px) ? Math.min(64, Math.max(-64, px)) : 0;
+  const px2 = p.shiftEdge / 100 * Math.max(p.radius, 4);
+  return Number.isFinite(px2) ? Math.min(64, Math.max(-64, px2)) : 0;
 }
 function refineEdgeHalo(params = {}) {
   const p = normalizeRefineEdgeParams(params);
@@ -4584,6 +4627,7 @@ function serializeMask(mask, hint, ctx) {
   if (mask.density !== void 0 && mask.density !== 1) out.density = mask.density;
   if (mask.feather) out.feather = mask.feather;
   if (mask.enabled === false) out.enabled = false;
+  if (mask.linked === false) out.linked = false;
   return out;
 }
 function serializeLayer(layer, ctx) {
@@ -4702,8 +4746,8 @@ function readSurface(ref, x, y, channels, defaultValue, ctx, what) {
     return emptySurface(channels, defaultValue);
   }
   try {
-    const px = (ctx.decodeAsset ?? decodePngDataUrl)(url, channels);
-    return surfaceFromPixels(px, channels, Math.round(num(x, -1e7, 1e7, 0)), Math.round(num(y, -1e7, 1e7, 0)), defaultValue);
+    const px2 = (ctx.decodeAsset ?? decodePngDataUrl)(url, channels);
+    return surfaceFromPixels(px2, channels, Math.round(num(x, -1e7, 1e7, 0)), Math.round(num(y, -1e7, 1e7, 0)), defaultValue);
   } catch (err) {
     ctx.problems.push(`${what}: asset "${ref}" could not be decoded (${err.message})`);
     return emptySurface(channels, defaultValue);
@@ -4720,6 +4764,7 @@ function readMask(raw, ctx, what) {
   if (typeof r.density === "number" && r.density !== 1) mask.density = num(r.density, 0, 1, 1);
   if (typeof r.feather === "number" && r.feather > 0) mask.feather = num(r.feather, 0, 1e3, 0);
   if (r.enabled === false) mask.enabled = false;
+  if (r.linked === false) mask.linked = false;
   if (r.source && typeof r.source === "object") {
     const s = { ...DEFAULT_DEPTH_MASK_VALUES, ...r.source };
     mask.source = { ...s, depthRange: [...s.depthRange] };
@@ -4989,7 +5034,12 @@ function offsetLayer(layers, id, offset) {
   requireUnlocked(loc.layer, "position", "move it");
   if (!Number.isFinite(offset.x) || !Number.isFinite(offset.y)) fail("x and y must be numbers.");
   const layer = loc.layer;
-  return mapLayer(layers, id, () => ({ ...layer, offset: { x: Math.round(offset.x), y: Math.round(offset.y) } }));
+  const next = { ...layer, offset: { x: Math.round(offset.x), y: Math.round(offset.y) } };
+  const mask = layer.mask;
+  if (mask && mask.linked === false && !mask.source) {
+    next.mask = { ...mask, surface: translateSurface(mask.surface, layer.offset.x - next.offset.x, layer.offset.y - next.offset.y) };
+  }
+  return mapLayer(layers, id, () => next);
 }
 function setLayerMask(layers, id, mask) {
   const loc = requireLayer(layers, id);
@@ -6175,6 +6225,7 @@ var CHANNEL_USER_MASK = -2;
 var CHANNEL_REAL_USER_MASK = -3;
 var LAYER_FLAG_TRANSPARENCY_PROTECTED = 1;
 var LAYER_FLAG_HIDDEN = 2;
+var MASK_FLAG_UNLINKED = 1;
 var MASK_FLAG_DISABLED = 2;
 var MASK_FLAG_PARAMETERS = 16;
 var SECTION_OTHER = 0;
@@ -7604,6 +7655,7 @@ function recordMask(ctx, rec, name) {
   if (m.userDensity !== void 0 && m.userDensity < 255) mask.density = percent(m.userDensity);
   if (m.userFeather !== void 0 && m.userFeather > 0) mask.feather = Math.min(1e3, m.userFeather);
   if (flags & MASK_FLAG_DISABLED) mask.enabled = false;
+  if (flags & MASK_FLAG_UNLINKED) mask.linked = false;
   return mask;
 }
 function baseProps(ctx, rec, name, notes) {
@@ -7890,7 +7942,8 @@ function maskChannel(mask, ox, oy, psb) {
   if (mask.source) throw new PsdError("A parametric mask must be baked before export.");
   const bounds = contentBounds(mask.surface);
   const def = mask.defaultValue;
-  const m = { rect: EMPTY_RECT, defaultColor: def, flags: mask.enabled === false ? MASK_FLAG_DISABLED : 0 };
+  const flags = (mask.enabled === false ? MASK_FLAG_DISABLED : 0) | (mask.linked === false ? MASK_FLAG_UNLINKED : 0);
+  const m = { rect: EMPTY_RECT, defaultColor: def, flags };
   if ((mask.density ?? 1) < 1) m.userDensity = Math.round(Math.max(0, mask.density ?? 1) * 255);
   if ((mask.feather ?? 0) > 0) m.userFeather = mask.feather;
   if (!bounds) return { channel: emptyChannel(CHANNEL_USER_MASK), mask: m };
@@ -8087,6 +8140,499 @@ function exportPsd(input) {
   return { bytes, psb, records: records.length, warnings };
 }
 
+// src/image-editor/transform.ts
+var FREE_TRANSFORM_MODES = ["scale", "rotate", "skew", "distort", "perspective", "warp"];
+var TRANSFORM_ANCHORS = ["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"];
+var ANCHOR_FRACTION = {
+  "top-left": [0, 0],
+  top: [0.5, 0],
+  "top-right": [1, 0],
+  left: [0, 0.5],
+  center: [0.5, 0.5],
+  right: [1, 0.5],
+  "bottom-left": [0, 1],
+  bottom: [0.5, 1],
+  "bottom-right": [1, 1]
+};
+function isTransformAnchor(value) {
+  return typeof value === "string" && value in ANCHOR_FRACTION;
+}
+function identityTransform(box) {
+  return { box: { ...box }, corners: boxQuad(box) };
+}
+function cornersFromMatrix(box, m) {
+  const q2 = boxQuad(box);
+  return [applyMatrix(m, q2[0]), applyMatrix(m, q2[1]), applyMatrix(m, q2[2]), applyMatrix(m, q2[3])];
+}
+function matrixFromCorners(box, corners, eps = 1e-6) {
+  const [tl, tr, br, bl] = corners;
+  const size = 1 + Math.max(box.width, box.height);
+  if (Math.abs(tl.x + br.x - tr.x - bl.x) > eps * size || Math.abs(tl.y + br.y - tr.y - bl.y) > eps * size) return null;
+  const h = rectToQuad(box, corners);
+  return h ? affineFromHomography(h, 1e-9) : null;
+}
+function transformHomography(geometry) {
+  const h = rectToQuad(geometry.box, geometry.corners);
+  if (!h) return null;
+  return homographyKeepsQuad(h, boxQuad(geometry.box)) ? h : null;
+}
+function hasWarp(geometry) {
+  const w = geometry.warp;
+  if (!w) return false;
+  const id = identityWarpMesh(geometry.box, w.us.length - 1, w.vs.length - 1);
+  if (id.points.length !== w.points.length || id.us.some((u, i) => Math.abs(u - w.us[i]) > 1e-12) || id.vs.some((v, i) => Math.abs(v - w.vs[i]) > 1e-12)) return true;
+  return w.points.some((p, i) => Math.abs(p.x - id.points[i].x) > 1e-6 || Math.abs(p.y - id.points[i].y) > 1e-6);
+}
+function isIdentityTransform(geometry) {
+  if (hasWarp(geometry)) return false;
+  const q2 = boxQuad(geometry.box);
+  return geometry.corners.every((c, i) => Math.abs(c.x - q2[i].x) < 1e-6 && Math.abs(c.y - q2[i].y) < 1e-6);
+}
+function transformMap(geometry) {
+  const h = transformHomography(geometry);
+  if (!h) return null;
+  const { box } = geometry;
+  const warp = hasWarp(geometry) ? geometry.warp : null;
+  if (!warp) return (p) => applyHomography(h, p);
+  return (p) => applyHomography(h, evalWarpMesh(warp, (p.x - box.x) / box.width, (p.y - box.y) / box.height));
+}
+function transformedPoint(geometry, fx, fy) {
+  const f = transformMap(geometry);
+  const { box } = geometry;
+  return f ? f({ x: box.x + fx * box.width, y: box.y + fy * box.height }) : null;
+}
+function anchorPoint(geometry, anchor) {
+  const [fx, fy] = ANCHOR_FRACTION[anchor];
+  const h = rectToQuad(geometry.box, geometry.corners);
+  const p = { x: geometry.box.x + fx * geometry.box.width, y: geometry.box.y + fy * geometry.box.height };
+  return (h && applyHomography(h, p)) ?? p;
+}
+function transformedBox(geometry) {
+  const f = transformMap(geometry);
+  if (!f) return null;
+  const { box } = geometry;
+  const pts = [];
+  const n = hasWarp(geometry) ? 16 : 1;
+  for (let i = 0; i <= n; i++) {
+    const t = i / n;
+    for (const [fx, fy] of [[t, 0], [1, t], [1 - t, 1], [0, 1 - t]]) {
+      const p = f({ x: box.x + fx * box.width, y: box.y + fy * box.height });
+      if (!p) return null;
+      pts.push(p);
+    }
+  }
+  const xs = pts.map((p) => p.x);
+  const ys = pts.map((p) => p.y);
+  const x = Math.min(...xs);
+  const y = Math.min(...ys);
+  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
+}
+function referencePoint(box, reference) {
+  if (reference && typeof reference === "object") return { x: reference.x, y: reference.y };
+  const [fx, fy] = ANCHOR_FRACTION[reference ?? "center"];
+  return { x: box.x + fx * box.width, y: box.y + fy * box.height };
+}
+function matrixFromParams(box, params) {
+  const sx = (params.scaleX ?? 100) / 100;
+  const sy = (params.scaleY ?? 100) / 100;
+  const tx = Math.tan((params.skewX ?? 0) * Math.PI / 180);
+  const ty = Math.tan((params.skewY ?? 0) * Math.PI / 180);
+  const ref = referencePoint(box, params.reference);
+  const linear = multiplyMatrices(multiplyMatrices([1, ty, tx, 1, 0, 0], [sx, 0, 0, sy, 0, 0]), rotateMatrix(params.rotate ?? 0));
+  return multiplyMatrices(matrixAbout(linear, ref), translateMatrix(params.dx ?? 0, params.dy ?? 0));
+}
+function describeTransform(geometry, reference = "center") {
+  const m = hasWarp(geometry) ? null : matrixFromCorners(geometry.box, geometry.corners);
+  const ref = referencePoint(geometry.box, reference);
+  const bounds = transformedBox(geometry);
+  if (!m) {
+    const h = rectToQuad(geometry.box, geometry.corners);
+    const at2 = (h && applyHomography(h, ref)) ?? ref;
+    return { affine: false, scaleX: 100, scaleY: 100, rotate: 0, skewX: 0, x: at2.x, y: at2.y, bounds, corners: geometry.corners };
+  }
+  const [a, b, c, d] = m;
+  const sxAbs = Math.hypot(a, b);
+  const rot = Math.atan2(b, a) * 180 / Math.PI;
+  const shear = sxAbs ? (a * c + b * d) / sxAbs : 0;
+  const sy = sxAbs ? (a * d - b * c) / sxAbs : 0;
+  const skew = sxAbs ? Math.atan(shear / sxAbs) * 180 / Math.PI : 0;
+  const at = applyMatrix(m, ref);
+  const clean = (v) => Math.abs(v) < 1e-9 ? 0 : v;
+  return {
+    affine: true,
+    scaleX: clean(sxAbs * 100),
+    scaleY: clean(sy * 100),
+    rotate: clean(rot === -180 ? 180 : rot),
+    skewX: clean(skew),
+    x: at.x,
+    y: at.y,
+    bounds,
+    corners: geometry.corners
+  };
+}
+function applyParams(geometry, params) {
+  const ref = params.reference && typeof params.reference === "object" ? params.reference : anchorPoint(geometry, params.reference ?? "center");
+  const m = matrixFromParams({ x: ref.x, y: ref.y, width: 0, height: 0 }, { ...params, reference: ref });
+  const c = geometry.corners;
+  return [applyMatrix(m, c[0]), applyMatrix(m, c[1]), applyMatrix(m, c[2]), applyMatrix(m, c[3])];
+}
+function flipCorners(geometry, axis) {
+  const c = anchorPoint(geometry, "center");
+  const m = axis === "horizontal" ? [-1, 0, 0, 1, 2 * c.x, 0] : [1, 0, 0, -1, 0, 2 * c.y];
+  const q2 = geometry.corners;
+  return [applyMatrix(m, q2[0]), applyMatrix(m, q2[1]), applyMatrix(m, q2[2]), applyMatrix(m, q2[3])];
+}
+function boxPointOf(geometry, p) {
+  const m = matrixFromCorners(geometry.box, geometry.corners);
+  if (m) return applyMatrix(invertMatrix(m), p);
+  return null;
+}
+function presetWarp(box, preset) {
+  return warpPresetMesh(preset, box);
+}
+function isValidWarp(mesh) {
+  return isValidWarpMesh(mesh);
+}
+function geometryHomography(geometry) {
+  const m = matrixFromCorners(geometry.box, geometry.corners);
+  return m ? homographyFromAffine(m) : transformHomography(geometry);
+}
+
+// src/image-editor/free-transform.ts
+var FREE_TRANSFORM_CONTENTS = ["auto", "layer", "selection", "selection-copy", "selection-outline"];
+var fail2 = (message) => {
+  throw new LayerOperationError(message);
+};
+var T = (x, y) => [1, 0, x, 0, 1, y, 0, 0, 1];
+function previewStep(scale) {
+  if (!scale || !(scale > 0) || scale >= 1) return 1;
+  return Math.min(8, 2 ** Math.floor(Math.log2(1 / scale)));
+}
+function toDoc(r, o) {
+  return r ? { x: r.x + o.x, y: r.y + o.y, width: r.width, height: r.height } : null;
+}
+function selectionSurface(sel) {
+  return surfaceFromPixels({ width: sel.width, height: sel.height, data: sel.data }, 1, 0, 0, 0);
+}
+function liftPixels(surface, sel, o) {
+  const sb = sel.bounds;
+  const area = { x: sb.x - o.x, y: sb.y - o.y, width: sb.width, height: sb.height };
+  const px2 = readRegion(surface, area);
+  const kept = new Uint8ClampedArray(px2);
+  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;
+        continue;
+      }
+      px2[i + 3] = px2[i + 3] * k;
+      if (!px2[i + 3]) px2[i] = px2[i + 1] = px2[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) };
+}
+function liftMask(mask, sel, o) {
+  const sb = sel.bounds;
+  const area = { x: sb.x - o.x, y: sb.y - o.y, width: sb.width, height: sb.height };
+  const v = readRegion(mask, area);
+  const def = mask.defaultValue;
+  const lifted = new Uint8ClampedArray(area.width * area.height * 4);
+  const rest = new Uint8ClampedArray(v.length);
+  for (let y = 0; y < area.height; y++) {
+    for (let x = 0; x < area.width; x++) {
+      const i = y * area.width + x;
+      const k = sel.data[(sb.y + y) * sel.width + sb.x + x] / 255;
+      const g = v[i];
+      if (k > 0) {
+        lifted[i * 4] = lifted[i * 4 + 1] = lifted[i * 4 + 2] = g;
+        lifted[i * 4 + 3] = k * 255;
+      }
+      rest[i] = g * (1 - k) + def * k;
+    }
+  }
+  return { lifted: surfaceFromPixels({ width: area.width, height: area.height, data: lifted }, 4, area.x, area.y), rest: writeRegion(mask, area, rest) };
+}
+var FreeTransformSession = class {
+  constructor(host, init = {}) {
+    this.host = host;
+    if (init.interpolation !== void 0 && !isInterpolation(init.interpolation)) fail2(`Unknown interpolation "${String(init.interpolation)}"; use nearest, bilinear or bicubic.`);
+    this.interp = init.interpolation ?? "bicubic";
+    const sel = host.selection();
+    const selected = Boolean(sel?.bounds);
+    let content = init.content ?? "auto";
+    if (!["auto", "layer", "selection", "selection-copy", "selection-outline"].includes(content)) {
+      fail2(`Unknown content "${String(content)}"; use auto, layer, selection, selection-copy or selection-outline.`);
+    }
+    if (content === "auto") content = selected ? "selection" : "layer";
+    this.content = content;
+    if (content !== "layer" && !selected) fail2(`Nothing is selected; ${content} needs a selection. Select first, or use content layer.`);
+    const layers = host.layers();
+    this.startLayers = layers;
+    this.startSelection = sel;
+    this.startActive = host.activeLayerId();
+    this.before = host.capture();
+    const moves = [];
+    let box = null;
+    if (content === "selection-outline") {
+      this.layerId = null;
+      this.parts.push({ what: "selection", offset: { x: 0, y: 0 }, moving: selectionSurface(sel), base: null, reduced: /* @__PURE__ */ new Map() });
+      moves.push("selection");
+      box = { ...sel.bounds };
+    } else {
+      const id = init.layerId ?? host.activeLayerId();
+      if (!id) fail2("No layer given and none is active; pass layerId (see list_layers).");
+      const layer = requireLayer(layers, id).layer;
+      this.layerId = layer.id;
+      const mask = layer.mask && !layer.mask.source ? layer.mask : void 0;
+      const channel = init.channel ?? (layer.id === host.activeLayerId() ? host.activeTarget() : "pixels");
+      if (channel !== "pixels" && channel !== "mask") fail2(`Unknown channel "${String(channel)}"; use pixels or mask.`);
+      const linked = mask?.linked !== false;
+      const maskAlone = channel === "mask" && (!linked || layer.type !== "pixel");
+      if (channel === "mask" && !mask) fail2(layer.mask?.source ? `Layer "${layer.name || id}" has a depth mask, which is generated, not transformed.` : `Layer "${layer.name || id}" has no mask to transform; add one with add_layer_mask, or transform its pixels.`);
+      if (!maskAlone && layer.type !== "pixel") fail2(`Layer "${layer.name || id}" is a ${layer.type} layer; Free Transform works on pixel layers, layer masks (channel mask) and selections.`);
+      if (!layer.visible && content !== "selection-copy") fail2(`Layer "${layer.name || id}" is hidden; show it before you transform it.`);
+      if (content !== "selection-copy") {
+        requireUnlocked(layer, "position", "transform it");
+        if (!maskAlone) requireUnlocked(layer, "pixels", "transform it");
+      }
+      const o = layer.type === "pixel" ? layer.offset : { x: 0, y: 0 };
+      const pixels = layer.type === "pixel" ? host.pixelsOf(layer) : null;
+      if (maskAlone) {
+        if (content === "selection-copy") fail2("Layer via Copy copies pixels; transform a mask with content layer or selection.");
+        if (content === "selection") {
+          const { lifted, rest } = liftMask(mask.surface, sel, o);
+          this.parts.push({ what: "mask", offset: o, moving: lifted, base: rest, reduced: /* @__PURE__ */ new Map() });
+          box = toDoc(contentBounds(lifted), o);
+        } else {
+          this.parts.push({ what: "mask", offset: o, moving: mask.surface, base: null, reduced: /* @__PURE__ */ new Map() });
+          box = toDoc(contentBounds(mask.surface), o);
+        }
+        moves.push("mask");
+      } else if (content === "layer") {
+        this.parts.push({ what: "pixels", offset: o, moving: pixels, base: null, reduced: /* @__PURE__ */ new Map() });
+        moves.push("pixels");
+        box = toDoc(contentBounds(pixels), o);
+        if (mask && linked) {
+          this.parts.push({ what: "mask", offset: o, moving: mask.surface, base: null, reduced: /* @__PURE__ */ new Map() });
+          moves.push("mask");
+          if (!box) box = toDoc(contentBounds(mask.surface), o);
+        }
+      } else if (content === "selection") {
+        const { lifted, rest } = liftPixels(pixels, sel, o);
+        this.parts.push({ what: "pixels", offset: o, moving: lifted, base: rest, reduced: /* @__PURE__ */ new Map() });
+        moves.push("pixels");
+        box = toDoc(contentBounds(lifted), o);
+        if (mask && linked) {
+          const m = liftMask(mask.surface, sel, o);
+          this.parts.push({ what: "mask", offset: o, moving: m.lifted, base: m.rest, reduced: /* @__PURE__ */ new Map() });
+          moves.push("mask");
+        }
+      } else {
+        const { lifted } = liftPixels(pixels, sel, o);
+        box = toDoc(contentBounds(lifted), o);
+        if (box) {
+          const copy = {
+            type: "pixel",
+            id: newLayerId(),
+            name: `${layer.name || "Layer"} copy`,
+            visible: true,
+            opacity: 1,
+            blend: "normal",
+            surface: lifted,
+            offset: { ...o }
+          };
+          this.copyId = copy.id;
+          const loc = findLayer(layers, layer.id);
+          this.startLayers = insertLayer(layers, copy, loc.parent?.id ?? null, loc.index + 1);
+          this.parts.push({ what: "pixels", offset: o, moving: lifted, base: null, reduced: /* @__PURE__ */ new Map() });
+          moves.push("pixels");
+        }
+      }
+      if (content !== "layer") {
+        this.parts.push({ what: "selection", offset: { x: 0, y: 0 }, moving: selectionSurface(sel), base: null, reduced: /* @__PURE__ */ new Map() });
+        moves.push("selection");
+      }
+    }
+    if (!box && moves[0] === "mask") fail2("The mask holds nothing but its default value, so there is nothing to transform; paint it first, or transform the pixels (channel pixels).");
+    if (!box) fail2(content === "layer" ? "The layer has no pixels to transform." : "The selection holds no pixels of this layer; select some, or transform the outline (content selection-outline).");
+    this.box = box;
+    this.moves = moves;
+    this.geometryValue = identityTransform(box);
+    this.shown = this.startLayers;
+    if (this.copyId) host.show(this.startLayers, sel, this.copyId);
+    this.shown = host.layers();
+  }
+  host;
+  content;
+  /** The layer being transformed (`null` for `selection-outline`). */
+  layerId;
+  /** The new layer of a `selection-copy`. */
+  copyId = null;
+  /** The frame (document pixels). */
+  box;
+  /** What moves. */
+  moves;
+  geometryValue;
+  interp;
+  parts = [];
+  before;
+  startLayers;
+  startSelection;
+  startActive;
+  /** The stack this session last showed: anything else means the document changed under it. */
+  shown;
+  closed = false;
+  /** The current geometry. */
+  get geometry() {
+    return this.geometryValue;
+  }
+  get interpolation() {
+    return this.interp;
+  }
+  get isOpen() {
+    return !this.closed;
+  }
+  check() {
+    if (this.closed) fail2("This transform has already been committed or cancelled; begin a new one.");
+    if (this.host.layers() !== this.shown) {
+      this.closed = true;
+      fail2("The document changed while the transform was open, so it was abandoned; begin a new one.");
+    }
+  }
+  /**
+   * Changes the geometry (`corners`, `warp`) or the interpolation and, unless `preview` is `false`,
+   * shows the result live (no history). Returns the geometry.
+   */
+  update(changes, preview = {}) {
+    this.check();
+    if (changes.interpolation !== void 0) {
+      if (!isInterpolation(changes.interpolation)) fail2(`Unknown interpolation "${String(changes.interpolation)}"; use nearest, bilinear or bicubic.`);
+      this.interp = changes.interpolation;
+    }
+    const next = {
+      box: this.box,
+      corners: (changes.corners ?? this.geometryValue.corners).map((p) => ({ x: p.x, y: p.y })),
+      warp: changes.warp === void 0 ? this.geometryValue.warp ?? null : changes.warp
+    };
+    if (next.corners.length !== 4 || !next.corners.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) fail2("corners must be four finite points: top-left, top-right, bottom-right, bottom-left.");
+    if (!transformMap(next)) fail2("These corners fold the frame over itself or through the horizon; keep the quad convex.");
+    this.geometryValue = next;
+    if (preview !== false) this.render(preview);
+    return next;
+  }
+  /** Resamples every part for the current geometry and shows it (or returns it, for commit). */
+  resample(final, preview = {}) {
+    const g = this.geometryValue;
+    const identity = isIdentityTransform(g);
+    const warp = hasWarp(g);
+    const h = warp ? null : geometryHomography(g);
+    const f = warp ? transformMap(g) : null;
+    const step = final ? 1 : previewStep(preview.scale);
+    const interpolation = final ? this.interp : this.interp === "nearest" ? "nearest" : "bilinear";
+    let layers = this.startLayers;
+    let selection = this.startSelection;
+    const targetId = this.copyId ?? this.layerId;
+    for (const part of this.parts) {
+      const o = part.offset;
+      let moved;
+      if (identity) moved = part.moving;
+      else {
+        let src = part.moving;
+        let k = 1;
+        if (step > 1) {
+          k = step;
+          let r = part.reduced.get(k);
+          if (!r) {
+            r = reduceSurface(part.moving, k);
+            part.reduced.set(k, r);
+          }
+          src = r;
+        }
+        const opts = { interpolation, step: step > 1 ? step : void 0 };
+        if (preview.clip && !final) opts.clip = { x: Math.floor(preview.clip.x - o.x), y: Math.floor(preview.clip.y - o.y), width: Math.ceil(preview.clip.width) + 1, height: Math.ceil(preview.clip.height) + 1 };
+        try {
+          if (f) {
+            moved = warpSurface(src, (p) => {
+              const q2 = f({ x: p.x * k + o.x, y: p.y * k + o.y });
+              return q2 && { x: q2.x - o.x, y: q2.y - o.y };
+            }, opts);
+          } else {
+            const hl = multiplyHomographies(multiplyHomographies(multiplyHomographies([k, 0, 0, 0, k, 0, 0, 0, 1], T(o.x, o.y)), h), T(-o.x, -o.y));
+            moved = transformSurface(src, hl, opts);
+          }
+        } catch (e) {
+          if (e instanceof TransformTooLargeError) fail2(e.message);
+          throw e;
+        }
+      }
+      const result = part.base ? compositeSurfaceOver(part.base, moved) : moved;
+      if (part.what === "selection") {
+        const { width, height } = this.host.canvas();
+        const data = new Uint8Array(readRegion(result, { x: 0, y: 0, width, height }).buffer);
+        const next = createSelectionMask(width, height, data);
+        selection = next.bounds ? next : null;
+      } else if (part.what === "pixels") {
+        layers = mapLayer(layers, targetId, (l) => {
+          const next = { ...l, surface: result };
+          delete next.source;
+          return next;
+        });
+      } else {
+        layers = mapLayer(layers, targetId, (l) => ({ ...l, mask: { ...l.mask, surface: result } }));
+      }
+    }
+    return { layers, selection };
+  }
+  render(preview) {
+    const { layers, selection } = this.resample(false, preview);
+    this.host.show(layers, selection, this.copyId ?? this.startActive);
+    this.shown = this.host.layers();
+  }
+  /** Finishes the transform with full-quality resampling, as one undo step. */
+  commit() {
+    this.check();
+    const g = this.geometryValue;
+    const changed = !isIdentityTransform(g) || Boolean(this.copyId);
+    if (!changed) {
+      this.closed = true;
+      this.host.restore(this.before);
+      return this.result(false, this.startLayers, this.startSelection);
+    }
+    const { layers, selection } = this.resample(true);
+    this.closed = true;
+    this.host.show(layers, selection, this.copyId ?? this.startActive);
+    this.host.record(this.before);
+    return this.result(true, layers, selection);
+  }
+  /** Abandons the transform and puts everything back (no history). */
+  cancel() {
+    if (this.closed) return;
+    this.closed = true;
+    this.host.restore(this.before);
+  }
+  result(changed, layers, selection) {
+    let bounds = null;
+    const id = this.copyId ?? this.layerId;
+    const layer = id ? findLayer(layers, id)?.layer : void 0;
+    if (this.moves.includes("pixels") && layer?.type === "pixel") bounds = toDoc(contentBounds(this.host.pixelsOf(layer)), layer.offset);
+    else if (this.moves.includes("mask") && layer?.mask) bounds = toDoc(contentBounds(layer.mask.surface), layer.type === "pixel" ? layer.offset : { x: 0, y: 0 });
+    else if (this.moves.includes("selection")) bounds = selection?.bounds ? { ...selection.bounds } : null;
+    return {
+      layerId: this.copyId ?? this.layerId,
+      content: this.content,
+      moved: [...this.moves],
+      box: { ...this.box },
+      corners: this.geometryValue.corners,
+      bounds,
+      changed
+    };
+  }
+};
+
 // src/image-editor/controller.ts
 var IMAGE_EDITOR_SCHEMA_VERSION = LAYERED_SCHEMA_VERSION;
 function paintCoverageInto(base, coverage, apply, rects) {
@@ -8763,17 +9309,17 @@ var ImageEditorController = class {
    */
   sourceSurface() {
     const { width, height } = this.naturalSize;
-    const fromPixels = (px2) => {
-      let s = this.sourceSurfaces.get(px2);
+    const fromPixels = (px3) => {
+      let s = this.sourceSurfaces.get(px3);
       if (!s) {
-        s = surfaceFromPixels(px2, 4);
-        this.sourceSurfaces.set(px2, s);
+        s = surfaceFromPixels(px3, 4);
+        this.sourceSurfaces.set(px3, s);
       }
       return s;
     };
-    const px = this.samplePixels;
-    const fits = Boolean(px && px.width === width && px.height === height);
-    if (this.samplePixelsOverride && fits) return fromPixels(px);
+    const px2 = this.samplePixels;
+    const fits = Boolean(px2 && px2.width === width && px2.height === height);
+    if (this.samplePixelsOverride && fits) return fromPixels(px2);
     const el = this.imageElement;
     if (el) {
       const cached = this.sourceSurfaces.get(el);
@@ -8787,7 +9333,7 @@ var ImageEditorController = class {
         return s;
       }
     }
-    return fits ? fromPixels(px) : null;
+    return fits ? fromPixels(px2) : null;
   }
   opaqueCache = /* @__PURE__ */ new WeakMap();
   /** Whether every source pixel is opaque (some legacy renders depend on it). */
@@ -8846,11 +9392,11 @@ var ImageEditorController = class {
     const { width, height } = this.naturalSize;
     let surface = emptySurface(4);
     if (init.pixels) {
-      const px = init.pixels;
-      if (!(px.width > 0 && px.height > 0) || px.data.length < px.width * px.height * 4) {
+      const px2 = init.pixels;
+      if (!(px2.width > 0 && px2.height > 0) || px2.data.length < px2.width * px2.height * 4) {
         throw new LayerOperationError("pixels must be RGBA with width \xD7 height \xD7 4 bytes.");
       }
-      surface = surfaceFromPixels(px, 4);
+      surface = surfaceFromPixels(px2, 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]));
@@ -9038,7 +9584,7 @@ var ImageEditorController = class {
       if (this.state.activeLayerId === id) this.state.activeTarget = "pixels";
     });
   }
-  /** Changes any layer mask's density, feather or enabled flag (pixels kept). Returns the mask. */
+  /** Changes any layer mask's density, feather, enabled or linked flag (pixels kept). Returns the mask. */
   setLayerMaskProps(id, props, commitToHistory = true) {
     const layer = requireLayer(this.state.layers, id).layer;
     if (!layer.mask) throw new LayerOperationError(`Layer "${layer.name || id}" has no mask; add one with add_layer_mask.`);
@@ -9098,14 +9644,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 px = readRegion(surface, src);
-    const kept = options.cut ? new Uint8ClampedArray(px) : null;
+    const px2 = readRegion(surface, src);
+    const kept = options.cut ? new Uint8ClampedArray(px2) : 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));
-        px[i] = Math.round(px[i] * (c / 255));
+        px2[i] = Math.round(px2[i] * (c / 255));
       }
     }
     const copy = {
@@ -9115,7 +9661,7 @@ var ImageEditorController = class {
       visible: true,
       opacity: 1,
       blend: "normal",
-      surface: surfaceFromPixels({ width: src.width, height: src.height, data: px }, 4, src.x, src.y),
+      surface: surfaceFromPixels({ width: src.width, height: src.height, data: px2 }, 4, src.x, src.y),
       offset: { ...layer.offset }
     };
     let next = insertLayer(this.state.layers, copy, loc.parent?.id ?? null, loc.index + 1);
@@ -9130,6 +9676,134 @@ var ImageEditorController = class {
     });
     return copy.id;
   }
+  // --- Free Transform ---
+  openTransform = null;
+  /** The Free Transform in progress (see `beginFreeTransform`), or `null`. */
+  getFreeTransform() {
+    if (this.openTransform && !this.openTransform.isOpen) this.openTransform = null;
+    return this.openTransform;
+  }
+  transformHost() {
+    return {
+      layers: () => this.state.layers,
+      activeLayerId: () => this.state.activeLayerId,
+      activeTarget: () => this.state.activeTarget,
+      selection: () => this.state.selection?.bounds ? this.state.selection : null,
+      canvas: () => this.naturalSize,
+      pixelsOf: (layer) => this.surfaceOf(layer),
+      capture: () => this.captureHistoryEntry(),
+      show: (layers, selection, active) => {
+        this.state.layers = layers;
+        this.state.selection = selection;
+        if (active !== this.state.activeLayerId) {
+          this.state.activeLayerId = active;
+          this.state.activeTarget = "pixels";
+        }
+        this.notify();
+      },
+      record: (before) => {
+        if (this.isApplyingHistory) return;
+        this.undoStack.push(before);
+        if (this.undoStack.length > this.maxHistoryDepth) this.undoStack.shift();
+        this.redoStack = [];
+        this.trimHistoryBytes();
+        this.notify();
+      },
+      restore: (before) => {
+        const e = before;
+        this.state.layers = e.layers;
+        this.state.selection = e.selection;
+        this.state.activeLayerId = e.activeLayerId;
+        this.state.activeTarget = e.activeTarget;
+        this.notify();
+      }
+    };
+  }
+  /**
+   * Starts a Free Transform (Edit › Free Transform, Transform Selection, or a transform of a Layer
+   * via Copy): of the layer's pixels with its linked mask, an unlinked mask alone, the selected
+   * pixels or just the selection outline (see `FreeTransformInit`). Change the geometry with
+   * `session.update` (live preview, no history), then `commit()` (one undo step) or `cancel()`.
+   * Refused while another transform is open.
+   */
+  beginFreeTransform(init = {}) {
+    if (this.getFreeTransform()) throw new LayerOperationError("A Free Transform is already open; commit or cancel it first.");
+    const session = new FreeTransformSession(this.transformHost(), init);
+    this.openTransform = session;
+    this.notify();
+    return session;
+  }
+  /**
+   * Transforms in one step (agents, scripts): begins a Free Transform for `spec`, sets its corners
+   * from exactly one of `matrix` (document-space affine), `corners` (where the frame's corners go:
+   * distort / perspective) or `params` (scale, rotate, skew and move about a reference point), and
+   * commits it as one undo step. Returns what changed and the new bounds.
+   */
+  transformLayer(spec) {
+    const given = [spec.matrix, spec.corners, spec.params].filter((v) => v !== void 0).length;
+    if (given > 1) throw new LayerOperationError("Give only one of matrix, corners and params.");
+    if (!given && spec.warp === void 0) throw new LayerOperationError("Give matrix, corners or params (or a warp).");
+    if (spec.matrix && !(Array.isArray(spec.matrix) && spec.matrix.length === 6 && spec.matrix.every(Number.isFinite))) {
+      throw new LayerOperationError("matrix must be six finite numbers [a, b, c, d, e, f] (x' = a\xB7x + c\xB7y + e, y' = b\xB7x + d\xB7y + f).");
+    }
+    if (spec.matrix) {
+      const [a, b, c, d] = spec.matrix;
+      if (Math.abs(a * d - b * c) < 1e-9) throw new LayerOperationError("matrix is singular (it collapses the layer to a line); its determinant a\xB7d \u2212 b\xB7c must not be 0.");
+    }
+    const session = this.beginFreeTransform(spec);
+    try {
+      const g = identityTransform(session.box);
+      const corners = spec.matrix ? cornersFromMatrix(session.box, spec.matrix) : spec.corners ? spec.corners : spec.params ? applyParams(g, spec.params) : g.corners;
+      let warp = null;
+      if (spec.warp) {
+        if ("style" in spec.warp) {
+          if (!WARP_STYLES.includes(spec.warp.style)) throw new LayerOperationError(`Unknown warp style "${String(spec.warp.style)}". Styles: ${WARP_STYLES.join(", ")}.`);
+          warp = presetWarp(session.box, spec.warp);
+        } else {
+          if (!isValidWarp(spec.warp)) throw new LayerOperationError("mesh must have us and vs (knots from 0 to 1, increasing) and (3\xB7columns + 1) \xD7 (3\xB7rows + 1) finite points, row by row.");
+          warp = spec.warp;
+        }
+      }
+      session.update({ corners, warp }, false);
+      return session.commit();
+    } catch (e) {
+      session.cancel();
+      throw e;
+    }
+  }
+  /** Flips the layer (or its selected pixels, or the outline) about the frame's centre, exactly (one undo step). */
+  flipLayer(axis, init = {}) {
+    if (axis !== "horizontal" && axis !== "vertical") throw new LayerOperationError(`axis must be horizontal or vertical, got "${String(axis)}".`);
+    const session = this.beginFreeTransform({ interpolation: "nearest", ...init });
+    try {
+      session.update({ corners: flipCorners(identityTransform(session.box), axis) }, false);
+      return session.commit();
+    } catch (e) {
+      session.cancel();
+      throw e;
+    }
+  }
+  /**
+   * Rotates by a quarter turn (90 clockwise, −90 counter-clockwise) or 180 about the frame's
+   * centre, snapped so pixels land on whole pixels: exact, no resampling (one undo step).
+   */
+  rotateLayer90(turn, init = {}) {
+    if (turn !== 90 && turn !== -90 && turn !== 180) throw new LayerOperationError(`turn must be 90, -90 or 180, got ${String(turn)}.`);
+    const session = this.beginFreeTransform({ interpolation: "nearest", ...init });
+    try {
+      const b = session.box;
+      const cx = b.x + b.width / 2;
+      const cy = b.y + b.height / 2;
+      const ox = turn === 180 ? 0 : Math.round(cx - b.height / 2) - (cx - b.height / 2);
+      const oy = turn === 180 ? 0 : Math.round(cy - b.width / 2) - (cy - b.width / 2);
+      const m = turn === 90 ? [0, 1, -1, 0, cx + cy + ox, cy - cx + oy] : turn === -90 ? [0, -1, 1, 0, cx - cy + ox, cy + cx + oy] : [-1, 0, 0, -1, 2 * cx, 2 * cy];
+      session.update({ corners: cornersFromMatrix(b, m) }, false);
+      return session.commit();
+    } catch (e) {
+      session.cancel();
+      throw e;
+    }
+  }
   /** Adds a `develop` or `blur` filter to a pixel layer (one undo step). Returns the layer's filters. */
   addLayerFilter(id, filter) {
     const f = normalizeFilter(filter);
@@ -10377,9 +11051,9 @@ var ImageEditorController = class {
       return;
     }
     const { width, height } = this.naturalSize;
-    let px = await this.decodeImage(newDataUrl);
-    if (px.width !== width || px.height !== height) px = resizePixels(px, width, height);
-    const data = new Uint8ClampedArray(px.data);
+    let px2 = await this.decodeImage(newDataUrl);
+    if (px2.width !== width || px2.height !== height) px2 = resizePixels(px2, width, height);
+    const data = new Uint8ClampedArray(px2.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 } });
@@ -10400,10 +11074,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 px = await this.decodeImage(newDataUrl);
-    if (px.width !== width || px.height !== height) px = resizePixels(px, width, height);
+    let px2 = await this.decodeImage(newDataUrl);
+    if (px2.width !== width || px2.height !== height) px2 = resizePixels(px2, width, height);
     const alpha = new Uint8ClampedArray(width * height);
-    for (let p = 0; p < alpha.length; p++) alpha[p] = px.data[p * 4 + 3];
+    for (let p = 0; p < alpha.length; p++) alpha[p] = px2.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 }));
@@ -10868,6 +11542,10 @@ function withMaskProps(mask, props) {
     if (props.enabled) delete next.enabled;
     else next.enabled = false;
   }
+  if (props.linked !== void 0) {
+    if (props.linked) delete next.linked;
+    else next.linked = false;
+  }
   return next;
 }
 function resizeLegacyMasks(layers, from, to) {
@@ -10913,24 +11591,24 @@ function pixelsOnly(layers) {
   }
   return out;
 }
-function resizePixels(px, width, height) {
-  const src = px.data;
+function resizePixels(px2, width, height) {
+  const src = px2.data;
   const out = new Uint8ClampedArray(width * height * 4);
-  const kx = px.width / width;
-  const ky = px.height / height;
+  const kx = px2.width / width;
+  const ky = px2.height / height;
   for (let y = 0; y < height; y++) {
-    const fy = Math.min(px.height - 1, Math.max(0, (y + 0.5) * ky - 0.5));
+    const fy = Math.min(px2.height - 1, Math.max(0, (y + 0.5) * ky - 0.5));
     const y0 = Math.floor(fy);
-    const y1 = Math.min(px.height - 1, y0 + 1);
+    const y1 = Math.min(px2.height - 1, y0 + 1);
     const ty = fy - y0;
     for (let x = 0; x < width; x++) {
-      const fx = Math.min(px.width - 1, Math.max(0, (x + 0.5) * kx - 0.5));
+      const fx = Math.min(px2.width - 1, Math.max(0, (x + 0.5) * kx - 0.5));
       const x0 = Math.floor(fx);
-      const x1 = Math.min(px.width - 1, x0 + 1);
+      const x1 = Math.min(px2.width - 1, x0 + 1);
       const tx = fx - x0;
       for (let c = 0; c < 4; c++) {
-        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;
+        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;
         out[(y * width + x) * 4 + c] = a * (1 - ty) + b * ty;
       }
     }
@@ -11425,8 +12103,8 @@ function describeSelection(mask) {
   if (!mask || !mask.bounds) return "No selection";
   let sum = 0;
   for (let i = 0; i < mask.data.length; i++) sum += mask.data[i];
-  const pct2 = sum / 255 / mask.data.length * 100;
-  const shown = pct2 >= 10 ? Math.round(pct2) : Math.round(pct2 * 10) / 10;
+  const pct3 = sum / 255 / mask.data.length * 100;
+  const shown = pct3 >= 10 ? Math.round(pct3) : Math.round(pct3 * 10) / 10;
   return `${mask.bounds.width} \xD7 ${mask.bounds.height} px selected (${shown}% of the image)`;
 }
 
@@ -11746,14 +12424,14 @@ function rebin(bins, count) {
   return out;
 }
 function histogramSummary(h, bins) {
-  const pct2 = (n) => h.samples ? round(n / h.samples * 100) : 0;
+  const pct3 = (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: pct3(h.shadows[0]), green: pct3(h.shadows[1]), blue: pct3(h.shadows[2]) },
+      highlightsPercent: { red: pct3(h.highlights[0]), green: pct3(h.highlights[1]), blue: pct3(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)])) } : {}
@@ -11985,6 +12663,7 @@ function maskSummary(mask) {
   const out = {
     kind: mask.source ? "depth" : "raster",
     enabled: mask.enabled !== false,
+    linked: mask.linked !== false,
     density: mask.density ?? 1,
     feather: mask.feather ?? 0
   };
@@ -12361,23 +13040,29 @@ function createImageLayerTools(controller) {
   const maskProps = {
     name: "set_layer_mask_properties",
     title: "Set layer mask properties",
-    description: "Changes a layer mask's density (0..1), feather (px) or enabled flag; its pixels are kept. One undo step. Returns the mask summary.",
+    description: "Changes a layer mask's density (0..1), feather (px), enabled flag or linked flag; its pixels are kept. An unlinked mask (linked false) stays in place when the layer is moved, transformed or warped; transform it alone with transform_layer target mask. One undo step. Returns the mask summary.",
     inputSchema: {
       type: "object",
       properties: {
         layerId: LAYER_ID2,
         density: { type: "number", minimum: 0, maximum: 1, description: "Density 0..1." },
         feather: { type: "number", minimum: 0, maximum: 1e3, description: "Feather \u03C3 in px." },
-        enabled: { type: "boolean", description: "false ignores the mask but keeps it." }
+        enabled: { type: "boolean", description: "false ignores the mask but keeps it." },
+        linked: { type: "boolean", description: "false unlinks the mask from the layer pixels (it stays put when they move or transform); true links it again." }
       },
       required: ["layerId"],
       additionalProperties: false
     },
     annotations: { title: "Set layer mask properties", ...WRITE_IDEMPOTENT2 },
-    handler: ({ layerId, density, feather, enabled }) => {
+    handler: ({ layerId, density, feather, enabled, linked }) => {
       const id = exists(layerId);
-      if ([density, feather, enabled].every((v) => v === void 0)) throw new LayerOperationError("Give density, feather or enabled.");
-      const mask = controller.setLayerMaskProps(id, { density, feather, enabled });
+      if ([density, feather, enabled, linked].every((v) => v === void 0)) throw new LayerOperationError("Give density, feather, enabled or linked.");
+      const mask = controller.setLayerMaskProps(id, {
+        density,
+        feather,
+        enabled,
+        linked
+      });
       return { layerId: id, mask: maskSummary(mask) };
     }
   };
@@ -12620,7 +13305,7 @@ var DEFS = {
 };
 var nullable = (schema, description) => ({ anyOf: [schema, { type: "null" }], description });
 function settingsSchema(forUpdate) {
-  const opt = (schema, description) => forUpdate ? nullable(schema, `${description} null removes it.`) : { ...schema, description };
+  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.",
@@ -12635,7 +13320,7 @@ function settingsSchema(forUpdate) {
       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: opt({ $ref: "#/$defs/contour" }, "Shadows, glows, satin: coverage contour (default linear)."),
+      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)." },
@@ -12649,14 +13334,14 @@ function settingsSchema(forUpdate) {
       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: opt({ $ref: "#/$defs/contour" }, "bevel-emboss: gloss contour over the shading (default linear)."),
+      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: opt(
+      contourElement: opt2(
         {
           type: "object",
           properties: {
@@ -12669,7 +13354,7 @@ function settingsSchema(forUpdate) {
         },
         "bevel-emboss: the Contour element, shaping the bevel's height profile (default off)."
       ),
-      texture: opt(
+      texture: opt2(
         {
           type: "object",
           properties: {
@@ -13238,6 +13923,248 @@ function createImagePsdTools(controller) {
   return [inspect, open, save];
 }
 
+// src/image-editor/transform-tools.ts
+var READ6 = { 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 = {
+  type: "object",
+  properties: { x: { type: "number", description: "Document pixels from the left." }, y: { type: "number", description: "Document pixels from the top." } },
+  required: ["x", "y"],
+  additionalProperties: false
+};
+var TARGET2 = {
+  layerId: { type: "string", description: "Layer to transform (from list_layers; default the active layer)." },
+  content: {
+    type: "string",
+    enum: FREE_TRANSFORM_CONTENTS.filter((c) => c !== "selection-outline"),
+    description: "What moves: layer (all its pixels with a linked mask), selection (only the selected pixels, committed back into the layer; the outline moves too), selection-copy (Layer via Copy: the selected pixels on a new layer above, then transformed; the original stays) or auto (default: selection when something is selected, else layer)."
+  },
+  channel: {
+    type: "string",
+    enum: ["pixels", "mask"],
+    description: "pixels (default) moves the pixels and a linked mask; mask moves an unlinked mask alone (a linked mask always moves with its pixels)."
+  },
+  interpolation: { type: "string", enum: INTERPOLATIONS, description: "Resampling: nearest (hard pixels), bilinear or bicubic (default, Photoshop\u2019s Bicubic)." }
+};
+var GEOMETRY = {
+  scaleX: { type: "number", description: "Width in percent of the frame (default 100; negative flips horizontally)." },
+  scaleY: { type: "number", description: "Height in percent of the frame (default 100; negative flips vertically)." },
+  rotate: { type: "number", description: "Rotation in degrees, clockwise (default 0)." },
+  skewX: { type: "number", minimum: -89, maximum: 89, description: "Horizontal skew in degrees: vertical edges lean right for positive angles (default 0)." },
+  skewY: { type: "number", minimum: -89, maximum: 89, description: "Vertical skew in degrees: horizontal edges lean down for positive angles (default 0)." },
+  dx: { type: "number", description: "Move right after scaling and rotating, in document pixels (default 0)." },
+  dy: { type: "number", description: "Move down after scaling and rotating, in document pixels (default 0)." },
+  reference: {
+    description: "Fixed point of scale, skew and rotate: an anchor of the frame (top-left, top, top-right, left, center, right, bottom-left, bottom, bottom-right; default center) or a document point {x, y}.",
+    anyOf: [{ type: "string", enum: TRANSFORM_ANCHORS }, POINT]
+  },
+  matrix: {
+    type: "array",
+    items: { type: "number" },
+    minItems: 6,
+    maxItems: 6,
+    description: "Instead of the numeric fields: an affine matrix [a, b, c, d, e, f] in document pixels (x' = a\xB7x + c\xB7y + e, y' = b\xB7x + d\xB7y + f)."
+  },
+  corners: {
+    type: "array",
+    items: POINT,
+    minItems: 4,
+    maxItems: 4,
+    description: "Instead of the numeric fields: where the frame\u2019s corners go, [top-left, top-right, bottom-right, bottom-left] in document pixels (Distort; for Perspective move a pair of corners symmetrically). The quad must stay convex. Get the frame and its corners from get_transform_frame."
+  }
+};
+var NUMERIC = ["scaleX", "scaleY", "rotate", "skewX", "skewY", "dx", "dy", "reference"];
+function geometryFrom(args) {
+  const numeric = NUMERIC.filter((k) => args[k] !== void 0);
+  const ways = [numeric.length > 0, args.matrix !== void 0, args.corners !== void 0].filter(Boolean).length;
+  if (ways === 0) throw new LayerOperationError("Give the transform one way: numeric fields (scaleX, scaleY, rotate, skewX, skewY, dx, dy, reference), matrix, or corners.");
+  if (ways > 1) throw new LayerOperationError("Give the transform only one way: numeric fields, matrix or corners, not a mix.");
+  if (args.matrix !== void 0) return { matrix: args.matrix };
+  if (args.corners !== void 0) return { corners: args.corners };
+  const params = {};
+  for (const k of NUMERIC) if (args[k] !== void 0) params[k] = args[k];
+  if (params.scaleX === 0 || params.scaleY === 0) throw new LayerOperationError("scaleX and scaleY must not be 0 (that collapses the layer to a line).");
+  if (typeof params.reference === "string" && !isTransformAnchor(params.reference)) throw new LayerOperationError(`Unknown reference "${params.reference}". Use ${TRANSFORM_ANCHORS.join(", ")} or {x, y}.`);
+  return { params };
+}
+function targetFrom(args) {
+  const init = {};
+  if (typeof args.layerId === "string") init.layerId = args.layerId;
+  if (args.content !== void 0) init.content = args.content;
+  init.channel = args.channel ?? "pixels";
+  if (args.interpolation !== void 0) init.interpolation = args.interpolation;
+  return init;
+}
+function summary2(res) {
+  return {
+    layerId: res.layerId,
+    content: res.content,
+    moved: res.moved,
+    changed: res.changed,
+    frame: { ...res.box },
+    corners: res.corners.map(roundPoint),
+    bounds: res.bounds
+  };
+}
+function createImageTransformTools(controller) {
+  const getFrame = {
+    name: "get_transform_frame",
+    title: "Get the Free Transform frame",
+    description: "Returns what a transform would move and its frame: content (layer, selection, selection-copy or selection-outline), moved (pixels, mask, selection), the frame (document bounds of the content), its corners [top-left, top-right, bottom-right, bottom-left] and centre. Pass meshColumns / meshRows to also get the identity warp mesh over the frame to edit for warp_layer. Changes nothing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layerId: TARGET2.layerId,
+        content: { type: "string", enum: FREE_TRANSFORM_CONTENTS, description: `${TARGET2.content.description} selection-outline frames the selection outline alone.` },
+        channel: TARGET2.channel,
+        meshColumns: { type: "integer", minimum: 1, maximum: 16, description: "Patch columns of an identity warp mesh to return (omit for none)." },
+        meshRows: { type: "integer", minimum: 1, maximum: 16, description: "Patch rows of an identity warp mesh to return (default meshColumns)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Get the Free Transform frame", ...READ6 },
+    handler: (args) => {
+      const init = targetFrom(args);
+      if (init.content === "selection-copy") init.content = "selection";
+      const s = controller.beginFreeTransform(init);
+      const out = {
+        layerId: s.layerId,
+        content: args.content === "selection-copy" ? "selection-copy" : s.content,
+        moved: [...s.moves],
+        frame: { ...s.box },
+        corners: identityTransform(s.box).corners.map(roundPoint),
+        center: roundPoint({ x: s.box.x + s.box.width / 2, y: s.box.y + s.box.height / 2 })
+      };
+      s.cancel();
+      if (args.meshColumns !== void 0) {
+        const cols = args.meshColumns;
+        const rows = args.meshRows ?? cols;
+        const mesh = identityWarpMesh(s.box, cols, rows);
+        out.mesh = { columns: cols, rows, pointsPerRow: warpMeshColumns(mesh), pointRows: warpMeshRows(mesh), points: mesh.points.map(roundPoint) };
+      }
+      return out;
+    }
+  };
+  const transformLayer = {
+    name: "transform_layer",
+    title: "Free Transform a layer",
+    description: "Edit \u203A Free Transform: scales, rotates, skews, moves, distorts or puts in perspective a pixel layer (with its linked mask), the selected pixels, a copy of them on a new layer, or an unlinked mask. Give the transform one way: the numeric fields (as Photoshop\u2019s options bar, about a reference point), a matrix, or the frame\u2019s new corners (distort / perspective; read the frame with get_transform_frame). Resamples once, tile by tile; one undo step. Returns layerId (the new layer for selection-copy), what moved, the frame, the corners and the new document bounds.",
+    inputSchema: {
+      type: "object",
+      properties: { ...TARGET2, ...GEOMETRY },
+      additionalProperties: false
+    },
+    annotations: { title: "Free Transform a layer", ...WRITE5 },
+    handler: (args) => summary2(controller.transformLayer({ ...targetFrom(args), ...geometryFrom(args) }))
+  };
+  const warpLayer = {
+    name: "warp_layer",
+    title: "Warp a layer",
+    description: "Edit \u203A Transform \u203A Warp: bends a pixel layer (with its linked mask), the selected pixels, a copy of them, or an unlinked mask through a preset (style with bend and distortions in percent) or a B\xE9zier mesh over the frame (get the frame and an identity mesh to edit from get_transform_frame with meshColumns). Give style or mesh, not both. One undo step. Returns what moved and the new document bounds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ...TARGET2,
+        style: { type: "string", enum: WARP_STYLES, description: "Preset warp (Photoshop\u2019s menu): arc, arcLower, arcUpper, arch, bulge, shellLower, shellUpper, flag, wave, fish, rise, fisheye, inflate, squeeze, twist." },
+        bend: { type: "number", minimum: -100, maximum: 100, description: "Preset bend in percent, \u2212100..100 (default 50)." },
+        horizontal: { type: "number", minimum: -100, maximum: 100, description: "Preset horizontal distortion in percent, \u2212100..100 (default 0)." },
+        vertical: { type: "number", minimum: -100, maximum: 100, description: "Preset vertical distortion in percent, \u2212100..100 (default 0)." },
+        orientation: { type: "string", enum: ["horizontal", "vertical"], description: "Bend along the horizontal (default) or vertical axis." },
+        mesh: {
+          type: "object",
+          description: "A custom warp: patch columns and rows, and the (3\xB7columns + 1) \xD7 (3\xB7rows + 1) control points row by row in document pixels (anchors where both indices are multiples of 3, B\xE9zier handles between). Start from get_transform_frame\u2019s identity mesh.",
+          properties: {
+            columns: { type: "integer", minimum: 1, maximum: 16, description: "Patch columns." },
+            rows: { type: "integer", minimum: 1, maximum: 16, description: "Patch rows." },
+            points: { type: "array", items: POINT, minItems: 16, description: "Control points, row by row, document pixels." }
+          },
+          required: ["columns", "rows", "points"],
+          additionalProperties: false
+        }
+      },
+      additionalProperties: false
+    },
+    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.");
+      if (!hasPreset && args.mesh === void 0) throw new LayerOperationError("Give a preset style or a mesh.");
+      let warp;
+      if (hasPreset) {
+        if (args.style === void 0) throw new LayerOperationError(`style is required with a preset. Styles: ${WARP_STYLES.join(", ")}.`);
+        warp = {
+          style: args.style,
+          bend: args.bend ?? 50,
+          horizontal: args.horizontal,
+          vertical: args.vertical,
+          orientation: args.orientation
+        };
+      } else {
+        const m = args.mesh;
+        const want = (3 * m.columns + 1) * (3 * m.rows + 1);
+        if (m.points.length !== want) throw new LayerOperationError(`A ${m.columns} \xD7 ${m.rows} mesh needs (3\xB7${m.columns} + 1) \xD7 (3\xB7${m.rows} + 1) = ${want} points, got ${m.points.length}.`);
+        const knots = (n) => Array.from({ length: n + 1 }, (_, i) => i / n);
+        warp = { us: knots(m.columns), vs: knots(m.rows), points: m.points.map((p) => ({ x: p.x, y: p.y })) };
+      }
+      return summary2(controller.transformLayer({ ...targetFrom(args), warp }));
+    }
+  };
+  const transformSelection = {
+    name: "transform_selection",
+    title: "Transform the selection outline",
+    description: "Select \u203A Transform Selection: scales, rotates, skews, moves or distorts only the selection outline; no pixels change. Give the transform one way: the numeric fields (about a reference point of the selection\u2019s bounds), a matrix, or the new corners of its bounds. Needs a selection. One undo step. Returns the new selection bounds.",
+    inputSchema: {
+      type: "object",
+      properties: { interpolation: { ...TARGET2.interpolation, description: "Resampling of soft edges: nearest, bilinear or bicubic (default)." }, ...GEOMETRY },
+      additionalProperties: false
+    },
+    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 };
+    }
+  };
+  const flipLayer = {
+    name: "flip_layer",
+    title: "Flip a layer",
+    description: "Edit \u203A Transform \u203A Flip Horizontal or Vertical: mirrors a pixel layer (with its linked mask), the selected pixels or a copy of them about the centre of their frame, exactly (no resampling). To flip the whole image use flip_image. One undo step. Returns the new bounds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        axis: { type: "string", enum: ["horizontal", "vertical"], description: "horizontal mirrors left \u2194 right, vertical top \u2194 bottom." },
+        layerId: TARGET2.layerId,
+        content: TARGET2.content,
+        channel: TARGET2.channel
+      },
+      required: ["axis"],
+      additionalProperties: false
+    },
+    annotations: { title: "Flip a layer", ...WRITE5 },
+    handler: (args) => summary2(controller.flipLayer(args.axis, targetFrom(args)))
+  };
+  const rotate90 = {
+    name: "rotate_layer_90",
+    title: "Rotate a layer by quarter turns",
+    description: "Edit \u203A Transform \u203A Rotate 90\xB0 / 180\xB0: turns a pixel layer (with its linked mask), the selected pixels or a copy of them about the centre of their frame, exactly (pixels land on whole pixels; no resampling). To rotate the whole image use set_rotation. One undo step. Returns the new bounds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        turn: { type: "integer", enum: [90, -90, 180], description: "Degrees: 90 clockwise, -90 counter-clockwise, or 180." },
+        layerId: TARGET2.layerId,
+        content: TARGET2.content,
+        channel: TARGET2.channel
+      },
+      required: ["turn"],
+      additionalProperties: false
+    },
+    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/tools.ts
 var LAYER_PATH = /^layers\.([^.]+)\.(.+)$/;
 function adjustmentsSummary(adjustments) {
@@ -13475,6 +14402,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageSelectionTools(controller),
       ...createImageEditTools(controller),
       ...createImageLayerTools(controller),
+      ...createImageTransformTools(controller),
       ...createImageEffectTools(controller),
       ...createImagePaintTools(controller),
       ...createPigmentTools(),
@@ -13686,8 +14614,8 @@ function applyRegionMosaic(imageData, regions, blockSize = 12) {
         const count = bw * bh;
         for (let py = by; py < by + bh; py++) {
           const rowOffset = py * width;
-          for (let px = bx; px < bx + bw; px++) {
-            const idx = (rowOffset + px) * 4;
+          for (let px2 = bx; px2 < bx + bw; px2++) {
+            const idx = (rowOffset + px2) * 4;
             rSum += data[idx];
             gSum += data[idx + 1];
             bSum += data[idx + 2];
@@ -13700,8 +14628,8 @@ function applyRegionMosaic(imageData, regions, blockSize = 12) {
         const aAvg = Math.round(aSum / count);
         for (let py = by; py < by + bh; py++) {
           const rowOffset = py * width;
-          for (let px = bx; px < bx + bw; px++) {
-            const idx = (rowOffset + px) * 4;
+          for (let px2 = bx; px2 < bx + bw; px2++) {
+            const idx = (rowOffset + px2) * 4;
             data[idx] = rAvg;
             data[idx + 1] = gAvg;
             data[idx + 2] = bAvg;
@@ -13919,6 +14847,179 @@ async function runLayerMenuAction(controller, action) {
   }
 }
 
+// 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 effects." };
+  if (layer.type === "adjustment") return { ...empty, available: false, reason: "Adjustment layers cannot have effects." };
+  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 effects." : 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 = (key, label, value, max = 250) => ({ key, label, type: "range", min: 0, max, step: 1, value, unit: "px" });
+var pct2 = (key, label, value, min = 0, max = 1) => ({ key, label, type: "range", min, max, step: 0.01, value, percent: true, unit: "%" });
+var deg = (key, label, value, min = -180, max = 180) => ({ key, 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 },
+    pct2("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" ? pct2("spread", "Spread", e.spread) : pct2("choke", "Choke", e.choke),
+        px("size", "Size", e.size),
+        pct2("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" ? pct2("spread", "Spread", e.spread) : pct2("choke", "Choke", e.choke),
+        px("size", "Size", e.size),
+        pct2("range", "Range", e.range, 0.01, 1),
+        pct2("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"]) },
+        pct2("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 },
+        pct2("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 },
+        pct2("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) },
+        pct2("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, key, value, patterns = []) {
+  const [top, ...rest] = key.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/psd/ui.ts
 var PSD_FILE_ACCEPT = ".psd,.psb,image/vnd.adobe.photoshop,application/x-photoshop";
 function blobBytes(file) {
@@ -13979,6 +15080,9 @@ export {
   DabWalker,
   EMPTY_DISTANCE,
   EMPTY_MIXER_LOAD,
+  FREE_TRANSFORM_CONTENTS,
+  FREE_TRANSFORM_MODES,
+  FreeTransformSession,
   GUIDED_FILTER_EPS,
   HISTOGRAM_BINS,
   HUE_RANGE_LABELS,
@@ -13986,11 +15090,13 @@ export {
   IMAGE_ADJUSTMENT_CONTROLS,
   IMAGE_EDITOR_SCHEMA_VERSION,
   IMAGE_EDITOR_STATE_VERSION,
+  INTERPOLATIONS,
   ImageEditorController,
   ImageEditorRenderer,
   LATEST_PROCESS_VERSION,
   LAYERED_SCHEMA_VERSION,
   LAYER_EFFECT_KINDS,
+  LAYER_EFFECT_MENU,
   LEGACY_PROCESS_VERSION,
   LUMA_709,
   LayerCompositor,
@@ -13999,6 +15105,7 @@ export {
   MAX_BRUSH_SIZE,
   MAX_EFFECT_REACH,
   MAX_KELVIN,
+  MAX_TRANSFORM_PIXELS,
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
   MIXER_DRAIN,
@@ -14034,8 +15141,12 @@ export {
   TINT_SCALE,
   TONE_LUT_SIZE,
   TONE_RANGE_PRESETS,
+  TRANSFORM_ANCHORS,
   TiledSurface,
+  TransformTooLargeError,
   VIBRANCE_GREY,
+  WARP_STYLES,
+  WARP_STYLE_LABELS,
   XYZ_D50_TO_SRGB,
   ZlibError,
   activeAdjustmentLayers,
@@ -14047,16 +15158,19 @@ export {
   adjustmentNodeAsLayer,
   adjustmentNodeFromLegacy,
   adler32,
+  anchorPoint,
   annotationLayerFor,
   annotationLayerName,
   applyAdjustmentLayers,
   applyAdjustments,
   applyBoxBlur,
   applyDepthMask,
+  applyHomography,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
   applyMatrix3,
   applyOutputStage,
+  applyParams,
   applyProcess2Adjustments,
   applyRegionBlur,
   applyRegionMosaic,
@@ -14074,6 +15188,8 @@ export {
   blurFilter,
   borderCoverage,
   boxMean,
+  boxPointOf,
+  boxQuad,
   boxToCurvePoint,
   bradfordAdaptation,
   buildLayerMaskPlanes,
@@ -14093,12 +15209,14 @@ export {
   colorRange,
   combineSelections,
   compileAdjustmentLayer,
+  compositeSurfaceOver,
   computeHistogram,
   computeSelectionBounds,
   contentBounds,
   contractCoverage,
   controlPosition,
   controlTrackBackground,
+  cornersFromMatrix,
   coverageTileCoord,
   coverageToByte,
   coveringRect,
@@ -14111,6 +15229,7 @@ export {
   createImagePaintTools,
   createImagePsdTools,
   createImageSelectionTools,
+  createImageTransformTools,
   createPigment,
   createPigmentTools,
   createSelectionMask,
@@ -14137,6 +15256,7 @@ export {
   describeLayer,
   describeLayerEffects,
   describeSelection,
+  describeTransform,
   deserializeEffects,
   deserializeLayer,
   deserializeLayers,
@@ -14147,11 +15267,13 @@ export {
   developTarget,
   distanceTransform,
   downloadPsd,
+  dragWarpMeshPoint,
   dropPlacement,
   dropZone,
   duplicateLayer,
   edgeWidth,
   effectColorHex,
+  effectControlChange,
   effectReach,
   effectsFingerprint,
   effectsMargin,
@@ -14164,6 +15286,7 @@ export {
   encodeRle,
   encodeSelectionRle,
   encodeSurface,
+  evalWarpMesh,
   evaluateAdjustmentLayers,
   expandCoverage,
   exportPsd,
@@ -14174,9 +15297,11 @@ export {
   findLayerControl,
   finishTile,
   flattenLayers,
+  flipCorners,
   formatControlValue,
   fullSelection,
   gaussianBlur,
+  geometryHomography,
   getAnnotationBounds,
   getControlPath,
   getCropCursor,
@@ -14191,6 +15316,7 @@ export {
   handlePaintShortcut,
   hasActiveEffects,
   hasResampledLegacyMask,
+  hasWarp,
   hashMaskContent,
   hashNoise,
   hexToRgb,
@@ -14198,6 +15324,8 @@ export {
   hitTestAnnotation,
   hitTestCrop,
   hitTestCurvePoint,
+  homographyFromAffine,
+  homographyFromPoints,
   hslToRgb,
   hueRange,
   hueRangeTables,
@@ -14205,6 +15333,8 @@ export {
   hueSaturation,
   identityCurve,
   identityLevels,
+  identityTransform,
+  identityWarpMesh,
   imageEditorStateMigrations,
   imageToCanvasPoint,
   importPsd,
@@ -14212,12 +15342,15 @@ export {
   inflateRaw,
   insertCurvePoint,
   insertLayer,
+  invertHomography,
   invertMatrix3,
   invertSelection,
   isActiveFilter,
   isAdjustmentKind,
   isBlendMode,
   isDefaultDepthMask,
+  isIdentityTransform,
+  isInterpolation,
   isLayerEffectKind,
   isLayerLocked,
   isLegacyShape,
@@ -14229,11 +15362,17 @@ export {
   isSelectionMode,
   isSeparableBlendMode,
   isSpatialFilter,
+  isTransformAnchor,
+  isValidWarp,
   kelvinToTemperature,
+  keysWeight,
   layerBadge,
+  layerEffectControls,
   layerEffectFields,
   layerEffectLabel,
+  layerEffectsBadge,
   layerEffectsOf,
+  layerEffectsPanel,
   layerLabel,
   layerMaskCoverage,
   layerMaskFromSelection,
@@ -14258,6 +15397,8 @@ export {
   mapCropHandle,
   mapLayer,
   maskSummary,
+  matrixFromCorners,
+  matrixFromParams,
   mergeLayerEffect,
   migrateSerializedImageEditorState,
   migrateToLayeredState,
@@ -14308,6 +15449,8 @@ export {
   polygonCoverage,
   polygonSelection,
   posterizeValue,
+  presetWarp,
+  previewStep,
   projectImagePoint,
   projectImageRect,
   projectMaskCoverage,
@@ -14316,6 +15459,7 @@ export {
   psdFileName,
   psdPatternToEffectPattern,
   psdToLayers,
+  pullWarpMesh,
   quickMaskPixels,
   rangeLightness,
   rasterMaskFromLegacy,
@@ -14325,6 +15469,9 @@ export {
   readPsd,
   readRegion,
   rectSelection,
+  rectToQuad,
+  reduceSurface,
+  referencePoint,
   refineCoverage,
   refineEdgeHalo,
   refineSelection,
@@ -14340,6 +15487,7 @@ export {
   requireUnlocked,
   resizePixels,
   resizeSelection,
+  resizeWarpMesh,
   resolveExternalAssets,
   resolveMosaicRegionBounds,
   rgbToGray,
@@ -14395,6 +15543,12 @@ export {
   toneCurve,
   toneLuts,
   toneRange,
+  transformHomography,
+  transformMap,
+  transformSurface,
+  transformedBounds,
+  transformedBox,
+  transformedPoint,
   translateSurface,
   ungroupLayer,
   uniformTile,
@@ -14411,6 +15565,11 @@ export {
   vibranceLinear,
   vibrancePixel,
   walkDabs,
+  warpMeshEditPoints,
+  warpMeshGridCurves,
+  warpMeshParamAt,
+  warpPresetMesh,
+  warpSurface,
   wbMatrix,
   whiteBalanceFromSample,
   whiteBalanceMatrix,