@developerz.ai/ts23d 0.1.0 → 0.2.0

package/dist/{chunk-kvcep7ft.js → chunk-y63c6zcv.js}

@@ -1,8 +1,590 @@
 import {
   Ts23dError2,
   createRng2
-} from "./chunk-4ddzsqtc.js";
+} from "./chunk-hg7pf34j.js";
 
+// src/material/cc0.ts
+var PH = "https://dl.polyhaven.org/file/ph-assets/Textures/png/1k/wood_planks_grey";
+var CC0_WOOD_PLANKS_GREY2 = {
+  id: "ph_wood_planks_grey",
+  kind: "flat",
+  scaleMetres: 0.6,
+  roughness: 0.85,
+  description: "Photo-scanned weathered grey planks (Poly Haven, CC0).",
+  sources: ["https://polyhaven.com/a/wood_planks_grey"],
+  texture: {
+    source: "polyhaven",
+    id: "wood_planks_grey",
+    license: "CC0-1.0",
+    page: "https://polyhaven.com/a/wood_planks_grey",
+    author: "Rob Tuytel",
+    metres: [1.5, 1.5],
+    maps: {
+      albedo: {
+        url: `${PH}/wood_planks_grey_diff_1k.png`,
+        sha256: "3e6aeb842edd813759fdc96a6ffe6b695c888280f42501de589442311749ac5d"
+      },
+      normal: {
+        url: `${PH}/wood_planks_grey_nor_gl_1k.png`,
+        sha256: "a9f2ad602eca2d59e84f203b1087e819e62ae517532bb25f7eb02a13c826e08b"
+      },
+      arm: {
+        url: `${PH}/wood_planks_grey_arm_1k.png`,
+        sha256: "9b81e9a0b4f9db0a920c4c2ce8ff13e0411b3624d4de455acdabe41e3fafe20e"
+      }
+    }
+  }
+};
+var CC0_MATERIALS2 = [CC0_WOOD_PLANKS_GREY2];
+// src/material/library.ts
+var PB = "https://physicallybased.info";
+var ROBLOX = "https://create.roblox.com/docs/art/modeling/material-reference";
+var PBR_GUIDE = "https://www.adobe.com/learn/substance-3d-designer/web/the-pbr-guide-part-2";
+var MATERIAL_LIBRARY2 = {
+  oak: {
+    id: "oak",
+    kind: "planks",
+    scaleMetres: 0.6,
+    roughness: 0.68,
+    albedo: "#a27b52",
+    albedo2: "#6a482b",
+    params: { width: 0.14, rings: 0.55, rays: 0.6, knots: 0.6 },
+    description: "Oak boards: warm brown, dark latewood rings, pale ray flecks.",
+    sources: [PBR_GUIDE, ROBLOX]
+  },
+  pine: {
+    id: "pine",
+    kind: "planks",
+    scaleMetres: 0.6,
+    roughness: 0.72,
+    albedo: "#d2b183",
+    albedo2: "#9b6a3c",
+    params: { width: 0.16, rings: 0.75, knots: 2.5 },
+    description: "Pine boards: pale yellow, strong orange latewood, frequent knots.",
+    sources: [PBR_GUIDE, ROBLOX]
+  },
+  wood_weathered: {
+    id: "wood_weathered",
+    kind: "planks",
+    scaleMetres: 0.6,
+    roughness: 0.86,
+    albedo: "#9b968c",
+    albedo2: "#4f463c",
+    params: { width: 0.2, rings: 0.35, checks: 1, knots: 1.5, grime: 0.15 },
+    description: "Barn-grey weathered boards: silvered, eroded grain, open checks.",
+    sources: [ROBLOX]
+  },
+  wood_painted: {
+    id: "wood_painted",
+    kind: "planks",
+    scaleMetres: 0.6,
+    roughness: 0.84,
+    albedo: "#ededed",
+    albedo2: "#a08c74",
+    params: { width: 0.14, paint: 1, paintRough: 0.62, chips: 0.38, knots: 0.8, grime: 0.3 },
+    description: "Painted boards (vertex colour = paint) worn through to grey wood at the edges.",
+    sources: [ROBLOX]
+  },
+  iron_rust: {
+    id: "iron_rust",
+    kind: "metal",
+    scaleMetres: 0.5,
+    roughness: 0.55,
+    metalness: 0.9,
+    albedo: "#8e8a85",
+    albedo2: "#764323",
+    params: { oxide: 0.62, cast: 0.25, streaks: 0.5 },
+    description: "Weathered wrought/rolled iron, rust blooming in patches and runs.",
+    sources: [PB, ROBLOX]
+  },
+  iron_cast: {
+    id: "iron_cast",
+    kind: "metal",
+    scaleMetres: 0.5,
+    roughness: 0.68,
+    metalness: 0.75,
+    albedo: "#6c6966",
+    albedo2: "#55372a",
+    params: { cast: 1, oxide: 0.35 },
+    description: "Sand-cast iron (wheels, frames): dark pitted skin, dull oxide.",
+    sources: [PB]
+  },
+  steel_painted: {
+    id: "steel_painted",
+    kind: "metal",
+    scaleMetres: 0.5,
+    roughness: 0.4,
+    metalness: 1,
+    albedo: "#eeeeee",
+    albedo2: "#5a3b2a",
+    params: { paint: 1, paintRough: 0.42, chips: 0.2, streaks: 0.2, grime: 0.2 },
+    description: "Painted steel (vertex colour = paint): chips show rusty steel beneath.",
+    sources: [ROBLOX]
+  },
+  steel_galvanised: {
+    id: "steel_galvanised",
+    kind: "metal",
+    scaleMetres: 0.5,
+    roughness: 0.42,
+    metalness: 1,
+    albedo: "#d5dadc",
+    albedo2: "#9a9c98",
+    params: { spangle: 1, oxide: 0.12 },
+    description: "Hot-dip galvanised steel: zinc spangle, white-rust bloom.",
+    sources: [PB]
+  },
+  brass: {
+    id: "brass",
+    kind: "metal",
+    scaleMetres: 0.5,
+    roughness: 0.28,
+    metalness: 1,
+    albedo: "#f5e5ae",
+    albedo2: "#6b5a3a",
+    params: { brush: 0.3, oxide: 0.1 },
+    description: "Brass fittings: warm gold reflectance, dark tarnish in patches.",
+    sources: [PB, ROBLOX]
+  },
+  copper: {
+    id: "copper",
+    kind: "metal",
+    scaleMetres: 0.5,
+    roughness: 0.32,
+    metalness: 1,
+    albedo: "#f2b89c",
+    albedo2: "#6fa58f",
+    params: { oxide: 0.15 },
+    description: "Copper: salmon reflectance with verdigris patches.",
+    sources: [PB]
+  },
+  aluminium: {
+    id: "aluminium",
+    kind: "metal",
+    scaleMetres: 0.5,
+    roughness: 0.34,
+    metalness: 1,
+    albedo: "#e6e8e9",
+    params: { brush: 1 },
+    description: "Brushed aluminium: bright, cool, streaked along U.",
+    sources: [PB]
+  },
+  chrome: {
+    id: "chrome",
+    kind: "metal",
+    scaleMetres: 0.5,
+    roughness: 0.07,
+    metalness: 1,
+    albedo: "#d3d9dc",
+    description: "Chrome plate: near-mirror.",
+    sources: [PB]
+  },
+  rubber: {
+    id: "rubber",
+    kind: "noise",
+    scaleMetres: 0.5,
+    roughness: 0.78,
+    albedo: "#2c2c2c",
+    params: { tone: 0.95, mottle: 0.06, relief: 0.0002, size: 0.05, grime: 0.2 },
+    description: "Vulcanised rubber (tyres, hoses, seals).",
+    sources: [PB, ROBLOX]
+  },
+  canvas: {
+    id: "canvas",
+    kind: "weave",
+    scaleMetres: 1,
+    roughness: 0.88,
+    albedo: "#cbbea2",
+    albedo2: "#8a7c62",
+    params: { pitch: 0.004, folds: 0.6, stains: 0.35 },
+    description: "Cotton duck canvas: natural, weave relief, folds and water stains.",
+    sources: [ROBLOX]
+  },
+  leather: {
+    id: "leather",
+    kind: "leather",
+    scaleMetres: 0.5,
+    roughness: 0.58,
+    albedo: "#7c5438",
+    albedo2: "#3e281a",
+    params: { creases: 0.5, wear: 0.4 },
+    description: "Worn brown leather: pebble grain, dark creases, burnished wear.",
+    sources: [ROBLOX]
+  },
+  plastic: {
+    id: "plastic",
+    kind: "noise",
+    scaleMetres: 0.5,
+    roughness: 0.35,
+    albedo: "#ececec",
+    params: { tone: 0.97, mottle: 0.01, relief: 0.00004, size: 0.2 },
+    description: "Moulded plastic (vertex colour = the plastic colour): satin, even.",
+    sources: [ROBLOX]
+  }
+};
+
+// 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)];
+}
+var NATURAL2 = [1, 1, 1];
+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/texture-source.ts
+var SHA = /^[0-9a-f]{64}$/;
+var provided = new Map;
+function provideTextures2(cache) {
+  for (const [k, v] of cache)
+    provided.set(k, v);
+}
+function textureBytes(file, where) {
+  const hit = provided.get(file.sha256);
+  if (hit)
+    return hit;
+  throw new Ts23dError2("T3D_TEXTURE_MISSING", {
+    cause: `${where}: texture ${file.url} (sha256 ${file.sha256.slice(0, 12)}…) is not in the cache`,
+    fix: "run `bun run textures <module defining the material>` once (downloads + verifies into node_modules/.cache/ts23d/textures), then provideTextures(await loadTextureCache()) before painting"
+  });
+}
+function validateTexture(id, t) {
+  const fail = (cause, fix) => {
+    throw new Ts23dError2("T3D_MATERIAL_INVALID", { cause: `material '${id}': ${cause}`, fix });
+  };
+  if (!["polyhaven", "ambientcg", "file"].includes(t.source))
+    fail(`texture.source '${t.source}'`, "use 'polyhaven', 'ambientcg' or 'file'");
+  if (t.license !== "CC0-1.0")
+    fail(`texture.license '${t.license}'`, "only CC0-1.0 sets are accepted (Poly Haven and ambientCG are CC0)");
+  if (!(t.metres.length === 2 && t.metres.every((m) => Number.isFinite(m) && m > 0)))
+    fail(`texture.metres [${t.metres}]`, "give the real size the image covers, e.g. [1.5, 1.5]");
+  for (const [map, f] of Object.entries(t.maps)) {
+    if (!f)
+      continue;
+    if (!SHA.test(f.sha256))
+      fail(`texture.maps.${map}.sha256 '${f.sha256}'`, "lower-case hex sha256 of the file (sha256sum)");
+    if (!/\.png$/i.test(f.url))
+      fail(`texture.maps.${map}.url '${f.url}'`, "use the PNG download (8- or 16-bit); JPEG is not decoded");
+  }
+}
+var creditOf2 = (t) => `${t.id}${t.author ? ` by ${t.author}` : ""} (${t.source}, ${t.license}) ${t.page}`;
+
+// src/material/material-def.ts
+var ID = /^[a-z][a-z0-9_]{1,31}$/;
+var unit = (v) => Number.isFinite(v) && v >= 0 && v <= 1;
+function fail(id, cause, fix) {
+  throw new Ts23dError2("T3D_MATERIAL_INVALID", { cause: `material '${id}': ${cause}`, fix });
+}
+function colour(id, key, v) {
+  if (v === undefined)
+    return;
+  if (typeof v === "string") {
+    if (!/^#?[0-9a-fA-F]{6}$/.test(v))
+      fail(id, `${key} '${v}' is not a hex colour`, "use '#rrggbb'");
+    return hex2(v);
+  }
+  if (!(v.length === 3 && v.every(unit)))
+    fail(id, `${key} [${v}] is not linear RGB 0..1`, "use '#rrggbb' or three numbers in 0..1");
+  return v;
+}
+function toStripRecipe(d) {
+  const id = String(d.id);
+  if (!ID.test(id))
+    fail(id, "id is not snake_case (2–32 chars, starts with a letter)", "e.g. 'teak_deck'");
+  if (!unit(d.roughness))
+    fail(id, `roughness ${d.roughness}`, "roughness is 0..1");
+  if (d.metalness !== undefined && !unit(d.metalness))
+    fail(id, `metalness ${d.metalness}`, "metalness is 0..1 (0 dielectric, 1 metal)");
+  const scale = d.scaleMetres ?? 1;
+  if (!(Number.isFinite(scale) && scale > 0))
+    fail(id, `scaleMetres ${scale}`, "scaleMetres is the face height in metres, > 0");
+  if (d.paint !== undefined && typeof d.paint !== "function")
+    fail(id, "paint is not a function", "paint is (surface, kit) => void");
+  for (const [k, v] of Object.entries(d.params ?? {}))
+    if (!Number.isFinite(v))
+      fail(id, `params.${k} is ${v}`, "params are finite numbers");
+  if (d.texture)
+    validateTexture(id, d.texture);
+  const albedo = colour(id, "albedo", d.albedo);
+  const albedo2 = colour(id, "albedo2", d.albedo2);
+  return {
+    kind: d.kind ?? "noise",
+    scaleMetres: scale,
+    roughness: d.roughness,
+    ...d.metalness !== undefined ? { metalness: d.metalness } : {},
+    ...d.params ? { params: d.params } : {},
+    ...albedo ? { albedo } : {},
+    ...albedo2 ? { albedo2 } : {},
+    ...d.paint ? { paint: d.paint } : {},
+    ...d.texture ? { texture: d.texture } : {}
+  };
+}
+
+// src/material/paint/default-sheet.ts
+var leaf = { kind: "flat", scaleMetres: 1, roughness: 0.6 };
+var library = Object.fromEntries(Object.values(MATERIAL_LIBRARY2).map((d) => [d.id, toStripRecipe(d)]));
+var HOUSE_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 } },
+  ...library
+};
+var DEFAULT_SHEET2 = {
+  seed: 1,
+  size: 2048,
+  strips: HOUSE_STRIPS,
+  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/slots.ts
+var custom = [];
+var customIndex = (id) => custom.indexOf(id);
+var customIds = () => custom;
+function pushCustom(id) {
+  custom.push(id);
+  return custom.length - 1;
+}
+function clearCustom() {
+  custom.length = 0;
+}
+
+// src/material/trim-sheet.ts
+var STRIP_ROWS2 = 28;
+var STRIP_H = 1 / 32;
+var classic = [
+  "plain",
+  "brick",
+  "stone",
+  "slate",
+  "iron",
+  "wood",
+  "glass",
+  "concrete"
+];
+var material = [
+  "oak",
+  "pine",
+  "wood_weathered",
+  "wood_painted",
+  "iron_rust",
+  "iron_cast",
+  "steel_painted",
+  "steel_galvanised",
+  "brass",
+  "copper",
+  "aluminium",
+  "chrome",
+  "rubber",
+  "canvas",
+  "leather",
+  "plastic"
+];
+var strips = [...classic, ...material];
+var CUSTOM_STRIP_SLOTS2 = STRIP_ROWS2 - strips.length;
+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 CELL = 1 / 16;
+var CELL_V0 = STRIP_ROWS2 * STRIP_H;
+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 = 2048;
+function stripRow2(id) {
+  const b = strips.indexOf(id);
+  if (b >= 0)
+    return b;
+  const c = customIndex(id);
+  return c >= 0 ? strips.length + c : -1;
+}
+function stripRect2(id) {
+  const i = stripRow2(id);
+  if (i < 0)
+    throw new Ts23dError2("T3D_MATERIAL_UNKNOWN", {
+      cause: `strip '${id}' is neither built in nor defined`,
+      fix: `use a built-in strip (${strips.join(", ")}) or register it first with defineMaterial({ id: '${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 u0 = i % 16 * CELL;
+  const v0 = CELL_V0 + Math.floor(i / 16) * CELL;
+  return { u0, v0, u1: u0 + CELL, v1: v0 + CELL, metres: 1 };
+}
+var STRIPS2 = strips;
+var CLASSIC_STRIPS2 = classic;
+var MATERIAL_STRIPS2 = material;
+var CELLS2 = cells;
+var DECAL_CELLS2 = decals;
+var FOLIAGE_CELLS2 = foliage;
+var isFoliage2 = (id) => id.startsWith("foliage_");
+
+// src/material/define.ts
+var defined = new Map;
+function same(a, b) {
+  return JSON.stringify({ ...a, paint: 0 }) === JSON.stringify({ ...b, paint: 0 }) && a.paint === b.paint;
+}
+function defineMaterial2(def) {
+  const recipe = toStripRecipe(def);
+  const id = def.id;
+  if (STRIPS2.includes(id))
+    throw new Ts23dError2("T3D_MATERIAL_CONFLICT", {
+      cause: `material '${id}' is a built-in strip`,
+      fix: `pick another id (e.g. '${id}_custom'), or restyle the built-in via paintTrimSheet({ ...DEFAULT_SHEET, strips: { ...DEFAULT_SHEET.strips, ${id}: … } })`
+    });
+  const prior = defined.get(id);
+  if (prior) {
+    if (same(prior, def))
+      return id;
+    throw new Ts23dError2("T3D_MATERIAL_CONFLICT", {
+      cause: `material '${id}' is already defined differently`,
+      fix: "define each material once in a shared module and import it, or give the variant its own id"
+    });
+  }
+  if (customIds().length >= CUSTOM_STRIP_SLOTS2)
+    throw new Ts23dError2("T3D_SHEET_FULL", {
+      cause: `the trim sheet has ${CUSTOM_STRIP_SLOTS2} custom strip rows, all taken (${customIds().join(", ")})`,
+      fix: "reuse a built-in strip with a vertex colour, or restyle an unused built-in strip in your SheetRecipe"
+    });
+  defined.set(id, def);
+  pushCustom(id);
+  HOUSE_STRIPS[id] = recipe;
+  return id;
+}
+function resetMaterials2() {
+  for (const id of defined.keys())
+    delete HOUSE_STRIPS[id];
+  defined.clear();
+  clearCustom();
+}
+function materialOf2(id) {
+  const recipe = HOUSE_STRIPS[id];
+  const lib = MATERIAL_LIBRARY2[id];
+  const def = lib ?? defined.get(id);
+  if (!recipe || customIndex(id) < 0 && !STRIPS2.includes(id))
+    throw new Ts23dError2("T3D_MATERIAL_UNKNOWN", {
+      cause: `strip '${id}' is neither built in nor defined`,
+      fix: `use one of ${STRIPS2.join(", ")}, or defineMaterial({ id: '${id}', ... }) first`
+    });
+  const classic = CLASSIC_STRIPS2.includes(id);
+  return {
+    id,
+    origin: classic ? "classic" : lib ? "library" : "defined",
+    recipe,
+    description: def?.description ?? `classic ${recipe.kind} strip (greyscale, vertex colour tints)`,
+    sources: def?.sources ?? []
+  };
+}
+function textureSources2() {
+  return [...defined.values()].flatMap((d) => d.texture ? [d.texture] : []);
+}
+function stripCredits2(vs) {
+  const out = [];
+  for (const [id, d] of defined) {
+    if (!d.texture)
+      continue;
+    const r = stripRect2(id);
+    for (let i = 0;i < vs.length; i++) {
+      const v = vs[i] ?? -1;
+      if (v >= r.v0 && v <= r.v1) {
+        out.push(creditOf2(d.texture));
+        break;
+      }
+    }
+  }
+  return out;
+}
 // src/material/paint/noise.ts
 function hash2(ix, iy, seed) {
   let h = Math.imul(ix | 0, 668265261) ^ Math.imul(iy | 0, 374761393) ^ seed;
@@ -53,7 +635,10 @@ function createCanvas(w, h, metresU, metresV, wrapU) {
     rough: new Float32Array(n).fill(0.8),
     metal: new Float32Array(n),
     occl: new Float32Array(n).fill(1),
-    rgba: null
+    mix: new Float32Array(n),
+    colours: null,
+    rgba: null,
+    normalRgba: null
   };
 }
 function periodFor(c, featureMetres) {
@@ -73,63 +658,6 @@ var smooth = (e0, e1, v) => {
   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;
@@ -460,10 +988,23 @@ function packOrm(c, ao) {
   }
   return out;
 }
+var enc = (t) => SRGB[t <= 0 ? 0 : t >= 1 ? 4095 : Math.round(t * 4095)] ?? 255;
 function packAlbedo(c, ao) {
   if (c.rgba)
     return c.rgba;
   const out = new Uint8Array(c.w * c.h * 4);
+  const pair = c.colours;
+  if (pair) {
+    const [a, b] = pair;
+    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 m = Math.min(1, Math.max(0, c.mix[i] ?? 0));
+      for (let k = 0;k < 3; k++)
+        out[o + k] = enc(((a[k] ?? 1) * (1 - m) + (b[k] ?? 1) * m) * t);
+      out[o + 3] = 255;
+    }
+    return out;
+  }
   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;
@@ -885,7 +1426,7 @@ 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)"
+    fix: "pass PNG bytes, 8 or 16 bits per channel, non-interlaced (e.g. re-save as RGBA8 PNG)"
   });
 }
 function paeth(a, b, c) {
@@ -902,6 +1443,7 @@ function decodePng(bytes) {
   let width = 0;
   let height = 0;
   let type = -1;
+  let depth = 8;
   let palette = new Uint8Array;
   let trns = new Uint8Array;
   const idat = [];
@@ -913,8 +1455,9 @@ function decodePng(bytes) {
       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)`);
+      depth = body[8] ?? 0;
+      if (depth !== 8 && !(depth === 16 && type !== 3))
+        bad(`bit depth ${depth} (8, or 16 for non-palette images, is supported)`);
       if (body[12] !== 0)
         bad("interlaced");
     } else if (name === "PLTE")
@@ -931,7 +1474,9 @@ function decodePng(bytes) {
   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;
+  const B = depth / 8;
+  const bpp = ch * B;
+  const stride = width * bpp;
   if (raw.length < height * (stride + 1))
     bad("truncated image data");
   const px = new Uint8Array(height * stride);
@@ -940,9 +1485,9 @@ function decodePng(bytes) {
     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 a = x >= bpp ? px[row + x - bpp] ?? 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 c = x >= bpp && y > 0 ? px[row - stride + x - bpp] ?? 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;
@@ -950,8 +1495,9 @@ function decodePng(bytes) {
   }
   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 s = i * bpp;
+    const at = (k) => px[s + k * B] ?? 0;
+    const g = at(0);
     const o = i * 4;
     if (type === 3) {
       data[o] = palette[g * 3] ?? 0;
@@ -960,14 +1506,14 @@ function decodePng(bytes) {
       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;
+      data[o + 1] = at(1);
+      data[o + 2] = at(2);
+      data[o + 3] = ch === 4 ? at(3) : 255;
     } else {
       data[o] = g;
       data[o + 1] = g;
       data[o + 2] = g;
-      data[o + 3] = ch === 2 ? px[s + 1] ?? 255 : 255;
+      data[o + 3] = ch === 2 ? at(1) : 255;
     }
   }
   return { width, height, data };
@@ -1169,6 +1715,158 @@ function paintConcrete(c, r, seed) {
   }
 }
 
+// src/material/paint/fabric.ts
+function paintWeave(c, r, seed) {
+  const p = r.params;
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const pitchU = Math.max(param(p, "pitch", 0.004), 2 * pu);
+  const pitchV = Math.max(param(p, "pitch", 0.004), 2 * pv);
+  const folds = param(p, "folds", 0.6);
+  const stains = param(p, "stains", 0.3);
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const wy = Math.sin(ym / pitchV * Math.PI * 2);
+    for (let x = 0;x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const wx = Math.sin(xm / pitchU * Math.PI * 2);
+      const over = Math.floor(xm / pitchU) + Math.floor(ym / pitchV);
+      const thread = over % 2 === 0 ? Math.abs(wy) : Math.abs(wx);
+      const slub = noiseAt(c, xm, ym, 0.05, 0.01, seed, 2);
+      const fold = noiseAt(c, xm, ym, 0.5, 0.35, seed + 1, 3);
+      const stain = stains * smooth(0.1, 0.6, noiseAt(c, xm, ym, 0.2, 0.15, seed + 2, 4));
+      c.height[i] = 0.0002 * thread + 0.003 * folds * fold;
+      c.tone[i] = (0.9 + 0.06 * thread + 0.05 * slub) * (1 - 0.25 * stain);
+      c.rough[i] = Math.min(1, r.roughness + 0.04 * slub - 0.03 * thread);
+      c.metal[i] = 0;
+      c.mix[i] = stain;
+    }
+  }
+}
+function paintLeather(c, r, seed) {
+  const p = r.params;
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const pebble = param(p, "pebble", 0.004);
+  const creases = param(p, "creases", 0.5);
+  const wear = param(p, "wear", 0.4);
+  for (let y = 0;y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    for (let x = 0;x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const grain = noiseAt(c, xm, ym, pebble, pebble, seed, 3);
+      const crease = smooth(0.4, 0.6, noiseAt(c, xm, ym, 0.12, 0.012, seed + 1, 3)) * creases;
+      const rub = wear * smooth(0, 0.6, noiseAt(c, xm, ym, 0.3, 0.3, seed + 2, 4));
+      c.height[i] = 0.00025 * grain - 0.0008 * crease;
+      c.tone[i] = (0.95 + 0.05 * grain) * (1 - 0.45 * crease) * (1 + 0.12 * rub);
+      c.rough[i] = Math.min(1, Math.max(0, r.roughness + 0.06 * grain - 0.2 * rub + 0.1 * crease));
+      c.metal[i] = 0;
+      c.mix[i] = crease;
+    }
+  }
+}
+
+// src/material/paint/image-strip.ts
+var decoded = new Map;
+function image(f, where) {
+  const hit = decoded.get(f.sha256);
+  if (hit)
+    return hit;
+  const img = decodePng(textureBytes(f, where));
+  decoded.set(f.sha256, img);
+  return img;
+}
+function resample(c, t, img, fn) {
+  const reps = Math.max(1, Math.round(c.metresU / (t.metres[0] ?? 1)));
+  const su = c.metresU / reps;
+  const sv = t.metres[1] ?? 1;
+  const W = img.width;
+  const H = img.height;
+  const px = new Float32Array(4);
+  for (let y = 0;y < c.h; y++) {
+    const v0 = y * c.metresV / c.h / sv * H;
+    const v1 = (y + 1) * c.metresV / c.h / sv * H;
+    for (let x = 0;x < c.w; x++) {
+      const u0 = x * c.metresU / c.w / su * W;
+      const u1 = (x + 1) * c.metresU / c.w / su * W;
+      px.fill(0);
+      let n = 0;
+      for (let sy = Math.floor(v0);sy < Math.max(Math.floor(v0) + 1, Math.ceil(v1)); sy++) {
+        const row = H - 1 - (sy % H + H) % H;
+        for (let sx = Math.floor(u0);sx < Math.max(Math.floor(u0) + 1, Math.ceil(u1)); sx++) {
+          const o = (row * W + (sx % W + W) % W) * 4;
+          for (let k = 0;k < 4; k++)
+            px[k] = (px[k] ?? 0) + (img.data[o + k] ?? 0);
+          n++;
+        }
+      }
+      for (let k = 0;k < 4; k++)
+        px[k] = (px[k] ?? 0) / n;
+      fn(y * c.w + x, px);
+    }
+  }
+}
+function paintImageStrip(c, r, t, where) {
+  const albedo = new Uint8Array(c.w * c.h * 4);
+  resample(c, t, image(t.maps.albedo, where), (i, p) => {
+    albedo.set([p[0] ?? 0, p[1] ?? 0, p[2] ?? 0, 255], i * 4);
+  });
+  c.rgba = albedo;
+  c.height.fill(0);
+  if (t.maps.normal) {
+    const nrm = new Uint8Array(c.w * c.h * 4);
+    resample(c, t, image(t.maps.normal, where), (i, p) => {
+      const x = (p[0] ?? 128) / 127.5 - 1;
+      const y = -((p[1] ?? 128) / 127.5 - 1);
+      const z = (p[2] ?? 255) / 127.5 - 1;
+      const l = Math.hypot(x, y, z) || 1;
+      nrm.set([x / l * 127.5 + 127.5, y / l * 127.5 + 127.5, z / l * 127.5 + 127.5, 255], i * 4);
+    });
+    c.normalRgba = nrm;
+  }
+  if (t.maps.arm) {
+    resample(c, t, image(t.maps.arm, where), (i, p) => {
+      c.occl[i] = (p[0] ?? 255) / 255;
+      c.rough[i] = (p[1] ?? 204) / 255;
+      c.metal[i] = (p[2] ?? 0) / 255;
+    });
+  } else {
+    c.rough.fill(r.roughness);
+    c.metal.fill(r.metalness ?? 0);
+  }
+}
+
+// src/material/paint/kit.ts
+function paintKit(c, seed) {
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  return {
+    seed,
+    noise: (xm, ym, sizeU, sizeV, salt = 0, octaves = 4) => noiseAt(c, xm, ym, sizeU, sizeV, seed + salt * 7919, octaves),
+    hash: (a, b, salt = 0) => hash2(a, b, seed + salt),
+    smooth,
+    each(fn) {
+      for (let y = 0;y < c.h; y++) {
+        const ym = (y + 0.5) * pv;
+        for (let x = 0;x < c.w; x++)
+          fn(y * c.w + x, (x + 0.5) * pu, ym);
+      }
+    }
+  };
+}
+function checkFinite(c, where) {
+  const layers = { height: c.height, tone: c.tone, rough: c.rough, metal: c.metal, mix: c.mix };
+  for (const [name, a] of Object.entries(layers))
+    for (let i = 0;i < a.length; i++)
+      if (!Number.isFinite(a[i] ?? 0))
+        throw new Ts23dError2("T3D_MATERIAL_INVALID", {
+          cause: `${where}: the painter wrote ${a[i]} into '${name}' at texel ${i}`,
+          fix: "write finite numbers only (guard divisions; clamp with Math.min/Math.max)"
+        });
+}
+
 // src/material/paint/masks.ts
 function rustStreaks(c, amount, seed) {
   if (amount <= 0)
@@ -1188,6 +1886,7 @@ function rustStreaks(c, amount, seed) {
       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);
+      c.mix[i] = Math.min(1, (c.mix[i] ?? 0) + m);
     }
   }
 }
