@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/dist/chunk-11v28977.js

@@ -0,0 +1,1575 @@
+import {
+  Ts23dError2,
+  notImplemented2,
+  compile2,
+  encodePng2,
+  sub2,
+  dot2,
+  cross2,
+  normalize2,
+  worldTransforms2,
+  toWorld2,
+  rotateZ2,
+  worldMeshes2
+} from "./chunk-4ddzsqtc.js";
+import {
+  DEFAULT_SHEET2,
+  paintTrimSheet2
+} from "./chunk-kvcep7ft.js";
+
+// src/render/camera.ts
+function basis(azDeg, elDeg) {
+  const az = azDeg * Math.PI / 180;
+  const el = elDeg * Math.PI / 180;
+  const dir = [Math.cos(el) * Math.cos(az), Math.cos(el) * Math.sin(az), Math.sin(el)];
+  const f = [-dir[0], -dir[1], -dir[2]];
+  const rl = Math.hypot(f[1], f[0]) || 1;
+  const r = [f[1] / rl, -f[0] / rl, 0];
+  const u = [r[1] * f[2] - r[2] * f[1], r[2] * f[0] - r[0] * f[2], r[0] * f[1] - r[1] * f[0]];
+  return { dir, r, u, f };
+}
+function project(c, x, y, z) {
+  const dx = x - c.eye[0];
+  const dy = y - c.eye[1];
+  const dz = z - c.eye[2];
+  const w = dx * c.f[0] + dy * c.f[1] + dz * c.f[2];
+  const sx = dx * c.r[0] + dy * c.r[1] + dz * c.r[2];
+  const sy = dx * c.u[0] + dy * c.u[1] + dz * c.u[2];
+  return [c.cx + sx / w * c.focal, c.cy - sy / w * c.focal, w];
+}
+function frameOrbit(points, o, width, height) {
+  const { dir, r, u, f } = basis(o.azDeg, o.elDeg);
+  const stride = Math.max(1, Math.floor(points.length / 3 / 20000)) * 3;
+  let lo = [Infinity, Infinity, Infinity];
+  let hi = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0;i < points.length; i += 3)
+    for (let k = 0;k < 3; k++) {
+      const v = points[i + k] ?? 0;
+      lo[k] = Math.min(lo[k] ?? 0, v);
+      hi[k] = Math.max(hi[k] ?? 0, v);
+    }
+  if (points.length === 0) {
+    lo = [-0.5, -0.5, -0.5];
+    hi = [0.5, 0.5, 0.5];
+  }
+  const target = [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2];
+  const radius = Math.max(Math.hypot(hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]) / 2, 0.05);
+  const tanY = Math.tan(o.fovDeg * Math.PI / 360);
+  const focal = height / 2 / tanY;
+  let dist = radius / Math.sin(Math.atan(tanY)) + radius;
+  const at = (d) => ({
+    eye: [target[0] + dir[0] * d, target[1] + dir[1] * d, target[2] + dir[2] * d],
+    r,
+    u,
+    f,
+    focal,
+    cx: width / 2,
+    cy: height / 2,
+    width,
+    height
+  });
+  for (let iter = 0;iter < 6; iter++) {
+    const cam = at(dist);
+    let x0 = Infinity;
+    let x1 = -Infinity;
+    let y0 = Infinity;
+    let y1 = -Infinity;
+    for (let i = 0;i < points.length; i += stride) {
+      const p = project(cam, points[i] ?? 0, points[i + 1] ?? 0, points[i + 2] ?? 0);
+      x0 = Math.min(x0, p[0]);
+      x1 = Math.max(x1, p[0]);
+      y0 = Math.min(y0, p[1]);
+      y1 = Math.max(y1, p[1]);
+    }
+    if (!Number.isFinite(x0))
+      break;
+    const k = dist / focal;
+    const ox = ((x0 + x1) / 2 - width / 2) * k;
+    const oy = -((y0 + y1) / 2 - height / 2) * k;
+    for (let a = 0;a < 3; a++)
+      target[a] = (target[a] ?? 0) + (r[a] ?? 0) * ox + (u[a] ?? 0) * oy;
+    const need = Math.max((x1 - x0) / (width * o.fill), (y1 - y0) / (height * o.fill));
+    dist = Math.max(dist * need ** 0.85, radius * 1.05);
+  }
+  return at(dist);
+}
+function zoomWindow(c, nx, ny, k) {
+  return {
+    ...c,
+    focal: c.focal * k,
+    cx: c.width / 2 - (nx * c.width - c.cx) * k,
+    cy: c.height / 2 - (ny * c.height - c.cy) * k
+  };
+}
+function scaled(c, s) {
+  return {
+    ...c,
+    focal: c.focal * s,
+    cx: c.cx * s,
+    cy: c.cy * s,
+    width: c.width * s,
+    height: c.height * s
+  };
+}
+
+// src/render/depth-map.ts
+function mapAxes(dir) {
+  const up = Math.abs(dir[2]) > 0.99 ? [1, 0, 0] : [0, 0, 1];
+  let r = [
+    up[1] * dir[2] - up[2] * dir[1],
+    up[2] * dir[0] - up[0] * dir[2],
+    up[0] * dir[1] - up[1] * dir[0]
+  ];
+  const l = Math.hypot(r[0], r[1], r[2]) || 1;
+  r = [r[0] / l, r[1] / l, r[2] / l];
+  const u = [
+    dir[1] * r[2] - dir[2] * r[1],
+    dir[2] * r[0] - dir[0] * r[2],
+    dir[0] * r[1] - dir[1] * r[0]
+  ];
+  return { r, u };
+}
+function fitFrame(s, dir) {
+  const { r, u } = mapAxes(dir);
+  let r0 = Infinity;
+  let r1 = -Infinity;
+  let u0 = Infinity;
+  let u1 = -Infinity;
+  const P = s.positions;
+  for (let i = 0;i < P.length; i += 3) {
+    const x = P[i] ?? 0;
+    const y = P[i + 1] ?? 0;
+    const z = P[i + 2] ?? 0;
+    const a = x * r[0] + y * r[1] + z * r[2];
+    const b = x * u[0] + y * u[1] + z * u[2];
+    if (a < r0)
+      r0 = a;
+    if (a > r1)
+      r1 = a;
+    if (b < u0)
+      u0 = b;
+    if (b > u1)
+      u1 = b;
+  }
+  if (!Number.isFinite(r0))
+    return { cr: 0, cu: 0, half: 1 };
+  return { cr: (r0 + r1) / 2, cu: (u0 + u1) / 2, half: Math.max(r1 - r0, u1 - u0, 0.001) * 0.51 };
+}
+function depthMap(s, dir, size, frame = fitFrame(s, dir), alpha) {
+  const { r, u } = mapAxes(dir);
+  const k = size / (2 * frame.half);
+  const r0 = frame.cr - frame.half;
+  const u1 = frame.cu + frame.half;
+  const data = new Float32Array(size * size).fill(-Infinity);
+  const nv = s.positions.length / 3;
+  const X = new Float32Array(nv);
+  const Y = new Float32Array(nv);
+  const D = new Float32Array(nv);
+  const P = s.positions;
+  for (let v = 0;v < nv; v++) {
+    const x = P[v * 3] ?? 0;
+    const y = P[v * 3 + 1] ?? 0;
+    const z = P[v * 3 + 2] ?? 0;
+    X[v] = (x * r[0] + y * r[1] + z * r[2] - r0) * k;
+    Y[v] = (u1 - (x * u[0] + y * u[1] + z * u[2])) * k;
+    D[v] = x * dir[0] + y * dir[1] + z * dir[2];
+  }
+  const I = s.indices;
+  for (let t = 0;t < s.triangles; t++) {
+    const a = I[t * 3] ?? 0;
+    const b = I[t * 3 + 1] ?? 0;
+    const c = I[t * 3 + 2] ?? 0;
+    const ax = X[a] ?? 0;
+    const ay = Y[a] ?? 0;
+    const bx = X[b] ?? 0;
+    const by = Y[b] ?? 0;
+    const cx = X[c] ?? 0;
+    const cy = Y[c] ?? 0;
+    const area = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+    if (Math.abs(area) < 0.000000000001)
+      continue;
+    const inv = 1 / area;
+    const da = D[a] ?? 0;
+    const db = D[b] ?? 0;
+    const dc = D[c] ?? 0;
+    const cut = alpha !== undefined && s.surface[t] === 1;
+    const lx = ax < bx ? Math.min(ax, cx) : Math.min(bx, cx);
+    const hx = ax > bx ? Math.max(ax, cx) : Math.max(bx, cx);
+    const ly = ay < by ? Math.min(ay, cy) : Math.min(by, cy);
+    const hy = ay > by ? Math.max(ay, cy) : Math.max(by, cy);
+    const minX = lx < 0 ? 0 : Math.floor(lx);
+    const maxX = hx > size - 1 ? size - 1 : Math.ceil(hx);
+    const minY = ly < 0 ? 0 : Math.floor(ly);
+    const maxY = hy > size - 1 ? size - 1 : Math.ceil(hy);
+    const A0 = (by - cy) * inv;
+    const B0 = (cx - bx) * inv;
+    const A1 = (cy - ay) * inv;
+    const B1 = (ax - cx) * inv;
+    const C0 = (bx * cy - by * cx) * inv;
+    const C1 = (cx * ay - cy * ax) * inv;
+    for (let y = minY;y <= maxY; y++) {
+      const py = y + 0.5;
+      let w0 = C0 + A0 * (minX + 0.5) + B0 * py;
+      let w1 = C1 + A1 * (minX + 0.5) + B1 * py;
+      for (let x = minX;x <= maxX; x++, w0 += A0, w1 += A1) {
+        if (w0 < 0 || w1 < 0 || w0 + w1 > 1)
+          continue;
+        const d = w0 * da + w1 * db + (1 - w0 - w1) * dc;
+        const i = y * size + x;
+        if (d <= (data[i] ?? 0))
+          continue;
+        if (cut && alpha && !alpha(t, w1, 1 - w0 - w1))
+          continue;
+        data[i] = d;
+      }
+    }
+  }
+  return { size, data, dir, r, u, r0, u1, k };
+}
+function visibility(m, x, y, z, bias, taps) {
+  const tx = (x * m.r[0] + y * m.r[1] + z * m.r[2] - m.r0) * m.k;
+  const ty = (m.u1 - (x * m.u[0] + y * m.u[1] + z * m.u[2])) * m.k;
+  const d = x * m.dir[0] + y * m.dir[1] + z * m.dir[2] + bias;
+  const s = m.size;
+  let lit = 0;
+  for (let i = 0;i < taps.length; i += 2) {
+    const px = Math.floor(tx + (taps[i] ?? 0));
+    const py = Math.floor(ty + (taps[i + 1] ?? 0));
+    if (px < 0 || py < 0 || px >= s || py >= s || d >= (m.data[py * s + px] ?? 0))
+      lit++;
+  }
+  return lit * 2 / taps.length;
+}
+function openness(m, x, y, z, bias, reach) {
+  const px = Math.floor((x * m.r[0] + y * m.r[1] + z * m.r[2] - m.r0) * m.k);
+  const py = Math.floor((m.u1 - (x * m.u[0] + y * m.u[1] + z * m.u[2])) * m.k);
+  const s = m.size;
+  if (px < 0 || py < 0 || px >= s || py >= s)
+    return 1;
+  const gap = (m.data[py * s + px] ?? 0) - (x * m.dir[0] + y * m.dir[1] + z * m.dir[2] + bias);
+  return gap <= 0 ? 1 : gap >= reach ? 1 : gap / reach;
+}
+
+// src/render/texture.ts
+var SRGB = new Float32Array(256).map((_, i) => {
+  const v = i / 255;
+  return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+});
+function chain(src, size, decode) {
+  const top = new Float32Array(size * size * 4);
+  for (let i = 0;i < top.length; i++)
+    top[i] = decode(i & 3, src[i] ?? 0);
+  const out = [{ size, data: top }];
+  let cur = out[0];
+  while (cur && cur.size > 4) {
+    const s = cur.size / 2;
+    const d = new Float32Array(s * s * 4);
+    const p = cur.data;
+    const w = cur.size;
+    for (let y = 0;y < s; y++)
+      for (let x = 0;x < s; x++)
+        for (let c = 0;c < 4; c++) {
+          const a = (2 * y * w + 2 * x << 2) + c;
+          const b = a + w * 4;
+          d[(y * s + x << 2) + c] = ((p[a] ?? 0) + (p[a + 4] ?? 0) + (p[b] ?? 0) + (p[b + 4] ?? 0)) * 0.25;
+        }
+    cur = { size: s, data: d };
+    out.push(cur);
+  }
+  return out;
+}
+var cache = new WeakMap;
+function sheetTextures(sheet) {
+  const hit = cache.get(sheet);
+  if (hit)
+    return hit;
+  const t = {
+    size: sheet.size,
+    albedo: chain(sheet.albedo, sheet.size, (c, v) => c === 3 ? v / 255 : SRGB[v] ?? 0),
+    normal: chain(sheet.normal, sheet.size, (c, v) => c === 3 ? 1 : v / 127.5 - 1),
+    orm: chain(sheet.orm, sheet.size, (_c, v) => v / 255)
+  };
+  cache.set(sheet, t);
+  return t;
+}
+function sample(mips, level, u, v, out) {
+  const m = mips[Math.min(mips.length - 1, Math.max(0, level))] ?? mips[0];
+  if (!m)
+    return;
+  const s = m.size;
+  const x = u * s - 0.5;
+  const y = Math.min(s - 1, Math.max(0, v * s - 0.5));
+  const xf = Math.floor(x);
+  const yf = Math.floor(y);
+  const fx = x - xf;
+  const fy = y - yf;
+  const x0 = (xf % s + s) % s;
+  const x1 = (x0 + 1) % s;
+  const y0 = yf;
+  const y1 = Math.min(s - 1, yf + 1);
+  const d = m.data;
+  const a = y0 * s + x0 << 2;
+  const b = y0 * s + x1 << 2;
+  const c = y1 * s + x0 << 2;
+  const e = y1 * s + x1 << 2;
+  const w0 = (1 - fx) * (1 - fy);
+  const w1 = fx * (1 - fy);
+  const w2 = (1 - fx) * fy;
+  const w3 = fx * fy;
+  for (let k = 0;k < 4; k++)
+    out[k] = (d[a + k] ?? 0) * w0 + (d[b + k] ?? 0) * w1 + (d[c + k] ?? 0) * w2 + (d[e + k] ?? 0) * w3;
+}
+
+// src/render/shade.ts
+var ONE_TAP = new Float32Array([0, 0]);
+var hyp = (x, y, z) => Math.sqrt(x * x + y * y + z * z);
+var texel = new Float32Array(4);
+function skyOpen(c, p, n) {
+  let open = 0;
+  let total = 0;
+  const dirs = c.rig.skyDirs;
+  for (let k = 0;k < dirs.length; k++) {
+    const d = dirs[k];
+    const m = c.aoMaps[k];
+    if (!d || !m)
+      continue;
+    const w = 0.5 + 0.5 * ((n[0] ?? 0) * d[0] + (n[1] ?? 0) * d[1] + (n[2] ?? 0) * d[2]);
+    if (w <= 0)
+      continue;
+    const off = 1.5 / m.k;
+    const v = openness(m, (p[0] ?? 0) + (n[0] ?? 0) * off, (p[1] ?? 0) + (n[1] ?? 0) * off, (p[2] ?? 0) + (n[2] ?? 0) * off, 2 / m.k, c.reach);
+    open += w * v;
+    total += w;
+  }
+  return total > 0 ? open / total : 1;
+}
+function sunVisible(c, p, n, set) {
+  const m = c.sunMap;
+  const off = 1.2 / m.k;
+  return visibility(m, (p[0] ?? 0) + (n[0] ?? 0) * off, (p[1] ?? 0) + (n[1] ?? 0) * off, (p[2] ?? 0) + (n[2] ?? 0) * off, 1.5 / m.k, c.pcf[set & 3] ?? ONE_TAP);
+}
+var pos = [0, 0, 0];
+var nrm = [0, 0, 0];
+var geo = [0, 0, 0];
+function shadeSample(c, t, b1, b2, mip, set, out) {
+  const s = c.scene;
+  const ia = (s.indices[t * 3] ?? 0) * 3;
+  const ib = (s.indices[t * 3 + 1] ?? 0) * 3;
+  const ic = (s.indices[t * 3 + 2] ?? 0) * 3;
+  const b0 = 1 - b1 - b2;
+  const P = s.positions;
+  const N = s.normals;
+  const C = s.colors;
+  for (let k = 0;k < 3; k++) {
+    pos[k] = (P[ia + k] ?? 0) * b0 + (P[ib + k] ?? 0) * b1 + (P[ic + k] ?? 0) * b2;
+    nrm[k] = (N[ia + k] ?? 0) * b0 + (N[ib + k] ?? 0) * b1 + (N[ic + k] ?? 0) * b2;
+  }
+  const ua = ia / 3 * 2;
+  const ub = ib / 3 * 2;
+  const uc = ic / 3 * 2;
+  const U = s.uvs;
+  const u = (U[ua] ?? 0) * b0 + (U[ub] ?? 0) * b1 + (U[uc] ?? 0) * b2;
+  const v = (U[ua + 1] ?? 0) * b0 + (U[ub + 1] ?? 0) * b1 + (U[uc + 1] ?? 0) * b2;
+  const e = c.cam.eye;
+  let vx = e[0] - (pos[0] ?? 0);
+  let vy = e[1] - (pos[1] ?? 0);
+  let vz = e[2] - (pos[2] ?? 0);
+  const vl = hyp(vx, vy, vz) || 1;
+  vx /= vl;
+  vy /= vl;
+  vz /= vl;
+  let nl = hyp(nrm[0] ?? 0, nrm[1] ?? 0, nrm[2] ?? 1) || 1;
+  if ((nrm[0] ?? 0) * vx + (nrm[1] ?? 0) * vy + (nrm[2] ?? 0) * vz < 0)
+    nl = -nl;
+  for (let k = 0;k < 3; k++) {
+    nrm[k] = (nrm[k] ?? 0) / nl;
+    geo[k] = nrm[k] ?? 0;
+  }
+  const T = s.tangents;
+  const to = t * 6;
+  const tx = T[to] ?? 0;
+  const ty = T[to + 1] ?? 0;
+  const tz = T[to + 2] ?? 0;
+  if (tx !== 0 || ty !== 0 || tz !== 0) {
+    sample(c.tex.normal, mip, u, v, texel);
+    const mx = texel[0] ?? 0;
+    const my = texel[1] ?? 0;
+    const mz = texel[2] ?? 1;
+    const n0 = nrm[0] ?? 0;
+    const n1 = nrm[1] ?? 0;
+    const n2 = nrm[2] ?? 0;
+    const bx = T[to + 3] ?? 0;
+    const by = T[to + 4] ?? 0;
+    const bz = T[to + 5] ?? 0;
+    const px = tx * mx + bx * my + n0 * mz;
+    const py = ty * mx + by * my + n1 * mz;
+    const pz = tz * mx + bz * my + n2 * mz;
+    const pl = hyp(px, py, pz) || 1;
+    nrm[0] = px / pl;
+    nrm[1] = py / pl;
+    nrm[2] = pz / pl;
+  }
+  sample(c.tex.albedo, mip, u, v, texel);
+  const surf = s.surface[t] ?? 0;
+  const glass = surf === 2;
+  let ar = (texel[0] ?? 1) * ((C[ia] ?? 1) * b0 + (C[ib] ?? 1) * b1 + (C[ic] ?? 1) * b2);
+  let ag = (texel[1] ?? 1) * ((C[ia + 1] ?? 1) * b0 + (C[ib + 1] ?? 1) * b1 + (C[ic + 1] ?? 1) * b2);
+  let ab = (texel[2] ?? 1) * ((C[ia + 2] ?? 1) * b0 + (C[ib + 2] ?? 1) * b1 + (C[ic + 2] ?? 1) * b2);
+  sample(c.tex.orm, mip, u, v, texel);
+  const occ = texel[0] ?? 1;
+  const rough = glass ? 0.06 : Math.max(0.08, texel[1] ?? 0.8);
+  const metal = glass ? 0 : texel[2] ?? 0;
+  if (glass) {
+    ar *= 0.12;
+    ag *= 0.14;
+    ab *= 0.16;
+  }
+  const r = c.rig;
+  const n0 = nrm[0] ?? 0;
+  const n1 = nrm[1] ?? 0;
+  const n2 = nrm[2] ?? 1;
+  const ndl = n0 * r.sun[0] + n1 * r.sun[1] + n2 * r.sun[2];
+  const gdl = (geo[0] ?? 0) * r.sun[0] + (geo[1] ?? 0) * r.sun[1] + (geo[2] ?? 0) * r.sun[2];
+  const lit = ndl > 0 && gdl > -0.05 ? sunVisible(c, pos, geo, set) * ndl : 0;
+  const open = skyOpen(c, pos, geo);
+  const hemi = 0.5 + 0.5 * n2;
+  const amb = open * (0.35 + 0.65 * occ);
+  const dk = 1 - metal;
+  let hx = r.sun[0] + vx;
+  let hy = r.sun[1] + vy;
+  let hz = r.sun[2] + vz;
+  const hl = hyp(hx, hy, hz) || 1;
+  hx /= hl;
+  hy /= hl;
+  hz /= hl;
+  const ndh = Math.max(0, n0 * hx + n1 * hy + n2 * hz);
+  const vdh = Math.max(0, vx * hx + vy * hy + vz * hz);
+  const ndv = Math.max(0, n0 * vx + n1 * vy + n2 * vz);
+  const shin = Math.min(2048, 2 / (rough * rough * rough * rough) - 2);
+  const lobe = (shin + 8) / 25.13 * ndh ** shin;
+  const fr = (1 - vdh) ** 5;
+  const fe = (1 - ndv) ** 5 * (1 - rough) * (1 - rough);
+  const ch = [ar, ag, ab];
+  for (let k = 0;k < 3; k++) {
+    const al = ch[k] ?? 0;
+    const f0 = 0.04 * dk + al * metal;
+    const sky = (r.bounce[k] ?? 0) * (1 - hemi) + (r.sky[k] ?? 0) * hemi;
+    const diffuse = al * dk * ((r.sunColor[k] ?? 0) * lit + sky * amb);
+    const spec = (f0 + (1 - f0) * fr) * lobe * lit * (r.sunColor[k] ?? 0) * 0.8;
+    const env = (f0 + (1 - f0) * fe) * (r.sky[k] ?? 0) * open * (glass ? 2.5 : 0.3 + 0.7 * (1 - rough));
+    out[k] = (diffuse + spec + env) * r.exposure;
+  }
+}
+
+// src/render/ground.ts
+var UP = [0, 0, 1];
+function floorGrid(c, size) {
+  const s = c.scene;
+  const z = s.min[2];
+  const h = s.max[2] - s.min[2];
+  const half = Math.max(s.max[0] - s.min[0], s.max[1] - s.min[1]) / 2 + Math.max(h * 1.4, 0.2);
+  const cx = (s.min[0] + s.max[0]) / 2;
+  const cy = (s.min[1] + s.max[1]) / 2;
+  const cell = 2 * half / size;
+  const light = new Float32Array(size * size);
+  const sunUp = Math.max(0, c.rig.sun[2]);
+  const sunW = sunUp * (c.rig.sunColor[1] ?? 1);
+  const skyW = c.rig.sky[1] ?? 1;
+  const p = [0, 0, z];
+  for (let j = 0;j < size; j++)
+    for (let i = 0;i < size; i++) {
+      p[0] = cx - half + (i + 0.5) * cell;
+      p[1] = cy - half + (j + 0.5) * cell;
+      const sun = sunVisible(c, p, UP, i + j * 2 & 3);
+      const open = skyOpen(c, p, UP);
+      light[j * size + i] = (sunW * sun * (0.55 + 0.45 * open) + skyW * open) / (sunW + skyW);
+    }
+  return { z, x0: cx - half, y0: cy - half, cell, size, light: blur(blur(light, size), size) };
+}
+function blur(src, n) {
+  const out = new Float32Array(src.length);
+  for (let y = 0;y < n; y++)
+    for (let x = 0;x < n; x++) {
+      let s = 0;
+      for (let dy = -1;dy <= 1; dy++)
+        for (let dx = -1;dx <= 1; dx++) {
+          const yy = Math.min(n - 1, Math.max(0, y + dy));
+          const xx = Math.min(n - 1, Math.max(0, x + dx));
+          s += src[yy * n + xx] ?? 1;
+        }
+      out[y * n + x] = s / 9;
+    }
+  return out;
+}
+function floorLight(g, cam, px, py) {
+  const sx = (px - cam.cx) / cam.focal;
+  const sy = -(py - cam.cy) / cam.focal;
+  const dx = cam.f[0] + cam.r[0] * sx + cam.u[0] * sy;
+  const dy = cam.f[1] + cam.r[1] * sx + cam.u[1] * sy;
+  const dz = cam.f[2] + cam.r[2] * sx + cam.u[2] * sy;
+  if (dz >= -0.000001)
+    return 1;
+  const t = (g.z - cam.eye[2]) / dz;
+  const gx = (cam.eye[0] + dx * t - g.x0) / g.cell - 0.5;
+  const gy = (cam.eye[1] + dy * t - g.y0) / g.cell - 0.5;
+  const ix = Math.floor(gx);
+  const iy = Math.floor(gy);
+  if (ix < 0 || iy < 0 || ix >= g.size - 1 || iy >= g.size - 1)
+    return 1;
+  const fx = gx - ix;
+  const fy = gy - iy;
+  const L = g.light;
+  const o = iy * g.size + ix;
+  return (L[o] ?? 1) * (1 - fx) * (1 - fy) + (L[o + 1] ?? 1) * fx * (1 - fy) + (L[o + g.size] ?? 1) * (1 - fx) * fy + (L[o + g.size + 1] ?? 1) * fx * fy;
+}
+
+// src/render/lighting.ts
+var unit = (az, el) => {
+  const a = az * Math.PI / 180;
+  const e = el * Math.PI / 180;
+  return [Math.cos(e) * Math.cos(a), Math.cos(e) * Math.sin(a), Math.sin(e)];
+};
+var RINGS = [
+  [14, 5],
+  [38, 4],
+  [64, 2],
+  [88, 1]
+];
+function studioRig(cameraAzDeg) {
+  const skyDirs = [];
+  RINGS.forEach(([el, n], ring) => {
+    for (let i = 0;i < n; i++)
+      skyDirs.push(unit(360 * (i + ring * 0.37) / n, el));
+  });
+  return {
+    sun: unit(cameraAzDeg - 50, 55),
+    sunColor: [0.95, 0.91, 0.84],
+    sky: [0.3, 0.33, 0.4],
+    bounce: [0.16, 0.15, 0.13],
+    skyDirs,
+    exposure: 1
+  };
+}
+var DISC = [
+  [-0.94, -0.4],
+  [0.95, -0.77],
+  [-0.09, -0.93],
+  [0.34, 0.29],
+  [-0.92, 0.46],
+  [-0.38, -0.06],
+  [0.79, 0.19],
+  [-0.24, 0.78],
+  [0.44, -0.3],
+  [0.55, 0.85],
+  [-0.66, -0.87],
+  [0.06, 0.37]
+];
+function pcfTaps(radius) {
+  return [0, 1, 2, 3].map((k) => {
+    const a = k * Math.PI / 8;
+    const c = Math.cos(a) * radius;
+    const s = Math.sin(a) * radius;
+    const out = new Float32Array(DISC.length * 2);
+    DISC.forEach(([x, y], i) => {
+      out[i * 2] = x * c - y * s;
+      out[i * 2 + 1] = x * s + y * c;
+    });
+    return out;
+  });
+}
+function tone(x) {
+  if (x <= 0)
+    return 0;
+  if (x <= 0.6)
+    return x;
+  return 0.6 + 0.4 * (1 - Math.exp(-(x - 0.6) / 0.4));
+}
+var toSrgb8 = (v) => Math.round(255 * (v <= 0.0031308 ? v * 12.92 : 1.055 * Math.min(1, v) ** (1 / 2.4) - 0.055));
+var fromSrgb = (v) => v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+
+// src/render/options.ts
+function need(ok, cause, fix) {
+  if (!ok)
+    throw new Ts23dError2("T3D_RENDER_OPTIONS", { cause, fix });
+}
+function checkBeautyOptions2(o) {
+  const v = {
+    width: o.width ?? 1600,
+    height: o.height ?? 900,
+    azDeg: o.azDeg ?? -35,
+    elDeg: o.elDeg ?? 18,
+    fovDeg: o.fovDeg ?? 30,
+    supersample: o.supersample ?? 2
+  };
+  for (const k of ["width", "height"])
+    need(Number.isInteger(v[k]) && v[k] >= 16 && v[k] <= 8192, `${k} ${v[k]} is not an integer in 16…8192 pixels`, "pass a size like 1600x900 (--size WxH), each side 16–8192");
+  need(Number.isFinite(v.azDeg), `azimuth ${v.azDeg} is not a number`, "pass degrees, e.g. --az -35");
+  need(Number.isFinite(v.elDeg) && v.elDeg >= -10 && v.elDeg <= 89, `elevation ${v.elDeg} is outside −10…89°`, "pass degrees above the horizon, e.g. --el 18 (89 = straight down)");
+  need(Number.isFinite(v.fovDeg) && v.fovDeg >= 5 && v.fovDeg <= 120, `field of view ${v.fovDeg} is outside 5…120°`, "pass a vertical FOV in degrees, e.g. --fov 30");
+  need(Number.isInteger(v.supersample) && v.supersample >= 1 && v.supersample <= 4, `supersample ${v.supersample} is not 1, 2, 3 or 4`, "use supersample: 2 (4 samples per pixel)");
+  if (o.window)
+    need(Number.isFinite(o.window.zoom) && o.window.zoom >= 1 && o.window.zoom <= 64, `window zoom ${o.window.zoom} is outside 1…64`, "zoom into the shot with window: { x, y, zoom } and 1 ≤ zoom ≤ 64");
+  return v;
+}
+function parseSize2(text) {
+  const m = /^(\d+)[x×](\d+)$/i.exec(text.trim());
+  need(m !== null, `size "${text}" is not WIDTHxHEIGHT`, "pass --size 1600x900");
+  const width = Number(m?.[1]);
+  const height = Number(m?.[2]);
+  checkBeautyOptions2({ width, height });
+  return { width, height };
+}
+
+// src/render/resolve.ts
+function backdrop(nx, ny, out) {
+  const dx = (nx - 0.5) * 1.1;
+  const dy = ny - 0.62;
+  const fall = Math.min(1, dx * dx + dy * dy * 1.6);
+  out[0] = fromSrgb(0.93 - 0.17 * fall);
+  out[1] = fromSrgb(0.935 - 0.15 * fall);
+  out[2] = fromSrgb(0.94 - 0.12 * fall);
+}
+function resolve(ctx, vis, floor, width, height, ss) {
+  const rgba = new Uint8Array(width * height * 4);
+  const mask = new Uint8Array(width * height);
+  const counted = new Int32Array(ctx.scene.triangles).fill(-1);
+  const detail = new Uint32Array(16 * 9);
+  const lin = new Float32Array(3);
+  const bg = new Float32Array(3);
+  const n = ss * ss;
+  const ids = new Int32Array(n);
+  const cnt = new Int32Array(n);
+  const sb1 = new Float64Array(n);
+  const sb2 = new Float64Array(n);
+  const W = vis.width;
+  const inv = 1 / n;
+  for (let y = 0;y < height; y++) {
+    for (let x = 0;x < width; x++) {
+      backdrop(x / width, y / height, bg);
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      let groups = 0;
+      let hits = 0;
+      for (let sy = 0;sy < ss; sy++)
+        for (let sx = 0;sx < ss; sx++) {
+          const X = x * ss + sx;
+          const Y = y * ss + sy;
+          const i = Y * W + X;
+          const t = vis.tri[i] ?? -1;
+          if (t < 0) {
+            const l = floorLight(floor, ctx.cam, X + 0.5, Y + 0.5);
+            r += (bg[0] ?? 0) * l;
+            g += (bg[1] ?? 0) * l;
+            b += (bg[2] ?? 0) * l;
+            continue;
+          }
+          hits++;
+          let k = 0;
+          while (k < groups && ids[k] !== t)
+            k++;
+          if (k === groups) {
+            ids[k] = t;
+            cnt[k] = 0;
+            sb1[k] = 0;
+            sb2[k] = 0;
+            groups++;
+          }
+          cnt[k] = (cnt[k] ?? 0) + 1;
+          sb1[k] = (sb1[k] ?? 0) + (vis.b1[i] ?? 0);
+          sb2[k] = (sb2[k] ?? 0) + (vis.b2[i] ?? 0);
+        }
+      const cell = Math.floor(y * 9 / height) * 16 + Math.floor(x * 16 / width);
+      for (let k = 0;k < groups; k++) {
+        const t = ids[k] ?? 0;
+        const c = cnt[k] ?? 1;
+        if (counted[t] !== cell) {
+          counted[t] = cell;
+          detail[cell] = (detail[cell] ?? 0) + 1;
+        }
+        shadeSample(ctx, t, (sb1[k] ?? 0) / c, (sb2[k] ?? 0) / c, vis.mip[t] ?? 0, x + y * 2, lin);
+        r += tone(lin[0] ?? 0) * c;
+        g += tone(lin[1] ?? 0) * c;
+        b += tone(lin[2] ?? 0) * c;
+      }
+      const o = (y * width + x) * 4;
+      rgba[o] = toSrgb8(r * inv);
+      rgba[o + 1] = toSrgb8(g * inv);
+      rgba[o + 2] = toSrgb8(b * inv);
+      rgba[o + 3] = 255;
+      mask[y * width + x] = Math.round(hits * inv * 255);
+    }
+  }
+  return { width, height, rgba, mask, detail };
+}
+
+// src/render/scene.ts
+var SURFACE_CODE = {
+  opaque: 0,
+  cutout: 1,
+  glass: 2,
+  translucent: 3
+};
+function sceneOf(asset) {
+  const meshes = worldMeshes2(asset.parts);
+  const surfOf = new Map(asset.parts.map((p) => [p.name, SURFACE_CODE[p.surface ?? "opaque"]]));
+  let nv = 0;
+  let nt = 0;
+  for (const m of meshes.values()) {
+    nv += m.positions.length / 3;
+    nt += m.indices.length / 3;
+  }
+  const positions = new Float32Array(nv * 3);
+  const normals = new Float32Array(nv * 3);
+  const uvs = new Float32Array(nv * 2);
+  const colors = new Float32Array(nv * 3);
+  const indices = new Uint32Array(nt * 3);
+  const surface = new Uint8Array(nt);
+  let vo = 0;
+  let to = 0;
+  for (const [name, m] of meshes) {
+    positions.set(m.positions, vo * 3);
+    normals.set(m.normals, vo * 3);
+    uvs.set(m.uvs, vo * 2);
+    colors.set(m.colors, vo * 3);
+    for (let i = 0;i < m.indices.length; i++)
+      indices[to * 3 + i] = (m.indices[i] ?? 0) + vo;
+    surface.fill(surfOf.get(name) ?? 0, to, to + m.indices.length / 3);
+    vo += m.positions.length / 3;
+    to += m.indices.length / 3;
+  }
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0;i < positions.length; i++) {
+    const v = positions[i] ?? 0;
+    const k = i % 3;
+    if (v < (min[k] ?? 0))
+      min[k] = v;
+    if (v > (max[k] ?? 0))
+      max[k] = v;
+  }
+  if (nv === 0) {
+    min.fill(-0.5);
+    max.fill(0.5);
+  }
+  return {
+    positions,
+    normals,
+    uvs,
+    colors,
+    indices,
+    surface,
+    tangents: tangentsOf(positions, uvs, indices),
+    min,
+    max,
+    triangles: nt
+  };
+}
+function tangentsOf(p, uv, idx) {
+  const out = new Float32Array(idx.length * 2);
+  for (let t = 0;t < idx.length; t += 3) {
+    const a = idx[t] ?? 0;
+    const b = idx[t + 1] ?? 0;
+    const c = idx[t + 2] ?? 0;
+    const e1x = (p[b * 3] ?? 0) - (p[a * 3] ?? 0);
+    const e1y = (p[b * 3 + 1] ?? 0) - (p[a * 3 + 1] ?? 0);
+    const e1z = (p[b * 3 + 2] ?? 0) - (p[a * 3 + 2] ?? 0);
+    const e2x = (p[c * 3] ?? 0) - (p[a * 3] ?? 0);
+    const e2y = (p[c * 3 + 1] ?? 0) - (p[a * 3 + 1] ?? 0);
+    const e2z = (p[c * 3 + 2] ?? 0) - (p[a * 3 + 2] ?? 0);
+    const du1 = (uv[b * 2] ?? 0) - (uv[a * 2] ?? 0);
+    const dv1 = (uv[b * 2 + 1] ?? 0) - (uv[a * 2 + 1] ?? 0);
+    const du2 = (uv[c * 2] ?? 0) - (uv[a * 2] ?? 0);
+    const dv2 = (uv[c * 2 + 1] ?? 0) - (uv[a * 2 + 1] ?? 0);
+    const det = du1 * dv2 - du2 * dv1;
+    if (Math.abs(det) < 0.000000000001)
+      continue;
+    const tx = (e1x * dv2 - e2x * dv1) / det;
+    const ty = (e1y * dv2 - e2y * dv1) / det;
+    const tz = (e1z * dv2 - e2z * dv1) / det;
+    const bx = (e2x * du1 - e1x * du2) / det;
+    const by = (e2y * du1 - e1y * du2) / det;
+    const bz = (e2z * du1 - e1z * du2) / det;
+    const lt = Math.hypot(tx, ty, tz) || 1;
+    const lb = -(Math.hypot(bx, by, bz) || 1);
+    const o = t * 2;
+    out[o] = tx / lt;
+    out[o + 1] = ty / lt;
+    out[o + 2] = tz / lt;
+    out[o + 3] = bx / lb;
+    out[o + 4] = by / lb;
+    out[o + 5] = bz / lb;
+  }
+  return out;
+}
+
+// src/render/vis-buffer.ts
+function rasteriseVis(s, cam, texSize, alpha) {
+  const W = cam.width;
+  const H = cam.height;
+  const n = W * H;
+  const tri = new Int32Array(n).fill(-1);
+  const b1 = new Float32Array(n);
+  const b2 = new Float32Array(n);
+  const invw = new Float32Array(n);
+  const nv = s.positions.length / 3;
+  const sx = new Float32Array(nv);
+  const sy = new Float32Array(nv);
+  const iw = new Float32Array(nv);
+  const P = s.positions;
+  const [ex, ey, ez] = cam.eye;
+  for (let v = 0;v < nv; v++) {
+    const dx = (P[v * 3] ?? 0) - ex;
+    const dy = (P[v * 3 + 1] ?? 0) - ey;
+    const dz = (P[v * 3 + 2] ?? 0) - ez;
+    const w = dx * cam.f[0] + dy * cam.f[1] + dz * cam.f[2];
+    const q = w > 0.0001 ? 1 / w : -1;
+    iw[v] = q;
+    sx[v] = cam.cx + (dx * cam.r[0] + dy * cam.r[1] + dz * cam.r[2]) * q * cam.focal;
+    sy[v] = cam.cy - (dx * cam.u[0] + dy * cam.u[1] + dz * cam.u[2]) * q * cam.focal;
+  }
+  const mip = new Uint8Array(s.triangles);
+  const I = s.indices;
+  const UV = s.uvs;
+  for (let t = 0;t < s.triangles; t++) {
+    const a = I[t * 3] ?? 0;
+    const b = I[t * 3 + 1] ?? 0;
+    const c = I[t * 3 + 2] ?? 0;
+    const qa = iw[a] ?? -1;
+    const qb = iw[b] ?? -1;
+    const qc = iw[c] ?? -1;
+    if (qa < 0 || qb < 0 || qc < 0)
+      continue;
+    const ax = sx[a] ?? 0;
+    const ay = sy[a] ?? 0;
+    const bx = sx[b] ?? 0;
+    const by = sy[b] ?? 0;
+    const cx = sx[c] ?? 0;
+    const cy = sy[c] ?? 0;
+    const area = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
+    if (Math.abs(area) < 0.000000000001)
+      continue;
+    const uvArea = Math.abs(((UV[b * 2] ?? 0) - (UV[a * 2] ?? 0)) * ((UV[c * 2 + 1] ?? 0) - (UV[a * 2 + 1] ?? 0)) - ((UV[b * 2 + 1] ?? 0) - (UV[a * 2 + 1] ?? 0)) * ((UV[c * 2] ?? 0) - (UV[a * 2] ?? 0)));
+    const lod = 0.5 * Math.log2(uvArea * texSize * texSize / Math.abs(area) + 0.000000000001);
+    const m = Math.max(0, Math.min(10, Math.floor(lod + 0.25)));
+    mip[t] = m;
+    const lx = ax < bx ? Math.min(ax, cx) : Math.min(bx, cx);
+    const hx = ax > bx ? Math.max(ax, cx) : Math.max(bx, cx);
+    const ly = ay < by ? Math.min(ay, cy) : Math.min(by, cy);
+    const hy = ay > by ? Math.max(ay, cy) : Math.max(by, cy);
+    const minX = lx < 0 ? 0 : Math.floor(lx);
+    const maxX = hx > W - 1 ? W - 1 : Math.ceil(hx);
+    const minY = ly < 0 ? 0 : Math.floor(ly);
+    const maxY = hy > H - 1 ? H - 1 : Math.ceil(hy);
+    if (minX > maxX || minY > maxY)
+      continue;
+    const inv = 1 / area;
+    const cut = alpha !== undefined && s.surface[t] === 1;
+    const A0 = (by - cy) * inv;
+    const B0 = (cx - bx) * inv;
+    const A1 = (cy - ay) * inv;
+    const B1 = (ax - cx) * inv;
+    const C0 = (bx * cy - by * cx) * inv;
+    const C1 = (cx * ay - cy * ax) * inv;
+    for (let y = minY;y <= maxY; y++) {
+      const py = y + 0.5;
+      let w0 = C0 + A0 * (minX + 0.5) + B0 * py;
+      let w1 = C1 + A1 * (minX + 0.5) + B1 * py;
+      for (let x = minX;x <= maxX; x++, w0 += A0, w1 += A1) {
+        const w2 = 1 - w0 - w1;
+        if (w0 < 0 || w1 < 0 || w2 < 0)
+          continue;
+        const z = w0 * qa + w1 * qb + w2 * qc;
+        const i = y * W + x;
+        if (z <= (invw[i] ?? 0))
+          continue;
+        const pb = w1 * qb / z;
+        const pc = w2 * qc / z;
+        if (cut && alpha && !alpha(t, pb, pc, m))
+          continue;
+        invw[i] = z;
+        tri[i] = t;
+        b1[i] = pb;
+        b2[i] = pc;
+      }
+    }
+  }
+  return { width: W, height: H, tri, b1, b2, invw, mip };
+}
+
+// src/render/beauty.ts
+var defaultSheet;
+var sheetOf = (o) => {
+  if (o.sheet)
+    return o.sheet;
+  defaultSheet ??= paintTrimSheet2({ ...DEFAULT_SHEET2, size: 512 });
+  return defaultSheet;
+};
+function cameraFor2(asset, o = {}) {
+  const v = checkBeautyOptions2(o);
+  const cam = frameOrbit(sceneOf(o.frameFrom ?? asset).positions, { azDeg: v.azDeg, elDeg: v.elDeg, fovDeg: v.fovDeg, fill: 0.8 }, v.width, v.height);
+  return o.window ? zoomWindow(cam, o.window.x, o.window.y, o.window.zoom) : cam;
+}
+function renderBeauty2(asset, o = {}) {
+  const v = checkBeautyOptions2(o);
+  const ss = v.supersample;
+  const scene = sceneOf(asset);
+  const tex = sheetTextures(sheetOf(o));
+  const rig = studioRig(v.azDeg);
+  const texel = new Float32Array(4);
+  const alpha = (t, b1, b2, mip = 2) => {
+    const I = scene.indices;
+    const U = scene.uvs;
+    const b0 = 1 - b1 - b2;
+    const a = (I[t * 3] ?? 0) * 2;
+    const b = (I[t * 3 + 1] ?? 0) * 2;
+    const c = (I[t * 3 + 2] ?? 0) * 2;
+    const u = (U[a] ?? 0) * b0 + (U[b] ?? 0) * b1 + (U[c] ?? 0) * b2;
+    const w = (U[a + 1] ?? 0) * b0 + (U[b + 1] ?? 0) * b1 + (U[c + 1] ?? 0) * b2;
+    sample(tex.albedo, mip, u, w, texel);
+    return (texel[3] ?? 1) >= 0.5;
+  };
+  const cam = scaled(cameraFor2(asset, o), ss);
+  const vis = rasteriseVis(scene, cam, tex.size, alpha);
+  const extent = Math.max(...scene.max.map((m, k) => m - (scene.min[k] ?? 0)));
+  const px = Math.max(v.width, v.height) * ss;
+  const res = (lo, hi, f) => Math.max(lo, Math.min(hi, Math.round(px * f)));
+  const sunMap = depthMap(scene, rig.sun, res(256, 2048, 1), undefined, alpha);
+  const ctx = {
+    scene,
+    cam,
+    tex,
+    rig,
+    sunMap,
+    aoMaps: rig.skyDirs.map((d) => depthMap(scene, d, res(96, 384, 0.25), undefined, alpha)),
+    pcf: pcfTaps(Math.max(1.2, 0.004 * extent * sunMap.k)),
+    reach: 0.12 * extent
+  };
+  const floor = floorGrid(ctx, res(96, 512, 0.25));
+  return resolve(ctx, vis, floor, v.width, v.height, ss);
+}
+function beauty2(asset, o = {}) {
+  const r = renderBeauty2(asset, o);
+  return encodePng2(r.width, r.height, r.rgba);
+}
+// src/render/font.ts
+var GLYPHS = {
+  A: "010101111101101",
+  B: "110101110101110",
+  C: "011100100100011",
+  D: "110101101101110",
+  E: "111100110100111",
+  F: "111100110100100",
+  G: "011100101101011",
+  H: "101101111101101",
+  I: "111010010010111",
+  J: "001001001101010",
+  K: "101101110101101",
+  L: "100100100100111",
+  M: "101111111101101",
+  N: "110101101101101",
+  O: "010101101101010",
+  P: "110101110100100",
+  Q: "010101101110011",
+  R: "110101110101101",
+  S: "011100010001110",
+  T: "111010010010010",
+  U: "101101101101111",
+  V: "101101101101010",
+  W: "101101111111101",
+  X: "101101010101101",
+  Y: "101101010010010",
+  Z: "111001010100111",
+  "0": "111101101101111",
+  "1": "010110010010111",
+  "2": "110001010100111",
+  "3": "110001010001110",
+  "4": "101101111001001",
+  "5": "111100110001110",
+  "6": "011100111101111",
+  "7": "111001010010010",
+  "8": "111101111101111",
+  "9": "111101111001110",
+  ".": "000000000000010",
+  "/": "001001010100100",
+  "-": "000000111000000",
+  ":": "000010000010000",
+  " ": "000000000000000",
+  "+": "000010111010000",
+  _: "000000000000111",
+  "=": "000111000111000"
+};
+function drawText(px, width, x, y, text, scale, rgb) {
+  let cx = x;
+  for (const ch of text.toUpperCase()) {
+    const g = GLYPHS[ch] ?? GLYPHS[" "] ?? "";
+    for (let i = 0;i < 15; i++) {
+      if (g[i] !== "1")
+        continue;
+      const gx = cx + i % 3 * scale;
+      const gy = y + Math.floor(i / 3) * scale;
+      for (let dy = 0;dy < scale; dy++) {
+        for (let dx = 0;dx < scale; dx++) {
+          const o = ((gy + dy) * width + gx + dx) * 4;
+          if (o >= 0 && o + 3 < px.length)
+            px.set([...rgb, 255], o);
+        }
+      }
+    }
+    cx += 4 * scale;
+  }
+}
+
+// src/render/lod-strip.ts
+var tris = (a) => a.parts.reduce((s, p) => s + (p.mesh ? p.mesh.indices.length / 3 : 0), 0);
+function lodStrip2(lods, o = {}) {
+  const w = o.width ?? 640;
+  const h = o.height ?? 480;
+  const first = lods[0];
+  const n = lods.length;
+  const out = new Uint8Array(w * n * h * 4);
+  lods.forEach((a, k) => {
+    const r = renderBeauty2(a, {
+      ...o,
+      width: w,
+      height: h,
+      ...first ? { frameFrom: first } : {}
+    });
+    for (let y = 0;y < h; y++)
+      out.set(r.rgba.subarray(y * w * 4, (y + 1) * w * 4), (y * w * n + k * w) * 4);
+    if (k > 0)
+      for (let y = 0;y < h; y++)
+        out.fill(255, (y * w * n + k * w) * 4, (y * w * n + k * w + 2) * 4);
+    drawText(out, w * n, k * w + 12, 12, `LOD${a.lod}  ${tris(a)} TRIS`, 3, [40, 44, 52]);
+  });
+  return encodePng2(w * n, h, out);
+}
+// src/render/metrics.ts
+var towardCamera = (v) => {
+  const l = Math.hypot(v.dir[0], v.dir[1], v.dir[2]) || 1;
+  return [-v.dir[0] / l, -v.dir[1] / l, -v.dir[2] / l];
+};
+function viewFrame2(asset, view) {
+  return fitFrame(sceneOf(asset), towardCamera(view));
+}
+function silhouette2(asset, view, size = 256, frame = viewFrame2(asset, view)) {
+  const m = depthMap(sceneOf(asset), towardCamera(view), size, frame);
+  const mask = new Uint8Array(size * size);
+  for (let i = 0;i < mask.length; i++)
+    mask[i] = (m.data[i] ?? -Infinity) > -Infinity ? 1 : 0;
+  return { size, mask };
+}
+function maskIoU2(a, b) {
+  if (a.length !== b.length)
+    throw new Ts23dError2("T3D_RENDER_OPTIONS", {
+      cause: `masks differ in size (${a.length} vs ${b.length} pixels)`,
+      fix: "render both silhouettes at the same size and frame (pass the LOD0 frame to both)"
+    });
+  let inter = 0;
+  let union = 0;
+  for (let i = 0;i < a.length; i++) {
+    const x = (a[i] ?? 0) !== 0;
+    const y = (b[i] ?? 0) !== 0;
+    if (x && y)
+      inter++;
+    if (x || y)
+      union++;
+  }
+  return union === 0 ? 1 : inter / union;
+}
+function poolMask2(s, f) {
+  const size = Math.floor(s.size / f);
+  const mask = new Uint8Array(size * size);
+  for (let y = 0;y < s.size; y++)
+    for (let x = 0;x < s.size; x++)
+      if (s.mask[y * s.size + x]) {
+        const i = Math.floor(y / f) * size + Math.floor(x / f);
+        if (i < mask.length)
+          mask[i] = 1;
+      }
+  return { size, mask };
+}
+function maskStats2(s) {
+  let n = 0;
+  let x0 = s.size;
+  let y0 = s.size;
+  let x1 = -1;
+  let y1 = -1;
+  for (let y = 0;y < s.size; y++)
+    for (let x = 0;x < s.size; x++) {
+      if (!s.mask[y * s.size + x])
+        continue;
+      n++;
+      if (x < x0)
+        x0 = x;
+      if (x > x1)
+        x1 = x;
+      if (y < y0)
+        y0 = y;
+      if (y > y1)
+        y1 = y;
+    }
+  const box = x1 < 0 ? 0 : (x1 - x0 + 1) * (y1 - y0 + 1);
+  return { coverage: n / (s.size * s.size), bboxFill: box ? n / box : 0 };
+}
+function exposure2(rgba, mask, width) {
+  const height = Math.max(1, Math.floor(mask.length / Math.max(1, width)));
+  let x0 = width;
+  let x1 = -1;
+  let y0 = height;
+  let y1 = -1;
+  let n = 0;
+  let sum = 0;
+  let sq = 0;
+  let black = 0;
+  let white = 0;
+  for (let i = 0;i < mask.length; i++) {
+    if ((mask[i] ?? 0) < 128)
+      continue;
+    const x = i % width;
+    const y = Math.floor(i / width);
+    if (x < x0)
+      x0 = x;
+    if (x > x1)
+      x1 = x;
+    if (y < y0)
+      y0 = y;
+    if (y > y1)
+      y1 = y;
+    const o = i * 4;
+    const l = (0.2126 * (rgba[o] ?? 0) + 0.7152 * (rgba[o + 1] ?? 0) + 0.0722 * (rgba[o + 2] ?? 0)) / 255;
+    n++;
+    sum += l;
+    sq += l * l;
+    if (l < 0.06)
+      black++;
+    if (l > 0.97)
+      white++;
+  }
+  const mean = n ? sum / n : 0;
+  return {
+    coverage: n / Math.max(1, mask.length),
+    span: x1 < 0 ? 0 : Math.max((x1 - x0 + 1) / width, (y1 - y0 + 1) / height),
+    mean,
+    contrast: n ? Math.sqrt(Math.max(0, sq / n - mean * mean)) : 0,
+    nearBlack: n ? black / n : 0,
+    nearWhite: n ? white / n : 0
+  };
+}
+// src/render/photo-match.ts
+function photoMatch2(_asset, _o) {
+  return notImplemented2("photoMatch (photo · model · overlay sheet + silhouette IoU)");
+}
+// src/render/review-prompt.ts
+var CHECKLIST = [
+  "**Floating bits** — every bar, bracket, lamp, rod, handle touches what holds it. Look at the close-ups and the TOP view.",
+  "**Clipping** — wheels through frames or fenders, rods through guides, brackets through roofs, branches through trunks.",
+  "**Proportions vs reality** — compare overall length/width/height ratios and signature features with the reference dossier and its photos.",
+  "**Open stacks and throats** — chimneys, funnels, exhausts, muzzles and pipes are OPEN (rim + dark inner throat), never capped.",
+  "**Hidden detail** — detail buried inside another mass (a clock behind a roof, a hatch under a turret) is wasted triangles.",
+  "**Silhouette at LOD2** — in lods.png, LOD2 keeps the outline and the big colour blocks; nothing pops, vanishes or shifts colour.",
+  "**Texture stretching** — trim-sheet strips run along faces at a sensible scale: no smeared bricks, giant planks or streaked rivets.",
+  "**Colour / value contrast** — materials separate (paint vs rubber vs metal vs glass); not one flat tone; no pure black or white.",
+  "**Lettering and decals** — numbers and signs are legible in the close-ups and read the right way round.",
+  "**Organic forms** — foliage, snow and terrain read as volume from the 3/4 hero, not as blotches, slabs or cards edge-on.",
+  "**Grounding** — the asset stands on the floor (contact shadow under every wheel, foot or base), not sunk or hovering."
+];
+function reviewPrompt(m, files, refs) {
+  const pct = (v) => `${(v * 100).toFixed(1)}%`;
+  const views = m.views.map((v) => `| ${v.view} | ${pct(v.lod0.coverage)} | ${pct(v.lod0.bboxFill)} | ${v.lodIoU.toFixed(3)} | ${v.lodIoUExact.toFixed(3)} |`).join(`
+`);
+  const warnings = m.warnings.length ? m.warnings.map((w) => `- **${w.code}**: ${w.message}
+  fix: ${w.fix}`).join(`
+`) : "- none — the metrics are proxies, so still run the checklist.";
+  return `# Visual review: ${m.asset}
+
+You are reviewing a game asset generated from code. READ every image in this folder before
+answering: ${files.filter((f) => f.endsWith(".png")).join(", ")}.
+${refs ? `Reference dossier (specs, measures, photo links): \`${refs}\` — read it first.
+` : `No reference dossier was found (expected recipes/<name>/README.md): judge against well-known photos of the real thing.
+`}
+- \`hero.png\` — 3/4 product shot, LOD0. · \`sheet.png\` — six orthographic views on a metre grid.
+- \`detail_*.png\` — 3× close-ups where the triangles are. · \`lods.png\` — LOD0 · LOD1 · LOD2, same camera.
+
+Triangles per LOD: ${m.triangles.join(" / ")}.
+
+## Checklist — answer each with PASS or FAIL + where + the fix
+${CHECKLIST.map((c, i) => `${i + 1}. ${c}`).join(`
+`)}
+
+## Automatic metrics (review.json)
+Hero: coverage ${pct(m.hero.coverage)}, span ${pct(m.hero.span)}, mean luminance ${m.hero.mean.toFixed(3)}, contrast ${m.hero.contrast.toFixed(3)}, near-black ${pct(m.hero.nearBlack)}, near-white ${pct(m.hero.nearWhite)}.
+
+| view | LOD0 coverage | bbox fill | LOD0↔LOD2 IoU (far) | IoU (exact) |
+|---|---|---|---|---|
+${views}
+
+## Warnings
+${warnings}
+
+## Output
+A list of findings, worst first: \`[FAIL] <check> — <where, which view/image> — <fix in the recipe>\`,
+then one line: \`VERDICT: SHIP\` or \`VERDICT: ITERATE\`.
+`;
+}
+
+// src/render/review-warnings.ts
+var REVIEW_THRESHOLDS2 = {
+  lodIoU: 0.8,
+  heroMeanMin: 0.18,
+  heroMeanMax: 0.85,
+  heroContrastMin: 0.06,
+  nearBlackMax: 0.2,
+  nearWhiteMax: 0.1,
+  heroSpanMin: 0.5
+};
+var f = (v) => v.toFixed(3);
+function warningsOf(m) {
+  const t = REVIEW_THRESHOLDS2;
+  const out = [];
+  for (const v of m.views)
+    if (v.lodIoU < t.lodIoU)
+      out.push({
+        code: "lod-popping",
+        message: `${v.view}: LOD0↔LOD2 silhouette IoU ${f(v.lodIoU)} < ${t.lodIoU}`,
+        fix: "keep the LOD2 massing on the LOD0 silhouette — same outer envelope, fewer cuts (see lods.png)"
+      });
+  const h = m.hero;
+  if (h.span < t.heroSpanMin)
+    out.push({
+      code: "tiny-in-frame",
+      message: `asset spans ${f(h.span)} of the hero frame (< ${t.heroSpanMin})`,
+      fix: "a stray or far-off part is stretching the bounds — find it in sheet.png and attach or remove it"
+    });
+  if (h.mean < t.heroMeanMin)
+    out.push({
+      code: "too-dark",
+      message: `hero mean luminance ${f(h.mean)} < ${t.heroMeanMin}`,
+      fix: "raise vertex colours (dark paint ≈ 0.05–0.1 linear, never 0) or check for inward-facing normals"
+    });
+  if (h.mean > t.heroMeanMax)
+    out.push({
+      code: "washed-out",
+      message: `hero mean luminance ${f(h.mean)} > ${t.heroMeanMax}`,
+      fix: "lower vertex colours: real paint and stone rarely exceed ~0.7 linear albedo"
+    });
+  if (h.contrast < t.heroContrastMin)
+    out.push({
+      code: "low-contrast",
+      message: `hero luminance contrast ${f(h.contrast)} < ${t.heroContrastMin}`,
+      fix: "add value contrast between materials (trim, rubber, metal, glass) and grime in crevices"
+    });
+  if (h.nearBlack > t.nearBlackMax)
+    out.push({
+      code: "crushed-blacks",
+      message: `${f(h.nearBlack)} of asset pixels are near black (> ${t.nearBlackMax})`,
+      fix: "lift near-black colours to ≥ 0.03 linear and check normals point outward"
+    });
+  if (h.nearWhite > t.nearWhiteMax)
+    out.push({
+      code: "blown-whites",
+      message: `${f(h.nearWhite)} of asset pixels are near white (> ${t.nearWhiteMax})`,
+      fix: "bring white paint down to ~0.8 linear so texture and shading stay readable"
+    });
+  return out;
+}
+
+// src/render/raster.ts
+function orthoCamera(view, centre, extent, size) {
+  const f = normalize2(view.dir);
+  const r = normalize2(cross2(f, view.up));
+  const u = cross2(r, f);
+  const k = size / (extent * 1.15);
+  return {
+    project: (p) => {
+      const d = sub2(p, centre);
+      return [size / 2 + dot2(d, r) * k, size / 2 - dot2(d, u) * k, dot2(d, f)];
+    }
+  };
+}
+var LIGHT = normalize2([0.4, -0.6, 0.8]);
+function worldParts(asset) {
+  const xf = worldTransforms2(asset.parts);
+  const out = [];
+  for (const p of asset.parts) {
+    const t = xf.get(p.name);
+    if (!p.mesh || !t)
+      continue;
+    const positions = new Float32Array(p.mesh.positions.length);
+    const normals = new Float32Array(p.mesh.normals.length);
+    for (let i = 0;i < positions.length; i += 3) {
+      positions.set(toWorld2(t, [
+        p.mesh.positions[i] ?? 0,
+        p.mesh.positions[i + 1] ?? 0,
+        p.mesh.positions[i + 2] ?? 0
+      ]), i);
+      normals.set(rotateZ2([p.mesh.normals[i] ?? 0, p.mesh.normals[i + 1] ?? 0, p.mesh.normals[i + 2] ?? 0], t.yaw), i);
+    }
+    out.push({ positions, normals, colors: p.mesh.colors, indices: p.mesh.indices });
+  }
+  return out;
+}
+function tri(t, a, b, c, rgb) {
+  const minX = Math.max(0, Math.floor(Math.min(a[0], b[0], c[0])));
+  const maxX = Math.min(t.width - 1, Math.ceil(Math.max(a[0], b[0], c[0])));
+  const minY = Math.max(0, Math.floor(Math.min(a[1], b[1], c[1])));
+  const maxY = Math.min(t.height - 1, Math.ceil(Math.max(a[1], b[1], c[1])));
+  const area = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+  if (Math.abs(area) < 0.000000001)
+    return;
+  for (let y = minY;y <= maxY; y++) {
+    for (let x = minX;x <= maxX; x++) {
+      const px = x + 0.5;
+      const py = y + 0.5;
+      const w0 = ((b[0] - px) * (c[1] - py) - (b[1] - py) * (c[0] - px)) / area;
+      const w1 = ((c[0] - px) * (a[1] - py) - (c[1] - py) * (a[0] - px)) / area;
+      const w2 = 1 - w0 - w1;
+      if (w0 < 0 || w1 < 0 || w2 < 0)
+        continue;
+      const z = w0 * a[2] + w1 * b[2] + w2 * c[2];
+      const i = y * t.width + x;
+      if (z >= (t.depth[i] ?? Infinity))
+        continue;
+      t.depth[i] = z;
+      t.px.set([rgb[0], rgb[1], rgb[2], 255], i * 4);
+    }
+  }
+}
+var toSrgb = (v) => Math.round(255 * Math.min(1, v <= 0.0031308 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - 0.055));
+function drawAsset(t, cam, asset) {
+  for (const m of worldParts(asset)) {
+    for (let i = 0;i < m.indices.length; i += 3) {
+      const ids = [m.indices[i] ?? 0, m.indices[i + 1] ?? 0, m.indices[i + 2] ?? 0];
+      const pts = ids.map((v) => cam.project([
+        m.positions[v * 3] ?? 0,
+        m.positions[v * 3 + 1] ?? 0,
+        m.positions[v * 3 + 2] ?? 0
+      ]));
+      const v0 = ids[0] ?? 0;
+      const n = [
+        m.normals[v0 * 3] ?? 0,
+        m.normals[v0 * 3 + 1] ?? 0,
+        m.normals[v0 * 3 + 2] ?? 1
+      ];
+      const shade = 0.35 + 0.65 * Math.max(0, dot2(n, LIGHT));
+      const rgb = [
+        toSrgb((m.colors[v0 * 3] ?? 1) * shade),
+        toSrgb((m.colors[v0 * 3 + 1] ?? 1) * shade),
+        toSrgb((m.colors[v0 * 3 + 2] ?? 1) * shade)
+      ];
+      const [a, b, c] = pts;
+      if (a && b && c)
+        tri(t, a, b, c, rgb);
+    }
+  }
+}
+function line(t, a, b, rgb) {
+  const steps = Math.ceil(Math.max(Math.abs(b[0] - a[0]), Math.abs(b[1] - a[1]), 1));
+  for (let s = 0;s <= steps; s++) {
+    const k = s / steps;
+    const x = Math.round(a[0] + (b[0] - a[0]) * k);
+    const y = Math.round(a[1] + (b[1] - a[1]) * k);
+    if (x < 0 || y < 0 || x >= t.width || y >= t.height)
+      continue;
+    const z = a[2] + (b[2] - a[2]) * k;
+    const i = y * t.width + x;
+    if (z > (t.depth[i] ?? Infinity) + 0.001)
+      continue;
+    t.px.set([rgb[0], rgb[1], rgb[2], 255], i * 4);
+  }
+}
+
+// src/render/sheet.ts
+var VIEWS2 = [
+  { label: "3/4 FRONT", dir: [-1, 0.8, -0.6], up: [0, 0, 1] },
+  { label: "FRONT +X", dir: [-1, 0, 0], up: [0, 0, 1] },
+  { label: "SIDE -Y", dir: [0, 1, 0], up: [0, 0, 1] },
+  { label: "TOP", dir: [0, 0, -1], up: [1, 0, 0] },
+  { label: "3/4 REAR", dir: [1, -0.8, -0.6], up: [0, 0, 1] },
+  { label: "FAR LOD2", dir: [-1, 0.8, -0.6], up: [0, 0, 1] }
+];
+function bounds(asset) {
+  const min = [Infinity, Infinity, Infinity];
+  const max = [-Infinity, -Infinity, -Infinity];
+  for (const m of worldParts(asset)) {
+    for (let i = 0;i < m.positions.length; i += 3) {
+      for (let k = 0;k < 3; k++) {
+        const v = m.positions[i + k] ?? 0;
+        min[k] = Math.min(min[k] ?? 0, v);
+        max[k] = Math.max(max[k] ?? 0, v);
+      }
+    }
+  }
+  const lo = [min[0] ?? 0, min[1] ?? 0, min[2] ?? 0];
+  const hi = [max[0] ?? 0, max[1] ?? 0, max[2] ?? 0];
+  const extent = Math.max(hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2], 0.1);
+  return {
+    centre: [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2],
+    extent,
+    min: lo,
+    max: hi
+  };
+}
+var gridStep = (extent) => [0.1, 0.5, 1, 5, 10, 50, 100].find((s) => extent / s <= 24) ?? 100;
+function contactSheet2(asset, o = {}) {
+  const cell = o.cell ?? 400;
+  const width = cell * 3;
+  const height = cell * 2 + 40;
+  const px = new Uint8Array(width * height * 4).fill(255);
+  const b = bounds(asset);
+  const step = gridStep(b.extent);
+  VIEWS2.forEach((view, i) => {
+    const t = {
+      px: new Uint8Array(cell * cell * 4),
+      depth: new Float32Array(cell * cell).fill(Infinity),
+      width: cell,
+      height: cell
+    };
+    for (let k = 0;k < cell * cell; k++)
+      t.px.set([238, 240, 243, 255], k * 4);
+    const cam = orthoCamera(view, b.centre, b.extent, cell);
+    drawAsset(t, cam, i === 5 && o.far ? o.far : asset);
+    const g0 = Math.floor(Math.min(b.min[0], b.min[1]) / step - 1) * step;
+    const g1 = Math.ceil(Math.max(b.max[0], b.max[1]) / step + 1) * step;
+    for (let g = g0;g <= g1 + 0.000000001; g += step) {
+      line(t, cam.project([g, g0, 0]), cam.project([g, g1, 0]), [190, 196, 204]);
+      line(t, cam.project([g0, g, 0]), cam.project([g1, g, 0]), [190, 196, 204]);
+    }
+    const ox = i % 3 * cell;
+    const oy = 40 + Math.floor(i / 3) * cell;
+    for (let y = 0;y < cell; y++)
+      px.set(t.px.subarray(y * cell * 4, (y + 1) * cell * 4), ((oy + y) * width + ox) * 4);
+    drawText(px, width, ox + 8, oy + 8, view.label, 3, [40, 44, 52]);
+  });
+  const dims = `${asset.name}  ${(b.max[0] - b.min[0]).toFixed(1)}X${(b.max[1] - b.min[1]).toFixed(1)}X${(b.max[2] - b.min[2]).toFixed(1)}M  GRID ${step}M  LOD${asset.lod}`;
+  drawText(px, width, 10, 10, dims, 4, [20, 22, 26]);
+  return encodePng2(width, height, px);
+}
+
+// src/render/review.ts
+var tris2 = (a) => a.parts.reduce((s, p) => s + (p.mesh ? p.mesh.indices.length / 3 : 0), 0);
+function detailWindows2(detail) {
+  const order = [...detail.keys()].sort((a, b) => (detail[b] ?? 0) - (detail[a] ?? 0) || a - b);
+  const picked = [];
+  for (const c of order) {
+    if ((detail[c] ?? 0) === 0 || picked.length === 2)
+      break;
+    if (picked.every((p) => Math.hypot(p % 16 - c % 16, Math.floor(p / 16) - Math.floor(c / 16)) >= 4))
+      picked.push(c);
+  }
+  const clamp = (v) => Math.min(5 / 6, Math.max(1 / 6, v));
+  return picked.map((c) => ({
+    x: clamp((c % 16 + 0.5) / 16),
+    y: clamp((Math.floor(c / 16) + 0.5) / 9)
+  }));
+}
+function reviewPack2(asset, o = {}) {
+  const lods = [0, 1, 2].map((lod) => compile2(asset, { lod }));
+  const lod0 = lods[0] ?? compile2(asset);
+  const lod2 = lods[2] ?? lod0;
+  const base = {
+    ...o.sheet ? { sheet: o.sheet } : {},
+    ...o.width ? { width: o.width } : {},
+    ...o.height ? { height: o.height } : {},
+    ...o.azDeg !== undefined ? { azDeg: o.azDeg } : {},
+    ...o.elDeg !== undefined ? { elDeg: o.elDeg } : {},
+    ...o.fovDeg !== undefined ? { fovDeg: o.fovDeg } : {}
+  };
+  const files = new Map;
+  const hero = renderBeauty2(lod0, base);
+  files.set("hero.png", encodePng2(hero.width, hero.height, hero.rgba));
+  files.set("sheet.png", contactSheet2(lod0, { far: lod2 }));
+  detailWindows2(hero.detail).forEach((w, i) => {
+    const r = renderBeauty2(lod0, { ...base, window: { ...w, zoom: 3 } });
+    files.set(`detail_${i + 1}.png`, encodePng2(r.width, r.height, r.rgba));
+  });
+  const k = Math.min(1, (o.width ?? 1600) / 640);
+  const panel = {
+    width: Math.max(16, Math.round(640 * k)),
+    height: Math.max(16, Math.round(480 * k))
+  };
+  files.set("lods.png", lodStrip2(lods, { ...base, ...panel }));
+  const views = VIEWS2.slice(0, 5).map((view) => {
+    const frame = viewFrame2(lod0, view);
+    const a = silhouette2(lod0, view, 256, frame);
+    const b = silhouette2(lod2, view, 256, frame);
+    return {
+      view: view.label,
+      lod0: maskStats2(a),
+      lod2: maskStats2(b),
+      lodIoU: maskIoU2(poolMask2(a, 4).mask, poolMask2(b, 4).mask),
+      lodIoUExact: maskIoU2(a.mask, b.mask)
+    };
+  });
+  const partial = {
+    asset: asset.name,
+    triangles: lods.map(tris2),
+    hero: exposure2(hero.rgba, hero.mask, hero.width),
+    views
+  };
+  const metrics = { ...partial, warnings: warningsOf(partial) };
+  files.set("review.json", `${JSON.stringify(metrics, null, 2)}
+`);
+  files.set("review.md", reviewPrompt(metrics, [...files.keys()], o.refs));
+  return { files, metrics };
+}
+// src/render/thumbnail.ts
+var HERO = { label: "HERO", dir: [-1, 0.75, -0.45], up: [0, 0, 1] };
+function thumbnail2(asset, o = {}) {
+  const size = o.size ?? 512;
+  const big = size * 3;
+  const t = {
+    px: new Uint8Array(big * big * 4),
+    depth: new Float32Array(big * big).fill(Infinity),
+    width: big,
+    height: big
+  };
+  const b = bounds(asset);
+  drawAsset(t, orthoCamera(o.view ?? HERO, b.centre, b.extent * 0.92, big), asset);
+  let x0 = big;
+  let y0 = big;
+  let x1 = -1;
+  let y1 = -1;
+  for (let y = 0;y < big; y++)
+    for (let x = 0;x < big; x++)
+      if ((t.px[(y * big + x) * 4 + 3] ?? 0) > 0) {
+        x0 = Math.min(x0, x);
+        y0 = Math.min(y0, y);
+        x1 = Math.max(x1, x);
+        y1 = Math.max(y1, y);
+      }
+  const side = x1 < 0 ? big : Math.max(x1 - x0, y1 - y0) * 1.12 + 1;
+  const ox = x1 < 0 ? 0 : (x0 + x1) / 2 - side / 2;
+  const oy = x1 < 0 ? 0 : (y0 + y1) / 2 - side / 2;
+  const step = side / size;
+  const out = new Uint8Array(size * size * 4);
+  const taps = [0.25, 0.75];
+  for (let y = 0;y < size; y++) {
+    for (let x = 0;x < size; x++) {
+      let r = 0;
+      let g = 0;
+      let bl = 0;
+      let a = 0;
+      for (const fy of taps)
+        for (const fx of taps) {
+          const sx = Math.floor(ox + (x + fx) * step);
+          const sy = Math.floor(oy + (y + fy) * step);
+          if (sx < 0 || sy < 0 || sx >= big || sy >= big)
+            continue;
+          const i = (sy * big + sx) * 4;
+          const w = t.px[i + 3] ?? 0;
+          r += (t.px[i] ?? 0) * w;
+          g += (t.px[i + 1] ?? 0) * w;
+          bl += (t.px[i + 2] ?? 0) * w;
+          a += w;
+        }
+      if (a > 0)
+        out.set([Math.round(r / a), Math.round(g / a), Math.round(bl / a), Math.round(a / 4)], (y * size + x) * 4);
+    }
+  }
+  return encodePng2(size, size, out);
+}
+export { checkBeautyOptions2, parseSize2, cameraFor2, renderBeauty2, beauty2, lodStrip2, viewFrame2, silhouette2, maskIoU2, poolMask2, maskStats2, exposure2, photoMatch2, REVIEW_THRESHOLDS2, VIEWS2, contactSheet2, detailWindows2, reviewPack2, thumbnail2 };
+
+//# debugId=42A245B665257F8A64756E2164756E21
+//# sourceMappingURL=chunk-11v28977.js.map