@nayan-ui/games 1.19.0 → 1.20.0

package/src/games/shared/EngineFruits.ts

@@ -0,0 +1,1435 @@
+// Fruit models for the Nayan engine games (from the engine's example, games/shapes/fruits.ts).
+// Fruit built from the engine's custom shapes: lathed bodies with painted skins (blushes, streaks,
+// stripes, speckles) and dimpled peel, tube stems and bananas, folded serrated leaves, seeds; each
+// merged into one mesh. Every fruit also comes in two pieces for slicing, as in Fruit Ninja.
+//
+// Pieces share the whole fruit's origin and size. Each has its cut face toward +Z and its solid
+// toward -Z: spawn pieces[0] turned a quarter turn about Y (cut facing +X, so it's the left piece)
+// and pieces[1] turned the other way, where the fruit was, and push them apart.
+import {
+  type Color,
+  extrude,
+  type Geometry,
+  type GeometryPart,
+  lathe,
+  merge,
+  type Model,
+  Path,
+  type Quat,
+  recolor,
+  tube,
+  type Vec3
+} from '@nayan-ui/engine';
+import { cacheGameAsset, createGameMesh as createShape } from './EngineMeshes';
+
+export type FruitKind =
+  | 'apple'
+  | 'orange'
+  | 'lemon'
+  | 'pear'
+  | 'strawberry'
+  | 'watermelon'
+  | 'banana'
+  | 'cherries'
+  | 'grapes'
+  | 'kiwi'
+  | 'mango'
+  | 'peach'
+  | 'pineapple'
+  | 'pomegranate'
+  | 'papaya';
+export type Fruit = {
+  whole: Model;
+  /** The left and right pieces after a slice. */
+  pieces: [Model, Model];
+  /** Color of its juice (for splashes). */
+  juice: Color;
+  /** Centre of the whole fruit's bounding box (stems and leaves included), in its own units. */
+  center: Vec3;
+};
+
+/** The middle of a geometry's bounding box. */
+function boxCenter(g: Geometry): Vec3 {
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (let i = 0; i < g.vertices.length; i += 11) {
+    for (let k = 0; k < 3; k++) {
+      lo[k] = Math.min(lo[k]!, g.vertices[i + k]!);
+      hi[k] = Math.max(hi[k]!, g.vertices[i + k]!);
+    }
+  }
+  return [(lo[0]! + hi[0]!) / 2, (lo[1]! + hi[1]!) / 2, (lo[2]! + hi[2]!) / 2];
+}
+
+const TAU = Math.PI * 2;
+
+// ── Little helpers: noise, colors, rotations ─────────────────────────────
+
+const fract = (x: number) => x - Math.floor(x);
+const hash = (x: number, y: number) => fract(Math.sin(x * 127.1 + y * 311.7) * 43758.5453);
+const smooth = (t: number) => t * t * (3 - 2 * t);
+const clamp01 = (x: number) => Math.max(0, Math.min(1, x));
+const smoothstep = (a: number, b: number, x: number) => smooth(clamp01((x - a) / (b - a)));
+
+/** Value noise, 0..1, repeating every `cu` cells in u (so it wraps around a lathe without a seam). */
+function noise(u: number, v: number, cu: number, cv: number) {
+  const x = u * cu;
+  const y = v * cv;
+  const ix = Math.floor(x);
+  const iy = Math.floor(y);
+  const fx = smooth(x - ix);
+  const fy = smooth(y - iy);
+  const h = (i: number, j: number) => hash(((i % cu) + cu) % cu, j);
+  const top = h(ix, iy) + (h(ix + 1, iy) - h(ix, iy)) * fx;
+  const bottom = h(ix, iy + 1) + (h(ix + 1, iy + 1) - h(ix, iy + 1)) * fx;
+  return top + (bottom - top) * fy;
+}
+
+const mix = (a: Color, b: Color, t: number): Color => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+const shade = (c: Color, k: number): Color => [c[0] * k, c[1] * k, c[2] * k];
+
+const turn = (axis: Vec3, angle: number): Quat => [
+  axis[0] * Math.sin(angle / 2),
+  axis[1] * Math.sin(angle / 2),
+  axis[2] * Math.sin(angle / 2),
+  Math.cos(angle / 2)
+];
+function mul(a: Quat, b: Quat): Quat {
+  const [ax, ay, az, aw] = a;
+  const [bx, by, bz, bw] = b;
+  return [
+    aw * bx + ax * bw + ay * bz - az * by,
+    aw * by - ax * bz + ay * bw + az * bx,
+    aw * bz + ax * by - ay * bx + az * bw,
+    aw * bw - ax * bx - ay * by - az * bz
+  ];
+}
+/** The rotation taking +Y to direction `n` (unit). */
+function upTo(n: Vec3): Quat {
+  const axis: Vec3 = [n[2], 0, -n[0]];
+  const len = Math.hypot(axis[0], axis[2]);
+  if (len < 1e-6) return n[1] > 0 ? [0, 0, 0, 1] : [1, 0, 0, 0];
+  return turn([axis[0] / len, 0, axis[2] / len], Math.acos(Math.max(-1, Math.min(1, n[1]))));
+}
+
+/** A rotation about Y (pieces are turned so their cut faces +Z). */
+const yTurn = (angle: number) => turn([0, 1, 0], angle);
+
+/**
+ * Bends geometry in place: every vertex moved by `f`, its normal carried along (by the inverse
+ * transpose of f's derivative), so curves, leans and grooves still catch the light. For shapes a
+ * lathe can't make alone: a mango's kidney curve, a peach's groove. Cut faces bend with the skin.
+ */
+function warp(g: Geometry, f: (p: Vec3) => Vec3): Geometry {
+  const v = g.vertices;
+  const e = 1e-4;
+  const sub = (a: Vec3, b: Vec3): Vec3 => [(a[0] - b[0]) / e, (a[1] - b[1]) / e, (a[2] - b[2]) / e];
+  const cross = (a: Vec3, b: Vec3): Vec3 => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  for (let i = 0; i < v.length; i += 11) {
+    const [x, y, z] = [v[i]!, v[i + 1]!, v[i + 2]!];
+    const q = f([x, y, z]);
+    const [jx, jy, jz] = [sub(f([x + e, y, z]), q), sub(f([x, y + e, z]), q), sub(f([x, y, z + e]), q)];
+    const [a, b, c] = [cross(jy, jz), cross(jz, jx), cross(jx, jy)];
+    const [nx, ny, nz] = [v[i + 3]!, v[i + 4]!, v[i + 5]!];
+    const n = [0, 1, 2].map((k) => nx * a[k]! + ny * b[k]! + nz * c[k]!);
+    const len = Math.hypot(n[0]!, n[1]!, n[2]!);
+    v.set(q, i);
+    if (len > 1e-12) v.set([n[0]! / len, n[1]! / len, n[2]! / len], i + 3);
+  }
+  return g;
+}
+
+// ── Profiles ─────────────────────────────────────────────────────────────
+
+type Profile = [number, number][];
+
+/** A profile from r(t), t going 0 (top) to 1 (bottom), `height` tall. */
+/**
+ * Mesh detail for the fruit being built (1 = full). Games that show fruit small (Tile Home's 72 tiles)
+ * build lighter meshes: around and along each lathe, vertex counts scale by this.
+ */
+let detail = 1;
+/** A segment / step count at the current detail (small counts are kept: seeds, grapes). */
+const seg = (n: number) => (n <= 8 ? n : Math.max(8, Math.round(n * detail)));
+
+function profile(height: number, r: (t: number) => number, steps = 48): Profile {
+  steps = seg(steps);
+  const out: Profile = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    out.push([Math.max(0, r(t)), height / 2 - t * height]);
+  }
+  return out;
+}
+
+/** Evenly spaced points along a profile, so painted details have vertices to land on. */
+function resample(p: Profile, n: number): Profile {
+  n = seg(n);
+  const lengths = [0];
+  for (let i = 1; i < p.length; i++) lengths.push(lengths[i - 1]! + Math.hypot(p[i]![0] - p[i - 1]![0], p[i]![1] - p[i - 1]![1]));
+  const total = lengths[lengths.length - 1]!;
+  const out: Profile = [];
+  let k = 0;
+  for (let i = 0; i <= n; i++) {
+    const at = (i / n) * total;
+    while (k < p.length - 2 && lengths[k + 1]! < at) k++;
+    const t = (at - lengths[k]!) / (lengths[k + 1]! - lengths[k]! || 1);
+    out.push([p[k]![0] + (p[k + 1]![0] - p[k]![0]) * t, p[k]![1] + (p[k + 1]![1] - p[k]![1]) * t]);
+  }
+  return out;
+}
+
+/** A rounded profile: an ellipse when `power` is 2, blunter above (a barrel, a kiwi), `height` tall. */
+const rounded = (height: number, radius: number, power = 2, steps = 64) =>
+  profile(height, (t) => radius * Math.pow(Math.max(0, 1 - Math.pow(Math.abs(2 * t - 1), power)), 1 / power), steps);
+
+/** A profile's radius at height `y` (for placing things on a cut face). */
+function radiusAt(p: Profile, y: number) {
+  let best = 0;
+  for (let i = 0; i < p.length - 1; i++) {
+    const [r0, y0] = p[i]!;
+    const [r1, y1] = p[i + 1]!;
+    if ((y - y0) * (y - y1) <= 0 && y0 !== y1) best = Math.max(best, r0 + ((y - y0) / (y1 - y0)) * (r1 - r0));
+  }
+  return best;
+}
+
+/**
+ * A dimpled profile from its highest point to its lowest, for a piece cut through the core: the cut
+ * face of a profile that turns back is filled without inner points, so painted cores wouldn't show.
+ */
+function undimpled(p: Profile): Profile {
+  let [top, bottom] = [0, 0];
+  p.forEach((q, i) => {
+    if (q[1] > p[top]![1]) top = i;
+    if (q[1] < p[bottom]![1]) bottom = i;
+  });
+  return p.slice(top, bottom + 1);
+}
+
+/** Scales a profile so its lathe is 1 unit across its largest side, centered on the origin. */
+function normalize(p: Profile): Profile {
+  const top = Math.max(...p.map((q) => q[1]));
+  const bottom = Math.min(...p.map((q) => q[1]));
+  const width = 2 * Math.max(...p.map((q) => q[0]));
+  const s = 1 / Math.max(width, top - bottom);
+  const mid = (top + bottom) / 2;
+  return p.map(([r, y]) => [r * s, (y - mid) * s]);
+}
+
+/** The point and outward normal of a lathe of `p` at `v` down the profile and `angle` around. */
+function onSurface(p: Profile, v: number, angle: number): [Vec3, Vec3] {
+  const f = v * (p.length - 1);
+  const i = Math.min(p.length - 2, Math.floor(f));
+  const t = f - i;
+  const [r0, y0] = p[i]!;
+  const [r1, y1] = p[i + 1]!;
+  const r = r0 + (r1 - r0) * t;
+  const y = y0 + (y1 - y0) * t;
+  const len = Math.hypot(r1 - r0, y1 - y0) || 1;
+  const [nr, ny] = [(y0 - y1) / len, (r1 - r0) / len];
+  const [c, s] = [Math.cos(angle), -Math.sin(angle)];
+  return [
+    [r * c, y, r * s],
+    [nr * c, ny, nr * s]
+  ];
+}
+
+// ── Parts: leaves, stems, seeds ──────────────────────────────────────────
+
+const LEAF_TOP: Color = [0.24, 0.56, 0.17];
+const LEAF_UNDER: Color = [0.19, 0.46, 0.14];
+const VEIN: Color = [0.55, 0.74, 0.36];
+
+/**
+ * A leaf from its base at the origin to its tip at +X, `length` long: two serrated halves folded up
+ * along a pale midrib (a V, like a real leaf), on a short stalk.
+ */
+function leaf(length: number, width: number, { fold = 0.38, teeth = 14, stalk = 0.16 } = {}): Geometry {
+  // One half's outline (y up): along the serrated edge to the tip, then back down the midrib.
+  const half = (sign: 1 | -1) => {
+    const pts: [number, number][] = [[0, 0]];
+    const steps = teeth * 2;
+    for (let i = 1; i < steps; i++) {
+      const s = i / steps;
+      const tooth = i % 2 ? 0.07 : 0; // little saw teeth along the edge
+      const w = width * Math.pow(Math.sin(Math.PI * s), 0.75) * (1 - 0.25 * s) * (1 + tooth);
+      pts.push([length * s, sign * w]);
+    }
+    pts.push([length, 0]);
+    // Path coordinates are y down.
+    return extrude(new Path().addPolygon(pts.map(([x, y]) => [x, -y] as [number, number])), { depth: 0.006 });
+  };
+  return merge([
+    { geometry: half(1), rotation: turn([1, 0, 0], fold), color: LEAF_TOP },
+    { geometry: half(-1), rotation: turn([1, 0, 0], -fold), color: LEAF_UNDER },
+    {
+      geometry: tube(
+        [
+          [0, 0, 0],
+          [length * 0.5, 0.004, 0],
+          [length * 0.96, 0, 0]
+        ],
+        { radius: (t) => 0.007 * (1 - t) + 0.002, sides: seg(6) }
+      ),
+      color: VEIN
+    },
+    {
+      geometry: tube(
+        [
+          [-length * stalk, -0.01, 0],
+          [0, 0, 0]
+        ],
+        { radius: 0.008, sides: seg(6) }
+      ),
+      color: [0.36, 0.42, 0.18]
+    }
+  ]);
+}
+
+/** A woody stem curving up from the origin, `height` tall, with a knobbly, paler cut end. */
+function stem(height: number, radius = 0.024, bend = 0.06): Geometry {
+  return tube(
+    [
+      [0, -0.03, 0],
+      [0.005, height * 0.4, 0],
+      [bend * 0.5, height * 0.8, 0],
+      [bend, height, 0]
+    ],
+    {
+      radius: (t) => radius * (1.25 - 0.45 * t + (t > 0.9 ? 0.5 * (t - 0.9) * 10 : 0)),
+      sides: seg(8),
+      color: (p) => mix([0.33, 0.21, 0.1], [0.5, 0.42, 0.28], smoothstep(0.75, 1, p.v) + 0.15 * noise(p.u, p.v, 6, 10)),
+      capColor: [0.62, 0.55, 0.4]
+    }
+  );
+}
+
+/** A seed: a small teardrop, 1 unit tall before scaling, pointing up. */
+const seed = (segments = 8) =>
+  lathe(
+    [
+      [0, 0.5],
+      [0.22, 0.32],
+      [0.4, 0.02],
+      [0.36, -0.28],
+      [0.2, -0.45],
+      [0, -0.5]
+    ],
+    { segments }
+  );
+
+/** A flat, pointed star (a calyx or the scar where a stem was). */
+const calyx = (outer: number, inner: number, points: number, depth = 0.012) => extrude(new Path().addStar(0, 0, outer, inner, points), { depth });
+
+/** Faces a geometry made facing +Z (an extrusion) up (+Y) instead. */
+const FACE_UP = turn([1, 0, 0], -Math.PI / 2);
+/** Turns a piece cut across (cut face down, -Y, solid up) to the convention: cut face +Z, solid -Z. */
+const CUT_ACROSS = turn([1, 0, 0], -Math.PI / 2);
+
+// ── The fruit ────────────────────────────────────────────────────────────
+
+const SKIN_SEGMENTS = 72;
+
+type Skin = (p: { u: number; v: number }) => Color;
+/** A piece's painter: its u (around half a turn) or v (down half the profile) mapped onto the whole's. */
+const halfTurn =
+  (skin: Skin): Skin =>
+  (q) =>
+    skin({ u: q.u * 0.5, v: q.v });
+const upperHalf =
+  (skin: Skin): Skin =>
+  (q) =>
+    skin({ u: q.u, v: q.v * 0.5 });
+const upperDisplace = (d: (u: number, v: number) => number) => (u: number, v: number) => d(u, v * 0.5);
+
+function apple(): Fruit {
+  // Drawn as a path (x = distance from the core, y down): dimpled at the top and bottom.
+  const outline = Path.fromSVG('M0 0.1 C 0.12 -0.03 0.42 -0.06 0.5 0.3 C 0.55 0.62 0.36 0.9 0.14 0.93 Q 0.05 0.94 0 0.88');
+  const p = normalize(
+    resample(
+      outline.toContours()[0]!.map(([x, y]) => [x, -y]),
+      64
+    )
+  );
+  const RED: Color = [0.68, 0.04, 0.06];
+  const DEEP: Color = [0.45, 0.02, 0.05];
+  const GOLD: Color = [0.86, 0.66, 0.18];
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    // Streaky red over a gold-green ground that shows near the stem and the bottom.
+    const streak = noise(u, v, 90, 4);
+    let c = mix(RED, DEEP, smoothstep(0.35, 0.9, streak) * 0.7);
+    c = mix(c, GOLD, smoothstep(0.55, 0.8, noise(u, v, 7, 3)) * 0.35); // a sunny patch
+    c = mix(c, [0.72, 0.68, 0.22], smoothstep(0.16, 0.02, v) * 0.75 + smoothstep(0.86, 0.99, v) * 0.6);
+    // Lenticels: tiny pale dots.
+    if (hash(Math.floor(u * 140), Math.floor(v * 70)) > 0.975) c = mix(c, [0.95, 0.85, 0.55], 0.55);
+    return c;
+  };
+  const top = p[0]![1];
+  const bottom = p[p.length - 1]![1];
+  const body = lathe(p, { segments: seg(SKIN_SEGMENTS), color: skin });
+  const whole = merge([
+    { geometry: body },
+    { geometry: stem(0.17, 0.022, 0.05), position: [0, top, 0] },
+    { geometry: leaf(0.32, 0.075), position: [0.03, top + 0.11, 0], rotation: mul(turn([0, 1, 0], -0.5), turn([0, 0, 1], 0.55)) },
+    { geometry: calyx(0.05, 0.015, 5), position: [0, bottom - 0.004, 0], rotation: turn([1, 0, 0], Math.PI / 2), color: [0.3, 0.2, 0.1] }
+  ]);
+  // Cut through the core: cream flesh, a faint core outline around the axis, two seeds.
+  const flesh = (r: number, y: number): Color => {
+    const core = Math.hypot(r / 0.2, y / 0.24);
+    let c: Color = [0.97, 0.93, 0.74];
+    c = mix(c, [0.92, 0.88, 0.62], smoothstep(1.05, 0.85, core)); // the core is a touch greener
+    c = mix(c, [0.82, 0.76, 0.5], smoothstep(0.12, 0, Math.abs(core - 1)) * 0.6); // its outline
+    return mix(c, [1, 0.97, 0.88], smoothstep(0.88, 1, r) * 0.6); // paler just under the skin
+  };
+  const pieces = (): [Model, Model] => {
+    const half = merge([
+      {
+        geometry: lathe(undimpled(p), {
+          segments: seg(SKIN_SEGMENTS),
+          sweep: Math.PI,
+          color: halfTurn(skin),
+          cutColor: flesh,
+          cutSteps: 24,
+          capColor: [0.7, 0.62, 0.25]
+        })
+      },
+      ...[-1, 1].map((side): GeometryPart => ({
+        geometry: seed(),
+        position: [side * 0.06, -0.02, 0.004],
+        scale: [0.045, 0.075, 0.02],
+        rotation: turn([0, 0, 1], side * 0.35),
+        color: [0.3, 0.17, 0.08]
+      }))
+    ]);
+    const piece = createShape(half, { center: false, shine: 0.3 });
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.65 }), juice: [0.98, 0.94, 0.75] }, pieces);
+}
+
+/** Citrus segments on a face cut across: rind, white pith, wedges with pale membranes, a pithy core. */
+function citrusFace(rind: Color, pith: Color, pulp: Color, wedges: number, pithWidth: number) {
+  return (r: number, angle: number): Color => {
+    if (r > 1 - pithWidth * 0.45) return rind;
+    if (r > 1 - pithWidth) return pith;
+    if (r < 0.12) return mix(pith, pulp, smoothstep(0.08, 0.12, r));
+    const w = TAU / wedges;
+    const across = Math.abs(fract(angle / w) - 0.5) * w * r; // distance from the wedge's middle, along the arc
+    const membrane = smoothstep(0.5 * w * r - 0.02, 0.5 * w * r - 0.006, across);
+    // Juice sacs: slightly lighter and darker grains, longer toward the rim.
+    const grain = noise(angle / TAU, r, wedges * 6, 9);
+    return mix(shade(pulp, 0.92 + 0.16 * grain), pith, membrane * 0.85);
+  };
+}
+
+/** Pitted peel: shallow pores pushed into the surface. */
+const peel = (depth: number, fine: number) => (u: number, v: number) =>
+  -depth * Math.pow(noise(u, v, fine, fine * 0.55), 2) - depth * 0.5 * noise(u, v, fine * 2.5, fine * 1.4);
+
+function orange(): Fruit {
+  const p = normalize(rounded(0.94, 0.5, 2, 64));
+  const ORANGE: Color = [1, 0.47, 0.03];
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    let c = shade(ORANGE, 0.9 + 0.14 * noise(u, v, 40, 22));
+    c = mix(c, [0.82, 0.55, 0.12], smoothstep(0.05, 0, v) * 0.6); // green-brown around the stem
+    return mix(c, [0.75, 0.35, 0.05], smoothstep(0.95, 1, v) * 0.7); // the navel
+  };
+  const displace = peel(0.006, 64);
+  const top = p[0]![1];
+  const whole = merge([
+    { geometry: lathe(p, { segments: seg(120), color: skin, displace }) },
+    { geometry: calyx(0.06, 0.025, 5, 0.01), position: [0, top - 0.002, 0], rotation: FACE_UP, color: [0.3, 0.42, 0.14] },
+    {
+      geometry: tube(
+        [
+          [0, top - 0.01, 0],
+          [0, top + 0.035, 0]
+        ],
+        { radius: 0.014, sides: seg(6) }
+      ),
+      color: [0.42, 0.4, 0.2]
+    }
+  ]);
+  const pieces = (): [Model, Model] => {
+    // Cut across the middle: the top half, its cut face showing ten segments.
+    const upper = p.slice(0, Math.floor(p.length / 2) + 1);
+    const face = citrusFace(shade(ORANGE, 0.95), [0.99, 0.95, 0.84], [1, 0.58, 0.08], 10, 0.12);
+    const piece = createShape(
+      merge([
+        {
+          geometry: lathe(upper, { segments: seg(120), color: upperHalf(skin), displace: upperDisplace(displace), capColor: face, capRings: 24 }),
+          rotation: CUT_ACROSS
+        }
+      ]),
+      {
+        center: false,
+        shine: 0.25
+      }
+    );
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.35 }), juice: [1, 0.6, 0.1] }, pieces);
+}
+
+function lemon(): Fruit {
+  // Pointed at both ends; laid on its side.
+  const p = normalize(profile(1, (t) => 0.34 * Math.pow(Math.sin(Math.PI * t), 0.75), 64));
+  const YELLOW: Color = [1, 0.86, 0.12];
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    const c = shade(YELLOW, 0.9 + 0.14 * noise(u, v, 36, 20));
+    return mix(c, [0.62, 0.72, 0.15], (smoothstep(0.06, 0, v) + smoothstep(0.94, 1, v)) * 0.6); // greenish tips
+  };
+  const displace = peel(0.005, 56);
+  const side = turn([0, 0, 1], Math.PI / 2);
+  const whole = merge([{ geometry: lathe(p, { segments: seg(96), color: skin, displace }), rotation: side }]);
+  const pieces = (): [Model, Model] => {
+    const upper = p.slice(0, Math.floor(p.length / 2) + 1);
+    const face = citrusFace(YELLOW, [0.99, 0.97, 0.86], [1, 0.93, 0.5], 9, 0.1);
+    // Cut across the middle of its length (the cut face toward +Z, the rest along -Z, as the whole lies).
+    const piece = createShape(
+      merge([
+        {
+          geometry: lathe(upper, { segments: seg(96), color: upperHalf(skin), displace: upperDisplace(displace), capColor: face, capRings: 20 }),
+          rotation: CUT_ACROSS
+        }
+      ]),
+      {
+        center: false,
+        shine: 0.3
+      }
+    );
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.4 }), juice: [1, 0.95, 0.55] }, pieces);
+}
+
+function pear(): Fruit {
+  // Narrow neck, round bottom, a slight dimple where the stem goes in.
+  const p = normalize(
+    profile(1, (t) => Math.pow(Math.sin(Math.PI * t), 0.55) * (0.18 + 0.37 * Math.pow(t, 1.35)) * (1 - 0.15 * Math.exp(-t * 30)), 64)
+  );
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    let c = mix([0.62, 0.74, 0.2], [0.84, 0.8, 0.28], noise(u, v, 6, 4));
+    const blush = Math.pow(Math.max(0, Math.cos((u - 0.2) * TAU)), 2) * smoothstep(0.3, 0.8, v);
+    c = mix(c, [0.78, 0.28, 0.12], blush * 0.55); // a red cheek on the sunny side
+    c = mix(c, [0.55, 0.42, 0.18], smoothstep(0.12, 0, v) * 0.6); // russet neck
+    if (hash(Math.floor(u * 120), Math.floor(v * 64)) > 0.95) c = mix(c, [0.5, 0.38, 0.18], 0.65); // speckles
+    return c;
+  };
+  const top = p[0]![1];
+  const bottom = p[p.length - 1]![1];
+  const whole = merge([
+    { geometry: lathe(p, { segments: seg(SKIN_SEGMENTS), color: skin }) },
+    { geometry: stem(0.2, 0.02, 0.07), position: [0, top, 0] },
+    { geometry: calyx(0.035, 0.012, 5), position: [0, bottom - 0.003, 0], rotation: turn([1, 0, 0], Math.PI / 2), color: [0.32, 0.22, 0.12] }
+  ]);
+  // The core sits low in a pear, with its seeds.
+  const flesh = (r: number, y: number): Color => {
+    const core = Math.hypot(r / 0.17, (y + 0.15) / 0.17);
+    let c: Color = [0.98, 0.96, 0.82];
+    c = mix(c, [0.92, 0.9, 0.7], smoothstep(1.1, 0.8, core));
+    return mix(c, [0.86, 0.82, 0.58], smoothstep(0.1, 0, Math.abs(core - 1)) * 0.6);
+  };
+  const pieces = (): [Model, Model] => {
+    const half = merge([
+      { geometry: lathe(p, { segments: seg(SKIN_SEGMENTS), sweep: Math.PI, color: halfTurn(skin), cutColor: flesh }) },
+      ...[-1, 1].map((side): GeometryPart => ({
+        geometry: seed(),
+        position: [side * 0.05, -0.16, 0.004],
+        scale: [0.035, 0.06, 0.018],
+        rotation: turn([0, 0, 1], side * 0.3),
+        color: [0.25, 0.14, 0.07]
+      }))
+    ]);
+    const piece = createShape(half, { center: false, shine: 0.25 });
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.45 }), juice: [0.98, 0.96, 0.8] }, pieces);
+}
+
+function strawberry(): Fruit {
+  // Broad shoulders, a pointed tip.
+  const p = normalize(profile(1, (t) => 0.5 * Math.pow(Math.sin(Math.PI * Math.min(1, t * 1.02)), 0.45) * (1 - 0.62 * Math.pow(t, 1.2)), 64));
+  const skin = ({ v }: { v: number }): Color => {
+    let c: Color = [0.82, 0.05, 0.1];
+    c = mix(c, [0.95, 0.8, 0.62], smoothstep(0.1, 0.02, v) * 0.7); // pale under the leaves
+    return mix(c, [0.95, 0.25, 0.12], smoothstep(0.8, 1, v) * 0.5); // a lighter, orange-red tip
+  };
+  // Seeds (achenes) spiral over the surface, every one at the golden angle from the last.
+  const seeds = (sweep: number): GeometryPart[] => {
+    const out: GeometryPart[] = [];
+    const n = 80;
+    for (let i = 0; i < n; i++) {
+      const v = 0.14 + (0.8 * i) / n;
+      const angle = fract(i * 0.381966) * TAU;
+      if (angle > sweep) continue;
+      const [pos, normal] = onSurface(p, v, angle);
+      out.push({
+        geometry: seed(6),
+        position: [pos[0] - normal[0] * 0.003, pos[1] - normal[1] * 0.003, pos[2] - normal[2] * 0.003], // half sunk into the skin
+        rotation: upTo(normal),
+        scale: [0.022, 0.018, 0.03],
+        color: [0.95, 0.8, 0.3]
+      });
+    }
+    return out;
+  };
+  const top = p[0]![1];
+  // Sepals: narrow pointed leaves fanned around the top, drooping over the shoulders.
+  const sepals: GeometryPart[] = [];
+  for (let i = 0; i < 8; i++) {
+    const around = (i / 8) * TAU + 0.2;
+    sepals.push({
+      geometry: leaf(0.26 + 0.05 * Math.sin(i * 2.3), 0.05, { fold: 0.2, teeth: 4, stalk: 0 }),
+      position: [0, top + 0.012, 0],
+      rotation: mul(turn([0, 1, 0], around), turn([0, 0, 1], 0.08 - 0.1 * Math.cos(i * 1.7)))
+    });
+  }
+  const crown: GeometryPart[] = [...sepals, { geometry: stem(0.12, 0.018, 0.02), position: [0, top - 0.02, 0], color: [0.55, 1.2, 0.5] }];
+  const whole = merge([{ geometry: lathe(p, { segments: seg(SKIN_SEGMENTS), color: skin }) }, ...seeds(TAU), ...crown]);
+  // Cut lengthwise: a pale heart fading to red at the edge.
+  const flesh = (r: number, y: number): Color => {
+    const c = mix([1, 0.85, 0.82], [0.88, 0.12, 0.16], smoothstep(0.35, 0.85, r));
+    return mix(c, [0.98, 0.75, 0.72], smoothstep(0.12, 0, Math.abs(r - 0.32)) * 0.4 * smoothstep(-0.4, 0.2, y)); // faint vascular ring
+  };
+  const pieces = (): [Model, Model] => {
+    const piece = createShape(
+      merge([{ geometry: lathe(p, { segments: seg(SKIN_SEGMENTS), sweep: Math.PI, color: halfTurn(skin), cutColor: flesh }) }, ...seeds(Math.PI)]),
+      {
+        center: false,
+        shine: 0.4
+      }
+    );
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.55 }), juice: [0.95, 0.15, 0.2] }, pieces);
+}
+
+function watermelon(): Fruit {
+  // Oblong: lathed along its length, then laid on its side.
+  const p = normalize(rounded(1, 0.36, 2.2, 64));
+  const DARK: Color = [0.07, 0.27, 0.08];
+  const LIGHT: Color = [0.42, 0.62, 0.26];
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    // Dark, jagged stripes running end to end over a pale ground.
+    const wobble = (noise(u, v, 16, 10) - 0.5) * 0.9;
+    const stripe = Math.sin((u * 16 + wobble) * TAU);
+    let c = mix(LIGHT, DARK, smoothstep(-0.35, 0.1, stripe));
+    c = shade(c, 0.9 + 0.15 * noise(u, v, 50, 30));
+    // The field spot where it lay on the ground: a creamy yellow patch on one side.
+    const spot = smoothstep(0.16, 0.05, Math.hypot((fract(u - 0.75 + 0.5) - 0.5) * 2.2, v - 0.5));
+    return mix(c, [0.82, 0.76, 0.38], spot * 0.85);
+  };
+  const side = turn([0, 0, 1], Math.PI / 2);
+  const whole = merge([{ geometry: lathe(p, { segments: seg(96), color: skin }), rotation: side }]);
+  // Cut across the middle: dark rind, a pale band, white, then red flesh, deeper toward the middle.
+  const face = (r: number): Color => {
+    if (r > 0.965) return DARK;
+    if (r > 0.92) return mix([0.62, 0.8, 0.45], [0.85, 0.93, 0.7], (0.965 - r) / 0.045);
+    if (r > 0.86) return mix([0.97, 0.97, 0.85], [0.98, 0.55, 0.5], smoothstep(0.92, 0.86, r));
+    return mix([0.98, 0.3, 0.32], [0.88, 0.1, 0.16], smoothstep(0.85, 0.2, r));
+  };
+  const pieces = (): [Model, Model] => {
+    const upper = p.slice(0, Math.floor(p.length / 2) + 1);
+    const r0 = upper[upper.length - 1]![0]; // the cut face's radius
+    const blackSeeds: GeometryPart[] = [];
+    for (let i = 0; i < 14; i++) {
+      const a = (i / 14) * TAU + (i % 2) * 0.12;
+      const rr = r0 * (0.5 + 0.1 * (i % 3));
+      // On the cut face (y = 0, facing -Y in the lathe), pointing out from the middle.
+      blackSeeds.push({
+        geometry: seed(),
+        position: [Math.cos(a) * rr, -0.004, -Math.sin(a) * rr],
+        rotation: mul(turn([0, 1, 0], a + Math.PI / 2), turn([1, 0, 0], Math.PI / 2)), // lying flat, pointing outward
+        scale: [0.03, 0.05, 0.012],
+        color: [0.08, 0.05, 0.04]
+      });
+    }
+    const half = merge([
+      {
+        geometry: merge([{ geometry: lathe(upper, { segments: seg(96), color: upperHalf(skin), capColor: face, capRings: 24 }) }, ...blackSeeds]),
+        rotation: CUT_ACROSS
+      }
+    ]);
+    const piece = createShape(half, { center: false, shine: 0.25 });
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.35 }), juice: [0.95, 0.2, 0.25] }, pieces);
+}
+
+function banana(): Fruit {
+  // A tapering, five-sided curve along X, centered, 1 unit from tip to stem.
+  const raw: Vec3[] = [];
+  for (let i = 0; i <= 12; i++) {
+    const a = Math.PI * (0.12 + (0.76 * i) / 12);
+    raw.push([-Math.cos(a) * 0.5, -Math.sin(a) * 0.3, 0]);
+  }
+  const xs = raw.map((q) => q[0]);
+  const ys = raw.map((q) => q[1]);
+  const [cx, cy] = [(Math.min(...xs) + Math.max(...xs)) / 2, (Math.min(...ys) + Math.max(...ys)) / 2];
+  const scale = 0.92 / (Math.max(...xs) - Math.min(...xs));
+  const arc: Vec3[] = raw.map(([x, y]) => [(x - cx) * scale, (y - cy) * scale + 0.06, 0]);
+  const radius = (t: number) => 0.014 + 0.09 * Math.pow(Math.sin(Math.PI * Math.min(1, 0.03 + t * 0.97)), 0.55);
+  const ridges = (around: number) => 1 + 0.06 * Math.cos(around * TAU * 5);
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    let c: Color = [1, 0.84, 0.16];
+    c = mix(c, [0.82, 0.76, 0.18], 0.4 * (0.5 + 0.5 * Math.cos(u * TAU * 5))); // darker in the grooves
+    c = mix(c, [0.62, 0.72, 0.2], smoothstep(0.82, 1, v) * 0.6); // still green by the stem
+    c = mix(c, [0.18, 0.12, 0.06], smoothstep(0.05, 0, v)); // the dark blossom tip
+    // Sugar spots.
+    const spot = noise(u, v, 18, 26);
+    if (spot > 0.78) c = mix(c, [0.45, 0.28, 0.08], smoothstep(0.78, 0.88, spot) * 0.9);
+    return c;
+  };
+  const flesh = (r: number): Color => (r > 0.9 ? [1, 0.84, 0.16] : r < 0.22 ? [0.86, 0.8, 0.58] : [0.99, 0.95, 0.78]);
+  // The stalk: green-brown, a little square, with a darker cut end.
+  const end = arc[arc.length - 1]!;
+  const prev = arc[arc.length - 2]!;
+  const dir = [end[0] - prev[0], end[1] - prev[1]];
+  const len = Math.hypot(dir[0]!, dir[1]!);
+  const stalkEnd: Vec3 = [end[0] + (dir[0]! / len) * 0.1, end[1] + (dir[1]! / len) * 0.1 + 0.015, 0];
+  const stalk = tube([end, stalkEnd], {
+    radius: (t) => 0.026 - 0.006 * t,
+    shape: (around) => 1 + 0.12 * Math.cos(around * TAU * 4),
+    sides: seg(12),
+    color: [0.45, 0.48, 0.2],
+    capColor: [0.3, 0.25, 0.12]
+  });
+  const body = (points: Vec3[], t0: number, t1: number) =>
+    tube(points, {
+      radius: (t) => radius(t0 + (t1 - t0) * t),
+      shape: ridges,
+      sides: seg(30),
+      smoothness: 6,
+      color: (p) => skin({ u: p.u, v: t0 + (t1 - t0) * p.v }),
+      capColor: (r) => flesh(r)
+    });
+  const whole = merge([{ geometry: body(arc, 0, 1) }, { geometry: stalk }]);
+  // Cut in the middle: the tip end on the left, the stalk end on the right, each turned so its cut faces +Z.
+  const pieces = (): [Model, Model] => {
+    const mid = Math.floor(arc.length / 2);
+    const left = body(arc.slice(0, mid + 1), 0, mid / (arc.length - 1));
+    const right = merge([{ geometry: body(arc.slice(mid), mid / (arc.length - 1), 1) }, { geometry: stalk }]);
+    return [
+      createShape(merge([{ geometry: left, rotation: turn([0, 1, 0], -Math.PI / 2) }]), { center: false, shine: 0.3 }),
+      createShape(merge([{ geometry: right, rotation: turn([0, 1, 0], Math.PI / 2) }]), { center: false, shine: 0.3 })
+    ];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.3 }), juice: [1, 0.95, 0.72] }, pieces);
+}
+
+function cherries(): Fruit {
+  // Two glossy cherries, dimpled where the stems go in, hanging from stems joined at the top.
+  const outline = Path.fromSVG('M0 0.12 C 0.1 0.01 0.46 -0.04 0.5 0.42 C 0.53 0.76 0.3 0.98 0 0.96');
+  const p = normalize(
+    resample(
+      outline.toContours()[0]!.map(([x, y]) => [x, -y]),
+      40
+    )
+  );
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    let c = mix([0.55, 0.02, 0.07], [0.26, 0.0, 0.04], smoothstep(0.3, 0.75, noise(u, v, 5, 3)) * 0.6 + smoothstep(0.5, 1, v) * 0.35);
+    c = mix(c, [0.78, 0.12, 0.12], smoothstep(0.2, 0.05, v) * 0.4); // lighter around the stem
+    return mix(c, [0.2, 0.02, 0.03], smoothstep(0.92, 1, v) * 0.7); // the dark blossom point
+  };
+  const top = p[0]![1];
+  const S = 0.42;
+  const at: Vec3[] = [
+    [-0.2, -0.2, 0.02],
+    [0.19, -0.28, -0.04]
+  ];
+  const join: Vec3 = [0.06, 0.55, 0];
+  const stemFrom = (c: Vec3, bow: number) =>
+    tube([[c[0], c[1] + top * S - 0.02, c[2]], [c[0] + bow * 0.4, c[1] + 0.38, c[2] * 0.5], [join[0] + bow * 0.15, join[1] - 0.12, 0], join], {
+      radius: (t) => 0.012 + 0.003 * t,
+      sides: seg(7),
+      color: (q) => mix([0.4, 0.55, 0.16], [0.42, 0.32, 0.14], smoothstep(0.75, 1, q.v)),
+      capColor: [0.35, 0.25, 0.12]
+    });
+  const stems: GeometryPart[] = [
+    { geometry: stemFrom(at[0]!, -0.1) },
+    { geometry: stemFrom(at[1]!, 0.08) },
+    { geometry: leaf(0.3, 0.07), position: join, rotation: mul(turn([0, 1, 0], 0.6), turn([0, 0, 1], 0.4)) }
+  ];
+  const body = lathe(p, { segments: seg(40), color: skin });
+  const whole = merge([...at.map((position): GeometryPart => ({ geometry: body, position, scale: S })), ...stems]);
+  // Cut through: dark red flesh around a pale stone.
+  const flesh = (r: number, y: number): Color => {
+    const stone = Math.hypot(r / 0.42, (y + 0.02) / 0.32);
+    if (stone < 1) return mix([0.93, 0.84, 0.66], [0.8, 0.66, 0.5], stone * stone);
+    return mix([0.62, 0.04, 0.1], [0.42, 0.01, 0.06], smoothstep(1, 2.2, stone));
+  };
+  const pieces = (): [Model, Model] => {
+    const half = lathe(undimpled(p), {
+      segments: seg(40),
+      sweep: Math.PI,
+      color: halfTurn(skin),
+      cutColor: flesh,
+      cutSteps: 20,
+      capColor: [0.5, 0.04, 0.08]
+    });
+    return [
+      createShape(merge([{ geometry: half, position: [0, at[0]![1], 0], scale: S }]), { center: false, shine: 0.7 }),
+      createShape(
+        merge([
+          { geometry: half, position: [0, at[1]![1], 0], scale: S },
+          { geometry: merge(stems), position: [-at[1]![0], 0, 0], rotation: yTurn(Math.PI / 2) }
+        ]),
+        {
+          center: false,
+          shine: 0.7
+        }
+      )
+    ];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.85 }), juice: [0.6, 0.03, 0.1] }, pieces);
+}
+
+function grapes(): Fruit {
+  // A bunch: dusky purple grapes with a waxy bloom, packed in a hanging cone below a woody stalk.
+  const p = normalize(rounded(1.12, 0.5, 2, 16));
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    let c = mix([0.3, 0.07, 0.27], [0.17, 0.03, 0.17], smoothstep(0.2, 0.9, noise(u, v, 4, 3)));
+    c = mix(c, [0.52, 0.46, 0.62], 0.3 * smoothstep(0.35, 0.8, noise(u, v, 9, 6))); // the powdery bloom
+    return mix(c, [0.36, 0.14, 0.25], smoothstep(0.6, 0.1, v) * 0.3); // a touch redder on top
+  };
+  const grape = lathe(p, { segments: seg(24), color: skin });
+  const half = lathe(p, {
+    segments: seg(24),
+    sweep: Math.PI,
+    color: halfTurn(skin),
+    cutColor: (r) => (r > 0.93 ? [0.3, 0.08, 0.25] : mix([0.86, 0.9, 0.62], [0.58, 0.68, 0.32], r * r)),
+    cutSteps: 6
+  });
+  const R = 0.085; // a grape's radius
+  // Rings of grapes, wide at the shoulders and narrowing to a single grape at the tip.
+  const spots: { at: Vec3; tint: Color; turn: number }[] = [];
+  const LAYERS = 8;
+  for (let i = 0; i < LAYERS; i++) {
+    const t = i / (LAYERS - 1);
+    const y = 0.32 - t * 0.78;
+    const ring = 0.26 * Math.pow(1 - t, 0.85) * (1 - 0.35 * Math.pow(1 - t, 6));
+    for (const [radius, offset] of [
+      [ring, 0],
+      [ring * 0.45, 0.5]
+    ] as const) {
+      const count = radius < 0.03 ? (offset ? 0 : 1) : Math.max(1, Math.floor((TAU * radius) / (R * 1.85)));
+      for (let k = 0; k < count; k++) {
+        const a = ((k + offset + i * 0.37) / count) * TAU;
+        const j = hash(i, k + offset * 10);
+        spots.push({
+          at: [Math.cos(a) * radius, y + (j - 0.5) * 0.04, Math.sin(a) * radius],
+          tint: shade([1, 0.95 + 0.1 * j, 1], 0.85 + 0.3 * hash(k, i + 3)),
+          turn: j * 2
+        });
+      }
+    }
+  }
+  const scale: Vec3 = [R * 2, R * 2, R * 2];
+  const placed = (s: (typeof spots)[number]): GeometryPart => ({
+    geometry: grape,
+    position: s.at,
+    scale,
+    color: s.tint,
+    rotation: mul(turn([0, 0, 1], (s.turn - 1) * 0.5), yTurn(s.turn * 3))
+  });
+  // The stalk, a few branches into the bunch, a vine leaf and a curly tendril.
+  const WOOD = (q: { v: number; u: number }): Color => mix([0.42, 0.35, 0.16], [0.32, 0.22, 0.1], noise(q.u, q.v, 4, 6));
+  const stalk = tube(
+    [
+      [0.02, 0.62, 0],
+      [0, 0.48, 0],
+      [0.01, 0.3, 0],
+      [0, 0.1, 0]
+    ],
+    { radius: (t) => 0.022 - 0.008 * t, sides: seg(8), color: WOOD, capColor: [0.55, 0.48, 0.3] }
+  );
+  const branches: GeometryPart[] = [0, 1, 2, 3].map((k) => {
+    const a = (k / 4) * TAU + 0.4;
+    return {
+      geometry: tube(
+        [
+          [0, 0.42 - k * 0.04, 0],
+          [Math.cos(a) * 0.12, 0.36 - k * 0.05, Math.sin(a) * 0.12],
+          [Math.cos(a) * 0.2, 0.3 - k * 0.06, Math.sin(a) * 0.2]
+        ],
+        { radius: 0.009, sides: seg(6), color: WOOD }
+      )
+    };
+  });
+  const vine: [number, number][] = [];
+  for (let i = 0; i < 160; i++) {
+    const a = (i / 160) * TAU;
+    // Five pointed lobes (deepest toward the stalk, at the bottom) with saw teeth.
+    const lobes = 0.6 + 0.4 * Math.pow(Math.abs(Math.cos(2.5 * (a - Math.PI / 2))), 0.7);
+    const notch = 1 - 0.55 * Math.exp(-Math.pow((a - Math.PI / 2) / 0.22, 2)); // y down: the stalk end is +y
+    const r = 0.22 * lobes * notch * (1 + (i % 4 === 0 ? 0.06 : 0));
+    vine.push([Math.cos(a) * r, Math.sin(a) * r - 0.05]);
+  }
+  const vineLeaf = recolor(extrude(new Path().addPolygon(vine), { depth: 0.008 }), ({ position }) => {
+    const a = Math.atan2(position[1] + 0.05, position[0]);
+    const vein = Math.min(...[0, 1, 2, 3, 4].map((k) => Math.abs(Math.sin(a - (Math.PI / 2 + (k * TAU) / 5)))));
+    return mix([0.22, 0.48, 0.14], [0.55, 0.72, 0.3], smoothstep(0.08, 0, vein * Math.hypot(position[0], position[1] + 0.05) * 6) * 0.8);
+  });
+  const helix: Vec3[] = [];
+  for (let i = 0; i <= 24; i++) helix.push([-0.04 - i * 0.008, 0.56 + 0.05 * Math.sin(i * 0.8), 0.05 * Math.cos(i * 0.8)]);
+  const top: GeometryPart[] = [
+    { geometry: stalk },
+    ...branches,
+    { geometry: vineLeaf, position: [0.17, 0.56, -0.06], rotation: mul(turn([0, 1, 0], -0.4), turn([1, 0, 0], -0.9)) },
+    { geometry: tube(helix, { radius: 0.005, sides: seg(5), color: [0.45, 0.6, 0.2] }) }
+  ];
+  const whole = merge([...spots.map(placed), ...top]);
+  // Sliced down the middle: the grapes on the cut halved (pale green inside), the rest to each side.
+  const side = (sign: 1 | -1): GeometryPart[] => {
+    const parts: GeometryPart[] = [];
+    for (const s of spots) {
+      if (Math.abs(s.at[0]) < R * 0.7)
+        parts.push({ geometry: half, position: [0, s.at[1], s.at[2]], scale, color: s.tint, rotation: yTurn((sign * Math.PI) / 2) });
+      else if (Math.sign(s.at[0]) === -sign) parts.push(placed(s));
+    }
+    return sign === 1 ? [...parts, ...top] : parts;
+  };
+  const pieces = (): [Model, Model] => {
+    return [
+      createShape(merge([{ geometry: merge(side(1)), rotation: yTurn(-Math.PI / 2) }]), { center: false, shine: 0.4 }),
+      createShape(merge([{ geometry: merge(side(-1)), rotation: yTurn(Math.PI / 2) }]), { center: false, shine: 0.4 })
+    ];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.4 }), juice: [0.75, 0.85, 0.45] }, pieces);
+}
+
+function kiwi(): Fruit {
+  // A blunt oval with fuzzy brown skin, laid on its side.
+  const p = normalize(rounded(1, 0.4, 2.4, 72));
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    let c = mix([0.5, 0.35, 0.18], [0.36, 0.24, 0.11], noise(u, v, 12, 8));
+    c = shade(c, 0.85 + 0.3 * hash(Math.floor(u * 200), Math.floor(v * 90))); // the fuzz
+    return mix(c, [0.3, 0.2, 0.1], (smoothstep(0.05, 0, v) + smoothstep(0.95, 1, v)) * 0.6);
+  };
+  const displace = (u: number, v: number) => -0.004 * noise(u, v, 60, 30);
+  const SIDE = turn([0, 0, 1], Math.PI / 2);
+  // Cut across: bright green flesh streaked toward a creamy core, ringed with tiny black seeds.
+  const face = (r: number, angle: number): Color => {
+    if (r > 0.975) return [0.42, 0.3, 0.14];
+    if (r > 0.94) return mix([0.55, 0.72, 0.2], [0.4, 0.58, 0.12], (r - 0.94) / 0.035);
+    const ray = noise(angle / TAU, r, 70, 3); // fine streaks running out from the core
+    if (r < 0.26) return mix([0.97, 0.96, 0.78], [0.86, 0.9, 0.55], smoothstep(0.18, 0.26, r) * 0.6 + ray * 0.1);
+    const n = 56;
+    const cell = Math.floor((angle / TAU) * n);
+    const jitter = hash(cell, 7);
+    const off = (Math.abs(fract((angle / TAU) * n) - 0.5) / n) * TAU * r; // arc distance from the seed's middle
+    const mid = 0.34 + 0.06 * jitter;
+    if (Math.hypot(off / 0.016, (r - mid) / 0.045) < 1) return [0.06, 0.05, 0.03];
+    const c = mix([0.62, 0.86, 0.22], [0.44, 0.7, 0.08], smoothstep(0.3, 0.9, r));
+    return mix(c, [0.85, 0.95, 0.5], ray * 0.25 * smoothstep(0.95, 0.4, r));
+  };
+  const whole = merge([{ geometry: lathe(p, { segments: seg(96), color: skin, displace }), rotation: SIDE }]);
+  const pieces = (): [Model, Model] => {
+    const upper = p.slice(0, Math.floor(p.length / 2) + 1);
+    const piece = createShape(
+      merge([
+        {
+          geometry: lathe(upper, { segments: seg(168), color: upperHalf(skin), displace: upperDisplace(displace), capColor: face, capRings: 48 }),
+          rotation: CUT_ACROSS
+        }
+      ]),
+      {
+        center: false,
+        shine: 0.45
+      }
+    );
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.05 }), juice: [0.6, 0.85, 0.25] }, pieces);
+}
+
+/** A mango's bean curve and flattened sides, applied after lathing (so cut faces bend too). */
+const mangoShape = ([x, y, z]: Vec3): Vec3 => [x - 0.22 * y * y + 0.05 * y, y, z * 0.8];
+
+function mango(): Fruit {
+  // An egg, broad at the shoulders, curved like a bean and flattened, blushing from green to red.
+  const p = normalize(profile(1, (t) => 0.36 * Math.sqrt(Math.max(0, 1 - Math.pow(2 * t - 1, 2))) * (1.08 - 0.2 * t), 64));
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    const sun = Math.max(0, Math.cos(u * TAU)) * smoothstep(0.85, 0.15, v) + 0.4 * noise(u, v, 5, 3) - 0.15; // the side facing the sun
+    let c = mix([0.42, 0.6, 0.16], [0.96, 0.72, 0.15], smoothstep(0.95, 0.3, v) * 0.8 + 0.25 * noise(u, v, 4, 3));
+    c = mix(c, [0.98, 0.5, 0.12], smoothstep(0.1, 0.5, sun) * 0.8);
+    c = mix(c, [0.78, 0.12, 0.12], smoothstep(0.35, 0.85, sun) * 0.85);
+    if (hash(Math.floor(u * 110), Math.floor(v * 60)) > 0.965) c = mix(c, [0.98, 0.9, 0.55], 0.5); // lenticels
+    return c;
+  };
+  const top = p[0]![1];
+  const stemAt = mangoShape([0, top, 0]);
+  const stub: GeometryPart = { geometry: stem(0.05, 0.018, 0.01), position: [stemAt[0], stemAt[1] - 0.01, 0] };
+  const whole = merge([{ geometry: warp(lathe(p, { segments: seg(SKIN_SEGMENTS), color: skin }), mangoShape) }, stub]);
+  // Cut through the flat sides: deep yellow flesh around a pale, fibrous, flat stone.
+  const flesh = (r: number, y: number): Color => {
+    const stone = Math.hypot(r / 0.24, y / 0.34);
+    if (stone < 1) return mix([0.98, 0.86, 0.5], [0.9, 0.72, 0.32], noise(r, y + 1, 3, 40) * 0.5 + stone * 0.4);
+    const c = mix([1, 0.62, 0.08], [1, 0.76, 0.22], smoothstep(1, 2.6, stone));
+    return mix(c, [0.62, 0.7, 0.2], smoothstep(0.93, 1, r) * 0.6);
+  };
+  const pieces = (): [Model, Model] => {
+    const half = merge([
+      {
+        geometry: warp(lathe(p, { segments: seg(SKIN_SEGMENTS), sweep: Math.PI, color: halfTurn(skin), cutColor: flesh, cutSteps: 32 }), mangoShape)
+      },
+      stub
+    ]);
+    const piece = createShape(half, { center: false, shine: 0.4 });
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.5 }), juice: [1, 0.7, 0.15] }, pieces);
+}
+
+/** A peach's groove (suture), down the side facing +Z, pinched toward the core. */
+const peachShape = ([x, y, z]: Vec3): Vec3 => {
+  const k = 1 - 0.09 * Math.exp(-Math.pow(x / 0.08, 2)) * smoothstep(0, 0.3, z) * smoothstep(0.48, 0.15, Math.abs(y + 0.03));
+  return [x, y, z * k];
+};
+
+function peach(): Fruit {
+  // Round, with a dimpled top, a little point at the bottom, a groove down one side; velvety skin.
+  const outline = Path.fromSVG('M0 0.08 C 0.14 -0.02 0.48 -0.02 0.5 0.42 C 0.52 0.78 0.3 0.96 0.04 0.98 L 0 1.0');
+  const p = normalize(
+    resample(
+      outline.toContours()[0]!.map(([x, y]) => [x, -y]),
+      64
+    )
+  );
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    const blush = smoothstep(0.3, 0.8, noise(u, v, 5, 4) * 0.6 + Math.max(0, Math.cos((u - 0.75) * TAU)) * 0.6);
+    let c = mix([1, 0.74, 0.3], [1, 0.62, 0.22], noise(u, v, 10, 6));
+    c = mix(c, [0.92, 0.3, 0.2], blush * 0.85);
+    c = mix(c, [0.7, 0.1, 0.12], blush * smoothstep(0.6, 0.9, noise(u, v, 48, 28)) * 0.45); // freckled red
+    return mix(shade(c, 0.97 + 0.05 * hash(Math.floor(u * 220), Math.floor(v * 110))), [1, 0.85, 0.7], 0.06); // the fuzz
+  };
+  const top = p[0]![1];
+  const crown: GeometryPart[] = [
+    { geometry: stem(0.05, 0.02, 0.01), position: [0, top - 0.015, 0] },
+    {
+      geometry: leaf(0.4, 0.07, { teeth: 18, fold: 0.3 }),
+      position: [0.01, top + 0.02, 0],
+      rotation: mul(turn([0, 1, 0], 2.4), turn([0, 0, 1], 0.35))
+    }
+  ];
+  const whole = merge([{ geometry: warp(lathe(p, { segments: seg(SKIN_SEGMENTS), color: skin }), peachShape) }, ...crown]);
+  // Cut down the groove: golden flesh blushing red around a wrinkled brown stone.
+  const flesh = (r: number, y: number): Color => {
+    const stone = Math.hypot(r / 0.4, (y + 0.02) / 0.34);
+    if (stone < 1) return mix([0.55, 0.28, 0.14], [0.36, 0.17, 0.08], smoothstep(0.3, 0.7, noise(r * 3, y + 1, 7, 9)));
+    let c = mix([1, 0.74, 0.3], [1, 0.82, 0.42], smoothstep(1.2, 2.6, stone));
+    c = mix(c, [0.88, 0.3, 0.16], smoothstep(1.35, 1, stone) * 0.85); // red around the stone
+    return mix(c, [0.85, 0.3, 0.18], smoothstep(0.94, 1, r) * 0.7);
+  };
+  const pieces = (): [Model, Model] => {
+    const half = merge([
+      {
+        geometry: warp(
+          lathe(undimpled(p), {
+            segments: seg(SKIN_SEGMENTS),
+            sweep: Math.PI,
+            color: halfTurn(skin),
+            cutColor: flesh,
+            cutSteps: 32,
+            capColor: [0.95, 0.5, 0.2]
+          }),
+          peachShape
+        )
+      },
+      ...crown
+    ]);
+    const piece = createShape(half, { center: false, shine: 0.25 });
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.12 }), juice: [1, 0.75, 0.35] }, pieces);
+}
+
+function pineapple(): Fruit {
+  // A barrel covered in diamond scales ("eyes") on two spirals, under a crown of spiky leaves.
+  const p = normalize(resample(rounded(1, 0.34, 2.6, 96), 110));
+  const AROUND = 13;
+  const DOWN = 7;
+  // Each scale's coordinates: which cell, and where in it (0..1 both ways).
+  const scale = (u: number, v: number) => {
+    const a = u * AROUND + v * DOWN;
+    const b = u * AROUND - v * DOWN;
+    return { fa: fract(a), fb: fract(b), cell: Math.floor(a) * 31 + Math.floor(b) };
+  };
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    const { fa, fb, cell } = scale(u, v);
+    const edge = Math.max(Math.abs(fa - 0.5), Math.abs(fb - 0.5)) * 2; // 0 middle .. 1 groove
+    const ripe = smoothstep(0.95, 0.3, v) * 0.8 + 0.3 * hash(cell, 3);
+    let c = mix([0.42, 0.42, 0.12], [0.86, 0.58, 0.14], ripe);
+    c = mix(c, [0.64, 0.42, 0.14], smoothstep(0.45, 0.15, edge) * 0.8); // the eye's brown middle
+    // The spike at the top of each eye.
+    if (Math.hypot(fa - 0.62, fb - 0.62) < 0.1) c = [0.3, 0.2, 0.08];
+    return mix(c, [0.2, 0.18, 0.06], smoothstep(0.75, 1, edge) * 0.85); // dark grooves
+  };
+  const displace = (u: number, v: number) => {
+    const { fa, fb } = scale(u, v);
+    const edge = Math.max(Math.abs(fa - 0.5), Math.abs(fb - 0.5)) * 2;
+    return 0.018 * (Math.sqrt(Math.max(0, 1 - edge * edge)) - 1) * smoothstep(0, 0.06, v) * smoothstep(1, 0.94, v);
+  };
+  const top = p[0]![1];
+  // Crown leaves: flat, tapering, curling outward, in tiers (the inner ones tallest and most upright).
+  const flat = (around: number) => 1 / Math.sqrt(Math.cos(around * TAU) ** 2 + (Math.sin(around * TAU) / 0.16) ** 2);
+  const leaves: GeometryPart[] = [];
+  const tiers = [
+    { n: 7, tilt: 0.45, length: 0.62 },
+    { n: 9, tilt: 0.8, length: 0.55 },
+    { n: 11, tilt: 1.15, length: 0.42 },
+    { n: 9, tilt: 1.45, length: 0.3 }
+  ];
+  tiers.forEach(({ n, tilt, length }, tier) => {
+    for (let k = 0; k < n; k++) {
+      const around = ((k + tier * 0.5) / n) * TAU;
+      const L = length * (0.85 + 0.3 * hash(k, tier));
+      const pts: Vec3[] = [];
+      for (let s = 0; s <= 5; s++) {
+        const t = s / 5;
+        const lean = tilt + t * 0.5; // curling outward toward the tip
+        pts.push([Math.sin(lean) * L * t, Math.cos(lean) * L * t, 0]);
+      }
+      leaves.push({
+        geometry: tube(pts, {
+          radius: (t) => 0.045 * Math.pow(1 - t, 0.9) + 0.002,
+          shape: flat,
+          sides: seg(10),
+          smoothness: 4,
+          color: (q) => mix(mix([0.24, 0.42, 0.22], [0.36, 0.55, 0.3], q.v), [0.6, 0.55, 0.3], smoothstep(0.8, 1, q.v) * 0.7)
+        }),
+        position: [0, top + 0.01, 0],
+        rotation: yTurn(around)
+      });
+    }
+  });
+  const crown: GeometryPart = { geometry: merge(leaves) };
+  const whole = merge([{ geometry: lathe(p, { segments: seg(130), color: skin, displace }) }, crown]);
+  // Cut across: a ring of rind and eyes, juicy golden flesh with radial fibres, a paler woody core.
+  const face = (r: number, angle: number): Color => {
+    if (r > 0.95) return [0.55, 0.42, 0.14];
+    const fibre = noise(angle / TAU, r, 90, 4);
+    if (r > 0.86) return Math.abs(fract((angle / TAU) * AROUND * 2) - 0.5) < 0.12 && r > 0.89 ? [0.55, 0.35, 0.12] : [0.96, 0.84, 0.45];
+    if (r < 0.2) return mix([1, 0.92, 0.62], [0.98, 0.86, 0.5], fibre * 0.4);
+    return shade(mix([1, 0.78, 0.18], [1, 0.84, 0.3], smoothstep(0.8, 0.3, r)), 0.9 + 0.15 * fibre);
+  };
+  const pieces = (): [Model, Model] => {
+    const mid = Math.floor(p.length / 2);
+    const upper = p.slice(0, mid + 1);
+    const lower = p.slice(mid);
+    const upperSkin = (q: { u: number; v: number }) => skin({ u: q.u, v: q.v * 0.5 });
+    const lowerSkin = (q: { u: number; v: number }) => skin({ u: q.u, v: 0.5 + q.v * 0.5 });
+    const opts = { segments: seg(130), capColor: face, capRings: 30 };
+    return [
+      createShape(
+        merge([
+          {
+            geometry: merge([{ geometry: lathe(upper, { ...opts, color: upperSkin, displace: (u, v) => displace(u, v * 0.5) }) }, crown]),
+            rotation: CUT_ACROSS
+          }
+        ]),
+        { center: false, shine: 0.3 }
+      ),
+      createShape(
+        merge([
+          {
+            geometry: lathe(lower, { ...opts, color: lowerSkin, displace: (u, v) => displace(u, 0.5 + v * 0.5) }),
+            rotation: turn([1, 0, 0], Math.PI / 2)
+          }
+        ]),
+        { center: false, shine: 0.3 }
+      )
+    ];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.3 }), juice: [1, 0.85, 0.3] }, pieces);
+}
+
+function pomegranate(): Fruit {
+  // A leathery red ball, slightly flattened and faceted, under a crown of pointed sepals.
+  const p = normalize(rounded(0.9, 0.5, 2, 64));
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    let c = mix([0.72, 0.1, 0.1], [0.5, 0.04, 0.07], smoothstep(0.3, 0.8, noise(u, v, 6, 4)));
+    c = mix(c, [0.88, 0.5, 0.32], smoothstep(0.6, 0.85, noise(u + 0.3, v, 5, 3)) * 0.55); // pale, sun-faded patches
+    c = mix(c, [0.45, 0.06, 0.06], smoothstep(0.7, 0.95, noise(u, v, 60, 30)) * 0.4); // fine marks
+    return mix(c, [0.62, 0.3, 0.2], smoothstep(0.08, 0, v) * 0.6);
+  };
+  const displace = (u: number, v: number) => -0.008 * Math.abs(Math.sin(u * TAU * 3)) * Math.sin(Math.PI * v); // six soft facets
+  const top = p[0]![1];
+  const SEPAL = (q: { v: number }): Color => mix([0.6, 0.14, 0.12], [0.42, 0.22, 0.12], smoothstep(0.6, 1, q.v));
+  const crown: GeometryPart[] = [
+    {
+      geometry: tube(
+        [
+          [0, top - 0.04, 0],
+          [0, top + 0.06, 0]
+        ],
+        { radius: (t) => 0.07 + 0.015 * t, sides: seg(18), color: SEPAL, capColor: [0.35, 0.12, 0.08] }
+      )
+    }
+  ];
+  for (let k = 0; k < 6; k++) {
+    const a = (k / 6) * TAU;
+    crown.push({
+      geometry: tube(
+        [
+          [0.07, 0, 0],
+          [0.09, 0.05, 0],
+          [0.12, 0.1, 0]
+        ],
+        { radius: (t) => 0.025 * (1 - t) + 0.002, sides: seg(6), color: SEPAL }
+      ),
+      position: [0, top + 0.04, 0],
+      rotation: yTurn(a)
+    });
+  }
+  const whole = merge([{ geometry: lathe(p, { segments: seg(SKIN_SEGMENTS), color: skin, displace }) }, ...crown]);
+  // Cut across: pale membranes between chambers packed with glossy, ruby seeds (arils).
+  const face = (r: number): Color => (r > 0.95 ? [0.62, 0.08, 0.09] : r > 0.88 ? [0.98, 0.82, 0.68] : [0.96, 0.9, 0.72]);
+  const pieces = (): [Model, Model] => {
+    const upper = p.slice(0, Math.floor(p.length / 2) + 1);
+    const r0 = upper[upper.length - 1]![0];
+    const aril = lathe(rounded(1.2, 0.5, 2, 8), { segments: seg(8), color: [1, 1, 1] });
+    const arils: GeometryPart[] = [];
+    const GAP = 0.052;
+    for (let gy = -1; gy <= 1; gy += GAP / r0) {
+      for (let gx = -1; gx <= 1; gx += GAP / r0) {
+        const jx = gx + (hash(gx * 13, gy * 7) - 0.5) * 0.04;
+        const jy = gy + (hash(gy * 11, gx * 5) - 0.5) * 0.04 + ((Math.round(gx / (GAP / r0)) % 2) * GAP) / r0 / 2;
+        const r = Math.hypot(jx, jy);
+        const a = Math.atan2(jy, jx);
+        const membrane = Math.abs(Math.sin(a * 3 + 0.3)) * r; // six chambers
+        if (r > 0.84 || r < 0.1 || membrane < 0.05) continue;
+        const h = hash(jx * 31, jy * 17);
+        arils.push({
+          geometry: aril,
+          position: [jx * r0, -0.006, jy * r0],
+          rotation: mul(yTurn(h * TAU), turn([1, 0, 0], Math.PI / 2 + (h - 0.5) * 0.6)),
+          scale: [0.044, 0.05, 0.03],
+          color: mix([0.85, 0.06, 0.14], [0.62, 0.02, 0.1], h)
+        });
+      }
+    }
+    const half = merge([
+      {
+        geometry: merge([
+          {
+            geometry: lathe(upper, {
+              segments: seg(SKIN_SEGMENTS),
+              color: upperHalf(skin),
+              displace: upperDisplace(displace),
+              capColor: face,
+              capRings: 12
+            })
+          },
+          ...crown,
+          ...arils
+        ]),
+        rotation: CUT_ACROSS
+      }
+    ]);
+    const piece = createShape(half, { center: false, shine: 0.55 });
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.45 }), juice: [0.8, 0.05, 0.15] }, pieces);
+}
+
+function papaya(): Fruit {
+  // Long, narrow at the stem end, green ripening to yellow-orange; laid on its side.
+  const p = normalize(profile(1, (t) => 0.25 * Math.pow(Math.max(0, 1 - Math.pow(Math.abs(2 * t - 1), 2.2)), 1 / 2.2) * (0.7 + 0.42 * t), 72));
+  const ribs = (u: number, v: number) => -0.006 * Math.pow(Math.abs(Math.cos(u * TAU * 2.5)), 3) * Math.sin(Math.PI * v); // five faint lobes
+  const skin = ({ u, v }: { u: number; v: number }): Color => {
+    const ripe = smoothstep(0.35, 0.8, v * 0.7 + noise(u, v, 5, 6) * 0.55);
+    let c = mix([0.3, 0.5, 0.14], [0.98, 0.7, 0.16], ripe);
+    c = mix(c, [0.95, 0.5, 0.12], ripe * smoothstep(0.55, 0.85, noise(u, v, 8, 10)) * 0.5);
+    if (hash(Math.floor(u * 140), Math.floor(v * 90)) > 0.97) c = mix(c, [0.25, 0.35, 0.1], 0.5); // speckles
+    return mix(c, [0.4, 0.5, 0.18], smoothstep(0.06, 0, v) * 0.6);
+  };
+  const SIDE = turn([0, 0, 1], -Math.PI / 2); // the stem end to +X
+  const top = p[0]![1];
+  const whole = merge([
+    {
+      geometry: merge([
+        { geometry: lathe(p, { segments: seg(SKIN_SEGMENTS), color: skin, displace: ribs }) },
+        { geometry: stem(0.04, 0.02, 0), position: [0, top - 0.01, 0], color: [1.3, 1.6, 0.9] }
+      ]),
+      rotation: SIDE
+    }
+  ]);
+  // Cut lengthwise: salmon-orange flesh around a glistening hollow full of black seeds.
+  const cavity = (y: number) => Math.max(0, 0.5 * Math.sin(Math.PI * smoothstep(0.25, -0.42, y)));
+  const flesh = (r: number, y: number): Color => {
+    const hollow = cavity(y);
+    if (r > 0.96) return [0.5, 0.6, 0.15];
+    if (r < hollow) return mix([0.5, 0.12, 0.07], [0.95, 0.42, 0.22], smoothstep(0.75, 1, r / hollow)); // the glistening hollow
+    return mix([1, 0.5, 0.26], [1, 0.62, 0.34], smoothstep(hollow, 0.9, r));
+  };
+  const pieces = (): [Model, Model] => {
+    const seeds: GeometryPart[] = [];
+    for (let i = 0; i < 90; i++) {
+      const y = 0.2 - 0.58 * hash(i, 1);
+      const reach = cavity(y) * radiusAt(p, y) * 0.85;
+      if (reach < 0.025) continue;
+      const x = (hash(i, 2) * 2 - 1) * reach;
+      seeds.push({
+        geometry: lathe(rounded(1, 0.5, 2, 8), { segments: seg(10) }),
+        position: [x, y, 0.004 + 0.01 * hash(i, 3)],
+        scale: 0.042,
+        color: [0.06, 0.05, 0.04]
+      });
+    }
+    const half = merge([
+      {
+        geometry: merge([
+          {
+            geometry: lathe(p, {
+              segments: seg(SKIN_SEGMENTS),
+              sweep: Math.PI,
+              color: halfTurn(skin),
+              displace: (u, v) => ribs(u * 0.5, v),
+              cutColor: flesh,
+              cutSteps: 24
+            })
+          },
+          ...seeds
+        ]),
+        rotation: SIDE
+      }
+    ]);
+    const piece = createShape(half, { center: false, shine: 0.45 });
+    return [piece, piece];
+  };
+  return withPieces({ center: boxCenter(whole), whole: createShape(whole, { center: false, shine: 0.4 }), juice: [1, 0.55, 0.3] }, pieces);
+}
+
+const sliced = new WeakSet<Fruit>();
+/** A fruit whose sliced pieces are only built if a game asks for them (Tile Home never does). */
+function withPieces(fruit: Omit<Fruit, 'pieces'>, build: (() => [Model, Model]) | undefined): Fruit {
+  let pieces: [Model, Model] | undefined;
+  const level = detail;
+  const make = () => {
+    detail = level;
+    try {
+      return build!();
+    } finally {
+      detail = 1;
+    }
+  };
+  return Object.defineProperty(fruit, 'pieces', {
+    get: () => {
+      if (!pieces) {
+        pieces = make();
+        build = undefined; // release the builder's temporary geometry once both models are cached
+        sliced.add(fruit as Fruit);
+      }
+      return pieces;
+    },
+    enumerable: true
+  }) as Fruit;
+}
+
+const BUILDERS: Record<FruitKind, () => Fruit> = {
+  apple,
+  orange,
+  lemon,
+  pear,
+  strawberry,
+  watermelon,
+  banana,
+  cherries,
+  grapes,
+  kiwi,
+  mango,
+  peach,
+  pineapple,
+  pomegranate,
+  papaya
+};
+const built = new Map<string, Fruit>();
+
+/**
+ * One fruit, built on first use (mesh ids last for the whole app). Needs the native core.
+ * `level` < 1 builds a lighter mesh for fruit shown small (0.35 still looks round at 60 points).
+ */
+export function getFruit(kind: FruitKind, level = 1): Fruit {
+  const key = `${kind}@${level}`;
+  let fruit = built.get(key);
+  if (!fruit) {
+    let generated: Fruit | undefined;
+    const generate = () => {
+      detail = level;
+      try {
+        return BUILDERS[kind]();
+      } finally {
+        detail = 1;
+      }
+    };
+    const whole = cacheGameAsset(`fruit:${key}:whole`, () => {
+      generated = generate();
+      return { whole: generated.whole, center: generated.center, juice: generated.juice };
+    });
+    let pieces: [Model, Model] | undefined;
+    fruit = Object.defineProperty({ ...whole }, 'pieces', {
+      enumerable: true,
+      get: () => {
+        if (!pieces) {
+          pieces = cacheGameAsset(`fruit:${key}:pieces`, () => (generated ??= generate()).pieces);
+          generated = undefined;
+          sliced.add(fruit!);
+        }
+        return pieces;
+      }
+    }) as Fruit;
+    built.set(key, fruit);
+  }
+  return fruit;
+}
+
+/** Whether `kind` is cached at `level`, including its sliced models when `withSlices` is true. */
+export const isFruitBuilt = (kind: FruitKind, level = 1, withSlices = false) => {
+  const fruit = built.get(`${kind}@${level}`);
+  return fruit !== undefined && (!withSlices || sliced.has(fruit));
+};
+
+/**
+ * Builds `kinds` one per frame, so the screen keeps animating while they're made, then calls `done`.
+ * Already built fruit cost nothing. Returns a cancel function.
+ */
+export function loadFruits(kinds: readonly FruitKind[], done: () => void, level = 1): () => void {
+  const queue = kinds.filter((k) => !built.has(`${k}@${level}`));
+  let frame = 0;
+  let cancelled = false;
+  const step = () => {
+    if (cancelled) return;
+    const kind = queue.shift();
+    if (kind) getFruit(kind, level);
+    if (queue.length) frame = requestAnimationFrame(step);
+    else done();
+  };
+  frame = requestAnimationFrame(step);
+  return () => {
+    cancelled = true;
+    cancelAnimationFrame(frame);
+  };
+}
+
+let fruits: Record<FruitKind, Fruit> | undefined;
+/** Every fruit, built once (mesh ids last for the whole app). Needs the native core. */
+export function getFruits(): Record<FruitKind, Fruit> {
+  if (!fruits) {
+    // Each fruit is built when a game first reads it.
+    const all = {} as Record<FruitKind, Fruit>;
+    for (const kind of Object.keys(BUILDERS) as FruitKind[]) Object.defineProperty(all, kind, { get: () => getFruit(kind), enumerable: true });
+    fruits = all;
+  }
+  return fruits;
+}
+
+/** Whole bodies and cut pieces are separate jobs; board games never build unused slices. */
+export function* warmAssets(kinds: readonly FruitKind[], level: number, pieces = false): Iterable<() => unknown> {
+  for (const kind of kinds) {
+    yield () => getFruit(kind, level).whole;
+    if (pieces) yield () => getFruit(kind, level).pieces;
+  }
+}