@pixerate/editor 0.97.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-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;
@@ -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) {
@@ -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) {
@@ -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.`);
@@ -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);
@@ -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) {
@@ -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) };
     }
   };
@@ -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(),
@@ -14152,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,
@@ -14159,6 +15090,7 @@ export {
   IMAGE_ADJUSTMENT_CONTROLS,
   IMAGE_EDITOR_SCHEMA_VERSION,
   IMAGE_EDITOR_STATE_VERSION,
+  INTERPOLATIONS,
   ImageEditorController,
   ImageEditorRenderer,
   LATEST_PROCESS_VERSION,
@@ -14173,6 +15105,7 @@ export {
   MAX_BRUSH_SIZE,
   MAX_EFFECT_REACH,
   MAX_KELVIN,
+  MAX_TRANSFORM_PIXELS,
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
   MIXER_DRAIN,
@@ -14208,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,
@@ -14221,16 +15158,19 @@ export {
   adjustmentNodeAsLayer,
   adjustmentNodeFromLegacy,
   adler32,
+  anchorPoint,
   annotationLayerFor,
   annotationLayerName,
   applyAdjustmentLayers,
   applyAdjustments,
   applyBoxBlur,
   applyDepthMask,
+  applyHomography,
   applyImageProjectionToContext,
   applyLegacyAdjustments,
   applyMatrix3,
   applyOutputStage,
+  applyParams,
   applyProcess2Adjustments,
   applyRegionBlur,
   applyRegionMosaic,
@@ -14248,6 +15188,8 @@ export {
   blurFilter,
   borderCoverage,
   boxMean,
+  boxPointOf,
+  boxQuad,
   boxToCurvePoint,
   bradfordAdaptation,
   buildLayerMaskPlanes,
@@ -14267,12 +15209,14 @@ export {
   colorRange,
   combineSelections,
   compileAdjustmentLayer,
+  compositeSurfaceOver,
   computeHistogram,
   computeSelectionBounds,
   contentBounds,
   contractCoverage,
   controlPosition,
   controlTrackBackground,
+  cornersFromMatrix,
   coverageTileCoord,
   coverageToByte,
   coveringRect,
@@ -14285,6 +15229,7 @@ export {
   createImagePaintTools,
   createImagePsdTools,
   createImageSelectionTools,
+  createImageTransformTools,
   createPigment,
   createPigmentTools,
   createSelectionMask,
@@ -14311,6 +15256,7 @@ export {
   describeLayer,
   describeLayerEffects,
   describeSelection,
+  describeTransform,
   deserializeEffects,
   deserializeLayer,
   deserializeLayers,
@@ -14321,6 +15267,7 @@ export {
   developTarget,
   distanceTransform,
   downloadPsd,
+  dragWarpMeshPoint,
   dropPlacement,
   dropZone,
   duplicateLayer,
@@ -14339,6 +15286,7 @@ export {
   encodeRle,
   encodeSelectionRle,
   encodeSurface,
+  evalWarpMesh,
   evaluateAdjustmentLayers,
   expandCoverage,
   exportPsd,
@@ -14349,9 +15297,11 @@ export {
   findLayerControl,
   finishTile,
   flattenLayers,
+  flipCorners,
   formatControlValue,
   fullSelection,
   gaussianBlur,
+  geometryHomography,
   getAnnotationBounds,
   getControlPath,
   getCropCursor,
@@ -14366,6 +15316,7 @@ export {
   handlePaintShortcut,
   hasActiveEffects,
   hasResampledLegacyMask,
+  hasWarp,
   hashMaskContent,
   hashNoise,
   hexToRgb,
@@ -14373,6 +15324,8 @@ export {
   hitTestAnnotation,
   hitTestCrop,
   hitTestCurvePoint,
+  homographyFromAffine,
+  homographyFromPoints,
   hslToRgb,
   hueRange,
   hueRangeTables,
@@ -14380,6 +15333,8 @@ export {
   hueSaturation,
   identityCurve,
   identityLevels,
+  identityTransform,
+  identityWarpMesh,
   imageEditorStateMigrations,
   imageToCanvasPoint,
   importPsd,
@@ -14387,12 +15342,15 @@ export {
   inflateRaw,
   insertCurvePoint,
   insertLayer,
+  invertHomography,
   invertMatrix3,
   invertSelection,
   isActiveFilter,
   isAdjustmentKind,
   isBlendMode,
   isDefaultDepthMask,
+  isIdentityTransform,
+  isInterpolation,
   isLayerEffectKind,
   isLayerLocked,
   isLegacyShape,
@@ -14404,7 +15362,10 @@ export {
   isSelectionMode,
   isSeparableBlendMode,
   isSpatialFilter,
+  isTransformAnchor,
+  isValidWarp,
   kelvinToTemperature,
+  keysWeight,
   layerBadge,
   layerEffectControls,
   layerEffectFields,
@@ -14436,6 +15397,8 @@ export {
   mapCropHandle,
   mapLayer,
   maskSummary,
+  matrixFromCorners,
+  matrixFromParams,
   mergeLayerEffect,
   migrateSerializedImageEditorState,
   migrateToLayeredState,
@@ -14486,6 +15449,8 @@ export {
   polygonCoverage,
   polygonSelection,
   posterizeValue,
+  presetWarp,
+  previewStep,
   projectImagePoint,
   projectImageRect,
   projectMaskCoverage,
@@ -14494,6 +15459,7 @@ export {
   psdFileName,
   psdPatternToEffectPattern,
   psdToLayers,
+  pullWarpMesh,
   quickMaskPixels,
   rangeLightness,
   rasterMaskFromLegacy,
@@ -14503,6 +15469,9 @@ export {
   readPsd,
   readRegion,
   rectSelection,
+  rectToQuad,
+  reduceSurface,
+  referencePoint,
   refineCoverage,
   refineEdgeHalo,
   refineSelection,
@@ -14518,6 +15487,7 @@ export {
   requireUnlocked,
   resizePixels,
   resizeSelection,
+  resizeWarpMesh,
   resolveExternalAssets,
   resolveMosaicRegionBounds,
   rgbToGray,
@@ -14573,6 +15543,12 @@ export {
   toneCurve,
   toneLuts,
   toneRange,
+  transformHomography,
+  transformMap,
+  transformSurface,
+  transformedBounds,
+  transformedBox,
+  transformedPoint,
   translateSurface,
   ungroupLayer,
   uniformTile,
@@ -14589,6 +15565,11 @@ export {
   vibranceLinear,
   vibrancePixel,
   walkDabs,
+  warpMeshEditPoints,
+  warpMeshGridCurves,
+  warpMeshParamAt,
+  warpPresetMesh,
+  warpSurface,
   wbMatrix,
   whiteBalanceFromSample,
   whiteBalanceMatrix,