@pixerate/editor 0.95.0 → 0.97.0

package/THIRD_PARTY_NOTICES.md

@@ -191,6 +191,7 @@ GridCraft. Apache POI is © The Apache Software Foundation, licensed under the A
 - `crates/io/src/psd_export.rs` and `crates/psd/src/builder.rs` (layer records with RLE channels, group divider and folder records, adjustment blocks, user masks with parameters, `luni` / `lyid` / `iOpa` / `lspf`, the resolution and version-info resources, PSB above 30 000 px) → `packages/core/src/image-editor/psd/export.ts`; 8-bit RGB only, with the merged image from our compositor
 - `crates/doc/src/effects.rs` (the layer-style model: shadows, glows, strokes, satin, bevel & emboss with its Contour and Texture elements, colour / gradient / pattern overlays, the shared enabled / blend / opacity, Photoshop's defaults, the global light) → `packages/core/src/raster/effects/model.ts`; colours are `#rrggbb`, effects carry ids, and validation, merging and Scale Effects are our own
 - `crates/compose/src/effects.rs` (render order and the per-kind maps: `margin`, `maps_are_local`, the Felzenszwalb–Huttenlocher `dt1` / `edt_nearest`, the 5 × 5 `chamfer_from`, `dist_outside` / `dist_inside` with coverage-placed edges, `local_coverage`, `dilate`, `spread_split`, the fractional `box_geom` / `box_line` / `tent_line` blur, `contour_lut` with corners, `ranged_lut`, `satin_lut`, `hash_noise` / `noise`, `shadow_map`, `glow_map`, `satin_map`, `bevel_geom`, `bevel_chisel_h`, `bevel_height`, `bevel_maps`, `gradient_units`, `gradient_t`, `paint_glow`, `stroke_widths`, the stroke frame and the outside-stroke shares, `knock_out_exterior`, `premerges_layer` and `composite_with_effects`), `crates/compose/src/fill_layout.rs` (`gradient_layout`) and `crates/compose/src/pattern.rs` (`Tile::sample`, `Placement`) → `packages/core/src/raster/effects/render.ts` and `patterns.ts`; single-threaded, without vector-shape outlines, text gamma, Transparency Shapes Layer or Blend Interior Effects as Group, with chiselled bevel edges measured to the coverage-gradient edge line instead of photocraft's sharp-edge refinement, and the maps built once per layer region and cropped per tile by our compositor; the built-in patterns are our own; test cases re-expressed → `packages/core/tests/raster-effects.test.ts`
+- `crates/io/src/effects_map.rs` (`parse_lfx2` / `write_lfx2`: the per-kind descriptor keys, the single and `…Multi` instance keys, `present` / `enab`, blend ids as four-character codes or long string ids, contours with corner points, `parse_lrfx` for legacy effects), `crates/io/src/blocks.rs` (`color_from_desc` / `color_to_desc`, `gradient_style`, the `Grdn` colour and transparency stops, `pattern_ref`, `pattern_placement`), `crates/io/src/psd_import.rs` / `psd_export.rs` (`lmfx` over `lfx2` / `lfxs`, the block kept and written back while the effects are unchanged, odd-length blocks padded) and `crates/psd/src/patterns.rs` (`Patt` / `Pat2` / `Pat3` blocks: patterns, virtual memory array lists, written channels, padded channel rectangles) → `packages/core/src/image-editor/psd/effects.ts` and `patterns.ts`; gradient midpoints become extra stops and smoothness is drawn linearly (photocraft bakes Photoshop's interpolation), and patterns are written as 8-bit RGB; test cases re-expressed → `packages/core/tests/image-psd-effects.test.ts`
 
 ## soundcraft
 

package/dist/{chunk-T6H3JDGA.cjs → chunk-4AB5BHYK.cjs}

@@ -10,6 +10,7 @@
 
 
 
+
 var _chunkCRMAXIUVcjs = require('./chunk-CRMAXIUV.cjs');
 
 // src/raster/blur.ts
@@ -372,6 +373,7 @@ function oneOf(r, key, path, values) {
 }
 function blend(r, key, path) {
   if (!_chunkCRMAXIUVcjs.isBlendMode.call(void 0, r[key])) fail(`${path}.${key}`, `must be a blend mode such as normal, multiply or screen (got ${JSON.stringify(r[key])}).`);
+  if (r[key] === "pigment") fail(`${path}.${key}`, "pigment is a layer blend mode only; effects cannot use it.");
 }
 function contour(v, path) {
   if (v === void 0) return;
@@ -1078,11 +1080,18 @@ function boxLine(src, x0, dst, bw) {
   }
 }
 var BLUR_EPS = 1e-7;
+var BLUR_FIX = 2 ** 32;
 function tentLine(src, dst, bw, mid) {
   const [r] = boxGeom(bw);
-  boxLine(src, -r, mid.subarray(0, src.length + 2 * r), bw);
-  boxLine(mid.subarray(0, src.length + 2 * r), r, dst, bw);
-  for (let i = 0; i < dst.length; i++) if (Math.abs(dst[i]) < BLUR_EPS) dst[i] = 0;
+  const m = mid.subarray(0, src.length + 2 * r);
+  for (let i = 0; i < src.length; i++) src[i] = Math.round(src[i] * BLUR_FIX);
+  boxLine(src, -r, m, bw);
+  for (let i = 0; i < m.length; i++) m[i] = Math.round(m[i]);
+  boxLine(m, r, dst, bw);
+  for (let i = 0; i < dst.length; i++) {
+    const v = dst[i] / BLUR_FIX;
+    dst[i] = Math.abs(v) < BLUR_EPS ? 0 : v;
+  }
 }
 function tent(m, w) {
   if (!Number.isFinite(w) || m.v.length === 0) return;
@@ -1384,25 +1393,41 @@ function effectsAreLocal(items) {
     }
   });
 }