@@ -1211,6 +1910,99 @@ function grime(c, amount, seed) {
   }
 }
 
+// src/material/paint/metal.ts
+function crystal(xm, ym, size, cellsU, seed) {
+  const gx = Math.floor(xm / size);
+  const gy = Math.floor(ym / size);
+  let best = 1e9;
+  let id = 0;
+  for (let j = -1;j <= 1; j++)
+    for (let i = -1;i <= 1; i++) {
+      const cx = ((gx + i) % cellsU + cellsU) % cellsU;
+      const px = (gx + i + hash2(cx, gy + j, seed)) * size;
+      const py = (gy + j + hash2(cx, gy + j, seed + 1)) * size;
+      const d = (xm - px) ** 2 + (ym - py) ** 2;
+      if (d < best) {
+        best = d;
+        id = hash2(cx, gy + j, seed + 2) * 1e6;
+      }
+    }
+  return id;
+}
+function paintMetal(c, r, seed) {
+  const p = r.params;
+  const brush = param(p, "brush", 0);
+  const cast = param(p, "cast", 0);
+  const spangle = param(p, "spangle", 0);
+  const oxide = param(p, "oxide", 0);
+  const paint = param(p, "paint", 0);
+  const paintRough = param(p, "paintRough", 0.45);
+  const chips = param(p, "chips", 0.25);
+  const size = param(p, "crystal", 0.03);
+  const metal = r.metalness ?? 1;
+  const cellsU = Math.max(1, Math.round(c.metresU / size));
+  const cs = c.metresU / cellsU;
+  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 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.01, 0.01, seed + 1, 2);
+      let tone = 1 + 0.05 * big;
+      let rough = r.roughness + 0.06 * big + 0.03 * fine;
+      let h = 0.00015 * big;
+      if (brush > 0) {
+        const s = noiseAt(c, xm, ym, 0.6, 0.002, seed + 2, 3);
+        tone *= 1 + 0.06 * brush * s;
+        rough += 0.08 * brush * s;
+        h += 0.00003 * brush * s;
+      }
+      if (cast > 0) {
+        const pit = noiseAt(c, xm, ym, 0.012, 0.012, seed + 3, 3);
+        const lump = noiseAt(c, xm, ym, 0.08, 0.08, seed + 4, 3);
+        h += cast * (0.0006 * pit + 0.0008 * lump);
+        rough += cast * (0.1 + 0.12 * pit);
+        tone *= 1 + cast * (0.16 * pit + 0.08 * lump - 0.04);
+      }
+      if (spangle > 0) {
+        const k = crystal(xm, ym, cs, cellsU, seed + 5);
+        const v = hash2(k, 7, seed) * 2 - 1;
+        tone *= 1 + 0.12 * spangle * v;
+        rough += 0.12 * spangle * v;
+      }
+      let ox = 0;
+      if (oxide > 0) {
+        const blot = noiseAt(c, xm, ym, 0.18, 0.18, seed + 6, 5);
+        const grain = noiseAt(c, xm, ym, 0.02, 0.02, seed + 7, 3);
+        ox = smooth(0.45, 0.75, blot * 0.5 + 0.5 + oxide - 0.5 + 0.15 * grain);
+        h += ox * 0.0004 * (1 + grain);
+      }
+      let m = metal * (1 - ox);
+      let mix = ox;
+      rough = rough * (1 - ox) + (0.88 + 0.06 * fine) * ox;
+      if (paint > 0) {
+        const n = noiseAt(c, xm, ym, 0.05, 0.05, seed + 8, 4);
+        const chip = smooth(0.42, 0.5, n * 0.5 + 0.5 - (1 - chips) * 0.5 + 0.1);
+        const film = paint * (1 - chip);
+        m *= 1 - film;
+        mix = mix * (1 - film) + chip * paint;
+        rough = rough * (1 - film) + (paintRough + 0.05 * big) * film;
+        tone = tone * (1 - film) + (0.96 + 0.03 * big) * film;
+        h -= chip * paint * 0.00015;
+      }
+      c.height[i] = h;
+      c.tone[i] = tone;
+      c.rough[i] = Math.min(1, Math.max(0, rough));
+      c.metal[i] = Math.min(1, Math.max(0, m));
+      c.mix[i] = mix;
+    }
+  }
+  rustStreaks(c, param(p, "streaks", 0), seed + 77);
+}
+
 // src/material/paint/planks.ts
 function paintPlanks(c, r, seed) {
   const p = r.params;
@@ -1219,9 +2011,16 @@ function paintPlanks(c, r, seed) {
   const gap = param(p, "gap", 0.004);
   const depth = param(p, "depth", 0.004);
   const knots = param(p, "knots", 1.5);
+  const rings = param(p, "rings", 0);
+  const rays = param(p, "rays", 0);
+  const checks = param(p, "checks", 0);
+  const paint = param(p, "paint", 0);
+  const paintRough = param(p, "paintRough", 0.5);
+  const chips = param(p, "chips", 0.3);
   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;
+  const ringsN = Math.max(1, Math.min(9, Math.floor(width / pv / 4)));
   for (let y = 0;y < c.h; y++) {
     const ym = (y + 0.5) * pv;
     const k = boards.at(ym);
@@ -1249,9 +2048,39 @@ function paintPlanks(c, r, seed) {
         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);
+      let height = -depth * (1 - edge) + 0.0004 * ring * edge + 0.0003 * fibre - 0.0008 * knot;
+      let tone = (0.66 + 0.22 * h) * (1 + 0.08 * ring + 0.06 * fibre) * (1 - 0.5 * knot) * (0.5 + 0.5 * edge);
+      let rough = r.roughness + 0.05 * fibre + 0.1 * (1 - edge);
+      const ring2 = Math.sin((vy * ringsN + warp * 2.5 + h * 6) * Math.PI * 2);
+      const late = smooth(0.1, 0.8, ring2) * (0.75 + 0.25 * fibre);
+      let mix = rings * Math.max(late, knot);
+      if (rays > 0) {
+        const fleck = smooth(0.55, 0.8, noiseAt(c, xm, ym, 0.03, 0.004, seed + 23, 2));
+        tone *= 1 + 0.25 * rays * fleck;
+        mix *= 1 - rays * fleck;
+      }
+      if (checks > 0) {
+        const split = smooth(0.45, 0.6, noiseAt(c, xm, ym, 0.3, 0.003, seed + 29 + id, 3));
+        height += checks * (0.0006 * late - 0.002 * split);
+        tone *= 1 - checks * (0.45 * split + 0.08 * (1 - late));
+        rough += checks * 0.1 * (1 - late);
+        mix = Math.max(mix, checks * split);
+      }
+      if (paint > 0) {
+        const n = noiseAt(c, xm, ym, 0.04, 0.03, seed + 31, 4) * 0.5 + 0.5;
+        const nearEdge = 1 - smooth(gap, gap * 6, d);
+        const chip = smooth(0.5, 0.56, n + chips * 0.5 + nearEdge * 0.15 - 0.45);
+        const film = paint * (1 - chip);
+        height = height * (1 - 0.4 * film) - chip * paint * 0.0002;
+        const under = (0.9 + 0.06 * h) * (1 + 0.05 * ring + 0.04 * fibre) * (0.55 + 0.45 * edge);
+        tone = tone * (1 - film) + under * film;
+        rough = rough * (1 - film) + (paintRough + 0.04 * fibre) * film;
+        mix = mix * (1 - film) + paint * chip;
+      }
+      c.height[i] = height;
+      c.tone[i] = tone;
+      c.rough[i] = Math.min(1, rough);
+      c.mix[i] = mix;
     }
   }
 }
