@pixerate/editor 0.97.0 → 0.99.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-OEVSVA6V.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;
@@ -3150,6 +3193,44 @@ var ImageEditorRenderer = class {
       }
       ctx.restore();
     }
+    if (options.freeTransform) {
+      const t = options.freeTransform;
+      ctx.save();
+      try {
+        const scr = (p) => projectImagePoint(p, projection);
+        const outline = t.outline.map(scr);
+        ctx.beginPath();
+        outline.forEach((p, i) => i ? ctx.lineTo(p.x, p.y) : ctx.moveTo(p.x, p.y));
+        ctx.closePath();
+        ctx.lineWidth = 3;
+        ctx.strokeStyle = "rgba(0,0,0,0.5)";
+        ctx.stroke();
+        ctx.lineWidth = 1;
+        ctx.strokeStyle = "#ffffff";
+        ctx.stroke();
+        for (const h of t.handles.map(scr)) {
+          ctx.fillStyle = "#ffffff";
+          ctx.strokeStyle = "#1e293b";
+          ctx.fillRect(h.x - 4, h.y - 4, 8, 8);
+          ctx.strokeRect(h.x - 4, h.y - 4, 8, 8);
+        }
+        const r = scr(t.reference);
+        ctx.beginPath();
+        ctx.arc(r.x, r.y, 5, 0, Math.PI * 2);
+        ctx.moveTo(r.x - 8, r.y);
+        ctx.lineTo(r.x + 8, r.y);
+        ctx.moveTo(r.x, r.y - 8);
+        ctx.lineTo(r.x, r.y + 8);
+        ctx.lineWidth = 3;
+        ctx.strokeStyle = "rgba(0,0,0,0.5)";
+        ctx.stroke();
+        ctx.lineWidth = 1;
+        ctx.strokeStyle = "#ffffff";
+        ctx.stroke();
+      } catch {
+      }
+      ctx.restore();
+    }
     if (isActivelyCropping) {
       const activeCrop = options.draftCrop !== void 0 && options.draftCrop !== null ? options.draftCrop : crop ?? { x: 0, y: 0, width: naturalWidth, height: naturalHeight };
       this.drawCropOverlay(ctx, getViewportMetrics(geoState, vpWidth, vpHeight, true, activeCrop));
@@ -3958,7 +4039,7 @@ function removeAnnotationLayers(layers) {
 function polygonCoverage(points, width, height, antiAlias = true) {
   const m = new Float32Array(width * height);
   if (points.length < 3 || width <= 0 || height <= 0) return m;
-  const sub = antiAlias ? 4 : 1;
+  const sub2 = antiAlias ? 4 : 1;
   const edges = [];
   for (let i = 0; i < points.length; i++) {
     const a = points[i];
@@ -3973,8 +4054,8 @@ function polygonCoverage(points, width, height, antiAlias = true) {
   const xs = [];
   for (let py = 0; py < height; py++) {
     const row = py * width;
-    for (let s = 0; s < sub; s++) {
-      const y = py + (s + 0.5) / sub;
+    for (let s = 0; s < sub2; s++) {
+      const y = py + (s + 0.5) / sub2;
       while (next < edges.length && edges[next].top <= y) active.push(edges[next++]);
       if (active.length) active = active.filter((e) => e.bottom > y);
       if (!active.length) continue;
@@ -3996,7 +4077,7 @@ function polygonCoverage(points, width, height, antiAlias = true) {
             const c = cx + 0.5;
             cov = c >= x0 && c < x1 ? 1 : 0;
           }
-          if (cov > 0) m[row + cx] += cov / sub;
+          if (cov > 0) m[row + cx] += cov / sub2;
         }
       }
     }
@@ -4584,6 +4665,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) {
@@ -4720,6 +4802,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 +5072,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 +6263,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 +7693,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 +7980,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 +8178,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) {
@@ -9038,7 +9622,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.`);
@@ -9130,6 +9714,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);
@@ -10506,7 +11218,7 @@ var ImageEditorController = class {
     const canvas = { x: 0, y: 0, width, height };
     const warnings = [];
     const note = /* @__PURE__ */ new Map();
-    const add = (msg, name) => note.set(msg, [...note.get(msg) ?? [], name]);
+    const add2 = (msg, name) => note.set(msg, [...note.get(msg) ?? [], name]);
     const canRasterize = this.renderer.canRasterize();
     await this.renderer.prepareLayerAssets(this.state.layers, width, height);
     const sources = this.renderer.compositorSources(width, height);
@@ -10514,7 +11226,7 @@ var ImageEditorController = class {
     const bakeMask = (layer) => {
       const mask = layer.mask;
       if (!mask?.source) return mask;
-      add("Parametric (depth) masks were baked into pixel masks", layer.name);
+      add2("Parametric (depth) masks were baked into pixel masks", layer.name);
       const plain3 = { ...layer, mask: { ...mask, density: 1, feather: 0, enabled: true } };
       const ox = layer.type === "pixel" ? layer.offset.x : 0;
       const oy = layer.type === "pixel" ? layer.offset.y : 0;
@@ -10530,7 +11242,7 @@ var ImageEditorController = class {
     };
     const prepare = async (layer) => {
       const p = await prepareLayer(layer);
-      if (p?.blend === "pigment") add("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
+      if (p?.blend === "pigment") add2("The Pigment blend mode has no PSD equivalent and was written as Normal", layer.name);
       return p;
     };
     const prepareLayer = async (layer) => {
@@ -10545,10 +11257,10 @@ var ImageEditorController = class {
       if (layer.type === "adjustment") return { ...layer, mask: bakeMask(layer) };
       if (layer.type === "annotation") {
         if (!canRasterize) {
-          add("Annotation layers need a canvas (a browser) to rasterize and were left out", layer.name);
+          add2("Annotation layers need a canvas (a browser) to rasterize and were left out", layer.name);
           return null;
         }
-        add("Annotation layers were written as pixel layers", layer.name);
+        add2("Annotation layers were written as pixel layers", layer.name);
         const blend = layer.blend === "normal" && layer.annotation.blend ? layer.annotation.blend : layer.blend;
         const content = { ...layer, visible: true, opacity: 1, blend: "normal", annotation: { ...layer.annotation, blend: void 0 } };
         delete content.mask;
@@ -10579,7 +11291,7 @@ var ImageEditorController = class {
       }
       const active = layer.filters?.filter(isActiveFilter) ?? [];
       if (active.length) {
-        add("Layer filters (develop, blur) were baked into the pixels", layer.name);
+        add2("Layer filters (develop, blur) were baked into the pixels", layer.name);
         const content = { ...out, visible: true, opacity: 1, blend: "normal" };
         delete content.mask;
         delete content.clipped;
@@ -10588,7 +11300,7 @@ var ImageEditorController = class {
         const data = compositor.composite([content], canvas, sources);
         out = { ...out, surface: surfaceFromPixels({ width, height, data }, 4, -layer.offset.x, -layer.offset.y) };
       }
-      if (layer.filters?.some((f) => !f.enabled)) add("Disabled layer filters were left out", layer.name);
+      if (layer.filters?.some((f) => !f.enabled)) add2("Disabled layer filters were left out", layer.name);
       delete out.filters;
       const mask = bakeMask(layer);
       if (mask) out.mask = mask;
@@ -10868,6 +11580,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) {
@@ -11985,6 +12701,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 +13078,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) };
     }
   };
@@ -12731,7 +13454,7 @@ function createImageEffectTools(controller) {
     annotations: { title: "List layer effects", ...READ3 },
     handler: ({ layerId }) => result(layerArg(layerId), { globalLight: controller.getGlobalLight(), patterns: patternList(controller), kinds: [...LAYER_EFFECT_KINDS] })
   };
-  const add = {
+  const add2 = {
     name: "add_layer_effect",
     title: "Add a layer effect",
     description: "Adds a live effect to a pixel, 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.",
@@ -12829,7 +13552,7 @@ function createImageEffectTools(controller) {
       return { globalLight: controller.setGlobalLight(next) };
     }
   };
-  return [list2, add, update, remove, setEnabled, light];
+  return [list2, add2, update, remove, setEnabled, light];
 }
 
 // src/image-editor/layers/paint-ui.ts
@@ -13238,6 +13961,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 +14440,7 @@ function createImageEditorToolProvider(controller, options = {}) {
       ...createImageSelectionTools(controller),
       ...createImageEditTools(controller),
       ...createImageLayerTools(controller),
+      ...createImageTransformTools(controller),
       ...createImageEffectTools(controller),
       ...createImagePaintTools(controller),
       ...createPigmentTools(),
@@ -13851,6 +14817,7 @@ function layerMenu(controller) {
     { action: "apply-mask", label: "Apply Layer Mask", enabled: isPixel && Boolean(active?.mask) },
     { action: "delete-mask", label: "Delete Layer Mask", enabled: Boolean(active?.mask) },
     { action: "toggle-mask", label: active?.mask?.enabled === false ? "Enable Layer Mask" : "Disable Layer Mask", enabled: Boolean(active?.mask) },
+    { action: "toggle-mask-link", label: active?.mask?.linked === false ? "Link Layer Mask" : "Unlink Layer Mask", enabled: Boolean(active?.mask && !active.mask.source) },
     { action: "rasterize", label: "Rasterize Layer", enabled: active?.type === "annotation" || isPixel && Boolean(active?.type === "pixel" && active.filters?.length) },
     { action: "toggle-clip", label: active?.clipped ? "Release Clipping Mask" : "Create Clipping Mask", enabled: Boolean(loc && loc.index > 0) }
   ];
@@ -13906,6 +14873,9 @@ async function runLayerMenuAction(controller, action) {
       case "toggle-mask":
         if (id && active?.mask) controller.setLayerMaskProps(id, { enabled: active.mask.enabled === false });
         break;
+      case "toggle-mask-link":
+        if (id && active?.mask) controller.setLayerMaskProps(id, { linked: active.mask.linked === false });
+        break;
       case "rasterize":
         if (id) await controller.rasterizeLayer(id);
         break;
@@ -14124,6 +15094,445 @@ async function downloadPsd(controller, name = "image") {
   }
   return { fileName, warnings: res.warnings };
 }
+
+// src/image-editor/layers/transform-ui.ts
+var CORNERS = ["nw", "ne", "se", "sw"];
+var SIDES = ["n", "e", "s", "w"];
+var CORNER_INDEX = { nw: 0, ne: 1, se: 2, sw: 3 };
+var SIDE_CORNERS = { n: [0, 1], e: [1, 2], s: [2, 3], w: [3, 0] };
+var HANDLE_FRACTION = { nw: [0, 0], n: [0.5, 0], ne: [1, 0], e: [1, 0.5], se: [1, 1], s: [0.5, 1], sw: [0, 1], w: [0, 0.5] };
+var ANCHOR_FRACTION2 = {
+  "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]
+};
+var FREE_TRANSFORM_MODE_OPTIONS = [
+  { id: "scale", label: "Free", title: "Free Transform: corners scale, outside rotates, Ctrl/Cmd distorts" },
+  { id: "rotate", label: "Rotate", title: "Every handle rotates about the reference point" },
+  { id: "skew", label: "Skew", title: "Sides slide along themselves" },
+  { id: "distort", label: "Distort", title: "Each corner moves freely" },
+  { id: "perspective", label: "Perspective", title: "A corner and its partner move symmetrically" }
+];
+var FREE_TRANSFORM_FIELDS = [
+  { id: "x", label: "X", unit: "px", title: "Reference point X (document pixels)" },
+  { id: "y", label: "Y", unit: "px", title: "Reference point Y (document pixels)" },
+  { id: "scaleX", label: "W", unit: "%", title: "Width in percent of the original" },
+  { id: "scaleY", label: "H", unit: "%", title: "Height in percent of the original" },
+  { id: "rotate", label: "\u2220", unit: "\xB0", title: "Rotation in degrees, clockwise" },
+  { id: "skewX", label: "H skew", unit: "\xB0", title: "Horizontal skew in degrees" },
+  { id: "skewY", label: "V skew", unit: "\xB0", title: "Vertical skew in degrees" }
+];
+var CURSOR = {
+  nw: "nwse-resize",
+  se: "nwse-resize",
+  ne: "nesw-resize",
+  sw: "nesw-resize",
+  n: "ns-resize",
+  s: "ns-resize",
+  e: "ew-resize",
+  w: "ew-resize",
+  reference: "move",
+  inside: "move",
+  outside: "alias"
+};
+var mod = (m) => Boolean(m.ctrlKey || m.metaKey);
+var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
+var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
+function rotateAbout(p, c, rad) {
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  const d = sub(p, c);
+  return { x: c.x + d.x * cos - d.y * sin, y: c.y + d.x * sin + d.y * cos };
+}
+function insideQuad(q2, p) {
+  let sign = 0;
+  for (let i = 0; i < 4; i++) {
+    const a = q2[i];
+    const b = q2[(i + 1) % 4];
+    const c = (b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x);
+    if (Math.abs(c) < 1e-12) continue;
+    const s = Math.sign(c);
+    if (sign && s !== sign) return false;
+    sign = s;
+  }
+  return true;
+}
+var FreeTransformTool = class {
+  constructor(controller, options = {}) {
+    this.controller = controller;
+    this.options = options;
+  }
+  controller;
+  options;
+  sessionRef = null;
+  modeValue = "scale";
+  /** The reference point in the untransformed frame's space (follows the transform). */
+  refBox = { x: 0, y: 0 };
+  corners = null;
+  drag = null;
+  pending = false;
+  viewScale = 1;
+  viewClip;
+  /** Values typed into the options bar since the last drag (V skew is not recovered from the shape). */
+  typed = {};
+  /** Width and height scale together when typed (the chain icon). */
+  proportional = true;
+  error = null;
+  lastResult = null;
+  get active() {
+    return Boolean(this.sessionRef?.isOpen);
+  }
+  get session() {
+    return this.active ? this.sessionRef : null;
+  }
+  get mode() {
+    return this.modeValue;
+  }
+  get interpolation() {
+    return this.sessionRef?.interpolation ?? "bicubic";
+  }
+  listeners = /* @__PURE__ */ new Set();
+  /** Calls `listener` whenever the overlay, readout, mode or error changes. Returns the unsubscribe. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  changed() {
+    this.options.onChange?.();
+    for (const l of this.listeners) l();
+  }
+  /** Opens a Free Transform (default: the selected pixels of the active layer, or the whole layer). Returns an error message or `null`. */
+  begin(init = {}) {
+    if (this.active) return null;
+    try {
+      if (!init.layerId && init.content !== "selection-outline" && !this.controller.getState().activeLayerId) {
+        const top = [...flattenLayers(this.controller.getState().layers)].reverse().find((l) => l.type === "pixel" && l.visible);
+        if (top) this.controller.setActiveLayer(top.id);
+      }
+      const s = this.controller.beginFreeTransform(init);
+      this.sessionRef = s;
+      this.corners = s.geometry.corners;
+      this.refBox = { x: s.box.x + s.box.width / 2, y: s.box.y + s.box.height / 2 };
+      this.modeValue = "scale";
+      this.typed = {};
+      this.error = null;
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+    }
+    this.changed();
+    return this.error;
+  }
+  setMode(mode) {
+    this.modeValue = mode;
+    this.changed();
+  }
+  /** Sets the reference point to an anchor of the frame (the options bar's locator). */
+  setReference(anchor) {
+    const s = this.session;
+    if (!s) return;
+    const [fx, fy] = ANCHOR_FRACTION2[anchor];
+    this.refBox = { x: s.box.x + fx * s.box.width, y: s.box.y + fy * s.box.height };
+    this.changed();
+  }
+  setInterpolation(interpolation) {
+    const s = this.session;
+    if (!s) return;
+    this.run(() => s.update({ interpolation }, false));
+  }
+  /** Screen pixels per document pixel and the visible document area, for previews. */
+  setView(scale, clip) {
+    this.viewScale = scale > 0 ? scale : 1;
+    this.viewClip = clip;
+  }
+  homography() {
+    const s = this.session;
+    return s && this.corners ? rectToQuad(s.box, this.corners) : null;
+  }
+  /** The reference point in document pixels. */
+  referencePoint() {
+    const h = this.homography();
+    return h ? applyHomography(h, this.refBox) : null;
+  }
+  /** The outline, handles and reference point to draw, or `null` when no transform is open. */
+  overlay() {
+    const s = this.session;
+    const h = this.homography();
+    if (!s || !h || !this.corners) return null;
+    const handles = [...CORNERS, ...SIDES].map((id) => {
+      const [fx, fy] = HANDLE_FRACTION[id];
+      const p = applyHomography(h, { x: s.box.x + fx * s.box.width, y: s.box.y + fy * s.box.height }) ?? { x: 0, y: 0 };
+      return { id, x: p.x, y: p.y };
+    });
+    return { outline: this.corners.map((p) => ({ x: p.x, y: p.y })), handles, reference: this.referencePoint() ?? { x: 0, y: 0 } };
+  }
+  /** What a document point is over (`tolerance` in document pixels: a few screen pixels / scale). */
+  hit(p, tolerance) {
+    const o = this.overlay();
+    if (!o) return null;
+    let best = null;
+    let bestD = tolerance;
+    for (const h of o.handles) {
+      const d = Math.hypot(h.x - p.x, h.y - p.y);
+      if (d <= bestD) {
+        best = h.id;
+        bestD = d;
+      }
+    }
+    if (Math.hypot(o.reference.x - p.x, o.reference.y - p.y) < bestD) best = "reference";
+    if (best) return best;
+    return insideQuad(o.outline, p) ? "inside" : "outside";
+  }
+  /** The CSS cursor for a handle. */
+  cursor(handle) {
+    if (!handle) return "default";
+    if (this.modeValue === "rotate" && handle !== "inside" && handle !== "reference") return CURSOR.outside;
+    return CURSOR[handle];
+  }
+  /** Starts a drag on what `p` is over. */
+  down(p, tolerance) {
+    if (!this.session || !this.corners) return null;
+    const handle = this.hit(p, tolerance);
+    if (!handle) return null;
+    this.drag = { handle, start: { x: p.x, y: p.y }, corners: this.corners, refBox: { ...this.refBox }, ref: this.referencePoint() ?? p };
+    return handle;
+  }
+  /** Continues the drag to `p` with the modifiers held now. */
+  move(p, m = {}) {
+    const d = this.drag;
+    const s = this.session;
+    if (!d || !s) return;
+    if (d.handle === "reference") {
+      const h = rectToQuad(s.box, d.corners);
+      const inv = h && invertHomography(h);
+      const q2 = inv && applyHomography(inv, p);
+      if (q2) this.refBox = q2;
+      this.changed();
+      return;
+    }
+    const corners = this.dragCorners(d, p, m);
+    if (corners) this.setCorners(corners);
+  }
+  /** Ends the drag (the transform stays open). */
+  up() {
+    this.drag = null;
+  }
+  dragCorners(d, p, m) {
+    const s = this.session;
+    const c0 = d.corners;
+    let delta = sub(p, d.start);
+    const map = (f) => c0.map(f);
+    const handle = d.handle;
+    const isCorner = handle in CORNER_INDEX;
+    const isSide = handle in SIDE_CORNERS;
+    const rotating = handle === "outside" || this.modeValue === "rotate" && (isCorner || isSide);
+    if (handle === "inside") {
+      if (m.shiftKey) delta = Math.abs(delta.x) >= Math.abs(delta.y) ? { x: delta.x, y: 0 } : { x: 0, y: delta.y };
+      return map((q3) => add(q3, delta));
+    }
+    if (rotating) {
+      const r = d.ref;
+      let a = Math.atan2(p.y - r.y, p.x - r.x) - Math.atan2(d.start.y - r.y, d.start.x - r.x);
+      if (m.shiftKey) a = Math.round(a / (Math.PI / 12)) * (Math.PI / 12);
+      return map((q3) => rotateAbout(q3, r, a));
+    }
+    const perspective = this.modeValue === "perspective" || mod(m) && m.altKey && m.shiftKey;
+    const distort = this.modeValue === "distort" || mod(m) && !perspective;
+    const skew = this.modeValue === "skew" || mod(m) && isSide;
+    if (isSide && (skew || perspective)) {
+      const [i, j] = SIDE_CORNERS[handle];
+      const dir = sub(c0[j], c0[i]);
+      const len = Math.hypot(dir.x, dir.y) || 1;
+      const t = (delta.x * dir.x + delta.y * dir.y) / len;
+      const v = { x: dir.x / len * t, y: dir.y / len * t };
+      const [oi, oj] = SIDE_CORNERS[{ n: "s", s: "n", e: "w", w: "e" }[handle]];
+      return map((q3, k) => k === i || k === j ? add(q3, v) : m.altKey && (k === oi || k === oj) ? sub(q3, v) : q3);
+    }
+    if (isCorner && perspective) {
+      const k = CORNER_INDEX[handle];
+      if (Math.abs(delta.x) >= Math.abs(delta.y)) {
+        const partner2 = [1, 0, 3, 2][k];
+        return map((q3, i) => i === k ? { x: q3.x + delta.x, y: q3.y } : i === partner2 ? { x: q3.x - delta.x, y: q3.y } : q3);
+      }
+      const partner = [3, 2, 1, 0][k];
+      return map((q3, i) => i === k ? { x: q3.x, y: q3.y + delta.y } : i === partner ? { x: q3.x, y: q3.y - delta.y } : q3);
+    }
+    if (distort || isCorner && this.modeValue === "skew") {
+      if (isCorner) return map((q3, i2) => i2 === CORNER_INDEX[handle] ? add(q3, delta) : q3);
+      const [i, j] = SIDE_CORNERS[handle];
+      return map((q3, k) => k === i || k === j ? add(q3, delta) : q3);
+    }
+    const h = rectToQuad(s.box, c0);
+    const inv = h && invertHomography(h);
+    if (!h || !inv) return null;
+    const q2 = applyHomography(inv, p);
+    const q0 = applyHomography(inv, d.start);
+    if (!q2 || !q0) return null;
+    const b = s.box;
+    const [fx, fy] = HANDLE_FRACTION[handle];
+    const grab = { x: b.x + fx * b.width, y: b.y + fy * b.height };
+    const anchor = m.altKey ? d.refBox : { x: b.x + (1 - fx) * b.width, y: b.y + (1 - fy) * b.height };
+    const target = add(grab, sub(q2, q0));
+    const ax = grab.x - anchor.x;
+    const ay = grab.y - anchor.y;
+    let sx = isCorner || handle === "e" || handle === "w" ? Math.abs(ax) > 1e-9 ? (target.x - anchor.x) / ax : 1 : 1;
+    let sy = isCorner || handle === "n" || handle === "s" ? Math.abs(ay) > 1e-9 ? (target.y - anchor.y) / ay : 1 : 1;
+    if (isCorner && !m.shiftKey) {
+      const k = Math.abs(sx) >= Math.abs(sy) ? sx : sy;
+      sx = k;
+      sy = k;
+    }
+    const scaled = [
+      { x: b.x, y: b.y },
+      { x: b.x + b.width, y: b.y },
+      { x: b.x + b.width, y: b.y + b.height },
+      { x: b.x, y: b.y + b.height }
+    ].map((c) => applyHomography(h, { x: anchor.x + (c.x - anchor.x) * sx, y: anchor.y + (c.y - anchor.y) * sy }));
+    return scaled.every(Boolean) ? scaled : null;
+  }
+  /** Sets new corners and refreshes the preview (scheduled). Invalid shapes keep the last good one. */
+  setCorners(corners) {
+    const s = this.session;
+    if (!s) return;
+    const h = rectToQuad(s.box, corners);
+    if (!h) return;
+    this.corners = corners;
+    this.typed = {};
+    this.changed();
+    this.preview();
+  }
+  preview() {
+    if (this.pending) return;
+    this.pending = true;
+    const run = () => {
+      this.pending = false;
+      const s = this.session;
+      if (!s || !this.corners) return;
+      this.run(() => s.update({ corners: this.corners }, { scale: this.viewScale, clip: this.viewClip }));
+    };
+    if (this.options.schedule) this.options.schedule(run);
+    else run();
+  }
+  run(fn) {
+    try {
+      fn();
+      this.error = null;
+    } catch (e) {
+      this.error = e instanceof Error ? e.message : String(e);
+      if (this.sessionRef && !this.sessionRef.isOpen) this.sessionRef = null;
+    }
+    this.changed();
+  }
+  /** The options bar's numbers for the current shape. */
+  bar() {
+    const s = this.session;
+    if (!s || !this.corners) return null;
+    const read = describeTransform({ box: s.box, corners: this.corners }, this.refBox);
+    return {
+      affine: read.affine,
+      x: this.typed.x ?? read.x,
+      y: this.typed.y ?? read.y,
+      scaleX: this.typed.scaleX ?? read.scaleX,
+      scaleY: this.typed.scaleY ?? read.scaleY,
+      rotate: this.typed.rotate ?? read.rotate,
+      skewX: this.typed.skewX ?? read.skewX,
+      skewY: this.typed.skewY ?? 0
+    };
+  }
+  /** Applies a typed options-bar value (W and H together while `proportional`). */
+  setField(field, value) {
+    const s = this.session;
+    const cur = this.bar();
+    if (!s || !cur || !Number.isFinite(value)) return;
+    const next = { ...cur, [field]: value };
+    if (this.proportional && field === "scaleX") next.scaleY = cur.scaleY === 0 ? value : value / cur.scaleX * cur.scaleY;
+    if (this.proportional && field === "scaleY") next.scaleX = cur.scaleX === 0 ? value : value / cur.scaleY * cur.scaleX;
+    if (!next.scaleX || !next.scaleY) {
+      this.error = "Width and height must not be 0 %.";
+      this.changed();
+      return;
+    }
+    const m = matrixFromParams(s.box, {
+      scaleX: next.scaleX,
+      scaleY: next.scaleY,
+      rotate: next.rotate,
+      skewX: next.skewX,
+      skewY: next.skewY,
+      reference: this.refBox,
+      dx: next.x - this.refBox.x,
+      dy: next.y - this.refBox.y
+    });
+    this.setCorners(cornersFromMatrix(s.box, m));
+    this.typed = { scaleX: next.scaleX, scaleY: next.scaleY, rotate: next.rotate, skewX: next.skewX, skewY: next.skewY, x: next.x, y: next.y };
+    this.changed();
+  }
+  /** Finishes with full-quality resampling (one undo step). */
+  commit() {
+    const s = this.session;
+    if (!s) return null;
+    let res = null;
+    this.pending = false;
+    this.run(() => {
+      if (this.corners) s.update({ corners: this.corners }, false);
+      res = s.commit();
+    });
+    this.lastResult = res;
+    this.sessionRef = null;
+    this.corners = null;
+    this.drag = null;
+    this.changed();
+    return res;
+  }
+  /** Abandons the transform and restores everything. */
+  cancel() {
+    this.sessionRef?.cancel();
+    this.sessionRef = null;
+    this.corners = null;
+    this.drag = null;
+    this.pending = false;
+    this.error = null;
+    this.changed();
+  }
+  /**
+   * Keyboard: Enter commits, Escape cancels, arrows nudge by 1 px (Shift: 10). Ctrl/Cmd+T opens a
+   * Free Transform when none is open. Returns true when the key was used (prevent its default).
+   */
+  key(e) {
+    const t = e.target;
+    const typing = Boolean(t && (t.isContentEditable || t.tagName === "INPUT" || t.tagName === "TEXTAREA" || t.tagName === "SELECT"));
+    if (!this.active) {
+      if ((e.ctrlKey || e.metaKey) && !e.altKey && e.key.toLowerCase() === "t" && !typing) {
+        this.begin();
+        return true;
+      }
+      return false;
+    }
+    if (e.key === "Enter") {
+      this.commit();
+      return true;
+    }
+    if (e.key === "Escape") {
+      this.cancel();
+      return true;
+    }
+    if (typing) return false;
+    const step = e.shiftKey ? 10 : 1;
+    const nudge = { ArrowLeft: { x: -step, y: 0 }, ArrowRight: { x: step, y: 0 }, ArrowUp: { x: 0, y: -step }, ArrowDown: { x: 0, y: step } };
+    const v = nudge[e.key];
+    if (v && this.corners) {
+      this.setCorners(this.corners.map((q2) => add(q2, v)));
+      return true;
+    }
+    return false;
+  }
+};
 export {
   ADJUSTMENT_KEYS,
   ADJUSTMENT_KINDS,
@@ -14152,6 +15561,12 @@ export {
   DabWalker,
   EMPTY_DISTANCE,
   EMPTY_MIXER_LOAD,
+  FREE_TRANSFORM_CONTENTS,
+  FREE_TRANSFORM_FIELDS,
+  FREE_TRANSFORM_MODES,
+  FREE_TRANSFORM_MODE_OPTIONS,
+  FreeTransformSession,
+  FreeTransformTool,
   GUIDED_FILTER_EPS,
   HISTOGRAM_BINS,
   HUE_RANGE_LABELS,
@@ -14159,6 +15574,7 @@ export {
   IMAGE_ADJUSTMENT_CONTROLS,
   IMAGE_EDITOR_SCHEMA_VERSION,
   IMAGE_EDITOR_STATE_VERSION,
+  INTERPOLATIONS,
   ImageEditorController,
   ImageEditorRenderer,
   LATEST_PROCESS_VERSION,
@@ -14173,6 +15589,7 @@ export {
   MAX_BRUSH_SIZE,
   MAX_EFFECT_REACH,
   MAX_KELVIN,
+  MAX_TRANSFORM_PIXELS,
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
   MIXER_DRAIN,
@@ -14208,8 +15625,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,
@@ -14221,16 +15642,19 @@ export {
   adjustmentNodeAsLayer,
   adjustmentNodeFromLegacy,
   adler32,
+  anchorPoint,
   annotationLayerFor,
   annotationLayerName,
   applyAdjustmentLayers,
   applyAdjustments,
   applyBoxBlur,
   applyDepthMask,
+  applyHomography,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
   applyMatrix3,
   applyOutputStage,
+  applyParams,
   applyProcess2Adjustments,
   applyRegionBlur,
   applyRegionMosaic,
@@ -14248,6 +15672,8 @@ export {
   blurFilter,
   borderCoverage,
   boxMean,
+  boxPointOf,
+  boxQuad,
   boxToCurvePoint,
   bradfordAdaptation,
   buildLayerMaskPlanes,
@@ -14267,12 +15693,14 @@ export {
   colorRange,
   combineSelections,
   compileAdjustmentLayer,
+  compositeSurfaceOver,
   computeHistogram,
   computeSelectionBounds,
   contentBounds,
   contractCoverage,
   controlPosition,
   controlTrackBackground,
+  cornersFromMatrix,
   coverageTileCoord,
   coverageToByte,
   coveringRect,
@@ -14285,6 +15713,7 @@ export {
   createImagePaintTools,
   createImagePsdTools,
   createImageSelectionTools,
+  createImageTransformTools,
   createPigment,
   createPigmentTools,
   createSelectionMask,
@@ -14311,6 +15740,7 @@ export {
   describeLayer,
   describeLayerEffects,
   describeSelection,
+  describeTransform,
   deserializeEffects,
   deserializeLayer,
   deserializeLayers,
@@ -14321,6 +15751,7 @@ export {
   developTarget,
   distanceTransform,
   downloadPsd,
+  dragWarpMeshPoint,
   dropPlacement,
   dropZone,
   duplicateLayer,
@@ -14339,6 +15770,7 @@ export {
   encodeRle,
   encodeSelectionRle,
   encodeSurface,
+  evalWarpMesh,
   evaluateAdjustmentLayers,
   expandCoverage,
   exportPsd,
@@ -14349,9 +15781,11 @@ export {
   findLayerControl,
   finishTile,
   flattenLayers,
+  flipCorners,
   formatControlValue,
   fullSelection,
   gaussianBlur,
+  geometryHomography,
   getAnnotationBounds,
   getControlPath,
   getCropCursor,
@@ -14366,6 +15800,7 @@ export {
   handlePaintShortcut,
   hasActiveEffects,
   hasResampledLegacyMask,
+  hasWarp,
   hashMaskContent,
   hashNoise,
   hexToRgb,
@@ -14373,6 +15808,8 @@ export {
   hitTestAnnotation,
   hitTestCrop,
   hitTestCurvePoint,
+  homographyFromAffine,
+  homographyFromPoints,
   hslToRgb,
   hueRange,
   hueRangeTables,
@@ -14380,6 +15817,8 @@ export {
   hueSaturation,
   identityCurve,
   identityLevels,
+  identityTransform,
+  identityWarpMesh,
   imageEditorStateMigrations,
   imageToCanvasPoint,
   importPsd,
@@ -14387,12 +15826,15 @@ export {
   inflateRaw,
   insertCurvePoint,
   insertLayer,
+  invertHomography,
   invertMatrix3,
   invertSelection,
   isActiveFilter,
   isAdjustmentKind,
   isBlendMode,
   isDefaultDepthMask,
+  isIdentityTransform,
+  isInterpolation,
   isLayerEffectKind,
   isLayerLocked,
   isLegacyShape,
@@ -14404,7 +15846,10 @@ export {
   isSelectionMode,
   isSeparableBlendMode,
   isSpatialFilter,
+  isTransformAnchor,
+  isValidWarp,
   kelvinToTemperature,
+  keysWeight,
   layerBadge,
   layerEffectControls,
   layerEffectFields,
@@ -14436,6 +15881,8 @@ export {
   mapCropHandle,
   mapLayer,
   maskSummary,
+  matrixFromCorners,
+  matrixFromParams,
   mergeLayerEffect,
   migrateSerializedImageEditorState,
   migrateToLayeredState,
@@ -14486,6 +15933,8 @@ export {
   polygonCoverage,
   polygonSelection,
   posterizeValue,
+  presetWarp,
+  previewStep,
   projectImagePoint,
   projectImageRect,
   projectMaskCoverage,
@@ -14494,6 +15943,7 @@ export {
   psdFileName,
   psdPatternToEffectPattern,
   psdToLayers,
+  pullWarpMesh,
   quickMaskPixels,
   rangeLightness,
   rasterMaskFromLegacy,
@@ -14503,6 +15953,9 @@ export {
   readPsd,
   readRegion,
   rectSelection,
+  rectToQuad,
+  reduceSurface,
+  referencePoint,
   refineCoverage,
   refineEdgeHalo,
   refineSelection,
@@ -14518,6 +15971,7 @@ export {
   requireUnlocked,
   resizePixels,
   resizeSelection,
+  resizeWarpMesh,
   resolveExternalAssets,
   resolveMosaicRegionBounds,
   rgbToGray,
@@ -14573,6 +16027,12 @@ export {
   toneCurve,
   toneLuts,
   toneRange,
+  transformHomography,
+  transformMap,
+  transformSurface,
+  transformedBounds,
+  transformedBox,
+  transformedPoint,
   translateSurface,
   ungroupLayer,
   uniformTile,
@@ -14589,6 +16049,11 @@ export {
   vibranceLinear,
   vibrancePixel,
   walkDabs,
+  warpMeshEditPoints,
+  warpMeshGridCurves,
+  warpMeshParamAt,
+  warpPresetMesh,
+  warpSurface,
   wbMatrix,
   whiteBalanceFromSample,
   whiteBalanceMatrix,