+function shapeBounds(shape, rect) {
+  const { width: w, height: h } = rect;
+  const rowHit = (y) => {
+    for (let x = 0, i = y * w; x < w; x++, i++) if (shape[i] > INSIDE_EPS) return true;
+    return false;
+  };
+  let y0 = 0;
+  while (y0 < h && !rowHit(y0)) y0++;
+  if (y0 === h) return null;
+  let y1 = h - 1;
+  while (!rowHit(y1)) y1--;
+  let x0 = w;
+  let x1 = -1;
+  for (let y = y0; y <= y1; y++) {
+    const o = y * w;
+    for (let x = 0; x < x0; x++) {
+      if (shape[o + x] > INSIDE_EPS) {
+        x0 = x;
+        break;
+      }
+    }
+    for (let x = w - 1; x > x1; x--) {
+      if (shape[o + x] > INSIDE_EPS) {
+        x1 = x;
+        break;
+      }
+    }
+  }
+  return { x: rect.x + x0, y: rect.y + y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+}
 function buildEffectMaps(items, shape, rect, ctx) {
   const w = rect.width;
   const h = rect.height;
   const s = { w, h, v: shape };
-  let x0 = Infinity;
-  let y0 = Infinity;
-  let x1 = -Infinity;
-  let y1 = -Infinity;
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      if (shape[y * w + x] > INSIDE_EPS) {
-        if (x < x0) x0 = x;
-        if (x > x1) x1 = x;
-        if (y < y0) y0 = y;
-        if (y > y1) y1 = y;
-      }
-    }
-  }
-  const bounds = x0 === Infinity ? null : { x: rect.x + x0, y: rect.y + y0, width: x1 - x0 + 1, height: y1 - y0 + 1 };
+  const bounds = shapeBounds(shape, rect);
   const anchor = bounds ? { x: bounds.x, y: bounds.y } : { x: rect.x, y: rect.y };
   const per = [];
   const bevelPaint = [];
@@ -1450,8 +1475,84 @@ function buildEffectMaps(items, shape, rect, ctx) {
   for (const d of [din, dout, doutExact]) if (d) bytes += d.byteLength;
   return { rect, items, bounds, shape, per, bevelPaint, din, dout, doutExact, frames, bytes };
 }
+var rectArea = (r) => r.width * r.height;
+function clipRect(a, b) {
+  const x0 = Math.max(a.x, b.x);
+  const y0 = Math.max(a.y, b.y);
+  const x1 = Math.min(a.x + a.width, b.x + b.width);
+  const y1 = Math.min(a.y + a.height, b.y + b.height);
+  return x1 > x0 && y1 > y0 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0 } : null;
+}
+var growRect = (r, m) => ({ x: r.x - m, y: r.y - m, width: r.width + 2 * m, height: r.height + 2 * m });
+function unionRect(a, b) {
+  const x0 = Math.min(a.x, b.x);
+  const y0 = Math.min(a.y, b.y);
+  return { x: x0, y: y0, width: Math.max(a.x + a.width, b.x + b.width) - x0, height: Math.max(a.y + a.height, b.y + b.height) - y0 };
+}
+function rectMinus(r, cut) {
+  const i = clipRect(r, cut);
+  if (!i) return [r];
+  const parts = [
+    { x: r.x, y: r.y, width: r.width, height: i.y - r.y },
+    { x: r.x, y: i.y + i.height, width: r.width, height: r.y + r.height - (i.y + i.height) },
+    { x: r.x, y: i.y, width: i.x - r.x, height: i.height },
+    { x: i.x + i.width, y: i.y, width: r.x + r.width - (i.x + i.width), height: i.height }
+  ];
+  return parts.filter((p) => p.width > 0 && p.height > 0);
+}
+function pasteMap(dst, to, src, from, a) {
+  for (let y = a.y; y < a.y + a.height; y++) {
+    const s = (y - from.y) * from.width + (a.x - from.x);
+    dst.set(src.subarray(s, s + a.width), (y - to.y) * to.width + (a.x - to.x));
+  }
+}
+function patchEffectMaps(prev, items, rect, changed, margin, shapeOver, ctx) {
+  if (!effectsAreLocal(items) || rectArea(rect) <= 0) return null;
+  let areas = [];
+  for (const c of changed) {
+    const a = clipRect(growRect(c, margin), rect);
+    if (a) areas.push(a);
+  }
+  areas.push(...rectMinus(rect, prev.rect));
+  for (let merged = true; merged; ) {
+    merged = false;
+    for (let i = 0; i < areas.length && !merged; i++) {
+      for (let j = i + 1; j < areas.length; j++) {
+        if (clipRect(growRect(areas[i], 2 * margin), areas[j])) {
+          areas[i] = unionRect(areas[i], areas[j]);
+          areas.splice(j, 1);
+          merged = true;
+          break;
+        }
+      }
+    }
+  }
+  const windows = areas.map((a) => clipRect(growRect(a, margin), rect));
+  if (windows.reduce((n, w) => n + rectArea(w), 0) > rectArea(rect) / 2) return null;
+  const same = rect.x === prev.rect.x && rect.y === prev.rect.y && rect.width === prev.rect.width && rect.height === prev.rect.height;
+  const take = (v) => same ? v : crop(v, prev.rect, rect, 0);
+  const shape = take(prev.shape);
+  const per = prev.per.map((maps) => maps.map(take));
+  const din = prev.din && take(prev.din);
+  const dout = prev.dout && take(prev.dout);
+  const doutExact = prev.doutExact && take(prev.doutExact);
+  areas.forEach((a, k) => {
+    const w = windows[k];
+    const part = buildEffectMaps(items, shapeOver(w), w, ctx);
+    pasteMap(shape, rect, part.shape, w, a);
+    per.forEach((maps, i) => maps.forEach((m, j) => pasteMap(m, rect, part.per[i][j], w, a)));
+    if (din) pasteMap(din, rect, part.din, w, a);
+    if (dout) pasteMap(dout, rect, part.dout, w, a);
+    if (doutExact) pasteMap(doutExact, rect, part.doutExact, w, a);
+  });
+  let bytes = shape.byteLength;
+  for (const maps of per) for (const m of maps) bytes += m.byteLength;
+  for (const d of [din, dout, doutExact]) if (d) bytes += d.byteLength;
+  return { rect, items, bounds: shapeBounds(shape, rect), shape, per, bevelPaint: prev.bevelPaint, din, dout, doutExact, frames: /* @__PURE__ */ new Map(), bytes };
+}
 var rgbScratchB = [0, 0, 0];
 var rgbScratchS = [0, 0, 0];
