@logomarks/core 0.1.9 → 0.2.0

package/src/iso/objects.js

@@ -0,0 +1,1042 @@
+/**
+ * Iso objects: the parts an iso object is built from, on top of the parts' solid engine, scene(). x runs to the front
+ * right, y to the front left, z up; a face shows when it looks along (1, 1, 1): the +x face (right), the +y face (left)
+ * and the top. Each part is one solid (its pieces merge where they share a plane); scene() parts every two parts, and
+ * every two faces that meet at a crease, by the gap. Openings (windows, slots, holes) are cut afterwards on the same
+ * fitted projection, so they stay true to the faces they sit on. Cut-outs square to the viewer (flat()) keep their true
+ * shape and are drawn by isoFlat() as a face and the band of their depth.
+ * From the Logomarks tools (isoparts.mjs, batch 180; shops, roofs, lathes and flat cut-outs added up to batch 285).
+ */
+import { U, D, I, poly, grow, mapPts } from '../geometry/index.js';
+import { scene, isoFit, loft, side, front, hull, ngonPts, box, piece, cyl, glyph } from '../parts/index.js';
+import { cross3 } from '../util/vec.js';
+
+export { cross3 } from '../util/vec.js';
+
+/* ---------- the projection and cuts ---------- */
+
+/**
+ * The projection scene() fits round these parts, so a cut lands on their faces.
+ *
+ * @param {readonly any[]} parts The parts (each a piece or a list of pieces).
+ * @returns {import('../parts/iso.js').FittedProjection} The fitted projection.
+ */
+export const fitOf = (parts) => isoFit(parts.flat().flatMap((q) => q.faces.flatMap((f) => f.pts)));
+
+/**
+ * The house gap in model units for these parts: a slot k wide on a face, parallel to one of its edges, shows k·u·cos 30°.
+ *
+ * @param {readonly any[]} parts The parts.
+ * @param {number} g The gap on the canvas.
+ * @returns {number} The gap in model units.
+ */
+export const gapIn = (parts, g) => g / (fitOf(parts).u * Math.cos(Math.PI / 6));
+
+/**
+ * 2D points [a, b] on the face of axis `ax` at `at`, as 3D points: on an x face a is y, on a y face a is x, and b is z;
+ * on the top, a is x and b is y.
+ *
+ * @param {'x' | 'y' | 'z'} ax The face's axis.
+ * @param {number} at Where the face sits along it.
+ * @param {readonly (readonly number[])[]} pts The 2D points.
+ * @returns {import('../geometry/types.js').Point3[]} The 3D points.
+ */
+export const onFace = (ax, at, pts) => pts.map(([a, b]) => (ax === 'x' ? [at, a, b] : ax === 'y' ? [a, at, b] : [a, b, at]));
+
+/**
+ * 2D points [a, b] on any plane: o + a·u + b·v (a sloped face: a keypad, a windscreen).
+ *
+ * @param {readonly number[]} o The plane's origin.
+ * @param {readonly number[]} u Its first axis.
+ * @param {readonly number[]} v Its second axis.
+ * @param {readonly (readonly number[])[]} pts The 2D points.
+ * @returns {import('../geometry/types.js').Point3[]} The 3D points.
+ */
+export const onPlane = (o, u, v, pts) => pts.map(([a, b]) => [0, 1, 2].map((i) => o[i] + a * u[i] + b * v[i]));
+
+/**
+ * Rectangles [a0, b0, a1, b1] on a face, as 3D quads.
+ *
+ * @param {'x' | 'y' | 'z'} ax The face's axis.
+ * @param {number} at Where the face sits.
+ * @param {readonly (readonly number[])[]} rects The rectangles.
+ * @returns {import('../geometry/types.js').Point3[][]} One quad each.
+ */
+export const quads = (ax, at, rects) => rects.map(([a0, b0, a1, b1]) => onFace(ax, at, [[a0, b0], [a1, b0], [a1, b1], [a0, b1]]));
+
+/**
+ * A disc of radius r at (a, b) on a face.
+ *
+ * @param {'x' | 'y' | 'z'} ax The face's axis.
+ * @param {number} at Where the face sits.
+ * @param {number} a The centre's first coordinate on the face.
+ * @param {number} b Its second.
+ * @param {number} r The radius.
+ * @param {number} [n=72] Sides.
+ * @returns {import('../geometry/types.js').Point3[]} The disc's outline.
+ */
+export const discOn = (ax, at, a, b, r, n = 72) => onFace(ax, at, ngonPts(a, b, r, n));
+
+/**
+ * A 2D shape (drawn about the origin in canvas units, y down) as 3D outlines on an iso face, to cut with isoCut(): on
+ * the +y face a runs along x, on the +x face along −y (so it reads left to right either way).
+ *
+ * @param {'x' | 'y'} ax The face's axis.
+ * @param {number} at Where the face sits.
+ * @param {import('../geometry/types.js').Shape} shape The shape.
+ * @param {number} f Model units per canvas unit.
+ * @param {number} ca The shape's middle on the face, first coordinate.
+ * @param {number} cb Its second.
+ * @returns {import('../geometry/types.js').Point3[][]} The outer ring of each polygon, on the face.
+ */
+export const shapeOn = (ax, at, shape, f, ca, cb) => shape.map((pg) => onFace(ax, at, pg[0].map(([x, y]) => [ax === 'x' ? ca - x * f : ca + x * f, cb - y * f])));
+
+/**
+ * Draws iso parts, cuts the 3D outlines in `holes` through them, then puts back the outlines in `keep` where something
+ * was drawn (the island inside a ring cut: cut a disc, keep a smaller one).
+ *
+ * @param {readonly any[]} parts The parts.
+ * @param {number} g The gap.
+ * @param {readonly (readonly number[])[][]} [holes=[]] 3D outlines to cut.
+ * @param {readonly (readonly number[])[][]} [keep=[]] 3D outlines to put back.
+ * @returns {import('../geometry/types.js').Shape} The mark.
+ */
+export const isoCut = (parts, g, holes = [], keep = []) => {
+	const P = fitOf(parts), pr = (q) => poly(q.map((p) => P(...p))), s = scene(parts, g);
+	const cut = holes.length ? D(s, ...holes.map(pr)) : s;
+	return keep.length ? U(cut, ...keep.map((q) => I(s, pr(q)))) : cut;
+};
+
+/* ---------- solids ---------- */
+
+/**
+ * A cylinder along x (centre y, z), radius r, from x0 to x1 (the parts' cyl() stands upright).
+ *
+ * @param {number} cy The axis's y.
+ * @param {number} cz Its z.
+ * @param {number} r The radius.
+ * @param {number} x0 From.
+ * @param {number} x1 To.
+ * @param {number} [n=72] Sides.
+ * @returns {import('../parts/iso.js').Piece} The cylinder.
+ */
+export const cylX = (cy, cz, r, x0, x1, n = 72) => front(ngonPts(cy, cz, r, n), x0, x1, true);
+
+/**
+ * A cylinder along y (centre x, z), radius r, from y0 to y1.
+ *
+ * @param {number} cx The axis's x.
+ * @param {number} cz Its z.
+ * @param {number} r The radius.
+ * @param {number} y0 From.
+ * @param {number} y1 To.
+ * @param {number} [n=72] Sides.
+ * @returns {import('../parts/iso.js').Piece} The cylinder.
+ */
+export const cylY = (cx, cz, r, y0, y1, n = 72) => side(ngonPts(cx, cz, r, n), y0, y1, true);
+
+/**
+ * An upright frustum (a cup, a cone, a pot): radius r0 at z0 to r1 at z1, n sides turned deg (n = 4, deg = 45: a square
+ * pot). Over 12 sides its side merges into one face.
+ *
+ * @param {number} cx The centre's x.
+ * @param {number} cy Its y.
+ * @param {number} r0 The radius at z0.
+ * @param {number} r1 The radius at z1.
+ * @param {number} z0 The bottom.
+ * @param {number} z1 The top.
+ * @param {number} [n=72] Sides.
+ * @param {number} [deg=0] The turn of the first corner.
+ * @returns {import('../parts/iso.js').Piece} The frustum.
+ */
+export const frustum = (cx, cy, r0, r1, z0, z1, n = 72, deg = 0) =>
+	loft(ngonPts(cx, cy, r0, n, deg).map(([x, y]) => [x, y, z0]), ngonPts(cx, cy, r1, n, deg).map(([x, y]) => [x, y, z1]), n > 12);
+
+/**
+ * A slab hinged on a line along y: t thick and h long, standing up from (x, z) and leaning back by `deg` (towards −x),
+ * from y0 to y1. A laptop's screen, a box's lid.
+ *
+ * @param {number} x The hinge's x.
+ * @param {number} z Its z.
+ * @param {number} y0 From.
+ * @param {number} y1 To.
+ * @param {number} h The slab's length.
+ * @param {number} t Its thickness.
+ * @param {number} deg How far it leans back.
+ * @returns {import('../parts/iso.js').Piece} The slab.
+ */
+export const leaning = (x, z, y0, y1, h, t, deg) => {
+	const a = (deg * Math.PI) / 180, ux = -Math.sin(a), uz = Math.cos(a), nx = Math.cos(a), nz = Math.sin(a);
+	const base = [[x, z], [x + nx * t, z + nz * t]], top = base.map(([px, pz]) => [px + ux * h, pz + uz * h]);
+	return side([base[0], base[1], top[1], top[0]], y0, y1);
+};
+
+/**
+ * A flap hinged on the edge p0–p1 (3D), folded out along the horizontal unit vector `out` by `deg` from upright, L long
+ * and t thick: a carton's flaps. Past 45° its inner face looks at the viewer; short of it, it's nearly edge-on and
+ * vanishes.
+ *
+ * @param {readonly number[]} p0 One end of the hinge.
+ * @param {readonly number[]} p1 The other.
+ * @param {readonly number[]} out The way it folds out (a horizontal unit vector).
+ * @param {number} deg The fold, from upright.
+ * @param {number} L Its length.
+ * @param {number} t Its thickness.
+ * @returns {import('../parts/iso.js').Piece} The flap.
+ */
+export const flap = (p0, p1, out, deg, L, t) => {
+	const a = (deg * Math.PI) / 180, d = [out[0] * Math.sin(a), out[1] * Math.sin(a), Math.cos(a)];
+	const m = [out[0] * Math.cos(a), out[1] * Math.cos(a), -Math.sin(a)], add = (p, v, k) => p.map((c, i) => c + v[i] * k);
+	const q = [p0, p1, add(p1, d, L), add(p0, d, L)];
+	return hull([...q, ...q.map((p) => add(p, m, t))]);
+};
+
+/**
+ * A bar between two 3D points with a square section w (a tonearm, a strut), as a hull.
+ *
+ * @param {readonly number[]} a One end.
+ * @param {readonly number[]} b The other.
+ * @param {number} w The section's side.
+ * @returns {import('../parts/iso.js').Piece} The bar.
+ */
+export const rod = (a, b, w) => {
+	const h = w / 2, c = [[-h, -h], [h, -h], [h, h], [-h, h]];
+	return hull([a, b].flatMap(([x, y, z]) => c.flatMap(([u, v]) => [[x + u, y + v, z - h], [x + u, y + v, z + h]])));
+};
+
+/**
+ * A round bar from a to b (3D points), radius r: two circles square to its axis, lofted smooth (a pestle, a handle at an
+ * angle). Unlike rod() it has no facets, so it reads as one clean shape.
+ *
+ * @param {readonly number[]} a One end.
+ * @param {readonly number[]} b The other.
+ * @param {number} r The radius.
+ * @param {number} [n=48] Sides.
+ * @returns {import('../parts/iso.js').Piece} The tube.
+ */
+export const tube = (a, b, r, n = 48) => {
+	const ax = b.map((v, i) => v - a[i]), L = Math.hypot(...ax), d = ax.map((v) => v / L);
+	const t = Math.abs(d[2]) < 0.9 ? [0, 0, 1] : [1, 0, 0], u = [d[1] * t[2] - d[2] * t[1], d[2] * t[0] - d[0] * t[2], d[0] * t[1] - d[1] * t[0]];
+	const ul = Math.hypot(...u), e1 = u.map((v) => v / ul), e2 = [d[1] * e1[2] - d[2] * e1[1], d[2] * e1[0] - d[0] * e1[2], d[0] * e1[1] - d[1] * e1[0]];
+	const ring = (c) => [...Array(n)].map((_, i) => { const q = (2 * Math.PI * i) / n; return c.map((v, k) => v + r * (Math.cos(q) * e1[k] + Math.sin(q) * e2[k])); });
+	return loft(ring(a), ring(b), true);
+};
+
+/**
+ * A vehicle's wheels on its visible (+y) side: one cylinder along y per x in `xs`, radius r at height z, standing proud
+ * of the side at y = W.
+ *
+ * @param {readonly number[]} xs Each wheel's x.
+ * @param {number} W The side's y.
+ * @param {number} [r=0.36] The radius.
+ * @param {number} [z=0.34] The axle's height.
+ * @returns {import('../parts/iso.js').Piece[]} The wheels.
+ */
+export const wheels = (xs, W, r = 0.36, z = 0.34) => xs.map((x) => cylY(x, z, r, W - 0.25, W + 0.06));
+
+/**
+ * A rectangle w wide from z0 to z1 on the tangent plane at the front of an upright cylinder (the point facing the
+ * viewer, along (1, 1)): a postbox's slot, a label on a can.
+ *
+ * @param {number} cx The cylinder's x.
+ * @param {number} cy Its y.
+ * @param {number} r Its radius.
+ * @param {number} w The rectangle's width.
+ * @param {number} z0 Its bottom.
+ * @param {number} z1 Its top.
+ * @returns {import('../geometry/types.js').Point3[]} The rectangle, as a 3D quad.
+ */
+export const cylFront = (cx, cy, r, w, z0, z1) => {
+	const d = Math.SQRT1_2, c = [cx + r * d, cy + r * d], h = (w / 2) * d;
+	return [[c[0] + h, c[1] - h, z0], [c[0] - h, c[1] + h, z0], [c[0] - h, c[1] + h, z1], [c[0] + h, c[1] - h, z1]];
+};
+
+/**
+ * A ball (an apple, a heap of popcorn) as one part: rings of frustums whose sides merge into one face, so it draws as
+ * one round solid. `squash` flattens it (z radius = r · squash); it runs from latitude `from` (−90 = the bottom) to
+ * `to`. Stop `to` short of 90 (about 60) so the top is a flat disc, not a dot: a dot on a dome reads as a nipple.
+ *
+ * @param {number} cx The centre's x.
+ * @param {number} cy Its y.
+ * @param {number} cz Its z.
+ * @param {number} r The radius.
+ * @param {{ squash?: number, rings?: number, from?: number, to?: number }} [o] The squash (1), the rings (8) and the
+ *   latitudes it runs between (−90 to 90).
+ * @returns {import('../parts/iso.js').Piece[]} The ball, one part.
+ */
+export const ball = (cx, cy, cz, r, { squash = 1, rings = 8, from = -90, to = 90 } = {}) => [...Array(rings)].map((_, i) => {
+	const a0 = ((from + ((to - from) * i) / rings) * Math.PI) / 180, a1 = ((from + ((to - from) * (i + 1)) / rings) * Math.PI) / 180;
+	return frustum(cx, cy, Math.max(r * Math.cos(a0), 0.02), Math.max(r * Math.cos(a1), 0.02), cz + r * squash * Math.sin(a0), cz + r * squash * Math.sin(a1));
+});
+
+/**
+ * A band along an arc in a side profile (x, z), centre (cx, cz), radii r0–r1 from angle a0 to a1 (degrees), pushed along
+ * y from y0 to y1, as convex pieces of one part: a taco shell, a melon's rind.
+ *
+ * @param {number} cx The arc's centre, x.
+ * @param {number} cz Its z.
+ * @param {number} r0 The inner radius.
+ * @param {number} r1 The outer radius.
+ * @param {number} a0 From (degrees).
+ * @param {number} a1 To.
+ * @param {number} y0 The band's near side.
+ * @param {number} y1 Its far side.
+ * @param {number} [n=16] Pieces.
+ * @returns {import('../parts/iso.js').Piece[]} The band.
+ */
+export const arcSide = (cx, cz, r0, r1, a0, a1, y0, y1, n = 16) => [...Array(n)].map((_, i) => {
+	const t0 = ((a0 + ((a1 - a0) * i) / n) * Math.PI) / 180, t1 = ((a0 + ((a1 - a0) * (i + 1)) / n) * Math.PI) / 180;
+	const P = (r, t) => [cx + r * Math.cos(t), cz + r * Math.sin(t)];
+	return side([P(r0, t0), P(r1, t0), P(r1, t1), P(r0, t1)], y0, y1);
+});
+
+/**
+ * arcSide()'s band pushed along x instead (its profile in (y, z)).
+ *
+ * @param {number} cy The arc's centre, y.
+ * @param {number} cz Its z.
+ * @param {number} r0 The inner radius.
+ * @param {number} r1 The outer radius.
+ * @param {number} a0 From (degrees).
+ * @param {number} a1 To.
+ * @param {number} x0 The band's one side.
+ * @param {number} x1 Its other.
+ * @param {number} [n=16] Pieces.
+ * @returns {import('../parts/iso.js').Piece[]} The band.
+ */
+export const arcFront = (cy, cz, r0, r1, a0, a1, x0, x1, n = 16) => [...Array(n)].map((_, i) => {
+	const t0 = ((a0 + ((a1 - a0) * i) / n) * Math.PI) / 180, t1 = ((a0 + ((a1 - a0) * (i + 1)) / n) * Math.PI) / 180;
+	const P = (r, t) => [cy + r * Math.cos(t), cz + r * Math.sin(t)];
+	return front([P(r0, t0), P(r1, t0), P(r1, t1), P(r0, t1)], x0, x1);
+});
+
+/* ---------- roofs ---------- */
+
+/**
+ * A gable roof from z0 rising by `rise` over the box x0–x1 × y0–y1, its ridge along y (the gable ends face ±y).
+ *
+ * @param {number} x0 The box's x from.
+ * @param {number} x1 Its x to.
+ * @param {number} y0 Its y from.
+ * @param {number} y1 Its y to.
+ * @param {number} z0 The eaves.
+ * @param {number} rise The ridge's height above them.
+ * @returns {import('../parts/iso.js').Piece} The roof.
+ */
+export const roofY = (x0, x1, y0, y1, z0, rise) => side([[x0, z0], [x1, z0], [(x0 + x1) / 2, z0 + rise]], y0, y1);
+
+/**
+ * A gable roof with its ridge along x (the gable ends face ±x).
+ *
+ * @param {number} x0 The box's x from.
+ * @param {number} x1 Its x to.
+ * @param {number} y0 Its y from.
+ * @param {number} y1 Its y to.
+ * @param {number} z0 The eaves.
+ * @param {number} rise The ridge's height above them.
+ * @returns {import('../parts/iso.js').Piece} The roof.
+ */
+export const roofX = (x0, x1, y0, y1, z0, rise) => front([[y0, z0], [y1, z0], [(y0 + y1) / 2, z0 + rise]], x0, x1);
+
+/* ---------- shopfronts ---------- */
+
+/**
+ * A shop: a block W along x, D along y, H tall, and its shopfront cut in the +y face: a window over the left half and a
+ * door at the right, both scaled to the block (`win: false` leaves only the door; `door` moves it, as a fraction of W).
+ * Jambs, sill and head are at least about 0.4 wide, so no strip of wall is thinner than the gap once it's cut.
+ *
+ * @param {number} W The block's length along x.
+ * @param {number} D Its depth along y.
+ * @param {number} H Its height.
+ * @param {{ win?: boolean, door?: number | null, dh?: number }} [o] The window (true), the door's place (null: at the
+ *   right) and its height as a fraction of H (0.62).
+ * @returns {{ parts: import('../parts/iso.js').Piece[], cuts: import('../geometry/types.js').Point3[][], c: import('../geometry/types.js').Point3 }}
+ *   The block, its shopfront cuts and the roof's centre (where the trade feature goes).
+ */
+export const shop = (W, D, H, { win = true, door = null, dh = 0.62 } = {}) => {
+	// jambs, sill and head at least ~0.4 wide, so no strip of wall is thinner than the gap once it's cut
+	const dw = Math.min(0.5, W * 0.2), d0 = door == null ? W - dw - 0.42 : W * door, top = Math.min(H * dh, H - 0.42, 1.05), sill = Math.max(0.36, H * 0.22);
+	const cuts = quads('y', D, [...(win && d0 - 0.4 - 0.38 > 0.45 && top - sill > 0.35 ? [[0.38, sill, d0 - 0.4, top]] : []), [d0, 0, d0 + dw, top]]);
+	return { parts: [box([0, 0, 0], [W, D, H])], cuts, c: [W / 2, D / 2, H] };
+};
+
+/**
+ * A flat profile [[x, z]…] (convex) standing on the roof facing +y, t thick, centred on y = yc.
+ *
+ * @param {readonly (readonly number[])[]} pts The profile.
+ * @param {number} yc Its middle along y.
+ * @param {number} [t=0.42] Its thickness.
+ * @returns {import('../parts/iso.js').Piece} The sign.
+ */
+export const sign = (pts, yc, t = 0.42) => side(pts, yc - t / 2, yc + t / 2);
+
+/**
+ * A disc of radius r standing on edge at (x, z) facing +y, t deep, centred on y = yc.
+ *
+ * @param {number} x The centre's x.
+ * @param {number} z Its z.
+ * @param {number} r The radius.
+ * @param {number} yc Its middle along y.
+ * @param {number} [t=0.42] Its depth.
+ * @returns {import('../parts/iso.js').Piece} The disc.
+ */
+export const discY = (x, z, r, yc, t = 0.42) => cylY(x, z, r, yc - t / 2, yc + t / 2);
+
+/**
+ * A disc of radius r standing on edge at (y, z) facing +x, t deep, centred on x = xc.
+ *
+ * @param {number} y The centre's y.
+ * @param {number} z Its z.
+ * @param {number} r The radius.
+ * @param {number} xc Its middle along x.
+ * @param {number} [t=0.42] Its depth.
+ * @returns {import('../parts/iso.js').Piece} The disc.
+ */
+export const discX = (y, z, r, xc, t = 0.42) => cylX(y, z, r, xc - t / 2, xc + t / 2);
+
+/**
+ * Scales a 3D point list about o by k.
+ *
+ * @param {readonly (readonly number[])[]} pts The points.
+ * @param {readonly number[]} o The centre.
+ * @param {number} k The factor.
+ * @returns {number[][]} The scaled points.
+ */
+export const sc3 = (pts, o, k) => pts.map((p) => p.map((v, i) => o[i] + (v - o[i]) * k));
+
+/**
+ * A part (a piece or a list of pieces) scaled about o by k: a roof feature drawn bigger, so it holds at 32 px.
+ *
+ * @param {any} part The part.
+ * @param {readonly number[]} o The centre.
+ * @param {number} k The factor.
+ * @returns {any} The part, scaled (a piece, or a list of pieces, as it came).
+ */
+export const scalePart = (part, o, k) => (Array.isArray(part) ? part.map((q) => scalePart(q, o, k)) : piece(part.faces.map((f) => sc3(f.pts, o, k)), part.faces.map((f) => f.tag)));
+
+/**
+ * A shop with its trade feature, as a build `(g) => shape`: `feat(c, W, D, H, k)` returns [parts, cuts, keeps, flats] (k
+ * is the gap in model units; flats are flat() cut-outs, drawn by isoFlat()); the shop's own shopfront cuts are added.
+ * `o` takes shop()'s options plus `big`, which scales the feature's parts, cuts and flats about the roof's centre.
+ *
+ * @param {readonly number[]} size The shop's [W, D, H].
+ * @param {(c: number[], W: number, D: number, H: number, k: number) => any[]} feat The trade feature.
+ * @param {{ win?: boolean, door?: number | null, dh?: number, big?: number }} [o] shop()'s options and the feature's scale.
+ * @returns {(g: number) => import('../geometry/types.js').Shape} The build.
+ */
+export const shopMark = ([W, D, H], feat, o = {}) => (g) => {
+	const sh = shop(W, D, H, o), big = o.big || 1, fe = (k) => {
+		const [p, c = [], kp = []] = feat(sh.c, W, D, H, k);
+		return big === 1 ? [p, c, kp] : [p.map((q) => scalePart(q, sh.c, big)), c.map((q) => sc3(q, sh.c, big)), kp.map((q) => sc3(q, sh.c, big))];
+	};
+	const k = gapIn([...sh.parts, ...fe(0)[0]], g), [parts, cuts, keep] = fe(k / big), fl = (feat(sh.c, W, D, H, k / big)[3] || []).map((f) => scaleFlat(f, sh.c, big));
+	return fl.length ? isoFlat([...sh.parts, ...parts], g, fl, [...sh.cuts, ...cuts], keep) : isoCut([...sh.parts, ...parts], g, [...sh.cuts, ...cuts], keep);
+};
+
+/* ---------- open and tapered boxes ---------- */
+
+/**
+ * A box tapering from a w × d footprint at z0 to W × D at z1, centred on (cx, cy): a bin, a hopper, a jar, a lectern.
+ *
+ * @param {number} cx The centre's x.
+ * @param {number} cy Its y.
+ * @param {number} w The width (along x) at z0.
+ * @param {number} d The depth (along y) at z0.
+ * @param {number} W The width at z1.
+ * @param {number} D The depth at z1.
+ * @param {number} z0 The bottom.
+ * @param {number} z1 The top.
+ * @returns {import('../parts/iso.js').Piece} The box.
+ */
+export const taper = (cx, cy, w, d, W, D, z0, z1) => loft([[-w, -d], [w, -d], [w, d], [-w, d]].map(([x, y]) => [cx + x / 2, cy + y / 2, z0]), [[-W, -D], [W, -D], [W, D], [-W, D]].map(([x, y]) => [cx + x / 2, cy + y / 2, z1]));
+
+/**
+ * An open box's walls (one part): floor and four walls t thick, so its inside shows: a tray, a crib, a planter.
+ *
+ * @param {number} x0 The box's x from.
+ * @param {number} y0 Its y from.
+ * @param {number} x1 Its x to.
+ * @param {number} y1 Its y to.
+ * @param {number} h The walls' height.
+ * @param {number} t Their thickness (and the floor's).
+ * @param {number} [z0=0] The floor's bottom.
+ * @returns {import('../parts/iso.js').Piece[]} The floor and walls.
+ */
+export const tray = (x0, y0, x1, y1, h, t, z0 = 0) => [box([x0, y0, z0], [x1, y1, z0 + t]), box([x0, y0, z0], [x0 + t, y1, z0 + h]), box([x0, y0, z0], [x1, y0 + t, z0 + h]), box([x1 - t, y0, z0], [x1, y1, z0 + h]), box([x0, y1 - t, z0], [x1, y1, z0 + h])];
+
+/* ---------- the plane facing the viewer, and lathes ---------- */
+
+/**
+ * The upright plane's right-hand axis: it faces the viewer square on and runs to the right on the canvas (along
+ * (1, −1, 0)). A profile drawn in it keeps its true shape: no iso shear, unlike one on the +x or +y face.
+ */
+export const FU = [Math.SQRT1_2, -Math.SQRT1_2, 0];
+
+/** The facing plane's normal: it points out at the viewer (along (1, 1, 0)). */
+export const FN = [Math.SQRT1_2, Math.SQRT1_2, 0];
+
+/**
+ * 2D points [a, b] (a to the right, b up) on the facing plane through o, pushed s towards the viewer, as 3D points.
+ *
+ * @param {readonly number[]} o A point on the plane.
+ * @param {readonly (readonly number[])[]} pts The 2D points.
+ * @param {number} [s=0] How far towards the viewer.
+ * @returns {import('../geometry/types.js').Point3[]} The 3D points.
+ */
+export const onFacing = (o, pts, s = 0) => onPlane([o[0] + s * FN[0], o[1] + s * FN[1], o[2]], FU, [0, 0, 1], pts);
+
+/**
+ * A convex profile on the facing plane through o, t deep (half each side of o): a cut-out solid whose face keeps its
+ * shape and whose upward edges show below it as its depth (a wooden toy, a donut on edge). `smooth` merges its sides.
+ *
+ * @param {readonly number[]} o A point on the plane.
+ * @param {readonly (readonly number[])[]} pts The profile (convex, a to the right, b up).
+ * @param {number} t The depth.
+ * @param {boolean} [smooth=false] Merge the sides into one face (an arc).
+ * @returns {import('../parts/iso.js').Piece} The solid.
+ */
+export const facing = (o, pts, t, smooth = false) => loft(onFacing(o, pts, -t / 2), onFacing(o, pts, t / 2), smooth);
+
+/**
+ * A band between radii r0 and r1 round (a, b) on the facing plane, from angle a0 to a1 (degrees), t deep, as convex
+ * pieces of one part. scene() can't order pieces whose boxes overlap, so a full ring draws side faces over its front:
+ * for a ring or any outline that isn't convex, use flat() instead.
+ *
+ * @param {readonly number[]} o A point on the plane.
+ * @param {readonly number[]} c The band's centre [a, b] on the plane.
+ * @param {number} r0 The inner radius.
+ * @param {number} r1 The outer radius.
+ * @param {number} a0 From (degrees).
+ * @param {number} a1 To.
+ * @param {number} t The depth.
+ * @param {number} [n=48] Pieces.
+ * @returns {import('../parts/iso.js').Piece[]} The band.
+ */
+export const facingArc = (o, [a, b], r0, r1, a0, a1, t, n = 48) => [...Array(n)].map((_, i) => {
+	const t0 = ((a0 + ((a1 - a0) * i) / n) * Math.PI) / 180, t1 = ((a0 + ((a1 - a0) * (i + 1)) / n) * Math.PI) / 180;
+	const P = (r, u) => [a + r * Math.cos(u), b + r * Math.sin(u)];
+	return facing(o, [P(r0, t0), P(r1, t0), P(r1, t1), P(r0, t1)], t, true);
+});
+
+/**
+ * A lathe round (cx, cy): stacked frustums through the profile [[r, z]…], bottom to top, their sides merged into one
+ * face (a bowling pin, a vase).
+ *
+ * @param {number} cx The axis's x.
+ * @param {number} cy Its y.
+ * @param {readonly (readonly number[])[]} prof The profile, [radius, height] bottom to top.
+ * @param {number} [n=72] Sides.
+ * @returns {import('../parts/iso.js').Piece[]} The lathe, one part.
+ */
+export const lathe = (cx, cy, prof, n = 72) => prof.slice(1).map(([r, z], i) => frustum(cx, cy, prof[i][0], r, prof[i][1], z, n));
+
+/**
+ * A cut-out square to the viewer: its outline the convex 2D polys in `outer` less the polys in `holes` (a, b on the
+ * facing plane through o, as onFacing()), t deep. Drawn by isoFlat() as one face and the band of its depth above it, so
+ * a profile that isn't convex (a rocking horse, a donut) keeps its true shape without scene() having to order its
+ * pieces. flat() subtracts its holes by orientation: pass outlines anticlockwise (ccw(), flatCcw()).
+ *
+ * @param {readonly number[]} o A point on the plane.
+ * @param {readonly (readonly (readonly number[])[])[]} outer Convex 2D outlines, their union the cut-out.
+ * @param {number} t The depth.
+ * @param {readonly (readonly (readonly number[])[])[]} [holes=[]] 2D outlines to take out of it.
+ * @returns {import('./objects.js').Flat} The cut-out.
+ */
+export const flat = (o, outer, t, holes = []) => ({ outer: outer.map((q) => onFacing(o, q, t / 2)), holes: holes.map((q) => onFacing(o, q, t / 2)), back: FN.map((v) => -v * t) });
+
+/**
+ * A 2D outline turned anticlockwise (a, b with b up): flat() subtracts its holes by orientation, and slot2()'s quads run
+ * clockwise, so a slot passed as a hole (or an outline) must be turned first.
+ *
+ * @param {readonly (readonly number[])[]} pts The outline.
+ * @returns {number[][]} It, anticlockwise.
+ */
+export const ccw = (pts) => {
+	let a = 0;
+	pts.forEach(([x0, y0], i) => { const [x1, y1] = pts[(i + 1) % pts.length]; a += x0 * y1 - x1 * y0; });
+	return a < 0 ? pts.slice().reverse() : pts;
+};
+
+/**
+ * flat() with every outline and hole turned anticlockwise first.
+ *
+ * @param {readonly number[]} o A point on the plane.
+ * @param {readonly (readonly (readonly number[])[])[]} outer Convex 2D outlines.
+ * @param {number} t The depth.
+ * @param {readonly (readonly (readonly number[])[])[]} [holes=[]] 2D outlines to take out.
+ * @returns {import('./objects.js').Flat} The cut-out.
+ */
+export const flatCcw = (o, outer, t, holes = []) => flat(o, outer.map(ccw), t, holes.map(ccw));
+
+/**
+ * A flat() scaled about o by k (a roof feature drawn bigger).
+ *
+ * @param {import('./objects.js').Flat} f The cut-out.
+ * @param {readonly number[]} o The centre.
+ * @param {number} k The factor.
+ * @returns {import('./objects.js').Flat} The scaled cut-out.
+ */
+export const scaleFlat = (f, o, k) => {
+	const sc = (q) => q.map((p) => p.map((v, i) => o[i] + (v - o[i]) * k));
+	return { outer: f.outer.map(sc), holes: f.holes.map(sc), back: f.back.map((v) => v * k) };
+};
+
+/**
+ * A 2D shape swept along the screen vector v: the shape, its copy moved by v, and every edge's sweep between them (a
+ * cut-out's depth; an oblique solid).
+ *
+ * @param {import('../geometry/types.js').Shape} sh The shape.
+ * @param {readonly number[]} v The sweep.
+ * @returns {import('../geometry/types.js').Shape} The swept shape.
+ */
+export const sweep = (sh, v) => U(sh, mapPts(sh, ([x, y]) => [x + v[0], y + v[1]]), ...sh.flatMap((pg) => pg.flatMap((r) => r.map((p, i) => { const q = r[(i + 1) % r.length]; return poly([p, q, [q[0] + v[0], q[1] + v[1]], [p[0] + v[0], p[1] + v[1]]]); }))));
+
+/**
+ * isoCut() with flat() cut-outs in front of the parts. Each is put in the scene as its convex pieces (so the parts
+ * behind it are hidden and parted from it by the gap), then that region is redrawn: the front face F, and the band of
+ * its depth showing above it (F swept back along its depth, less F), each shrunk by g/2 so they sit a gap apart. Holes
+ * show what's behind the band; cut-outs later in the list stand in front of earlier ones, a gap clear of them.
+ *
+ * @param {readonly any[]} parts The parts.
+ * @param {number} g The gap.
+ * @param {readonly import('./objects.js').Flat[]} flats The cut-outs, back to front.
+ * @param {readonly (readonly number[])[][]} [holes=[]] 3D outlines to cut.
+ * @param {readonly (readonly number[])[][]} [keep=[]] 3D outlines to put back.
+ * @returns {import('../geometry/types.js').Shape} The mark.
+ */
+export const isoFlat = (parts, g, flats, holes = [], keep = []) => {
+	const add = (q, v) => q.map((p) => p.map((c, i) => c + v[i]));
+	const all = [...parts, ...flats.flatMap((f) => f.outer.map((q) => loft(add(q, f.back), q)))], P = fitOf(all), pr = (q) => poly(q.map((p) => P(...p)));
+	let base = scene(all, g), ink = []; // flats later in the list stand in front of earlier ones, a gap clear of them
+	for (const f of flats) {
+		const o = P(0, 0, 0), b = P(...f.back), v = [b[0] - o[0], b[1] - o[1]], full = U(...f.outer.map(pr)), F = f.holes.length ? D(full, ...f.holes.map(pr)) : full, E = sweep(full, v);
+		base = D(base, E); ink = U(D(ink, grow(E, g / 2)), grow(F, -g / 2), grow(D(sweep(F, v), F), -g / 2));
+	}
+	const s = U(base, ink), cut = holes.length ? D(s, ...holes.map(pr)) : s;
+	return keep.length ? U(cut, ...keep.map((q) => I(s, pr(q)))) : cut;
+};
+
+/* ---------- 2D outlines and turned solids ---------- */
+
+/**
+ * Points round an ellipse (a, b), radii ra and rb, from d0 to d1 degrees (2D, both ends included).
+ *
+ * @param {number} a The centre's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} ra The radius along a.
+ * @param {number} rb The radius along b.
+ * @param {number} d0 From (degrees).
+ * @param {number} d1 To.
+ * @param {number} [n=24] Steps.
+ * @returns {import('../geometry/types.js').Point[]} n + 1 points.
+ */
+export const arcPts = (a, b, ra, rb, d0, d1, n = 24) => [...Array(n + 1)].map((_, i) => { const t = ((d0 + ((d1 - d0) * i) / n) * Math.PI) / 180; return [a + ra * Math.cos(t), b + rb * Math.sin(t)]; });
+
+/**
+ * A slot w wide along the segment p–q (2D), as a quad.
+ *
+ * @param {readonly number[]} p One end.
+ * @param {readonly number[]} q The other.
+ * @param {number} w The width.
+ * @returns {import('../geometry/types.js').Point[]} The quad.
+ */
+export const slot2 = ([x0, y0], [x1, y1], w) => {
+	const L = Math.hypot(x1 - x0, y1 - y0), nx = (-(y1 - y0) / L) * (w / 2), ny = ((x1 - x0) / L) * (w / 2);
+	return [[x0 + nx, y0 + ny], [x1 + nx, y1 + ny], [x1 - nx, y1 - ny], [x0 - nx, y0 - ny]];
+};
+
+/**
+ * A ring of gap w wide at radius r round (a, b) on a face, as small quads (a ring is no simple outline, so it's cut in
+ * pieces).
+ *
+ * @param {number} a The centre's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} r The radius.
+ * @param {number} w The width.
+ * @param {number} [n=48] Quads.
+ * @returns {import('../geometry/types.js').Point[][]} The quads.
+ */
+export const ring2 = (a, b, r, w, n = 48) => [...Array(n)].map((_, i) => {
+	const t0 = (2 * Math.PI * i) / n, t1 = (2 * Math.PI * (i + 1)) / n, P = (rr, t) => [a + rr * Math.cos(t), b + rr * Math.sin(t)];
+	return [P(r - w / 2, t0), P(r + w / 2, t0), P(r + w / 2, t1), P(r - w / 2, t1)];
+});
+
+/**
+ * A part re-aimed and moved: each point p goes to T + p.x·e1 + p.y·e2 + p.z·e3, so a lathe built up z round the origin
+ * lies along e3 from T.
+ *
+ * @param {any} part The part (a piece or a list of pieces).
+ * @param {readonly number[]} T Where the origin goes.
+ * @param {readonly number[]} e1 Where x points.
+ * @param {readonly number[]} e2 Where y points.
+ * @param {readonly number[]} e3 Where z points.
+ * @returns {any} The part, moved.
+ */
+export const turned = (part, T, e1, e2, e3) => (Array.isArray(part) ? part.map((q) => turned(q, T, e1, e2, e3)) :
+	piece(part.faces.map((f) => f.pts.map((p) => [0, 1, 2].map((i) => T[i] + p[0] * e1[i] + p[1] * e2[i] + p[2] * e3[i]))), part.faces.map((f) => f.tag)));
+
+/**
+ * A capsule's lathe profile [[r, z]…] up z from 0: a round end of radius r, a straight run L, and a round end again if
+ * `both`.
+ *
+ * @param {number} r The radius.
+ * @param {number} L The straight run.
+ * @param {boolean} [both=true] Round the top end too.
+ * @returns {number[][]} The profile, for lathe().
+ */
+export const capsule = (r, L, both = true) => {
+	const cap = (d) => [r * Math.sin((d * Math.PI) / 180), r * (1 - Math.cos((d * Math.PI) / 180))], ds = [12, 30, 48, 66, 90];
+	return [...ds.map(cap), ...(both ? ds.slice().reverse().map((d) => { const [rr, h] = cap(d); return [rr, 2 * r + L - h]; }) : [[r, r + L]])];
+};
+
+/**
+ * A part built up z from the origin (a lathe, a cylinder) turned so its z axis runs from a towards b: a pole, a tilted
+ * mixer drum.
+ *
+ * @param {any} part The part.
+ * @param {readonly number[]} a Where its foot goes.
+ * @param {readonly number[]} b The way its z axis points.
+ * @returns {any} The part, aimed.
+ */
+export const aimed = (part, a, b) => {
+	const d = b.map((v, i) => v - a[i]), L = Math.hypot(...d), e3 = d.map((v) => v / L), h = Math.abs(e3[2]) < 0.9 ? [0, 0, 1] : [1, 0, 0];
+	const c = [e3[1] * h[2] - e3[2] * h[1], e3[2] * h[0] - e3[0] * h[2], e3[0] * h[1] - e3[1] * h[0]], n = Math.hypot(...c), e1 = c.map((v) => v / n), e2 = [e3[1] * e1[2] - e3[2] * e1[1], e3[2] * e1[0] - e3[0] * e1[2], e3[0] * e1[1] - e3[1] * e1[0]];
+	return turned(part, a, e1, e2, e3);
+};
+
+/**
+ * A round pole of radius r from a to b (a straw, a chopstick): a cylinder turned along a–b, its side one face.
+ *
+ * @param {readonly number[]} a One end.
+ * @param {readonly number[]} b The other.
+ * @param {number} r The radius.
+ * @returns {import('../parts/iso.js').Piece} The pole.
+ */
+export const pole = (a, b, r) => aimed(cyl(0, 0, r, 0, Math.hypot(...b.map((v, i) => v - a[i])), 32), a, b);
+
+/**
+ * Lies a lathe (built round the origin) along the horizontal unit vector u, its middle at c.
+ *
+ * @param {any} part The lathe.
+ * @param {readonly number[]} c Where its middle goes.
+ * @param {readonly number[]} u The way it lies (horizontal, unit).
+ * @param {number} len Its length.
+ * @returns {any} The part, lying.
+ */
+export const lying = (part, c, u, len) => turned(part, [c[0] - (u[0] * len) / 2, c[1] - (u[1] * len) / 2, c[2]], [0, 0, 1], [-u[1], u[0], 0], [u[0], u[1], 0]);
+
+/* ---------- helpers for flat() cut-outs ---------- */
+
+/**
+ * The gap in model units for parts plus flat() cut-outs (their depth counts towards the fit).
+ *
+ * @param {readonly any[]} parts The parts.
+ * @param {readonly import('./objects.js').Flat[]} flats The cut-outs.
+ * @param {number} g The gap on the canvas.
+ * @returns {number} The gap in model units.
+ */
+export const gapWith = (parts, flats, g) => gapIn([...parts, ...flats.flatMap((f) => f.outer.map((q) => loft(q.map((p) => p.map((c, i) => c + f.back[i])), q)))], g);
+
+/**
+ * A circle as 2D points (a, b), radius r, n sides.
+ *
+ * @param {number} a The centre's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} r The radius.
+ * @param {number} [n=48] Sides.
+ * @returns {import('../geometry/types.js').Point[]} n points.
+ */
+export const circ = (a, b, r, n = 48) => arcPts(a, b, r, r, 0, 360, n).slice(0, n);
+
+/**
+ * A quad along an arm from (cx, cy): angle d (degrees), from radius r0 to r1, w wide (centred on the arm), w1 wide at r1.
+ *
+ * @param {number} cx The centre's first coordinate.
+ * @param {number} cy Its second.
+ * @param {number} d The arm's angle (degrees).
+ * @param {number} r0 Where it starts.
+ * @param {number} r1 Where it ends.
+ * @param {number} w Its width at r0.
+ * @param {number} [w1=w] Its width at r1.
+ * @returns {import('../geometry/types.js').Point[]} The quad.
+ */
+export const arm = (cx, cy, d, r0, r1, w, w1 = w) => {
+	const t = (d * Math.PI) / 180, u = [Math.cos(t), Math.sin(t)], n = [-u[1], u[0]];
+	return [[cx + u[0] * r0 + (n[0] * w) / 2, cy + u[1] * r0 + (n[1] * w) / 2], [cx + u[0] * r1 + (n[0] * w1) / 2, cy + u[1] * r1 + (n[1] * w1) / 2],
+		[cx + u[0] * r1 - (n[0] * w1) / 2, cy + u[1] * r1 - (n[1] * w1) / 2], [cx + u[0] * r0 - (n[0] * w) / 2, cy + u[1] * r0 - (n[1] * w) / 2]];
+};
+
+/* ---------- 2D outlines for flat() cut-outs ---------- */
+
+/**
+ * 2D points turned deg (anticlockwise, b up) about (ca, cb).
+ *
+ * @param {readonly (readonly number[])[]} pts The points.
+ * @param {number} deg The turn.
+ * @param {readonly number[]} [c=[0, 0]] The centre.
+ * @returns {import('../geometry/types.js').Point[]} The turned points.
+ */
+export const rot = (pts, deg, [ca, cb] = [0, 0]) => { const t = (deg * Math.PI) / 180, c = Math.cos(t), s = Math.sin(t); return pts.map(([u, v]) => [ca + (u - ca) * c - (v - cb) * s, cb + (u - ca) * s + (v - cb) * c]); };
+
+/**
+ * An ellipse round (a, b), radii ra and rb, turned deg (2D points).
+ *
+ * @param {number} a The centre's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} ra The radius along a.
+ * @param {number} rb The radius along b.
+ * @param {number} [deg=0] The turn.
+ * @param {number} [n=48] Sides.
+ * @returns {import('../geometry/types.js').Point[]} n points.
+ */
+export const ell = (a, b, ra, rb, deg = 0, n = 48) => rot(arcPts(0, 0, ra, rb, 0, 360, n).slice(0, n), deg).map(([u, v]) => [a + u, b + v]);
+
+/** The facing plane's vertical foreshortening: a circle drawn with rb = r / SQ projects round. */
+export const SQ = Math.sqrt(2 / 3);
+
+/**
+ * A circle on the facing plane that projects round (2D points, for flat()).
+ *
+ * @param {number} a The centre's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} r The radius as it shows.
+ * @param {number} [n=48] Sides.
+ * @returns {import('../geometry/types.js').Point[]} n points.
+ */
+export const rnd = (a, b, r, n = 48) => ell(a, b, r, r / SQ, 0, n);
+
+/**
+ * A disc's outline (a full ellipse with ra = rb, 2D points).
+ *
+ * @param {number} a The centre's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} r The radius.
+ * @param {number} [n=48] Sides.
+ * @returns {import('../geometry/types.js').Point[]} n points.
+ */
+export const disc = (a, b, r, n = 48) => ell(a, b, r, r, 0, n);
+
+/**
+ * A rectangle a0–a1 × b0–b1 with its corners rounded by r (2D points).
+ *
+ * @param {number} a0 From, first coordinate.
+ * @param {number} b0 From, second.
+ * @param {number} a1 To, first coordinate.
+ * @param {number} b1 To, second.
+ * @param {number} r The corner radius.
+ * @param {number} [n=6] Steps a corner.
+ * @returns {import('../geometry/types.js').Point[]} The outline.
+ */
+export const rr = (a0, b0, a1, b1, r, n = 6) => [[a1 - r, b0 + r, -90], [a1 - r, b1 - r, 0], [a0 + r, b1 - r, 90], [a0 + r, b0 + r, 180]].flatMap(([a, b, d]) => arcPts(a, b, r, r, d, d + 90, n));
+
+/**
+ * An almond from p to q, w wide at its middle (a leaf, a blade; 2D points).
+ *
+ * @param {readonly number[]} p One tip.
+ * @param {readonly number[]} q The other.
+ * @param {number} w The width at the middle.
+ * @param {number} [n=14] Steps a side.
+ * @returns {import('../geometry/types.js').Point[]} The outline.
+ */
+export const lens = ([a0, b0], [a1, b1], w, n = 14) => {
+	const L = Math.hypot(a1 - a0, b1 - b0), u = [(a1 - a0) / L, (b1 - b0) / L], nn = [-u[1], u[0]];
+	const side = (s) => [...Array(n + 1)].map((_, i) => { const t = i / n, h = s * (w / 2) * Math.sin(Math.PI * t); return [a0 + u[0] * L * t + nn[0] * h, b0 + u[1] * L * t + nn[1] * h]; });
+	return [...side(1), ...side(-1).reverse().slice(1, -1)];
+};
+
+/**
+ * A slot of gap w wide along a polyline: one slot2() per segment.
+ *
+ * @param {readonly (readonly number[])[]} pts The polyline.
+ * @param {number} w The width.
+ * @returns {import('../geometry/types.js').Point[][]} The quads.
+ */
+export const path2 = (pts, w) => pts.slice(0, -1).map((p, i) => slot2(p, pts[i + 1], w));
+
+/**
+ * 2D outlines as cuts on the front face of a flat() t deep through o.
+ *
+ * @param {readonly number[]} o The flat's point on the plane.
+ * @param {number} t Its depth.
+ * @param {readonly (readonly (readonly number[])[])[]} list The outlines.
+ * @returns {import('../geometry/types.js').Point3[][]} The cuts, in 3D.
+ */
+export const flatCuts = (o, t, list) => list.map((q) => onFacing(o, q, t / 2));
+
+/**
+ * A roof feature made only of flat() cut-outs (back to front) and cuts on them, as the feat shopMark() takes: fn(o, k)
+ * returns { flats, cuts, keep }, o the roof's centre lifted a hair, k the gap in model units.
+ *
+ * @param {(o: number[], k: number) => { flats: import('./objects.js').Flat[], cuts?: any[], keep?: any[] }} fn The feature.
+ * @returns {(c: number[], W: number, D: number, H: number, k: number) => any[]} The feat for shopMark().
+ */
+export const roofFlats = (fn) => (c, W, D, H, k) => { const o = [c[0], c[1], c[2] + 0.04], { flats, cuts = [], keep = [] } = fn(o, k); return [[], cuts, keep, flats]; };
+
+/**
+ * A spiral slot w wide on a face: from radius r0 to r1 over `turns`, round (a, b), as 2D quads.
+ *
+ * @param {number} a The centre's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} r0 The starting radius.
+ * @param {number} r1 The end radius.
+ * @param {number} turns How many turns.
+ * @param {number} w The slot's width.
+ * @param {number} [n=80] Quads.
+ * @returns {import('../geometry/types.js').Point[][]} The quads.
+ */
+export const spiral = (a, b, r0, r1, turns, w, n = 80) => {
+	const P = (i) => { const t = i / n, ang = t * turns * 2 * Math.PI, r = r0 + (r1 - r0) * t; return [a + r * Math.cos(ang), b + r * Math.sin(ang)]; };
+	return [...Array(n)].map((_, i) => slot2(P(i), P(i + 1), w));
+};
+
+/**
+ * Pieces whose side faces merge into one surface (a band built from arcFront()/arcSide() quads): every face but the two
+ * end caps is tagged 'side'.
+ *
+ * @param {readonly import('../parts/iso.js').Piece[]} ps The pieces.
+ * @returns {import('../parts/iso.js').Piece[]} The pieces, retagged.
+ */
+export const smooth = (ps) => ps.map((q) => piece(q.faces.map((f) => f.pts), q.faces.map((f, i) => (i < 2 ? 0 : 'side'))));
+
+/**
+ * A flame (2D points, about its foot at (a, b), h tall, b up): a teardrop with a second tongue off its side. Not a
+ * curled flame.
+ *
+ * @param {number} a The foot's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} h The height.
+ * @returns {import('../geometry/types.js').Point[]} The outline.
+ */
+export const flame = (a, b, h) => {
+	const w = h * 0.36;
+	return [[a, b], ...arcPts(a, b + w, w, w, -90, 90, 10), [a + w * 0.25, b + h * 0.72], [a + w * 0.05, b + h * 0.55], [a - w * 0.1, b + h], [a - w * 0.85, b + h * 0.48], ...arcPts(a, b + w, w, w, 180, 270, 6)];
+};
+
+/* ---------- 2D stroke and band helpers for flat() cut-outs ---------- */
+
+/**
+ * A thick stroke along a 2D polyline, w wide: a quad per segment and a disc at every joint (all convex, for flat()).
+ *
+ * @param {readonly (readonly number[])[]} pts The polyline.
+ * @param {number} w The width.
+ * @returns {import('../geometry/types.js').Point[][]} The convex pieces.
+ */
+export const stroke = (pts, w) => [...pts.slice(0, -1).map((p, i) => slot2(p, pts[i + 1], w)), ...pts.map(([a, b]) => circ(a, b, w / 2, 16))];
+
+/**
+ * A band of an annulus (2D) round (a, b), radii r0–r1, from d0 to d1 degrees, as convex quads (a handle, a hook).
+ *
+ * @param {number} a The centre's first coordinate.
+ * @param {number} b Its second.
+ * @param {number} r0 The inner radius.
+ * @param {number} r1 The outer radius.
+ * @param {number} d0 From (degrees).
+ * @param {number} d1 To.
+ * @param {number} [n=16] Quads.
+ * @returns {import('../geometry/types.js').Point[][]} The quads.
+ */
+export const band = (a, b, r0, r1, d0, d1, n = 16) => [...Array(n)].map((_, i) => {
+	const t0 = ((d0 + ((d1 - d0) * i) / n) * Math.PI) / 180, t1 = ((d0 + ((d1 - d0) * (i + 1)) / n) * Math.PI) / 180;
+	const P = (r, t) => [a + r * Math.cos(t), b + r * Math.sin(t)];
+	return [P(r0, t0), P(r1, t0), P(r1, t1), P(r0, t1)];
+});
+
+/**
+ * 2D points moved by (da, db).
+ *
+ * @param {readonly (readonly number[])[]} pts The points.
+ * @param {number} da Along the first coordinate.
+ * @param {number} db Along the second.
+ * @returns {import('../geometry/types.js').Point[]} The moved points.
+ */
+export const mv = (pts, da, db) => pts.map(([a, b]) => [a + da, b + db]);
+
+/**
+ * A rectangle a0–a1 × b0–b1 (2D points; the geometry kit's rect() is a polygon from a corner and a size).
+ *
+ * @param {number} a0 From, first coordinate.
+ * @param {number} b0 From, second.
+ * @param {number} a1 To, first coordinate.
+ * @param {number} b1 To, second.
+ * @returns {import('../geometry/types.js').Point[]} Its four corners.
+ */
+export const rect = (a0, b0, a1, b1) => [[a0, b0], [a1, b0], [a1, b1], [a0, b1]];
+
+/**
+ * A kit glyph h tall on a plane o + a·u + b·v (centred on o, upright along v), its strokes T of 400 thick: its outlines
+ * to cut and its counters to keep.
+ *
+ * @param {string} k The glyph (the parts' glyph() key).
+ * @param {readonly number[]} o The plane's origin (the glyph's centre).
+ * @param {readonly number[]} u The plane's first axis.
+ * @param {readonly number[]} v Its second (up the glyph).
+ * @param {number} h The glyph's height.
+ * @param {number} [T=96] Its stroke, of 400.
+ * @returns {{ cut: import('../geometry/types.js').Point3[][], keep: import('../geometry/types.js').Point3[][] }} The
+ *   outlines to cut and the counters to put back.
+ */
+export const glyphOn = (k, o, u, v, h, T = 96) => {
+	const s = glyph(k, 400, T), ys = s.flat(2).map((p) => p[1]), sc = h / (Math.max(...ys) - Math.min(...ys));
+	const to = (ring) => onPlane(o, u, v, ring.map(([x, y]) => [x * sc, -y * sc]));
+	return { cut: s.map((pg) => to(pg[0])), keep: s.flatMap((pg) => pg.slice(1).map(to)) };
+};
+
+/* ---------- tipped slabs ---------- */
+
+/**
+ * A 3D point p moved by k times the vector v.
+ *
+ * @param {readonly number[]} p The point.
+ * @param {readonly number[]} v The vector.
+ * @param {number} [k=1] How many times.
+ * @returns {number[]} The moved point.
+ */
+export const add3 = (p, v, k = 1) => p.map((c, i) => c + v[i] * k);
+
+/**
+ * A ring of gap round the 3D outline q, measured on the canvas (an inset in model units on a tipped or sloped face
+ * projects wider one way than the other): cuts q from the drawn mark s and puts back its inside g in.
+ *
+ * @param {readonly any[]} parts The parts s was drawn from (for the projection).
+ * @param {import('../geometry/types.js').Shape} s The drawn mark.
+ * @param {readonly (readonly number[])[]} q The 3D outline.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The mark with the ring cut.
+ */
+export const ringIn = (parts, s, q, g) => { const P = fitOf(parts), h = poly(q.map((p) => P(...p))); return U(D(s, h), I(s, grow(h, -g))); };
+
+/**
+ * Keys tiling the 3D outline `area`, cut as islands with the gap between them measured on the canvas.
+ *
+ * @param {readonly any[]} parts The parts s was drawn from.
+ * @param {import('../geometry/types.js').Shape} s The drawn mark.
+ * @param {readonly (readonly number[])[]} area The keypad's 3D outline.
+ * @param {readonly (readonly (readonly number[])[])[]} keys Each key's 3D outline.
+ * @param {number} g The gap.
+ * @returns {import('../geometry/types.js').Shape} The mark with the keys cut.
+ */
+export const keysIn = (parts, s, area, keys, g) => {
+	const P = fitOf(parts), pr = (q) => poly(q.map((p) => P(...p))), A = pr(area), inner = grow(A, -g);
+	return U(D(s, A), ...keys.map((q) => I(s, grow(pr(q), -g / 2), inner)));
+};
+
+/**
+ * A slab tipped back by `deg` from upright, its foot edge's middle at o. `dir` 'y': its width runs along −y (up and
+ * right on the canvas) and it tips back towards −x; 'x': its width runs along +x (down and right) and it tips back
+ * towards −y. At 90° it lies flat. `outline` is a 2D (a, b) shape on its face (a across, b up the face), `t` its
+ * thickness behind the face; `smooth` merges its edge band into one face.
+ *
+ * @param {readonly number[]} o The foot edge's middle.
+ * @param {number} deg How far it tips back.
+ * @param {readonly (readonly number[])[]} outline The face's outline (2D).
+ * @param {number} t The thickness.
+ * @param {{ dir?: 'x' | 'y', smooth?: boolean }} [o] The way its width runs ('y') and whether its edge merges (true).
+ * @returns {{ part: import('../parts/iso.js').Piece, on: (pts: readonly (readonly number[])[]) => number[][], n: import('../geometry/types.js').Point3 }}
+ *   The slab, a function putting 2D outlines on its face, and the face's normal.
+ */
+export const slab = (o, deg, outline, t, { dir = 'y', smooth = true } = {}) => {
+	const r = (deg * Math.PI) / 180, s = Math.sin(r), c = Math.cos(r);
+	const u = dir === 'y' ? [0, -1, 0] : [1, 0, 0], v = dir === 'y' ? [-s, 0, c] : [0, -s, c], n = cross3(v, u);
+	const on = (pts) => pts.map(([a, b]) => [0, 1, 2].map((i) => o[i] + a * u[i] + b * v[i])), face = on(outline);
+	return { part: loft(face.map((p) => add3(p, n, -t)), face, smooth), on, n };
+};