@@ -1400,34 +2229,33 @@ function paintGlass(c, r, seed) {
 }
 
 // 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;
+var PAINTERS = {
+  bond: paintBond,
+  planks: paintPlanks,
+  plates: paintPlates,
+  slate: paintSlate,
+  concrete: paintConcrete,
+  metal: paintMetal,
+  weave: paintWeave,
+  leather: paintLeather,
+  noise: paintNoise,
+  glass: paintGlass,
+  flat: (c, r) => paintFlat(c, r)
+};
+function paintStrip(c, r, seed, where = "strip") {
+  if (r.texture)
+    paintImageStrip(c, r, r.texture, where);
+  else {
+    if (r.albedo || r.albedo2)
+      c.colours = [r.albedo ?? [1, 1, 1], r.albedo2 ?? r.albedo ?? [1, 1, 1]];
+    PAINTERS[r.kind](c, r, seed);
+    if (r.kind !== "glass" && r.kind !== "flat")
+      grime(c, param(r.params, "grime", 0), seed + 101);
+  }
+  if (r.paint) {
+    r.paint(c, paintKit(c, seed + 211));
+    checkFinite(c, where);
   }
-  grime(c, param(r.params, "grime", 0), seed + 101);
 }
 
 // src/material/paint/cell.ts
@@ -1519,7 +2347,7 @@ function composeRegion(sheet, c, x0, y0, pad) {
   const ao = cavityOcclusion(c);
   const maps = [
     [sheet.albedo, packAlbedo(c, ao)],
-    [sheet.normal, sobelNormals(c)],
+    [sheet.normal, c.normalRgba ?? sobelNormals(c)],
     [sheet.orm, packOrm(c, ao)]
   ];
   const padX = c.wrapU ? 0 : pad;
@@ -1539,63 +2367,6 @@ function composeRegion(sheet, c, x0, y0, pad) {
   }
 }
 
