@logomarks/core 0.1.9 → 0.2.0

package/src/letters/mono.js

@@ -0,0 +1,684 @@
+/**
+ * Monogram letters: the letter-building geometry the monogram pairs are drawn with, so each pair draws with one build of
+ * each letter instead of a copy. Four styles:
+ * - Fused: solid letters, stems W (84), cap 360 (y T0 76 to T1 436), square ends;
+ * - Track: centrelines drawn as two tracks (26 wide, 48 apart) with filleted corners, on a cap TH (360) from y 0;
+ * - Badge: monoline letters (BT 52 wide, cap BH 212 before the knockout's fit) knocked out of a house badge;
+ * - Fan: two Fan letters on one grid of square and quarter-disc tiles (Modular).
+ * Also Puff (balloon strokes), Linked (woven bands) and `clean()`, which tidies a finished shape for writing.
+ * From the Logomarks tools (monoletters.mjs, batches 99 and 102–104).
+ */
+import { C, GAP as G, U, D, I, circle, annulus, rect, bar, poly, sector, arcBand, weave, balloon, sample, stroke, dedupe, fillet, tracks, knockout, linePts, arcPts, joinPts } from '../geometry/index.js';
+
+/** @typedef {import('../geometry/types.js').Point} Point */
+/** @typedef {import('../geometry/types.js').Polygon} Polygon */
+/** @typedef {import('../geometry/types.js').Shape} Shape */
+
+/* ---------- Fused: solid letters, stems 84, cap 360 (y 76–436) ---------- */
+
+/** The Fused stem width: 84. */
+export const W = 84;
+
+/** The Fused cap line: y 76. */
+export const T0 = 76;
+
+/** The Fused baseline: y 436. */
+export const T1 = 436;
+
+/** Halfway between the cap line and the baseline: y 256. */
+export const MID = (T0 + T1) / 2;
+
+/**
+ * A Fused stem.
+ *
+ * @param {number} x Its left edge.
+ * @param {number} [y0] Its top (T0).
+ * @param {number} [y1] Its foot (T1).
+ * @returns {Polygon} The stem.
+ */
+export const stem = (x, y0 = T0, y1 = T1) => rect(x, y0, W, y1 - y0);
+
+/**
+ * A Fused bar.
+ *
+ * @param {number} x0 Its left end.
+ * @param {number} x1 Its right end.
+ * @param {number} y Its top edge.
+ * @returns {Polygon} The bar.
+ */
+export const hbar = (x0, x1, y) => rect(x0, y, x1 - x0, W);
+
+/**
+ * Clips a shape flat at the cap and base lines.
+ *
+ * @param {import('../geometry/types.js').Geom} g The shape.
+ * @param {number} [y0] The top line (T0).
+ * @param {number} [y1] The bottom line (T1).
+ * @returns {Shape} It, clipped.
+ */
+export const clipH = (g, y0 = T0, y1 = T1) => I(g, rect(-400, y0, 1400, y1 - y0));
+
+/**
+ * A D-shaped bowl to the right of a stem.
+ *
+ * @param {number} x The stem's left edge.
+ * @param {number} y0 The bowl's top.
+ * @param {number} y1 Its foot.
+ * @param {number} [reach=60] How far its straight runs reach past the stem before the curve.
+ * @returns {Shape} The bowl (the stem's height between y0 and y1 included).
+ */
+export const bowl = (x, y0, y1, reach = 60) => {
+	const h = y1 - y0, r = h / 2;
+	return D(U(rect(x, y0, W + reach, h), circle(x + W + reach, y0 + r, r)), U(rect(x + W, y0 + W, reach, h - 2 * W), circle(x + W + reach, y0 + r, r - W)));
+};
+
+/* ---------- centreline helpers (Track, Badge, Puff) ---------- */
+
+/**
+ * A straight run of points, about one every 8 units.
+ *
+ * @param {readonly number[]} a From.
+ * @param {readonly number[]} b To.
+ * @param {number} [n] The number of points (by the length, by default).
+ * @returns {Point[]} The run.
+ */
+export const L_ = (a, b, n) => linePts(a, b, n || Math.max(2, Math.ceil(Math.hypot(b[0] - a[0], b[1] - a[1]) / 8)));
+
+/**
+ * A circular arc's points, about one every 3°.
+ *
+ * @param {number} cx The centre's x.
+ * @param {number} cy The centre's y.
+ * @param {number} r The radius.
+ * @param {number} a0 The start angle (degrees, 0 = right, 90 = down).
+ * @param {number} a1 The end angle.
+ * @returns {Point[]} The arc.
+ */
+export const A_ = (cx, cy, r, a0, a1) => arcPts(cx, cy, r, a0, a1, Math.max(12, Math.ceil(Math.abs(a1 - a0) / 3)));
+
+/**
+ * Joins runs end to start (each run's first point dropped after the first).
+ *
+ * @param {...Point[]} p The runs.
+ * @returns {Point[]} One run.
+ */
+export const J_ = (...p) => joinPts(...p);
+
+/**
+ * Drops the in-between points of straight runs, so fillet() sees each corner between two long legs.
+ *
+ * @param {readonly Point[]} p The polyline.
+ * @returns {Point[]} Its corners and ends.
+ */
+export const straighten = (p) => p.filter((pt, i) => {
+	if (!i || i === p.length - 1) return true;
+	const a = p[i - 1], b = p[i + 1];
+	const t1 = Math.atan2(pt[1] - a[1], pt[0] - a[0]), t2 = Math.atan2(b[1] - pt[1], b[0] - pt[0]);
+	let d = Math.abs(t2 - t1);
+	if (d > Math.PI) d = 2 * Math.PI - d;
+	return d > 0.017;
+});
+
+/**
+ * Trims a polyline by d from its start, or its end.
+ *
+ * @param {readonly Point[]} p The polyline.
+ * @param {number} d How much to trim.
+ * @param {boolean} [atEnd] Trim the end instead.
+ * @returns {Point[]} The trimmed polyline.
+ */
+export const trim = (p, d, atEnd) => {
+	const q = atEnd ? p.slice().reverse() : p.slice();
+	let left = d;
+	while (q.length > 2) { const L = Math.hypot(q[1][0] - q[0][0], q[1][1] - q[0][1]); if (L > left) { const t = left / L; q[0] = [q[0][0] + (q[1][0] - q[0][0]) * t, q[0][1] + (q[1][1] - q[0][1]) * t]; break; } left -= L; q.shift(); }
+	return atEnd ? q.reverse() : q;
+};
+
+/** The two tracks' width (the Duo rule): 26. */
+export const TW = 26;
+
+/** The two tracks' pitch: 48, so a 74 band with a 22 gap between the tracks. */
+export const PITCH = 48;
+
+/**
+ * Two tracks along a centreline whose sharp corners are filleted.
+ *
+ * @param {readonly Point[]} pts The centreline.
+ * @param {number | number[]} [r=60] The fillet (or one per corner).
+ * @param {object} [o] More tracks() options.
+ * @returns {Shape} The tracks.
+ */
+export const track2 = (pts, r = 60, o = {}) => tracks(dedupe(fillet(straighten(pts), r)), { n: 2, pitch: PITCH, w: TW, ...o });
+
+/**
+ * Three tracks (22 wide, 44 apart) along a filleted centreline.
+ *
+ * @param {readonly Point[]} pts The centreline.
+ * @param {number | number[]} [r=70] The fillet (or one per corner).
+ * @returns {Shape} The tracks.
+ */
+export const track3 = (pts, r = 70) => tracks(dedupe(fillet(straighten(pts), r)), { n: 3, pitch: 44, w: 22 });
+
+/**
+ * A monoline stroke with square ends.
+ *
+ * @param {readonly Point[]} pts The centreline.
+ * @param {number} w The width.
+ * @returns {Shape} The stroke.
+ */
+export const mline = (pts, w) => stroke(dedupe(pts), w, { chunk: 8 });
+
+/**
+ * An ellipse arc's points, about one every 3°.
+ *
+ * @param {number} cx The centre's x.
+ * @param {number} cy The centre's y.
+ * @param {number} rx The x radius.
+ * @param {number} ry The y radius.
+ * @param {number} a0 The start angle (degrees, 0 = right, 90 = down).
+ * @param {number} a1 The end angle.
+ * @returns {Point[]} The arc.
+ */
+export const E_ = (cx, cy, rx, ry, a0, a1) => sample((t) => [cx + rx * Math.cos((t * Math.PI) / 180), cy + ry * Math.sin((t * Math.PI) / 180)], a0, a1, Math.max(16, Math.ceil(Math.abs(a1 - a0) / 3)));
+
+/**
+ * The top ring of a Fused S's centreline (cap 360): from a0 back round to the spine.
+ *
+ * @param {number} sx The S's centre x.
+ * @param {number} rx The ring's x radius.
+ * @param {number} [a0=-25] Where the terminal starts (degrees).
+ * @param {number} [ry] The ring's y radius (a quarter of the cap less a stem).
+ * @returns {Point[]} The centreline.
+ */
+export const sTop = (sx, rx, a0 = -25, ry = (T1 - T0 - W) / 4) => E_(sx, T0 + W / 2 + ry, rx, ry, a0, -270);
+
+/**
+ * The lower ring of a Fused S's centreline: from the spine to a1.
+ *
+ * @param {number} sx The S's centre x.
+ * @param {number} rx The ring's x radius.
+ * @param {number} [a1=160] Where the terminal ends (degrees).
+ * @param {number} [ry] The ring's y radius.
+ * @returns {Point[]} The centreline.
+ */
+export const sLow = (sx, rx, a1 = 160, ry = (T1 - T0 - W) / 4) => E_(sx, T1 - W / 2 - ry, rx, ry, -90, a1);
+
+/**
+ * A centreline stroked solid (square ends).
+ *
+ * @param {readonly Point[]} pts The centreline.
+ * @param {number} [w] The width (W).
+ * @returns {Shape} The stroke.
+ */
+export const solid = (pts, w = W) => stroke(dedupe(pts), w, { chunk: 8 });
+
+/* ---------- solid letters ---------- */
+
+/**
+ * A Fused A's two legs (stroke 96, like the set's A's), clipped to the cap.
+ *
+ * @param {number} ax The apex's x.
+ * @param {number} w How far the feet spread.
+ * @returns {Shape} The legs.
+ */
+export const aLegs = (ax, w) => clipH(U(bar([ax - w / 2 - 30, T1 + 60], [ax, T0 - 40], 96), bar([ax, T0 - 40], [ax + w / 2 + 30, T1 + 60], 96)));
+
+/**
+ * A Fused M: two stems and a V whose bars meet at (mid, v); the notch their square ends leave is filled, so the V ends in
+ * one clean point.
+ *
+ * @param {number} x The left stem's left edge.
+ * @param {number} xr The right stem's left edge.
+ * @param {number} [v=340] The V's point's height.
+ * @returns {Shape} The M.
+ */
+export const mLetter = (x, xr, v = 340) => {
+	const V = [(x + xr) / 2 + 42, v], ends = [[x + 42, 30], [xr + 42, 30]].flatMap(([px, py]) => { const L = Math.hypot(V[0] - px, V[1] - py), n = [-(V[1] - py) / L * 48, (V[0] - px) / L * 48]; return [[V[0] + n[0], V[1] + n[1]], [V[0] - n[0], V[1] - n[1]]]; });
+	const hull = ends.sort((a, b) => Math.atan2(a[1] - V[1], a[0] - V[0]) - Math.atan2(b[1] - V[1], b[0] - V[0]));
+	return U(stem(x), stem(xr), clipH(U(bar([x + 42, 30], V, 96), bar([xr + 42, 30], V, 96), poly(hull))));
+};
+
+/**
+ * A Fused A's crossbar, kept inside the legs.
+ *
+ * @param {number} ax The apex's x.
+ * @param {number} aw How far the feet spread (as aLegs()).
+ * @param {number} y The bar's top edge.
+ * @returns {Shape} The bar.
+ */
+export const aBar = (ax, aw, y) => I(hbar(ax - 300, ax + 300, y), U(aLegs(ax, aw), poly([[ax, T0 - 40], [ax - aw / 2 - 30, T1 + 60], [ax + aw / 2 + 30, T1 + 60]])));
+
+/* ---------- Badge: monoline letters (52), knocked out of a house badge ---------- */
+
+/** The Badge letters' monoline width: 52. */
+export const BT = 52;
+
+/** The Badge letters' centreline cap height: 212. */
+export const BH = 212;
+
+/**
+ * A Badge J's centreline: a stem at x, hooking to the left.
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} [r=50] The hook's radius.
+ * @param {number} [H] The cap height (BH).
+ * @returns {Point[]} The centreline.
+ */
+export const bJ = (x, r = 50, H = BH) => J_(L_([x, -BT], [x, H - r]), A_(x - r, H - r, r, 0, 180), L_([x - 2 * r, H - r], [x - 2 * r, H - r - 24]));
+
+/**
+ * A Badge bowl's centreline off a stem: out along y0, round, and back along y1.
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} y0 The bowl's top.
+ * @param {number} y1 Its foot.
+ * @param {number} w How far it reaches.
+ * @returns {Point[]} The centreline.
+ */
+export const bBowl = (x, y0, y1, w) => { const r = (y1 - y0) / 2; return J_(L_([x, y0], [x + w - r, y0]), A_(x + w - r, y0 + r, r, -90, 90), L_([x + w - r, y1], [x, y1])); };
+
+/**
+ * A Badge B's centrelines: the stem and two bowls.
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} [w=128] The lower bowl's reach (the upper reaches 12 less).
+ * @param {number} [H] The cap height (BH).
+ * @param {number} [k=0.48] Where the bowls meet, as a share of the cap.
+ * @returns {Point[][]} The strokes.
+ */
+export const bB = (x, w = 128, H = BH, k = 0.48) => [L_([x, -BT], [x, H + BT]), bBowl(x, 0, H * k, w - 12), bBowl(x, H * k, H, w)];
+
+/**
+ * A Badge M's centreline: up, down to the V, up, down.
+ *
+ * @param {number} x The left stem's centreline.
+ * @param {number} [w=190] The width.
+ * @param {number} [H] The cap height (BH).
+ * @param {number} [v=0.72] The V's depth, as a share of the cap.
+ * @returns {Point[][]} The stroke.
+ */
+export const bM = (x, w = 190, H = BH, v = 0.72) => [J_(L_([x, H + BT], [x, 0]), L_([x, 0], [x + w / 2, H * v]), L_([x + w / 2, H * v], [x + w, 0]), L_([x + w, 0], [x + w, H + BT]))];
+
+/**
+ * A Badge H's centrelines.
+ *
+ * @param {number} x The left stem's centreline.
+ * @param {number} [w=150] The width.
+ * @param {number} [H] The cap height (BH).
+ * @returns {Point[][]} The strokes.
+ */
+export const bH = (x, w = 150, H = BH) => [L_([x, -BT], [x, H + BT]), L_([x + w, -BT], [x + w, H + BT]), L_([x, H / 2], [x + w, H / 2])];
+
+/**
+ * A Badge S's centreline: two rings on a quarter of the cap each.
+ *
+ * @param {number} sx The S's centre x.
+ * @param {number} [rx=64] The rings' x radius.
+ * @param {number} [a0=-25] Where the top terminal starts (degrees).
+ * @param {number} [a1=160] Where the bottom terminal ends.
+ * @param {number} [H] The cap height (BH).
+ * @returns {Point[][]} The stroke.
+ */
+export const bS = (sx, rx = 64, a0 = -25, a1 = 160, H = BH) => { const ry = H / 4; return [J_(E_(sx, ry, rx, ry, a0, -270), E_(sx, 3 * ry, rx, ry, -90, a1))]; };
+
+/**
+ * A Badge C's centreline.
+ *
+ * @param {number} cx The centre's x.
+ * @param {number} [r] The radius (half the cap).
+ * @param {number} [a0=42] Where it starts (degrees).
+ * @param {number} [a1=318] Where it ends.
+ * @returns {Point[][]} The stroke.
+ */
+export const bC = (cx, r = BH / 2, a0 = 42, a1 = 318) => [A_(cx, BH / 2, r, a0, a1)];
+
+/**
+ * A Badge P's centrelines.
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} [w=130] The bowl's reach.
+ * @param {number} [H] The cap height (BH).
+ * @returns {Point[][]} The strokes.
+ */
+export const bP = (x, w = 130, H = BH) => [L_([x, -BT], [x, H + BT]), bBowl(x, 0, H * 0.56, w)];
+
+/**
+ * A Badge R's centrelines: stem, bowl and leg.
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} [w=136] The width (the bowl reaches 6 less).
+ * @param {number} [H] The cap height (BH).
+ * @returns {Point[][]} The strokes.
+ */
+export const bR = (x, w = 136, H = BH) => [L_([x, -BT], [x, H + BT]), bBowl(x, 0, H * 0.54, w - 6), L_([x + w * 0.42, H * 0.54], [x + w + 30, H + 60])];
+
+/**
+ * A Badge A's centrelines: the legs and the bar.
+ *
+ * @param {number} ax The apex's x.
+ * @param {number} [w=200] The width.
+ * @param {number} [H] The cap height (BH).
+ * @param {number} [bar=0.66] The bar's height, as a share of the cap.
+ * @returns {Point[][]} The strokes.
+ */
+export const bA = (ax, w = 200, H = BH, bar = 0.66) => [J_(L_([ax - w / 2 - 40, H + 90], [ax, 0]), L_([ax, 0], [ax + w / 2 + 40, H + 90])), L_([ax - w * 0.3, H * bar], [ax + w * 0.3, H * bar])];
+
+/**
+ * A Badge D's centreline.
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} [w=160] The bowl's reach.
+ * @param {number} [H] The cap height (BH).
+ * @returns {Point[][]} The stroke.
+ */
+export const bD = (x, w = 160, H = BH) => [J_(L_([x, H / 2], [x, -0]), bBowl(x, 0, H, w), L_([x, H], [x, H / 2]))];
+
+/**
+ * The top-bar ligature as a monoline: a bar from the J's left across to x1, the J's stem at jx with its hook.
+ *
+ * @param {number} jx The J's stem's centreline.
+ * @param {number} x1 Where the bar ends.
+ * @param {number} [r=46] The hook's radius.
+ * @returns {Point[][]} The strokes.
+ */
+export const bJbar = (jx, x1, r = 46) => [L_([jx - 2 * r - 20, 0], [x1, 0]), J_(L_([jx, 0], [jx, BH - r]), A_(jx - r, BH - r, r, 0, 180), L_([jx - 2 * r, BH - r], [jx - 2 * r, BH - r - 24]))];
+
+/**
+ * Strokes (point lists) as one monoline, square ends, clipped flat at the cap and base lines.
+ *
+ * @param {readonly (readonly Point[])[]} parts The centrelines.
+ * @param {number} [T] The width (BT).
+ * @param {number} [H] The cap height (BH).
+ * @returns {Shape} The monoline.
+ */
+export const mono = (parts, T = BT, H = BH) => I(U(...parts.map((p) => mline(p, T))), rect(-800, -T / 2, 2000, H + T));
+
+/**
+ * The pair as a monoline knocked out of a house badge.
+ *
+ * @param {import('../geometry/badges.js').BadgeKind} kind The badge.
+ * @param {readonly (readonly Point[])[]} parts The centrelines.
+ * @returns {Shape} The badge.
+ */
+export const badge = (kind, parts) => knockout(kind, mono(parts));
+
+/* ---------- Modular: Fan tiles (a square, a quarter disc centred on one corner, or empty) ---------- */
+
+/** The Fan cell: 140. */
+export const FC = 140;
+
+/** The Fan gutter: 26. */
+export const FG = 26;
+
+/**
+ * A grid of Fan tiles, centred on the canvas.
+ *
+ * @param {readonly (readonly string[])[]} rows The tiles, row by row: 'S' a square, '.' empty, 'tl', 'tr', 'bl' or 'br'
+ *   a quarter disc centred on that corner of the cell.
+ * @returns {Shape} The grid.
+ */
+export const fan = (rows) => {
+	const out = [], h = rows.length, w = rows[0].length, x0 = C - (w * FC) / 2, y0 = C - (h * FC) / 2;
+	rows.forEach((row, r) => row.forEach((c, k) => {
+		if (c === '.') return;
+		const x = x0 + k * FC + FG / 2, y = y0 + r * FC + FG / 2, s = FC - FG;
+		if (c === 'S') { out.push(rect(x, y, s, s)); return; }
+		const cx = c[1] === 'l' ? x : x + s, cy = c[0] === 't' ? y : y + s;
+		out.push(I(circle(cx, cy, s, 160), rect(x, y, s, s)));
+	}));
+	return U(...out);
+};
+
+/* ---------- more solid letters ---------- */
+
+/**
+ * A Fused C opening off a stem: monoBowl() with its right side cut away by a wedge (half-angle a), so the terminals are
+ * radial.
+ *
+ * @param {number} x The stem's left edge.
+ * @param {number} [reach=0] The bowl's straight runs past the stem.
+ * @param {number} [a=42] The opening's half-angle (degrees).
+ * @param {number} [y0] The top (T0).
+ * @param {number} [y1] The foot (T1).
+ * @returns {Shape} The C.
+ */
+export const cStem = (x, reach = 0, a = 42, y0 = T0, y1 = T1) => { const r = (y1 - y0) / 2; return D(monoBowl(x, y0, y1, reach), sector(x + W + reach, y0 + r, 600, -a, a)); };
+
+/**
+ * bowl() kept to the right of its stem's left edge: a bowl taller than twice its reach plus the stem would otherwise
+ * bulge out left.
+ *
+ * @param {number} x The stem's left edge.
+ * @param {number} y0 The bowl's top.
+ * @param {number} y1 Its foot.
+ * @param {number} [reach=0] Its straight runs past the stem.
+ * @returns {Shape} The bowl.
+ */
+export const monoBowl = (x, y0, y1, reach = 0) => I(bowl(x, y0, y1, reach), rect(x, y0 - 10, 2000, y1 - y0 + 20));
+
+/**
+ * A Fused A whose right leg stands upright as a stem. Its crossbar: I(hbar(…), rightOf(...aUpLeg(sx))).
+ *
+ * @param {number} sx The stem's left edge.
+ * @returns {Shape} The A.
+ */
+export const aUp = (sx) => clipH(U(bar(...aUpLeg(sx), 96), stem(sx, T0 - 100, T1)));
+
+/**
+ * The half-plane right of the line from a to b (y down): clips an A's crossbar to its inside.
+ *
+ * @param {readonly number[]} a A point on the line.
+ * @param {readonly number[]} b Another.
+ * @returns {Polygon} The half-plane, as a big quad.
+ */
+export const rightOf = (a, b) => { const dx = b[0] - a[0], dy = b[1] - a[1], k = 3000 / Math.hypot(dx, dy); return poly([[a[0] - dx * k, a[1] - dy * k], [b[0] + dx * k, b[1] + dy * k], [3000, b[1] + dy * k], [3000, a[1] - dy * k]]); };
+
+/**
+ * The left leg's centreline of aUp(sx), foot to apex, landing on the stem's left edge so the counter stays open.
+ *
+ * @param {number} sx The stem's left edge.
+ * @returns {[Point, Point]} The foot and the apex.
+ */
+export const aUpLeg = (sx) => [[sx - 180, T1 + 34], [sx - 10, T0 - 36]];
+
+/**
+ * A Fused J's hook: an arc band curling left off a stem.
+ *
+ * @param {number} jx The stem's left edge.
+ * @returns {Shape} The hook.
+ */
+export const jHook = (jx) => arcBand(jx - 58, T1 - 100 - W / 2, 100, W, 0, 180);
+
+/* ---------- Track letters: centrelines at cap TH (y 0 to TH), as two tracks ---------- */
+
+/** The Track cap height: 360. */
+export const TH = 360;
+
+/** The Track S's ring radius: a quarter of the cap. */
+export const TR = TH / 4;
+
+/** Half a two-track band: 37 (a track stopping short of another clears it by this plus the gap). */
+export const TB2 = 37;
+
+/** How far a track's round end reaches past its centreline: 13. */
+export const TCAP = 13;
+
+/**
+ * A Track S entered from the left along the base: the lower ring up its right side to the spine, the upper ring round to
+ * its top terminal.
+ *
+ * @param {number} sx The S's centre x.
+ * @param {number} [r] The rings' radius (TR).
+ * @param {number} [end=325] Where the top terminal ends (degrees).
+ * @returns {Point[]} The centreline.
+ */
+export const sFromBase = (sx, r = TR, end = 325) => J_(A_(sx, 3 * r, r, 90, -90), A_(sx, r, r, 90, end));
+
+/**
+ * A Track S from its bottom terminal up to its top point, leaving to the right along the cap line.
+ *
+ * @param {number} sx The S's centre x.
+ * @param {number} [r] The rings' radius (TR).
+ * @param {number} [start=145] Where the bottom terminal starts (degrees).
+ * @returns {Point[]} The centreline.
+ */
+export const sToTop = (sx, r = TR, start = 145) => J_(A_(sx, 3 * r, r, start, -90), A_(sx, r, r, 90, 270));
+
+/**
+ * A Track M from its first stem's foot to its last stem's foot.
+ *
+ * @param {number} x The first stem's centreline.
+ * @param {number} [w=270] The width.
+ * @param {number} [v=0.62] Where the V meets, as a share of the cap.
+ * @returns {Point[]} The centreline.
+ */
+export const tM = (x, w = 270, v = 0.62) => J_(L_([x, TH], [x, 0]), L_([x, 0], [x + w / 2, TH * v]), L_([x + w / 2, TH * v], [x + w, 0]), L_([x + w, 0], [x + w, TH]));
+
+/**
+ * A Track R's stem and bowl from the stem's foot: the bowl comes back a gap short of the stem.
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} [bw=230] The bowl's width.
+ * @param {number} [bh=190] Its height.
+ * @returns {Point[]} The centreline.
+ */
+export const tRbowl = (x, bw = 230, bh = 190) => J_(L_([x, TH], [x, 0]), L_([x, 0], [x + bw - bh / 2, 0]), A_(x + bw - bh / 2, bh / 2, bh / 2, -90, 90), L_([x + bw - bh / 2, bh], [x + 72 + G + 4, bh]));
+
+/**
+ * A Track R's leg, standing free a gap below the bowl, down to the base line.
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} [kx=120] Where the leg starts, from the stem.
+ * @param {number} [lx=250] Where it lands, from the stem.
+ * @param {number} [bh=190] The bowl's height.
+ * @returns {Point[]} The centreline.
+ */
+export const tRleg = (x, kx = 120, lx = 250, bh = 190) => L_([x + kx, bh + 74 + G], [x + lx, TH]);
+
+/**
+ * A Track house A: upright legs, a peaked roof from the shoulders to the apex, from its left foot to its right foot.
+ *
+ * @param {number} x The left leg's centreline.
+ * @param {number} [aw=280] The width.
+ * @param {number} [k=130] How far down the shoulders sit.
+ * @returns {Point[]} The centreline.
+ */
+export const tA = (x, aw = 280, k = 130) => J_(L_([x, TH], [x, k]), L_([x, k], [x + aw / 2, 0]), L_([x + aw / 2, 0], [x + aw, k]), L_([x + aw, k], [x + aw, TH]));
+
+/**
+ * The house A's bar, stopping a gap short of both legs (round ends showing).
+ *
+ * @param {number} x The left leg's centreline.
+ * @param {number} [aw=280] The width.
+ * @param {number} [y=228] The bar's height.
+ * @returns {Point[]} The centreline.
+ */
+export const tAbar = (x, aw = 280, y = 228) => L_([x + TB2 + G + TCAP, y], [x + aw - TB2 - G - TCAP, y]);
+
+/**
+ * A Track J's hook and stem, from the hook's tip up to the stem's top at (x, 0).
+ *
+ * @param {number} x The stem's centreline.
+ * @param {number} [rj=76] The hook's radius.
+ * @returns {Point[]} The centreline.
+ */
+export const tJ = (x, rj = 76) => J_(L_([x - 2 * rj, TH - rj - 40], [x - 2 * rj, TH - rj]), A_(x - rj, TH - rj, rj, 180, 0), L_([x, TH - rj], [x, 0]));
+
+/* ---------- lowercase (x-height 176 on the 360 cap) ---------- */
+
+/** The lowercase x-height: 176. */
+export const XH = 176;
+
+/**
+ * A Fused n-arch standing from the x-height to the base.
+ *
+ * @param {number} xl The left stem's left edge.
+ * @param {number} [rA=74] The arch's centreline radius.
+ * @param {number} [xh] The x-height (XH).
+ * @param {boolean} [both=true] Draw the left stem too.
+ * @returns {Shape} The arch.
+ */
+export const arch = (xl, rA = 74, xh = XH, both = true) => U(arcBand(xl + W / 2 + rA, xh + W / 2 + rA, rA, W, 180, 360), ...(both ? [rect(xl, xh + W / 2 + rA, W, T1 - xh - W / 2 - rA)] : []), rect(xl + 2 * rA, xh + W / 2 + rA, W, T1 - xh - W / 2 - rA));
+
+/**
+ * A Fused lowercase e: a ring band W wide, the bar across its middle, the ring open at its lower right.
+ *
+ * @param {number} cx The centre's x.
+ * @param {number} cy The centre's y.
+ * @param {number} r The radius to the band's centre.
+ * @param {number[]} [open] The opening's angles (degrees, [8, 42]).
+ * @returns {Shape} The e.
+ */
+export const eLow = (cx, cy, r, open = [8, 42]) => U(D(annulus(cx, cy, r, W), sector(cx, cy, r + W, open[0], open[1])), rect(cx - r, cy - W / 2, 2 * r, W));
+
+/* ---------- Puff: balloon strokes (100 at the ends, 134 in the middle), one per stroke ---------- */
+
+/**
+ * Puff letters: each stroke a balloon, 100 wide at its ends and 134 in the middle.
+ *
+ * @param {...Point[]} strokes The centrelines.
+ * @returns {Shape} The letters.
+ */
+export const puff = (...strokes) => U(...strokes.map((p) => balloon(dense(p, 12), 100, 134)));
+
+/* ---------- Linked: letters as bands woven over and under ---------- */
+
+/** The Linked band's width: 46. */
+export const LBW = 46;
+
+/** The Linked gap at a crossing: 12. */
+export const LBG = 12;
+
+/**
+ * Densifies a polyline (closed or open) to a step.
+ *
+ * @param {readonly Point[]} pts The polyline.
+ * @param {number} [step=6] The spacing.
+ * @param {boolean} [closed=false] Whether it closes.
+ * @returns {Point[]} The dense polyline.
+ */
+export const dense = (pts, step = 6, closed = false) => {
+	const out = [];
+	const m = closed ? pts.length : pts.length - 1;
+	for (let i = 0; i < m; i++) { const a = pts[i], b = pts[(i + 1) % pts.length], n = Math.max(1, Math.ceil(Math.hypot(b[0] - a[0], b[1] - a[1]) / step)); for (let k = 0; k < n; k++) out.push([a[0] + ((b[0] - a[0]) * k) / n, a[1] + ((b[1] - a[1]) * k) / n]); }
+	if (!closed) out.push(pts.at(-1));
+	return dedupe(out);
+};
+
+/**
+ * Woven letters: bands over and under where they cross.
+ *
+ * @param {readonly [readonly Point[], boolean?][]} strands Each strand's points and whether it closes.
+ * @param {number} [w] The band (LBW).
+ * @param {number} [g] The gap at a crossing (LBG).
+ * @returns {Shape} The letters.
+ */
+export const linked = (strands, w = LBW, g = LBG) => weave(strands.map(([pts, closed]) => ({ pts: dense(pts, 6, !!closed), closed: !!closed })), w, g);
+
+/* ---------- a finished shape ---------- */
+
+/**
+ * Drops the zero-width leftovers polygon-clipping can leave where square-ended strokes meet at a sharp turn: spike
+ * vertices (an edge running straight back along the one before it) and rings with next to no area. Nothing visible
+ * changes. Every ring comes back closed (its last point repeating the first).
+ *
+ * @param {Shape} shape The shape.
+ * @returns {Shape} It, cleaned.
+ */
+export const clean = (shape) => {
+	const area = (r) => r.reduce((a, p, i) => { const q = r[(i + 1) % r.length]; return a + p[0] * q[1] - q[0] * p[1]; }, 0) / 2;
+	const despike = (ring) => {
+		let r = ring.slice();
+		if (r.length > 1 && Math.hypot(r[0][0] - r.at(-1)[0], r[0][1] - r.at(-1)[1]) < 1e-9) r.pop();
+		for (let changed = true; changed && r.length > 3; ) {
+			changed = false;
+			for (let i = 0; i < r.length && r.length > 3; i++) {
+				const a = r[(i - 1 + r.length) % r.length], b = r[i], c = r[(i + 1) % r.length];
+				const u = [a[0] - b[0], a[1] - b[1]], v = [c[0] - b[0], c[1] - b[1]], lu = Math.hypot(...u), lv = Math.hypot(...v);
+				if (lu < 0.05 || lv < 0.05 || (u[0] * v[0] + u[1] * v[1]) / (lu * lv) > 0.998) { r.splice(i, 1); changed = true; i--; }
+			}
+		}
+		return [...r, r[0]];
+	};
+	return shape.map((pg) => pg.map(despike).filter((r) => r.length >= 4 && Math.abs(area(r)) > 1)).filter((pg) => pg.length && Math.abs(area(pg[0])) > 1);
+};