@koda-sl/baker-cli 0.481.0 → 0.482.0

package/dist/{chunk-LJNYZLOH.js → chunk-GQ6JS5MR.js}

@@ -3283,6 +3283,29 @@ function renderRect(plate, rect, format, ratios) {
   return best ?? { ...rect, ratio: format };
 }
 
+// src/engine/nodes/local/lib/picture-memo.ts
+var ids = /* @__PURE__ */ new WeakMap();
+var nextId = 0;
+function pictureId(picture) {
+  const known = ids.get(picture);
+  if (known !== void 0) return known;
+  const id = nextId++;
+  ids.set(picture, id);
+  return id;
+}
+function remembered() {
+  const readings = /* @__PURE__ */ new WeakMap();
+  return (picture, what, read) => {
+    const known = readings.get(picture) ?? /* @__PURE__ */ new Map();
+    readings.set(picture, known);
+    const kept = known.get(what);
+    if (kept !== void 0) return kept;
+    const value = read();
+    known.set(what, value);
+    return value;
+  };
+}
+
 // src/engine/nodes/local/lib/words-band.ts
 var GROUND_REACH = 0.06;
 var LAID = 24;
@@ -3485,7 +3508,9 @@ function moveBand(g, move) {
   const dx = Math.round(move.dx * width);
   const dy = Math.round(move.dy * height);
   const data = Buffer.alloc(width * height * 3);
-  for (let i = 0; i < width * height; i++) g.out.data.copy(data, i * 3, i * g.out.channels, i * g.out.channels + 3);
+  if (g.out.channels === 3) g.out.data.copy(data, 0, 0, width * height * 3);
+  else
+    for (let i = 0; i < width * height; i++) g.out.data.copy(data, i * 3, i * g.out.channels, i * g.out.channels + 3);
   const shape = shapeOf(g, r);
   const edge = edgeLeft(r, dx, dy, width, height);
   const tone = edge ? toneOf(
@@ -3626,6 +3651,25 @@ async function fitPicture(image, fit) {
 
 // src/engine/nodes/local/lib/words-layer.ts
 var inSpans = (spans, fx, fy) => spans.some((s) => fx >= s.x0 && fx <= s.x1 && fy >= s.y0 && fy <= s.y1);
+function centresIn(lo, hi, size) {
+  const inside = new Uint8Array(size);
+  for (let t = 0; t < size; t++) {
+    const f = (t + 0.5) / size;
+    inside[t] = f >= lo && f <= hi ? 1 : 0;
+  }
+  return inside;
+}
+function spanMask(spans, width, height) {
+  const mask = new Uint8Array(width * height);
+  for (const s of spans) {
+    const across2 = centresIn(s.x0, s.x1, width);
+    const down = centresIn(s.y0, s.y1, height);
+    for (let y = 0; y < height; y++) {
+      if (down[y]) for (let x = 0; x < width; x++) mask[y * width + x] ||= across2[x] ?? 0;
+    }
+  }
+  return mask;
+}
 function taps(u, v, width, height) {
   const x = Math.min(width - 1, Math.max(0, u));
   const y = Math.min(height - 1, Math.max(0, v));
@@ -3663,7 +3707,10 @@ function shrink(g, edge) {
     const x = i % width * f;
     const y = Math.floor(i / width) * f;
     let sum = 0;
-    for (let k = 0; k < f * f; k++) sum += g.data[(y + Math.floor(k / f)) * g.width + x + k % f] ?? 0;
+    for (let j = 0; j < f; j++) {
+      const row = (y + j) * g.width + x;
+      for (let k = 0; k < f; k++) sum += g.data[row + k] ?? 0;
+    }
     data[i] = sum / (f * f);
   }
   return { data, width, height };
@@ -3681,19 +3728,34 @@ function judgedPixels(g, exclude) {
     if (x < mx || y < my || x >= g.width - mx || y >= g.height - my) continue;
     if (!inSpans(exclude, x / g.width, y / g.height)) out.push(i);
   }
-  return Int32Array.from(out);
+  const rows = [];
+  const starts = [];
+  out.forEach((i, j) => {
+    const y = Math.floor(i / g.width);
+    if (rows[rows.length - 1] === y) return;
+    rows.push(y);
+    starts.push(j);
+  });
+  starts.push(out.length);
+  return {
+    at: Int32Array.from(out),
+    xs: Int32Array.from(out, (i) => i % g.width),
+    rows: Int32Array.from(rows),
+    starts: Int32Array.from(starts)
+  };
 }
-function grayAt(g, u, v) {
-  const x = Math.min(g.width - 1.001, Math.max(0, u));
-  const y = Math.min(g.height - 1.001, Math.max(0, v));
-  const x0 = x | 0;
-  const y0 = y | 0;
-  const fx = x - x0;
-  const fy = y - y0;
-  const i = y0 * g.width + x0;
-  const top = (g.data[i] ?? 0) * (1 - fx) + (g.data[i + 1] ?? 0) * fx;
-  const bottom = (g.data[i + g.width] ?? 0) * (1 - fx) + (g.data[i + g.width + 1] ?? 0) * fx;
-  return top * (1 - fy) + bottom * fy;
+function axisOf(origin, scale, count, size) {
+  const near = new Int32Array(count);
+  const at2 = new Int32Array(count);
+  const frac = new Float64Array(count);
+  for (let t = 0; t < count; t++) {
+    const p = origin + scale * t;
+    near[t] = Math.min(size - 1, Math.max(0, Math.round(p)));
+    const q = Math.min(size - 1.001, Math.max(0, p));
+    at2[t] = q | 0;
+    frac[t] = q - (at2[t] ?? 0);
+  }
+  return { near, at: at2, frac };
 }
 var MISFIT_CAP = 40;
 var LINEUP_FLAT = 1.5;
@@ -3714,26 +3776,42 @@ function withFlat(g) {
   }
   return { ...g, flat };
 }
-function misfit(cut, render, judged, k, c, cap = MISFIT_CAP) {
+function misfit(cut, render, judged, k, c, cap = MISFIT_CAP, beat = Number.POSITIVE_INFINITY, above = Number.POSITIVE_INFINITY) {
   const cx = cut.width / 2;
   const cy = cut.height / 2;
   const ox = cx - c.scale * cx + c.dx * k;
   const oy = cy - c.scale * cy + c.dy * k;
-  const most = cap * cap;
-  let sum = 0;
-  let n = 0;
-  for (const i of judged) {
-    const x = i % cut.width;
-    const y = (i - x) / cut.width;
-    const u = ox + c.scale * x;
-    const v = oy + c.scale * y;
-    const at2 = Math.min(render.height - 1, Math.max(0, Math.round(v))) * render.width + Math.min(render.width - 1, Math.max(0, Math.round(u)));
-    if (render.flat?.[at2]) continue;
-    const d = (cut.data[i] ?? 0) - grayAt(render, u, v);
-    sum += Math.min(d * d, most);
-    n++;
+  const cols = axisOf(ox, c.scale, cut.width, render.width);
+  const rows = axisOf(oy, c.scale, cut.height, render.height);
+  const look = { cut, render, judged, cols, most: cap * cap };
+  const count = judged.at.length;
+  const acc = { sum: 0, n: 0 };
+  for (let r = 0; r < judged.rows.length; r++) {
+    const from = judged.starts[r] ?? 0;
+    const least = acc.sum / (acc.n + count - from);
+    if (least >= beat || least > above) return Number.POSITIVE_INFINITY;
+    rowMisfit(look, rows, judged.rows[r] ?? 0, from, judged.starts[r + 1] ?? count, acc);
+  }
+  return acc.n > 0 ? acc.sum / acc.n : Number.POSITIVE_INFINITY;
+}
+function bilinear(data, i, width, fx, fy) {
+  const top = (data[i] ?? 0) * (1 - fx) + (data[i + 1] ?? 0) * fx;
+  const bottom = (data[i + width] ?? 0) * (1 - fx) + (data[i + width + 1] ?? 0) * fx;
+  return top * (1 - fy) + bottom * fy;
+}
+function rowMisfit(s, rows, y, from, to, acc) {
+  const { width, data, flat } = s.render;
+  const { near, at: at2, frac } = s.cols;
+  const flatRow = (rows.near[y] ?? 0) * width;
+  const row = (rows.at[y] ?? 0) * width;
+  const fy = rows.frac[y] ?? 0;
+  for (let j = from; j < to; j++) {
+    const x = s.judged.xs[j] ?? 0;
+    if (flat?.[flatRow + (near[x] ?? 0)]) continue;
+    const d = (s.cut.data[s.judged.at[j] ?? 0] ?? 0) - bilinear(data, row + (at2[x] ?? 0), width, frac[x] ?? 0, fy);
+    acc.sum += Math.min(d * d, s.most);
+    acc.n++;
   }
-  return n > 0 ? sum / n : Number.POSITIVE_INFINITY;
 }
 var MAX_SHIFT = 0.03;
 var MAX_SCALE_OFF = 0.03;
@@ -3747,13 +3825,14 @@ function searchLevel(cut, render, k, level, centre, exclude) {
   const reach = level.reach ?? Math.ceil(MAX_SHIFT * Math.max(cut.width, cut.height));
   let best = centre;
   let score = Number.POSITIVE_INFINITY;
+  const atCentre = misfit(cut, render, judged, k, centre);
   const side = 2 * reach + 1;
   for (const ds of level.scales) {
     const scale = centre.scale + ds;
     if (Math.abs(scale - 1) > MAX_SCALE_OFF + 1e-9) continue;
     for (let s = 0; s < side * side; s++) {
       const c = { scale, dx: centre.dx + (s % side - reach) / k, dy: centre.dy + (Math.floor(s / side) - reach) / k };
-      const m = misfit(cut, render, judged, k, c);
+      const m = misfit(cut, render, judged, k, c, MISFIT_CAP, score, atCentre);
       if (m < score) {
         score = m;
         best = c;
@@ -3763,6 +3842,11 @@ function searchLevel(cut, render, k, level, centre, exclude) {
   return { best, score };
 }
 function registerToSource(render, cut, exclude) {
+  return lineUps(render, `${pictureId(cut)} ${JSON.stringify(exclude)}`, () => lineUp(render, cut, exclude));
+}
+var lineUps = remembered();
+var warps = remembered();
+function lineUp(render, cut, exclude) {
   const full = { cut: grayOf(cut), render: grayOf(render) };
   let best = { scale: 1, dx: 0, dy: 0 };
   let finest = { cut: full.cut, render: full.render, k: 1 };
@@ -3777,19 +3861,54 @@ function registerToSource(render, cut, exclude) {
   const residual = misfit(finest.cut, finest.render, judged, finest.k, best, Number.POSITIVE_INFINITY);
   return { ...best, residual: Math.sqrt(residual) };
 }
+function bilinearAxis(centre, scale, shift, size) {
+  const lo = new Int32Array(size);
+  const hi = new Int32Array(size);
+  const frac = new Float64Array(size);
+  for (let t = 0; t < size; t++) {
+    const p = Math.min(size - 1, Math.max(0, centre + scale * (t - centre) + shift));
+    lo[t] = Math.floor(p);
+    hi[t] = Math.min(size - 1, (lo[t] ?? 0) + 1);
+    frac[t] = p - (lo[t] ?? 0);
+  }
+  return { lo, hi, frac };
+}
 function warpToCut(render, fit) {
-  const { width, height, channels } = render;
+  return warps(render, `${fit.scale} ${fit.dx} ${fit.dy}`, () => warped(render, fit));
+}
+function warped(render, fit) {
+  const { width, height } = render;
   const out = Buffer.alloc(width * height * 3);
-  const cx = width / 2;
-  const cy = height / 2;
-  for (let i = 0; i < width * height; i++) {
-    const x = i % width;
-    const y = Math.floor(i / width);
-    const t = taps(cx + fit.scale * (x - cx) + fit.dx, cy + fit.scale * (y - cy) + fit.dy, width, height);
-    for (let c = 0; c < 3; c++) out[i * 3 + c] = Math.round(tapped(render.data, t, channels, c));
+  const cols = bilinearAxis(width / 2, fit.scale, fit.dx, width);
+  const rows = bilinearAxis(height / 2, fit.scale, fit.dy, height);
+  for (let y = 0; y < height; y++) {
+    const row = { y, top: (rows.lo[y] ?? 0) * width, bottom: (rows.hi[y] ?? 0) * width, fy: rows.frac[y] ?? 0 };
+    warpRow(render, out, cols, row);
   }
   return { data: out, width, height, channels: 3 };
 }
+function warpRow(render, out, cols, row) {
+  const { width, channels, data } = render;
+  const { fy } = row;
+  for (let x = 0; x < width; x++) {
+    const fx = cols.frac[x] ?? 0;
+    const w = [(1 - fx) * (1 - fy), fx * (1 - fy), (1 - fx) * fy, fx * fy];
+    const lo = cols.lo[x] ?? 0;
+    const hi = cols.hi[x] ?? 0;
+    const a = [
+      (row.top + lo) * channels,
+      (row.top + hi) * channels,
+      (row.bottom + lo) * channels,
+      (row.bottom + hi) * channels
+    ];
+    const o = (row.y * width + x) * 3;
+    for (let c = 0; c < 3; c++) {
+      out[o + c] = Math.round(
+        w[0] * (data[a[0] + c] ?? 0) + w[1] * (data[a[1] + c] ?? 0) + w[2] * (data[a[2] + c] ?? 0) + w[3] * (data[a[3] + c] ?? 0)
+      );
+    }
+  }
+}
 function emptyLayer(width, height) {
   return {
     width,
@@ -3869,7 +3988,7 @@ function cellStats(aligned, cut, words, grid) {
     const x = i % cut.width;
     const y = Math.floor(i / cut.width);
     const g = grid.cell(x, y);
-    const tone = !inSpans(words, (x + 0.5) / cut.width, (y + 0.5) / cut.height);
+    const tone = !words[i];
     const d = addPixel(s, aligned, cut, i, g, tone);
     s.pixelDiff[i] = d;
     s.diff[g] = (s.diff[g] ?? 0) + d;
@@ -3960,7 +4079,7 @@ function toneMisfit(aligned, cut, gains, words, grid) {
   for (let i = 0; i < cut.width * cut.height; i++) {
     const x = i % cut.width;
     const y = (i - x) / cut.width;
-    if (inSpans(words, (x + 0.5) / cut.width, (y + 0.5) / cut.height)) continue;
+    if (words[i]) continue;
     const g = grid.cell(x, y);
     let d = 0;
     for (let c = 0; c < 3; c++) {
@@ -3972,19 +4091,19 @@ function toneMisfit(aligned, cut, gains, words, grid) {
   }
   return sum.map((v, g) => count[g] ? v / (count[g] ?? 1) : 0);
 }
-function atCell(values, grid, x, y, stride = 1, c = 0) {
-  const t = taps((x + 0.5) / CELL - 0.5, (y + 0.5) / CELL - 0.5, grid.gw, grid.gh);
-  return tapped(values, t, stride, c, 1);
+function cellTaps(grid, x, y) {
+  return taps((x + 0.5) / CELL - 0.5, (y + 0.5) / CELL - 0.5, grid.gw, grid.gh);
 }
 function wordsLayer(aligned, cut, designed, opts = {}) {
   const { width, height } = cut;
   const grid = gridOf(width, height);
   const boxes = designed.map((b) => padded(b, width, height));
   const tight = designed.map((b) => ({ ...b }));
-  const stats = cellStats(aligned, cut, boxes, grid);
+  const inBoxes2 = spanMask(boxes, width, height);
+  const stats = cellStats(aligned, cut, inBoxes2, grid);
   const kept = keptChange(stats.diff, boxes, grid, TOUCH * width / height);
   const gains = smoothGains(toneGains(stats, grid), grid);
-  const misfit2 = opts.boxesOnly ? null : toneMisfit(aligned, cut, gains, boxes, grid);
+  const misfit2 = opts.boxesOnly ? null : toneMisfit(aligned, cut, gains, inBoxes2, grid);
   const tone = kept.tone.map((t, g) => t > 0 && misfit2 && (misfit2[g] ?? 0) < STRUCTURAL ? 1 : 0);
   const dropped = kept.tone.reduce((n, t, g) => n + (t > 0 && !tone[g] ? 1 : 0), 0);
   const reverted = kept.reverted + dropped / kept.tone.length;
@@ -3992,12 +4111,12 @@ function wordsLayer(aligned, cut, designed, opts = {}) {
     aligned,
     stats,
     grid,
-    boxes,
+    boxes: inBoxes2,
     tone,
     gains,
-    tight,
-    subjects: opts.subjects ?? [],
-    keepOut: opts.keepOut ?? []
+    tight: spanMask(tight, width, height),
+    subjects: spanMask(opts.subjects ?? [], width, height),
+    keepOut: spanMask(opts.keepOut ?? [], width, height)
   };
   const layer = emptyLayer(width, height);
   for (let i = 0; i < width * height; i++) setLayerPixel(layer, look, i);
@@ -4025,21 +4144,21 @@ function keptChange(diff, boxes, grid, touchY) {
 function setLayerPixel(layer, look, i) {
   const x = i % layer.width;
   const y = Math.floor(i / layer.width);
-  const fx = (x + 0.5) / layer.width;
-  const fy = (y + 0.5) / layer.height;
-  const onSubject = look.subjects.length > 0 && inSpans(look.subjects, fx, fy);
-  const inBox = inSpans(onSubject ? look.tight : look.boxes, fx, fy);
-  if (!inBox && inSpans(look.keepOut, fx, fy)) return;
-  const toned = look.tone[look.grid.cell(x, y)] ? atCell(look.tone, look.grid, x, y) : 0;
+  const onSubject = look.subjects[i] === 1;
+  const inBox = (onSubject ? look.tight : look.boxes)[i] === 1;
+  if (!inBox && look.keepOut[i]) return;
+  const near = look.tone[look.grid.cell(x, y)] ? cellTaps(look.grid, x, y) : void 0;
+  const toned = near ? tapped(look.tone, near, 1, 0, 1) : 0;
   const changed = ((look.stats.pixelDiff[i] ?? 0) - MATTE_LO) / (MATTE_HI - MATTE_LO);
   const matte = inBox ? Math.min(1, Math.max(0, changed)) : 0;
   const a = Math.max(matte, toned);
   if (a <= 0) return;
   layer.alpha[i] = a;
   layer.ink[i] = inBox ? 1 : 0;
+  const cells = near ?? cellTaps(look.grid, x, y);
   for (let c = 0; c < 3; c++) {
     layer.pixels[i * 3 + c] = look.aligned.data[i * look.aligned.channels + c] ?? 0;
-    layer.gain[i * 3 + c] = atCell(look.gains, look.grid, x, y, 3, c);
+    layer.gain[i * 3 + c] = tapped(look.gains, cells, 3, c, 1);
   }
 }
 function protectFaces(layer, faces) {
@@ -4236,17 +4355,33 @@ function owners(layer, moves) {
   const { width } = layer;
   const own = new Int16Array(width * layer.height).fill(-1);
   for (let i = 0; i < own.length; i++) if ((layer.alpha[i] ?? 0) > 0) own[i] = blockAt(layer, moves, i);
-  const stack = [...own.keys()].filter((i) => (own[i] ?? -1) >= 0);
-  const free = (n) => n >= 0 && n < own.length && (own[n] ?? -1) < 0 && (layer.alpha[n] ?? 0) > 0;
-  while (stack.length > 0) {
-    const i = stack.pop() ?? 0;
-    const x = i % width;
-    const open = [x > 0 ? i - 1 : -1, x < width - 1 ? i + 1 : -1, i - width, i + width].filter(free);
-    for (const n of open) own[n] = own[i] ?? -1;
-    stack.push(...open);
-  }
+  spreadOwners(own, layer.alpha, width);
   return own;
 }
+function spreadOwners(own, alpha, width) {
+  const { stack, seeds } = seedsOf(own);
+  let top = seeds;
+  const free = (n) => n >= 0 && n < own.length && (own[n] ?? -1) < 0 && (alpha[n] ?? 0) > 0;
+  while (top > 0) {
+    const i = stack[--top] ?? 0;
+    const block = own[i] ?? -1;
+    for (const n of touching(i, width)) {
+      if (!free(n)) continue;
+      own[n] = block;
+      stack[top++] = n;
+    }
+  }
+}
+function seedsOf(own) {
+  const stack = new Int32Array(own.length);
+  let seeds = 0;
+  for (let i = 0; i < own.length; i++) if ((own[i] ?? -1) >= 0) stack[seeds++] = i;
+  return { stack, seeds };
+}
+function touching(i, width) {
+  const x = i % width;
+  return [x > 0 ? i - 1 : -1, x < width - 1 ? i + 1 : -1, i - width, i + width];
+}
 function takePixel(out, to, layer, t) {
   const a = tapped(layer.alpha, t);
   if (a <= (out.alpha[to] ?? 0)) return;
@@ -4311,12 +4446,29 @@ function blurLine(src, out, start, step, n, r) {
     acc += (src[enter >= n - 1 ? last : start + enter * step] ?? 0) - (src[leave <= 0 ? start : start + leave * step] ?? 0);
   }
 }
+function blurColumns(src, out, width, height, r) {
+  const acc = new Float64Array(width);
+  const row = (k) => (k <= 0 ? 0 : k >= height - 1 ? height - 1 : k) * width;
+  for (let k = -r; k <= r; k++) {
+    const from = row(k);
+    for (let x = 0; x < width; x++) acc[x] = (acc[x] ?? 0) + (src[from + x] ?? 0);
+  }
+  for (let k = 0; k < height; k++) {
+    const to = k * width;
+    const enter = row(k + r + 1);
+    const leave = row(k - r);
+    for (let x = 0; x < width; x++) {
+      out[to + x] = (acc[x] ?? 0) / (2 * r + 1);
+      acc[x] = (acc[x] ?? 0) + ((src[enter + x] ?? 0) - (src[leave + x] ?? 0));
+    }
+  }
+}
 function boxBlur(src, width, height, r) {
   if (r < 1) return Float32Array.from(src);
   const along = new Float32Array(width * height);
   for (let y = 0; y < height; y++) blurLine(src, along, y * width, 1, width, r);
   const out = new Float32Array(width * height);
-  for (let x = 0; x < width; x++) blurLine(along, out, x, width, height, r);
+  blurColumns(along, out, width, height, r);
   return out;
 }
 var soften = (src, width, height, r) => boxBlur(boxBlur(src, width, height, r), width, height, r);
@@ -4337,14 +4489,16 @@ function flatOf2(img) {
     const o = i * img.channels;
     grey[i] = 0.299 * (img.data[o] ?? 0) + 0.587 * (img.data[o + 1] ?? 0) + 0.114 * (img.data[o + 2] ?? 0);
   }
+  const squares = new Float32Array(grey.length);
+  for (let i = 0; i < grey.length; i++) squares[i] = (grey[i] ?? 0) * (grey[i] ?? 0);
   const mean = boxBlur(grey, width, height, 2);
-  const square = boxBlur(
-    grey.map((v) => v * v),
-    width,
-    height,
-    2
-  );
-  return Uint8Array.from(mean, (m, i) => Math.sqrt(Math.max(0, (square[i] ?? 0) - m * m)) < FLAT2 ? 1 : 0);
+  const square = boxBlur(squares, width, height, 2);
+  const flat = new Uint8Array(mean.length);
+  for (let i = 0; i < mean.length; i++) {
+    const m = mean[i] ?? 0;
+    flat[i] = Math.sqrt(Math.max(0, (square[i] ?? 0) - m * m)) < FLAT2 ? 1 : 0;
+  }
+  return flat;
 }
 var gridOver = (width, height, size) => ({
   size,
@@ -4402,7 +4556,15 @@ function flood2(seeds, open, grid) {
 function surfaceOf(flat, structure, width, height, words) {
   const grid = gridOver(width, height, SURFACE_CELL);
   const reached = flood2(wordCells(words, width, height, grid), laidCells(flat, structure, width, grid), grid);
-  return Uint8Array.from(structure, (d, i) => reached[cellOf(grid, i, width)] && d > MOVED ? 1 : 0);
+  const surface = new Uint8Array(structure.length);
+  for (let y = 0; y < height; y++) {
+    const row = Math.floor(y / grid.size) * grid.gw;
+    for (let x = 0; x < width; x++) {
+      const i = y * width + x;
+      surface[i] = reached[row + Math.floor(x / grid.size)] && (structure[i] ?? 0) > MOVED ? 1 : 0;
+    }
+  }
+  return surface;
 }
 var GROUND_LINE = 3;
 var CARD_TONE = 16;
@@ -4492,6 +4654,8 @@ function trustOf(width, height, words) {
   }
   return trust;
 }
+var cutPlanes = remembered();
+var shrunkCuts = remembered();
 function planesOf(img, r1) {
   const own = [0, 1, 2].map((c) => channelOf(img, c));
   return {
@@ -4504,13 +4668,11 @@ var LIGHT_CELL = 0.015;
 var LIGHT_REACH = 3;
 function cellSums(a, b, open, width, grid) {
   const sums = new Float32Array(grid.gw * grid.gh * 7);
+  const own = [...a.own, ...b.own];
   for (let i = 0; i < open.length; i++) {
     if (!open[i]) continue;
     const g = cellOf(grid, i, width) * 7;
-    for (let c = 0; c < 3; c++) {
-      sums[g + c] = (sums[g + c] ?? 0) + (a.own[c]?.[i] ?? 0);
-      sums[g + 3 + c] = (sums[g + 3 + c] ?? 0) + (b.own[c]?.[i] ?? 0);
-    }
+    for (let c = 0; c < 6; c++) sums[g + c] = (sums[g + c] ?? 0) + (own[c]?.[i] ?? 0);
     sums[g + 6] = (sums[g + 6] ?? 0) + 1;
   }
   return sums;
@@ -4527,14 +4689,24 @@ function cellRatios(a, b, open, width, grid) {
   }
   return ratio;
 }
-function medianNear(values, grid, g, c, reach) {
-  const near = cellsNear(grid, g, reach).map((n) => values[n * 3 + c] ?? Number.NaN).filter((v) => !Number.isNaN(v)).sort((p, q) => p - q);
-  return near.length > 0 ? near[Math.floor(near.length / 2)] ?? 1 : 1;
+function medianNear(values, near, c, scratch) {
+  let known = 0;
+  for (const n of near) {
+    const v = values[n * 3 + c] ?? Number.NaN;
+    if (!Number.isNaN(v)) scratch[known++] = v;
+  }
+  if (known === 0) return 1;
+  const sorted = scratch.subarray(0, known).sort();
+  return sorted[Math.floor(known / 2)] ?? 1;
 }
 function medianLight(ratio, grid) {
   const cells = grid.gw * grid.gh;
   const median = new Float32Array(cells * 3);
-  for (let k = 0; k < cells * 3; k++) median[k] = medianNear(ratio, grid, Math.floor(k / 3), k % 3, LIGHT_REACH);
+  const scratch = new Float64Array((2 * LIGHT_REACH + 1) ** 2);
+  for (let g = 0; g < cells; g++) {
+    const near = cellsNear(grid, g, LIGHT_REACH);
+    for (let c = 0; c < 3; c++) median[g * 3 + c] = medianNear(ratio, near, c, scratch);
+  }
   const smooth = new Float32Array(cells * 3);
   for (let k = 0; k < cells * 3; k++) {
     const near = cellsNear(grid, Math.floor(k / 3), 1);
@@ -4546,16 +4718,19 @@ function lightOf(a, b, open, width, height) {
   const grid = gridOver(width, height, Math.max(8, Math.round(width * LIGHT_CELL)));
   const light = medianLight(cellRatios(a, b, open, width, grid), grid);
   const gain = enlarge(light, { width: grid.gw, height: grid.gh }, { width, height }, 3);
-  return gain.map((g) => Math.min(GAIN_MAX2, Math.max(1 / GAIN_MAX2, g)));
+  const kept = new Float32Array(gain.length);
+  for (let i = 0; i < gain.length; i++) kept[i] = Math.min(GAIN_MAX2, Math.max(1 / GAIN_MAX2, gain[i] ?? 0));
+  return kept;
 }
 function compared(a, b, gain, n) {
   const structure = new Float32Array(n);
   const detail = new Float32Array(n);
   for (let c = 0; c < 3; c++) {
+    const [aLow, bLow, aFine, bFine] = [a.low[c], b.low[c], a.fine[c], b.fine[c]];
     for (let i = 0; i < n; i++) {
       const g = gain[i * 3 + c] ?? 1;
-      structure[i] = Math.max(structure[i] ?? 0, Math.abs((a.low[c]?.[i] ?? 0) - g * (b.low[c]?.[i] ?? 0)));
-      detail[i] = Math.max(detail[i] ?? 0, Math.abs((a.fine[c]?.[i] ?? 0) - g * (b.fine[c]?.[i] ?? 0)));
+      structure[i] = Math.max(structure[i] ?? 0, Math.abs((aLow?.[i] ?? 0) - g * (bLow?.[i] ?? 0)));
+      detail[i] = Math.max(detail[i] ?? 0, Math.abs((aFine?.[i] ?? 0) - g * (bFine?.[i] ?? 0)));
     }
   }
   return { structure, detail };
@@ -4564,7 +4739,7 @@ function renderDiff(aligned, cut, words) {
   const { width, height } = cut;
   const r1 = Math.max(2, Math.round(width * STRUCTURE_RADIUS));
   const a = planesOf(aligned, r1);
-  const b = planesOf(cut, r1);
+  const b = cutPlanes(cut, String(r1), () => planesOf(cut, r1));
   const gain = lightOf(a, b, trustOf(width, height, words), width, height);
   const { structure, detail } = compared(a, b, gain, width * height);
   const flat = flatOf2(aligned);
@@ -4633,9 +4808,11 @@ function greyOf(img, f) {
     const x = i % width * f;
     const y = Math.floor(i / width) * f;
     let sum = 0;
-    for (let k = 0; k < f * f; k++) {
-      const o = ((y + Math.floor(k / f)) * img.width + x + k % f) * img.channels;
-      sum += 0.299 * (img.data[o] ?? 0) + 0.587 * (img.data[o + 1] ?? 0) + 0.114 * (img.data[o + 2] ?? 0);
+    for (let j = 0; j < f; j++) {
+      for (let k = 0; k < f; k++) {
+        const o = ((y + j) * img.width + x + k) * img.channels;
+        sum += 0.299 * (img.data[o] ?? 0) + 0.587 * (img.data[o + 1] ?? 0) + 0.114 * (img.data[o + 2] ?? 0);
+      }
     }
     data[i] = sum / (f * f);
   }
@@ -4810,10 +4987,15 @@ function keptShare(diff, words) {
 }
 function cropRaw(img, rect) {
   const data = Buffer.alloc(rect.width * rect.height * 3);
-  for (let i = 0; i < rect.width * rect.height; i++) {
-    const x = i % rect.width;
-    const from = ((rect.y + (i - x) / rect.width) * img.width + rect.x + x) * img.channels;
-    img.data.copy(data, i * 3, from, from + 3);
+  for (let y = 0; y < rect.height; y++) {
+    const from = ((rect.y + y) * img.width + rect.x) * img.channels;
+    if (img.channels === 3) {
+      img.data.copy(data, y * rect.width * 3, from, from + rect.width * 3);
+      continue;
+    }
+    for (let x = 0; x < rect.width; x++) {
+      for (let c = 0; c < 3; c++) data[(y * rect.width + x) * 3 + c] = img.data[from + x * img.channels + c] ?? 0;
+    }
   }
   return { data, width: rect.width, height: rect.height, channels: 3 };
 }
@@ -4843,8 +5025,10 @@ function shrinkRaw(img, f) {
     const y = Math.floor(i / width) * f;
     for (let c = 0; c < 3; c++) {
       let sum = 0;
-      for (let k = 0; k < f * f; k++)
-        sum += img.data[((y + Math.floor(k / f)) * img.width + x + k % f) * img.channels + c] ?? 0;
+      for (let j = 0; j < f; j++) {
+        const row = ((y + j) * img.width + x) * img.channels + c;
+        for (let k = 0; k < f; k++) sum += img.data[row + k * img.channels] ?? 0;
+      }
       data[i * 3 + c] = Math.round(sum / (f * f));
     }
   }
@@ -4863,15 +5047,16 @@ function axisTaps(from, to) {
   return { near, far, t };
 }
 function enlargeRow(values, out, xs, row, stride) {
-  const at2 = (i) => values[i] ?? 0;
+  const { top, bottom, fy } = row;
   for (let x = 0; x < row.width; x++) {
     const left = xs.near[x] ?? 0;
     const right = xs.far[x] ?? 0;
     const fx = xs.t[x] ?? 0;
+    const o = (row.y * row.width + x) * stride;
     for (let c = 0; c < stride; c++) {
-      const upper = at2((row.top + left) * stride + c) * (1 - fx) + at2((row.top + right) * stride + c) * fx;
-      const lower = at2((row.bottom + left) * stride + c) * (1 - fx) + at2((row.bottom + right) * stride + c) * fx;
-      out[(row.y * row.width + x) * stride + c] = upper * (1 - row.fy) + lower * row.fy;
+      const upper = (values[(top + left) * stride + c] ?? 0) * (1 - fx) + (values[(top + right) * stride + c] ?? 0) * fx;
+      const lower = (values[(bottom + left) * stride + c] ?? 0) * (1 - fx) + (values[(bottom + right) * stride + c] ?? 0) * fx;
+      out[o + c] = upper * (1 - fy) + lower * fy;
     }
   }
 }
@@ -5057,7 +5242,7 @@ function takeWhole(input) {
     aligned,
     cut,
     out,
-    gain,
+    gain: gain(),
     judged: judging.judged,
     frame,
     words: input.words,
@@ -5075,7 +5260,7 @@ function judge(input, read, fit, aligned) {
   const { width, height } = cut;
   const words = read.designed.map((b) => padded(b, width, height));
   const shrink2 = Math.max(1, Math.round(width / JUDGED_WIDTH));
-  const judged = shrink2 > 1 ? { aligned: shrinkRaw(aligned, shrink2), cut: shrinkRaw(cut, shrink2) } : { aligned, cut };
+  const judged = shrink2 > 1 ? { aligned: shrinkRaw(aligned, shrink2), cut: shrunkCuts(cut, String(shrink2), () => shrinkRaw(cut, shrink2)) } : { aligned, cut };
   const diff = renderDiff(judged.aligned, judged.cut, words);
   const drifts = input.subjects.map((s) => ({ subject: s, ...subjectDrift(diff, s, words) }));
   const inFrame = (b) => ({
@@ -5130,8 +5315,12 @@ function putBack(input, read, aligned, j) {
   const back = input.subjects.filter((s) => restored.includes(s.label));
   const zones = [...back, ...read.inScene.map((b) => padded(b, full.width, full.height))];
   const covered = j.drifts.filter((d) => (d.subject.kind === "product" || d.subject.kind === "animal") && d.shown < SHOWN_MIN).map((d) => d.subject.label);
-  const gain = enlarge(j.diff.gain, j.diff, full, 3);
-  let out = zones.length === 0 ? aligned : restoreSubjects(aligned, cut, gain, enlarge(restoreMask(j.diff, zones, j.words), j.diff, full, 1));
+  let enlarged;
+  const gain = () => {
+    enlarged ??= enlarge(j.diff.gain, j.diff, full, 3);
+    return enlarged;
+  };
+  let out = zones.length === 0 ? aligned : restoreSubjects(aligned, cut, gain(), enlarge(restoreMask(j.diff, zones, j.words), j.diff, full, 1));
   for (const r of j.relocated) out = putMoved(out, cut, r, j);
   const moved = j.relocated.map((r) => r.subject.label);
   return { out, gain, taken: { restored: [.../* @__PURE__ */ new Set([...restored, ...moved])], covered } };
@@ -5164,7 +5353,8 @@ function movedBox(box, place) {
 function cutMoved(cut, box, place) {
   const { width, height } = cut;
   const out = Buffer.alloc(width * height * 3);
-  for (let i = 0; i < width * height; i++) cut.data.copy(out, i * 3, i * cut.channels, i * cut.channels + 3);
+  if (cut.channels === 3) cut.data.copy(out, 0, 0, width * height * 3);
+  else for (let i = 0; i < width * height; i++) cut.data.copy(out, i * 3, i * cut.channels, i * cut.channels + 3);
   const to = movedBox(box, place);
   const margin = (ZONE_MARGIN + FEATHER) * Math.max((to.x1 - to.x0) * width, (to.y1 - to.y0) * height) + 4;
   const cx = (box.x0 + box.x1) / 2 * width;
@@ -8658,4 +8848,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-LJNYZLOH.js.map
+//# sourceMappingURL=chunk-GQ6JS5MR.js.map