+var rgbScratchM = [0, 0, 0];
 function compositeAt(dst, i, mode, separable, sr, sg, sb, sa) {
   if (!(sa > 0)) return;
   const ab = dst[i + 3];
@@ -1463,6 +1564,20 @@ function compositeAt(dst, i, mode, separable, sr, sg, sb, sa) {
   const b0 = dst[i];
   const b1 = dst[i + 1];
   const b2 = dst[i + 2];
+  if (mode === "pigment") {
+    rgbScratchB[0] = b0;
+    rgbScratchB[1] = b1;
+    rgbScratchB[2] = b2;
+    rgbScratchS[0] = sr;
+    rgbScratchS[1] = sg;
+    rgbScratchS[2] = sb;
+    _chunkCRMAXIUVcjs.mixPigmentRgb.call(void 0, rgbScratchB, rgbScratchS, sa / ao, rgbScratchM);
+    dst[i] = rgbScratchM[0];
+    dst[i + 1] = rgbScratchM[1];
+    dst[i + 2] = rgbScratchM[2];
+    dst[i + 3] = ao;
+    return;
+  }
   let m0;
   let m1;
   let m2;
@@ -2042,7 +2157,7 @@ var ZERO_TILE = new Uint8ClampedArray(TILE_BYTES);
 var isGroup = (l) => l.type === "group";
 var isPixel = (l) => l.type === "pixel";
 var RasterCompositor = (_class = class {
-  constructor(profile = {}, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);_class.prototype.__init13.call(this);_class.prototype.__init14.call(this);_class.prototype.__init15.call(this);_class.prototype.__init16.call(this);_class.prototype.__init17.call(this);_class.prototype.__init18.call(this);_class.prototype.__init19.call(this);
+  constructor(profile = {}, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);_class.prototype.__init11.call(this);_class.prototype.__init12.call(this);_class.prototype.__init13.call(this);_class.prototype.__init14.call(this);_class.prototype.__init15.call(this);_class.prototype.__init16.call(this);_class.prototype.__init17.call(this);_class.prototype.__init18.call(this);_class.prototype.__init19.call(this);_class.prototype.__init20.call(this);_class.prototype.__init21.call(this);
     this.profile = profile;
     this.maxCacheBytes = _nullishCoalesce(options.maxCacheBytes, () => ( 256 * 1024 * 1024));
   }
@@ -2067,8 +2182,11 @@ var RasterCompositor = (_class = class {
   __init15() {this.patternTiles = /* @__PURE__ */ new WeakMap()}
   __init16() {this.reachCache = /* @__PURE__ */ new WeakMap()}
   __init17() {this.fxContext = null}
-  __init18() {this.lastStats = { tiles: 0, cached: 0, stepsRun: 0 }}
+  __init18() {this.lastStats = { tiles: 0, cached: 0, stepsRun: 0, effectsBuilt: 0, effectsPatched: 0 }}
   __init19() {this.hint = -1}
+  /** The `dirty` rectangles of the current call, as passed. */
+  __init20() {this.callDirty = null}
+  __init21() {this.callStats = this.lastStats}
   /** Drops every cached tile and plane. */
   clear() {
     this.tiles.clear();
@@ -2116,7 +2234,9 @@ var RasterCompositor = (_class = class {
     const steps = this.buildSteps(layers);
     this.hint = options.checkpointLayerId ? this.stepIndexOf(steps, options.checkpointLayerId) : -1;
     this.stamp++;
-    const stats = { tiles: 0, cached: 0, stepsRun: 0 };
+    this.callDirty = _nullishCoalesce(options.dirty, () => ( null));
+    const stats = { tiles: 0, cached: 0, stepsRun: 0, effectsBuilt: 0, effectsPatched: 0 };
+    this.callStats = stats;
     const grow = options.dirty ? this.effectsReach(layers) : 0;
     const dirty = grow > 0 ? options.dirty.map((d) => inflateRect(d, grow)) : options.dirty;
     for (const { tx, ty } of _chunkCRMAXIUVcjs.tilesInRect.call(void 0, rect)) {
@@ -2132,8 +2252,10 @@ var RasterCompositor = (_class = class {
   tile(layers, tx, ty, sources) {
     this.setSources(sources);
     this.stamp++;
-    const stats = { tiles: 1, cached: 0, stepsRun: 0 };
+    const stats = { tiles: 1, cached: 0, stepsRun: 0, effectsBuilt: 0, effectsPatched: 0 };
+    this.callStats = stats;
     this.hint = -1;
+    this.callDirty = null;
     const data = this.compositeTile(layers, this.buildSteps(layers), tx, ty, stats);
     this.lastStats = stats;
     this.evict();
@@ -2203,7 +2325,8 @@ var RasterCompositor = (_class = class {
     let first = 0;
     if (entry) {
       while (first < sigs.length && first < entry.sigs.length && sameSig(entry.sigs[first], sigs[first])) first++;
-      if (first === sigs.length && first === entry.sigs.length) {
+      if (first === sigs.length && first === entry.sigs.length || this.changedOnlyNearby(steps, sigs, entry, dirty)) {
+        entry.sigs = sigs;
         entry.stamp = this.stamp;
         stats.cached++;
         return entry.result;
@@ -2268,6 +2391,20 @@ var RasterCompositor = (_class = class {
     this.cacheBytes += this.entryBytes(next) - prevBytes;
     return result;
   }
+  /**
+   * Whether a tile with no part in this call's (grown) `dirty` rectangles changed only in what local
+   * effects read beyond it: every changed step is a pixel layer with local effects whose changes stay
+   * inside `dirty` (and so are farther than its margin), which leaves the tile's pixels as they were.
+   */
+  changedOnlyNearby(steps, sigs, entry, dirty) {
+    if (this.callDirty === null || dirty || entry.stamp !== this.stamp - 1 || sigs.length !== entry.sigs.length) return false;
+    return steps.every((step, i) => {
+      if (sameSig(entry.sigs[i], sigs[i])) return true;
+      if (step.kind !== "content" || entry.sigs[i].key !== sigs[i].key) return false;
+      const { layer, clipped } = step;
+      return this.hasEffects(layer) && effectsAreLocal(activeEffectItems(layer.effects)) && this.dirtyCoversShape(layer) && clipped.every((c) => this.dirtyCoversShape(c));
+    });
+  }
   entryBytes(e) {
     let n = e.result === ZERO_TILE ? 0 : TILE_BYTES;
     for (const cp of e.checkpoints.values()) n += cp.data.byteLength;
@@ -2398,14 +2535,20 @@ var RasterCompositor = (_class = class {
     if (!b) return { x: 0, y: 0, width: 0, height: 0 };
     return intersectRect({ x: b.x + dx - m, y: b.y + dy - m, width: b.width + 2 * m, height: b.height + 2 * m }, canvas);
   }
+  /** The signature of a layer's shape (its surface tiles and mask refs) per tile of `region`. */
+  shapeSigs(layer, region) {
+    const sigs = /* @__PURE__ */ new Map();
+    if (region.width <= 0 || region.height <= 0) return sigs;
+    const steps = isGroup(layer) ? this.buildSteps(_nullishCoalesce(layer.children, () => ( []))) : null;
+    for (const t of _chunkCRMAXIUVcjs.tilesInRect.call(void 0, region)) {
+      sigs.set(_chunkCRMAXIUVcjs.tileKey.call(void 0, t.tx, t.ty), steps ? this.plainGroupSig(layer, steps, t.tx, t.ty) : this.plainContentSig(layer, t.tx, t.ty));
+    }
+    return sigs;
+  }
   /** The surface tiles (and mask refs) a layer's shape reads over `region`. */
   shapeRefs(layer, region) {
     const refs = [];
-    if (region.width <= 0 || region.height <= 0) return refs;
-    for (const t of _chunkCRMAXIUVcjs.tilesInRect.call(void 0, region)) {
-      const sig = isGroup(layer) ? this.plainGroupSig(layer, this.buildSteps(_nullishCoalesce(layer.children, () => ( []))), t.tx, t.ty) : this.plainContentSig(layer, t.tx, t.ty);
-      for (const r of sig.refs) refs.push(r);
-    }
+    for (const sig of this.shapeSigs(layer, region).values()) for (const r of sig.refs) refs.push(r);
     return refs;
   }
   lightKey() {
@@ -2431,18 +2574,28 @@ var RasterCompositor = (_class = class {
     const memo = this.effectMemo.get(layer);
     if (memo && memo.stamp === this.stamp) return memo.maps;
     const region = this.effectRegion(layer);
-    const key = `${this.propsKey(layer)}${this.lightKey()}|${region.x},${region.y},${region.width},${region.height}`;
-    const refs = this.shapeRefs(layer, region);
+    const key = this.propsKey(layer) + this.lightKey();
+    const tiles = this.shapeSigs(layer, region);
     const hit = this.effectCache.get(layer.id);
-    let maps;
-    if (hit && hit.key === key && sameSig({ key, refs: hit.refs }, { key, refs })) {
-      this.effectCache.delete(layer.id);
-      this.effectCache.set(layer.id, hit);
-      maps = hit.maps;
+    this.effectCache.delete(layer.id);
+    let entry;
+    if (hit && hit.key === key && sameRect(hit.region, region) && [...tiles].every(([k, sig]) => sameSig(hit.tiles.get(k), sig))) {
+      entry = hit;
     } else {
-      maps = buildEffectMaps(activeEffectItems(layer.effects), this.layerShape(layer, region), region, this.effectContext());
-      this.effectCache.delete(layer.id);
-      this.effectCache.set(layer.id, { key, refs, maps });
+      const items = activeEffectItems(layer.effects);
+      const ctx = this.effectContext();
+      let maps = null;
+      if (hit && hit.key === key && items.every((e) => effectReach(e) <= MAX_EFFECT_REACH)) {
+        const changed = this.shapeChanges(layer, hit, tiles, region);
+        maps = patchEffectMaps(hit.maps, items, region, changed, effectsMargin(layer.effects), (r) => this.layerShape(layer, r), ctx);
+      }
+      if (maps) this.callStats.effectsPatched++;
+      else this.callStats.effectsBuilt++;
+      entry = { key, region, tiles, maps: _nullishCoalesce(maps, () => ( buildEffectMaps(items, this.layerShape(layer, region), region, ctx))), stamp: 0 };
+    }
+    entry.stamp = this.stamp;
+    this.effectCache.set(layer.id, entry);
+    if (entry !== hit) {
       let bytes = 0;
       for (const e of this.effectCache.values()) bytes += e.maps.bytes;
       while (this.effectCache.size > 1 && (this.effectCache.size > 32 || bytes > this.maxCacheBytes / 2)) {
@@ -2451,8 +2604,42 @@ var RasterCompositor = (_class = class {
         this.effectCache.delete(oldest);
       }
     }
-    this.effectMemo.set(layer, { stamp: this.stamp, maps });
-    return maps;
+    this.effectMemo.set(layer, { stamp: this.stamp, maps: entry.maps });
+    return entry.maps;
+  }
+  /**
+   * Where a layer's shape may differ from the one `prev` was built from: the tiles whose signature
+   * changed (a tile new to the region that reads nothing did not), narrowed to this call's `dirty`
+   * rectangles when `prev` is from the previous call and they cover every change of the shape.
+   */
+  shapeChanges(layer, prev, tiles, region) {
+    const out = [];
+    for (const { tx, ty } of _chunkCRMAXIUVcjs.tilesInRect.call(void 0, region)) {
+      const sig = tiles.get(_chunkCRMAXIUVcjs.tileKey.call(void 0, tx, ty));
+      const old = prev.tiles.get(_chunkCRMAXIUVcjs.tileKey.call(void 0, tx, ty));
+      if (old ? sameSig(old, sig) : sig.refs.every((r2) => r2 === null || r2 === 0)) continue;
+      const r = intersectRect({ x: tx * _chunkCRMAXIUVcjs.TILE, y: ty * _chunkCRMAXIUVcjs.TILE, width: _chunkCRMAXIUVcjs.TILE, height: _chunkCRMAXIUVcjs.TILE }, region);
+      if (r.width > 0 && r.height > 0) out.push(r);
+    }
+    const dirty = this.callDirty;
+    if (!dirty || prev.stamp !== this.stamp - 1 || !this.dirtyCoversShape(layer)) return out;
+    const narrowed = [];
+    for (const r of out) {
+      for (const d of dirty) {
+        const a = intersectRect(r, { x: Math.floor(d.x), y: Math.floor(d.y), width: Math.ceil(d.x + d.width) - Math.floor(d.x), height: Math.ceil(d.y + d.height) - Math.floor(d.y) });
+        if (a.width > 0 && a.height > 0) narrowed.push(a);
+      }
+    }
+    return narrowed;
+  }
+  /**
+   * Whether a change to a layer stays inside the `dirty` rectangles that name it: a pixel layer
+   * without filters or a feathered or parametric mask (those spread a change beyond it).
+   */
+  dirtyCoversShape(layer) {
+    if (!isPixel(layer) || _optionalChain([this, 'access', _26 => _26.profile, 'access', _27 => _27.pixelFilters, 'optionalCall', _28 => _28(layer)])) return false;
+    const mask = layer.mask;
+    return !mask || mask.enabled === false || !mask.source && !((_nullishCoalesce(mask.feather, () => ( 0))) > 0);
   }
   /** A layer's alpha over `r` after its mask (0..1, quantised to bytes as tiles see it). */
   layerShape(layer, r) {
@@ -2538,10 +2725,10 @@ var RasterCompositor = (_class = class {
    */
   layerPixels(layer) {
     const raw = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
-    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _26 => _26.offset, 'optionalAccess', _27 => _27.x]), () => ( 0));
-    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _28 => _28.offset, 'optionalAccess', _29 => _29.y]), () => ( 0));
-    const filters = _nullishCoalesce(_optionalChain([this, 'access', _30 => _30.profile, 'access', _31 => _31.pixelFilters, 'optionalCall', _32 => _32(layer)]), () => ( null));
-    if (!_optionalChain([filters, 'optionalAccess', _33 => _33.spatial])) return { surface: raw, dx: ox, dy: oy, perPixel: filters };
+    const ox = _nullishCoalesce(_optionalChain([layer, 'access', _29 => _29.offset, 'optionalAccess', _30 => _30.x]), () => ( 0));
+    const oy = _nullishCoalesce(_optionalChain([layer, 'access', _31 => _31.offset, 'optionalAccess', _32 => _32.y]), () => ( 0));
+    const filters = _nullishCoalesce(_optionalChain([this, 'access', _33 => _33.profile, 'access', _34 => _34.pixelFilters, 'optionalCall', _35 => _35(layer)]), () => ( null));
+    if (!_optionalChain([filters, 'optionalAccess', _36 => _36.spatial])) return { surface: raw, dx: ox, dy: oy, perPixel: filters };
     const fkey = `${ox},${oy}:${filters.key}`;
     let byKey = this.filteredCache.get(raw);
     if (!byKey) {
@@ -2558,7 +2745,7 @@ var RasterCompositor = (_class = class {
   }
   /** RGBA of a content layer over `r` (document space, inside one tile), or `null` when it has nothing there. */
   contentTile(layer, r) {
-    if (!isPixel(layer)) return _nullishCoalesce(_optionalChain([this, 'access', _34 => _34.profile, 'access', _35 => _35.contentTile, 'optionalCall', _36 => _36(layer, r, this.sources)]), () => ( null));
+    if (!isPixel(layer)) return _nullishCoalesce(_optionalChain([this, 'access', _37 => _37.profile, 'access', _38 => _38.contentTile, 'optionalCall', _39 => _39(layer, r, this.sources)]), () => ( null));
     const { surface, dx, dy, perPixel } = this.layerPixels(layer);
     const src = { x: r.x - dx, y: r.y - dy, width: r.width, height: r.height };
     const covered = _chunkCRMAXIUVcjs.tilesInRect.call(void 0, src).map((t) => surface.getTile(t.tx, t.ty));
@@ -2573,7 +2760,7 @@ var RasterCompositor = (_class = class {
     let byKey = this.contentCache.get(anchor);
     const refsKey = `${r.x},${r.y}:${fkey}`;
     if (aligned) {
-      const hit = _optionalChain([byKey, 'optionalAccess', _37 => _37.get, 'call', _38 => _38(refsKey)]);
+      const hit = _optionalChain([byKey, 'optionalAccess', _40 => _40.get, 'call', _41 => _41(refsKey)]);
       if (hit) return hit;
     }
     const data = _chunkCRMAXIUVcjs.readRegion.call(void 0, surface, src);
@@ -2611,7 +2798,7 @@ var RasterCompositor = (_class = class {
     const H = this.sources.height;
     let v = new Float32Array(W * H);
     if (mask.source) {
-      const generated = _nullishCoalesce(_optionalChain([this, 'access', _39 => _39.profile, 'access', _40 => _40.maskSourcePlane, 'optionalCall', _41 => _41(mask.source, W, H, this.sources)]), () => ( null));
+      const generated = _nullishCoalesce(_optionalChain([this, 'access', _42 => _42.profile, 'access', _43 => _43.maskSourcePlane, 'optionalCall', _44 => _44(mask.source, W, H, this.sources)]), () => ( null));
       if (!generated || generated.length !== W * H) v.fill(1);
       else v.set(generated);
     } else {
@@ -2630,8 +2817,8 @@ var RasterCompositor = (_class = class {
   maskTile(layer, r) {
     const mask = layer.mask;
     if (!mask || mask.enabled === false) return null;
-    const ox = isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _42 => _42.offset, 'optionalAccess', _43 => _43.x]), () => ( 0)) : 0;
-    const oy = isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _44 => _44.offset, 'optionalAccess', _45 => _45.y]), () => ( 0)) : 0;
+    const ox = isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _45 => _45.offset, 'optionalAccess', _46 => _46.x]), () => ( 0)) : 0;
+    const oy = isPixel(layer) ? _nullishCoalesce(_optionalChain([layer, 'access', _47 => _47.offset, 'optionalAccess', _48 => _48.y]), () => ( 0)) : 0;
     const n = r.width * r.height;
     const out = new Float32Array(n);
     const density = _nullishCoalesce(mask.density, () => ( 1));
@@ -2705,7 +2892,7 @@ var RasterCompositor = (_class = class {
     return empty;
   }
   contentBlend(layer) {
-    return _nullishCoalesce(_optionalChain([this, 'access', _46 => _46.profile, 'access', _47 => _47.contentBlend, 'optionalCall', _48 => _48(layer)]), () => ( layer.blend));
+    return _nullishCoalesce(_optionalChain([this, 'access', _49 => _49.profile, 'access', _50 => _50.contentBlend, 'optionalCall', _51 => _51(layer)]), () => ( layer.blend));
   }
   blendOnto(acc, src, empty, mode, alpha, coverage) {
     if (!(alpha > 0)) return empty;
@@ -2759,7 +2946,7 @@ var RasterCompositor = (_class = class {
       }
       visible.push(node);
     }
-    if (visible.length) _optionalChain([this, 'access', _49 => _49.profile, 'access', _50 => _50.applyFilterRun, 'optionalCall', _51 => _51(visible, acc, r, masks, this.sources)]);
+    if (visible.length) _optionalChain([this, 'access', _52 => _52.profile, 'access', _53 => _53.applyFilterRun, 'optionalCall', _54 => _54(visible, acc, r, masks, this.sources)]);
   }
 }, _class);
 function filterOverCanvas(surface, ox, oy, filters, width, height) {
@@ -2779,6 +2966,9 @@ function copyRect(data, r, a) {
 function pasteRect(data, r, part, a) {
   for (let y = 0; y < a.height; y++) data.set(part.subarray(y * a.width * 4, (y + 1) * a.width * 4), ((a.y - r.y + y) * r.width + (a.x - r.x)) * 4);
 }
+function sameRect(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
 function inflateRect(r, m) {
   return { x: r.x - m, y: r.y - m, width: r.width + 2 * m, height: r.height + 2 * m };
 }
@@ -2834,13 +3024,13 @@ function fixedTables() {
   return [fixedLit, fixedDist];
 }
 var BitReader = (_class2 = class {
-  constructor(data) {;_class2.prototype.__init20.call(this);_class2.prototype.__init21.call(this);_class2.prototype.__init22.call(this);
+  constructor(data) {;_class2.prototype.__init22.call(this);_class2.prototype.__init23.call(this);_class2.prototype.__init24.call(this);
     this.data = data;
   }
   
-  __init20() {this.pos = 0}
-  __init21() {this.bit = 0}
-  __init22() {this.bits = 0}
+  __init22() {this.pos = 0}
+  __init23() {this.bit = 0}
+  __init24() {this.bits = 0}
   need(n) {
     while (this.bits < n) {
       if (this.pos >= this.data.length) throw new ZlibError("Unexpected end of compressed data");
@@ -2873,13 +3063,13 @@ var BitReader = (_class2 = class {
   }
 }, _class2);
 var Output = (_class3 = class {
-  constructor(hint, max) {;_class3.prototype.__init23.call(this);
+  constructor(hint, max) {;_class3.prototype.__init25.call(this);
     this.max = max;
     this.buf = new Uint8Array(Math.max(1024, Math.min(hint, max)));
   }
   
   
-  __init23() {this.len = 0}
+  __init25() {this.len = 0}
   ensure(n) {
     if (this.len + n > this.max) throw new ZlibError(`Decompressed data exceeds ${this.max} bytes`);
     if (this.len + n <= this.buf.length) return;
@@ -2999,10 +3189,10 @@ function inflate(data, options = {}) {
 }
 var BitWriter = (_class4 = class {
   
-  __init24() {this.len = 0}
-  __init25() {this.bit = 0}
-  __init26() {this.bits = 0}
-  constructor(hint) {;_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this);
+  __init26() {this.len = 0}
+  __init27() {this.bit = 0}
+  __init28() {this.bits = 0}
+  constructor(hint) {;_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);_class4.prototype.__init28.call(this);
     this.buf = new Uint8Array(Math.max(1024, hint));
   }
   grow() {
@@ -3691,5 +3881,6 @@ function pngDataUrl(width, height, data, channels = 4) {
 
 
 
-exports.DIRECT_GAUSSIAN_MAX_SIGMA = DIRECT_GAUSSIAN_MAX_SIGMA; exports.gaussianBlur = gaussianBlur; exports.flattenLayers = flattenLayers; exports.findLayer = findLayer; exports.mapLayer = mapLayer; exports.insertLayer = insertLayer; exports.isLayerLocked = isLayerLocked; exports.DEFAULT_GLOBAL_LIGHT = DEFAULT_GLOBAL_LIGHT; exports.LAYER_EFFECT_KINDS = LAYER_EFFECT_KINDS; exports.layerEffectLabel = layerEffectLabel; exports.isLayerEffectKind = isLayerEffectKind; exports.defaultEffectGradient = defaultEffectGradient; exports.newEffectId = newEffectId; exports.defaultLayerEffect = defaultLayerEffect; exports.hasActiveEffects = hasActiveEffects; exports.MAX_EFFECT_REACH = MAX_EFFECT_REACH; exports.effectReach = effectReach; exports.effectsMargin = effectsMargin; exports.effectsScale = effectsScale; exports.scaleLayerEffect = scaleLayerEffect; exports.parseEffectColor = parseEffectColor; exports.effectColorHex = effectColorHex; exports.LayerEffectError = LayerEffectError; exports.validateEffectGradient = validateEffectGradient; exports.layerEffectFields = layerEffectFields; exports.validateLayerEffect = validateLayerEffect; exports.mergeLayerEffect = mergeLayerEffect; exports.validateLayerEffects = validateLayerEffects; exports.normalizeLayerEffects = normalizeLayerEffects; exports.effectsFingerprint = effectsFingerprint; exports.PatternTile = PatternTile; exports.PatternPlacement = PatternPlacement; exports.builtinPatternIds = builtinPatternIds; exports.builtinPattern = builtinPattern; exports.hashNoise = hashNoise; exports.CURVE_LUT_SIZE = CURVE_LUT_SIZE; exports.curveLut = curveLut; exports.STROKE_CHAMFER_MAX = STROKE_CHAMFER_MAX; exports.contourLut = contourLut; exports.activeEffectItems = activeEffectItems; exports.effectsAreLocal = effectsAreLocal; exports.buildEffectMaps = buildEffectMaps; exports.gradientT = gradientT; exports.compositeLayerEffects = compositeLayerEffects; exports.renderLayerEffects = renderLayerEffects; exports.blendTile = blendTile; exports.RasterCompositor = RasterCompositor; exports.changedTiles = changedTiles; exports.ZlibError = ZlibError; exports.inflateRaw = inflateRaw; exports.adler32 = adler32; exports.inflate = inflate; exports.deflateRaw = deflateRaw; exports.deflate = deflate; exports.encodePng = encodePng; exports.isPng = isPng; exports.decodePng = decodePng; exports.bytesToBase64 = bytesToBase64; exports.base64ToBytes = base64ToBytes; exports.parseDataUrl = parseDataUrl; exports.pngDataUrl = pngDataUrl;
-//# sourceMappingURL=chunk-T6H3JDGA.cjs.map
+
+exports.DIRECT_GAUSSIAN_MAX_SIGMA = DIRECT_GAUSSIAN_MAX_SIGMA; exports.gaussianBlur = gaussianBlur; exports.flattenLayers = flattenLayers; exports.findLayer = findLayer; exports.mapLayer = mapLayer; exports.insertLayer = insertLayer; exports.isLayerLocked = isLayerLocked; exports.DEFAULT_GLOBAL_LIGHT = DEFAULT_GLOBAL_LIGHT; exports.LAYER_EFFECT_KINDS = LAYER_EFFECT_KINDS; exports.layerEffectLabel = layerEffectLabel; exports.isLayerEffectKind = isLayerEffectKind; exports.defaultEffectGradient = defaultEffectGradient; exports.newEffectId = newEffectId; exports.defaultLayerEffect = defaultLayerEffect; exports.hasActiveEffects = hasActiveEffects; exports.MAX_EFFECT_REACH = MAX_EFFECT_REACH; exports.effectReach = effectReach; exports.effectsMargin = effectsMargin; exports.effectsScale = effectsScale; exports.scaleLayerEffect = scaleLayerEffect; exports.parseEffectColor = parseEffectColor; exports.effectColorHex = effectColorHex; exports.LayerEffectError = LayerEffectError; exports.validateEffectGradient = validateEffectGradient; exports.layerEffectFields = layerEffectFields; exports.validateLayerEffect = validateLayerEffect; exports.mergeLayerEffect = mergeLayerEffect; exports.validateLayerEffects = validateLayerEffects; exports.normalizeLayerEffects = normalizeLayerEffects; exports.effectsFingerprint = effectsFingerprint; exports.PatternTile = PatternTile; exports.PatternPlacement = PatternPlacement; exports.builtinPatternIds = builtinPatternIds; exports.builtinPattern = builtinPattern; exports.hashNoise = hashNoise; exports.CURVE_LUT_SIZE = CURVE_LUT_SIZE; exports.curveLut = curveLut; exports.STROKE_CHAMFER_MAX = STROKE_CHAMFER_MAX; exports.contourLut = contourLut; exports.activeEffectItems = activeEffectItems; exports.effectsAreLocal = effectsAreLocal; exports.buildEffectMaps = buildEffectMaps; exports.patchEffectMaps = patchEffectMaps; exports.gradientT = gradientT; exports.compositeLayerEffects = compositeLayerEffects; exports.renderLayerEffects = renderLayerEffects; exports.blendTile = blendTile; exports.RasterCompositor = RasterCompositor; exports.changedTiles = changedTiles; exports.ZlibError = ZlibError; exports.inflateRaw = inflateRaw; exports.adler32 = adler32; exports.inflate = inflate; exports.deflateRaw = deflateRaw; exports.deflate = deflate; exports.encodePng = encodePng; exports.isPng = isPng; exports.decodePng = decodePng; exports.bytesToBase64 = bytesToBase64; exports.base64ToBytes = base64ToBytes; exports.parseDataUrl = parseDataUrl; exports.pngDataUrl = pngDataUrl;
+//# sourceMappingURL=chunk-4AB5BHYK.cjs.map