@pixerate/editor 0.94.0 → 0.96.0

package/dist/image-editor/index.js

@@ -9,6 +9,9 @@ import {
   DIRECT_GAUSSIAN_MAX_SIGMA,
   LAYER_EFFECT_KINDS,
   LayerEffectError,
+  MAX_EFFECT_REACH,
+  PatternPlacement,
+  PatternTile,
   RasterCompositor,
   ZlibError,
   adler32,
@@ -20,61 +23,76 @@ import {
   changedTiles,
   curveLut,
   decodePng,
+  defaultEffectGradient,
   defaultLayerEffect,
   deflate,
   deflateRaw,
+  effectColorHex,
+  effectReach,
+  effectsFingerprint,
   effectsMargin,
+  effectsScale,
   encodePng,
   findLayer,
   flattenLayers,
   gaussianBlur,
+  hasActiveEffects,
+  hashNoise,
   inflate,
   inflateRaw,
   insertLayer,
   isLayerEffectKind,
   isLayerLocked,
   isPng,
+  layerEffectFields,
   layerEffectLabel,
   mapLayer,
   mergeLayerEffect,
   newEffectId,
   normalizeLayerEffects,
   parseDataUrl,
+  parseEffectColor,
   pngDataUrl,
+  renderLayerEffects,
+  scaleLayerEffect,
+  validateEffectGradient,
+  validateLayerEffect,
   validateLayerEffects
-} from "../chunk-747CGOT2.js";
+} from "../chunk-KFTQ2PKP.js";
 import {
   CoverageMap,
   DEFAULT_BRUSH,
+  DEFAULT_MIXER,
   DabWalker,
+  EMPTY_MIXER_LOAD,
   MAX_BRUSH_SIZE,
-  PIGMENT_BANDS,
-  PIGMENT_LAMBDA_MIN,
-  PIGMENT_LAMBDA_STEP,
-  PIGMENT_WAVELENGTHS,
+  MIXER_DRAIN,
+  MIXER_PICKUP_RATE,
+  MIXING_MODELS,
+  MixerStroke,
   StrokeCoverage,
   applyStrokeToTile,
+  cleanMixer,
   coverageTileCoord,
-  createPigment,
   createPigmentTools,
   dabCoverage,
   dabRect,
-  lerpPigment,
-  lerpPigmentInto,
-  mixPigments,
+  loadMixer,
   normalizeBrush,
+  normalizeMixer,
   rasterizeDab,
-  reflectanceToRgb,
-  rgbToReflectance,
-  setPigmentColor,
   smoothPoints,
   tipFalloff,
   tipReach,
   tipShape,
   walkDabs
-} from "../chunk-ISDCJHTO.js";
+} from "../chunk-IB53LVGV.js";
 import {
   BLEND_MODES,
+  PIGMENT_BANDS,
+  PIGMENT_LAMBDA_MIN,
+  PIGMENT_LAMBDA_STEP,
+  PIGMENT_WAVELENGTHS,
   SurfaceDraft,
   TILE,
   TILE_SHIFT,
@@ -87,16 +105,25 @@ import {
   canvasCompositeOperation,
   collectTiles,
   contentBounds,
+  createPigment,
   emptySurface,
   fillRect,
   finishTile,
   isBlendMode,
   isSeparableBlendMode,
+  lerpPigment,
+  lerpPigmentInto,
+  mixPigment8,
+  mixPigmentRgb,
+  mixPigments,
   normalizeBlendMode,
   packRgba,
   readPixel,
   readRegion,
+  reflectanceToRgb,
+  rgbToReflectance,
   setLum,
+  setPigmentColor,
   solidSurface,
   surfaceBytes,
   surfaceFromPixels,
@@ -108,7 +135,7 @@ import {
   translateSurface,
   uniformTile,
   writeRegion
-} from "../chunk-D4ZCU72J.js";
+} from "../chunk-HEW6KDNI.js";
 
 // src/image-editor/color.ts
 var LEGACY_PROCESS_VERSION = 1;
@@ -297,8 +324,8 @@ function whiteBalanceFromSample(rgb) {
   if (lin[0] + lin[1] + lin[2] <= 1e-6) return { temperature: 0, tint: 0 };
   const src = linearSrgbToXy(applyMatrix3(AS_SHOT_WB_INV, lin));
   const { kelvin, tint } = xyToTempTint(src);
-  const clamp3 = (v) => Math.max(-100, Math.min(100, v));
-  return { temperature: clamp3(kelvinToTemperature(kelvin)), tint: clamp3(tint) };
+  const clamp4 = (v) => Math.max(-100, Math.min(100, v));
+  return { temperature: clamp4(kelvinToTemperature(kelvin)), tint: clamp4(tint) };
 }
 var TONE_LUT_SIZE = 4096;
 var GREY = 0.18;
@@ -892,21 +919,21 @@ function toBase64(bytes, length) {
   parts.push(chunk);
   return parts.join("");
 }
-function fromBase64(text) {
-  if (text.length % 4 !== 0) throw new Error("Invalid base64 length");
+function fromBase64(text2) {
+  if (text2.length % 4 !== 0) throw new Error("Invalid base64 length");
   let pad = 0;
-  if (text.endsWith("==")) pad = 2;
-  else if (text.endsWith("=")) pad = 1;
-  const out = new Uint8Array(text.length / 4 * 3 - pad);
+  if (text2.endsWith("==")) pad = 2;
+  else if (text2.endsWith("=")) pad = 1;
+  const out = new Uint8Array(text2.length / 4 * 3 - pad);
   let o = 0;
   const digit = (i, k) => {
-    const ch = text.charCodeAt(i + k);
-    if (ch === 61 && i + 4 === text.length && k >= 4 - pad) return 0;
+    const ch = text2.charCodeAt(i + k);
+    if (ch === 61 && i + 4 === text2.length && k >= 4 - pad) return 0;
     const idx = ch < 128 ? B64_INDEX[ch] : -1;
     if (idx < 0) throw new Error("Invalid base64 character");
     return idx;
   };
-  for (let i = 0; i < text.length; i += 4) {
+  for (let i = 0; i < text2.length; i += 4) {
     const n = digit(i, 0) << 18 | digit(i, 1) << 12 | digit(i, 2) << 6 | digit(i, 3);
     if (o < out.length) out[o++] = n >> 16 & 255;
     if (o < out.length) out[o++] = n >> 8 & 255;
@@ -1919,6 +1946,10 @@ function applyLayer(c, layer, op, coverage = 1) {
   }
   const cb0 = c[0], cb1 = c[1], cb2 = c[2];
   op(c);
+  if (blend === "pigment") {
+    mixPigmentRgb([clamp01(cb0), clamp01(cb1), clamp01(cb2)], [clamp01(c[0]), clamp01(c[1]), clamp01(c[2])], alpha, c);
+    return;
+  }
   const b = blend === "normal" ? c : blendRgb(blend, [cb0, cb1, cb2], c);
   c[0] = (1 - alpha) * cb0 + alpha * b[0];
   c[1] = (1 - alpha) * cb1 + alpha * b[1];
@@ -2413,10 +2444,10 @@ function depthMaskAlpha(depth, options) {
 }
 var filterSpecCache = /* @__PURE__ */ new WeakMap();
 function pixelFilterSpec(layer) {
-  const list = layer.filters;
-  if (!list?.length) return null;
-  if (filterSpecCache.has(list)) return filterSpecCache.get(list);
-  const filters = list.filter(isActiveFilter);
+  const list2 = layer.filters;
+  if (!list2?.length) return null;
+  if (filterSpecCache.has(list2)) return filterSpecCache.get(list2);
+  const filters = list2.filter(isActiveFilter);
   let spec = null;
   if (filters.length) {
     const spatial = filters.some(isSpatialFilter);
@@ -2431,7 +2462,7 @@ function pixelFilterSpec(layer) {
       }
     };
   }
-  filterSpecCache.set(list, spec);
+  filterSpecCache.set(list2, spec);
   return spec;
 }
 var PHOTO_PROFILE = {
@@ -2648,8 +2679,8 @@ function legacyAdjustmentLayer(node, width, height) {
 }
 function developTarget(layers, activeLayerId) {
   const pixels = [];
-  const walk = (list) => {
-    for (const l of list) {
+  const walk = (list2) => {
+    for (const l of list2) {
       if (l.type === "pixel") pixels.push(l);
       else if (l.type === "group") walk(l.children);
     }
@@ -2683,8 +2714,8 @@ function legacyView(stack, width, height, activeLayerId = null) {
   };
   const adjNodes = [];
   const annotations = [];
-  const walk = (list) => {
-    for (const l of list) {
+  const walk = (list2) => {
+    for (const l of list2) {
       if (l.type === "adjustment") adjNodes.push(l);
       else if (l.type === "annotation") annotations.push(l.annotation);
       else if (l.type === "group") walk(l.children);
@@ -4475,6 +4506,23 @@ function refineSelection(pixels, mask, params = {}) {
 
 // src/image-editor/layers/serialize.ts
 var LAYERED_SCHEMA_VERSION = 3;
+function serializePatterns(patterns) {
+  return patterns.map((p) => ({ id: p.id, name: p.name, png: pngDataUrl(p.width, p.height, p.data) }));
+}
+function deserializePatterns(raw, problems = []) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const p of raw) {
+    if (!p || typeof p !== "object" || typeof p.id !== "string" || typeof p.png !== "string") continue;
+    try {
+      const png = decodePngDataUrl(p.png, 4);
+      out.push({ id: p.id, name: typeof p.name === "string" ? p.name : p.id, width: png.width, height: png.height, data: png.data });
+    } catch (e) {
+      problems.push(`Pattern "${p.name ?? p.id}" could not be decoded (${e instanceof Error ? e.message : String(e)}).`);
+    }
+  }
+  return out;
+}
 var encodedCache = /* @__PURE__ */ new WeakMap();
 function encodeSurface(surface) {
   if (encodedCache.has(surface)) return encodedCache.get(surface);
@@ -4770,7 +4818,7 @@ function deserializeLayer(raw, ctx) {
 function deserializeLayers(raw, ctx) {
   if (!Array.isArray(raw)) return [];
   const seen = /* @__PURE__ */ new Set();
-  const dedupe = (list) => list.map((l) => {
+  const dedupe = (list2) => list2.map((l) => {
     let next = l;
     if (seen.has(l.id)) next = { ...l, id: newLayerId() };
     seen.add(next.id);
@@ -5172,8 +5220,8 @@ var PsdReader = class _PsdReader {
     return v;
   }
   /** A length field: 8 bytes in PSB where the format says so, else 4. */
-  len(long2) {
-    return long2 ? this.u64() : this.u32();
+  len(long3) {
+    return long3 ? this.u64() : this.u32();
   }
   bytes(n) {
     this.need(n, `${n} bytes`);
@@ -5280,11 +5328,11 @@ var PsdWriter = class {
     this.length += n;
   }
   /** Reserves a length field; `endLen` fills it with the bytes written since. */
-  beginLen(long2) {
+  beginLen(long3) {
     const at = this.length;
-    if (long2) this.u64(0);
+    if (long3) this.u64(0);
     else this.u32(0);
-    return { at, long: long2 };
+    return { at, long: long3 };
   }
   endLen(mark) {
     const n = this.length - mark.at - (mark.long ? 8 : 4);
@@ -5444,12 +5492,12 @@ function readValue(r, depth) {
     case "UntF":
       return { type, unit: r.ascii(4), value: r.f64() };
     case "UnFl": {
-      const unit = r.ascii(4);
+      const unit2 = r.ascii(4);
       const n = r.u32();
       r.checkCount(n, 8, "Unit float list");
       const values = [];
       for (let i = 0; i < n; i++) values.push(r.f64());
-      return { type, unit, values };
+      return { type, unit: unit2, values };
     }
     case "TEXT":
       return { type, value: r.unicode() };
@@ -5902,11 +5950,11 @@ function writeAdjustmentBlock(kind, params) {
     case "blackWhite": {
       const p = params;
       const tint = p.tint ? hexToRgb(p.tint) : BW_TINT;
-      const dbl = (v) => ({ type: "doub", value: clamp2(v, 0, 1) * 255 });
+      const dbl2 = (v) => ({ type: "doub", value: clamp2(v, 0, 1) * 255 });
       const items = BW_KEYS.map(([field, key]) => [key, long(clamp2(p[field], -200, 300))]);
       items.push(
         ["useTint", { type: "bool", value: p.tint !== null }],
-        ["tintColor", { type: "Objc", value: descriptor("RGBC", [["Rd  ", dbl(tint[0])], ["Grn ", dbl(tint[1])], ["Bl  ", dbl(tint[2])]]) }],
+        ["tintColor", { type: "Objc", value: descriptor("RGBC", [["Rd  ", dbl2(tint[0])], ["Grn ", dbl2(tint[1])], ["Bl  ", dbl2(tint[2])]]) }],
         ["bwPresetKind", { type: "long", value: 1 }],
         ["blackAndWhitePresetFileName", { type: "TEXT", value: "" }]
       );
@@ -6390,11 +6438,11 @@ function writeRect(w, r) {
 }
 function writeBlocks(w, blocks, psb, alignment) {
   for (const b of blocks) {
-    const long2 = psb && PSB_LONG_KEYS.has(b.key);
-    w.ascii(long2 ? "8B64" : "8BIM");
+    const long3 = psb && PSB_LONG_KEYS.has(b.key);
+    w.ascii(long3 ? "8B64" : "8BIM");
     w.ascii(b.key);
     const pad = (alignment - b.data.length % alignment) % alignment;
-    if (long2) w.u64(b.data.length + pad);
+    if (long3) w.u64(b.data.length + pad);
     else w.u32(b.data.length + pad);
     w.bytes(b.data);
     w.zeros(pad);
@@ -6648,6 +6696,784 @@ function matteWhite(data) {
   return out;
 }
 
+// src/image-editor/psd/effects.ts
+var BLEND_CODES = [
+  ["normal", "Nrml"],
+  ["darken", "Drkn"],
+  ["multiply", "Mltp"],
+  ["color-burn", "CBrn"],
+  ["linear-burn", "linearBurn"],
+  ["darker-color", "darkerColor"],
+  ["lighten", "Lghn"],
+  ["screen", "Scrn"],
+  ["color-dodge", "CDdg"],
+  ["linear-dodge", "linearDodge"],
+  ["lighter-color", "lighterColor"],
+  ["overlay", "Ovrl"],
+  ["soft-light", "SftL"],
+  ["hard-light", "HrdL"],
+  ["vivid-light", "vividLight"],
+  ["linear-light", "linearLight"],
+  ["pin-light", "pinLight"],
+  ["hard-mix", "hardMix"],
+  ["difference", "Dfrn"],
+  ["exclusion", "Xclu"],
+  ["subtract", "blendSubtraction"],
+  ["divide", "blendDivide"],
+  ["hue", "H   "],
+  ["saturation", "Strt"],
+  ["color", "Clr "],
+  ["luminosity", "Lmns"]
+];
+var BLEND_LONG = [
+  ["normal", "normal"],
+  ["darken", "darken"],
+  ["multiply", "multiply"],
+  ["color-burn", "colorBurn"],
+  ["lighten", "lighten"],
+  ["screen", "screen"],
+  ["color-dodge", "colorDodge"],
+  ["overlay", "overlay"],
+  ["soft-light", "softLight"],
+  ["hard-light", "hardLight"],
+  ["difference", "difference"],
+  ["exclusion", "exclusion"],
+  ["hue", "hue"],
+  ["saturation", "saturation"],
+  ["color", "color"],
+  ["luminosity", "luminosity"]
+];
+var BLEND_OF = new Map([...BLEND_CODES, ...BLEND_LONG].map(([m, id]) => [id, m]));
+var BLEND_ID = new Map(BLEND_CODES);
+var num2 = (d, key, fallback) => descNumber(d, key) ?? fallback;
+var pct = (d, key, fallback) => num2(d, key, fallback * 100) / 100;
+var bool = (d, key) => descBool(d, key) === true;
+var enumOf = (d, key) => {
+  const v = descGet(d, key);
+  return v?.type === "enum" ? v.value : void 0;
+};
+var text = (d, key) => {
+  const v = d ? descGet(d, key) : void 0;
+  return v?.type === "TEXT" ? v.value : "";
+};
+var list = (d, key) => {
+  const v = descGet(d, key);
+  if (v?.type !== "VlLs") return [];
+  return v.items.flatMap((it) => it.type === "Objc" || it.type === "GlbO" ? [it.value] : []);
+};
+var clamp3 = (v, lo, hi) => Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : lo;
+var unit = (u, value) => ({ type: "UntF", unit: u, value });
+var dbl = (value) => ({ type: "doub", value });
+var long2 = (value) => ({ type: "long", value: Math.round(value) });
+var boolV = (value) => ({ type: "bool", value });
+var enumV = (typeId, value) => ({ type: "enum", typeId, value });
+var textV = (value) => ({ type: "TEXT", value });
+var obj = (d) => ({ type: "Objc", value: d });
+function blendOf(d, key, fallback, notes) {
+  const id = enumOf(d, key);
+  if (id === void 0) return fallback;
+  const m = BLEND_OF.get(id);
+  if (m) return m;
+  notes.add(id === "Dslv" || id === "dissolve" ? "Dissolve became Normal" : `an unknown blend mode "${id}" became Normal`);
+  return "normal";
+}
+function colorOf(d, fallback = "#000000") {
+  if (!d) return fallback;
+  const g = (k) => descNumber(d, k);
+  if (g("redFloat") !== void 0) return effectColorHex([g("redFloat"), g("greenFloat") ?? 0, g("blueFloat") ?? 0]);
+  switch (d.classId) {
+    case "HSBC": {
+      const rgb = decodePsdColor(1, [(g("H   ") ?? 0) / 360 * 65535, (g("Strt") ?? 0) / 100 * 65535, (g("Brgh") ?? 0) / 100 * 65535]);
+      return rgb ? effectColorHex(rgb) : fallback;
+    }
+    case "CMYC": {
+      const inv = (k) => (1 - (g(k) ?? 0) / 100) * 65535;
+      const rgb = decodePsdColor(2, [inv("Cyn "), inv("Mgnt"), inv("Ylw "), inv("Blck")]);
+      return rgb ? effectColorHex(rgb) : fallback;
+    }
+    case "LbCl": {
+      const rgb = decodePsdColor(7, [(g("Lmnc") ?? 0) * 100, Math.round((g("A   ") ?? 0) * 100) & 65535, Math.round((g("B   ") ?? 0) * 100) & 65535]);
+      return rgb ? effectColorHex(rgb) : fallback;
+    }
+    case "Grsc": {
+      const v = 1 - (g("Gry ") ?? 0) / 100;
+      return effectColorHex([v, v, v]);
+    }
+  }
+  const r = g("Rd  ");
+  const gr = g("Grn ");
+  const b = g("Bl  ");
+  if (r === void 0 || gr === void 0 || b === void 0) return fallback;
+  return effectColorHex([r / 255, gr / 255, b / 255]);
+}
+function colorDesc(hex) {
+  const [r, g, b] = parseEffectColor(hex) ?? [0, 0, 0];
+  return descriptor("RGBC", [
+    ["Rd  ", dbl(r * 255)],
+    ["Grn ", dbl(g * 255)],
+    ["Bl  ", dbl(b * 255)]
+  ]);
+}
+function contourOf(d, key) {
+  const c = descObject(d, key);
+  if (!c) return void 0;
+  const name = text(c, "Nm  ");
+  const points = list(c, "Crv ").map((p) => {
+    const out = { input: clamp3(num2(p, "Hrzn", 0) / 255, 0, 1), output: clamp3(num2(p, "Vrtc", 0) / 255, 0, 1) };
+    if (descBool(p, "Cnty") === false) out.corner = true;
+    return out;
+  });
+  const linear = points.length === 2 && points[0].input === 0 && points[0].output === 0 && points[1].input === 1 && points[1].output === 1 && !points.some((p) => p.corner);
+  if (points.length < 2 || linear && (!name || name === "Linear")) return void 0;
+  return { name, points };
+}
+function contourDesc(c) {
+  const name = c?.name ?? "Linear";
+  const points = c?.points ?? [
+    { input: 0, output: 0 },
+    { input: 1, output: 1 }
+  ];
+  const pts = {
+    type: "VlLs",
+    items: points.map((p) => {
+      const items = [
+        ["Hrzn", dbl(p.input * 255)],
+        ["Vrtc", dbl(p.output * 255)]
+      ];
+      if (p.corner) items.push(["Cnty", boolV(false)]);
+      return obj(descriptor("CrPt", items));
+    })
+  };
+  return obj(
+    descriptor("ShpC", [
+      ["Nm  ", textV(name)],
+      ["Crv ", pts]
+    ])
+  );
+}
+var GRADIENT_STYLES = [
+  ["linear", "Lnr "],
+  ["radial", "Rdl "],
+  ["angle", "Angl"],
+  ["reflected", "Rflc"],
+  ["diamond", "Dmnd"]
+];
+function gradientOf(d, notes) {
+  const g = {
+    stops: [
+      { position: 0, color: "#000000" },
+      { position: 1, color: "#ffffff" }
+    ],
+    style: GRADIENT_STYLES.find(([, id]) => id === enumOf(d, "Type"))?.[0] ?? "linear",
+    angle: clamp3(num2(d, "Angl", 90), -360, 360),
+    scale: clamp3(pct(d, "Scl ", 1), 0.1, 1.5),
+    reverse: bool(d, "Rvrs"),
+    align: descBool(d, "Algn") !== false,
+    offset: { x: 0, y: 0 }
+  };
+  const off = descObject(d, "Ofst");
+  if (off) g.offset = { x: clamp3(pct(off, "Hrzn", 0), -1, 1), y: clamp3(pct(off, "Vrtc", 0), -1, 1) };
+  const grad = descObject(d, "Grad");
+  if (!grad) return g;
+  if (enumOf(grad, "GrdF") === "ClNs") {
+    notes.add("noise gradients became black to white");
+    return g;
+  }
+  const raw = list(grad, "Clrs").map((s) => {
+    const type = enumOf(s, "Type");
+    if (type === "FrgC" || type === "BckC") notes.add("foreground / background gradient stops became black / white");
+    const color = type === "BckC" ? "#ffffff" : colorOf(descObject(s, "Clr "));
+    return { position: clamp3(num2(s, "Lctn", 0) / 4096, 0, 1), color, mid: clamp3(num2(s, "Mdpn", 50) / 100, 0.05, 0.95) };
+  }).sort((a, b) => a.position - b.position);
+  if (raw.length) {
+    const stops = [];
+    raw.forEach((s, i) => {
+      if (i > 0 && Math.abs(s.mid - 0.5) > 1e-3) {
+        const a = raw[i - 1];
+        const ca = parseEffectColor(a.color);
+        const cb = parseEffectColor(s.color);
+        stops.push({ position: a.position + (s.position - a.position) * s.mid, color: effectColorHex(ca.map((v, k) => (v + cb[k]) / 2)) });
+        notes.add("gradient midpoints are drawn as straight segments");
+      }
+      stops.push({ position: s.position, color: s.color });
+    });
+    g.stops = stops;
+  }
+  const opacity = list(grad, "Trns").map((s) => ({ position: clamp3(num2(s, "Lctn", 0) / 4096, 0, 1), opacity: clamp3(num2(s, "Opct", 100) / 100, 0, 1) })).sort((a, b) => a.position - b.position);
+  if (opacity.some((o) => o.opacity < 1)) g.opacityStops = opacity;
+  if (num2(grad, "Intr", 0) > 0) notes.add("gradient smoothness is drawn as straight segments");
+  return g;
+}
+function gradientItems(g) {
+  const clrs = {
+    type: "VlLs",
+    items: g.stops.map(
+      (s) => obj(
+        descriptor("Clrt", [
+          ["Clr ", obj(colorDesc(s.color))],
+          ["Type", enumV("Clry", "UsrS")],
+          ["Lctn", long2(s.position * 4096)],
+          ["Mdpn", long2(50)]
+        ])
+      )
+    )
+  };
+  const op = g.opacityStops?.length ? g.opacityStops : g.stops.map((s) => ({ position: s.position, opacity: 1 }));
+  const trns = {
+    type: "VlLs",
+    items: op.map(
+      (s) => obj(
+        descriptor("TrnS", [
+          ["Opct", unit("#Prc", s.opacity * 100)],
+          ["Lctn", long2(s.position * 4096)],
+          ["Mdpn", long2(50)]
+        ])
+      )
+    )
+  };
+  const grad = descriptor("Grdn", [
+    ["Nm  ", textV("Custom")],
+    ["GrdF", enumV("GrdF", "CstS")],
+    ["Intr", dbl(0)],
+    ["Clrs", clrs],
+    ["Trns", trns]
+  ]);
+  return [
+    ["Grad", obj(grad)],
+    ["Angl", unit("#Ang", g.angle)],
+    ["Type", enumV("GrdT", GRADIENT_STYLES.find(([s]) => s === g.style)[1])],
+    ["Rvrs", boolV(g.reverse)],
+    ["Algn", boolV(g.align)],
+    ["Scl ", unit("#Prc", g.scale * 100)],
+    [
+      "Ofst",
+      obj(
+        descriptor("Pnt ", [
+          ["Hrzn", unit("#Prc", g.offset.x * 100)],
+          ["Vrtc", unit("#Prc", g.offset.y * 100)]
+        ])
+      )
+    ]
+  ];
+}
+function patternRefOf(d) {
+  const p = descObject(d, "Ptrn");
+  return { patternId: text(p, "Idnt") || text(p, "Nm  "), name: text(p, "Nm  ") };
+}
+function patternRefDesc(patternId, name) {
+  return obj(
+    descriptor("Ptrn", [
+      ["Nm  ", textV(name ?? patternId)],
+      ["Idnt", textV(patternId)]
+    ])
+  );
+}
+function placementOf(d) {
+  const phase = descObject(d, "phase");
+  return {
+    angle: clamp3(num2(d, "Angl", 0), -360, 360),
+    link: descBool(d, "Algn") !== false,
+    phase: phase ? { x: num2(phase, "Hrzn", 0), y: num2(phase, "Vrtc", 0) } : { x: 0, y: 0 }
+  };
+}
+function placementItems(angle, link, phase) {
+  const out = [];
+  if (angle) out.push(["Angl", unit("#Ang", angle)]);
+  out.push(["Algn", boolV(link)]);
+  out.push([
+    "phase",
+    obj(
+      descriptor("Pnt ", [
+        ["Hrzn", dbl(phase.x)],
+        ["Vrtc", dbl(phase.y)]
+      ])
+    )
+  ]);
+  return out;
+}
+var KINDS = [
+  ["DrSh", "dropShadowMulti", "drop-shadow"],
+  ["IrSh", "innerShadowMulti", "inner-shadow"],
+  ["OrGl", "", "outer-glow"],
+  ["IrGl", "", "inner-glow"],
+  ["ebbl", "", "bevel-emboss"],
+  ["ChFX", "", "satin"],
+  ["SoFi", "solidFillMulti", "color-overlay"],
+  ["GrFl", "gradientFillMulti", "gradient-overlay"],
+  ["patternFill", "", "pattern-overlay"],
+  ["FrFX", "frameFXMulti", "stroke"]
+];
+function common(d, kind, notes) {
+  const def = defaultLayerEffect(kind, "x");
+  return { id: newEffectId(), enabled: descBool(d, "enab") !== false, blend: blendOf(d, "Md  ", def.blend, notes), opacity: clamp3(pct(d, "Opct", def.opacity), 0, 1) };
+}
+function readOne(kind, d, notes) {
+  const size = (key, fallback) => clamp3(num2(d, key, fallback), 0, 250);
+  switch (kind) {
+    case "drop-shadow":
+    case "inner-shadow": {
+      const base = {
+        ...common(d, kind, notes),
+        color: colorOf(descObject(d, "Clr ")),
+        angle: clamp3(num2(d, "lagl", 120), -360, 360),
+        useGlobalLight: descBool(d, "uglg") !== false,
+        distance: clamp3(num2(d, "Dstn", 5), 0, 3e4),
+        size: size("blur", 5),
+        contour: contourOf(d, "TrnS"),
+        antiAlias: bool(d, "AntA"),
+        noise: clamp3(pct(d, "Nose", 0), 0, 1)
+      };
+      const spread = clamp3(pct(d, "Ckmt", 0), 0, 1);
+      return kind === "drop-shadow" ? { ...base, kind, spread, knocksOut: descBool(d, "layerConceals") !== false } : { ...base, kind, choke: spread };
+    }
+    case "outer-glow":
+    case "inner-glow": {
+      const fill = descGet(d, "Grad") ? { type: "gradient", gradient: gradientOf(d, notes) } : { type: "color", color: colorOf(descObject(d, "Clr "), "#ffffbe") };
+      const jitter = clamp3(pct(d, "ShdN", 0), 0, 1);
+      if (jitter > 0) notes.add("glow jitter is not drawn");
+      const base = {
+        ...common(d, kind, notes),
+        fill,
+        technique: enumOf(d, "GlwT") === "PrBL" ? "precise" : "softer",
+        size: size("blur", 5),
+        contour: contourOf(d, "TrnS"),
+        antiAlias: bool(d, "AntA"),
+        range: clamp3(pct(d, "Inpr", 0.5), 0.01, 1),
+        jitter,
+        noise: clamp3(pct(d, "Nose", 0), 0, 1)
+      };
+      const spread = clamp3(pct(d, "Ckmt", 0), 0, 1);
+      return kind === "outer-glow" ? { ...base, kind, spread } : { ...base, kind, choke: spread, source: enumOf(d, "glwS") === "SrcC" ? "center" : "edge" };
+    }
+    case "bevel-emboss": {
+      const styles = { OtrB: "outer-bevel", InrB: "inner-bevel", Embs: "emboss", PlEb: "pillow-emboss", strokeEmboss: "stroke-emboss" };
+      const out = {
+        id: newEffectId(),
+        enabled: descBool(d, "enab") !== false,
+        kind,
+        style: styles[enumOf(d, "bvlS") ?? ""] ?? "inner-bevel",
+        technique: enumOf(d, "bvlT") === "PrBL" ? "chisel-hard" : enumOf(d, "bvlT") === "Slmt" ? "chisel-soft" : "smooth",
+        depth: clamp3(pct(d, "srgR", 1), 0, 10),
+        direction: enumOf(d, "bvlD") === "Out " ? "down" : "up",
+        size: size("blur", 5),
+        soften: clamp3(num2(d, "Sftn", 0), 0, 16),
+        angle: clamp3(num2(d, "lagl", 120), -360, 360),
+        altitude: clamp3(num2(d, "Lald", 30), 0, 90),
+        useGlobalLight: descBool(d, "uglg") !== false,
+        glossContour: contourOf(d, "TrnS"),
+        highlightColor: colorOf(descObject(d, "hglC"), "#ffffff"),
+        highlightBlend: blendOf(d, "hglM", "screen", notes),
+        highlightOpacity: clamp3(pct(d, "hglO", 0.75), 0, 1),
+        shadowColor: colorOf(descObject(d, "sdwC")),
+        shadowBlend: blendOf(d, "sdwM", "multiply", notes),
+        shadowOpacity: clamp3(pct(d, "sdwO", 0.75), 0, 1)
+      };
+      if (bool(d, "useShape")) out.contourElement = { contour: contourOf(d, "MpgS") ?? { name: "Linear", points: [{ input: 0, output: 0 }, { input: 1, output: 1 }] }, range: clamp3(pct(d, "Inpr", 0.5), 0, 1), antiAlias: bool(d, "AntA") };
+      if (bool(d, "useTexture")) {
+        const ref = patternRefOf(d);
+        const place = placementOf(d);
+        out.texture = { patternId: ref.patternId, name: ref.name, scale: clamp3(pct(d, "Scl ", 1), 0.01, 10), depth: clamp3(pct(d, "textureDepth", 1), -10, 10), invert: bool(d, "InvT"), link: place.link, phase: place.phase };
+      }
+      return out;
+    }
+    case "satin":
+      return {
+        ...common(d, kind, notes),
+        kind,
+        color: colorOf(descObject(d, "Clr ")),
+        angle: clamp3(num2(d, "lagl", 19), -360, 360),
+        distance: size("Dstn", 11),
+        size: size("blur", 14),
+        contour: contourOf(d, "MpgS"),
+        antiAlias: bool(d, "AntA"),
+        invert: bool(d, "Invr")
+      };
+    case "color-overlay":
+      return { ...common(d, kind, notes), kind, color: colorOf(descObject(d, "Clr ")) };
+    case "gradient-overlay":
+      return { ...common(d, kind, notes), kind, gradient: gradientOf(d, notes), dither: bool(d, "Dthr") };
+    case "pattern-overlay": {
+      const ref = patternRefOf(d);
+      const place = placementOf(d);
+      return { ...common(d, kind, notes), kind, patternId: ref.patternId, name: ref.name, scale: clamp3(pct(d, "Scl ", 1), 0.01, 10), angle: place.angle, link: place.link, phase: place.phase };
+    }
+    case "stroke": {
+      const paint = enumOf(d, "PntT");
+      let fill;
+      if (paint === "GrFl") fill = { type: "gradient", gradient: gradientOf(d, notes) };
+      else if (paint === "Ptrn") {
+        const ref = patternRefOf(d);
+        fill = { type: "pattern", patternId: ref.patternId, name: ref.name, scale: clamp3(pct(d, "Scl ", 1), 0.01, 10) };
+      } else fill = { type: "color", color: colorOf(descObject(d, "Clr ")) };
+      const pos = enumOf(d, "Styl");
+      return { ...common(d, kind, notes), kind, size: size("Sz  ", 3), position: pos === "InsF" ? "inside" : pos === "CtrF" ? "center" : "outside", fill };
+    }
+  }
+}
+function parseLfx2(data) {
+  let d;
+  try {
+    d = parseVersionedDescriptor(data.subarray(4));
+  } catch {
+    return null;
+  }
+  const notes = /* @__PURE__ */ new Set();
+  const items = [];
+  for (const [single, multi, kind] of KINDS) {
+    const many = multi ? list(d, multi) : [];
+    const one = descObject(d, single);
+    for (const x of many.length ? many : one ? [one] : []) {
+      if (descBool(x, "present") === false) continue;
+      items.push(readOne(kind, x, notes));
+    }
+  }
+  const effects = { enabled: descBool(d, "masterFXSwitch") !== false, items };
+  return { effects, notes: [...notes] };
+}
+function commonItems(e) {
+  return [
+    ["enab", boolV(e.enabled)],
+    ["present", boolV(true)],
+    ["showInDialog", boolV(true)],
+    ["Md  ", enumV("BlnM", BLEND_ID.get(e.blend) ?? "Nrml")],
+    ["Opct", unit("#Prc", e.opacity * 100)]
+  ];
+}
+function writeOne(e) {
+  switch (e.kind) {
+    case "drop-shadow":
+    case "inner-shadow": {
+      const inner = e.kind === "inner-shadow";
+      const items = [
+        ...commonItems(e),
+        ["Clr ", obj(colorDesc(e.color))],
+        ["uglg", boolV(e.useGlobalLight)],
+        ["lagl", unit("#Ang", e.angle)],
+        ["Dstn", unit("#Pxl", e.distance)],
+        ["Ckmt", unit("#Pxl", (inner ? e.choke : e.spread) * 100)],
+        ["blur", unit("#Pxl", e.size)],
+        ["Nose", unit("#Prc", e.noise * 100)],
+        ["AntA", boolV(e.antiAlias)],
+        ["TrnS", contourDesc(e.contour)]
+      ];
+      if (e.kind === "drop-shadow") items.push(["layerConceals", boolV(e.knocksOut)]);
+      return descriptor(inner ? "IrSh" : "DrSh", items);
+    }
+    case "outer-glow":
+    case "inner-glow": {
+      const inner = e.kind === "inner-glow";
+      const items = [...commonItems(e)];
+      if (e.fill.type === "gradient") items.push(...gradientItems(e.fill.gradient));
+      else items.push(["Clr ", obj(colorDesc(e.fill.color))]);
+      items.push(
+        ["GlwT", enumV("BETE", e.technique === "precise" ? "PrBL" : "SfBL")],
+        ["Ckmt", unit("#Pxl", (inner ? e.choke : e.spread) * 100)],
+        ["blur", unit("#Pxl", e.size)],
+        ["Nose", unit("#Prc", e.noise * 100)],
+        ["ShdN", unit("#Prc", e.jitter * 100)],
+        ["AntA", boolV(e.antiAlias)],
+        ["TrnS", contourDesc(e.contour)],
+        ["Inpr", unit("#Prc", e.range * 100)]
+      );
+      if (e.kind === "inner-glow") items.push(["glwS", enumV("IGSr", e.source === "center" ? "SrcC" : "SrcE")]);
+      return descriptor(inner ? "IrGl" : "OrGl", items);
+    }
+    case "bevel-emboss": {
+      const style = { "outer-bevel": "OtrB", "inner-bevel": "InrB", emboss: "Embs", "pillow-emboss": "PlEb", "stroke-emboss": "strokeEmboss" }[e.style];
+      const tech = { smooth: "SfBL", "chisel-hard": "PrBL", "chisel-soft": "Slmt" }[e.technique];
+      const items = [
+        ["enab", boolV(e.enabled)],
+        ["present", boolV(true)],
+        ["showInDialog", boolV(true)],
+        ["hglM", enumV("BlnM", BLEND_ID.get(e.highlightBlend) ?? "Scrn")],
+        ["hglC", obj(colorDesc(e.highlightColor))],
+        ["hglO", unit("#Prc", e.highlightOpacity * 100)],
+        ["sdwM", enumV("BlnM", BLEND_ID.get(e.shadowBlend) ?? "Mltp")],
+        ["sdwC", obj(colorDesc(e.shadowColor))],
+        ["sdwO", unit("#Prc", e.shadowOpacity * 100)],
+        ["bvlT", enumV("bvlT", tech)],
+        ["bvlS", enumV("BESl", style)],
+        ["uglg", boolV(e.useGlobalLight)],
+        ["lagl", unit("#Ang", e.angle)],
+        ["Lald", unit("#Ang", e.altitude)],
+        ["srgR", unit("#Prc", e.depth * 100)],
+        ["blur", unit("#Pxl", e.size)],
+        ["bvlD", enumV("BESs", e.direction === "up" ? "In  " : "Out ")],
+        ["TrnS", contourDesc(e.glossContour)],
+        ["Sftn", unit("#Pxl", e.soften)]
+      ];
+      if (e.contourElement) {
+        items.push(["useShape", boolV(true)], ["MpgS", contourDesc(e.contourElement.contour)], ["AntA", boolV(e.contourElement.antiAlias)], ["Inpr", unit("#Prc", e.contourElement.range * 100)]);
+      } else items.push(["useShape", boolV(false)]);
+      if (e.texture) {
+        const t = e.texture;
+        items.push(
+          ["useTexture", boolV(true)],
+          ["InvT", boolV(t.invert)],
+          ["Scl ", unit("#Prc", t.scale * 100)],
+          ["textureDepth", unit("#Prc", t.depth * 100)],
+          ["Ptrn", patternRefDesc(t.patternId, t.name)],
+          ...placementItems(0, t.link ?? true, t.phase ?? { x: 0, y: 0 })
+        );
+      } else items.push(["useTexture", boolV(false)]);
+      return descriptor("ebbl", items);
+    }
+    case "satin":
+      return descriptor("ChFX", [
+        ...commonItems(e),
+        ["Clr ", obj(colorDesc(e.color))],
+        ["AntA", boolV(e.antiAlias)],
+        ["Invr", boolV(e.invert)],
+        ["lagl", unit("#Ang", e.angle)],
+        ["Dstn", unit("#Pxl", e.distance)],
+        ["blur", unit("#Pxl", e.size)],
+        ["MpgS", contourDesc(e.contour)]
+      ]);
+    case "color-overlay":
+      return descriptor("SoFi", [...commonItems(e), ["Clr ", obj(colorDesc(e.color))]]);
+    case "gradient-overlay":
+      return descriptor("GrFl", [...commonItems(e), ...gradientItems(e.gradient), ["Dthr", boolV(e.dither)]]);
+    case "pattern-overlay":
+      return descriptor("patternFill", [
+        ...commonItems(e),
+        ["Ptrn", patternRefDesc(e.patternId, e.name)],
+        ["Scl ", unit("#Prc", e.scale * 100)],
+        ...placementItems(e.angle ?? 0, e.link ?? true, e.phase ?? { x: 0, y: 0 })
+      ]);
+    case "stroke": {
+      const items = [
+        ...commonItems(e),
+        ["Styl", enumV("FStl", e.position === "inside" ? "InsF" : e.position === "center" ? "CtrF" : "OutF")],
+        ["Sz  ", unit("#Pxl", e.size)]
+      ];
+      const f = e.fill;
+      if (f.type === "color") items.push(["PntT", enumV("FrFl", "SClr")], ["Clr ", obj(colorDesc(f.color))]);
+      else if (f.type === "gradient") items.push(["PntT", enumV("FrFl", "GrFl")], ...gradientItems(f.gradient));
+      else items.push(["PntT", enumV("FrFl", "Ptrn")], ["Ptrn", patternRefDesc(f.patternId, f.name)], ["Scl ", unit("#Prc", f.scale * 100)]);
+      return descriptor("FrFX", items);
+    }
+  }
+}
+function writeLfx2(effects) {
+  const items = [
+    ["Scl ", unit("#Prc", 100)],
+    ["masterFXSwitch", boolV(effects.enabled)]
+  ];
+  const scale = effectsScale(effects);
+  let dropped = 0;
+  for (const [single, multi, kind] of KINDS) {
+    const of = effects.items.filter((e) => e.kind === kind).map((e) => writeOne(scaleLayerEffect(e, scale)));
+    if (!of.length) continue;
+    if (of.length === 1) items.push([single, obj(of[0])]);
+    else if (multi) items.push([multi, { type: "VlLs", items: of.map(obj) }]);
+    else {
+      items.push([single, obj(of[0])]);
+      dropped += of.length - 1;
+    }
+  }
+  const body = versionedDescriptorBytes(descriptor("null", items));
+  const w = new PsdWriter();
+  w.u32(0);
+  w.bytes(body);
+  if (w.length % 2) w.u8(0);
+  return { data: w.result(), dropped };
+}
+function parseLrfx(data) {
+  try {
+    const r = new PsdReader(data);
+    r.u16();
+    const count = r.u16();
+    const items = [];
+    const notes = /* @__PURE__ */ new Set();
+    const fixed = (v) => (v | 0) / 65536;
+    for (let i = 0; i < count; i++) {
+      if (new TextDecoder().decode(r.bytes(4)) !== "8BIM") return null;
+      const key = new TextDecoder().decode(r.bytes(4));
+      const size = r.u32();
+      const b = new PsdReader(r.bytes(size));
+      const colorAt = (rd) => {
+        rd.u16();
+        const c = [rd.u16(), rd.u16(), rd.u16(), rd.u16()];
+        return effectColorHex([c[0] >> 8, c[1] >> 8, c[2] >> 8].map((v) => v / 255));
+      };
+      const blendAt = (rd) => {
+        rd.skip(4);
+        const k = new TextDecoder().decode(rd.bytes(4));
+        const m = PSD_BLEND_KEYS[k];
+        return m && m !== "pass-through" ? m : "normal";
+      };
+      if (key === "dsdw" || key === "isdw") {
+        b.u32();
+        const blur = fixed(b.u32());
+        b.u32();
+        const angle = fixed(b.u32());
+        const distance = fixed(b.u32());
+        const color = colorAt(b);
+        const blend = blendAt(b);
+        const enabled = b.u8() !== 0;
+        const useGlobalLight = b.u8() !== 0;
+        const opacity = b.u8() / 255;
+        const base = { id: newEffectId(), enabled, blend, opacity, color, angle, useGlobalLight, distance: clamp3(distance, 0, 3e4), size: clamp3(blur, 0, 250), antiAlias: false, noise: 0 };
+        items.push(key === "dsdw" ? { ...base, kind: "drop-shadow", spread: 0, knocksOut: true } : { ...base, kind: "inner-shadow", choke: 0 });
+      } else if (key === "oglw" || key === "iglw") {
+        b.u32();
+        const blur = fixed(b.u32());
+        b.u32();
+        const color = colorAt(b);
+        const blend = blendAt(b);
+        const enabled = b.u8() !== 0;
+        const opacity = b.u8() / 255;
+        const base = { id: newEffectId(), enabled, blend, opacity, fill: { type: "color", color }, technique: "softer", size: clamp3(blur, 0, 250), antiAlias: false, range: 0.5, jitter: 0, noise: 0 };
+        items.push(key === "oglw" ? { ...base, kind: "outer-glow", spread: 0 } : { ...base, kind: "inner-glow", choke: 0, source: "edge" });
+      } else if (key === "sofi") {
+        b.u32();
+        const blend = blendAt(b);
+        const color = colorAt(b);
+        const opacity = b.u8() / 255;
+        const enabled = b.u8() !== 0;
+        items.push({ id: newEffectId(), kind: "color-overlay", enabled, blend, opacity, color });
+      } else if (key === "bevl") notes.add("legacy bevels are not read");
+    }
+    return { effects: { enabled: true, items }, notes: [...notes] };
+  } catch {
+    return null;
+  }
+}
+
+// src/image-editor/psd/patterns.ts
+var MAX_EDGE = 3e4;
+var PATTERN_BLOCK_KEYS = ["Patt", "Pat2", "Pat3"];
+function modeChannels(mode) {
+  return mode === MODE_RGB || mode === MODE_LAB ? 3 : mode === MODE_CMYK ? 4 : 1;
+}
+var rowBytes2 = (width, depth) => depth === 1 ? Math.ceil(width / 8) : width * (depth / 8);
+function readPattern(r) {
+  const version = r.u32();
+  if (version !== 1) throw new PsdError(`Pattern version ${version}, expected 1.`);
+  const mode = r.u32();
+  r.u16();
+  r.u16();
+  const name = r.unicode();
+  const idLength = r.u8();
+  const id = new TextDecoder().decode(r.bytes(idLength));
+  let palette;
+  if (mode === MODE_INDEXED) {
+    palette = r.bytes(768).slice();
+    const next = r.peek(4);
+    if (next.length === 4 && !(next[0] === 0 && next[1] === 0 && next[2] === 0 && next[3] === 3)) r.skip(4);
+  }
+  const vmaVersion = r.u32();
+  if (vmaVersion !== 3) throw new PsdError(`Pattern virtual memory array list version ${vmaVersion}, expected 3.`);
+  const length = r.u32();
+  const body = new PsdReader(r.bytes(length));
+  const [top, left, bottom, right] = [body.i32(), body.i32(), body.i32(), body.i32()];
+  const width = right - left;
+  const height = bottom - top;
+  if (!(width > 0 && height > 0 && width <= MAX_EDGE && height <= MAX_EDGE)) throw new PsdError(`Pattern "${name}" has an invalid size ${width} \xD7 ${height}.`);
+  const count = body.u32();
+  if (count > 64) throw new PsdError(`Pattern "${name}" has ${count} channels.`);
+  const planes = [];
+  let depth = 8;
+  for (let i = 0; i < count + 2 && body.remaining > 0; i++) {
+    if (body.u32() === 0) continue;
+    const arrayLength = body.u32();
+    if (arrayLength === 0) continue;
+    if (arrayLength < 23) throw new PsdError(`Pattern "${name}" has a short channel.`);
+    const d32 = body.u32();
+    const [ct, cl, cb, cr] = [body.i32(), body.i32(), body.i32(), body.i32()];
+    const d16 = body.u16();
+    const compression = body.u8();
+    const data = body.bytes(arrayLength - 23);
+    const d = [1, 8, 16, 32].includes(d16) ? d16 : d32;
+    if (![1, 8, 16, 32].includes(d)) throw new PsdError(`Pattern "${name}" has depth ${d}.`);
+    if (ct < top || cl < left || cb > bottom || cr > right || cb < ct || cr < cl) throw new PsdError(`Pattern "${name}" has a channel outside its rectangle.`);
+    if (compression > 1) throw new PsdError(`Pattern "${name}" uses compression ${compression}.`);
+    depth = d;
+    const cw = cr - cl;
+    const ch = cb - ct;
+    const plane = decodePlanes(compression, data, { planes: 1, width: cw, height: ch, depth: d, psb: false });
+    if (cw === width && ch === height) {
+      planes.push(plane);
+      continue;
+    }
+    if (d === 1) throw new PsdError(`Pattern "${name}" has a cropped bitmap channel.`);
+    const bps = d / 8;
+    const out = new Uint8Array(rowBytes2(width, d) * height);
+    for (let y = 0; y < ch; y++) {
+      out.set(plane.subarray(y * cw * bps, (y + 1) * cw * bps), ((ct - top + y) * width + (cl - left)) * bps);
+    }
+    planes.push(out);
+  }
+  const nc = modeChannels(mode);
+  if (planes.length < nc) throw new PsdError(`Pattern "${name}" has fewer channels than its colour mode.`);
+  return { mode, width, height, name, id, palette, depth, channels: planes.slice(0, nc), alpha: planes[nc] };
+}
+function parsePatternBlock(data) {
+  const r = new PsdReader(data);
+  const out = [];
+  while (r.remaining >= 4) {
+    const length = r.u32();
+    if (length === 0) break;
+    out.push(readPattern(new PsdReader(r.bytes(length))));
+    r.skip(Math.min((4 - length % 4) % 4, r.remaining));
+  }
+  return out;
+}
+function psdPatternToEffectPattern(p) {
+  const data = toRgba8({ width: p.width, height: p.height, depth: p.depth, mode: p.mode, color: p.channels, alpha: p.alpha, palette: p.palette });
+  return { id: p.id, name: p.name, width: p.width, height: p.height, data };
+}
+function writePatternBlock(patterns) {
+  const out = new PsdWriter();
+  for (const p of patterns) {
+    if (!(p.width > 0 && p.height > 0) || p.width > 32767 || p.height > 32767) throw new PsdError(`Pattern "${p.name}" is ${p.width} \xD7 ${p.height}; patterns are 1 to 32767 px.`);
+    const one = new PsdWriter();
+    one.u32(1);
+    one.u32(MODE_RGB);
+    one.u16(p.height);
+    one.u16(p.width);
+    one.unicode(p.name, true);
+    const id = new TextEncoder().encode(p.id).subarray(0, 255);
+    one.u8(id.length);
+    one.bytes(id);
+    const n = p.width * p.height;
+    const plane = (c) => {
+      const v = new Uint8Array(n);
+      for (let i = 0; i < n; i++) v[i] = p.data[i * 4 + c];
+      return v;
+    };
+    const alpha = plane(3);
+    const opaque = alpha.every((v) => v === 255);
+    const body = new PsdWriter();
+    for (const v of [0, 0, p.height, p.width]) body.i32(v);
+    body.u32(24);
+    const array = (v) => {
+      const data = encodeRle(v, { planes: 1, width: p.width, height: p.height, depth: 8, psb: false });
+      body.u32(1);
+      body.u32(23 + data.length);
+      body.u32(8);
+      for (const x of [0, 0, p.height, p.width]) body.i32(x);
+      body.u16(8);
+      body.u8(1);
+      body.bytes(data);
+    };
+    for (let c = 0; c < 3; c++) array(plane(c));
+    for (let c = 3; c < 24; c++) body.u32(0);
+    if (opaque) body.u32(0);
+    else array(alpha);
+    body.u32(0);
+    const b = body.result();
+    one.u32(3);
+    one.u32(b.length);
+    one.bytes(b);
+    const bytes = one.result();
+    out.u32(bytes.length);
+    out.bytes(bytes);
+    for (let k = 0; k < (4 - bytes.length % 4) % 4; k++) out.u8(0);
+  }
+  return out.result();
+}
+
 // src/image-editor/psd/import.ts
 var PSD_BLEND_KEYS = {
   pass: "pass-through",
@@ -6685,15 +7511,14 @@ var FILL_KEYS = ["SoCo", "GdFl", "PtFl"];
 var TYPE_KEYS = ["TySh", "tySh"];
 var SMART_KEYS = ["SoLd", "SoLE", "PlLd"];
 var VECTOR_KEYS = ["vmsk", "vsms"];
-var EFFECT_KEYS = ["lfx2", "lfxs", "lmfx"];
 var percent = (v) => Math.round(v / 255 * 100) / 100;
 var Warnings = class {
   groups = /* @__PURE__ */ new Map();
   extra = [];
   add(message, layer) {
-    const list = this.groups.get(message) ?? [];
-    if (!list.includes(layer)) list.push(layer);
-    this.groups.set(message, list);
+    const list2 = this.groups.get(message) ?? [];
+    if (!list2.includes(layer)) list2.push(layer);
+    this.groups.set(message, list2);
   }
   list() {
     const out = [...this.extra];
@@ -6800,10 +7625,6 @@ function baseProps(ctx, rec, name, notes) {
   if (rec.clipping) props.clipped = true;
   const locks = locksOf(rec);
   if (locks) props.locks = locks;
-  if (rec.blocks.some((b) => EFFECT_KEYS.includes(b.key))) {
-    ctx.warn.add("Layer effects (lfx2) are not rendered", name);
-    notes.push("layer effects are not rendered");
-  }
   if (rec.blocks.some((b) => b.key === "artb" || b.key === "artd" || b.key === "abdd")) {
     ctx.warn.add("Artboards are not supported; they came in as plain groups, without their background colour and clipping", name);
     notes.push("artboard imported as a group");
@@ -6814,6 +7635,47 @@ function baseProps(ctx, rec, name, notes) {
   }
   return props;
 }
+function patternIds(e) {
+  if (e.kind === "pattern-overlay") return [e.patternId];
+  if (e.kind === "stroke" && e.fill.type === "pattern") return [e.fill.patternId];
+  if (e.kind === "bevel-emboss" && e.texture) return [e.texture.patternId];
+  return [];
+}
+function recordEffects(ctx, rec, name, notes, group) {
+  const key = ["lmfx", "lfx2", "lfxs"].find((k) => layerBlock(rec, k));
+  if (key) {
+    const data = layerBlock(rec, key);
+    const parsed = parseLfx2(data);
+    if (!parsed) {
+      ctx.warn.add("Layer effects could not be read; they are kept for export but not drawn", name);
+      notes.push("layer effects could not be read");
+      return { enabled: true, items: [], psd: { key, data: data.slice() } };
+    }
+    for (const n of parsed.notes) {
+      ctx.warn.add(`Layer effects were approximated: ${n}`, name);
+      notes.push(`effects: ${n}`);
+    }
+    for (const e of parsed.effects.items) {
+      for (const id of patternIds(e)) {
+        if (ctx.patterns.has(id) || builtinPattern(id)) continue;
+        ctx.warn.add("A pattern effect uses a pattern the file does not contain, and paints nothing", name);
+        notes.push(`pattern "${id}" is not in the file`);
+      }
+    }
+    return { ...parsed.effects, psd: { key, data: data.slice() } };
+  }
+  const legacy = layerBlock(rec, "lrFX");
+  if (legacy && !group) {
+    const parsed = parseLrfx(legacy);
+    if (!parsed) return void 0;
+    for (const n of parsed.notes) {
+      ctx.warn.add(`Layer effects were approximated: ${n}`, name);
+      notes.push(`effects: ${n}`);
+    }
+    return parsed.effects.items.length ? parsed.effects : void 0;
+  }
+  return void 0;
+}
 function importNode(ctx, node, depth) {
   const rec = ctx.file.layers[node.index];
   const name = layerName(rec);
@@ -6832,6 +7694,8 @@ function importNode(ctx, node, depth) {
       if (layer2) children.push(layer2);
     }
     const group = { type: "group", id: ctx.newId(name), ...props2, blend: groupBlend, children };
+    const effects2 = recordEffects(ctx, rec, name, notes, true);
+    if (effects2) group.effects = effects2;
     if (divider?.kind === SECTION_CLOSED) group.collapsed = true;
     const mask2 = recordMask(ctx, rec, name);
     if (mask2) group.mask = mask2;
@@ -6872,6 +7736,8 @@ function importNode(ctx, node, depth) {
   const layer = { type: "pixel", id: ctx.newId(name), ...props, surface: recordPixels(ctx, rec, name), offset: { x: 0, y: 0 } };
   const fill = u8Block(rec, "iOpa");
   if (fill !== void 0 && fill < 255) layer.fillOpacity = percent(fill);
+  const effects = recordEffects(ctx, rec, name, notes, false);
+  if (effects) layer.effects = effects;
   const mask = recordMask(ctx, rec, name);
   if (mask) layer.mask = mask;
   entry.type = "pixel";
@@ -6925,8 +7791,17 @@ function psdToLayers(file, options = {}) {
     skipPixels: options.skipPixels ?? false,
     summary: [],
     colorCount: colorChannelCount(header.colorMode, header.channels),
-    palette: header.colorMode === MODE_INDEXED ? file.colorModeData : void 0
+    palette: header.colorMode === MODE_INDEXED ? file.colorModeData : void 0,
+    patterns: /* @__PURE__ */ new Map()
   };
+  for (const block of file.globalBlocks) {
+    if (!PATTERN_BLOCK_KEYS.includes(block.key)) continue;
+    try {
+      for (const p of parsePatternBlock(block.data)) ctx.patterns.set(p.id, psdPatternToEffectPattern(p));
+    } catch (e) {
+      warn.extra.push(`The file's patterns could not be read (${e instanceof Error ? e.message : String(e)}); pattern effects paint nothing.`);
+    }
+  }
   const mode = COLOR_MODES[header.colorMode] ?? `mode ${header.colorMode}`;
   if (mode !== "rgb" || header.depth !== 8) {
     warn.extra.push(`The file is ${header.depth}-bit ${mode}; it was converted to 8-bit RGB.`);
@@ -6952,6 +7827,9 @@ function psdToLayers(file, options = {}) {
     const bg = mergedLayer(ctx);
     if (bg) layers = [bg];
   }
+  const i32 = (b) => b && b.length >= 4 ? new DataView(b.buffer, b.byteOffset, 4).getInt32(0) : void 0;
+  const angle = i32(resource(file, 1037));
+  const altitude = i32(resource(file, 1049));
   return {
     width: header.width,
     height: header.height,
@@ -6959,6 +7837,8 @@ function psdToLayers(file, options = {}) {
     warnings: warn.list(),
     summary: ctx.summary,
     resolution: resolution(file),
+    patterns: [...ctx.patterns.values()],
+    ...angle !== void 0 || altitude !== void 0 ? { globalLight: { angle: Math.max(-360, Math.min(360, angle ?? 120)), altitude: Math.max(0, Math.min(90, altitude ?? 30)) } } : {},
     info: { psb: header.psb, depth: header.depth, colorMode: mode, channels: header.channels }
   };
 }
@@ -6968,6 +7848,18 @@ function importPsd(bytes, options = {}) {
 }
 
 // src/image-editor/psd/export.ts
+function usedPatterns(e) {
+  if (e.kind === "pattern-overlay") return [e.patternId];
+  if (e.kind === "stroke" && e.fill.type === "pattern") return [e.fill.patternId];
+  if (e.kind === "bevel-emboss" && e.texture) return [e.texture.patternId];
+  return [];
+}
+var padEven = (d) => {
+  if (d.length % 2 === 0) return d;
+  const out = new Uint8Array(d.length + 1);
+  out.set(d);
+  return out;
+};
 var FLAG_PIXELS_IRRELEVANT = 8 | 16;
 var EMPTY_RECT = { top: 0, left: 0, bottom: 0, right: 0 };
 function unicodeBlock(s) {
@@ -7017,9 +7909,28 @@ function exportPsd(input) {
   const psb = width > PSD_MAX_DIMENSION || height > PSD_MAX_DIMENSION;
   const records = [];
   let nextId = 0;
-  const common = (layer, extra = []) => {
+  const notes = /* @__PURE__ */ new Map();
+  const note = (msg, name) => notes.set(msg, [...notes.get(msg) ?? [], name]);
+  const patternIds2 = /* @__PURE__ */ new Set();
+  const effectsBlock = (layer) => {
+    const fx = layer.effects;
+    if (!fx) return null;
+    for (const e of fx.items) for (const id of usedPatterns(e)) patternIds2.add(id);
+    const key = layer.type === "group" ? "lfxs" : "lfx2";
+    if (fx.psd) {
+      const original = parseLfx2(fx.psd.data);
+      if (original ? effectsFingerprint(original.effects) === effectsFingerprint(fx) : !fx.items.length) return { key, data: padEven(fx.psd.data) };
+    }
+    if (!fx.items.length && fx.enabled && (fx.scale ?? 1) === 1) return null;
+    const { data, dropped } = writeLfx2(fx);
+    if (dropped) note("Only the first outer glow, inner glow, bevel, satin and pattern overlay of a layer can be written; the others were left out", layer.name);
+    return { key, data };
+  };
+  const common2 = (layer, extra = []) => {
     const name = layer.name || (layer.type === "adjustment" ? adjustmentKindLabel(layer.kind) : "");
     const blocks = [{ key: "luni", data: unicodeBlock(name) }, { key: "lyid", data: u32Bytes(++nextId) }, ...extra];
+    const fx = effectsBlock(layer);
+    if (fx) blocks.push(fx);
     const locks = lockBits(layer);
     if (locks) blocks.push({ key: "lspf", data: u32Bytes(locks >>> 0) });
     return {
@@ -7048,7 +7959,7 @@ function exportPsd(input) {
         });
         for (const child of layer.children) write(child);
         const blendKey = BLEND_TO_PSD[layer.blend] ?? "norm";
-        const base = common(layer, [{ key: "lsct", data: sectionBlock(layer.collapsed ? SECTION_CLOSED : SECTION_OPEN, blendKey) }]);
+        const base = common2(layer, [{ key: "lsct", data: sectionBlock(layer.collapsed ? SECTION_CLOSED : SECTION_OPEN, blendKey) }]);
         const rec = {
           ...base,
           rect: EMPTY_RECT,
@@ -7067,7 +7978,7 @@ function exportPsd(input) {
       case "adjustment": {
         const block = writeAdjustmentBlock(layer.kind, layer.params);
         const rec = {
-          ...common(layer, [{ key: block.key, data: block.data }]),
+          ...common2(layer, [{ key: block.key, data: block.data }]),
           rect: EMPTY_RECT,
           channels: [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel),
           blendKey: BLEND_TO_PSD[layer.blend] ?? "norm"
@@ -7087,7 +7998,7 @@ function exportPsd(input) {
         if (layer.fillOpacity !== void 0 && layer.fillOpacity < 1) {
           extra.push({ key: "iOpa", data: Uint8Array.from([Math.round(Math.max(0, layer.fillOpacity) * 255), 0, 0, 0]) });
         }
-        const rec = { ...common(layer, extra), rect: EMPTY_RECT, channels: [], blendKey: BLEND_TO_PSD[layer.blend] ?? "norm" };
+        const rec = { ...common2(layer, extra), rect: EMPTY_RECT, channels: [], blendKey: BLEND_TO_PSD[layer.blend] ?? "norm" };
         const bounds = contentBounds(layer.surface);
         if (bounds) {
           const n2 = bounds.width * bounds.height;
@@ -7140,6 +8051,25 @@ function exportPsd(input) {
     { id: 1005, name: "", data: rw.result() },
     { id: 1057, name: "", data: version.result() }
   ];
+  if (input.globalLight) {
+    const i32 = (v) => {
+      const w = new PsdWriter();
+      w.i32(Math.round(v));
+      return w.result();
+    };
+    resources.push({ id: 1037, name: "", data: i32(input.globalLight.angle) }, { id: 1049, name: "", data: i32(input.globalLight.altitude) });
+  }
+  const globalBlocks = [];
+  if (patternIds2.size) {
+    const byId = new Map((input.patterns ?? []).map((p) => [p.id, p]));
+    const embed = [];
+    for (const id of patternIds2) {
+      const p = byId.get(id) ?? builtinPattern(id);
+      if (p) embed.push(p);
+      else note(`Pattern "${id}" is not in the document and was not embedded`, id);
+    }
+    if (embed.length) globalBlocks.push({ key: "Patt", data: writePatternBlock(embed) });
+  }
   const bytes = writePsd(
     {
       header: { psb, channels: planes.length, width, height, depth: 8, colorMode: 3 },
@@ -7147,13 +8077,14 @@ function exportPsd(input) {
       resources,
       layers: records,
       mergedAlpha: transparent && records.length > 0,
-      globalBlocks: [],
+      globalBlocks,
       imageCompression: 1,
       imageData: encodeRle(merged, { planes: planes.length, width, height, depth: 8, psb })
     },
     encodeLegacyName
   );
-  return { bytes, psb, records: records.length };
+  const warnings = [...notes].map(([msg, names]) => `${msg} (${names.map((n2) => `"${n2}"`).join(", ")}).`);
+  return { bytes, psb, records: records.length, warnings };
 }
 
 // src/image-editor/controller.ts
@@ -7184,22 +8115,53 @@ var PaintStrokeSession = class {
   constructor(controller, target, stroke, apply) {
     this.controller = controller;
     this.target = target;
-    this.stroke = stroke;
     this.apply = apply;
     this.before = controller._captureForStroke();
     this.base = target.surface;
     this.live = new Map(this.base.tiles);
+    if (stroke instanceof StrokeCoverage) {
+      this.stroke = stroke;
+      this.mixer = null;
+    } else {
+      this.stroke = null;
+      this.mixer = stroke.create(this.mixerPixels());
+      this.mixerInit = stroke;
+    }
   }
   controller;
   target;
-  stroke;
   apply;
   before;
   base;
   live;
   touched = /* @__PURE__ */ new Set();
+  stroke;
+  mixer;
+  mixerInit = null;
+  /** Mixer tiles written since the last update: they get new tile objects so the compositor sees them change. */
+  fresh = /* @__PURE__ */ new Set();
   last = null;
   closed = false;
+  /** The live pixels a mixer stroke reads and writes; base tiles are copied on first write. */
+  mixerPixels() {
+    const a = this.apply;
+    return {
+      offset: a.offset,
+      lockTransparency: a.lockTransparency,
+      selection: a.selection,
+      readTile: (tx, ty) => this.live.get(tileKey(tx, ty))?.data ?? (this.base.defaultValue ? defaultTile(this.base) : null),
+      writeTile: (tx, ty) => {
+        const key = tileKey(tx, ty);
+        if (!this.touched.has(key)) {
+          const src = this.base.tiles.get(key)?.data ?? defaultTile(this.base);
+          this.live.set(key, { data: new Uint8ClampedArray(src), uniform: null });
+          this.touched.add(key);
+        }
+        this.fresh.add(key);
+        return this.live.get(key).data;
+      }
+    };
+  }
   get layerId() {
     return this.target.id;
   }
@@ -7207,11 +8169,18 @@ var PaintStrokeSession = class {
   push(points) {
     if (this.closed || !points.length) return;
     this.last = points[points.length - 1];
-    this.update(this.stroke.push(points));
+    this.update(this.mixer ? this.mixer.push(points) : this.stroke.push(points));
   }
   update(rects) {
     if (!rects.length) return;
     const ch = this.base.channels;
+    if (this.mixer) {
+      for (const key of this.fresh) this.live.set(key, { data: this.live.get(key).data, uniform: null });
+      this.fresh.clear();
+      this.controller._strokeUpdate(this.target.id, this.target.channel, new TiledSurface(ch, new Map(this.live), this.base.defaultValue), rects);
+      return;
+    }
+    const stroke = this.stroke;
     const regions = /* @__PURE__ */ new Map();
     for (const r of rects) {
       for (const t of tilesInRect({ x: r.x - this.apply.offset.x, y: r.y - this.apply.offset.y, width: r.width, height: r.height })) {
@@ -7224,7 +8193,7 @@ var PaintStrokeSession = class {
       const src = this.base.tiles.get(key)?.data ?? defaultTile(this.base);
       const prev = this.touched.has(key) ? this.live.get(key)?.data : void 0;
       this.touched.add(key);
-      const data = applyStrokeToTile(this.stroke.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
+      const data = applyStrokeToTile(stroke.coverage, src, ch, tx, ty, this.apply, prev ? { into: prev, region: r } : {});
       this.live.set(key, { data, uniform: null });
     }
     this.controller._strokeUpdate(this.target.id, this.target.channel, new TiledSurface(ch, new Map(this.live), this.base.defaultValue), rects);
@@ -7232,7 +8201,8 @@ var PaintStrokeSession = class {
   /** Finishes the stroke (one undo step) and returns what changed. */
   end() {
     if (this.closed) throw new LayerOperationError("This stroke has already ended.");
-    this.update(this.stroke.finish(this.last ?? void 0));
+    const last = this.last ?? void 0;
+    this.update(this.mixer ? this.mixer.finish(last) : this.stroke.finish(last));
     this.closed = true;
     const ch = this.base.channels;
     const tiles = new Map(this.base.tiles);
@@ -7246,9 +8216,12 @@ var PaintStrokeSession = class {
       if (!sameTile(prev, tile)) changed = true;
     }
     const surface = changed ? new TiledSurface(ch, tiles, this.base.defaultValue) : null;
+    const mixerLoad = this.mixer ? this.mixerInit.end(this.mixer.load) : void 0;
     this.controller._strokeCommit(this.before, this.target.id, this.target.channel, surface);
-    const b = this.stroke.coverage.bounds;
-    return { layerId: this.target.id, channel: this.target.channel, bounds: changed ? b : null, dabs: this.stroke.dabCount };
+    const b = this.mixer ? this.mixer.bounds : this.stroke.coverage.bounds;
+    const result = { layerId: this.target.id, channel: this.target.channel, bounds: changed ? b : null, dabs: (this.mixer ?? this.stroke).dabCount };
+    if (mixerLoad) result.mixerLoad = mixerLoad;
+    return result;
   }
   /** Abandons the stroke and restores the layer. */
   cancel() {
@@ -7362,8 +8335,9 @@ var ImageEditorController = class {
     this.renderer.layerSources = {
       surfaceOf: (layer) => this.surfaceOf(layer),
       sourceIsOpaque: () => this.sourceIsOpaque(),
-      version: () => this.sourceVersion(),
-      globalLight: () => this.state.globalLight
+      version: () => `${this.sourceVersion()}:${this.patternsVersion()}`,
+      globalLight: () => this.state.globalLight,
+      pattern: (id) => this.state.patterns?.find((p) => p.id === id) ?? null
     };
     this.state = {
       sourceUrl: typeof options.image === "string" ? options.image : null,
@@ -7384,7 +8358,7 @@ var ImageEditorController = class {
       activeLayerId: null,
       activeTarget: "pixels",
       outputOpacity: 1,
-      paint: { brush: { ...DEFAULT_BRUSH }, foreground: "#000000", background: "#ffffff" },
+      paint: { brush: { ...DEFAULT_BRUSH }, foreground: "#000000", background: "#ffffff", mixer: { ...DEFAULT_MIXER }, mixerLoad: EMPTY_MIXER_LOAD },
       fit: options.fit ?? "margin"
     };
     if (options.image instanceof Object && "width" in options.image) {
@@ -7518,6 +8492,7 @@ var ImageEditorController = class {
     };
     if (s.legacyOutputBlur !== void 0) entry.legacyOutputBlur = s.legacyOutputBlur;
     if (s.globalLight) entry.globalLight = { ...s.globalLight };
+    if (s.patterns) entry.patterns = s.patterns;
     return entry;
   }
   restoreHistoryEntry(entry) {
@@ -7532,6 +8507,8 @@ var ImageEditorController = class {
     else delete s.legacyOutputBlur;
     if (entry.globalLight) s.globalLight = { ...entry.globalLight };
     else delete s.globalLight;
+    if (entry.patterns) s.patterns = entry.patterns;
+    else delete s.patterns;
     s.selection = entry.selection;
     if (this.imageElement !== entry.source.element && !this.samplePixelsOverride) this.samplePixels = null;
     this.imageElement = entry.source.element;
@@ -7753,7 +8730,14 @@ var ImageEditorController = class {
   }
   compositorSources() {
     const { width, height } = this.naturalSize;
-    return { width, height, surfaceOf: (l) => this.surfaceOf(l), version: this.sourceVersion(), globalLight: this.state.globalLight };
+    return {
+      width,
+      height,
+      surfaceOf: (l) => this.surfaceOf(l),
+      version: `${this.sourceVersion()}:${this.patternsVersion()}`,
+      globalLight: this.state.globalLight,
+      pattern: (id) => this.state.patterns?.find((p) => p.id === id) ?? null
+    };
   }
   sourceIds = /* @__PURE__ */ new WeakMap();
   nextSourceId = 1;
@@ -8199,6 +9183,22 @@ var ImageEditorController = class {
     this.commitLayers(setLayerEffects(this.state.layers, id, effects), void 0, commitToHistory);
     return this.getLayerEffects(id);
   }
+  patternIds = /* @__PURE__ */ new WeakMap();
+  /** Changes whenever the document's pattern list is replaced (the compositor then drops its caches). */
+  patternsVersion() {
+    const list2 = this.state.patterns;
+    if (!list2) return 0;
+    let id = this.patternIds.get(list2);
+    if (id === void 0) {
+      id = this.nextSourceId++;
+      this.patternIds.set(list2, id);
+    }
+    return id;
+  }
+  /** The document's patterns (from an opened PSD), besides the built-in ones. */
+  getDocumentPatterns() {
+    return this.state.patterns ?? [];
+  }
   /** The light effects with "use global light" follow. */
   getGlobalLight() {
     return { ...this.state.globalLight ?? DEFAULT_GLOBAL_LIGHT };
@@ -8375,12 +9375,38 @@ var ImageEditorController = class {
     const next = {
       brush: options.brush ? normalizeBrush({ ...cur.brush, ...options.brush }) : cur.brush,
       foreground: options.foreground !== void 0 ? toHex2(parseColor(options.foreground)) : cur.foreground,
-      background: options.background !== void 0 ? toHex2(parseColor(options.background)) : cur.background
+      background: options.background !== void 0 ? toHex2(parseColor(options.background)) : cur.background,
+      mixer: options.mixer ? normalizeMixer({ ...cur.mixer, ...options.mixer }) : cur.mixer,
+      mixerLoad: cur.mixerLoad
     };
     this.state.paint = next;
     this.notify();
     return next;
   }
+  /**
+   * Loads the Mixer Brush's reservoir full with `color` (default the foreground); the picked-up
+   * colour is kept. View state, no undo. Returns the brush load.
+   */
+  loadMixerBrush(color) {
+    const c = parseColor(color ?? this.state.paint.foreground);
+    const load = loadMixer(this.state.paint.mixerLoad, [c[0] / 255, c[1] / 255, c[2] / 255]);
+    this.state.paint = { ...this.state.paint, mixerLoad: load };
+    this.notify();
+    return load;
+  }
+  /** Cleans the Mixer Brush: empties the pickup well (the reservoir is kept). Returns the brush load. */
+  cleanMixerBrush() {
+    const load = cleanMixer(this.state.paint.mixerLoad);
+    this.state.paint = { ...this.state.paint, mixerLoad: load };
+    this.notify();
+    return load;
+  }
+  /** Empties the Mixer Brush entirely (no reservoir, nothing picked up). Returns the brush load. */
+  emptyMixerBrush() {
+    this.state.paint = { ...this.state.paint, mixerLoad: EMPTY_MIXER_LOAD };
+    this.notify();
+    return EMPTY_MIXER_LOAD;
+  }
   /** D: black foreground, white background. */
   resetPaintColors() {
     this.setPaintOptions({ foreground: "#000000", background: "#ffffff" });
@@ -8425,7 +9451,11 @@ var ImageEditorController = class {
    */
   beginStroke(init = {}) {
     const tool = init.tool ?? "brush";
+    if (tool !== "brush" && tool !== "eraser" && tool !== "mixer") throw new LayerOperationError(`Unknown paint tool "${String(tool)}"; use brush, eraser or mixer.`);
     const target = this.paintTarget(init.layerId, init.channel, tool === "eraser" ? "erase" : "paint");
+    if (tool === "mixer" && target.channel === "mask") {
+      throw new LayerOperationError("The Mixer Brush paints colour on pixels, not on masks; target pixels (channel pixels), or paint the mask with the brush.");
+    }
     const brush = normalizeBrush({ ...this.state.paint.brush, ...init.brush ?? {} });
     const color = parseColor(init.color ?? this.state.paint.foreground);
     const background = parseColor(init.background ?? this.state.paint.background);
@@ -8443,8 +9473,26 @@ var ImageEditorController = class {
       selection: this.state.selection?.bounds ? this.state.selection : null,
       offset: target.offset
     };
+    if (tool === "mixer") return new PaintStrokeSession(this, target, this.mixerStroke(init, brush), apply);
     return new PaintStrokeSession(this, target, new StrokeCoverage(brush), apply);
   }
+  /** A Mixer Brush stroke's start: the settings, and the load (refilled when asked or set to). */
+  mixerStroke(init, brush) {
+    const settings = normalizeMixer({ ...this.state.paint.mixer, ...init.mixer ?? {} });
+    let load = this.state.paint.mixerLoad;
+    if (init.color !== void 0 || settings.loadEachStroke) {
+      const c = parseColor(init.color ?? this.state.paint.foreground);
+      load = loadMixer(load, [c[0] / 255, c[1] / 255, c[2] / 255]);
+    }
+    return {
+      create: (pixels) => new MixerStroke(brush, settings, load, pixels),
+      end: (after) => {
+        const next = settings.cleanEachStroke ? cleanMixer(after) : after;
+        this.state.paint = { ...this.state.paint, mixerLoad: next };
+        return next;
+      }
+    };
+  }
   /** @internal Shows a stroke's live surface (no history). */
   _strokeUpdate(layerId, channel, surface, rects) {
     this.state.layers = mapLayer(this.state.layers, layerId, (l) => this.withSurface(l, channel, surface));
@@ -8468,7 +9516,7 @@ var ImageEditorController = class {
   }
   /**
    * Paints a whole stroke in one call (agents, replays): `points` in document pixels with optional
-   * pressure, through the brush or eraser. One undo step. Returns the layer, channel, the changed
+   * pressure, through the brush, eraser or Mixer Brush. One undo step. Returns the layer, channel, the changed
    * document bounds and the number of dabs.
    */
   paintStroke(init) {
@@ -9433,6 +10481,10 @@ var ImageEditorController = class {
     s.activeLayerId = pixels.length ? pixels[pixels.length - 1].id : null;
     s.activeTarget = "pixels";
     this.psdResolution = result.resolution;
+    if (result.patterns.length) s.patterns = result.patterns;
+    else delete s.patterns;
+    if (result.globalLight) s.globalLight = result.globalLight;
+    else delete s.globalLight;
     this.lastLoadProblems = result.warnings;
     this.notify();
     return {
@@ -9477,6 +10529,11 @@ var ImageEditorController = class {
       return baked;
     };
     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);
+      return p;
+    };
+    const prepareLayer = async (layer) => {
       if (layer.type === "group") {
         const children = [];
         for (const c of layer.children) {
@@ -9496,6 +10553,7 @@ var ImageEditorController = class {
         const content = { ...layer, visible: true, opacity: 1, blend: "normal", annotation: { ...layer.annotation, blend: void 0 } };
         delete content.mask;
         delete content.clipped;
+        delete content.effects;
         const data = compositor.composite([content], canvas, sources);
         const out2 = {
           type: "pixel",
@@ -9509,6 +10567,7 @@ var ImageEditorController = class {
         };
         if (layer.clipped) out2.clipped = true;
         if (layer.locks) out2.locks = layer.locks;
+        if (layer.effects) out2.effects = layer.effects;
         const mask2 = bakeMask(layer);
         if (mask2) out2.mask = mask2;
         return out2;
@@ -9525,6 +10584,7 @@ var ImageEditorController = class {
         delete content.mask;
         delete content.clipped;
         delete content.fillOpacity;
+        delete content.effects;
         const data = compositor.composite([content], canvas, sources);
         out = { ...out, surface: surfaceFromPixels({ width, height, data }, 4, -layer.offset.x, -layer.offset.y) };
       }
@@ -9547,7 +10607,8 @@ var ImageEditorController = class {
     if (s.legacyOutputBlur) warnings.push("The document-level blur of an old document is not written.");
     for (const [msg, names] of note) warnings.push(`${msg} (${names.length === 1 ? "layer" : "layers"} ${names.map((n) => `"${n}"`).join(", ")}).`);
     const merged = compositor.composite(prepared, canvas, { ...sources, version: `psd:${Date.now()}` });
-    const result = exportPsd({ width, height, layers: prepared, merged, resolution: this.psdResolution });
+    const result = exportPsd({ width, height, layers: prepared, merged, resolution: this.psdResolution, patterns: this.state.patterns, globalLight: this.state.globalLight });
+    warnings.push(...result.warnings);
     return { bytes: result.bytes, warnings, psb: result.psb, width, height };
   }
   async replaceSource(src, clearAnnotations) {
@@ -9651,6 +10712,9 @@ var ImageEditorController = class {
       const light = data.globalLight;
       if (light && Number.isFinite(light.angle) && Number.isFinite(light.altitude)) s.globalLight = { angle: light.angle, altitude: Math.min(90, Math.max(0, light.altitude)) };
       else delete s.globalLight;
+      const patterns = deserializePatterns(data.patterns, problems);
+      if (patterns.length) s.patterns = patterns;
+      else delete s.patterns;
       if (!this.imageElement && typeof data.width === "number" && typeof data.height === "number" && data.width > 0 && data.height > 0) {
         s.imageDimensions = { width: data.width, height: data.height };
       }
@@ -9665,6 +10729,7 @@ var ImageEditorController = class {
       s.transform = { ...data.transform };
       s.activeLayerId = null;
       delete s.globalLight;
+      delete s.patterns;
     }
     s.activeTarget = "pixels";
     this.viewKey = [];
@@ -9674,7 +10739,7 @@ var ImageEditorController = class {
   serializeState() {
     const { width, height } = this.naturalSize;
     const view = legacyView(this.stack(), width, height, null);
-    if (view.exact && !this.state.globalLight) {
+    if (view.exact && !this.state.globalLight && !this.state.patterns?.length) {
       return {
         // States without adjustment layers keep schema 1, so they round-trip unchanged.
         version: view.adjustments.layers?.length ? 2 : 1,
@@ -9702,6 +10767,7 @@ var ImageEditorController = class {
     };
     if (this.state.legacyOutputBlur !== void 0) out.legacyOutputBlur = this.state.legacyOutputBlur;
     if (this.state.globalLight) out.globalLight = { ...this.state.globalLight };
+    if (this.state.patterns?.length) out.patterns = serializePatterns(this.state.patterns);
     return out;
   }
 };
@@ -10291,17 +11357,17 @@ function controlTrackBackground(spec) {
       return void 0;
   }
 }
-function getControlPath(obj, path) {
-  let cur = obj;
+function getControlPath(obj2, path) {
+  let cur = obj2;
   for (const part of path.split(".")) {
     if (cur === null || cur === void 0) return void 0;
     cur = cur[part];
   }
   return cur;
 }
-function setControlPath(obj, path, value) {
+function setControlPath(obj2, path, value) {
   const parts = path.split(".");
-  const root = Array.isArray(obj) ? [...obj] : { ...obj };
+  const root = Array.isArray(obj2) ? [...obj2] : { ...obj2 };
   let cur = root;
   for (let i = 0; i < parts.length - 1; i++) {
     const next = cur[parts[i]];
@@ -10359,8 +11425,8 @@ function describeSelection(mask) {
   if (!mask || !mask.bounds) return "No selection";
   let sum = 0;
   for (let i = 0; i < mask.data.length; i++) sum += mask.data[i];
-  const pct = sum / 255 / mask.data.length * 100;
-  const shown = pct >= 10 ? Math.round(pct) : Math.round(pct * 10) / 10;
+  const pct2 = sum / 255 / mask.data.length * 100;
+  const shown = pct2 >= 10 ? Math.round(pct2) : Math.round(pct2 * 10) / 10;
   return `${mask.bounds.width} \xD7 ${mask.bounds.height} px selected (${shown}% of the image)`;
 }
 
@@ -10370,7 +11436,7 @@ var modeSchema = {
   enum: [...SELECTION_MODES],
   description: "How the result combines with the current selection (default replace)."
 };
-var num2 = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+var num3 = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
 function summary(controller) {
   const sel = controller.getSelection();
   const { width, height } = controller.getState().imageDimensions;
@@ -10420,7 +11486,7 @@ function createImageSelectionTools(controller) {
     },
     annotations: writeAnnotations("Select a region", true),
     handler: ({ shape, x, y, width, height, mode, feather }) => {
-      const opts = { mode: parseSelectionMode(mode), feather: num2(feather, 0) };
+      const opts = { mode: parseSelectionMode(mode), feather: num3(feather, 0) };
       switch (shape) {
         case "all":
           controller.selectAll();
@@ -10433,7 +11499,7 @@ function createImageSelectionTools(controller) {
           break;
         case "rect":
         case "ellipse": {
-          const rect = { x: num2(x, NaN), y: num2(y, NaN), width: num2(width, NaN), height: num2(height, NaN) };
+          const rect = { x: num3(x, NaN), y: num3(y, NaN), width: num3(width, NaN), height: num3(height, NaN) };
           if (![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite)) {
             throw new Error("rect and ellipse need numeric x, y, width and height.");
           }
@@ -10472,15 +11538,15 @@ function createImageSelectionTools(controller) {
     },
     annotations: writeAnnotations("Select by colour", true),
     handler: async ({ x, y, color, tolerance, contiguous, fuzziness, sampleMerged, sample, mode }) => {
-      const common = {
+      const common2 = {
         mode: parseSelectionMode(mode),
         sampleMerged: sampleMerged === true,
         sample: sample ?? "composite"
       };
       if (typeof color === "string") {
-        await controller.selectColorRange([{ color }], { ...common, fuzziness: num2(fuzziness, 40) });
+        await controller.selectColorRange([{ color }], { ...common2, fuzziness: num3(fuzziness, 40) });
       } else if (typeof x === "number" && typeof y === "number") {
-        await controller.magicWand({ x, y }, { ...common, tolerance: num2(tolerance, 32), contiguous: contiguous !== false });
+        await controller.magicWand({ x, y }, { ...common2, tolerance: num3(tolerance, 32), contiguous: contiguous !== false });
       } else {
         throw new Error("Pass x and y (magic wand) or color (#rrggbb).");
       }
@@ -10504,7 +11570,7 @@ function createImageSelectionTools(controller) {
     handler: ({ op, radius }) => {
       if (!SELECTION_MODIFY_OPS.includes(op)) throw new Error(`Unknown op "${String(op)}".`);
       if (!controller.getSelection()) throw new Error("Nothing is selected.");
-      controller.modifySelection(op, Math.min(500, Math.max(0, num2(radius, 0))));
+      controller.modifySelection(op, Math.min(500, Math.max(0, num3(radius, 0))));
       return summary(controller);
     }
   };
@@ -10528,12 +11594,12 @@ function createImageSelectionTools(controller) {
     handler: async (params) => {
       if (!controller.getSelection()) throw new Error("Nothing is selected.");
       await controller.refineSelection({
-        radius: num2(params.radius, 8),
+        radius: num3(params.radius, 8),
         smartRadius: params.smartRadius === true,
-        smooth: num2(params.smooth, 0),
-        feather: num2(params.feather, 0),
-        contrast: num2(params.contrast, 0),
-        shiftEdge: num2(params.shiftEdge, 0)
+        smooth: num3(params.smooth, 0),
+        feather: num3(params.feather, 0),
+        contrast: num3(params.contrast, 0),
+        shiftEdge: num3(params.shiftEdge, 0)
       });
       return summary(controller);
     }
@@ -10680,14 +11746,14 @@ function rebin(bins, count) {
   return out;
 }
 function histogramSummary(h, bins) {
-  const pct = (n) => h.samples ? round(n / h.samples * 100) : 0;
+  const pct2 = (n) => h.samples ? round(n / h.samples * 100) : 0;
   const channels = { red: h.red, green: h.green, blue: h.blue, luminance: h.luminance };
   return {
     samples: h.samples,
     transparent: h.transparent,
     clipping: {
-      shadowsPercent: { red: pct(h.shadows[0]), green: pct(h.shadows[1]), blue: pct(h.shadows[2]) },
-      highlightsPercent: { red: pct(h.highlights[0]), green: pct(h.highlights[1]), blue: pct(h.highlights[2]) }
+      shadowsPercent: { red: pct2(h.shadows[0]), green: pct2(h.shadows[1]), blue: pct2(h.shadows[2]) },
+      highlightsPercent: { red: pct2(h.highlights[0]), green: pct2(h.highlights[1]), blue: pct2(h.highlights[2]) }
     },
     stats: Object.fromEntries(Object.entries(channels).map(([k, v]) => [k, binStats(v, h.samples)])),
     ...bins ? { bins: Object.fromEntries(Object.entries(channels).map(([k, v]) => [k, rebin(v, bins)])) } : {}
@@ -11442,7 +12508,7 @@ var WRITE_IDEMPOTENT3 = { readOnlyHint: false, destructiveHint: false, idempoten
 var DESTRUCTIVE2 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var LAYER_ID3 = { type: "string", description: "Layer id from list_layers (a pixel, annotation or group layer)." };
 var EFFECT_ID = { type: "string", description: "Effect id from list_layer_effects or add_layer_effect." };
-var BLEND_IDS = BLEND_MODES.map((m) => m.id);
+var BLEND_IDS = BLEND_MODES.map((m) => m.id).filter((id) => id !== "pigment");
 var DEFS = {
   color: { type: "string", pattern: "^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$", description: "Colour as #rrggbb." },
   contour: {
@@ -11633,11 +12699,13 @@ function settingsSchema(forUpdate) {
     additionalProperties: false
   };
 }
-function patternList() {
-  return builtinPatternIds().map((id) => {
+function patternList(controller) {
+  const doc = controller.getDocumentPatterns().map((p) => ({ id: p.id, name: p.name, width: p.width, height: p.height, builtin: false }));
+  const builtins = builtinPatternIds().map((id) => {
     const p = builtinPattern(id);
     return { id, name: p.name, width: p.width, height: p.height, builtin: true };
   });
+  return [...doc, ...builtins];
 }
 function describeLayerEffects(effects) {
   return {
@@ -11655,13 +12723,13 @@ function createImageEffectTools(controller) {
     return id;
   };
   const result = (layerId, extra = {}) => ({ layerId, ...extra, ...describeLayerEffects(controller.getLayerEffects(layerId)) });
-  const list = {
+  const list2 = {
     name: "list_layer_effects",
     title: "List layer effects",
     description: "Returns a layer's effects: the master switch (enabled), Scale Effects (scale, 1 = 100 %), margin (px the effects reach beyond the shape), whether they came from a PSD, and every effect with its id, kind, label and all settings. Also returns the document global light and the pattern ids pattern effects can use.",
     inputSchema: { type: "object", properties: { layerId: LAYER_ID3 }, required: ["layerId"], additionalProperties: false },
     annotations: { title: "List layer effects", ...READ3 },
-    handler: ({ layerId }) => result(layerArg(layerId), { globalLight: controller.getGlobalLight(), patterns: patternList(), kinds: [...LAYER_EFFECT_KINDS] })
+    handler: ({ layerId }) => result(layerArg(layerId), { globalLight: controller.getGlobalLight(), patterns: patternList(controller), kinds: [...LAYER_EFFECT_KINDS] })
   };
   const add = {
     name: "add_layer_effect",
@@ -11761,10 +12829,163 @@ function createImageEffectTools(controller) {
       return { globalLight: controller.setGlobalLight(next) };
     }
   };
-  return [list, add, update, remove, setEnabled, light];
+  return [list2, add, update, remove, setEnabled, light];
 }
 
+// src/image-editor/layers/paint-ui.ts
+var plain2 = { kind: "plain" };
+var BRUSH_OPTION_CONTROLS = [
+  { id: "size", label: "Size", section: "layer", min: 1, max: 500, step: 1, default: 20, decimals: 0, track: plain2, unit: "px" },
+  { id: "hardness", label: "Hardness", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "opacity", label: "Opacity", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "flow", label: "Flow", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "smoothing", label: "Smoothing", section: "layer", min: 0, max: 0.95, step: 0.01, default: 0, decimals: 0, track: plain2, displayScale: 100, unit: "%" }
+];
+var MIXER_OPTION_CONTROLS = [
+  { id: "wet", label: "Wet", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "load", label: "Load", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
+  { id: "mix", label: "Mix", section: "layer", min: 0, max: 1, step: 0.01, default: 0.5, decimals: 0, track: plain2, displayScale: 100, unit: "%" }
+];
+var MIXER_MIXING_OPTIONS = [
+  { id: "rgb", label: "RGB", title: "Mix colours as RGB averages" },
+  { id: "pigment", label: "Pigment", title: "Mix colours like paint: blue and yellow make green" }
+];
+var PAINT_TOOLS = [
+  { id: "move", label: "Move", shortcut: "V" },
+  { id: "brush", label: "Brush", shortcut: "B" },
+  { id: "mixer", label: "Mixer", shortcut: "Shift+B" },
+  { id: "eraser", label: "Eraser", shortcut: "E" }
+];
+var isPaintTool = (tool) => tool === "move" || tool === "brush" || tool === "mixer" || tool === "eraser";
+function rgbUnitToHex(c) {
+  return `#${c.map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+function sizeStep(size) {
+  return size < 10 ? 1 : size < 50 ? 5 : size < 100 ? 10 : size < 200 ? 25 : size < 500 ? 50 : 100;
+}
+var isTyping = (t) => {
+  const el = t;
+  return Boolean(el && (el.isContentEditable || el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT"));
+};
+function handlePaintShortcut(controller, e) {
+  if (e.ctrlKey || e.metaKey || e.altKey || isTyping(e.target)) return false;
+  const brush = controller.getState().paint.brush;
+  const set = (b) => controller.setPaintOptions({ brush: b });
+  const key = e.key;
+  switch (key.toLowerCase()) {
+    case "b":
+      controller.setTool(e.shiftKey || key === "B" ? "mixer" : "brush");
+      return true;
+    case "e":
+      controller.setTool("eraser");
+      return true;
+    case "v":
+      controller.setTool("move");
+      return true;
+    case "d":
+      controller.resetPaintColors();
+      return true;
+    case "x":
+      controller.swapPaintColors();
+      return true;
+  }
+  if (key === "[" || key === "{") {
+    if (e.shiftKey || key === "{") set({ hardness: Math.max(0, Math.round((brush.hardness - 0.25) * 4) / 4) });
+    else set({ size: Math.max(1, brush.size - sizeStep(brush.size - 1)) });
+    return true;
+  }
+  if (key === "]" || key === "}") {
+    if (e.shiftKey || key === "}") set({ hardness: Math.min(1, Math.round((brush.hardness + 0.25) * 4) / 4) });
+    else set({ size: Math.min(MAX_BRUSH_SIZE, brush.size + sizeStep(brush.size)) });
+    return true;
+  }
+  if (/^[0-9]$/.test(key) && isPaintTool(controller.getState().activeTool)) {
+    set({ opacity: key === "0" ? 1 : Number(key) / 10 });
+    return true;
+  }
+  return false;
+}
+function pointerPressure(e) {
+  if (e.pointerType === "pen" && typeof e.pressure === "number" && e.pressure > 0) return Math.min(1, e.pressure);
+  return 1;
+}
+var PaintGesture = class {
+  constructor(controller) {
+    this.controller = controller;
+  }
+  controller;
+  stroke = null;
+  move = null;
+  /** The last refusal (e.g. "layer is locked"), for the editor to show. */
+  error = null;
+  get active() {
+    return Boolean(this.stroke || this.move);
+  }
+  down(sample) {
+    this.error = null;
+    const tool = this.controller.getState().activeTool;
+    try {
+      if (tool === "move") {
+        const layer = this.controller.getActiveLayer();
+        if (!layer) throw new Error("Select a layer to move in the Layers panel.");
+        if (layer.type !== "pixel") throw new Error(`Only pixel layers move; "${layer.name}" is a ${layer.type} layer.`);
+        if (layer.locks?.all || layer.locks?.position) throw new Error(`Layer "${layer.name}" has its position locked.`);
+        this.move = { id: layer.id, start: { x: sample.x, y: sample.y }, origin: { ...layer.offset }, moved: false };
+        return null;
+      }
+      if (tool === "brush" || tool === "eraser" || tool === "mixer") {
+        this.stroke = this.controller.beginStroke({ tool });
+        this.stroke.push([sample]);
+        return null;
+      }
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+      this.stroke = null;
+      this.move = null;
+    }
+    return this.error;
+  }
+  /** Feeds pointer samples (all coalesced events of one move, in order). */
+  moveTo(samples) {
+    if (!samples.length) return;
+    if (this.stroke) {
+      this.stroke.push(samples);
+      return;
+    }
+    const m = this.move;
+    if (m) {
+      const last = samples[samples.length - 1];
+      const x = m.origin.x + Math.round(last.x - m.start.x);
+      const y = m.origin.y + Math.round(last.y - m.start.y);
+      try {
+        this.controller.offsetLayer(m.id, { x, y }, !m.moved);
+        m.moved = true;
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+        this.move = null;
+      }
+    }
+  }
+  up() {
+    if (this.stroke) {
+      try {
+        this.stroke.end();
+      } catch (err) {
+        this.error = err instanceof Error ? err.message : String(err);
+      }
+    }
+    this.stroke = null;
+    this.move = null;
+  }
+  cancel() {
+    this.stroke?.cancel();
+    this.stroke = null;
+    this.move = null;
+  }
+};
+
 // src/image-editor/paint-tools.ts
+var READ4 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE4 = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var DESTRUCTIVE3 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var TARGET = {
@@ -11785,10 +13006,30 @@ var BRUSH = {
     smoothing: { type: "number", minimum: 0, maximum: 0.95, description: "Point smoothing 0..0.95 (default 0)." },
     pressureSize: { type: "boolean", description: "Point pressure scales the size (default true)." },
     pressureOpacity: { type: "boolean", description: "Point pressure scales the opacity (default false)." },
-    blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "How paint combines with the layer (default normal)." }
+    blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "How paint combines with the layer (default normal). pigment mixes it in like real paint (blue into yellow gives green) instead of laying it over." }
+  },
+  additionalProperties: false
+};
+var MIXER = {
+  type: "object",
+  description: "Mixer Brush settings (tool mixer only); missing fields use the current mixer options (wet 0.5, load 0.5, mix 0.5, loadEachStroke true, cleanEachStroke true, mixing rgb).",
+  properties: {
+    wet: { type: "number", minimum: 0, maximum: 1, description: "How much canvas colour each dab picks up, 0 (dry: paints only the reservoir) .. 1 (default 0.5)." },
+    load: { type: "number", minimum: 0, maximum: 1, description: "How much paint the reservoir holds, 0 .. 1 (default 0.5); below 1 it drains per dab, so long strokes run dry." },
+    mix: { type: "number", minimum: 0, maximum: 1, description: "How far each dab's paint moves from the reservoir towards the picked-up colour, 0 .. 1 (default 0.5)." },
+    loadEachStroke: { type: "boolean", description: "Refill the reservoir with `color` (or the foreground) before the stroke (default true). Off, the brush keeps what is left of its last load." },
+    cleanEachStroke: { type: "boolean", description: "Empty the pickup well after the stroke (default true). Off, the next stroke starts with the colour this one picked up." },
+    mixing: { type: "string", enum: [...MIXING_MODELS], description: "rgb (default): RGB averages. pigment: mixes like paint (Kubelka-Munk), so blue dragged through yellow makes green." }
   },
   additionalProperties: false
 };
+function mixerLoadResult(load) {
+  return {
+    reservoir: load.reservoir ? rgbUnitToHex(load.reservoir) : null,
+    amount: Math.round(load.amount * 1e3) / 1e3,
+    pickup: load.pickup ? rgbUnitToHex(load.pickup) : null
+  };
+}
 function readTarget(args) {
   return { layerId: args.layerId, channel: args.channel };
 }
@@ -11796,11 +13037,11 @@ function createImagePaintTools(controller) {
   const paintStroke = {
     name: "paint_stroke",
     title: "Paint a brush stroke",
-    description: "Paints one stroke with the brush (or removes pixels with the eraser) through points in document pixels (optional pressure 0..1 each) on a pixel layer or a layer mask. The selection limits the paint; a transparency-locked layer keeps its alpha (the eraser then paints the background colour). One undo step. Returns the layerId, channel, changed bounds and dab count.",
+    description: "Paints one stroke with the brush, smears and blends paint with the Mixer Brush (tool mixer: its reservoir mixes with colour picked up from the layer under each dab, in RGB or pigment mixing), or removes pixels with the eraser, through points in document pixels (optional pressure 0..1 each) on a pixel layer or a layer mask (the mixer paints pixels only). The selection limits the paint; a transparency-locked layer keeps its alpha (the eraser then paints the background colour). One undo step. Returns the layerId, channel, changed bounds and dab count, and for the mixer its mixerLoad after the stroke ({reservoir, amount, pickup}).",
     inputSchema: {
       type: "object",
       properties: {
-        tool: { type: "string", enum: ["brush", "eraser"], description: "brush (default) or eraser." },
+        tool: { type: "string", enum: ["brush", "eraser", "mixer"], description: "brush (default), eraser, or mixer (the Mixer Brush: picks up and blends the layer colour under each dab)." },
         points: {
           type: "array",
           minItems: 1,
@@ -11817,21 +13058,66 @@ function createImagePaintTools(controller) {
             additionalProperties: false
           }
         },
-        color: { type: "string", description: "Paint colour #rrggbb (default the foreground). On a mask its grey value: #000000 hides, #ffffff reveals." },
+        color: {
+          type: "string",
+          description: "Paint colour #rrggbb (default the foreground). On a mask its grey value: #000000 hides, #ffffff reveals. For the mixer, the colour its reservoir is loaded with before the stroke (given, it loads even with loadEachStroke false)."
+        },
         brush: BRUSH,
+        mixer: MIXER,
         ...TARGET
       },
       required: ["points"],
       additionalProperties: false
     },
     annotations: { title: "Paint a brush stroke", ...WRITE4 },
-    handler: (args) => controller.paintStroke({
-      tool: args.tool,
-      points: args.points,
-      color: args.color,
-      brush: args.brush,
-      ...readTarget(args)
-    })
+    handler: (args) => {
+      const tool = args.tool;
+      if (args.mixer !== void 0 && tool !== "mixer") throw new LayerOperationError('mixer settings apply to the Mixer Brush only; pass tool "mixer", or drop mixer.');
+      const result = controller.paintStroke({
+        tool,
+        points: args.points,
+        color: args.color,
+        brush: args.brush,
+        mixer: args.mixer,
+        ...readTarget(args)
+      });
+      return result.mixerLoad ? { ...result, mixerLoad: mixerLoadResult(result.mixerLoad) } : result;
+    }
+  };
+  const getMixer = {
+    name: "get_mixer_brush",
+    title: "Get the Mixer Brush",
+    description: "Reads the Mixer Brush: its settings (wet, load, mix, loadEachStroke, cleanEachStroke, mixing) and what it carries now (reservoir #rrggbb or null, amount 0..1 left, pickup #rrggbb or null). Call it before a paint_stroke with tool mixer and loadEachStroke false, to know the brush's starting paint.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Get the Mixer Brush", ...READ4 },
+    handler: () => {
+      const { mixer, mixerLoad } = controller.getState().paint;
+      return { settings: { ...mixer }, load: mixerLoadResult(mixerLoad) };
+    }
+  };
+  const loadMixerTool = {
+    name: "load_mixer_brush",
+    title: "Load the Mixer Brush",
+    description: "Fills the Mixer Brush reservoir with a colour (amount 1); the picked-up colour is kept. View state, not an undo step. Use it with loadEachStroke false to carry one load across several paint_stroke calls. Returns the load {reservoir, amount, pickup}.",
+    inputSchema: {
+      type: "object",
+      properties: { color: { type: "string", description: "Paint colour #rrggbb (default the foreground)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Load the Mixer Brush", ...WRITE4, idempotentHint: true },
+    handler: (args) => mixerLoadResult(controller.loadMixerBrush(args.color))
+  };
+  const cleanMixerTool = {
+    name: "clean_mixer_brush",
+    title: "Clean the Mixer Brush",
+    description: "Cleans the Mixer Brush: empties the pickup well so the next stroke starts without canvas colour; with emptyReservoir also drops the loaded paint (the brush then only smears). View state, not an undo step. Returns the load {reservoir, amount, pickup}.",
+    inputSchema: {
+      type: "object",
+      properties: { emptyReservoir: { type: "boolean", description: "Also drop the reservoir (default false)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Clean the Mixer Brush", ...WRITE4, idempotentHint: true },
+    handler: (args) => mixerLoadResult(args.emptyReservoir === true ? controller.emptyMixerBrush() : controller.cleanMixerBrush())
   };
   const fill = {
     name: "fill_pixels",
@@ -11842,7 +13128,7 @@ function createImagePaintTools(controller) {
       properties: {
         color: { type: "string", description: "Fill colour #rrggbb or #rrggbbaa (default the foreground)." },
         opacity: { type: "number", minimum: 0, maximum: 1, description: "Fill opacity 0..1 (default 1)." },
-        blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal)." },
+        blend: { type: "string", enum: BLEND_MODES.map((m) => m.id), description: "Blend mode (default normal). pigment mixes the colour into the pixels like paint, opacity being the share of new paint." },
         useSelection: { type: "boolean", description: "Limit to the selection when there is one (default true)." },
         ...TARGET
       },
@@ -11873,11 +13159,11 @@ function createImagePaintTools(controller) {
     annotations: { title: "Clear pixels", ...DESTRUCTIVE3 },
     handler: (args) => controller.clearPixels({ opacity: args.opacity, useSelection: args.useSelection, ...readTarget(args) })
   };
-  return [paintStroke, fill, clear];
+  return [paintStroke, fill, clear, getMixer, loadMixerTool, cleanMixerTool];
 }
 
 // src/image-editor/psd-tools.ts
-var READ4 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var READ5 = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var DESTRUCTIVE4 = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
 var DATA = {
   type: "string",
@@ -11898,7 +13184,7 @@ function createImagePsdTools(controller) {
     title: "Inspect a PSD",
     description: "Reads a PSD / PSB without opening it: size, bit depth, colour mode, resolution, and every layer (bottom first, a group before its children) with its PSD kind, the layer type it would become and its status (mapped, approximated or dropped, with notes), plus the import warnings. Changes nothing. Call before import_psd to see what would be lost.",
     inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
-    annotations: { title: "Inspect a PSD", ...READ4 },
+    annotations: { title: "Inspect a PSD", ...READ5 },
     handler: ({ data }) => {
       const res = importPsd(psdBytesFromBase64(data), { skipPixels: true });
       return {
@@ -11914,7 +13200,7 @@ function createImagePsdTools(controller) {
   const open = {
     name: "import_psd",
     title: "Open a PSD as the document",
-    description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility and locks map directly; type, smart-object, fill and shape layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
+    description: "Opens a PSD / PSB as the document, replacing the current layers, crop and rotation (one undo step; undo brings the previous document back). Pixel, group and adjustment layers, masks, blend modes, opacity, fill, clipping, visibility, locks, layer effects (with the patterns and global light of the file) map directly; type, smart-object, fill and shape layers come in as their pixels; unsupported adjustments are left out. Returns the new layer tree with ids, the size and the warnings (each names the affected layers).",
     inputSchema: { type: "object", properties: { data: DATA }, required: ["data"], additionalProperties: false },
     annotations: { title: "Open a PSD as the document", ...DESTRUCTIVE4 },
     handler: ({ data }) => {
@@ -11933,9 +13219,9 @@ function createImagePsdTools(controller) {
   const save = {
     name: "export_psd",
     title: "Export the document as a PSD",
-    description: "Writes the document as an 8-bit RGB PSD (a PSB above 30000 px) with real layers, groups, adjustment layers and masks, in the source frame (crop and rotation are not applied). Layer filters and depth masks are baked, annotation layers are rasterized (in a browser; elsewhere left out), and the merged image is the editor's composite. Changes nothing. Returns the file as base64, its size in bytes, whether it is a PSB, and warnings for everything that was changed or left out.",
+    description: "Writes the document as an 8-bit RGB PSD (a PSB above 30000 px) with real layers, groups, adjustment layers, masks and layer effects (an effects block opened from a PSD is written back unchanged while its effects are; the patterns effects use are embedded), in the source frame (crop and rotation are not applied). Layer filters and depth masks are baked, annotation layers are rasterized (in a browser; elsewhere left out), and the merged image is the editor's composite. Changes nothing. Returns the file as base64, its size in bytes, whether it is a PSB, and warnings for everything that was changed or left out.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
-    annotations: { title: "Export the document as a PSD", ...READ4 },
+    annotations: { title: "Export the document as a PSD", ...READ5 },
     handler: async () => {
       const res = await controller.toPsd();
       return {
@@ -12494,9 +13780,9 @@ function applyRegionBlur(imageData, regions, radius = 10) {
 // src/image-editor/layers/panel.ts
 function layerPanelRows(layers, activeId) {
   const rows = [];
-  const walk = (list, depth, parentId) => {
-    for (let i = list.length - 1; i >= 0; i--) {
-      const layer = list[i];
+  const walk = (list2, depth, parentId) => {
+    for (let i = list2.length - 1; i >= 0; i--) {
+      const layer = list2[i];
       rows.push({
         layer,
         depth,
@@ -12633,145 +13919,6 @@ async function runLayerMenuAction(controller, action) {
   }
 }
 
-// src/image-editor/layers/paint-ui.ts
-var plain2 = { kind: "plain" };
-var BRUSH_OPTION_CONTROLS = [
-  { id: "size", label: "Size", section: "layer", min: 1, max: 500, step: 1, default: 20, decimals: 0, track: plain2, unit: "px" },
-  { id: "hardness", label: "Hardness", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "opacity", label: "Opacity", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "flow", label: "Flow", section: "layer", min: 0, max: 1, step: 0.01, default: 1, decimals: 0, track: plain2, displayScale: 100, unit: "%" },
-  { id: "smoothing", label: "Smoothing", section: "layer", min: 0, max: 0.95, step: 0.01, default: 0, decimals: 0, track: plain2, displayScale: 100, unit: "%" }
-];
-var PAINT_TOOLS = [
-  { id: "move", label: "Move", shortcut: "V" },
-  { id: "brush", label: "Brush", shortcut: "B" },
-  { id: "eraser", label: "Eraser", shortcut: "E" }
-];
-var isPaintTool = (tool) => tool === "move" || tool === "brush" || tool === "eraser";
-function sizeStep(size) {
-  return size < 10 ? 1 : size < 50 ? 5 : size < 100 ? 10 : size < 200 ? 25 : size < 500 ? 50 : 100;
-}
-var isTyping = (t) => {
-  const el = t;
-  return Boolean(el && (el.isContentEditable || el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT"));
-};
-function handlePaintShortcut(controller, e) {
-  if (e.ctrlKey || e.metaKey || e.altKey || isTyping(e.target)) return false;
-  const brush = controller.getState().paint.brush;
-  const set = (b) => controller.setPaintOptions({ brush: b });
-  const key = e.key;
-  switch (key.toLowerCase()) {
-    case "b":
-      controller.setTool("brush");
-      return true;
-    case "e":
-      controller.setTool("eraser");
-      return true;
-    case "v":
-      controller.setTool("move");
-      return true;
-    case "d":
-      controller.resetPaintColors();
-      return true;
-    case "x":
-      controller.swapPaintColors();
-      return true;
-  }
-  if (key === "[" || key === "{") {
-    if (e.shiftKey || key === "{") set({ hardness: Math.max(0, Math.round((brush.hardness - 0.25) * 4) / 4) });
-    else set({ size: Math.max(1, brush.size - sizeStep(brush.size - 1)) });
-    return true;
-  }
-  if (key === "]" || key === "}") {
-    if (e.shiftKey || key === "}") set({ hardness: Math.min(1, Math.round((brush.hardness + 0.25) * 4) / 4) });
-    else set({ size: Math.min(MAX_BRUSH_SIZE, brush.size + sizeStep(brush.size)) });
-    return true;
-  }
-  if (/^[0-9]$/.test(key) && isPaintTool(controller.getState().activeTool)) {
-    set({ opacity: key === "0" ? 1 : Number(key) / 10 });
-    return true;
-  }
-  return false;
-}
-function pointerPressure(e) {
-  if (e.pointerType === "pen" && typeof e.pressure === "number" && e.pressure > 0) return Math.min(1, e.pressure);
-  return 1;
-}
-var PaintGesture = class {
-  constructor(controller) {
-    this.controller = controller;
-  }
-  controller;
-  stroke = null;
-  move = null;
-  /** The last refusal (e.g. "layer is locked"), for the editor to show. */
-  error = null;
-  get active() {
-    return Boolean(this.stroke || this.move);
-  }
-  down(sample) {
-    this.error = null;
-    const tool = this.controller.getState().activeTool;
-    try {
-      if (tool === "move") {
-        const layer = this.controller.getActiveLayer();
-        if (!layer) throw new Error("Select a layer to move in the Layers panel.");
-        if (layer.type !== "pixel") throw new Error(`Only pixel layers move; "${layer.name}" is a ${layer.type} layer.`);
-        if (layer.locks?.all || layer.locks?.position) throw new Error(`Layer "${layer.name}" has its position locked.`);
-        this.move = { id: layer.id, start: { x: sample.x, y: sample.y }, origin: { ...layer.offset }, moved: false };
-        return null;
-      }
-      if (tool === "brush" || tool === "eraser") {
-        this.stroke = this.controller.beginStroke({ tool });
-        this.stroke.push([sample]);
-        return null;
-      }
-    } catch (err) {
-      this.error = err instanceof Error ? err.message : String(err);
-      this.stroke = null;
-      this.move = null;
-    }
-    return this.error;
-  }
-  /** Feeds pointer samples (all coalesced events of one move, in order). */
-  moveTo(samples) {
-    if (!samples.length) return;
-    if (this.stroke) {
-      this.stroke.push(samples);
-      return;
-    }
-    const m = this.move;
-    if (m) {
-      const last = samples[samples.length - 1];
-      const x = m.origin.x + Math.round(last.x - m.start.x);
-      const y = m.origin.y + Math.round(last.y - m.start.y);
-      try {
-        this.controller.offsetLayer(m.id, { x, y }, !m.moved);
-        m.moved = true;
-      } catch (err) {
-        this.error = err instanceof Error ? err.message : String(err);
-        this.move = null;
-      }
-    }
-  }
-  up() {
-    if (this.stroke) {
-      try {
-        this.stroke.end();
-      } catch (err) {
-        this.error = err instanceof Error ? err.message : String(err);
-      }
-    }
-    this.stroke = null;
-    this.move = null;
-  }
-  cancel() {
-    this.stroke?.cancel();
-    this.stroke = null;
-    this.move = null;
-  }
-};
-
 // src/image-editor/psd/ui.ts
 var PSD_FILE_ACCEPT = ".psd,.psb,image/vnd.adobe.photoshop,application/x-photoshop";
 function blobBytes(file) {
@@ -12822,6 +13969,8 @@ export {
   DEFAULT_ADJUSTMENTS,
   DEFAULT_BRUSH,
   DEFAULT_DEPTH_MASK,
+  DEFAULT_GLOBAL_LIGHT,
+  DEFAULT_MIXER,
   DEFAULT_REFINE_EDGE_PARAMS,
   DEFAULT_SELECTION_TOOL_OPTIONS,
   DEFAULT_TRANSFORM,
@@ -12829,6 +13978,7 @@ export {
   DIRECT_GAUSSIAN_MAX_SIGMA,
   DabWalker,
   EMPTY_DISTANCE,
+  EMPTY_MIXER_LOAD,
   GUIDED_FILTER_EPS,
   HISTOGRAM_BINS,
   HUE_RANGE_LABELS,
@@ -12840,15 +13990,25 @@ export {
   ImageEditorRenderer,
   LATEST_PROCESS_VERSION,
   LAYERED_SCHEMA_VERSION,
+  LAYER_EFFECT_KINDS,
   LEGACY_PROCESS_VERSION,
   LUMA_709,
   LayerCompositor,
+  LayerEffectError,
   LayerOperationError,
   MAX_BRUSH_SIZE,
+  MAX_EFFECT_REACH,
   MAX_KELVIN,
   MIN_KELVIN,
   MIRED_PER_TEMPERATURE_UNIT,
+  MIXER_DRAIN,
+  MIXER_MIXING_OPTIONS,
+  MIXER_OPTION_CONTROLS,
+  MIXER_PICKUP_RATE,
+  MIXING_MODELS,
+  MixerStroke,
   PAINT_TOOLS,
+  PATTERN_BLOCK_KEYS,
   PIGMENT_BANDS,
   PIGMENT_LAMBDA_MIN,
   PIGMENT_LAMBDA_STEP,
@@ -12857,6 +14017,8 @@ export {
   PSD_FILE_ACCEPT,
   PaintGesture,
   PaintStrokeSession,
+  PatternPlacement,
+  PatternTile,
   PsdError,
   REFINE_EDGE_CONTROLS,
   SELECTION_MODES,
@@ -12916,6 +14078,8 @@ export {
   bradfordAdaptation,
   buildLayerMaskPlanes,
   buildToneLut,
+  builtinPattern,
+  builtinPatternIds,
   bytesToBase64,
   calculateCropDrag,
   canvasCompositeOperation,
@@ -12923,6 +14087,7 @@ export {
   changedTiles,
   clampControlValue,
   clampCropToImage,
+  cleanMixer,
   collectTiles,
   colorBalanceChannel,
   colorRange,
@@ -12963,6 +14128,8 @@ export {
   decodePngDataUrl,
   decodeSelectionRle,
   defaultAdjustmentParams,
+  defaultEffectGradient,
+  defaultLayerEffect,
   deflate,
   deflateRaw,
   depthMaskAlpha,
@@ -12973,6 +14140,7 @@ export {
   deserializeEffects,
   deserializeLayer,
   deserializeLayers,
+  deserializePatterns,
   deserializeSelection,
   developFilter,
   developFromAdjustments,
@@ -12983,6 +14151,11 @@ export {
   dropZone,
   duplicateLayer,
   edgeWidth,
+  effectColorHex,
+  effectReach,
+  effectsFingerprint,
+  effectsMargin,
+  effectsScale,
   ellipsePoints,
   ellipseSelection,
   emptyHistogram,
@@ -13016,8 +14189,10 @@ export {
   guidePlanes,
   guidedFilterColor,
   handlePaintShortcut,
+  hasActiveEffects,
   hasResampledLegacyMask,
   hashMaskContent,
+  hashNoise,
   hexToRgb,
   histogramPath,
   hitTestAnnotation,
@@ -13043,6 +14218,7 @@ export {
   isAdjustmentKind,
   isBlendMode,
   isDefaultDepthMask,
+  isLayerEffectKind,
   isLayerLocked,
   isLegacyShape,
   isPaintTool,
@@ -13055,6 +14231,8 @@ export {
   isSpatialFilter,
   kelvinToTemperature,
   layerBadge,
+  layerEffectFields,
+  layerEffectLabel,
   layerEffectsOf,
   layerLabel,
   layerMaskCoverage,
@@ -13075,19 +14253,25 @@ export {
   linearSrgbToXy,
   linearToSrgb,
   loadImageEditorDocument,
+  loadMixer,
   magicWand,
   mapCropHandle,
   mapLayer,
   maskSummary,
+  mergeLayerEffect,
   migrateSerializedImageEditorState,
   migrateToLayeredState,
+  mixPigment8,
+  mixPigmentRgb,
   mixPigments,
+  mixerLoadResult,
   modifySelection,
   moveCurvePoint,
   moveLayer,
   mulMatrix3,
   needsLegacyBase,
   neutralHueRange,
+  newEffectId,
   newLayerId,
   normalizeAdjustmentLayer,
   normalizeAdjustmentLayers,
@@ -13095,7 +14279,9 @@ export {
   normalizeBlendMode,
   normalizeBrush,
   normalizeFilter,
+  normalizeLayerEffects,
   normalizeLayerMask,
+  normalizeMixer,
   normalizeProcessVersion,
   normalizeRect,
   normalizeRefineEdgeParams,
@@ -13107,6 +14293,10 @@ export {
   parseBlend,
   parseColor,
   parseDataUrl,
+  parseEffectColor,
+  parseLfx2,
+  parseLrfx,
+  parsePatternBlock,
   parseSelectionMode,
   parseVersionedDescriptor,
   photoFilterMatrix,
@@ -13124,6 +14314,7 @@ export {
   projectQuarterTurn,
   psdBytesFromBase64,
   psdFileName,
+  psdPatternToEffectPattern,
   psdToLayers,
   quickMaskPixels,
   rangeLightness,
@@ -13143,6 +14334,7 @@ export {
   removeLayer,
   removeLayerEffect,
   removeLayerFilter,
+  renderLayerEffects,
   renderLayeredBase,
   requireLayer,
   requireUnlocked,
@@ -13153,9 +14345,11 @@ export {
   rgbToGray,
   rgbToHsl,
   rgbToReflectance,
+  rgbUnitToHex,
   runLayerMenuAction,
   sampleLut,
   sampleToneLut,
+  scaleLayerEffect,
   selectionArea,
   selectionFromCoverage,
   selectionFromPixels,
@@ -13168,6 +14362,7 @@ export {
   serializeLayer,
   serializeLayers,
   serializeLayersExternal,
+  serializePatterns,
   serializeSelection,
   setControlPath,
   setLayerEffects,
@@ -13209,6 +14404,9 @@ export {
   updateLayerFilter,
   updateLayerMaskProps,
   uvToXy,
+  validateEffectGradient,
+  validateLayerEffect,
+  validateLayerEffects,
   versionedDescriptorBytes,
   vibranceLinear,
   vibrancePixel,
@@ -13218,6 +14416,8 @@ export {
   whiteBalanceMatrix,
   withNewIds,
   writeAdjustmentBlock,
+  writeLfx2,
+  writePatternBlock,
   writePsd,
   writeRegion,
   xyToTempTint,