-// 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",
@@ -1605,45 +2376,55 @@ var KINDS = [
   "flat",
   "slate",
   "concrete",
-  "glass"
+  "glass",
+  "metal",
+  "weave",
+  "leather"
 ];
 var SIZES = [512, 1024, 2048];
-function fail(cause, fix) {
+function fail2(cause, fix) {
   throw new Ts23dError2("T3D_RECIPE_INVALID", { cause: `sheet recipe: ${cause}`, fix });
 }
-var unit = (v) => Number.isFinite(v) && v >= 0 && v <= 1;
+var unit2 = (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(" | ")}`);
+    fail2(`${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");
+    fail2(`${where}.scaleMetres is ${r.scaleMetres}`, "set the metres the strip V span represents, > 0 (e.g. 0.6 for brick)");
+  if (!unit2(r.roughness))
+    fail2(`${where}.roughness is ${r.roughness}`, "roughness is 0..1");
+  if (r.metalness !== undefined && !unit2(r.metalness))
+    fail2(`${where}.metalness is ${r.metalness}`, "metalness is 0..1");
+  for (const key of ["albedo", "albedo2"]) {
+    const a = r[key];
+    if (a !== undefined && !(a.length === 3 && a.every(unit2)))
+      fail2(`${where}.${key} is [${a}]`, `${key} is linear RGB, three numbers 0..1 (use hex('#rrggbb'))`);
+  }
+  if (r.paint !== undefined && typeof r.paint !== "function")
+    fail2(`${where}.paint is not a function`, "paint is (surface, kit) => void");
   for (const [k, v] of Object.entries(r.params ?? {}))
     if (!Number.isFinite(v))
-      fail(`${where}.params.${k} is ${v}`, "params are finite numbers");
+      fail2(`${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");
+    fail2(`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");
+    fail2(`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 (stripRow2(id) < 0)
+      fail2(`strip '${id}' is not in the layout`, `strips are ${STRIPS2.join(", ")} or a defineMaterial() id`);
     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(", ")}`);
+      fail2(`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");
+        fail2(`cells.${id}.image is not bytes`, "pass PNG file bytes as a Uint8Array");
     } else
       validateStrip(`cells.${id}`, e);
   }
@@ -1653,18 +2434,19 @@ function validateSheet(recipe) {
 var FALLBACK = { kind: "noise", scaleMetres: 1, roughness: 0.6 };
 function paintTrimSheet2(recipe = DEFAULT_SHEET2) {
   validateSheet(recipe);
-  const size = recipe.size ?? 1024;
+  const size = recipe.size ?? 2048;
   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 all = [...STRIPS2, ...customIds()];
+  for (const id of all) {
     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));
+    paintStrip(c, r, seedOf(id), `strips.${id}`);
     composeRegion(sheet, c, 0, Math.round(rect.v0 * size), pad);
   }
   for (const id of CELLS2) {
@@ -1677,39 +2459,6 @@ function paintTrimSheet2(recipe = DEFAULT_SHEET2) {
   }
   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)}))`;
@@ -1878,18 +2627,18 @@ export function upgradeTrimMaterials(root: Object3D): void {
 }
 
 // src/material/shader.ts
-function fail2(cause, fix) {
+function fail3(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");
+    fail3(`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 unit = (v, what) => Number.isFinite(v) && v >= 0 && v <= 1 ? v : fail3(`${what} is ${v}`, `${what} is 0..1`);
+  const pos = (v, what) => Number.isFinite(v) && v > 0 ? v : fail3(`${what} is ${v}`, `${what} is a positive number`);
   const strength = h.wind ? pos(h.wind.strength, "wind.strength") : 0;
   return {
     windStrength: strength,
@@ -1913,7 +2662,7 @@ function threeMaterialSource2(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 };
+export { CC0_WOOD_PLANKS_GREY2, CC0_MATERIALS2, MATERIAL_LIBRARY2, hex2, NATURAL2, definePalette2, palettes2, provideTextures2, creditOf2, DEFAULT_SHEET2, STRIP_ROWS2, CUSTOM_STRIP_SLOTS2, TRIM_SHEET_SIZE2, stripRow2, stripRect2, cellRect2, STRIPS2, CLASSIC_STRIPS2, MATERIAL_STRIPS2, CELLS2, DECAL_CELLS2, FOLIAGE_CELLS2, isFoliage2, defineMaterial2, resetMaterials2, materialOf2, textureSources2, stripCredits2, paintTrimSheet2, threeMaterialSource2, godotShaderSource2 };
 
-//# debugId=F437FE42A323CC4464756E2164756E21
-//# sourceMappingURL=chunk-kvcep7ft.js.map
+//# debugId=06EA6C9948471A9664756E2164756E21
+//# sourceMappingURL=chunk-y63c6zcv.js.map