@pixerate/editor 0.120.0 → 0.122.0

package/dist/{chunk-UMVW2Q66.js → chunk-CLTTLLWA.js}

@@ -7,7 +7,7 @@ import {
   invertHomography,
   isIdentityHomography,
   multiplyHomographies
-} from "./chunk-N3467VD6.js";
+} from "./chunk-GX332W2C.js";
 import {
   TILE,
   TiledSurface,
@@ -464,877 +464,448 @@ function stableStringify(v) {
   return JSON.stringify(v);
 }
 
-// src/raster/deep-compositor.ts
-var isGroup = (l) => l.type === "group";
-var DeepCompositor = class {
-  constructor(base, profile, deep, depth) {
-    this.base = base;
-    this.profile = profile;
-    this.deep = deep;
-    this.depth = depth;
-    this.linear = depth === 32;
-  }
-  base;
-  profile;
-  deep;
-  depth;
-  sources;
-  linear;
-  /** The composite of `layers` over `rect` as float RGBA in the working space (`rect.width × rect.height × 4`). */
-  composite(layers, rect, sources) {
-    this.sources = sources;
-    const acc = new Float32Array(Math.max(0, rect.width * rect.height * 4));
-    if (rect.width > 0 && rect.height > 0) this.runSteps(this.buildSteps(layers), acc, true, rect);
-    return acc;
-  }
-  // --- Steps (as RasterCompositor.buildSteps) ------------------------------------
-  isPixel(l) {
-    return l.type === "pixel" || (this.profile.isPixelLike?.(l) ?? false);
+// src/raster/curve.ts
+var CURVE_LUT_SIZE = 4096;
+var clamp01 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
+function curveLut(points, size = CURVE_LUT_SIZE) {
+  const pts = points.filter((p) => Number.isFinite(p.input) && Number.isFinite(p.output)).map((p) => [p.input, p.output]).sort((a, b) => a[0] - b[0]);
+  const dedup = [];
+  for (const p of pts) {
+    if (dedup.length && Math.abs(dedup[dedup.length - 1][0] - p[0]) < 1e-6) continue;
+    dedup.push(p);
   }
-  isFilter(l) {
-    return this.profile.isFilterLayer?.(l) ?? false;
+  const out = new Float32Array(size);
+  const n = dedup.length;
+  if (n < 2) {
+    for (let k = 0; k < size; k++) out[k] = k / (size - 1);
+    return out;
   }
-  buildSteps(layers) {
-    const steps = [];
-    for (const layer of layers) {
-      const last = steps[steps.length - 1];
-      if (layer.clipped && last && (last.kind === "content" || last.kind === "group")) {
-        last.clipped.push(layer);
-        continue;
-      }
-      if (this.isFilter(layer)) {
-        if (last && last.kind === "adjust") last.layers.push(layer);
-        else steps.push({ kind: "adjust", layers: [layer] });
-      } else if (isGroup(layer)) steps.push({ kind: "group", layer, clipped: [], steps: this.buildSteps(layer.children ?? []) });
-      else steps.push({ kind: "content", layer, clipped: [] });
+  const x = dedup.map((p) => p[0]);
+  const y = dedup.map((p) => p[1]);
+  const m2 = new Float64Array(n);
+  if (n > 2) {
+    const c = new Float64Array(n);
+    const d = new Float64Array(n);
+    for (let i = 1; i < n - 1; i++) {
+      const h0 = x[i] - x[i - 1];
+      const h1 = x[i + 1] - x[i];
+      const a = h0 / 6;
+      const b = (h0 + h1) / 3;
+      const cc = h1 / 6;
+      const r = (y[i + 1] - y[i]) / h1 - (y[i] - y[i - 1]) / h0;
+      const denom = b - a * c[i - 1];
+      c[i] = cc / denom;
+      d[i] = (r - a * d[i - 1]) / denom;
     }
-    return steps;
-  }
-  runSteps(steps, acc, empty, r) {
-    for (const s of steps) empty = this.runStep(s, acc, empty, r);
-    return empty;
+    for (let i = n - 2; i >= 1; i--) m2[i] = d[i] - c[i] * m2[i + 1];
   }
-  runStep(step, acc, empty, r) {
-    if (step.kind === "adjust") {
-      if (empty) return true;
-      this.applyFilterRun(step.layers, acc, r);
-      return false;
-    }
-    const layer = step.layer;
-    if (!layer.visible) return empty;
-    const clipped = step.clipped.filter((l) => l.visible);
-    const coverage = this.renderedAlone(layer) ? null : this.base.maskCoverage(layer, r, this.sources);
-    if (coverage && coverage.every((v) => v <= 0)) return empty;
-    if (step.kind === "group" && !this.renderedAlone(layer)) {
-      if (layer.blend === "pass-through" && !clipped.length) {
-        if (layer.opacity >= 1 && !coverage) return this.runSteps(step.steps, acc, empty, r);
-        const before = acc.slice();
-        const stillEmpty = this.runSteps(step.steps, acc, empty, r);
-        lerp(acc, before, layer.opacity, coverage);
-        return empty && stillEmpty;
-      }
-      const buf2 = new Float32Array(acc.length);
-      if (this.runSteps(step.steps, buf2, true, r)) return empty;
-      this.applyClipped(clipped, buf2, r);
-      const mode2 = layer.blend === "pass-through" ? "normal" : layer.blend;
-      this.blend(acc, buf2, mode2, layer.opacity, coverage);
-      return false;
+  let seg = 0;
+  for (let k = 0; k < size; k++) {
+    const xv = k / (size - 1);
+    if (xv <= x[0]) {
+      out[k] = clamp01(y[0]);
+      continue;
     }
-    const content = this.content(layer, r);
-    if (!content) return empty;
-    const alone = this.renderedAlone(layer);
-    const fill2 = !alone && this.isPixel(layer) ? layer.fillOpacity ?? 1 : 1;
-    const mode = this.blendOf(layer);
-    if (!clipped.length) {
-      this.blend(acc, content, mode, layer.opacity * fill2, coverage);
-      return false;
+    if (xv >= x[n - 1]) {
+      out[k] = clamp01(y[n - 1]);
+      continue;
     }
-    const buf = new Float32Array(acc.length);
-    this.blend(buf, content, "normal", fill2, coverage);
-    this.applyClipped(clipped, buf, r);
-    this.blend(acc, buf, mode, layer.opacity, null);
-    return false;
+    while (seg < n - 2 && xv > x[seg + 1]) seg++;
+    const x0 = x[seg], x1 = x[seg + 1];
+    const h = x1 - x0;
+    const a = (x1 - xv) / h;
+    const b = (xv - x0) / h;
+    const v = a * y[seg] + b * y[seg + 1] + ((a * a * a - a) * m2[seg] + (b * b * b - b) * m2[seg + 1]) * (h * h) / 6;
+    out[k] = clamp01(v);
   }
-  applyClipped(clipped, buf, r) {
-    let run = [];
-    const flush = () => {
-      if (run.length) this.applyFilterRun(run, buf, r);
-      run = [];
-    };
-    for (const c of clipped) {
-      if (this.isFilter(c)) {
-        run.push(c);
-        continue;
-      }
-      flush();
-      const alone = this.renderedAlone(c);
-      const coverage = alone ? null : this.base.maskCoverage(c, r, this.sources);
-      let src;
-      if (isGroup(c) && !alone) {
-        src = new Float32Array(buf.length);
-        if (this.runSteps(this.buildSteps(c.children ?? []), src, true, r)) continue;
-      } else src = this.content(c, r);
-      if (!src) continue;
-      const fill2 = !alone && this.isPixel(c) ? c.fillOpacity ?? 1 : 1;
-      const keep = new Float32Array(buf.length >> 2);
-      for (let i = 3, p = 0; i < buf.length; i += 4, p++) keep[p] = buf[i];
-      this.blend(buf, src, c.blend === "pass-through" ? "normal" : this.blendOf(c), c.opacity * fill2, coverage);
-      for (let i = 3, p = 0; i < buf.length; i += 4, p++) buf[i] = keep[p];
+  return out;
+}
+
+// src/raster/effects/patterns.ts
+var PatternTile = class {
+  w;
+  h;
+  px;
+  constructor(p) {
+    this.w = Math.max(1, p.width | 0);
+    this.h = Math.max(1, p.height | 0);
+    const n = this.w * this.h;
+    this.px = new Float32Array(n * 4);
+    for (let i = 0; i < n; i++) {
+      const a = (p.data[i * 4 + 3] ?? 0) / 255;
+      this.px[i * 4] = (p.data[i * 4] ?? 0) / 255 * a;
+      this.px[i * 4 + 1] = (p.data[i * 4 + 1] ?? 0) / 255 * a;
+      this.px[i * 4 + 2] = (p.data[i * 4 + 2] ?? 0) / 255 * a;
+      this.px[i * 4 + 3] = a;
     }
-    flush();
   }
-  applyFilterRun(layers, acc, r) {
-    const visible = [];
-    let masks;
-    for (const node of layers) {
-      if (!node.visible) continue;
-      const cov = this.base.maskCoverage(node, r, this.sources);
-      if (cov) {
-        if (cov.every((v) => v <= 0)) continue;
-        (masks ??= /* @__PURE__ */ new Map()).set(node.id, cov);
+  /** Bilinear wrapping sample at tile coordinates (pixel centres at `i + 0.5`), straight alpha into `out`. */
+  sample(u, v, out) {
+    u -= 0.5;
+    v -= 0.5;
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v);
+    const fx = u - x0;
+    const fy = v - y0;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 0;
+    for (let dy = 0; dy < 2; dy++) {
+      const wy2 = dy ? fy : 1 - fy;
+      if (wy2 === 0) continue;
+      const yi = ((y0 + dy) % this.h + this.h) % this.h;
+      for (let dx = 0; dx < 2; dx++) {
+        const wx2 = dx ? fx : 1 - fx;
+        if (wx2 === 0) continue;
+        const xi = ((x0 + dx) % this.w + this.w) % this.w;
+        const k = wx2 * wy2;
+        const i = (yi * this.w + xi) * 4;
+        r += this.px[i] * k;
+        g += this.px[i + 1] * k;
+        b += this.px[i + 2] * k;
+        a += this.px[i + 3] * k;
       }
-      visible.push(node);
     }
-    if (!visible.length) return;
-    if (this.deep.applyFilterRunDeep) {
-      if (this.linear) mapColour(acc, srgbEncode);
-      this.deep.applyFilterRunDeep(visible, acc, r, masks, this.sources);
-      if (this.linear) mapColour(acc, srgbDecode);
+    if (a <= 0) {
+      out[0] = out[1] = out[2] = out[3] = 0;
       return;
     }
-    const bytes = this.to8(acc);
-    this.profile.applyFilterRun?.(visible, bytes, r, masks, this.sources);
-    acc.set(this.from8(bytes));
+    out[0] = r / a;
+    out[1] = g / a;
+    out[2] = b / a;
+    out[3] = Math.min(1, a);
   }
-  // --- Layer content ---------------------------------------------------------------
-  /** Layers drawn by the 8-bit compositor alone (effects, pixel filters, content the editor draws). */
-  renderedAlone(layer) {
-    if (hasActiveEffects(layer.effects) && !this.isFilter(layer)) return true;
-    if (this.isPixel(layer)) return Boolean(this.profile.pixelFilters?.(layer));
-    return !isGroup(layer);
+};
+var PatternPlacement = class {
+  ox;
+  oy;
+  c;
+  s;
+  inv;
+  /** `anchor`: the layer's top-left (used when `link`); `phase` in px; `scale` a fraction; `angle` degrees counter-clockwise. */
+  constructor(anchor, link, phase, scale, angle) {
+    const bx = link ? anchor.x : 0;
+    const by = link ? anchor.y : 0;
+    this.ox = bx + phase.x;
+    this.oy = by + phase.y;
+    this.inv = Number.isFinite(scale) && scale > 1e-3 ? 1 / scale : 1;
+    const a = (Number.isFinite(angle) ? angle : 0) * Math.PI / 180;
+    this.c = Math.cos(a);
+    this.s = Math.sin(a);
   }
-  blendOf(layer) {
-    return this.profile.contentBlend?.(layer) ?? layer.blend;
+  /** Tile coordinates of the document point `(x, y)` into `out[0..1]`. */
+  map(x, y, out) {
+    const dx = x - this.ox;
+    const dy = y - this.oy;
+    out[0] = (dx * this.c - dy * this.s) * this.inv;
+    out[1] = (dx * this.s + dy * this.c) * this.inv;
   }
-  /** A layer's float RGBA over `r` (straight alpha, working space), or `null` when it has none there. */
-  content(layer, r) {
-    if (this.renderedAlone(layer)) {
-      const solo = { ...layer, blend: isGroup(layer) && layer.blend === "pass-through" ? "pass-through" : "normal", opacity: 1, clipped: false };
-      const bytes = this.base.composite([solo], r, this.sources);
-      return this.from8(bytes);
-    }
-    const surface = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
-    if (!surface) return null;
-    const ox = layer.offset?.x ?? 0;
-    const oy = layer.offset?.y ?? 0;
-    const samples = readDeepRegion(surface, { x: r.x - ox, y: r.y - oy, width: r.width, height: r.height }, this.depth);
-    if (samples instanceof Float32Array) return samples;
-    const out = new Float32Array(samples.length);
-    for (let i = 0; i < samples.length; i++) out[i] = samples[i] / 65535;
-    return out;
-  }
-  /** 8-bit RGBA to the working space. */
-  from8(bytes) {
-    if (this.linear) return to32From8(bytes, 4);
-    const out = new Float32Array(bytes.length);
-    for (let i = 0; i < bytes.length; i++) out[i] = bytes[i] / 255;
-    return out;
-  }
-  /** The working space to 8-bit RGBA. */
-  to8(acc) {
-    const out = new Uint8ClampedArray(acc.length);
-    for (let i = 0; i < acc.length; i += 4) {
-      for (let c = 0; c < 3; c++) out[i + c] = Math.round((this.linear ? srgbEncode(acc[i + c]) : acc[i + c]) * 255);
-      out[i + 3] = Math.round(acc[i + 3] * 255);
+};
+var BUILTINS = {
+  checker: { name: "Checker", size: 16, paint: (x, y) => x < 8 !== y < 8 ? [204, 204, 204, 255] : [255, 255, 255, 255] },
+  stripes: { name: "Diagonal Stripes", size: 16, paint: (x, y) => (x + y) % 16 < 8 ? [40, 40, 40, 255] : [235, 235, 235, 255] },
+  dots: {
+    name: "Dots",
+    size: 12,
+    paint: (x, y) => {
+      const d = Math.hypot(x + 0.5 - 6, y + 0.5 - 6);
+      const a = Math.max(0, Math.min(1, 3.5 - d));
+      return [Math.round(255 - a * 215), Math.round(255 - a * 215), Math.round(255 - a * 215), 255];
     }
-    return out;
-  }
-  // --- Blending --------------------------------------------------------------------
-  /** `src` over `dst` with `mode` at `alpha` × coverage (straight alpha, float), as `blendTile`. */
-  blend(dst, src, mode, alpha, coverage) {
-    if (!(alpha > 0)) return;
-    const normal = mode === "normal";
-    const pigment = mode === "pigment";
-    const cb = [0, 0, 0];
-    const cs = [0, 0, 0];
-    const mix = [0, 0, 0];
-    for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
-      const sa = src[i + 3];
-      if (!(sa > 0)) continue;
-      const k = coverage ? alpha * coverage[p] : alpha;
-      if (!(k > 0)) continue;
-      const as = Math.min(1, sa * k);
-      const ab = dst[i + 3];
-      const ao = as + ab * (1 - as);
-      if (ao <= 0) {
-        dst[i] = dst[i + 1] = dst[i + 2] = dst[i + 3] = 0;
-        continue;
-      }
-      if (normal && as >= 1) {
-        dst[i] = src[i];
-        dst[i + 1] = src[i + 1];
-        dst[i + 2] = src[i + 2];
-        dst[i + 3] = 1;
-        continue;
-      }
-      for (let c = 0; c < 3; c++) {
-        cb[c] = dst[i + c];
-        cs[c] = src[i + c];
-      }
-      if (pigment) {
-        if (this.linear) for (let c = 0; c < 3; c++) cb[c] = srgbEncode(cb[c]), cs[c] = srgbEncode(cs[c]);
-        mixPigmentRgb(cb, cs, as / ao, mix);
-        for (let c = 0; c < 3; c++) dst[i + c] = this.linear ? srgbDecode(mix[c]) : mix[c];
-        dst[i + 3] = ao;
-        continue;
-      }
-      const m = normal ? cs : blendRgb(mode, cb, cs);
-      const wb = (1 - as) * ab;
-      const ws = (1 - ab) * as;
-      const wm = as * ab;
-      for (let c = 0; c < 3; c++) dst[i + c] = (wb * cb[c] + ws * cs[c] + wm * m[c]) / ao;
-      dst[i + 3] = ao;
+  },
+  grid: { name: "Grid", size: 16, paint: (x, y) => x === 0 || y === 0 ? [90, 90, 90, 255] : [250, 250, 250, 255] },
+  noise: {
+    name: "Noise",
+    size: 64,
+    paint: (x, y) => {
+      const v = Math.round(hashNoise(x, y) * 255);
+      return [v, v, v, 255];
     }
   }
 };
-function lerp(dst, before, alpha, coverage) {
-  for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
-    const k = coverage ? alpha * coverage[p] : alpha;
-    if (k >= 1) continue;
-    for (let c = 0; c < 4; c++) dst[i + c] = before[i + c] + (dst[i + c] - before[i + c]) * k;
-  }
+function builtinPatternIds() {
+  return Object.keys(BUILTINS);
 }
-function mapColour(data, f) {
-  for (let i = 0; i < data.length; i += 4) {
-    data[i] = f(data[i]);
-    data[i + 1] = f(data[i + 1]);
-    data[i + 2] = f(data[i + 2]);
+var builtinCache = /* @__PURE__ */ new Map();
+function builtinPattern(id) {
+  const def = BUILTINS[id];
+  if (!def) return null;
+  let p = builtinCache.get(id);
+  if (!p) {
+    const data = new Uint8ClampedArray(def.size * def.size * 4);
+    for (let y = 0; y < def.size; y++) {
+      for (let x = 0; x < def.size; x++) data.set(def.paint(x, y), (y * def.size + x) * 4);
+    }
+    p = { id, name: def.name, width: def.size, height: def.size, data };
+    builtinCache.set(id, p);
   }
+  return p;
 }
-function workingToSamples(data, depth) {
-  if (depth === 32) return data;
-  const out = new Uint16Array(data.length);
-  for (let i = 0; i < data.length; i++) {
-    const v = data[i];
-    out[i] = v > 0 ? v < 1 ? Math.round(v * 65535) : 65535 : 0;
-  }
-  return out;
+function hashNoise(x, y) {
+  let h = Math.imul(x | 0, 2376512323) ^ Math.imul(y | 0, 3625334849) ^ 2654435769;
+  h ^= h >>> 15;
+  h = Math.imul(h, 739982445);
+  h ^= h >>> 12;
+  return (h & 65535) / 65536;
 }
 
-// src/raster/blur.ts
-function gaussianKernel(sigma) {
-  const r = Math.ceil(sigma * 3);
-  const k = new Float32Array(2 * r + 1);
-  let s = 0;
-  for (let i = -r; i <= r; i++) {
-    const v = Math.exp(-(i * i) / (2 * sigma * sigma));
-    k[i + r] = v;
-    s += v;
+// src/raster/effects/render.ts
+var INSIDE_EPS = 0.5 / 255;
+var INF = 1e20;
+var FAR = 1e9;
+var STROKE_CHAMFER_MAX = 20;
+var BEVEL_H_EPS = 1e-5;
+var fmap = (w, h, fill2 = 0) => {
+  const v = new Float32Array(w * h);
+  if (fill2) v.fill(fill2);
+  return { w, h, v };
+};
+var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+var clamp012 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
+function mapGet(m, x, y) {
+  return x < 0 || y < 0 || x >= m.w || y >= m.h ? 0 : m.v[y * m.w + x];
+}
+function shifted(m, dx, dy, outside) {
+  const reach = (d) => Number.isFinite(d) ? clamp(d, -1e9, 1e9) : 0;
+  dx = reach(dx);
+  dy = reach(dy);
+  const fx = Math.floor(dx);
+  const fy = Math.floor(dy);
+  const ax = dx - fx;
+  const ay = dy - fy;
+  const { w, h, v } = m;
+  const s = (x, y) => x < 0 || y < 0 || x >= w || y >= h ? outside : v[y * w + x];
+  const out = fmap(w, h);
+  for (let y = 0; y < h; y++) {
+    const sy = y - fy;
+    for (let x = 0; x < w; x++) {
+      const sx = x - fx;
+      const top = s(sx, sy) * (1 - ax) + s(sx - 1, sy) * ax;
+      const bot = s(sx, sy - 1) * (1 - ax) + s(sx - 1, sy - 1) * ax;
+      out.v[y * w + x] = top * (1 - ay) + bot * ay;
+    }
   }
-  for (let i = 0; i < k.length; i++) k[i] /= s;
-  return k;
+  return out;
 }
-var DIRECT_GAUSSIAN_MAX_SIGMA = 8;
-function boxRadii(sigma) {
-  const n = 3;
-  const wIdeal = Math.sqrt(12 * sigma * sigma / n + 1);
-  let wl = Math.floor(wIdeal);
-  if (wl % 2 === 0) wl--;
-  const wu = wl + 2;
-  const mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
-  const m = Math.round(mIdeal);
-  const sizes = [0, 1, 2].map((i) => i < m ? wl : wu);
-  return sizes.map((s) => (s - 1) / 2);
+function mapped(m, f) {
+  const out = fmap(m.w, m.h);
+  for (let i = 0; i < m.v.length; i++) out.v[i] = f(m.v[i]);
+  return out;
 }
-function convolveLine(src, off, stride, len, k, edge, dst) {
-  const r = (k.length - 1) / 2;
-  for (let i = 0; i < len; i++) {
-    let a = 0;
-    const lo = i - r;
-    for (let j = 0; j < k.length; j++) {
-      let x = lo + j;
-      if (x < 0 || x >= len) {
-        if (edge === "zero") continue;
-        x = x < 0 ? 0 : len - 1;
+function dt1(f, n, out, near, v, z) {
+  let k = 0;
+  v[0] = 0;
+  z[0] = -Infinity;
+  z[1] = Infinity;
+  for (let q = 1; q < n; q++) {
+    for (; ; ) {
+      const p = v[k];
+      const s = (f[q] + q * q - (f[p] + p * p)) / (2 * q - 2 * p);
+      if (s <= z[k] && k > 0) {
+        k--;
+        continue;
       }
-      a += src[off + x * stride] * k[j];
+      if (s <= z[k]) {
+        v[0] = q;
+        z[0] = -Infinity;
+        z[1] = Infinity;
+        break;
+      }
+      k++;
+      v[k] = q;
+      z[k] = s;
+      z[k + 1] = Infinity;
+      break;
     }
-    dst[i] = a;
   }
-}
-function boxesLine(src, off, stride, len, radii, edge, a, b, dst) {
-  const pad = radii.reduce((s, r) => s + r, 0);
-  const plen = len + 2 * pad;
-  for (let i = 0; i < plen; i++) {
-    const j = i - pad;
-    a[i] = j < 0 ? edge === "zero" ? 0 : src[off] : j >= len ? edge === "zero" ? 0 : src[off + (len - 1) * stride] : src[off + j * stride];
+  k = 0;
+  for (let q = 0; q < n; q++) {
+    while (z[k + 1] < q) k++;
+    const p = v[k];
+    const d = q - p;
+    out[q] = d * d + f[p];
+    near[q] = p;
   }
-  let from = a;
-  let to = b;
-  for (const r of radii) {
-    let sum = 0;
-    for (let i = 0; i <= Math.min(r, plen - 1); i++) sum += from[i];
-    const k = 2 * r + 1;
-    for (let i = 0; i < plen; i++) {
-      to[i] = sum / k;
-      const add = i + r + 1;
-      const drop = i - r;
-      if (add < plen) sum += from[add];
-      if (drop >= 0) sum -= from[drop];
-    }
-    const t = from;
-    from = to;
-    to = t;
-  }
-  for (let i = 0; i < len; i++) dst[i] = from[i + pad];
 }
-function gaussianBlur(src, w, h, sigma, edge = "zero") {
-  const out = Float32Array.from(src);
-  if (!(sigma >= 0.1) || w <= 0 || h <= 0) return out;
-  const s = Math.min(sigma, 4 * Math.max(w, h));
-  const line = new Float32Array(Math.max(w, h));
-  const passes = [];
-  if (s <= DIRECT_GAUSSIAN_MAX_SIGMA) {
-    const k = gaussianKernel(s);
-    passes.push((buf, off, stride, len) => convolveLine(buf, off, stride, len, k, edge, line));
-  } else {
-    const radii = boxRadii(s);
-    const plen = Math.max(w, h) + 2 * radii.reduce((a2, r) => a2 + r, 0);
-    const a = new Float32Array(plen);
-    const b = new Float32Array(plen);
-    passes.push((buf, off, stride, len) => boxesLine(buf, off, stride, len, radii, edge, a, b, line));
-  }
-  for (const pass of passes) {
+function edtNearest(inside, w, h) {
+  const total = w * h;
+  const n = Math.max(w, h);
+  const f = new Float64Array(n);
+  const o = new Float64Array(n);
+  const nr = new Int32Array(n);
+  const v = new Int32Array(n);
+  const z = new Float64Array(n + 1);
+  const gc = new Float64Array(total);
+  const nc = new Int32Array(total);
+  for (let x = 0; x < w; x++) {
+    for (let y = 0; y < h; y++) f[y] = inside[y * w + x] ? 0 : INF;
+    dt1(f, h, o, nr, v, z);
     for (let y = 0; y < h; y++) {
-      pass(out, y * w, 1, w);
-      out.set(line.subarray(0, w), y * w);
+      gc[x * h + y] = o[y];
+      nc[x * h + y] = nr[y];
     }
   }
-  for (const pass of passes) {
+  const d = new Float32Array(total);
+  const near = new Int32Array(total);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) f[x] = gc[x * h + y];
+    dt1(f, w, o, nr, v, z);
     for (let x = 0; x < w; x++) {
-      pass(out, x, w, h);
-      for (let y = 0; y < h; y++) out[y * w + x] = line[y];
+      d[y * w + x] = Math.sqrt(o[x]);
+      const px = nr[x];
+      near[y * w + x] = nc[px * h + y] * w + px;
     }
   }
-  return out;
+  return { d, near };
 }
-
-// src/raster/layers.ts
-var childrenOf = (l) => l.type === "group" ? l.children ?? null : null;
-function flattenLayers(layers) {
-  const out = [];
-  const walk = (list) => {
-    for (const l of list) {
-      out.push(l);
-      const c = childrenOf(l);
-      if (c) walk(c);
+var S2 = Math.SQRT2;
+var S5 = 2.236068;
+var FWD = [
+  [-1, 0, 1],
+  [-1, -1, S2],
+  [0, -1, 1],
+  [1, -1, S2],
+  [-1, -2, S5],
+  [1, -2, S5],
+  [-2, -1, S5],
+  [2, -1, S5]
+];
+function chamferFrom(d, w, h) {
+  const ox = FWD.map((f) => f[0]);
+  const oy = FWD.map((f) => f[1]);
+  const wt = FWD.map((f) => f[2]);
+  const k = FWD.length;
+  for (let pass = 0; pass < 2; pass++) {
+    const sign = pass === 0 ? 1 : -1;
+    for (let yy = 0; yy < h; yy++) {
+      const y = pass === 0 ? yy : h - 1 - yy;
+      for (let xx = 0; xx < w; xx++) {
+        const x = pass === 0 ? xx : w - 1 - xx;
+        const i = y * w + x;
+        let best = d[i];
+        for (let j = 0; j < k; j++) {
+          const nx = x + ox[j] * sign;
+          const ny = y + oy[j] * sign;
+          if (nx < 0 || ny < 0 || nx >= w || ny >= h) continue;
+          const c = d[ny * w + nx] + wt[j];
+          if (c < best) best = c;
+        }
+        d[i] = best;
+      }
     }
-  };
-  walk(layers);
+  }
+  return d;
+}
+function distOutside(s, chamfer) {
+  const { w, h, v } = s;
+  const n = v.length;
+  const out = new Float32Array(n);
+  if (chamfer) {
+    const start = new Float32Array(n);
+    for (let i = 0; i < n; i++) start[i] = v[i] > INSIDE_EPS ? 1 - Math.min(v[i], 1) : INF;
+    const d2 = chamferFrom(start, w, h);
+    for (let i = 0; i < n; i++) out[i] = v[i] > INSIDE_EPS ? -0.5 : d2[i] - 0.5;
+    return out;
+  }
+  const inside = new Uint8Array(n);
+  for (let i = 0; i < n; i++) inside[i] = v[i] > INSIDE_EPS ? 1 : 0;
+  const { d, near } = edtNearest(inside, w, h);
+  for (let i = 0; i < n; i++) out[i] = inside[i] ? -0.5 : d[i] - 0.5 + (1 - Math.min(v[near[i]], 1));
   return out;
 }
-function findLayer(layers, id) {
-  const walk = (list, parent, path) => {
-    for (let i = 0; i < list.length; i++) {
-      const l = list[i];
-      if (l.id === id) return { layer: l, parent, index: i, path };
-      const c = childrenOf(l);
-      if (c) {
-        const g = l;
-        const hit = walk(c, g, [...path, g]);
-        if (hit) return hit;
-      }
+function localCoverage(s) {
+  const out = { w: s.w, h: s.h, v: new Float32Array(s.v) };
+  for (let y = 0; y < s.h; y++) {
+    for (let x = 0; x < s.w; x++) {
+      const a = s.v[y * s.w + x];
+      if (a <= INSIDE_EPS) continue;
+      let mx = a;
+      for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) mx = Math.max(mx, mapGet(s, x + dx, y + dy));
+      out.v[y * s.w + x] = Math.min(a / mx, 1);
     }
-    return null;
-  };
-  return walk(layers, null, []);
+  }
+  return out;
 }
-function mapLayer(layers, id, fn) {
-  let changed = false;
-  const walk = (list) => {
-    let out = null;
-    for (let i = 0; i < list.length; i++) {
-      const l = list[i];
-      let next = l;
-      if (l.id === id) {
-        next = fn(l);
-        changed = true;
+function distInside(s, chamfer) {
+  const { w, h, v } = s;
+  const n = v.length;
+  const out = new Float32Array(n);
+  if (chamfer) {
+    const cov = localCoverage(s);
+    const start = new Float32Array(n);
+    for (let i = 0; i < n; i++) start[i] = v[i] <= INSIDE_EPS ? 0 : cov.v[i] < 1 - INSIDE_EPS ? cov.v[i] : INF;
+    const d2 = chamferFrom(start, w, h);
+    for (let i = 0; i < n; i++) out[i] = v[i] <= INSIDE_EPS ? -0.5 : d2[i] - 0.5;
+    return out;
+  }
+  const outside = new Uint8Array(n);
+  for (let i = 0; i < n; i++) outside[i] = v[i] <= INSIDE_EPS ? 1 : 0;
+  const { d } = edtNearest(outside, w, h);
+  for (let i = 0; i < n; i++) out[i] = outside[i] ? -0.5 : d[i] - 0.5;
+  return out;
+}
+function edgeDistances(s, reach) {
+  const { w, h, v } = s;
+  const n = v.length;
+  const edge = new Uint8Array(n);
+  const inside = new Uint8Array(n);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      const a = v[i];
+      if (a <= INSIDE_EPS) continue;
+      inside[i] = 1;
+      if (a < 1 - INSIDE_EPS || mapGet(s, x - 1, y) <= INSIDE_EPS || mapGet(s, x + 1, y) <= INSIDE_EPS || mapGet(s, x, y - 1) <= INSIDE_EPS || mapGet(s, x, y + 1) <= INSIDE_EPS) edge[i] = 1;
+    }
+  }
+  const { d, near } = edtNearest(edge, w, h);
+  const din = new Float32Array(n);
+  const dout = new Float32Array(n);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      const q = near[i];
+      let sd;
+      if (d[i] > reach || d[i] >= INF / 2) {
+        sd = inside[i] ? -(d[i] + 0.5) : d[i] - 0.5;
       } else {
-        const c = childrenOf(l);
-        if (c) {
-          const children = walk(c);
-          if (children !== c) next = { ...l, children };
+        const qx = q % w;
+        const qy = (q - qx) / w;
+        const g = (dx, dy) => mapGet(s, qx + dx, qy + dy);
+        let nx = -(g(1, -1) + 2 * g(1, 0) + g(1, 1) - g(-1, -1) - 2 * g(-1, 0) - g(-1, 1));
+        let ny = -(g(-1, 1) + 2 * g(0, 1) + g(1, 1) - g(-1, -1) - 2 * g(0, -1) - g(1, -1));
+        const len = Math.hypot(nx, ny);
+        if (len > 1e-6) {
+          nx /= len;
+          ny /= len;
+        } else if (d[i] > 0) {
+          nx = (x - qx) / d[i];
+          ny = (y - qy) / d[i];
+        } else {
+          nx = 1;
+          ny = 0;
         }
+        sd = (x - qx) * nx + (y - qy) * ny - (Math.min(v[q], 1) - 0.5);
       }
-      if (next !== l) {
-        if (!out) out = list.slice(0, i);
-        if (next) out.push(next);
-      } else if (out) out.push(l);
+      din[i] = inside[i] ? Math.max(-sd, inside[i] && !edge[i] ? 0.5 : -0.5) : -0.5;
+      dout[i] = inside[i] && !edge[i] ? -0.5 : Math.max(sd, -0.5);
     }
-    return out ?? list;
-  };
-  const result = walk(layers);
-  return changed ? result : layers;
+  }
+  return { din, dout };
 }
-function insertLayer(layers, layer, parentId, index) {
-  const put = (list) => {
-    const at = index === void 0 ? list.length : Math.max(0, Math.min(list.length, index));
-    const next = list.slice();
-    next.splice(at, 0, layer);
-    return next;
-  };
-  if (!parentId) return put(layers);
-  return mapLayer(layers, parentId, (g) => {
-    const c = childrenOf(g);
-    return c ? { ...g, children: put(c) } : g;
-  });
+function dilate(s, r) {
+  if (!(r > 0)) return s;
+  const d = distOutside(s, true);
+  const out = { w: s.w, h: s.h, v: new Float32Array(s.v) };
+  for (let i = 0; i < d.length; i++) {
+    const o = out.v[i];
+    out.v[i] = d[i] < 0 ? Math.min(o + r, 1) : Math.max(o, clamp012(r + 0.5 - d[i]));
+  }
+  return out;
 }
-function isLayerLocked(layer, what) {
-  return Boolean(layer.locks?.all || layer.locks?.[what]);
-}
-
-// src/raster/effects/patterns.ts
-var PatternTile = class {
-  w;
-  h;
-  px;
-  constructor(p) {
-    this.w = Math.max(1, p.width | 0);
-    this.h = Math.max(1, p.height | 0);
-    const n = this.w * this.h;
-    this.px = new Float32Array(n * 4);
-    for (let i = 0; i < n; i++) {
-      const a = (p.data[i * 4 + 3] ?? 0) / 255;
-      this.px[i * 4] = (p.data[i * 4] ?? 0) / 255 * a;
-      this.px[i * 4 + 1] = (p.data[i * 4 + 1] ?? 0) / 255 * a;
-      this.px[i * 4 + 2] = (p.data[i * 4 + 2] ?? 0) / 255 * a;
-      this.px[i * 4 + 3] = a;
-    }
-  }
-  /** Bilinear wrapping sample at tile coordinates (pixel centres at `i + 0.5`), straight alpha into `out`. */
-  sample(u, v, out) {
-    u -= 0.5;
-    v -= 0.5;
-    const x0 = Math.floor(u);
-    const y0 = Math.floor(v);
-    const fx = u - x0;
-    const fy = v - y0;
-    let r = 0;
-    let g = 0;
-    let b = 0;
-    let a = 0;
-    for (let dy = 0; dy < 2; dy++) {
-      const wy2 = dy ? fy : 1 - fy;
-      if (wy2 === 0) continue;
-      const yi = ((y0 + dy) % this.h + this.h) % this.h;
-      for (let dx = 0; dx < 2; dx++) {
-        const wx2 = dx ? fx : 1 - fx;
-        if (wx2 === 0) continue;
-        const xi = ((x0 + dx) % this.w + this.w) % this.w;
-        const k = wx2 * wy2;
-        const i = (yi * this.w + xi) * 4;
-        r += this.px[i] * k;
-        g += this.px[i + 1] * k;
-        b += this.px[i + 2] * k;
-        a += this.px[i + 3] * k;
-      }
-    }
-    if (a <= 0) {
-      out[0] = out[1] = out[2] = out[3] = 0;
-      return;
-    }
-    out[0] = r / a;
-    out[1] = g / a;
-    out[2] = b / a;
-    out[3] = Math.min(1, a);
-  }
-};
-var PatternPlacement = class {
-  ox;
-  oy;
-  c;
-  s;
-  inv;
-  /** `anchor`: the layer's top-left (used when `link`); `phase` in px; `scale` a fraction; `angle` degrees counter-clockwise. */
-  constructor(anchor, link, phase, scale, angle) {
-    const bx = link ? anchor.x : 0;
-    const by = link ? anchor.y : 0;
-    this.ox = bx + phase.x;
-    this.oy = by + phase.y;
-    this.inv = Number.isFinite(scale) && scale > 1e-3 ? 1 / scale : 1;
-    const a = (Number.isFinite(angle) ? angle : 0) * Math.PI / 180;
-    this.c = Math.cos(a);
-    this.s = Math.sin(a);
-  }
-  /** Tile coordinates of the document point `(x, y)` into `out[0..1]`. */
-  map(x, y, out) {
-    const dx = x - this.ox;
-    const dy = y - this.oy;
-    out[0] = (dx * this.c - dy * this.s) * this.inv;
-    out[1] = (dx * this.s + dy * this.c) * this.inv;
-  }
-};
-var BUILTINS = {
-  checker: { name: "Checker", size: 16, paint: (x, y) => x < 8 !== y < 8 ? [204, 204, 204, 255] : [255, 255, 255, 255] },
-  stripes: { name: "Diagonal Stripes", size: 16, paint: (x, y) => (x + y) % 16 < 8 ? [40, 40, 40, 255] : [235, 235, 235, 255] },
-  dots: {
-    name: "Dots",
-    size: 12,
-    paint: (x, y) => {
-      const d = Math.hypot(x + 0.5 - 6, y + 0.5 - 6);
-      const a = Math.max(0, Math.min(1, 3.5 - d));
-      return [Math.round(255 - a * 215), Math.round(255 - a * 215), Math.round(255 - a * 215), 255];
-    }
-  },
-  grid: { name: "Grid", size: 16, paint: (x, y) => x === 0 || y === 0 ? [90, 90, 90, 255] : [250, 250, 250, 255] },
-  noise: {
-    name: "Noise",
-    size: 64,
-    paint: (x, y) => {
-      const v = Math.round(hashNoise(x, y) * 255);
-      return [v, v, v, 255];
-    }
-  }
-};
-function builtinPatternIds() {
-  return Object.keys(BUILTINS);
-}
-var builtinCache = /* @__PURE__ */ new Map();
-function builtinPattern(id) {
-  const def = BUILTINS[id];
-  if (!def) return null;
-  let p = builtinCache.get(id);
-  if (!p) {
-    const data = new Uint8ClampedArray(def.size * def.size * 4);
-    for (let y = 0; y < def.size; y++) {
-      for (let x = 0; x < def.size; x++) data.set(def.paint(x, y), (y * def.size + x) * 4);
-    }
-    p = { id, name: def.name, width: def.size, height: def.size, data };
-    builtinCache.set(id, p);
-  }
-  return p;
-}
-function hashNoise(x, y) {
-  let h = Math.imul(x | 0, 2376512323) ^ Math.imul(y | 0, 3625334849) ^ 2654435769;
-  h ^= h >>> 15;
-  h = Math.imul(h, 739982445);
-  h ^= h >>> 12;
-  return (h & 65535) / 65536;
-}
-
-// src/raster/curve.ts
-var CURVE_LUT_SIZE = 4096;
-var clamp01 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
-function curveLut(points, size = CURVE_LUT_SIZE) {
-  const pts = points.filter((p) => Number.isFinite(p.input) && Number.isFinite(p.output)).map((p) => [p.input, p.output]).sort((a, b) => a[0] - b[0]);
-  const dedup = [];
-  for (const p of pts) {
-    if (dedup.length && Math.abs(dedup[dedup.length - 1][0] - p[0]) < 1e-6) continue;
-    dedup.push(p);
-  }
-  const out = new Float32Array(size);
-  const n = dedup.length;
-  if (n < 2) {
-    for (let k = 0; k < size; k++) out[k] = k / (size - 1);
-    return out;
-  }
-  const x = dedup.map((p) => p[0]);
-  const y = dedup.map((p) => p[1]);
-  const m2 = new Float64Array(n);
-  if (n > 2) {
-    const c = new Float64Array(n);
-    const d = new Float64Array(n);
-    for (let i = 1; i < n - 1; i++) {
-      const h0 = x[i] - x[i - 1];
-      const h1 = x[i + 1] - x[i];
-      const a = h0 / 6;
-      const b = (h0 + h1) / 3;
-      const cc = h1 / 6;
-      const r = (y[i + 1] - y[i]) / h1 - (y[i] - y[i - 1]) / h0;
-      const denom = b - a * c[i - 1];
-      c[i] = cc / denom;
-      d[i] = (r - a * d[i - 1]) / denom;
-    }
-    for (let i = n - 2; i >= 1; i--) m2[i] = d[i] - c[i] * m2[i + 1];
-  }
-  let seg = 0;
-  for (let k = 0; k < size; k++) {
-    const xv = k / (size - 1);
-    if (xv <= x[0]) {
-      out[k] = clamp01(y[0]);
-      continue;
-    }
-    if (xv >= x[n - 1]) {
-      out[k] = clamp01(y[n - 1]);
-      continue;
-    }
-    while (seg < n - 2 && xv > x[seg + 1]) seg++;
-    const x0 = x[seg], x1 = x[seg + 1];
-    const h = x1 - x0;
-    const a = (x1 - xv) / h;
-    const b = (xv - x0) / h;
-    const v = a * y[seg] + b * y[seg + 1] + ((a * a * a - a) * m2[seg] + (b * b * b - b) * m2[seg + 1]) * (h * h) / 6;
-    out[k] = clamp01(v);
-  }
-  return out;
-}
-
-// src/raster/effects/render.ts
-var INSIDE_EPS = 0.5 / 255;
-var INF = 1e20;
-var FAR = 1e9;
-var STROKE_CHAMFER_MAX = 20;
-var BEVEL_H_EPS = 1e-5;
-var fmap = (w, h, fill2 = 0) => {
-  const v = new Float32Array(w * h);
-  if (fill2) v.fill(fill2);
-  return { w, h, v };
-};
-var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
-var clamp012 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
-function mapGet(m, x, y) {
-  return x < 0 || y < 0 || x >= m.w || y >= m.h ? 0 : m.v[y * m.w + x];
-}
-function shifted(m, dx, dy, outside) {
-  const reach = (d) => Number.isFinite(d) ? clamp(d, -1e9, 1e9) : 0;
-  dx = reach(dx);
-  dy = reach(dy);
-  const fx = Math.floor(dx);
-  const fy = Math.floor(dy);
-  const ax = dx - fx;
-  const ay = dy - fy;
-  const { w, h, v } = m;
-  const s = (x, y) => x < 0 || y < 0 || x >= w || y >= h ? outside : v[y * w + x];
-  const out = fmap(w, h);
-  for (let y = 0; y < h; y++) {
-    const sy = y - fy;
-    for (let x = 0; x < w; x++) {
-      const sx = x - fx;
-      const top = s(sx, sy) * (1 - ax) + s(sx - 1, sy) * ax;
-      const bot = s(sx, sy - 1) * (1 - ax) + s(sx - 1, sy - 1) * ax;
-      out.v[y * w + x] = top * (1 - ay) + bot * ay;
-    }
-  }
-  return out;
-}
-function mapped(m, f) {
-  const out = fmap(m.w, m.h);
-  for (let i = 0; i < m.v.length; i++) out.v[i] = f(m.v[i]);
-  return out;
-}
-function dt1(f, n, out, near, v, z) {
-  let k = 0;
-  v[0] = 0;
-  z[0] = -Infinity;
-  z[1] = Infinity;
-  for (let q = 1; q < n; q++) {
-    for (; ; ) {
-      const p = v[k];
-      const s = (f[q] + q * q - (f[p] + p * p)) / (2 * q - 2 * p);
-      if (s <= z[k] && k > 0) {
-        k--;
-        continue;
-      }
-      if (s <= z[k]) {
-        v[0] = q;
-        z[0] = -Infinity;
-        z[1] = Infinity;
-        break;
-      }
-      k++;
-      v[k] = q;
-      z[k] = s;
-      z[k + 1] = Infinity;
-      break;
-    }
-  }
-  k = 0;
-  for (let q = 0; q < n; q++) {
-    while (z[k + 1] < q) k++;
-    const p = v[k];
-    const d = q - p;
-    out[q] = d * d + f[p];
-    near[q] = p;
-  }
-}
-function edtNearest(inside, w, h) {
-  const total = w * h;
-  const n = Math.max(w, h);
-  const f = new Float64Array(n);
-  const o = new Float64Array(n);
-  const nr = new Int32Array(n);
-  const v = new Int32Array(n);
-  const z = new Float64Array(n + 1);
-  const gc = new Float64Array(total);
-  const nc = new Int32Array(total);
-  for (let x = 0; x < w; x++) {
-    for (let y = 0; y < h; y++) f[y] = inside[y * w + x] ? 0 : INF;
-    dt1(f, h, o, nr, v, z);
-    for (let y = 0; y < h; y++) {
-      gc[x * h + y] = o[y];
-      nc[x * h + y] = nr[y];
-    }
-  }
-  const d = new Float32Array(total);
-  const near = new Int32Array(total);
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) f[x] = gc[x * h + y];
-    dt1(f, w, o, nr, v, z);
-    for (let x = 0; x < w; x++) {
-      d[y * w + x] = Math.sqrt(o[x]);
-      const px = nr[x];
-      near[y * w + x] = nc[px * h + y] * w + px;
-    }
-  }
-  return { d, near };
-}
-var S2 = Math.SQRT2;
-var S5 = 2.236068;
-var FWD = [
-  [-1, 0, 1],
-  [-1, -1, S2],
-  [0, -1, 1],
-  [1, -1, S2],
-  [-1, -2, S5],
-  [1, -2, S5],
-  [-2, -1, S5],
-  [2, -1, S5]
-];
-function chamferFrom(d, w, h) {
-  const ox = FWD.map((f) => f[0]);
-  const oy = FWD.map((f) => f[1]);
-  const wt = FWD.map((f) => f[2]);
-  const k = FWD.length;
-  for (let pass = 0; pass < 2; pass++) {
-    const sign = pass === 0 ? 1 : -1;
-    for (let yy = 0; yy < h; yy++) {
-      const y = pass === 0 ? yy : h - 1 - yy;
-      for (let xx = 0; xx < w; xx++) {
-        const x = pass === 0 ? xx : w - 1 - xx;
-        const i = y * w + x;
-        let best = d[i];
-        for (let j = 0; j < k; j++) {
-          const nx = x + ox[j] * sign;
-          const ny = y + oy[j] * sign;
-          if (nx < 0 || ny < 0 || nx >= w || ny >= h) continue;
-          const c = d[ny * w + nx] + wt[j];
-          if (c < best) best = c;
-        }
-        d[i] = best;
-      }
-    }
-  }
-  return d;
-}
-function distOutside(s, chamfer) {
-  const { w, h, v } = s;
-  const n = v.length;
-  const out = new Float32Array(n);
-  if (chamfer) {
-    const start = new Float32Array(n);
-    for (let i = 0; i < n; i++) start[i] = v[i] > INSIDE_EPS ? 1 - Math.min(v[i], 1) : INF;
-    const d2 = chamferFrom(start, w, h);
-    for (let i = 0; i < n; i++) out[i] = v[i] > INSIDE_EPS ? -0.5 : d2[i] - 0.5;
-    return out;
-  }
-  const inside = new Uint8Array(n);
-  for (let i = 0; i < n; i++) inside[i] = v[i] > INSIDE_EPS ? 1 : 0;
-  const { d, near } = edtNearest(inside, w, h);
-  for (let i = 0; i < n; i++) out[i] = inside[i] ? -0.5 : d[i] - 0.5 + (1 - Math.min(v[near[i]], 1));
-  return out;
-}
-function localCoverage(s) {
-  const out = { w: s.w, h: s.h, v: new Float32Array(s.v) };
-  for (let y = 0; y < s.h; y++) {
-    for (let x = 0; x < s.w; x++) {
-      const a = s.v[y * s.w + x];
-      if (a <= INSIDE_EPS) continue;
-      let mx = a;
-      for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) mx = Math.max(mx, mapGet(s, x + dx, y + dy));
-      out.v[y * s.w + x] = Math.min(a / mx, 1);
-    }
-  }
-  return out;
-}
-function distInside(s, chamfer) {
-  const { w, h, v } = s;
-  const n = v.length;
-  const out = new Float32Array(n);
-  if (chamfer) {
-    const cov = localCoverage(s);
-    const start = new Float32Array(n);
-    for (let i = 0; i < n; i++) start[i] = v[i] <= INSIDE_EPS ? 0 : cov.v[i] < 1 - INSIDE_EPS ? cov.v[i] : INF;
-    const d2 = chamferFrom(start, w, h);
-    for (let i = 0; i < n; i++) out[i] = v[i] <= INSIDE_EPS ? -0.5 : d2[i] - 0.5;
-    return out;
-  }
-  const outside = new Uint8Array(n);
-  for (let i = 0; i < n; i++) outside[i] = v[i] <= INSIDE_EPS ? 1 : 0;
-  const { d } = edtNearest(outside, w, h);
-  for (let i = 0; i < n; i++) out[i] = outside[i] ? -0.5 : d[i] - 0.5;
-  return out;
-}
-function edgeDistances(s, reach) {
-  const { w, h, v } = s;
-  const n = v.length;
-  const edge = new Uint8Array(n);
-  const inside = new Uint8Array(n);
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      const i = y * w + x;
-      const a = v[i];
-      if (a <= INSIDE_EPS) continue;
-      inside[i] = 1;
-      if (a < 1 - INSIDE_EPS || mapGet(s, x - 1, y) <= INSIDE_EPS || mapGet(s, x + 1, y) <= INSIDE_EPS || mapGet(s, x, y - 1) <= INSIDE_EPS || mapGet(s, x, y + 1) <= INSIDE_EPS) edge[i] = 1;
-    }
-  }
-  const { d, near } = edtNearest(edge, w, h);
-  const din = new Float32Array(n);
-  const dout = new Float32Array(n);
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      const i = y * w + x;
-      const q = near[i];
-      let sd;
-      if (d[i] > reach || d[i] >= INF / 2) {
-        sd = inside[i] ? -(d[i] + 0.5) : d[i] - 0.5;
-      } else {
-        const qx = q % w;
-        const qy = (q - qx) / w;
-        const g = (dx, dy) => mapGet(s, qx + dx, qy + dy);
-        let nx = -(g(1, -1) + 2 * g(1, 0) + g(1, 1) - g(-1, -1) - 2 * g(-1, 0) - g(-1, 1));
-        let ny = -(g(-1, 1) + 2 * g(0, 1) + g(1, 1) - g(-1, -1) - 2 * g(0, -1) - g(1, -1));
-        const len = Math.hypot(nx, ny);
-        if (len > 1e-6) {
-          nx /= len;
-          ny /= len;
-        } else if (d[i] > 0) {
-          nx = (x - qx) / d[i];
-          ny = (y - qy) / d[i];
-        } else {
-          nx = 1;
-          ny = 0;
-        }
-        sd = (x - qx) * nx + (y - qy) * ny - (Math.min(v[q], 1) - 0.5);
-      }
-      din[i] = inside[i] ? Math.max(-sd, inside[i] && !edge[i] ? 0.5 : -0.5) : -0.5;
-      dout[i] = inside[i] && !edge[i] ? -0.5 : Math.max(sd, -0.5);
-    }
-  }
-  return { din, dout };
-}
-function dilate(s, r) {
-  if (!(r > 0)) return s;
-  const d = distOutside(s, true);
-  const out = { w: s.w, h: s.h, v: new Float32Array(s.v) };
-  for (let i = 0; i < d.length; i++) {
-    const o = out.v[i];
-    out.v[i] = d[i] < 0 ? Math.min(o + r, 1) : Math.max(o, clamp012(r + 0.5 - d[i]));
-  }
-  return out;
-}
-function boxWidth(w) {
-  return Number.isNaN(w) ? 1 : clamp(w, 1, MAX_EFFECT_REACH);
+function boxWidth(w) {
+  return Number.isNaN(w) ? 1 : clamp(w, 1, MAX_EFFECT_REACH);
 }
 function boxGeom(bw) {
   bw = boxWidth(bw);
@@ -2139,10 +1710,13 @@ function compositeLayerEffects(input) {
   const { backdrop, content, rect, maps, ctx } = input;
   const items = maps.items;
   const n = rect.width * rect.height;
+  const cs = content instanceof Float32Array ? 1 : 1 / 255;
+  const bs = backdrop instanceof Float32Array ? 1 : 1 / 255;
+  const floatOut = backdrop instanceof Float32Array;
   const shape = new Float32Array(n);
-  for (let i = 0; i < n; i++) shape[i] = content[i * 4 + 3] / 255;
+  for (let i = 0; i < n; i++) shape[i] = content[i * 4 + 3] * cs;
   const before = new Float32Array(n * 4);
-  for (let i = 0; i < n * 4; i++) before[i] = backdrop[i] / 255;
+  for (let i = 0; i < n * 4; i++) before[i] = backdrop[i] * bs;
   const work = new Float32Array(before);
   const fx = (i, k) => crop(maps.per[i][k], maps.rect, rect, 0);
   const bounds = maps.bounds ?? rect;
@@ -2170,178 +1744,692 @@ function compositeLayerEffects(input) {
     knockOut(m, fill2);
     paintGlow(work, m, e, env);
   }
-  const lay = new Float32Array(n * 4);
-  for (let i = 0; i < n; i++) {
-    lay[i * 4] = content[i * 4] / 255;
-    lay[i * 4 + 1] = content[i * 4 + 1] / 255;
-    lay[i * 4 + 2] = content[i * 4 + 2] / 255;
-    lay[i * 4 + 3] = inside(shape[i]) ? fill2 : 0;
+  const lay = new Float32Array(n * 4);
+  for (let i = 0; i < n; i++) {
+    lay[i * 4] = content[i * 4] * cs;
+    lay[i * 4 + 1] = content[i * 4 + 1] * cs;
+    lay[i * 4 + 2] = content[i * 4 + 2] * cs;
+    lay[i * 4 + 3] = inside(shape[i]) ? fill2 : 0;
+  }
+  const premerge = !normalLike;
+  if (premerge) {
+    const sep2 = isSeparableBlendMode(input.blend);
+    for (let i = 0; i < n; i++) {
+      const p = i * 4;
+      const sr = lay[p];
+      const sg = lay[p + 1];
+      const sb = lay[p + 2];
+      const sa = lay[p + 3];
+      lay[p] = work[p];
+      lay[p + 1] = work[p + 1];
+      lay[p + 2] = work[p + 2];
+      lay[p + 3] = work[p + 3];
+      compositeAt(lay, p, input.blend, sep2, sr, sg, sb, sa);
+    }
+  }
+  const rel = (m) => {
+    for (let i = 0; i < n; i++) m[i] = inside(shape[i]) ? Math.min(m[i] / shape[i], 1) : 0;
+    return m;
+  };
+  const full = new Float32Array(n);
+  for (let i = 0; i < n; i++) full[i] = inside(shape[i]) ? 1 : 0;
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "pattern-overlay") paintPattern(lay, full, e, env, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "gradient-overlay") paintGradient(lay, full, e.gradient, e.gradient.align ? bounds : input.canvas, env, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "color-overlay") paintColor(lay, full, e.color, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "satin") paintColor(lay, rel(fx(i, 0)), e.color, e.blend, e.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "inner-glow") paintGlow(lay, rel(fx(i, 0)), e, env);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind === "inner-shadow") paintColor(lay, rel(fx(i, 0)), e.color, e.blend, e.opacity);
+  }
+  const strokeIdx = items.map((e, i) => e.kind === "stroke" ? i : -1).filter((i) => i >= 0);
+  const din = strokeIdx.length && maps.din ? crop(maps.din, maps.rect, rect, 0) : null;
+  const frameOf = (i) => maps.frames.get(i) ?? bounds;
+  for (let k = strokeIdx.length - 1; k >= 0; k--) {
+    const st = items[strokeIdx[k]];
+    const [inW] = strokeWidths(st);
+    if (!(inW > 0) || !din) continue;
+    const m = new Float32Array(n);
+    for (let i = 0; i < n; i++) m[i] = inside(shape[i]) ? clamp012(inW + 0.5 - din[i]) : 0;
+    paintFill(lay, m, st.fill, frameOf(strokeIdx[k]), env, st.blend, st.opacity);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "inner") continue;
+    paintColor(lay, rel(fx(i, 0)), e.highlightColor, e.highlightBlend, e.highlightOpacity);
+    paintColor(lay, rel(fx(i, 1)), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+  }
+  for (let i = 0; i < n; i++) lay[i * 4 + 3] *= Math.min(shape[i], 1);
+  const outside = strokeIdx.filter((i) => strokeWidths(items[i])[1] > 0);
+  if (outside.length) {
+    const dout = maps.dout ? crop(maps.dout, maps.rect, rect, FAR) : null;
+    const doutExact = maps.doutExact ? crop(maps.doutExact, maps.rect, rect, FAR) : null;
+    const base = new Float32Array(work);
+    const acc = new Float32Array(n * 4);
+    const cover = new Float32Array(n);
+    for (const si of outside) {
+      const st = items[si];
+      const outW = strokeWidths(st)[1];
+      const d = (outW >= STROKE_CHAMFER_MAX ? doutExact : dout) ?? new Float32Array(n).fill(FAR);
+      const share = new Float32Array(n);
+      const ones = new Float32Array(n);
+      for (let i = 0; i < n; i++) {
+        const band = clamp012(outW + 0.5 - d[i]);
+        let k;
+        if (inside(shape[i])) {
+          const c = clamp012(lay[i * 4 + 3]);
+          k = c >= 1 ? 1 : clamp012((1 - clamp012(shape[i])) / (1 - c));
+        } else k = band;
+        share[i] = k * st.opacity * (1 - cover[i]);
+        cover[i] += share[i];
+        ones[i] = share[i] > 0 ? 1 : 0;
+      }
+      const blended = new Float32Array(base);
+      paintFill(blended, ones, st.fill, frameOf(si), env, st.blend, 1);
+      for (let i = 0; i < n; i++) {
+        const s = share[i];
+        if (!(s > 0)) continue;
+        const p = i * 4;
+        const ba = blended[p + 3];
+        acc[p] += s * blended[p] * ba;
+        acc[p + 1] += s * blended[p + 1] * ba;
+        acc[p + 2] += s * blended[p + 2] * ba;
+        acc[p + 3] += s * ba;
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      const c = cover[i];
+      if (c <= 0) continue;
+      const p = i * 4;
+      const k = 1 - Math.min(c, 1);
+      const a = work[p + 3] * k + acc[p + 3];
+      if (a > 0) {
+        work[p] = (work[p] * work[p + 3] * k + acc[p]) / a;
+        work[p + 1] = (work[p + 1] * work[p + 3] * k + acc[p + 1]) / a;
+        work[p + 2] = (work[p + 2] * work[p + 3] * k + acc[p + 2]) / a;
+        work[p + 3] = Math.min(a, 1);
+      }
+    }
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "outer") continue;
+    paintColor(work, fx(i, 0), e.highlightColor, e.highlightBlend, e.highlightOpacity);
+    paintColor(work, fx(i, 1), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+  }
+  const mode = premerge ? "normal" : input.blend;
+  const sep = isSeparableBlendMode(mode);
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    if (lay[p + 3] > 0) compositeAt(work, p, mode, sep, lay[p], lay[p + 1], lay[p + 2], lay[p + 3]);
+  }
+  for (const i of rev) {
+    const e = items[i];
+    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "both") continue;
+    paintColor(work, fx(i, 0), e.highlightColor, e.highlightBlend, e.highlightOpacity);
+    paintColor(work, fx(i, 1), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+  }
+  const op = clamp012(input.opacity);
+  for (let i = 0; i < n; i++) {
+    const p = i * 4;
+    const aa = before[p + 3];
+    const ba = work[p + 3];
+    const alpha = aa + (ba - aa) * op;
+    if (alpha <= 0) {
+      backdrop[p] = backdrop[p + 1] = backdrop[p + 2] = backdrop[p + 3] = 0;
+      continue;
+    }
+    if (floatOut) {
+      for (let c = 0; c < 3; c++) backdrop[p + c] = (before[p + c] * aa + (work[p + c] * ba - before[p + c] * aa) * op) / alpha;
+      backdrop[p + 3] = alpha;
+      continue;
+    }
+    for (let c = 0; c < 3; c++) backdrop[p + c] = Math.round((before[p + c] * aa + (work[p + c] * ba - before[p + c] * aa) * op) / alpha * 255);
+    backdrop[p + 3] = Math.round(alpha * 255);
+  }
+}
+function renderLayerEffects(effects, layer, backdrop, canvas, ctx) {
+  const items = activeEffectItems(effects);
+  const n = layer.rect.width * layer.rect.height;
+  const shape = new Float32Array(n);
+  for (let i = 0; i < n; i++) shape[i] = layer.content[i * 4 + 3] / 255;
+  const maps = buildEffectMaps(items, shape, layer.rect, ctx);
+  compositeLayerEffects({
+    backdrop,
+    content: layer.content,
+    rect: layer.rect,
+    maps,
+    blend: layer.blend,
+    opacity: layer.opacity,
+    fillOpacity: layer.fillOpacity ?? 1,
+    canvas,
+    ctx
+  });
+}
+
+// src/raster/deep-compositor.ts
+var isGroup = (l) => l.type === "group";
+var DeepCompositor = class {
+  constructor(base, profile, deep, depth) {
+    this.base = base;
+    this.profile = profile;
+    this.deep = deep;
+    this.depth = depth;
+    this.linear = depth === 32;
+  }
+  base;
+  profile;
+  deep;
+  depth;
+  sources;
+  linear;
+  /** The composite of `layers` over `rect` as float RGBA in the working space (`rect.width × rect.height × 4`). */
+  composite(layers, rect, sources) {
+    this.sources = sources;
+    const acc = new Float32Array(Math.max(0, rect.width * rect.height * 4));
+    if (rect.width > 0 && rect.height > 0) this.runSteps(this.buildSteps(layers), acc, true, rect);
+    return acc;
+  }
+  // --- Steps (as RasterCompositor.buildSteps) ------------------------------------
+  isPixel(l) {
+    return l.type === "pixel" || (this.profile.isPixelLike?.(l) ?? false);
+  }
+  isFilter(l) {
+    return this.profile.isFilterLayer?.(l) ?? false;
+  }
+  buildSteps(layers) {
+    const steps = [];
+    for (const layer of layers) {
+      const last = steps[steps.length - 1];
+      if (layer.clipped && last && (last.kind === "content" || last.kind === "group")) {
+        last.clipped.push(layer);
+        continue;
+      }
+      if (this.isFilter(layer)) {
+        if (last && last.kind === "adjust") last.layers.push(layer);
+        else steps.push({ kind: "adjust", layers: [layer] });
+      } else if (isGroup(layer)) steps.push({ kind: "group", layer, clipped: [], steps: this.buildSteps(layer.children ?? []) });
+      else steps.push({ kind: "content", layer, clipped: [] });
+    }
+    return steps;
+  }
+  runSteps(steps, acc, empty, r) {
+    for (const s of steps) empty = this.runStep(s, acc, empty, r);
+    return empty;
+  }
+  runStep(step, acc, empty, r) {
+    if (step.kind === "adjust") {
+      if (empty) return true;
+      this.applyFilterRun(step.layers, acc, r);
+      return false;
+    }
+    const layer = step.layer;
+    if (!layer.visible) return empty;
+    const clipped = step.clipped.filter((l) => l.visible);
+    if (step.kind === "content" && this.deepEffects(layer)) return this.runEffects(layer, clipped, acc, r) ? false : empty;
+    const coverage = this.renderedAlone(layer) ? null : this.base.maskCoverage(layer, r, this.sources);
+    if (coverage && coverage.every((v) => v <= 0)) return empty;
+    if (step.kind === "group" && !this.renderedAlone(layer)) {
+      if (layer.blend === "pass-through" && !clipped.length) {
+        if (layer.opacity >= 1 && !coverage) return this.runSteps(step.steps, acc, empty, r);
+        const before = acc.slice();
+        const stillEmpty = this.runSteps(step.steps, acc, empty, r);
+        lerp(acc, before, layer.opacity, coverage);
+        return empty && stillEmpty;
+      }
+      const buf2 = new Float32Array(acc.length);
+      if (this.runSteps(step.steps, buf2, true, r)) return empty;
+      this.applyClipped(clipped, buf2, r);
+      const mode2 = layer.blend === "pass-through" ? "normal" : layer.blend;
+      this.blend(acc, buf2, mode2, layer.opacity, coverage);
+      return false;
+    }
+    const content = this.content(layer, r);
+    if (!content) return empty;
+    const alone = this.renderedAlone(layer);
+    const fill2 = !alone && this.isPixel(layer) ? layer.fillOpacity ?? 1 : 1;
+    const mode = this.blendOf(layer);
+    if (!clipped.length) {
+      this.blend(acc, content, mode, layer.opacity * fill2, coverage);
+      return false;
+    }
+    const buf = new Float32Array(acc.length);
+    this.blend(buf, content, "normal", fill2, coverage);
+    this.applyClipped(clipped, buf, r);
+    this.blend(acc, buf, mode, layer.opacity, null);
+    return false;
+  }
+  /**
+   * A pixel layer with effects onto `acc` over `r`: its deep content (filters, mask, clipped
+   * layers) and the effects composited in float. Effect maps come from the 8-bit shape. At 32
+   * bits the effects composite in sRGB-encoded values (their colours and blends are defined
+   * there) and the result is decoded back. Returns whether anything was drawn.
+   */
+  runEffects(layer, clipped, acc, r) {
+    const fx = this.base.effectsInput(layer, r, this.sources);
+    if (!fx) return false;
+    const a = fx.rect;
+    const content = this.content(layer, a) ?? new Float32Array(a.width * a.height * 4);
+    const coverage = this.base.maskCoverage(layer, a, this.sources);
+    if (coverage) for (let i = 0; i < coverage.length; i++) content[i * 4 + 3] *= coverage[i];
+    if (clipped.length) this.applyClipped(clipped, content, a);
+    const sub = new Float32Array(a.width * a.height * 4);
+    for (let y = 0; y < a.height; y++) {
+      const s = ((a.y - r.y + y) * r.width + (a.x - r.x)) * 4;
+      sub.set(acc.subarray(s, s + a.width * 4), y * a.width * 4);
+    }
+    if (this.linear) {
+      encodeInPlace(sub);
+      encodeInPlace(content);
+    }
+    compositeLayerEffects({ ...fx, backdrop: sub, content });
+    if (this.linear) decodeInPlace(sub);
+    for (let y = 0; y < a.height; y++) acc.set(sub.subarray(y * a.width * 4, (y + 1) * a.width * 4), ((a.y - r.y + y) * r.width + (a.x - r.x)) * 4);
+    return true;
   }
-  const premerge = !normalLike;
-  if (premerge) {
-    const sep2 = isSeparableBlendMode(input.blend);
-    for (let i = 0; i < n; i++) {
-      const p = i * 4;
-      const sr = lay[p];
-      const sg = lay[p + 1];
-      const sb = lay[p + 2];
-      const sa = lay[p + 3];
-      lay[p] = work[p];
-      lay[p + 1] = work[p + 1];
-      lay[p + 2] = work[p + 2];
-      lay[p + 3] = work[p + 3];
-      compositeAt(lay, p, input.blend, sep2, sr, sg, sb, sa);
+  applyClipped(clipped, buf, r) {
+    let run = [];
+    const flush = () => {
+      if (run.length) this.applyFilterRun(run, buf, r);
+      run = [];
+    };
+    for (const c of clipped) {
+      if (this.isFilter(c)) {
+        run.push(c);
+        continue;
+      }
+      flush();
+      const alone = this.renderedAlone(c);
+      const coverage = alone ? null : this.base.maskCoverage(c, r, this.sources);
+      let src;
+      if (isGroup(c) && !alone) {
+        src = new Float32Array(buf.length);
+        if (this.runSteps(this.buildSteps(c.children ?? []), src, true, r)) continue;
+      } else src = this.content(c, r);
+      if (!src) continue;
+      const fill2 = !alone && this.isPixel(c) ? c.fillOpacity ?? 1 : 1;
+      const keep = new Float32Array(buf.length >> 2);
+      for (let i = 3, p = 0; i < buf.length; i += 4, p++) keep[p] = buf[i];
+      this.blend(buf, src, c.blend === "pass-through" ? "normal" : this.blendOf(c), c.opacity * fill2, coverage);
+      for (let i = 3, p = 0; i < buf.length; i += 4, p++) buf[i] = keep[p];
     }
+    flush();
   }
-  const rel = (m) => {
-    for (let i = 0; i < n; i++) m[i] = inside(shape[i]) ? Math.min(m[i] / shape[i], 1) : 0;
-    return m;
-  };
-  const full = new Float32Array(n);
-  for (let i = 0; i < n; i++) full[i] = inside(shape[i]) ? 1 : 0;
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind === "pattern-overlay") paintPattern(lay, full, e, env, e.blend, e.opacity);
+  applyFilterRun(layers, acc, r) {
+    const visible = [];
+    let masks;
+    for (const node of layers) {
+      if (!node.visible) continue;
+      const cov = this.base.maskCoverage(node, r, this.sources);
+      if (cov) {
+        if (cov.every((v) => v <= 0)) continue;
+        (masks ??= /* @__PURE__ */ new Map()).set(node.id, cov);
+      }
+      visible.push(node);
+    }
+    if (!visible.length) return;
+    if (this.deep.applyFilterRunDeep) {
+      if (this.linear) mapColour(acc, srgbEncode);
+      this.deep.applyFilterRunDeep(visible, acc, r, masks, this.sources);
+      if (this.linear) mapColour(acc, srgbDecode);
+      return;
+    }
+    const bytes = this.to8(acc);
+    this.profile.applyFilterRun?.(visible, bytes, r, masks, this.sources);
+    acc.set(this.from8(bytes));
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind === "gradient-overlay") paintGradient(lay, full, e.gradient, e.gradient.align ? bounds : input.canvas, env, e.blend, e.opacity);
+  // --- Layer content ---------------------------------------------------------------
+  /** Layers drawn by the 8-bit compositor alone (effects, pixel filters, content the editor draws). */
+  /** A pixel(-like) layer with effects: composited in float through `compositeLayerEffects`. */
+  deepEffects(layer) {
+    return hasActiveEffects(layer.effects) && !this.isFilter(layer) && this.isPixel(layer) && !isGroup(layer);
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind === "color-overlay") paintColor(lay, full, e.color, e.blend, e.opacity);
+  renderedAlone(layer) {
+    if (hasActiveEffects(layer.effects) && !this.isFilter(layer) && !this.deepEffects(layer)) return true;
+    if (this.isPixel(layer)) return Boolean(this.profile.pixelFilters?.(layer)) && !this.deep.pixelFiltersDeep?.(layer);
+    return !isGroup(layer);
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind === "satin") paintColor(lay, rel(fx(i, 0)), e.color, e.blend, e.opacity);
+  blendOf(layer) {
+    return this.profile.contentBlend?.(layer) ?? layer.blend;
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind === "inner-glow") paintGlow(lay, rel(fx(i, 0)), e, env);
+  /** A layer's float RGBA over `r` (straight alpha, working space), or `null` when it has none there. */
+  content(layer, r) {
+    if (this.renderedAlone(layer)) {
+      const solo = { ...layer, blend: isGroup(layer) && layer.blend === "pass-through" ? "pass-through" : "normal", opacity: 1, clipped: false };
+      const bytes = this.base.composite([solo], r, this.sources);
+      return this.from8(bytes);
+    }
+    const surface = this.sources.surfaceOf ? this.sources.surfaceOf(layer) : layer.surface;
+    if (!surface) return null;
+    const ox = layer.offset?.x ?? 0;
+    const oy = layer.offset?.y ?? 0;
+    const filters = this.isPixel(layer) ? this.deep.pixelFiltersDeep?.(layer) ?? null : null;
+    if (!filters) return this.samples(surface, { x: r.x - ox, y: r.y - oy, width: r.width, height: r.height });
+    const m = filters.reach;
+    const W = this.sources.width;
+    const H = this.sources.height;
+    const x0 = m ? Math.max(0, r.x - m) : r.x;
+    const y0 = m ? Math.max(0, r.y - m) : r.y;
+    const x1 = m ? Math.min(W, r.x + r.width + m) : r.x + r.width;
+    const y1 = m ? Math.min(H, r.y + r.height + m) : r.y + r.height;
+    if (x1 <= x0 || y1 <= y0) return new Float32Array(r.width * r.height * 4);
+    const big = { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+    const data = this.samples(surface, { ...big, x: big.x - ox, y: big.y - oy });
+    filters.apply(data, big.width, big.height, this.linear);
+    if (big.x === r.x && big.y === r.y && big.width === r.width && big.height === r.height) return data;
+    const out = new Float32Array(r.width * r.height * 4);
+    for (let y = 0; y < r.height; y++) {
+      const sy = r.y + y - big.y;
+      if (sy < 0 || sy >= big.height) continue;
+      for (let x = 0; x < r.width; x++) {
+        const sx = r.x + x - big.x;
+        if (sx < 0 || sx >= big.width) continue;
+        const s = (sy * big.width + sx) * 4;
+        const d = (y * r.width + x) * 4;
+        out[d] = data[s];
+        out[d + 1] = data[s + 1];
+        out[d + 2] = data[s + 2];
+        out[d + 3] = data[s + 3];
+      }
+    }
+    return out;
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind === "inner-shadow") paintColor(lay, rel(fx(i, 0)), e.color, e.blend, e.opacity);
+  /** A surface's samples over `rect` (layer space) in the working space. */
+  samples(surface, rect) {
+    const samples = readDeepRegion(surface, rect, this.depth);
+    if (samples instanceof Float32Array) return samples;
+    const out = new Float32Array(samples.length);
+    for (let i = 0; i < samples.length; i++) out[i] = samples[i] / 65535;
+    return out;
   }
-  const strokeIdx = items.map((e, i) => e.kind === "stroke" ? i : -1).filter((i) => i >= 0);
-  const din = strokeIdx.length && maps.din ? crop(maps.din, maps.rect, rect, 0) : null;
-  const frameOf = (i) => maps.frames.get(i) ?? bounds;
-  for (let k = strokeIdx.length - 1; k >= 0; k--) {
-    const st = items[strokeIdx[k]];
-    const [inW] = strokeWidths(st);
-    if (!(inW > 0) || !din) continue;
-    const m = new Float32Array(n);
-    for (let i = 0; i < n; i++) m[i] = inside(shape[i]) ? clamp012(inW + 0.5 - din[i]) : 0;
-    paintFill(lay, m, st.fill, frameOf(strokeIdx[k]), env, st.blend, st.opacity);
+  /** 8-bit RGBA to the working space. */
+  from8(bytes) {
+    if (this.linear) return to32From8(bytes, 4);
+    const out = new Float32Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) out[i] = bytes[i] / 255;
+    return out;
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "inner") continue;
-    paintColor(lay, rel(fx(i, 0)), e.highlightColor, e.highlightBlend, e.highlightOpacity);
-    paintColor(lay, rel(fx(i, 1)), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+  /** The working space to 8-bit RGBA. */
+  to8(acc) {
+    const out = new Uint8ClampedArray(acc.length);
+    for (let i = 0; i < acc.length; i += 4) {
+      for (let c = 0; c < 3; c++) out[i + c] = Math.round((this.linear ? srgbEncode(acc[i + c]) : acc[i + c]) * 255);
+      out[i + 3] = Math.round(acc[i + 3] * 255);
+    }
+    return out;
   }
-  for (let i = 0; i < n; i++) lay[i * 4 + 3] *= Math.min(shape[i], 1);
-  const outside = strokeIdx.filter((i) => strokeWidths(items[i])[1] > 0);
-  if (outside.length) {
-    const dout = maps.dout ? crop(maps.dout, maps.rect, rect, FAR) : null;
-    const doutExact = maps.doutExact ? crop(maps.doutExact, maps.rect, rect, FAR) : null;
-    const base = new Float32Array(work);
-    const acc = new Float32Array(n * 4);
-    const cover = new Float32Array(n);
-    for (const si of outside) {
-      const st = items[si];
-      const outW = strokeWidths(st)[1];
-      const d = (outW >= STROKE_CHAMFER_MAX ? doutExact : dout) ?? new Float32Array(n).fill(FAR);
-      const share = new Float32Array(n);
-      const ones = new Float32Array(n);
-      for (let i = 0; i < n; i++) {
-        const band = clamp012(outW + 0.5 - d[i]);
-        let k;
-        if (inside(shape[i])) {
-          const c = clamp012(lay[i * 4 + 3]);
-          k = c >= 1 ? 1 : clamp012((1 - clamp012(shape[i])) / (1 - c));
-        } else k = band;
-        share[i] = k * st.opacity * (1 - cover[i]);
-        cover[i] += share[i];
-        ones[i] = share[i] > 0 ? 1 : 0;
+  // --- Blending --------------------------------------------------------------------
+  /** `src` over `dst` with `mode` at `alpha` × coverage (straight alpha, float), as `blendTile`. */
+  blend(dst, src, mode, alpha, coverage) {
+    if (!(alpha > 0)) return;
+    const normal = mode === "normal";
+    const pigment = mode === "pigment";
+    const cb = [0, 0, 0];
+    const cs = [0, 0, 0];
+    const mix = [0, 0, 0];
+    for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
+      const sa = src[i + 3];
+      if (!(sa > 0)) continue;
+      const k = coverage ? alpha * coverage[p] : alpha;
+      if (!(k > 0)) continue;
+      const as = Math.min(1, sa * k);
+      const ab = dst[i + 3];
+      const ao = as + ab * (1 - as);
+      if (ao <= 0) {
+        dst[i] = dst[i + 1] = dst[i + 2] = dst[i + 3] = 0;
+        continue;
       }
-      const blended = new Float32Array(base);
-      paintFill(blended, ones, st.fill, frameOf(si), env, st.blend, 1);
-      for (let i = 0; i < n; i++) {
-        const s = share[i];
-        if (!(s > 0)) continue;
-        const p = i * 4;
-        const ba = blended[p + 3];
-        acc[p] += s * blended[p] * ba;
-        acc[p + 1] += s * blended[p + 1] * ba;
-        acc[p + 2] += s * blended[p + 2] * ba;
-        acc[p + 3] += s * ba;
+      if (normal && as >= 1) {
+        dst[i] = src[i];
+        dst[i + 1] = src[i + 1];
+        dst[i + 2] = src[i + 2];
+        dst[i + 3] = 1;
+        continue;
+      }
+      for (let c = 0; c < 3; c++) {
+        cb[c] = dst[i + c];
+        cs[c] = src[i + c];
+      }
+      if (pigment) {
+        if (this.linear) for (let c = 0; c < 3; c++) cb[c] = srgbEncode(cb[c]), cs[c] = srgbEncode(cs[c]);
+        mixPigmentRgb(cb, cs, as / ao, mix);
+        for (let c = 0; c < 3; c++) dst[i + c] = this.linear ? srgbDecode(mix[c]) : mix[c];
+        dst[i + 3] = ao;
+        continue;
       }
+      const m = normal ? cs : blendRgb(mode, cb, cs);
+      const wb = (1 - as) * ab;
+      const ws = (1 - ab) * as;
+      const wm = as * ab;
+      for (let c = 0; c < 3; c++) dst[i + c] = (wb * cb[c] + ws * cs[c] + wm * m[c]) / ao;
+      dst[i + 3] = ao;
     }
-    for (let i = 0; i < n; i++) {
-      const c = cover[i];
-      if (c <= 0) continue;
-      const p = i * 4;
-      const k = 1 - Math.min(c, 1);
-      const a = work[p + 3] * k + acc[p + 3];
-      if (a > 0) {
-        work[p] = (work[p] * work[p + 3] * k + acc[p]) / a;
-        work[p + 1] = (work[p + 1] * work[p + 3] * k + acc[p + 1]) / a;
-        work[p + 2] = (work[p + 2] * work[p + 3] * k + acc[p + 2]) / a;
-        work[p + 3] = Math.min(a, 1);
+  }
+};
+function lerp(dst, before, alpha, coverage) {
+  for (let i = 0, p = 0; i < dst.length; i += 4, p++) {
+    const k = coverage ? alpha * coverage[p] : alpha;
+    if (k >= 1) continue;
+    for (let c = 0; c < 4; c++) dst[i + c] = before[i + c] + (dst[i + c] - before[i + c]) * k;
+  }
+}
+function mapColour(data, f) {
+  for (let i = 0; i < data.length; i += 4) {
+    data[i] = f(data[i]);
+    data[i + 1] = f(data[i + 1]);
+    data[i + 2] = f(data[i + 2]);
+  }
+}
+function workingToSamples(data, depth) {
+  if (depth === 32) return data;
+  const out = new Uint16Array(data.length);
+  for (let i = 0; i < data.length; i++) {
+    const v = data[i];
+    out[i] = v > 0 ? v < 1 ? Math.round(v * 65535) : 65535 : 0;
+  }
+  return out;
+}
+function encodeInPlace(d) {
+  for (let i = 0; i < d.length; i += 4) {
+    d[i] = srgbEncode(d[i]);
+    d[i + 1] = srgbEncode(d[i + 1]);
+    d[i + 2] = srgbEncode(d[i + 2]);
+  }
+}
+function decodeInPlace(d) {
+  for (let i = 0; i < d.length; i += 4) {
+    d[i] = srgbDecode(d[i]);
+    d[i + 1] = srgbDecode(d[i + 1]);
+    d[i + 2] = srgbDecode(d[i + 2]);
+  }
+}
+
+// src/raster/blur.ts
+function gaussianKernel(sigma) {
+  const r = Math.ceil(sigma * 3);
+  const k = new Float32Array(2 * r + 1);
+  let s = 0;
+  for (let i = -r; i <= r; i++) {
+    const v = Math.exp(-(i * i) / (2 * sigma * sigma));
+    k[i + r] = v;
+    s += v;
+  }
+  for (let i = 0; i < k.length; i++) k[i] /= s;
+  return k;
+}
+var DIRECT_GAUSSIAN_MAX_SIGMA = 8;
+function boxRadii(sigma) {
+  const n = 3;
+  const wIdeal = Math.sqrt(12 * sigma * sigma / n + 1);
+  let wl = Math.floor(wIdeal);
+  if (wl % 2 === 0) wl--;
+  const wu = wl + 2;
+  const mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
+  const m = Math.round(mIdeal);
+  const sizes = [0, 1, 2].map((i) => i < m ? wl : wu);
+  return sizes.map((s) => (s - 1) / 2);
+}
+function convolveLine(src, off, stride, len, k, edge, dst) {
+  const r = (k.length - 1) / 2;
+  for (let i = 0; i < len; i++) {
+    let a = 0;
+    const lo = i - r;
+    for (let j = 0; j < k.length; j++) {
+      let x = lo + j;
+      if (x < 0 || x >= len) {
+        if (edge === "zero") continue;
+        x = x < 0 ? 0 : len - 1;
       }
+      a += src[off + x * stride] * k[j];
     }
+    dst[i] = a;
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "outer") continue;
-    paintColor(work, fx(i, 0), e.highlightColor, e.highlightBlend, e.highlightOpacity);
-    paintColor(work, fx(i, 1), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+}
+function boxesLine(src, off, stride, len, radii, edge, a, b, dst) {
+  const pad = radii.reduce((s, r) => s + r, 0);
+  const plen = len + 2 * pad;
+  for (let i = 0; i < plen; i++) {
+    const j = i - pad;
+    a[i] = j < 0 ? edge === "zero" ? 0 : src[off] : j >= len ? edge === "zero" ? 0 : src[off + (len - 1) * stride] : src[off + j * stride];
   }
-  const mode = premerge ? "normal" : input.blend;
-  const sep = isSeparableBlendMode(mode);
-  for (let i = 0; i < n; i++) {
-    const p = i * 4;
-    if (lay[p + 3] > 0) compositeAt(work, p, mode, sep, lay[p], lay[p + 1], lay[p + 2], lay[p + 3]);
+  let from = a;
+  let to = b;
+  for (const r of radii) {
+    let sum = 0;
+    for (let i = 0; i <= Math.min(r, plen - 1); i++) sum += from[i];
+    const k = 2 * r + 1;
+    for (let i = 0; i < plen; i++) {
+      to[i] = sum / k;
+      const add = i + r + 1;
+      const drop = i - r;
+      if (add < plen) sum += from[add];
+      if (drop >= 0) sum -= from[drop];
+    }
+    const t = from;
+    from = to;
+    to = t;
   }
-  for (const i of rev) {
-    const e = items[i];
-    if (e.kind !== "bevel-emboss" || maps.bevelPaint[i] !== "both") continue;
-    paintColor(work, fx(i, 0), e.highlightColor, e.highlightBlend, e.highlightOpacity);
-    paintColor(work, fx(i, 1), e.shadowColor, e.shadowBlend, e.shadowOpacity);
+  for (let i = 0; i < len; i++) dst[i] = from[i + pad];
+}
+function gaussianBlur(src, w, h, sigma, edge = "zero") {
+  const out = Float32Array.from(src);
+  if (!(sigma >= 0.1) || w <= 0 || h <= 0) return out;
+  const s = Math.min(sigma, 4 * Math.max(w, h));
+  const line = new Float32Array(Math.max(w, h));
+  const passes = [];
+  if (s <= DIRECT_GAUSSIAN_MAX_SIGMA) {
+    const k = gaussianKernel(s);
+    passes.push((buf, off, stride, len) => convolveLine(buf, off, stride, len, k, edge, line));
+  } else {
+    const radii = boxRadii(s);
+    const plen = Math.max(w, h) + 2 * radii.reduce((a2, r) => a2 + r, 0);
+    const a = new Float32Array(plen);
+    const b = new Float32Array(plen);
+    passes.push((buf, off, stride, len) => boxesLine(buf, off, stride, len, radii, edge, a, b, line));
   }
-  const op = clamp012(input.opacity);
-  for (let i = 0; i < n; i++) {
-    const p = i * 4;
-    const aa = before[p + 3];
-    const ba = work[p + 3];
-    const alpha = aa + (ba - aa) * op;
-    if (alpha <= 0) {
-      backdrop[p] = backdrop[p + 1] = backdrop[p + 2] = backdrop[p + 3] = 0;
-      continue;
+  for (const pass of passes) {
+    for (let y = 0; y < h; y++) {
+      pass(out, y * w, 1, w);
+      out.set(line.subarray(0, w), y * w);
     }
-    for (let c = 0; c < 3; c++) backdrop[p + c] = Math.round((before[p + c] * aa + (work[p + c] * ba - before[p + c] * aa) * op) / alpha * 255);
-    backdrop[p + 3] = Math.round(alpha * 255);
   }
+  for (const pass of passes) {
+    for (let x = 0; x < w; x++) {
+      pass(out, x, w, h);
+      for (let y = 0; y < h; y++) out[y * w + x] = line[y];
+    }
+  }
+  return out;
 }
-function renderLayerEffects(effects, layer, backdrop, canvas, ctx) {
-  const items = activeEffectItems(effects);
-  const n = layer.rect.width * layer.rect.height;
-  const shape = new Float32Array(n);
-  for (let i = 0; i < n; i++) shape[i] = layer.content[i * 4 + 3] / 255;
-  const maps = buildEffectMaps(items, shape, layer.rect, ctx);
-  compositeLayerEffects({
-    backdrop,
-    content: layer.content,
-    rect: layer.rect,
-    maps,
-    blend: layer.blend,
-    opacity: layer.opacity,
-    fillOpacity: layer.fillOpacity ?? 1,
-    canvas,
-    ctx
+
+// src/raster/layers.ts
+var childrenOf = (l) => l.type === "group" ? l.children ?? null : null;
+function flattenLayers(layers) {
+  const out = [];
+  const walk = (list) => {
+    for (const l of list) {
+      out.push(l);
+      const c = childrenOf(l);
+      if (c) walk(c);
+    }
+  };
+  walk(layers);
+  return out;
+}
+function findLayer(layers, id) {
+  const walk = (list, parent, path) => {
+    for (let i = 0; i < list.length; i++) {
+      const l = list[i];
+      if (l.id === id) return { layer: l, parent, index: i, path };
+      const c = childrenOf(l);
+      if (c) {
+        const g = l;
+        const hit = walk(c, g, [...path, g]);
+        if (hit) return hit;
+      }
+    }
+    return null;
+  };
+  return walk(layers, null, []);
+}
+function mapLayer(layers, id, fn) {
+  let changed = false;
+  const walk = (list) => {
+    let out = null;
+    for (let i = 0; i < list.length; i++) {
+      const l = list[i];
+      let next = l;
+      if (l.id === id) {
+        next = fn(l);
+        changed = true;
+      } else {
+        const c = childrenOf(l);
+        if (c) {
+          const children = walk(c);
+          if (children !== c) next = { ...l, children };
+        }
+      }
+      if (next !== l) {
+        if (!out) out = list.slice(0, i);
+        if (next) out.push(next);
+      } else if (out) out.push(l);
+    }
+    return out ?? list;
+  };
+  const result = walk(layers);
+  return changed ? result : layers;
+}
+function insertLayer(layers, layer, parentId, index) {
+  const put = (list) => {
+    const at = index === void 0 ? list.length : Math.max(0, Math.min(list.length, index));
+    const next = list.slice();
+    next.splice(at, 0, layer);
+    return next;
+  };
+  if (!parentId) return put(layers);
+  return mapLayer(layers, parentId, (g) => {
+    const c = childrenOf(g);
+    return c ? { ...g, children: put(c) } : g;
   });
 }
+function isLayerLocked(layer, what) {
+  return Boolean(layer.locks?.all || layer.locks?.[what]);
+}
 
 // src/raster/compositor.ts
 var TILE_PIXELS = TILE * TILE;
@@ -2591,6 +2679,26 @@ var RasterCompositor = class {
     this.setSources(sources);
     return this.maskTile(layer, r);
   }
+  /**
+   * For the float compositor: everything `compositeLayerEffects` needs for `layer` over `r` but
+   * the pixels (the area its effects reach inside `r`, the effect maps built from its 8-bit
+   * shape, blend, opacities, canvas and context), or `null` when nothing reaches `r`.
+   */
+  effectsInput(layer, r, sources) {
+    this.setSources(sources);
+    const maps = this.effectMapsOf(layer);
+    const rect = this.effectArea(layer, maps, r);
+    if (!rect) return null;
+    return {
+      rect,
+      maps,
+      blend: isGroup2(layer) ? layer.blend === "pass-through" ? "normal" : layer.blend : this.contentBlend(layer),
+      opacity: layer.opacity,
+      fillOpacity: this.isPixel(layer) ? layer.fillOpacity ?? 1 : 1,
+      canvas: { x: 0, y: 0, width: this.sources.width, height: this.sources.height },
+      ctx: this.effectContext()
+    };
+  }
   // --- Steps -------------------------------------------------------------------
   /** Pixel layers, and the layer kinds the profile composites like them. */
   isPixel(l) {
@@ -4162,22 +4270,13 @@ export {
   validateLayerEffects,
   normalizeLayerEffects,
   effectsFingerprint,
-  DeepCompositor,
-  workingToSamples,
-  DIRECT_GAUSSIAN_MAX_SIGMA,
-  gaussianBlur,
-  flattenLayers,
-  findLayer,
-  mapLayer,
-  insertLayer,
-  isLayerLocked,
+  CURVE_LUT_SIZE,
+  curveLut,
   PatternTile,
   PatternPlacement,
   builtinPatternIds,
   builtinPattern,
   hashNoise,
-  CURVE_LUT_SIZE,
-  curveLut,
   STROKE_CHAMFER_MAX,
   contourLut,
   activeEffectItems,
@@ -4188,6 +4287,15 @@ export {
   effectFillColors,
   compositeLayerEffects,
   renderLayerEffects,
+  DeepCompositor,
+  workingToSamples,
+  DIRECT_GAUSSIAN_MAX_SIGMA,
+  gaussianBlur,
+  flattenLayers,
+  findLayer,
+  mapLayer,
+  insertLayer,
+  isLayerLocked,
   blendTile,
   RasterCompositor,
   changedTiles,
@@ -4202,4 +4310,4 @@ export {
   warpSurface,
   compositeSurfaceOver
 };
-//# sourceMappingURL=chunk-UMVW2Q66.js.map
+//# sourceMappingURL=chunk-CLTTLLWA.js.map