@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/dist/chunk-kvcep7ft.js

@@ -0,0 +1,1919 @@
+import {
+  Ts23dError2,
+  createRng2
+} from "./chunk-4ddzsqtc.js";
+
+// src/material/paint/noise.ts
+function hash2(ix, iy, seed) {
+  let h = Math.imul(ix | 0, 668265261) ^ Math.imul(iy | 0, 374761393) ^ seed;
+  h = Math.imul(h ^ h >>> 15, 2246822507);
+  h = Math.imul(h ^ h >>> 13, 3266489909);
+  return ((h ^ h >>> 16) >>> 0) / 4294967296;
+}
+function valueNoise(x, y, period, seed) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  const fx = x - xi;
+  const fy = y - yi;
+  const sx = fx * fx * (3 - 2 * fx);
+  const sy = fy * fy * (3 - 2 * fy);
+  const x0 = (xi % period + period) % period;
+  const x1 = (x0 + 1) % period;
+  const a = hash2(x0, yi, seed);
+  const b = hash2(x1, yi, seed);
+  const c = hash2(x0, yi + 1, seed);
+  const d = hash2(x1, yi + 1, seed);
+  return a + (b - a) * sx + (c - a + (d - c - b + a) * sx) * sy;
+}
+function fbm(x, y, period, seed, octaves = 4, gain = 0.5) {
+  let sum = 0;
+  let amp = 1;
+  let norm = 0;
+  let f = 1;
+  for (let o = 0;o < octaves; o++) {
+    sum += amp * valueNoise(x * f, y * f, period * f, seed + o * 1013);
+    norm += amp;
+    amp *= gain;
+    f *= 2;
+  }
+  return sum / norm * 2 - 1;
+}
+
+// src/material/paint/canvas.ts
+function createCanvas(w, h, metresU, metresV, wrapU) {
+  const n = w * h;
+  return {
+    w,
+    h,
+    metresU,
+    metresV,
+    wrapU,
+    height: new Float32Array(n),
+    tone: new Float32Array(n).fill(1),
+    rough: new Float32Array(n).fill(0.8),
+    metal: new Float32Array(n),
+    occl: new Float32Array(n).fill(1),
+    rgba: null
+  };
+}
+function periodFor(c, featureMetres) {
+  return c.wrapU ? Math.max(1, Math.round(c.metresU / featureMetres)) : 1 << 20;
+}
+function noiseAt(c, xm, ym, sizeU, sizeV, seed, octaves = 4) {
+  const finest = 1.5 * Math.max(c.metresU / c.w, c.metresV / c.h);
+  const k = Math.max(1, finest / Math.min(sizeU, sizeV));
+  const period = periodFor(c, sizeU * k);
+  const cell = c.wrapU ? c.metresU / period : sizeU * k;
+  return fbm(xm / cell, ym / (sizeV * k), period, seed, octaves);
+}
+var param = (params, key, fallback) => params?.[key] ?? fallback;
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+var smooth = (e0, e1, v) => {
+  const t = clamp01((v - e0) / (e1 - e0));
+  return t * t * (3 - 2 * t);
+};
+
+// src/material/trim-sheet.ts
+var STRIP_H = 1 / 16;
+var strips = [
+  "plain",
+  "brick",
+  "stone",
+  "slate",
+  "iron",
+  "wood",
+  "glass",
+  "concrete"
+];
+var decals = [
+  "window_sash",
+  "door_panel",
+  "clock",
+  "smokebox",
+  "sign",
+  "porthole"
+];
+var foliage = [
+  "foliage_broadleaf",
+  "foliage_maple",
+  "foliage_maple_autumn",
+  "foliage_birch",
+  "foliage_acacia",
+  "foliage_palm",
+  "foliage_spruce",
+  "foliage_spruce_snow",
+  "foliage_willow",
+  "foliage_reeds",
+  "foliage_needles"
+];
+var cells = [...decals, ...foliage];
+var FOLIAGE_SLOT = 8;
+var slotOf = (id) => {
+  const d = decals.indexOf(id);
+  return d >= 0 ? d : FOLIAGE_SLOT + foliage.indexOf(id);
+};
+var TRIM_SHEET_SIZE2 = 1024;
+function stripRect2(id) {
+  const i = strips.indexOf(id);
+  return { u0: 0, v0: i * STRIP_H, u1: 1, v1: (i + 1) * STRIP_H, metres: 2 };
+}
+function cellRect2(id) {
+  const i = slotOf(id);
+  const size = 1 / 8;
+  const u0 = i % 8 * size;
+  const v0 = 0.5 + Math.floor(i / 8) * size;
+  return { u0, v0, u1: u0 + size, v1: v0 + size, metres: 1 };
+}
+var STRIPS2 = strips;
+var CELLS2 = cells;
+var DECAL_CELLS2 = decals;
+var FOLIAGE_CELLS2 = foliage;
+var isFoliage2 = (id) => id.startsWith("foliage_");
+
+// src/material/paint/shapes.ts
+function segment(px, py, ax, ay, bx, by) {
+  const dx = bx - ax;
+  const dy = by - ay;
+  const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)));
+  return Math.hypot(px - ax - t * dx, py - ay - t * dy);
+}
+function rect(px, py, x0, y0, x1, y1) {
+  const qx = Math.max(x0 - px, px - x1);
+  const qy = Math.max(y0 - py, py - y1);
+  return qx > 0 || qy > 0 ? Math.hypot(Math.max(qx, 0), Math.max(qy, 0)) : Math.max(qx, qy);
+}
+var dome = (d, r) => d < r ? Math.sqrt(1 - (d / r) ** 2) : 0;
+function boltRing(px, py, ring, n, phase = 0) {
+  const a = Math.atan2(py, px) - phase;
+  const step = Math.PI * 2 / n;
+  const k = Math.round(a / step);
+  const ba = k * step + phase;
+  return Math.hypot(px - ring * Math.cos(ba), py - ring * Math.sin(ba));
+}
+
+// src/material/paint/cells.ts
+var PANE_TONE = 0.12;
+function paintWindowSash(c, r, seed) {
+  const cols = param(r.params, "cols", 2);
+  const rows = param(r.params, "rows", 2);
+  const frame = param(r.params, "frame", 0.07);
+  const bar = param(r.params, "bar", 0.022);
+  const meet = 0.5;
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const lower = ym < meet;
+    const y0 = lower ? frame : meet + bar;
+    const y1 = lower ? meet - bar : 1 - frame;
+    for (let x = 0;x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const i = y * c.w + x;
+      const fx = (xm - frame) / (1 - 2 * frame) * cols;
+      const fy = (ym - y0) / (y1 - y0) * rows;
+      const inX = Math.min(fx - Math.floor(fx), Math.ceil(fx) - fx) * ((1 - 2 * frame) / cols);
+      const inY = Math.min(fy - Math.floor(fy), Math.ceil(fy) - fy) * ((y1 - y0) / rows);
+      const open = -rect(xm, ym, frame, y0, 1 - frame, y1);
+      const pane = Math.min(open, inX - bar / 2, inY - bar / 2);
+      const wood = noiseAt(c, xm, ym, 0.3, 0.02, seed, 3);
+      if (pane > 0) {
+        const sky = noiseAt(c, xm, ym, 0.6, 0.6, seed + 1, 2);
+        c.height[i] = -0.012;
+        c.tone[i] = PANE_TONE + 0.05 * (ym - y0) + 0.03 * sky;
+        c.rough[i] = 0.05;
+        c.metal[i] = 0;
+      } else {
+        const bevel = smooth(0, 0.01, -pane);
+        c.height[i] = -0.012 * (1 - bevel) + 0.0003 * wood;
+        c.tone[i] = 0.9 + 0.03 * wood;
+        c.rough[i] = r.roughness;
+      }
+    }
+  }
+}
+function paintDoorPanel(c, r, seed) {
+  const stile = param(r.params, "stile", 0.12);
+  const muntin = stile * 0.7;
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const midX = 0.5;
+  const panels = [
+    [stile, 0.2, midX - muntin / 2, 0.42],
+    [midX + muntin / 2, 0.2, 1 - stile, 0.42],
+    [stile, 0.58, midX - muntin / 2, 1 - stile],
+    [midX + muntin / 2, 0.58, 1 - stile, 1 - stile]
+  ];
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    for (let x = 0;x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const i = y * c.w + x;
+      let d = 1;
+      for (const [x0, y0, x1, y1] of panels)
+        d = Math.min(d, rect(xm, ym, x0, y0, x1, y1));
+      const grain = noiseAt(c, xm, ym, 0.02, 0.4, seed, 3);
+      const recess = d < 0 ? 1 : 1 - smooth(0, 0.006, d);
+      const field = smooth(0.005, 0.04, -d);
+      c.height[i] = -0.012 * recess + 0.008 * field + 0.0003 * grain;
+      c.tone[i] = (0.8 + 0.08 * grain) * (d < 0 && d > -0.008 ? 0.65 : d < 0 ? 0.92 : 1);
+      c.rough[i] = r.roughness + 0.05 * grain;
+    }
+  }
+}
+function paintSign(c, r, _seed) {
+  const border = param(r.params, "border", 0.05);
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const screws = [0.07, 0.93];
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    for (let x = 0;x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const i = y * c.w + x;
+      const inner = -rect(xm, ym, border, border, 1 - border, 1 - border);
+      const edge = Math.min(xm, ym, 1 - xm, 1 - ym);
+      const moulding = inner < 0 ? dome(Math.abs(-inner - border / 2), border / 2) : 0;
+      let screw = 0;
+      for (const sx of screws)
+        for (const sy of screws)
+          screw = Math.max(screw, dome(Math.hypot(xm - sx, ym - sy), 0.012));
+      c.height[i] = 0.006 * moulding + 0.002 * screw - 0.002 * (1 - smooth(0, 0.004, edge));
+      c.tone[i] = inner > 0 ? 0.95 : 0.85 + 0.1 * moulding;
+      if (screw > 0) {
+        c.tone[i] = 0.6;
+        c.metal[i] = 1;
+        c.rough[i] = 0.35;
+      }
+    }
+  }
+}
+
+// src/material/paint/cells-round.ts
+var TAU = Math.PI * 2;
+function hand(px, py, hours, len) {
+  const a = hours / 12 * TAU;
+  return segment(px, py, 0, 0, Math.sin(a) * len, Math.cos(a) * len);
+}
+function paintClock(c, r, _seed) {
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const py = (y + 0.5) * pv - 0.5;
+    for (let x = 0;x < c.w; x++) {
+      const px = (x + 0.5) * pu - 0.5;
+      const i = y * c.w + x;
+      const d = Math.hypot(px, py);
+      if (d > 0.48)
+        continue;
+      const i0 = i;
+      if (d > 0.42) {
+        c.height[i0] = 0.012 * dome(Math.abs(d - 0.45), 0.03);
+        c.tone[i0] = 0.55;
+        c.metal[i0] = 1;
+        c.rough[i0] = 0.35;
+        continue;
+      }
+      const a = Math.atan2(px, py);
+      const minute = Math.abs((a / TAU * 60 + 60.5) % 1 - 0.5) * (TAU / 60) * d;
+      const hour = Math.abs((a / TAU * 12 + 12.5) % 1 - 0.5) * (TAU / 12) * d;
+      const tickM = d > 0.38 && d < 0.41 && minute < 0.003 ? 1 : 0;
+      const tickH = d > 0.32 && d < 0.41 && hour < 0.008 ? 1 : 0;
+      const hands = Math.min(hand(px, py, 10 + 10 / 60, 0.22) - 0.012, hand(px, py, 2, 0.34) - 0.007);
+      const ink = Math.max(tickM, tickH, hands < 0 ? 1 : 0, d < 0.02 ? 1 : 0);
+      c.height[i0] = -0.004 + 0.002 * ink;
+      c.tone[i0] = ink ? 0.08 : 0.96;
+      c.rough[i0] = ink ? 0.5 : r.roughness;
+      c.metal[i0] = 0;
+    }
+  }
+}
+function paintSmokebox(c, r, seed) {
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const metal = r.metalness ?? 0;
+  for (let y = 0;y < c.h; y++) {
+    const py = (y + 0.5) * pv - 0.5;
+    for (let x = 0;x < c.w; x++) {
+      const px = (x + 0.5) * pu - 0.5;
+      const i = y * c.w + x;
+      const d = Math.hypot(px, py);
+      if (d > 0.47)
+        continue;
+      const pit = noiseAt(c, px + 0.5, py + 0.5, 0.03, 0.03, seed, 3);
+      let h = 0.01 * (1 - (d / 0.47) ** 2) + 0.0004 * pit;
+      const flange = dome(Math.abs(d - 0.45), 0.02);
+      h += 0.006 * flange;
+      const bolt = dome(boltRing(px, py, 0.415, 28), 0.011);
+      h += 0.006 * bolt;
+      const strap = Math.min(segment(px, py, -0.47, 0.17, 0.12, 0.17), segment(px, py, -0.47, -0.17, 0.12, -0.17));
+      const strapH = smooth(0.024, 0.018, strap);
+      h = Math.max(h, 0.014 * strapH + h * (1 - strapH));
+      const boss = dome(d, 0.05);
+      const handle = smooth(0.012, 0.008, segment(px, py, -0.13, 0, 0.13, 0));
+      h += 0.02 * boss + 0.012 * handle;
+      c.height[i] = h;
+      c.tone[i] = (0.5 + 0.05 * pit) * (1 + 0.5 * Math.max(bolt, handle, strapH * 0.6, flange, boss));
+      c.rough[i] = r.roughness - 0.15 * Math.max(bolt, handle, boss);
+      c.metal[i] = metal + (1 - metal) * Math.max(handle, boss) * 0.8;
+    }
+  }
+}
+function paintPorthole(c, r, seed) {
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const py = (y + 0.5) * pv - 0.5;
+    for (let x = 0;x < c.w; x++) {
+      const px = (x + 0.5) * pu - 0.5;
+      const i = y * c.w + x;
+      const d = Math.hypot(px, py);
+      if (d > 0.44)
+        continue;
+      if (d < 0.29) {
+        const sky = noiseAt(c, px + 0.5, py + 0.5, 0.5, 0.5, seed, 2);
+        c.height[i] = -0.012;
+        c.tone[i] = PANE_TONE + 0.04 * (py + 0.3) + 0.02 * sky;
+        c.rough[i] = 0.05;
+        c.metal[i] = 0;
+        continue;
+      }
+      const ring = dome(Math.abs(d - 0.365), 0.075);
+      const bolt = dome(boltRing(px, py, 0.405, 10, Math.PI / 10), 0.018);
+      const lip = dome(Math.abs(d - 0.3), 0.012);
+      c.height[i] = 0.016 * ring + 0.008 * bolt + 0.004 * lip;
+      c.tone[i] = 0.75 + 0.15 * ring;
+      c.rough[i] = Math.max(0.2, r.roughness - 0.2 * ring);
+      c.metal[i] = 1;
+    }
+  }
+}
+
+// src/material/paint/foliage-common.ts
+function curve(x0, y0, x1, y1, x2, y2, n = 16) {
+  const x = [];
+  const y = [];
+  const a = [];
+  for (let i = 0;i <= n; i++) {
+    const t = i / n;
+    const u = 1 - t;
+    x.push(u * u * x0 + 2 * u * t * x1 + t * t * x2);
+    y.push(u * u * y0 + 2 * u * t * y1 + t * t * y2);
+    const dx = 2 * u * (x1 - x0) + 2 * t * (x2 - x1);
+    const dy = 2 * u * (y1 - y0) + 2 * t * (y2 - y1);
+    a.push(Math.atan2(dx, dy));
+  }
+  return { x, y, a };
+}
+var at = (c, t) => Math.round(t * (c.x.length - 1));
+function drawStem(f, c, w0, w1, col) {
+  const n = c.x.length - 1;
+  for (let i = 0;i < n; i++) {
+    const t0 = i / n;
+    const t1 = (i + 1) / n;
+    f.stem(c.x[i] ?? 0, c.y[i] ?? 0, c.x[i + 1] ?? 0, c.y[i + 1] ?? 0, w0 + (w1 - w0) * t0, w0 + (w1 - w0) * t1, col);
+  }
+}
+function vary(rng, col, amt) {
+  const k = 1 + amt * (rng.next() * 2 - 1);
+  const drift = 1 + amt * 0.6 * (rng.next() * 2 - 1);
+  return [col[0] * k * drift, col[1] * k, col[2] * k / drift];
+}
+var dim = (col, k) => [col[0] * k, col[1] * k, col[2] * k];
+var LEAF = {
+  beech: [0.09, 0.2, 0.035],
+  maple: [0.1, 0.24, 0.04],
+  birch: [0.16, 0.3, 0.05],
+  acacia: [0.11, 0.2, 0.06],
+  palm: [0.12, 0.22, 0.05],
+  dry: [0.3, 0.2, 0.08],
+  spruce: [0.035, 0.09, 0.04],
+  pine: [0.06, 0.13, 0.04],
+  willow: [0.2, 0.3, 0.08],
+  reed: [0.2, 0.28, 0.08],
+  snow: [0.85, 0.88, 0.92],
+  bark: [0.08, 0.055, 0.035],
+  twig: [0.12, 0.09, 0.05]
+};
+var AUTUMN = [
+  [0.6, 0.08, 0.02],
+  [0.75, 0.25, 0.02],
+  [0.8, 0.45, 0.03],
+  [0.45, 0.04, 0.03],
+  [0.55, 0.35, 0.05]
+];
+
+// src/material/paint/orm.ts
+var AO_DEPTH = 0.006;
+var AO_STRENGTH = 0.75;
+var AO_RADIUS = 0.02;
+function boxBlur(src, w, h, rx, ry, wrap) {
+  const tmp = new Float32Array(src.length);
+  const out = new Float32Array(src.length);
+  const ix = (i) => i < 0 ? wrap ? i % w + w : 0 : i >= w ? wrap ? i % w : w - 1 : i;
+  for (let y = 0;y < h; y++) {
+    const row = y * w;
+    let s = 0;
+    for (let k = -rx;k <= rx; k++)
+      s += src[row + ix(k)] ?? 0;
+    for (let x = 0;x < w; x++) {
+      tmp[row + x] = s / (2 * rx + 1);
+      s += (src[row + ix(x + rx + 1)] ?? 0) - (src[row + ix(x - rx)] ?? 0);
+    }
+  }
+  const iy = (j) => j < 0 ? 0 : j >= h ? h - 1 : j;
+  for (let x = 0;x < w; x++) {
+    let s = 0;
+    for (let k = -ry;k <= ry; k++)
+      s += tmp[iy(k) * w + x] ?? 0;
+    for (let y = 0;y < h; y++) {
+      out[y * w + x] = s / (2 * ry + 1);
+      s += (tmp[iy(y + ry + 1) * w + x] ?? 0) - (tmp[iy(y - ry) * w + x] ?? 0);
+    }
+  }
+  return out;
+}
+function cavityOcclusion(c) {
+  const rx = Math.max(1, Math.round(AO_RADIUS / (c.metresU / c.w)));
+  const ry = Math.max(1, Math.round(AO_RADIUS / (c.metresV / c.h)));
+  const blur = boxBlur(boxBlur(c.height, c.w, c.h, rx, ry, c.wrapU), c.w, c.h, rx, ry, c.wrapU);
+  const ao = new Float32Array(c.height.length);
+  for (let i = 0;i < ao.length; i++) {
+    const cavity = (blur[i] ?? 0) - (c.height[i] ?? 0);
+    const t = cavity <= 0 ? 0 : cavity >= AO_DEPTH ? 1 : cavity / AO_DEPTH;
+    ao[i] = (1 - AO_STRENGTH * t) * (c.occl[i] ?? 1);
+  }
+  return ao;
+}
+var SRGB = new Uint8Array(4096).map((_, i) => {
+  const l = i / 4095;
+  const s = l <= 0.0031308 ? l * 12.92 : 1.055 * l ** (1 / 2.4) - 0.055;
+  return Math.round(s * 255);
+});
+var byte = (v) => v <= 0 ? 0 : v >= 1 ? 255 : Math.round(v * 255);
+function packOrm(c, ao) {
+  const out = new Uint8Array(c.w * c.h * 4);
+  for (let i = 0, o = 0;i < ao.length; i++, o += 4) {
+    out[o] = byte(ao[i] ?? 1);
+    out[o + 1] = byte(c.rough[i] ?? 0.8);
+    out[o + 2] = byte(c.metal[i] ?? 0);
+    out[o + 3] = 255;
+  }
+  return out;
+}
+function packAlbedo(c, ao) {
+  if (c.rgba)
+    return c.rgba;
+  const out = new Uint8Array(c.w * c.h * 4);
+  for (let i = 0, o = 0;i < ao.length; i++, o += 4) {
+    const t = (c.tone[i] ?? 1) * (0.8 + 0.2 * (ao[i] ?? 1));
+    const g = SRGB[t <= 0 ? 0 : t >= 1 ? 4095 : Math.round(t * 4095)] ?? 255;
+    out[o] = g;
+    out[o + 1] = g;
+    out[o + 2] = g;
+    out[o + 3] = 255;
+  }
+  return out;
+}
+
+// src/material/paint/foliage-raster.ts
+var total = (a) => a.reduce((s, v) => s + v, 0);
+var LOBE = Math.PI * 2 / 5;
+
+class Foliage {
+  r;
+  g;
+  b;
+  a;
+  c;
+  px;
+  constructor(c) {
+    this.c = c;
+    const n = c.w * c.h;
+    this.r = new Float32Array(n);
+    this.g = new Float32Array(n);
+    this.b = new Float32Array(n);
+    this.a = new Float32Array(n);
+    this.px = c.metresU / c.w;
+    c.height.fill(0);
+  }
+  put(i, cov, col, shade, h, rough) {
+    if (cov <= 0)
+      return;
+    const k = 1 - cov;
+    const s = shade * cov;
+    this.r[i] = (this.r[i] ?? 0) * k + col[0] * s;
+    this.g[i] = (this.g[i] ?? 0) * k + col[1] * s;
+    this.b[i] = (this.b[i] ?? 0) * k + col[2] * s;
+    this.a[i] = (this.a[i] ?? 0) * k + cov;
+    this.c.height[i] = (this.c.height[i] ?? 0) * k + h * cov;
+    this.c.rough[i] = (this.c.rough[i] ?? 0.8) * k + rough * cov;
+  }
+  span(x0, y0, x1, y1) {
+    const { w, h } = this.c;
+    const p = this.px;
+    return [
+      Math.max(0, Math.floor(x0 / p) - 1),
+      Math.max(0, Math.floor(y0 / p) - 1),
+      Math.min(w - 1, Math.ceil(x1 / p) + 1),
+      Math.min(h - 1, Math.ceil(y1 / p) + 1)
+    ];
+  }
+  stem(ax, ay, bx, by, w0, w1, col) {
+    const m = Math.max(w0, w1);
+    const [sx0 = 0, sy0 = 0, sx1 = 0, sy1 = 0] = this.span(Math.min(ax, bx) - m, Math.min(ay, by) - m, Math.max(ax, bx) + m, Math.max(ay, by) + m);
+    const lx = bx - ax;
+    const ly = by - ay;
+    const l2 = lx * lx + ly * ly || 1;
+    for (let y = sy0;y <= sy1; y++) {
+      const ym = (y + 0.5) * this.px;
+      for (let x = sx0;x <= sx1; x++) {
+        const xm = (x + 0.5) * this.px;
+        const t = clamp01(((xm - ax) * lx + (ym - ay) * ly) / l2);
+        const half = (w0 + (w1 - w0) * t) / 2;
+        const d = segment(xm, ym, ax, ay, bx, by);
+        const cov = clamp01(0.5 - (d - half) / this.px);
+        const round = half > 0 ? Math.sqrt(Math.max(0, 1 - (d / half) ** 2)) : 0;
+        this.put(y * this.c.w + x, cov, col, 1, 0.0015 + half * 0.4 * round, 0.85);
+      }
+    }
+  }
+  leaf(shape, bx, by, angle, len, wid, col, serrate = 0, lift = 0) {
+    const ux = Math.sin(angle);
+    const uy = Math.cos(angle);
+    const tx = bx + ux * len;
+    const ty = by + uy * len;
+    const pad = shape === "palmate" ? len : wid;
+    const [sx0 = 0, sy0 = 0, sx1 = 0, sy1 = 0] = this.span(Math.min(bx, tx) - pad, Math.min(by, ty) - pad, Math.max(bx, tx) + pad, Math.max(by, ty) + pad);
+    for (let y = sy0;y <= sy1; y++) {
+      const ym = (y + 0.5) * this.px - by;
+      for (let x = sx0;x <= sx1; x++) {
+        const xm = (x + 0.5) * this.px - bx;
+        const along = xm * ux + ym * uy;
+        const across = xm * uy - ym * ux;
+        let sd;
+        let rib;
+        if (shape === "palmate") {
+          const rr = Math.hypot(along - len * 0.45, across);
+          const th = Math.atan2(across, along - len * 0.45);
+          const lobe = 1 - Math.abs(Math.sin(2.5 * th)) ** 0.6;
+          const edge = len * 0.5 * (0.35 + 0.65 * lobe) * (1 + serrate * Math.abs(Math.sin(18 * th)));
+          sd = rr - edge;
+          const axis = Math.round(th / LOBE) * LOBE;
+          rib = rr * Math.abs(Math.sin(th - axis));
+        } else {
+          const t = along / len;
+          if (t < 0 || t > 1) {
+            sd = Math.max(-along, along - len) + Math.abs(across) * 0.5;
+          } else {
+            const prof = shape === "ovate" ? Math.sin(Math.PI * t ** 0.8) ** 0.9 : shape === "lance" ? Math.sin(Math.PI * t ** 0.6) : shape === "blade" ? (1 - t) ** 0.4 : 1 - 0.6 * t;
+            const teeth = 1 - serrate * Math.abs(Math.sin(t * 40));
+            sd = Math.abs(across) - wid / 2 * prof * teeth;
+          }
+          rib = Math.abs(across);
+        }
+        const cov = clamp01(0.5 - sd / this.px);
+        if (cov <= 0)
+          continue;
+        const inside = clamp01(-sd / (wid * 0.5 + 0.000001));
+        const vein = 1 - smooth(0, this.px * 1.5, rib);
+        const shade = 0.85 + 0.15 * inside;
+        this.put(y * this.c.w + x, cov, col, shade, 0.002 + lift + 0.0015 * inside + 0.0006 * vein, 0.6);
+      }
+    }
+  }
+  finish(axisX = 0.5, reach = 0.35) {
+    const { w, h } = this.c;
+    const n = w * h;
+    const sa = total(this.a);
+    const mean = sa > 0 ? [total(this.r) / sa, total(this.g) / sa, total(this.b) / sa] : [0.1, 0.2, 0.05];
+    const out = new Uint8Array(n * 4);
+    const enc = (v) => SRGB[Math.round(clamp01(v) * 4095)] ?? 0;
+    for (let y = 0;y < h; y++) {
+      for (let x = 0;x < w; x++) {
+        const i = y * w + x;
+        const a = this.a[i] ?? 0;
+        const k = a > 0.02 ? 1 / a : 0;
+        const mix = clamp01(a * 4);
+        out[i * 4] = enc((this.r[i] ?? 0) * k * mix + mean[0] * (1 - mix));
+        out[i * 4 + 1] = enc((this.g[i] ?? 0) * k * mix + mean[1] * (1 - mix));
+        out[i * 4 + 2] = enc((this.b[i] ?? 0) * k * mix + mean[2] * (1 - mix));
+        out[i * 4 + 3] = Math.round(clamp01(a) * 255);
+        const d = Math.abs((x + 0.5) * this.px - axisX);
+        this.c.occl[i] = 0.55 + 0.45 * smooth(0, reach, d + (y + 0.5) * this.px * 0.4);
+      }
+    }
+    this.c.rgba = out;
+    this.c.metal.fill(0);
+  }
+}
+
+// src/material/paint/foliage-broad.ts
+function cluster(c, seed, s) {
+  const rng = createRng2(seed);
+  const f = new Foliage(c);
+  const leafAt = (x, y, a, k, lift) => {
+    const len = s.len * rng.range(0.8, 1.15) * k;
+    f.leaf(s.shape, x, y, a, len, s.wid * (len / s.len), s.colour(rng), s.serrate, lift);
+  };
+  for (let i = 0;i < s.back; i++) {
+    const x = 0.5 + rng.range(-0.33, 0.33);
+    const y = rng.range(0.3, 0.85);
+    const col = dim(s.colour(rng), 0.5);
+    const len = s.len * rng.range(0.8, 1.1);
+    f.leaf(s.shape, x, y, rng.range(-1.4, 1.4), len, s.wid * (len / s.len), col, s.serrate);
+  }
+  const main = curve(0.5, 0.02, 0.5 + rng.range(-0.1, 0.1), 0.45, 0.5 + rng.range(-0.08, 0.08), 0.8);
+  drawStem(f, main, 0.016, 0.004, LEAF.twig);
+  for (let k = 0;k < s.twigs; k++) {
+    const t = 0.22 + k / Math.max(1, s.twigs - 1) * 0.6;
+    const side = k % 2 === 0 ? 1 : -1;
+    const i = at(main, t);
+    const bx = main.x[i] ?? 0.5;
+    const by = main.y[i] ?? 0.5;
+    const a = (main.a[i] ?? 0) + side * rng.range(0.7, 1.1);
+    const len = 0.3 * (1 - t * 0.45);
+    const ex = bx + Math.sin(a) * len;
+    const ey = by + Math.cos(a) * len - s.droop * len * 0.4;
+    const twig = curve(bx, by, (bx + ex) / 2, (by + ey) / 2 + len * 0.15, ex, ey, 8);
+    drawStem(f, twig, 0.007, 0.002, LEAF.twig);
+    for (let q = 1;q <= s.perTwig; q++) {
+      const j = at(twig, q / s.perTwig);
+      const alt = q % 2 === 0 ? 1 : -1;
+      const ta = (twig.a[j] ?? 0) + (q === s.perTwig ? 0 : alt * rng.range(0.5, 0.9));
+      leafAt(twig.x[j] ?? 0, twig.y[j] ?? 0, ta, 1 - 0.15 * (1 - q / s.perTwig), 0.002);
+    }
+  }
+  const tip = main.x.length - 1;
+  leafAt(main.x[tip] ?? 0.5, main.y[tip] ?? 0.8, main.a[tip] ?? 0, 1.1, 0.003);
+  f.finish(0.5, 0.35);
+}
+function paintBroadleaf(c, seed) {
+  cluster(c, seed, {
+    shape: "ovate",
+    len: 0.15,
+    wid: 0.085,
+    serrate: 0.03,
+    twigs: 6,
+    perTwig: 3,
+    back: 16,
+    droop: 0.1,
+    colour: (rng) => vary(rng, LEAF.beech, 0.18)
+  });
+}
+function paintMaple(c, seed) {
+  cluster(c, seed, {
+    shape: "palmate",
+    len: 0.24,
+    wid: 0.24,
+    serrate: 0.04,
+    twigs: 4,
+    perTwig: 2,
+    back: 7,
+    droop: 0,
+    colour: (rng) => vary(rng, LEAF.maple, 0.15)
+  });
+}
+function paintMapleAutumn(c, seed) {
+  cluster(c, seed, {
+    shape: "palmate",
+    len: 0.24,
+    wid: 0.24,
+    serrate: 0.04,
+    twigs: 4,
+    perTwig: 2,
+    back: 7,
+    droop: 0,
+    colour: (rng) => vary(rng, rng.pick(AUTUMN), 0.12)
+  });
+}
+function paintBirch(c, seed) {
+  cluster(c, seed, {
+    shape: "ovate",
+    len: 0.085,
+    wid: 0.06,
+    serrate: 0.12,
+    twigs: 8,
+    perTwig: 5,
+    back: 22,
+    droop: 0.6,
+    colour: (rng) => vary(rng, LEAF.birch, 0.2)
+  });
+}
+
+// src/material/paint/foliage-compound.ts
+function paintAcacia(c, seed) {
+  const rng = createRng2(seed);
+  const f = new Foliage(c);
+  const rachis = curve(0.5, 0.02, 0.48 + rng.range(-0.05, 0.05), 0.5, 0.5, 0.95);
+  for (let layer = 0;layer < 2; layer++) {
+    const k = layer === 0 ? 0.5 : 1;
+    if (layer === 1)
+      drawStem(f, rachis, 0.01, 0.003, LEAF.twig);
+    const pairs = layer === 0 ? 6 : 8;
+    for (let p = 0;p < pairs; p++) {
+      const t = 0.15 + p / pairs * 0.8 + (layer === 0 ? 0.05 : 0);
+      const i = at(rachis, t);
+      for (const side of [-1, 1]) {
+        const a = (rachis.a[i] ?? 0) + side * rng.range(0.9, 1.2);
+        const len = 0.22 * (1 - t * 0.5);
+        const bx = rachis.x[i] ?? 0.5;
+        const by = rachis.y[i] ?? 0.5;
+        const pinna = curve(bx, by, bx + Math.sin(a) * len * 0.5, by + Math.cos(a) * len * 0.5 + 0.02, bx + Math.sin(a) * len, by + Math.cos(a) * len, 6);
+        drawStem(f, pinna, 0.003, 0.0015, dim(LEAF.twig, k));
+        for (let q = 1;q <= 12; q++) {
+          const j = at(pinna, q / 12.5);
+          const col = dim(vary(rng, LEAF.acacia, 0.15), k);
+          for (const s2 of [-1, 1])
+            f.leaf("ovate", pinna.x[j] ?? 0, pinna.y[j] ?? 0, (pinna.a[j] ?? 0) + s2 * 1.1, 0.03, 0.011, col, 0, layer * 0.002);
+        }
+      }
+    }
+  }
+  f.finish(0.5, 0.25);
+}
+function paintPalm(c, seed) {
+  const rng = createRng2(seed);
+  const f = new Foliage(c);
+  const rachis = curve(0.5, 0.02, 0.3, 0.7, 0.78, 0.96, 24);
+  for (let layer = 0;layer < 2; layer++) {
+    const k = layer === 0 ? 0.55 : 1;
+    const n = 26;
+    for (let q = 0;q < n; q++) {
+      const t = 0.1 + q / n * 0.9 + (layer === 0 ? 0.015 : 0);
+      const i = at(rachis, Math.min(1, t));
+      const bx = rachis.x[i] ?? 0.5;
+      const by = rachis.y[i] ?? 0.5;
+      for (const side of [-1, 1]) {
+        const a = (rachis.a[i] ?? 0) + side * rng.range(0.75, 1);
+        const len = 0.3 * Math.sin(Math.PI * (0.2 + 0.75 * t)) * rng.range(0.85, 1.05);
+        const wid = 0.03;
+        f.leaf("lance", bx, by, a, len, wid, dim(vary(rng, LEAF.palm, 0.15), k), 0, layer * 0.002);
+        if (rng.next() < 0.3) {
+          const tx = bx + Math.sin(a) * len * 0.72;
+          const ty = by + Math.cos(a) * len * 0.72;
+          f.leaf("blade", tx, ty, a, len * 0.28, wid * 0.55, dim(vary(rng, LEAF.dry, 0.2), k), 0, layer * 0.002 + 0.0002);
+        }
+      }
+    }
+    if (layer === 0)
+      drawStem(f, rachis, 0.018, 0.004, dim(LEAF.palm, 0.8));
+  }
+  f.finish(0.5, 0.2);
+}
+function paintWillow(c, seed) {
+  const rng = createRng2(seed);
+  const f = new Foliage(c);
+  const strands = 9;
+  for (let s = 0;s < strands; s++) {
+    const back = s < 3;
+    const k = back ? 0.55 : 1;
+    const ex = 0.5 + rng.range(-0.4, 0.4);
+    const strand = curve(0.5 + rng.range(-0.03, 0.03), 0.02, (0.5 + ex) / 2 + rng.range(-0.1, 0.1), 0.5, ex, rng.range(0.85, 0.97), 24);
+    drawStem(f, strand, 0.006, 0.0015, dim(LEAF.twig, k));
+    for (let q = 2;q < 30; q++) {
+      const j = at(strand, q / 30);
+      const side = q % 2 === 0 ? 1 : -1;
+      const a = (strand.a[j] ?? 0) + side * rng.range(0.2, 0.45);
+      const col = dim(vary(rng, LEAF.willow, 0.18), k);
+      f.leaf("lance", strand.x[j] ?? 0, strand.y[j] ?? 0, a, rng.range(0.07, 0.1), 0.014, col, 0, back ? 0 : 0.002);
+    }
+  }
+  f.finish(0.5, 0.2);
+}
+
+// src/material/paint/foliage-conifer.ts
+function comb(f, rng, shoot, len, k, lift) {
+  const n = shoot.x.length - 1;
+  for (let i = 0;i <= n; i++) {
+    for (const side of [-1, 1]) {
+      const a = (shoot.a[i] ?? 0) + side * rng.range(0.7, 1);
+      const col = dim(vary(rng, LEAF.spruce, 0.2), k);
+      f.leaf("needle", shoot.x[i] ?? 0, shoot.y[i] ?? 0, a, len * rng.range(0.8, 1.1), 0.006, col, 0, lift);
+    }
+  }
+}
+function spruce(c, seed, snow) {
+  const rng = createRng2(seed);
+  const f = new Foliage(c);
+  const axis = curve(0.5, 0.02, 0.5 + rng.range(-0.04, 0.04), 0.5, 0.5, 0.95, 60);
+  const shoots = [];
+  for (let s = 0;s < 8; s++) {
+    const t = 0.15 + s / 8 * 0.75;
+    const i = at(axis, t);
+    const side = s % 2 === 0 ? 1 : -1;
+    const bx = axis.x[i] ?? 0.5;
+    const by = axis.y[i] ?? 0.5;
+    const len = 0.32 * (1 - t * 0.6);
+    const a = side * rng.range(0.9, 1.2);
+    shoots.push(curve(bx, by, bx + Math.sin(a) * len * 0.5, by + Math.cos(a) * len * 0.5, bx + Math.sin(a) * len, by + Math.cos(a) * len + 0.03, 24));
+  }
+  for (const sh of shoots)
+    comb(f, rng, sh, 0.045, 0.55, 0);
+  drawStem(f, axis, 0.012, 0.004, LEAF.bark);
+  for (const sh of shoots)
+    drawStem(f, sh, 0.005, 0.002, LEAF.bark);
+  comb(f, rng, axis, 0.05, 1, 0.002);
+  for (const sh of shoots)
+    comb(f, rng, sh, 0.04, 1, 0.002);
+  if (snow) {
+    for (const sh of [axis, ...shoots]) {
+      const n = sh.x.length - 1;
+      for (let i = 2;i < n; i += 3) {
+        const col = vary(rng, LEAF.snow, 0.05);
+        f.leaf("ovate", (sh.x[i] ?? 0) - 0.02, (sh.y[i] ?? 0) + 0.008, Math.PI / 2 + rng.range(-0.3, 0.3), rng.range(0.04, 0.07), rng.range(0.025, 0.04), col, 0, 0.006);
+      }
+    }
+  }
+  f.finish(0.5, 0.25);
+}
+var paintSpruce = (c, seed) => spruce(c, seed, false);
+var paintSpruceSnow = (c, seed) => spruce(c, seed, true);
+function paintNeedles(c, seed) {
+  const rng = createRng2(seed);
+  const f = new Foliage(c);
+  const twigs = [];
+  for (let s = 0;s < 5; s++) {
+    const ex = 0.5 + (s - 2) * 0.13 + rng.range(-0.03, 0.03);
+    twigs.push(curve(0.5, 0.02, 0.5 + (ex - 0.5) * 0.4, 0.3, ex, rng.range(0.55, 0.7), 12));
+  }
+  for (const [s, tw] of twigs.entries()) {
+    drawStem(f, tw, 0.012, 0.006, LEAF.bark);
+    const k = s % 2 === 0 ? 0.6 : 1;
+    for (let i = 6;i < tw.x.length; i++) {
+      const fan = i === tw.x.length - 1 ? 14 : 4;
+      for (let q = 0;q < fan; q++) {
+        const a = (tw.a[i] ?? 0) + rng.range(-1.1, 1.1) * (fan > 4 ? 0.8 : 1.2);
+        const col = dim(vary(rng, LEAF.pine, 0.2), k);
+        f.leaf("needle", tw.x[i] ?? 0, tw.y[i] ?? 0, a, rng.range(0.12, 0.2), 0.006, col, 0, k * 0.002);
+      }
+    }
+  }
+  f.finish(0.5, 0.3);
+}
+function paintReeds(c, seed) {
+  const rng = createRng2(seed);
+  const f = new Foliage(c);
+  for (let b = 0;b < 22; b++) {
+    const back = b < 8;
+    const x = 0.5 + rng.range(-0.2, 0.2);
+    const tilt = (x - 0.5) * 1.2 + rng.range(-0.25, 0.25);
+    const col = dim(vary(rng, rng.next() < 0.2 ? LEAF.dry : LEAF.reed, 0.2), back ? 0.55 : 1);
+    f.leaf("blade", x, 0, tilt, rng.range(0.55, 0.97), rng.range(0.018, 0.032), col, 0, back ? 0 : 0.002);
+  }
+  f.finish(0.5, 0.15);
+}
+
+// src/material/paint/foliage.ts
+var FOLIAGE_PAINTERS = {
+  foliage_broadleaf: paintBroadleaf,
+  foliage_maple: paintMaple,
+  foliage_maple_autumn: paintMapleAutumn,
+  foliage_birch: paintBirch,
+  foliage_acacia: paintAcacia,
+  foliage_palm: paintPalm,
+  foliage_spruce: paintSpruce,
+  foliage_spruce_snow: paintSpruceSnow,
+  foliage_willow: paintWillow,
+  foliage_reeds: paintReeds,
+  foliage_needles: paintNeedles
+};
+
+// src/material/paint/decode-png.ts
+import { inflateSync } from "node:zlib";
+var SIG = [137, 80, 78, 71, 13, 10, 26, 10];
+var CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+function bad(cause) {
+  throw new Ts23dError2("T3D_RECIPE_INVALID", {
+    cause: `cell image: ${cause}`,
+    fix: "pass PNG bytes, 8 bits per channel, non-interlaced (e.g. re-save as RGBA8 PNG)"
+  });
+}
+function paeth(a, b, c) {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+function decodePng(bytes) {
+  if (bytes.length < 33 || SIG.some((s, i) => bytes[i] !== s))
+    bad("not a PNG (bad signature)");
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let width = 0;
+  let height = 0;
+  let type = -1;
+  let palette = new Uint8Array;
+  let trns = new Uint8Array;
+  const idat = [];
+  for (let o = 8;o + 8 <= bytes.length; ) {
+    const len = dv.getUint32(o);
+    const name = String.fromCharCode(...bytes.subarray(o + 4, o + 8));
+    const body = bytes.subarray(o + 8, o + 8 + len);
+    if (name === "IHDR") {
+      width = dv.getUint32(o + 8);
+      height = dv.getUint32(o + 12);
+      type = body[9] ?? -1;
+      if (body[8] !== 8)
+        bad(`bit depth ${body[8]} (only 8 is supported)`);
+      if (body[12] !== 0)
+        bad("interlaced");
+    } else if (name === "PLTE")
+      palette = body;
+    else if (name === "tRNS")
+      trns = body;
+    else if (name === "IDAT")
+      idat.push(body);
+    else if (name === "IEND")
+      break;
+    o += 12 + len;
+  }
+  const ch = CHANNELS[type];
+  if (!ch || width === 0 || height === 0)
+    bad(`colour type ${type} or empty image`);
+  const raw = new Uint8Array(inflateSync(Buffer.concat(idat)));
+  const stride = width * ch;
+  if (raw.length < height * (stride + 1))
+    bad("truncated image data");
+  const px = new Uint8Array(height * stride);
+  for (let y = 0;y < height; y++) {
+    const f = raw[y * (stride + 1)] ?? 0;
+    const src = y * (stride + 1) + 1;
+    const row = y * stride;
+    for (let x = 0;x < stride; x++) {
+      const a = x >= ch ? px[row + x - ch] ?? 0 : 0;
+      const b = y > 0 ? px[row - stride + x] ?? 0 : 0;
+      const c = x >= ch && y > 0 ? px[row - stride + x - ch] ?? 0 : 0;
+      const v = raw[src + x] ?? 0;
+      const pred = f === 1 ? a : f === 2 ? b : f === 3 ? a + b >> 1 : f === 4 ? paeth(a, b, c) : 0;
+      px[row + x] = v + pred & 255;
+    }
+  }
+  const data = new Uint8Array(width * height * 4);
+  for (let i = 0;i < width * height; i++) {
+    const s = i * ch;
+    const g = px[s] ?? 0;
+    const o = i * 4;
+    if (type === 3) {
+      data[o] = palette[g * 3] ?? 0;
+      data[o + 1] = palette[g * 3 + 1] ?? 0;
+      data[o + 2] = palette[g * 3 + 2] ?? 0;
+      data[o + 3] = trns[g] ?? 255;
+    } else if (ch >= 3) {
+      data[o] = g;
+      data[o + 1] = px[s + 1] ?? 0;
+      data[o + 2] = px[s + 2] ?? 0;
+      data[o + 3] = ch === 4 ? px[s + 3] ?? 255 : 255;
+    } else {
+      data[o] = g;
+      data[o + 1] = g;
+      data[o + 2] = g;
+      data[o + 3] = ch === 2 ? px[s + 1] ?? 255 : 255;
+    }
+  }
+  return { width, height, data };
+}
+
+// src/material/paint/stamp.ts
+var STAMP_ROUGHNESS = 0.6;
+function stampImage(c, png) {
+  const img = decodePng(png);
+  const out = new Uint8Array(c.w * c.h * 4);
+  for (let y = 0;y < c.h; y++) {
+    const sy = Math.min(img.height - 1, Math.max(0, (c.h - 1 - y + 0.5) / c.h * img.height - 0.5));
+    const y0 = Math.floor(sy);
+    const y1 = Math.min(img.height - 1, y0 + 1);
+    const fy = sy - y0;
+    for (let x = 0;x < c.w; x++) {
+      const sx = Math.min(img.width - 1, Math.max(0, (x + 0.5) / c.w * img.width - 0.5));
+      const x0 = Math.floor(sx);
+      const x1 = Math.min(img.width - 1, x0 + 1);
+      const fx = sx - x0;
+      for (let k = 0;k < 4; k++) {
+        const a = img.data[(y0 * img.width + x0) * 4 + k] ?? 0;
+        const b = img.data[(y0 * img.width + x1) * 4 + k] ?? 0;
+        const d = img.data[(y1 * img.width + x0) * 4 + k] ?? 0;
+        const e = img.data[(y1 * img.width + x1) * 4 + k] ?? 0;
+        const top = a + (b - a) * fx;
+        out[(y * c.w + x) * 4 + k] = Math.round(top + (d + (e - d) * fx - top) * fy);
+      }
+    }
+  }
+  c.rgba = out;
+  c.height.fill(0);
+  c.rough.fill(STAMP_ROUGHNESS);
+  c.metal.fill(0);
+}
+
+// src/material/paint/courses.ts
+class Courses {
+  id;
+  dx;
+  ux;
+  index = -1;
+  y0 = 0;
+  y1 = 0;
+  bounds = [0];
+  c;
+  spec;
+  constructor(c, spec) {
+    this.c = c;
+    this.spec = spec;
+    this.id = new Int32Array(c.w);
+    this.dx = new Float32Array(c.w);
+    this.ux = new Float32Array(c.w);
+    const rng = createRng2(spec.seed).fork("rows");
+    let y = 0;
+    while (y < c.metresV) {
+      y += spec.course * (1 + spec.irregular * (rng.next() - 0.5));
+      this.bounds.push(y);
+    }
+  }
+  at(ym) {
+    if (this.index >= 0 && ym >= this.y0 && ym < this.y1)
+      return this.index;
+    let k = 0;
+    while (k < this.bounds.length - 2 && ym >= (this.bounds[k + 1] ?? 0))
+      k++;
+    this.index = k;
+    this.y0 = this.bounds[k] ?? 0;
+    this.y1 = this.bounds[k + 1] ?? this.c.metresV;
+    this.fill(k);
+    return k;
+  }
+  fill(k) {
+    const { w, metresU } = this.c;
+    const s = this.spec;
+    const rng = createRng2(s.seed).fork(`course${k}`);
+    const n = Math.max(1, Math.round(metresU / s.length));
+    const lens = [];
+    for (let i = 0;i < n; i++)
+      lens.push(1 + s.irregular * (rng.next() - 0.5));
+    const total = lens.reduce((a, b) => a + b, 0);
+    const joints = [0];
+    for (const l of lens)
+      joints.push((joints[joints.length - 1] ?? 0) + l / total * metresU);
+    const shift = s.irregular > 0 ? rng.next() * metresU : k % 2 * s.stagger * (metresU / n);
+    const px = metresU / w;
+    for (let x = 0;x < w; x++) {
+      let u = ((x + 0.5) * px - shift) % metresU;
+      if (u < 0)
+        u += metresU;
+      let t = 0;
+      while (t < n - 1 && u >= (joints[t + 1] ?? metresU))
+        t++;
+      const a = joints[t] ?? 0;
+      const b = joints[t + 1] ?? metresU;
+      this.id[x] = t;
+      this.ux[x] = u - a;
+      this.dx[x] = Math.min(u - a, b - u);
+    }
+  }
+}
+
+// src/material/paint/bond.ts
+function paintBond(c, r, seed) {
+  const p = r.params;
+  const mortar = param(p, "mortar", 0.01);
+  const depth = param(p, "depth", 0.006);
+  const bevel = param(p, "bevel", 0.004);
+  const relief = param(p, "relief", 0.0008);
+  const variation = param(p, "variation", 0.3);
+  const course = param(p, "course", 0.075);
+  const length = param(p, "length", 0.225);
+  const courses = new Courses(c, {
+    course,
+    length,
+    irregular: param(p, "irregular", 0),
+    stagger: param(p, "stagger", 0.5),
+    seed
+  });
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const half = mortar / 2;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const k = courses.at(ym);
+    const dy = Math.min(ym - courses.y0, courses.y1 - ym);
+    for (let x = 0;x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const unit = courses.id[x] ?? 0;
+      const chip = noiseAt(c, xm, ym, 0.02, 0.02, seed + 7, 3) * mortar * 0.6;
+      const d = Math.min(courses.dx[x] ?? 0, dy) + chip;
+      const fine = noiseAt(c, xm, ym, 0.006, 0.006, seed + 11, 2);
+      if (d < half) {
+        c.height[i] = -depth + fine * 0.0006;
+        c.tone[i] = 0.95 + 0.04 * fine;
+        c.rough[i] = Math.min(1, r.roughness + 0.08);
+        continue;
+      }
+      const h = hash2(k, unit, seed);
+      const h2 = hash2(unit, k, seed + 3);
+      const big = noiseAt(c, xm, ym, length * 0.6, course * 0.8, seed + 5, 3);
+      const edge = smooth(0, bevel, d - half);
+      const tilt = ((h2 - 0.5) * (courses.ux[x] ?? 0) * 0.02 + (h - 0.5) * 0.001) * edge;
+      const pit = fine > 0.55 ? (fine - 0.55) * 0.004 : 0;
+      c.height[i] = -depth * (1 - edge) + relief * big + tilt - pit;
+      c.tone[i] = (0.62 - variation * 0.5 + variation * h) * (1 + 0.15 * big + 0.05 * fine) - pit * 40;
+      c.rough[i] = r.roughness + 0.06 * fine;
+    }
+  }
+}
+
+// src/material/paint/concrete.ts
+var PORE_CELL = 0.008;
+function paintConcrete(c, r, seed) {
+  const p = r.params;
+  const pores = param(p, "pores", 0.35);
+  const ties = param(p, "ties", 0.6);
+  const lift = param(p, "lift", 0.6);
+  const mottle = param(p, "mottle", 0.1);
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const cellM = Math.max(PORE_CELL, 2.5 * Math.max(pu, pv));
+  const pPer = periodFor(c, cellM);
+  const pCell = c.wrapU ? c.metresU / pPer : cellM;
+  const tPer = ties > 0 ? periodFor(c, ties) : 1;
+  const tCell = c.wrapU ? c.metresU / tPer : ties;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const liftD = lift > 0 ? Math.abs(ym - Math.round(ym / lift) * lift) : 1;
+    const liftGroove = 1 - smooth(0, 0.003, liftD);
+    const liftBand = lift > 0 ? hash2(Math.floor(ym / lift), 0, seed + 4) - 0.5 : 0;
+    for (let x = 0;x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const big = noiseAt(c, xm, ym, 0.25, 0.25, seed, 4);
+      const fine = noiseAt(c, xm, ym, 0.004, 0.004, seed + 2, 2);
+      const ix = Math.floor(xm / pCell) % pPer;
+      const iy = Math.floor(ym / pCell);
+      let pit = 0;
+      if (hash2(ix, iy, seed + 5) < pores) {
+        const cx = (ix + 0.2 + 0.6 * hash2(ix, iy, seed + 6)) * pCell;
+        const cy = (iy + 0.2 + 0.6 * hash2(ix, iy, seed + 7)) * pCell;
+        const rad = pCell * (0.12 + 0.25 * hash2(ix, iy, seed + 8));
+        const d = Math.hypot(xm - cx, ym - cy);
+        pit = d < rad ? 1 - d / rad : 0;
+      }
+      let tie = 0;
+      if (ties > 0) {
+        const tx = xm - (Math.floor(xm / tCell) + 0.5) * tCell;
+        const ty = ym - (Math.floor(ym / ties) + 0.5) * ties;
+        const d = Math.hypot(tx, ty);
+        tie = d < 0.012 ? 1 : 0;
+      }
+      c.height[i] = 0.0005 * big + 0.00015 * fine - 0.0015 * pit - 0.006 * tie - 0.0012 * liftGroove;
+      c.tone[i] = (0.78 + mottle * big + 0.05 * liftBand) * (1 + 0.04 * fine) * (1 - 0.4 * pit) * (1 - 0.5 * tie);
+      c.rough[i] = r.roughness + 0.05 * fine + 0.05 * big;
+    }
+  }
+}
+
+// src/material/paint/masks.ts
+function rustStreaks(c, amount, seed) {
+  if (amount <= 0)
+    return;
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    for (let x = 0;x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const run = noiseAt(c, xm, ym, 0.025, 0.6, seed, 3);
+      const patch = noiseAt(c, xm, ym, 0.3, 0.3, seed + 1, 2);
+      const m = amount * smooth(0.15, 0.6, run) * smooth(-0.1, 0.4, patch);
+      if (m <= 0)
+        continue;
+      const i = y * c.w + x;
+      c.tone[i] = (c.tone[i] ?? 1) * (1 - 0.4 * m);
+      c.rough[i] = Math.min(1, (c.rough[i] ?? 0.8) + 0.2 * m);
+      c.metal[i] = (c.metal[i] ?? 0) * (1 - m);
+    }
+  }
+}
+function grime(c, amount, seed) {
+  if (amount <= 0)
+    return;
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const low = (1 - ym / c.metresV) ** 2;
+    for (let x = 0;x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const streak = smooth(0, 0.7, noiseAt(c, xm, ym, 0.05, 0.5, seed, 3));
+      const blot = 0.6 + 0.4 * noiseAt(c, xm, ym, 0.2, 0.2, seed + 1, 3);
+      const m = amount * Math.min(1, low * blot + 0.35 * streak);
+      const i = y * c.w + x;
+      c.tone[i] = (c.tone[i] ?? 1) * (1 - 0.3 * m);
+      c.rough[i] = Math.min(1, (c.rough[i] ?? 0.8) + 0.1 * m);
+    }
+  }
+}
+
+// src/material/paint/planks.ts
+function paintPlanks(c, r, seed) {
+  const p = r.params;
+  const width = param(p, "width", 0.15);
+  const length = param(p, "length", 1);
+  const gap = param(p, "gap", 0.004);
+  const depth = param(p, "depth", 0.004);
+  const knots = param(p, "knots", 1.5);
+  const boards = new Courses(c, { course: width, length, irregular: 0.6, stagger: 0, seed });
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const k = boards.at(ym);
+    const dy = Math.min(ym - boards.y0, boards.y1 - ym);
+    const vy = (ym - boards.y0) / (boards.y1 - boards.y0);
+    for (let x = 0;x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const id = boards.id[x] ?? 0;
+      const h = hash2(k, id, seed);
+      const d = Math.min((boards.dx[x] ?? 0) * 1.5, dy);
+      const edge = smooth(gap * 0.5, gap * 1.5, d);
+      const warp = noiseAt(c, xm, ym, 0.4, 0.05, seed + id * 31 + k * 7, 3);
+      const ring = Math.sin((vy * 9 + warp * 3 + h * 6) * Math.PI * 2);
+      const fibre = noiseAt(c, xm, ym, 0.08, 0.002, seed + 17, 2);
+      let knot = 0;
+      const nk = Math.floor(knots * length * h * 2);
+      for (let q = 0;q < nk; q++) {
+        const kx = hash2(k * 13 + q, id, seed + 41) * c.metresU;
+        const ky = boards.y0 + (0.25 + 0.5 * hash2(k, id * 5 + q, seed + 43)) * (boards.y1 - boards.y0);
+        let ddx = Math.abs(xm - kx);
+        if (c.wrapU)
+          ddx = Math.min(ddx, c.metresU - ddx);
+        const rr = Math.sqrt((ddx / 2.2) ** 2 + (ym - ky) ** 2) / (width * 0.12);
+        if (rr < 1)
+          knot = Math.max(knot, 1 - rr);
+      }
+      c.height[i] = -depth * (1 - edge) + 0.0004 * ring * edge + 0.0003 * fibre - 0.0008 * knot;
+      c.tone[i] = (0.66 + 0.22 * h) * (1 + 0.08 * ring + 0.06 * fibre) * (1 - 0.5 * knot) * (0.5 + 0.5 * edge);
+      c.rough[i] = r.roughness + 0.05 * fibre + 0.1 * (1 - edge);
+    }
+  }
+}
+
+// src/material/paint/plates.ts
+function along(q, pitch) {
+  const t = q / pitch;
+  return Math.abs(t - Math.round(t)) * pitch;
+}
+function paintPlates(c, r, seed) {
+  const p = r.params;
+  const lap = param(p, "lap", 0.003);
+  const rivet = param(p, "rivet", 0.014);
+  const pitch = param(p, "pitch", 0.09);
+  const inset = param(p, "inset", 0.05);
+  const chips = param(p, "chips", 0.3);
+  const metal = r.metalness ?? 0;
+  const plates = new Courses(c, {
+    course: param(p, "height", 0.5),
+    length: param(p, "width", 1),
+    irregular: 0,
+    stagger: 0.5,
+    seed
+  });
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const k = plates.at(ym);
+    const dy = Math.min(ym - plates.y0, plates.y1 - ym);
+    for (let x = 0;x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const ux = plates.ux[x] ?? 0;
+      const dx = plates.dx[x] ?? 0;
+      const id = plates.id[x] ?? 0;
+      const hammer = noiseAt(c, xm, ym, 0.05, 0.05, seed + 3, 3);
+      const fine = noiseAt(c, xm, ym, 0.004, 0.004, seed + 9, 2);
+      const seam = Math.min(dx, dy);
+      let h = lap * smooth(0, 0.004, ux) + 0.0004 * hammer - 0.001 * (1 - smooth(0, 0.0015, seam));
+      const ry = Math.abs(dy - inset);
+      const rx = Math.abs(dx - inset);
+      const d1 = Math.sqrt(rx * rx + along(ym - plates.y0, pitch) ** 2);
+      const d2 = Math.sqrt(ry * ry + along(xm, pitch) ** 2);
+      const d = Math.min(dx > inset * 2 ? 1 : d1, dy > inset * 2 ? 1 : d2);
+      const dome = d < rivet ? Math.sqrt(1 - (d / rivet) ** 2) : 0;
+      h += dome * rivet * 0.5;
+      const chip = smooth(0.35, 0.45, noiseAt(c, xm, ym, 0.03, 0.03, seed + 21, 4) - (seam * 6 + 0.2) + chips * 0.3);
+      c.height[i] = h - chip * 0.0003;
+      c.tone[i] = (0.8 + 0.06 * hash2(k, id, seed)) * (1 + 0.06 * hammer + 0.03 * fine) * (1 + 0.15 * dome);
+      c.rough[i] = r.roughness + 0.08 * fine - 0.25 * chip;
+      c.metal[i] = metal + (1 - metal) * chip;
+    }
+  }
+  rustStreaks(c, param(p, "rust", 0.4), seed + 77);
+}
+
+// src/material/paint/slate.ts
+function paintSlate(c, r, seed) {
+  const p = r.params;
+  const course = param(p, "course", 0.11);
+  const gap = param(p, "gap", 0.003);
+  const thick = param(p, "thick", 0.007);
+  const variation = param(p, "variation", 0.3);
+  const rows = new Courses(c, {
+    course,
+    length: param(p, "length", 0.25),
+    irregular: 0.15,
+    stagger: 0.5,
+    seed
+  });
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const k = rows.at(ym);
+    const span = rows.y1 - rows.y0;
+    for (let x = 0;x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const id = rows.id[x] ?? 0;
+      const h = hash2(k, id, seed);
+      const chip = (noiseAt(c, xm, ym, 0.015, 0.01, seed + 5, 3) + 0.3) * span * 0.08;
+      const uy = Math.max(0, ym - rows.y0 - Math.max(0, chip));
+      const t = uy / span;
+      const lam = noiseAt(c, xm, ym, 0.12, 0.004, seed + 9, 3);
+      const fine = noiseAt(c, xm, ym, 0.005, 0.005, seed + 13, 2);
+      const sideGap = smooth(gap * 0.5, gap * 1.2, rows.dx[x] ?? 0);
+      const bevel = smooth(0, 0.004, uy);
+      const tilt = (hash2(id, k, seed + 1) - 0.5) * 0.002 * ((rows.ux[x] ?? 0) / 0.25);
+      c.height[i] = (thick * (1 - t) * bevel + 0.0005 * lam + tilt) * sideGap - thick * (1 - sideGap);
+      c.tone[i] = (0.62 - variation * 0.5 + variation * h) * (1 + 0.08 * lam + 0.04 * fine) * (0.55 + 0.45 * sideGap);
+      c.rough[i] = r.roughness + 0.08 * lam + 0.05 * fine;
+    }
+  }
+}
+
+// src/material/paint/surface.ts
+function paintFlat(c, r) {
+  c.tone.fill(param(r.params, "tone", 1));
+  c.rough.fill(r.roughness);
+  c.metal.fill(r.metalness ?? 0);
+  c.height.fill(0);
+}
+function paintNoise(c, r, seed) {
+  const tone = param(r.params, "tone", 0.93);
+  const mottle = param(r.params, "mottle", 0.03);
+  const relief = param(r.params, "relief", 0.0002);
+  const size = param(r.params, "size", 0.3);
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const metal = r.metalness ?? 0;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    for (let x = 0;x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const big = noiseAt(c, xm, ym, size, size, seed, 4);
+      const fine = noiseAt(c, xm, ym, 0.01, 0.01, seed + 1, 2);
+      const i = y * c.w + x;
+      c.tone[i] = tone + mottle * big;
+      c.rough[i] = r.roughness + 0.06 * big + 0.03 * fine;
+      c.metal[i] = metal;
+      c.height[i] = relief * (big + 0.3 * fine);
+    }
+  }
+}
+function paintGlass(c, r, seed) {
+  const ripple = param(r.params, "ripple", 0.0002);
+  const smudge = param(r.params, "smudge", 0.08);
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    for (let x = 0;x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const wave = noiseAt(c, xm, ym, 0.15, 0.4, seed, 3);
+      const smear = noiseAt(c, xm, ym, 0.08, 0.08, seed + 1, 4);
+      const i = y * c.w + x;
+      c.tone[i] = 0.92 + 0.02 * wave;
+      c.rough[i] = r.roughness + smudge * Math.max(0, smear);
+      c.metal[i] = 0;
+      c.height[i] = ripple * wave;
+    }
+  }
+  grime(c, param(r.params, "grime", 0.4), seed + 9);
+}
+
+// src/material/paint/strip.ts
+function paintStrip(c, r, seed) {
+  switch (r.kind) {
+    case "bond":
+      paintBond(c, r, seed);
+      break;
+    case "planks":
+      paintPlanks(c, r, seed);
+      break;
+    case "plates":
+      paintPlates(c, r, seed);
+      break;
+    case "slate":
+      paintSlate(c, r, seed);
+      break;
+    case "concrete":
+      paintConcrete(c, r, seed);
+      break;
+    case "glass":
+      paintGlass(c, r, seed);
+      return;
+    case "noise":
+      paintNoise(c, r, seed);
+      break;
+    case "flat":
+      paintFlat(c, r);
+      return;
+  }
+  grime(c, param(r.params, "grime", 0), seed + 101);
+}
+
+// src/material/paint/cell.ts
+var MOTIFS = {
+  window_sash: paintWindowSash,
+  door_panel: paintDoorPanel,
+  clock: paintClock,
+  smokebox: paintSmokebox,
+  sign: paintSign,
+  porthole: paintPorthole
+};
+var LEAF_ROUGHNESS = 0.6;
+function paintCell(c, id, entry, seed) {
+  if ("image" in entry) {
+    stampImage(c, entry.image);
+    return;
+  }
+  if (isFoliage2(id)) {
+    FOLIAGE_PAINTERS[id](c, seed);
+    const k = entry.roughness / LEAF_ROUGHNESS;
+    for (let i = 0;i < c.rough.length; i++)
+      c.rough[i] = Math.min(1, (c.rough[i] ?? 0.6) * k);
+    return;
+  }
+  paintStrip(c, entry, seed);
+  MOTIFS[id]?.(c, entry, seed + 1);
+}
+
+// src/material/paint/normal.ts
+function neighbours(n, wrap) {
+  const lo = new Int32Array(n);
+  const hi = new Int32Array(n);
+  for (let i = 0;i < n; i++) {
+    lo[i] = i > 0 ? i - 1 : wrap ? n - 1 : 0;
+    hi[i] = i < n - 1 ? i + 1 : wrap ? 0 : n - 1;
+  }
+  return { lo, hi };
+}
+function sobelNormals(c, strength = 1) {
+  const { w, h, height } = c;
+  const out = new Uint8Array(w * h * 4);
+  const cx = neighbours(w, c.wrapU);
+  const cy = neighbours(h, false);
+  const sx = strength / (8 * (c.metresU / w));
+  const sy = strength / (8 * (c.metresV / h));
+  for (let y = 0;y < h; y++) {
+    const r0 = (cy.lo[y] ?? 0) * w;
+    const r1 = y * w;
+    const r2 = (cy.hi[y] ?? 0) * w;
+    for (let x = 0;x < w; x++) {
+      const xl = cx.lo[x] ?? 0;
+      const xr = cx.hi[x] ?? 0;
+      const tl = height[r0 + xl] ?? 0;
+      const tc = height[r0 + x] ?? 0;
+      const tr = height[r0 + xr] ?? 0;
+      const ml = height[r1 + xl] ?? 0;
+      const mr = height[r1 + xr] ?? 0;
+      const bl = height[r2 + xl] ?? 0;
+      const bc = height[r2 + x] ?? 0;
+      const br = height[r2 + xr] ?? 0;
+      const gx = (tr + 2 * mr + br - tl - 2 * ml - bl) * sx;
+      const gy = (bl + 2 * bc + br - tl - 2 * tc - tr) * sy;
+      const inv = 1 / Math.sqrt(gx * gx + gy * gy + 1);
+      const o = (r1 + x) * 4;
+      out[o] = Math.round((-gx * inv * 0.5 + 0.5) * 255);
+      out[o + 1] = Math.round((gy * inv * 0.5 + 0.5) * 255);
+      out[o + 2] = Math.round((inv * 0.5 + 0.5) * 255);
+      out[o + 3] = 255;
+    }
+  }
+  return out;
+}
+
+// src/material/paint/compose.ts
+function blankSheet(size) {
+  const n = size * size * 4;
+  const albedo = new Uint8Array(n).fill(255);
+  const normal = new Uint8Array(n);
+  const orm = new Uint8Array(n);
+  const flat = new Uint8Array([128, 128, 255, 255]);
+  const base = new Uint8Array([255, 204, 0, 255]);
+  for (let i = 0;i < n; i += 4) {
+    normal.set(flat, i);
+    orm.set(base, i);
+  }
+  return { size, albedo, normal, orm };
+}
+function composeRegion(sheet, c, x0, y0, pad) {
+  const ao = cavityOcclusion(c);
+  const maps = [
+    [sheet.albedo, packAlbedo(c, ao)],
+    [sheet.normal, sobelNormals(c)],
+    [sheet.orm, packOrm(c, ao)]
+  ];
+  const padX = c.wrapU ? 0 : pad;
+  for (let y = 0;y < c.h; y++) {
+    const sy = Math.min(c.h - 1 - pad, Math.max(pad, y));
+    const dst = ((y0 + y) * sheet.size + x0) * 4;
+    const src = sy * c.w;
+    const l = (src + padX) * 4;
+    const r = (src + c.w - 1 - padX) * 4;
+    for (const [to, from] of maps) {
+      to.set(from.subarray(l, r + 4), dst + padX * 4);
+      for (let x = 0;x < padX; x++) {
+        to.set(from.subarray(l, l + 4), dst + x * 4);
+        to.set(from.subarray(r, r + 4), dst + (c.w - 1 - x) * 4);
+      }
+    }
+  }
+}
+
+// src/material/paint/default-sheet.ts
+var leaf = { kind: "flat", scaleMetres: 1, roughness: 0.6 };
+var DEFAULT_SHEET2 = {
+  seed: 1,
+  size: 1024,
+  strips: {
+    plain: { kind: "noise", scaleMetres: 1, roughness: 0.6 },
+    brick: { kind: "bond", scaleMetres: 0.45, roughness: 0.85, params: { grime: 0.2 } },
+    stone: {
+      kind: "bond",
+      scaleMetres: 0.9,
+      roughness: 0.9,
+      params: {
+        course: 0.22,
+        length: 0.4,
+        mortar: 0.016,
+        depth: 0.012,
+        bevel: 0.025,
+        irregular: 0.5,
+        relief: 0.004,
+        variation: 0.3,
+        grime: 0.2
+      }
+    },
+    slate: { kind: "slate", scaleMetres: 0.66, roughness: 0.7 },
+    iron: { kind: "plates", scaleMetres: 0.5, roughness: 0.55, metalness: 0 },
+    wood: { kind: "planks", scaleMetres: 0.6, roughness: 0.75 },
+    glass: { kind: "glass", scaleMetres: 1, roughness: 0.05 },
+    concrete: { kind: "concrete", scaleMetres: 1, roughness: 0.9, params: { grime: 0.3 } }
+  },
+  cells: {
+    window_sash: { kind: "noise", scaleMetres: 1, roughness: 0.5 },
+    door_panel: { kind: "noise", scaleMetres: 1, roughness: 0.6 },
+    clock: { kind: "noise", scaleMetres: 1, roughness: 0.3 },
+    smokebox: {
+      kind: "plates",
+      scaleMetres: 1,
+      roughness: 0.6,
+      metalness: 0.2,
+      params: { rust: 0.3 }
+    },
+    sign: { kind: "noise", scaleMetres: 1, roughness: 0.5 },
+    porthole: { kind: "plates", scaleMetres: 1, roughness: 0.5 },
+    foliage_broadleaf: leaf,
+    foliage_maple: leaf,
+    foliage_maple_autumn: leaf,
+    foliage_birch: leaf,
+    foliage_acacia: leaf,
+    foliage_palm: leaf,
+    foliage_spruce: leaf,
+    foliage_spruce_snow: leaf,
+    foliage_willow: leaf,
+    foliage_reeds: leaf,
+    foliage_needles: leaf
+  }
+};
+
+// src/material/paint/validate.ts
+var KINDS = [
+  "bond",
+  "planks",
+  "plates",
+  "noise",
+  "flat",
+  "slate",
+  "concrete",
+  "glass"
+];
+var SIZES = [512, 1024, 2048];
+function fail(cause, fix) {
+  throw new Ts23dError2("T3D_RECIPE_INVALID", { cause: `sheet recipe: ${cause}`, fix });
+}
+var unit = (v) => Number.isFinite(v) && v >= 0 && v <= 1;
+function validateStrip(where, r) {
+  if (!KINDS.includes(r.kind))
+    fail(`${where}.kind '${r.kind}' is unknown`, `use one of ${KINDS.join(" | ")}`);
+  if (!(Number.isFinite(r.scaleMetres) && r.scaleMetres > 0))
+    fail(`${where}.scaleMetres is ${r.scaleMetres}`, "set the metres the strip V span represents, > 0 (e.g. 0.6 for brick)");
+  if (!unit(r.roughness))
+    fail(`${where}.roughness is ${r.roughness}`, "roughness is 0..1");
+  if (r.metalness !== undefined && !unit(r.metalness))
+    fail(`${where}.metalness is ${r.metalness}`, "metalness is 0..1");
+  for (const [k, v] of Object.entries(r.params ?? {}))
+    if (!Number.isFinite(v))
+      fail(`${where}.params.${k} is ${v}`, "params are finite numbers");
+}
+function validateSheet(recipe) {
+  if (!Number.isInteger(recipe.seed))
+    fail(`seed ${recipe.seed}`, "seed is an integer");
+  if (recipe.size !== undefined && !SIZES.includes(recipe.size))
+    fail(`size ${recipe.size}`, "size is 512, 1024 or 2048");
+  for (const [id, r] of Object.entries(recipe.strips)) {
+    if (!STRIPS2.includes(id))
+      fail(`strip '${id}' is not in the layout`, `strips are ${STRIPS2.join(", ")}`);
+    if (r)
+      validateStrip(`strips.${id}`, r);
+  }
+  for (const [id, e] of Object.entries(recipe.cells ?? {})) {
+    if (!CELLS2.includes(id))
+      fail(`cell '${id}' is not in the layout`, `cells are ${CELLS2.join(", ")}`);
+    if (!e)
+      continue;
+    if ("image" in e) {
+      if (!(e.image instanceof Uint8Array))
+        fail(`cells.${id}.image is not bytes`, "pass PNG file bytes as a Uint8Array");
+    } else
+      validateStrip(`cells.${id}`, e);
+  }
+}
+
+// src/material/generator.ts
+var FALLBACK = { kind: "noise", scaleMetres: 1, roughness: 0.6 };
+function paintTrimSheet2(recipe = DEFAULT_SHEET2) {
+  validateSheet(recipe);
+  const size = recipe.size ?? 1024;
+  const sheet = blankSheet(size);
+  const rng = createRng2(recipe.seed);
+  const seedOf = (name) => rng.fork(name).int(0, 2147483647);
+  const pad = Math.max(2, size / 256);
+  for (const id of STRIPS2) {
+    const r = recipe.strips[id] ?? DEFAULT_SHEET2.strips[id] ?? FALLBACK;
+    validateStrip(`strips.${id}`, r);
+    const rect = stripRect2(id);
+    const h = Math.round((rect.v1 - rect.v0) * size);
+    const c = createCanvas(size, h, rect.metres, r.scaleMetres, true);
+    paintStrip(c, r, seedOf(id));
+    composeRegion(sheet, c, 0, Math.round(rect.v0 * size), pad);
+  }
+  for (const id of CELLS2) {
+    const e = recipe.cells?.[id] ?? DEFAULT_SHEET2.cells?.[id] ?? FALLBACK;
+    const rect = cellRect2(id);
+    const w = Math.round((rect.u1 - rect.u0) * size);
+    const c = createCanvas(w, w, rect.metres, rect.metres, false);
+    paintCell(c, id, e, seedOf(id));
+    composeRegion(sheet, c, Math.round(rect.u0 * size), Math.round(rect.v0 * size), pad);
+  }
+  return sheet;
+}
+// src/material/palette.ts
+function hex2(value) {
+  const n = Number.parseInt(value.replace("#", ""), 16);
+  const lin = (c) => {
+    const s = c / 255;
+    return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  };
+  return [lin(n >> 16 & 255), lin(n >> 8 & 255), lin(n & 255)];
+}
+function definePalette2(entries) {
+  return Object.fromEntries(Object.entries(entries).map(([k, v]) => [k, hex2(v)]));
+}
+var palettes2 = {
+  victorianRail: definePalette2({
+    paint: "#2f4a3a",
+    trim: "#b08d57",
+    iron: "#2b2b2e",
+    brass: "#c9a24a",
+    red: "#7a2a22"
+  }),
+  artDeco: definePalette2({
+    limestone: "#d8cfbd",
+    steel: "#9aa3ad",
+    glass: "#4a6a80",
+    bronze: "#8a6a3c"
+  }),
+  modernGlass: definePalette2({
+    glass: "#6f8fa8",
+    aluminium: "#c4c9cf",
+    concrete: "#a7a39b"
+  }),
+  harbour: definePalette2({ hull: "#1f2f45", deck: "#8a6f4e", white: "#e8e6df", red: "#a1302a" })
+};
+// src/material/shader-godot.ts
+var f = (n) => Number.isInteger(n) ? `${n}.0` : `${+n.toFixed(6)}`;
+var rect2 = (r) => `in_rect(UV, vec4(${f(r.u0)}, ${f(r.v0)}, ${f(r.u1)}, ${f(r.v1)}))`;
+function godotSource(p) {
+  const modes = ["blend_mix", "depth_draw_opaque", p.cutout ? "cull_disabled" : "cull_back"];
+  const weight = p.windAttribute ? "CUSTOM0.x /* import _WIND into CUSTOM0 (glTF import: custom attribute mapping) */" : "smoothstep(0.0, wind_height, VERTEX.z)";
+  return `// Generated by @developerz.ai/ts23d godotShaderSource(). A starting point your project owns:
+// assign it to a ShaderMaterial and set albedo_tex / normal_tex / orm_tex from the GLB's
+// ts23d_* material (or the shared trim_sheet_{albedo,normal,orm}.png). Godot 4.x.
+shader_type spatial;
+render_mode ${modes.join(", ")};
+
+uniform sampler2D albedo_tex : source_color, filter_linear_mipmap, repeat_enable;
+uniform sampler2D normal_tex : hint_normal, filter_linear_mipmap, repeat_enable;
+uniform sampler2D orm_tex : hint_default_white, filter_linear_mipmap, repeat_enable;
+
+uniform float night : hint_range(0.0, 1.0) = 0.0;
+uniform float wind_strength = ${f(p.windStrength)};
+uniform float wind_height = ${f(p.windHeight)};
+uniform float wind_hz = ${f(p.windHz)};
+uniform vec3 glow_color : source_color = vec3(${f(p.glow[0])}, ${f(p.glow[1])}, ${f(p.glow[2])});
+uniform float glow_ratio : hint_range(0.0, 1.0) = ${f(p.glowRatio)};
+uniform float glow_intensity = ${f(p.glowIntensity)};
+uniform float wear : hint_range(0.0, 1.0) = ${f(p.wear)};
+uniform float grime_height = ${f(p.grimeHeight)};
+
+varying vec3 world_pos;
+
+float in_rect(vec2 uv, vec4 r) {
+	float u = fract(uv.x);
+	return step(r.x, u) * step(u, r.z) * step(r.y, uv.y) * step(uv.y, r.w);
+}
+
+float hash13(vec3 p) {
+	p = fract(p * 0.1031);
+	p += dot(p, p.zyx + 31.32);
+	return fract((p.x + p.y) * p.z);
+}
+
+void vertex() {
+	// Wind sway: mesh-local Z is the authored up axis; sway in local XY.
+	float weight = ${weight};
+	float phase = VERTEX.x * 0.7 + VERTEX.y * 0.45;
+	float sway = sin(TIME * wind_hz * 6.2832 + phase) * wind_strength * weight * 0.1;
+	VERTEX.xy += vec2(sway, sway * 0.6);
+	world_pos = (MODEL_MATRIX * vec4(VERTEX, 1.0)).xyz;
+}
+
+void fragment() {
+	vec4 base = texture(albedo_tex, UV);
+	vec3 orm = texture(orm_tex, UV).rgb;
+	float ground = 1.0 - smoothstep(0.0, grime_height, world_pos.y);
+	float grime = clamp(wear * max((1.0 - orm.r) * 1.5, ground), 0.0, 1.0);
+	ALBEDO = base.rgb * COLOR.rgb * (1.0 - grime * 0.45);
+	AO = orm.r;
+	ROUGHNESS = clamp(orm.g + grime * 0.2, 0.0, 1.0);
+	METALLIC = orm.b * (1.0 - grime);
+	NORMAL_MAP = texture(normal_tex, UV).rgb;
+${p.cutout ? `	ALPHA = base.a;
+	ALPHA_SCISSOR_THRESHOLD = 0.5;
+` : p.blend ? `	ALPHA = base.a * 0.6;
+` : ""}
+	// Window glow: dark panes in window cells, or the glass strip; 1.5 m world slots, glow_ratio lit.
+	float luma = dot(base.rgb, vec3(0.2126, 0.7152, 0.0722));
+	float panes = (${p.glowRects.map(rect2).join(" + ")}) * step(luma, 0.3);
+	float mask = max(panes, ${rect2(p.glassRect)});
+	float lit = step(hash13(floor(world_pos / 1.5)), glow_ratio);
+	EMISSION = glow_color * mask * lit * night * glow_intensity;
+}
+`;
+}
+
+// src/material/shader-three.ts
+var f2 = (n) => Number.isInteger(n) ? `${n}.0` : `${+n.toFixed(6)}`;
+var rectNode = (r) => `inRect(${f2(r.u0)}, ${f2(r.v0)}, ${f2(r.u1)}, ${f2(r.v1)})`;
+function threeSource(p) {
+  const weight = p.windAttribute ? "attribute('_wind', 'float')" : "smoothstep(float(0), uWindHeight, positionLocal.z)";
+  const glowCells = p.glowRects.map(rectNode).join(".add(") + ")".repeat(p.glowRects.length - 1);
+  return `// Generated by @developerz.ai/ts23d threeMaterialSource(). A starting point your project owns:
+// edit freely. Needs three r18x (WebGPURenderer + TSL). ts23d itself has no three dependency.
+//
+// Usage: const gltf = await loader.loadAsync('tank.glb'); upgradeTrimMaterials(gltf.scene);
+//        trim.uniforms.night.value = 1; // at dusk
+
+import { DoubleSide, type Material, type Mesh, MeshStandardMaterial, MeshStandardNodeMaterial, type Object3D, type Texture } from 'three/webgpu';
+import { attribute, color, float, floor, fract, hash, max, normalMap, positionLocal, positionWorld, sin, smoothstep, step, texture, time, uniform, uv, vec3, vertexColor } from 'three/tsl';
+
+export interface TrimMaps {
+  readonly albedo: Texture;
+  readonly normal: Texture | null;
+  readonly orm: Texture | null;
+}
+
+/** Shared uniforms: one set drives every trim material, so a scene-wide night switch is one write. */
+export const uniforms = {
+  night: uniform(0),
+  windStrength: uniform(${f2(p.windStrength)}),
+  windHeight: uniform(${f2(p.windHeight)}),
+  windHz: uniform(${f2(p.windHz)}),
+  glowColor: uniform(color(${f2(p.glow[0])}, ${f2(p.glow[1])}, ${f2(p.glow[2])})),
+  glowRatio: uniform(${f2(p.glowRatio)}),
+  glowIntensity: uniform(${f2(p.glowIntensity)}),
+  wear: uniform(${f2(p.wear)}),
+  grimeHeight: uniform(${f2(p.grimeHeight)}),
+};
+
+/** 1 inside a trim-sheet UV rect (U wraps: strips tile along U). */
+function inRect(u0: number, v0: number, u1: number, v1: number) {
+  const t = uv();
+  const u = fract(t.x);
+  return step(u0, u).mul(step(u, u1)).mul(step(v0, t.y)).mul(step(t.y, v1));
+}
+
+export function createTrimMaterial(maps: TrimMaps, cutout = ${p.cutout}): MeshStandardNodeMaterial {
+  const { night, windStrength: uWindStrength, windHeight: uWindHeight, windHz, glowColor, glowRatio, glowIntensity, wear, grimeHeight } = uniforms;
+  const m = new MeshStandardNodeMaterial();
+  const base = texture(maps.albedo, uv());
+  const orm = maps.orm ? texture(maps.orm, uv()) : vec3(1, 0.8, 0);
+  const tint = vertexColor();
+
+  // Wear / grime: cavities (low AO) and the first metres above the ground get darker and rougher.
+  const ground = float(1).sub(smoothstep(float(0), grimeHeight, positionWorld.y));
+  const grime = wear.mul(max(float(1).sub(orm.x).mul(1.5), ground)).clamp(0, 1);
+  m.colorNode = base.rgb.mul(tint.rgb).mul(float(1).sub(grime.mul(0.45)));
+  m.roughnessNode = orm.y.add(grime.mul(0.2)).clamp(0, 1);
+  m.metalnessNode = orm.z.mul(float(1).sub(grime));
+  m.aoNode = orm.x;
+  if (maps.normal) m.normalNode = normalMap(texture(maps.normal, uv()));
+  if (cutout) {
+    m.opacityNode = base.a;
+    m.alphaTest = 0.5;
+    m.side = DoubleSide;
+  }
+
+  // Wind sway (authored Z-up, so sway in local XY), phase-shifted across the crown.
+  const windWeight = ${weight};
+  const phase = positionLocal.x.mul(0.7).add(positionLocal.y.mul(0.45));
+  const sway = sin(time.mul(windHz).mul(6.2832).add(phase)).mul(uWindStrength).mul(windWeight).mul(0.1);
+  m.positionNode = positionLocal.add(vec3(sway, sway.mul(0.6), 0));
+
+  // Window glow: dark pane texels in window cells, or the glass strip; a world-space hash lights
+  // \`glowRatio\` of the 1.5 m window slots; scaled by \`night\`.
+  const luma = base.r.mul(0.2126).add(base.g.mul(0.7152)).add(base.b.mul(0.0722));
+  const panes = ${glowCells}.mul(step(luma, 0.3));
+  const mask = max(panes, ${rectNode(p.glassRect)});
+  const slot = floor(positionWorld.div(1.5));
+  const lit = step(hash(slot.x.mul(73).add(slot.y.mul(157)).add(slot.z.mul(311))), glowRatio);
+  m.emissiveNode = glowColor.mul(mask).mul(lit).mul(night).mul(glowIntensity);
+  return m;
+}
+
+/** Replace every ts23d_* material under \`root\` with the node material, reusing the GLB's maps. */
+export function upgradeTrimMaterials(root: Object3D): void {
+  const cache = new Map<Material, MeshStandardNodeMaterial>();
+  root.traverse((o) => {
+    const mesh = o as Mesh;
+    const old = mesh.isMesh ? mesh.material : null;
+    if (!(old instanceof MeshStandardMaterial) || !old.name.startsWith('ts23d') || !old.map) return;
+    const next = cache.get(old) ?? createTrimMaterial({ albedo: old.map, normal: old.normalMap, orm: old.roughnessMap }, old.alphaTest > 0);
+    next.name = old.name;
+    cache.set(old, next);
+    mesh.material = next;
+  });
+}
+`;
+}
+
+// src/material/shader.ts
+function fail2(cause, fix) {
+  throw new Ts23dError2("T3D_RECIPE_INVALID", { cause: `shader hints: ${cause}`, fix });
+}
+function srgbHex(value) {
+  if (!/^#[0-9a-fA-F]{6}$/.test(value))
+    fail2(`colour '${value}'`, "use '#rrggbb' sRGB hex");
+  const n = Number.parseInt(value.slice(1), 16);
+  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+}
+function resolveHints(h) {
+  const unit = (v, what) => Number.isFinite(v) && v >= 0 && v <= 1 ? v : fail2(`${what} is ${v}`, `${what} is 0..1`);
+  const pos = (v, what) => Number.isFinite(v) && v > 0 ? v : fail2(`${what} is ${v}`, `${what} is a positive number`);
+  const strength = h.wind ? pos(h.wind.strength, "wind.strength") : 0;
+  return {
+    windStrength: strength,
+    windAttribute: h.wind?.source === "attribute",
+    windHeight: pos(h.wind?.height ?? 4, "wind.height"),
+    windHz: pos(h.wind?.hz ?? 0.4, "wind.hz"),
+    glow: h.windowGlow ? srgbHex(h.windowGlow.color) : [1, 0.75, 0.4],
+    glowRatio: h.windowGlow ? unit(h.windowGlow.ratio, "windowGlow.ratio") : 0,
+    glowIntensity: pos(h.windowGlow?.intensity ?? 2, "windowGlow.intensity"),
+    wear: h.wear ? unit(h.wear.amount, "wear.amount") : 0,
+    grimeHeight: pos(h.wear?.grimeHeight ?? 0.6, "wear.grimeHeight"),
+    cutout: h.surface === "cutout",
+    blend: h.surface === "glass" || h.surface === "translucent",
+    glowRects: [cellRect2("window_sash"), cellRect2("porthole")],
+    glassRect: stripRect2("glass")
+  };
+}
+function threeMaterialSource2(hints = {}) {
+  return threeSource(resolveHints(hints));
+}
+function godotShaderSource2(hints = {}) {
+  return godotSource(resolveHints(hints));
+}
+export { TRIM_SHEET_SIZE2, stripRect2, cellRect2, STRIPS2, CELLS2, DECAL_CELLS2, FOLIAGE_CELLS2, isFoliage2, DEFAULT_SHEET2, paintTrimSheet2, hex2, definePalette2, palettes2, threeMaterialSource2, godotShaderSource2 };
+
+//# debugId=F437FE42A323CC4464756E2164756E21
+//# sourceMappingURL=chunk-kvcep7ft.js.map