@logomarks/core 0.1.11 → 0.2.1

package/src/forms/discs.js

@@ -0,0 +1,114 @@
+/**
+ * Bold discs: one solid disc of radius DISC_R, centred, and the cuts that keep its gap exact when a piece moves. A
+ * moving piece is I(region, moved disc): the region's edge (the cut) stays put and only the rim moves, so the gap along
+ * the cut is still g. From the Logomarks tools (discparts.mjs, batch 201, "Bold · Discs", and its editions in batch 220).
+ */
+import { C, D, I, U, circle, poly, rot, sample, stroke } 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 */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/** The disc's radius. */
+export const DISC_R = 224;
+
+/**
+ * The disc (720 points), moved by (dx, dy).
+ *
+ * @param {number} [dx=0] Moved right.
+ * @param {number} [dy=0] Moved down.
+ * @param {number} [r=DISC_R] Its radius.
+ * @returns {Polygon} The disc.
+ */
+export const disc = (dx = 0, dy = 0, r = DISC_R) => circle(C + dx, C + dy, r, 720);
+
+/**
+ * A curve across the disc: `f(u)` gives [u, v] in a frame turned by `deg` about the centre, u running from −span·R to
+ * span·R.
+ *
+ * @param {(u: number) => readonly number[]} f The curve in its own frame.
+ * @param {number} [deg=0] The frame's turn.
+ * @param {number} [span=1.5] How far either side it runs, in radii.
+ * @param {number} [n=300] Points along it.
+ * @returns {Point[]} The curve on the canvas.
+ */
+export const across = (f, deg = 0, span = 1.5, n = 300) => {
+	const a = (deg * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a);
+	return sample(f, -span * DISC_R, span * DISC_R, n).map(([u, v]) => [C + u * c - v * s, C + u * s + v * c]);
+};
+
+/**
+ * The half plane on one side of an open curve that runs right across the disc: the curve closed 3000 out along the
+ * normal of its first-to-last chord.
+ *
+ * @param {readonly Point[]} L The curve.
+ * @param {number} s Which side: 1 or −1.
+ * @returns {Polygon} The half plane.
+ */
+export const discSide = (L, s) => {
+	const a = L[0], b = L.at(-1), d = [b[0] - a[0], b[1] - a[1]], l = Math.hypot(...d), n = [(-d[1] / l) * s * 3000, (d[0] / l) * s * 3000];
+	return poly([...L, [b[0] + n[0], b[1] + n[1]], [a[0] + n[0], a[1] + n[1]]]);
+};
+
+/**
+ * The disc parted along the curve L by the gap g, each half's rim moved by sa / sb (the cut stays put, so the gap stays g).
+ *
+ * @param {readonly Point[]} L The cut.
+ * @param {number} g The gap.
+ * @param {readonly number[]} [sa=[0, 0]] The left half's rim, moved.
+ * @param {readonly number[]} [sb=[0, 0]] The right half's rim, moved.
+ * @returns {Shape} The two halves.
+ */
+export const split = (L, g, sa = [0, 0], sb = [0, 0]) => {
+	const z = stroke(L, g, { chunk: 8 });
+	return U(D(I(disc(...sa), discSide(L, 1)), z), D(I(disc(...sb), discSide(L, -1)), z));
+};
+
+/**
+ * A solid band of width b along L, parted from both halves of the disc by g; the band's ends follow a disc moved by sm, so
+ * it rides out past the rim at one end.
+ *
+ * @param {readonly Point[]} L The band's centreline.
+ * @param {number | ((i: number, n: number) => number)} b Its width, or a width per point.
+ * @param {number} g The gap.
+ * @param {readonly number[]} [sm=[0, 0]] The band's disc, moved.
+ * @param {readonly number[]} [sa=[0, 0]] The left half's rim, moved.
+ * @param {readonly number[]} [sb=[0, 0]] The right half's rim, moved.
+ * @returns {Shape} The halves and the band.
+ */
+export const bandCut = (L, b, g, sm = [0, 0], sa = [0, 0], sb = [0, 0]) => {
+	const wz = typeof b === 'function' ? (i, n) => b(i, n) + 2 * g : b + 2 * g, z = stroke(L, wz, { chunk: 8 });
+	return U(D(I(disc(...sa), discSide(L, 1)), z), D(I(disc(...sb), discSide(L, -1)), z), I(disc(...sm), stroke(L, b, { chunk: 8 })));
+};
+
+/**
+ * A point on the disc's frame: radius r from the centre at angle deg (0 right, 90 down).
+ *
+ * @param {number} r The radius.
+ * @param {number} deg The angle.
+ * @returns {Point} The point.
+ */
+export const discAt = (r, deg) => [C + r * Math.cos((deg * Math.PI) / 180), C + r * Math.sin((deg * Math.PI) / 180)];
+
+/**
+ * A shape turned by deg about the point p.
+ *
+ * @param {Geom} s The shape.
+ * @param {number} deg The turn, degrees.
+ * @param {readonly number[]} p The pivot.
+ * @returns {Geom} The shape, turned.
+ */
+export const turn = (s, deg, p) => rot(s, deg, p[0], p[1]);
+
+/**
+ * The two sides of a circular cut (centre P, radius Ra) through the disc, parted by g; the inner side turned th° about P,
+ * so it glides along the cut.
+ *
+ * @param {readonly number[]} P The cut's centre.
+ * @param {number} Ra The cut's radius.
+ * @param {number} g The gap.
+ * @param {number} th The inner side's turn, degrees.
+ * @returns {Shape} The two sides.
+ */
+export const arcSplit = (P, Ra, g, th) => U(I(turn(disc(), th, P), circle(...P, Ra - g / 2, 900)), D(disc(), circle(...P, Ra + g / 2, 900)));

package/src/forms/emblems.d.ts

@@ -0,0 +1,22 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** The frame's left edge (32). */
+export const EMBLEM_X0: number;
+/** The frame's right edge (480). */
+export const EMBLEM_X1: number;
+/** The frame's bottom edge (480). */
+export const EMBLEM_Y1: number;
+/** The frame's width (448). */
+export const EMBLEM_W: number;
+/** The scene parted by the horizon: everything within g/2 of y = hz cut away. */
+export function horizon(shape: Geom, hz: number, g: number): Shape;
+/** A sine line across the frame at height y. */
+export function sine(y: number, amp: number, cycles: number, ph?: number, x0?: number, x1?: number): Point[];
+/** The sea: a block cut by n wave bands g wide. */
+export function sea(y0: number, y1: number, g: number, o?: { n?: number; amp?: number; cycles?: number; ph?: number; block?: Geom }): Shape;
+/** A ploughed field: a block cut by n bands fanning from a vanishing point. */
+export function field(y0: number, y1: number, g: number, n?: number, vy?: number, spread?: number, block?: Geom): Shape;
+/** A triangle, its base on y from xa to xb, its apex at (ax, ay). */
+export function tri(xa: number, xb: number, y: number, ax: number, ay: number): Polygon;
+/** A cloud: a flat base on y, three bumps. */
+export function cloud(cx: number, y: number, w: number, h: number): Shape;

package/src/forms/emblems.js

@@ -0,0 +1,109 @@
+/**
+ * Split emblems: a 448 frame (x and y from 32 to 480) whose scene is drawn whole and then parted by the horizon gap
+ * (`horizon()`), so the cut is always exactly g; the lower half is a ground block carved by gap-wide bands (`sea()`: sine
+ * bands; `field()`: bands fanning from a vanishing point). Each mark sets its own horizon. From the Logomarks tools
+ * (emblemparts.mjs, batch 216, "Bold · Emblems", and its editions in batch 241).
+ */
+import { U, D, I, poly, rect, circle, sample, mitreBand as band } 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 */
+/** @typedef {import('../geometry/types.js').Geom} Geom */
+
+/** The frame's left edge. */
+export const EMBLEM_X0 = 32;
+
+/** The frame's right edge. */
+export const EMBLEM_X1 = 480;
+
+/** The frame's bottom edge. */
+export const EMBLEM_Y1 = 480;
+
+/** The frame's width. */
+export const EMBLEM_W = EMBLEM_X1 - EMBLEM_X0;
+
+/**
+ * The scene parted by the horizon: everything within g/2 of y = hz cut away.
+ *
+ * @param {Geom} shape The scene.
+ * @param {number} hz The horizon's height.
+ * @param {number} g The gap.
+ * @returns {Shape} The scene, parted.
+ */
+export const horizon = (shape, hz, g) => D(shape, rect(-200, hz - g / 2, 900, g));
+
+/**
+ * A sine line across the frame at height y: amp tall, `cycles` waves over the frame's width, starting at phase ph.
+ *
+ * @param {number} y Its middle height.
+ * @param {number} amp Its amplitude.
+ * @param {number} cycles Waves across the frame.
+ * @param {number} [ph=0] The phase, degrees.
+ * @param {number} [x0=EMBLEM_X0 - 40] Where it starts.
+ * @param {number} [x1=EMBLEM_X1 + 40] Where it ends.
+ * @returns {Point[]} The line (160 steps).
+ */
+export const sine = (y, amp, cycles, ph = 0, x0 = EMBLEM_X0 - 40, x1 = EMBLEM_X1 + 40) =>
+	sample((x) => [x, y + amp * Math.sin(((x - EMBLEM_X0) / EMBLEM_W) * cycles * 2 * Math.PI + (ph * Math.PI) / 180)], x0, x1, 160);
+
+/**
+ * The sea: the block from y0 to y1 with n wave bands g wide cut across it, evenly spaced.
+ *
+ * @param {number} y0 The block's top.
+ * @param {number} y1 Its bottom.
+ * @param {number} g The gap (the bands' width).
+ * @param {{ n?: number, amp?: number, cycles?: number, ph?: number, block?: Geom }} [o] Bands (2), their amplitude (16),
+ *   waves across (2), phase (0) and the block to carve (the frame's width from y0 to y1).
+ * @returns {Shape} The sea.
+ */
+export const sea = (y0, y1, g, { n = 2, amp = 16, cycles = 2, ph = 0, block = rect(EMBLEM_X0, y0, EMBLEM_W, y1 - y0) } = {}) => {
+	const step = (y1 - y0) / (n + 1);
+	return D(block, ...[...Array(n)].map((_, i) => band(sine(y0 + step * (i + 1), amp, cycles, ph), g)));
+};
+
+/**
+ * A ploughed field in perspective: the block cut by n bands g wide fanning down from a vanishing point (256, vy) above
+ * the horizon, their feet spread across the width (spread 1 lays the outer feet on the frame's corners).
+ *
+ * @param {number} y0 The block's top.
+ * @param {number} y1 Its bottom.
+ * @param {number} g The gap (the bands' width).
+ * @param {number} [n=3] The bands.
+ * @param {number} [vy=y0 - 150] The vanishing point's height.
+ * @param {number} [spread=1.15] How far the feet spread.
+ * @param {Geom} [block] The block to carve (the frame's width from y0 to y1).
+ * @returns {Shape} The field.
+ */
+export const field = (y0, y1, g, n = 3, vy = y0 - 150, spread = 1.15, block = rect(EMBLEM_X0, y0, EMBLEM_W, y1 - y0)) =>
+	D(block, ...[...Array(n)].map((_, i) => {
+		const t = (i - (n - 1) / 2) / ((n + 1) / 2), foot = [256 + t * (EMBLEM_W / 2) * spread * 1.6, y1 + 60];
+		return I(band([[256, vy], foot], g), rect(-200, y0, 900, 900));
+	}));
+
+/**
+ * A triangle with its base on y from xa to xb and its apex at (ax, ay).
+ *
+ * @param {number} xa The base's left end.
+ * @param {number} xb The base's right end.
+ * @param {number} y The base's height.
+ * @param {number} ax The apex.
+ * @param {number} ay The apex.
+ * @returns {Polygon} The triangle.
+ */
+export const tri = (xa, xb, y, ax, ay) => poly([[xa, y], [ax, ay], [xb, y]]);
+
+/**
+ * A cloud: a flat base on y and three bumps, w wide and h tall about cx.
+ *
+ * @param {number} cx Its middle.
+ * @param {number} y Its base.
+ * @param {number} w Its width.
+ * @param {number} h Its height.
+ * @returns {Shape} The cloud.
+ */
+export const cloud = (cx, y, w, h) => {
+	const r1 = h * 0.42, r2 = h * 0.62, r3 = h * 0.36;
+	return I(U(circle(cx - w * 0.26, y - r1, r1, 240), circle(cx + w * 0.04, y - h + r2, r2, 240), circle(cx + w * 0.3, y - r3, r3, 240),
+		rect(cx - w * 0.26, y - r1, w * 0.56, r1)), rect(cx - w, y - 2 * h, 2 * w, 2 * h));
+};

package/src/forms/flow.d.ts

@@ -0,0 +1,21 @@
+import type { Point, Shape } from '../geometry/types.js';
+
+/** A flow grid's drawing: n × m discs of radius r, gap g, the path, the bridges' neck, blend, fillet and skipped cells. */
+export interface FlowOptions {
+	n: number;
+	m?: number;
+	r: number;
+	g: number;
+	path: string;
+	neck?: number;
+	k?: number;
+	fillet?: number;
+	skip?: string;
+}
+
+/** A flow path ("a0 b0 b1", a trailing "~" closing it) as cells [column, row]. */
+export function cells(s: string): { path: [number, number][]; closed: boolean };
+/** A flow grid's pitch and each cell's centre, for n × m discs of radius r and gap g centred on (cx, cy). */
+export function grid(n: number, m: number, r: number, g: number, cx?: number, cy?: number): { p: number; at: (cell: readonly number[]) => Point };
+/** A flow grid as shapes: the path, the free discs, both, and the narrowest gap between them. */
+export function flowShape(o: FlowOptions): { path: Shape; free: Shape; shape: Shape; clearance: number };

package/src/forms/flow.js

@@ -0,0 +1,80 @@
+/**
+ * Flow grids: discs on a small square grid where one path of neighbouring discs is joined by capsule bridges into a
+ * single smooth stroke (a letter, a wave, a loop), every join filleted, while the other discs stay single dots.
+ *
+ * The grid's pitch is 2r + g, so a free disc sits exactly the gap g from any path disc beside it. A path is a string of
+ * cells, "a0 b0 b1 …" (column letter a–d, row digit 0–3, y down), each cell an orthogonal neighbour of the one before; a
+ * trailing "~" closes it into a loop. A tube (`neck` 1) is drawn with the kit: a pill per bridge, each turn's inner
+ * corner filleted by closing just that turn's two pills, so a fillet never reaches across to a cell it isn't joined to.
+ * A bead string (`neck` under 1) is a distance field: each bridge melted into its two discs by a smooth minimum, the
+ * bridges then joined sharply, so two path discs side by side but unbridged keep their gap. The smooth minimum bulges
+ * where two of its fields run level, so it suits waisted bridges only.
+ * From the Logomarks tools (flowparts.mjs, batch 236, "Modular · Flow").
+ */
+import { circle, pill, U, soften } from '../geometry/index.js';
+import { sdCircle, sdCapsule, smin, fmin, shapeOf } from '../sdf/index.js';
+
+/**
+ * A flow path parsed into cells: "a0 b0 b1" → [[0, 0], [1, 0], [1, 1]]; a trailing "~" marks a closed loop.
+ *
+ * @param {string} s The path.
+ * @returns {{ path: [number, number][], closed: boolean }} Its cells (column, row) and whether it closes.
+ */
+export const cells = (s) => {
+	const t = s.trim().split(/\s+/), closed = t[t.length - 1] === '~';
+	return { path: (closed ? t.slice(0, -1) : t).map((c) => [c.charCodeAt(0) - 97, +c.slice(1)]), closed };
+};
+
+/**
+ * A flow grid's geometry: its pitch and each cell's centre, for an n × m grid of discs of radius r and gap g centred on
+ * (cx, cy).
+ *
+ * @param {number} n Columns.
+ * @param {number} m Rows.
+ * @param {number} r The discs' radius.
+ * @param {number} g The gap.
+ * @param {number} [cx=256] The grid's centre.
+ * @param {number} [cy=256] The grid's centre.
+ * @returns {{ p: number, at: (cell: readonly number[]) => [number, number] }} The pitch and a cell's centre.
+ */
+export const grid = (n, m, r, g, cx = 256, cy = 256) => {
+	const p = 2 * r + g, x0 = cx - ((n - 1) * p) / 2, y0 = cy - ((m - 1) * p) / 2;
+	return { p, at: ([i, j]) => [x0 + i * p, y0 + j * p] };
+};
+
+/**
+ * A flow grid as shapes: the path, the free discs, both together, and the narrowest gap between them (so a fillet that
+ * bulges into the gap is caught).
+ *
+ * @param {{ n: number, m?: number, r: number, g: number, path: string, neck?: number, k?: number, fillet?: number, skip?: string }} o
+ *   The grid (n × m, m = n), the discs' radius r and the gap g; the path (cells()); `neck` the bridges' width as a share
+ *   of the disc (1, a tube; under 1 a bead string melted with blend k, 0.6 r); `fillet` the tube's inner-corner radius
+ *   (0.6 r); `skip` cells left empty (no free disc either).
+ * @returns {{ path: import('../geometry/types.js').Shape, free: import('../geometry/types.js').Shape, shape: import('../geometry/types.js').Shape, clearance: number }}
+ *   The path, the free discs, both, and the narrowest gap from the path to a free disc.
+ * @throws {Error} When a step of the path isn't to a neighbouring cell.
+ */
+export function flowShape({ n, m = n, r, g, path, neck = 1, k = r * 0.6, fillet = r * 0.6, skip = '' }) {
+	const G = grid(n, m, r, g), { path: P, closed } = cells(path), key = ([i, j]) => `${i},${j}`, on = new Set(P.map(key));
+	const off = new Set(skip.trim() ? cells(skip).path.map(key) : []);
+	P.forEach((c, i) => { if (i && Math.abs(c[0] - P[i - 1][0]) + Math.abs(c[1] - P[i - 1][1]) !== 1) throw new Error(`flow: ${key(P[i - 1])} → ${key(c)} is not a neighbour step`); });
+	const B = P.slice(1).map((c, i) => [P[i], c]); if (closed) B.push([P[P.length - 1], P[0]]);
+	let pathS;
+	if (neck >= 1) {
+		const pills = B.map(([a, b]) => pill(G.at(a), G.at(b), 2 * r));
+		// a turn: two bridges meeting at a cell at a right angle; close just those two so the fillet stays in that corner
+		const turns = B.map((b, i) => [b, B[(i + 1) % B.length], i]).filter(([a, b, i]) => (closed || i < B.length - 1) && a[1] === b[0]
+			&& (a[1][0] - a[0][0]) * (b[1][0] - b[0][0]) + (a[1][1] - a[0][1]) * (b[1][1] - b[0][1]) === 0);
+		pathS = U(...pills, ...P.map((c) => circle(...G.at(c), r)), ...turns.map(([, , i]) => soften(U(pills[i], pills[(i + 1) % pills.length]), fillet, 0)));
+	} else pathS = shapeOf(fmin(...B.map(([a, b]) => smin(k, sdCircle(...G.at(a), r), sdCircle(...G.at(b), r), sdCapsule(G.at(a), G.at(b), 2 * r * neck)))));
+	const freeC = []; for (let j = 0; j < m; j++) for (let i = 0; i < n; i++) if (!on.has(key([i, j])) && !off.has(key([i, j]))) freeC.push(G.at([i, j]));
+	const free = freeC.length ? U(...freeC.map((c) => circle(...c, r))) : [];
+	// the narrowest gap: from each free disc's centre to the path's outline, less the radius
+	const seg = ([ax, ay], [bx, by], [x, y]) => {
+		const dx = bx - ax, dy = by - ay, t = Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy || 1e-9)));
+		return Math.hypot(x - ax - t * dx, y - ay - t * dy);
+	};
+	let clearance = Infinity;
+	for (const c of freeC) for (const pg of pathS) for (const ring of pg) for (let i = 1; i < ring.length; i++) clearance = Math.min(clearance, seg(ring[i - 1], ring[i], c) - r);
+	return { path: pathS, free, shape: freeC.length ? U(pathS, free) : pathS, clearance };
+}

package/src/forms/folds.d.ts

@@ -0,0 +1,18 @@
+import type { Point, Polygon, Shape, Geom } from '../geometry/types.js';
+
+/** A seam g wide along a polyline, round ends (two points: a pill). */
+export function seamLine(g: number, pts: readonly Point[]): Geom;
+/** A shape split into facets by seams g wide. */
+export function crease(shape: Geom, g: number, ...seams: Point[][]): Shape;
+/** A smooth seam through control points (Catmull-Rom, n points a span). */
+export function curve(pts: readonly Point[], n?: number): Point[];
+/** A quadratic Bézier from a to b pulled towards c, n + 1 points. */
+export function foldQuad(a: readonly number[], c: readonly number[], b: readonly number[], n?: number): Point[];
+/** A strap: a pill w wide from a to b. */
+export function strap(a: Point, b: Point, w: number): Polygon;
+/** A flat strip w wide from a to b, its ends cut on the lines y = y0 and y = y1 if given. */
+export function strip(a: readonly number[], b: readonly number[], w: number, o?: { y0?: number; y1?: number }): Polygon;
+/** A hand-cut edge: every ring wobbled along its normal by a smooth seeded wave of amplitude amp. */
+export function wobble(shape: Geom, amp: number, rnd?: () => number, o?: { step?: number; waves?: number }): Shape;
+/** Scissor-cut edges: every ring as straight snips about `step` long, ends nudged by up to `jit`. */
+export function snip(shape: Geom, step?: number, jit?: number, rnd?: () => number, corner?: number): Shape;

package/src/forms/folds.js

@@ -0,0 +1,147 @@
+/**
+ * Fold seams, straps and hand-cut edges, the parts the Crease, Strap and Snip marks share. A seam is half the house gap
+ * (11 once fitted, against the 22 gap): a fold or an overlap drawn as a hairline that shows at large sizes and fades at
+ * 32 px, where the mark must read as its silhouette alone. Every build takes the seam width g (exact() with a target of
+ * 11 keeps it 11 once fitted), so a part that is truly separate stands 2g clear. Laying parts one over another, each
+ * cut free by the seam, is the parts' chain().
+ * From the Logomarks tools (foldparts.mjs, batch 170).
+ */
+import { U, D, poly, pill, stroke, dedupe } from '../geometry/index.js';
+import { spline } from '../parts/index.js';
+
+/**
+ * A seam along a polyline: g wide with round ends, so seams that meet at a node leave the facets' corners sharp.
+ *
+ * @param {number} g The seam's width.
+ * @param {readonly import('../geometry/types.js').Point[]} pts The seam's line (two points: a straight seam).
+ * @returns {import('../geometry/types.js').Geom} The seam.
+ */
+export const seamLine = (g, pts) => (pts.length === 2 ? pill(pts[0], pts[1], g) : stroke(dedupe(pts), g, { roundCaps: true, chunk: 8 }));
+
+/**
+ * A shape split into facets by seams. Run a seam that ends on the outline a little past it, and end inner seams exactly
+ * on a node where they meet another.
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @param {number} g The seam's width.
+ * @param {...import('../geometry/types.js').Point[]} seams Each seam's points (two for a straight seam, more for a curve).
+ * @returns {import('../geometry/types.js').Shape} The facets.
+ */
+export const crease = (shape, g, ...seams) => D(shape, ...seams.map((s) => seamLine(g, s)));
+
+/**
+ * A smooth seam through control points (Catmull-Rom, the ends held).
+ *
+ * @param {readonly import('../geometry/types.js').Point[]} pts The control points.
+ * @param {number} [n=24] Points a span.
+ * @returns {import('../geometry/types.js').Point[]} The seam's line.
+ */
+export const curve = (pts, n = 24) => spline(pts, n);
+
+/**
+ * A quadratic Bézier from a to b pulled towards c, as n + 1 points.
+ *
+ * @param {readonly number[]} a The start.
+ * @param {readonly number[]} c The control point.
+ * @param {readonly number[]} b The end.
+ * @param {number} [n=48] Steps.
+ * @returns {import('../geometry/types.js').Point[]} The curve.
+ */
+export const foldQuad = (a, c, b, n = 48) => [...Array(n + 1)].map((_, i) => {
+	const t = i / n, u = 1 - t;
+	return [u * u * a[0] + 2 * u * t * c[0] + t * t * b[0], u * u * a[1] + 2 * u * t * c[1] + t * t * b[1]];
+});
+
+/**
+ * A strap: a pill stroke w wide from a to b (strap letters lay one strap over another with the parts' chain()).
+ *
+ * @param {import('../geometry/types.js').Point} a One end.
+ * @param {import('../geometry/types.js').Point} b The other.
+ * @param {number} w The width.
+ * @returns {import('../geometry/types.js').Polygon} The strap.
+ */
+export const strap = (a, b, w) => pill(a, b, w);
+
+/**
+ * A flat strip w wide from a to b, each end cut on a horizontal line (y0 at a, y1 at b) if given, else square.
+ *
+ * @param {readonly number[]} a One end.
+ * @param {readonly number[]} b The other.
+ * @param {number} w The width.
+ * @param {{ y0?: number, y1?: number }} [o] The heights the ends are cut on.
+ * @returns {import('../geometry/types.js').Polygon} The strip.
+ */
+export const strip = (a, b, w, { y0, y1 } = {}) => {
+	const dx = b[0] - a[0], dy = b[1] - a[1], L = Math.hypot(dx, dy), n = [-dy / L * w / 2, dx / L * w / 2];
+	const ends = (p, y, sgn) => {
+		if (y == null) return [[p[0] + n[0], p[1] + n[1]], [p[0] - n[0], p[1] - n[1]]];
+		// slide each edge along the strip's direction until it meets y
+		return [n, [-n[0], -n[1]]].map((o) => { const q = [p[0] + o[0], p[1] + o[1]], t = (y - q[1]) / dy; return [q[0] + dx * t, y]; });
+	};
+	const [a1, a2] = ends(a, y0), [b1, b2] = ends(b, y1); return poly([a1, b1, b2, a2]);
+};
+
+/**
+ * A hand-cut edge: every ring of a shape resampled every `step` and pushed along its normal by a smooth, seeded wobble
+ * of amplitude `amp` (three sine waves round the ring with random phases from `rnd`, about `waves` bumps per 1000 units
+ * of outline), so the cut reads as scissors on paper, not as noise. The same seed gives the same edge.
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @param {number} amp The wobble's amplitude.
+ * @param {() => number} [rnd=Math.random] The random source (seeded, for a repeatable edge).
+ * @param {{ step?: number, waves?: number }} [o] The resampling step (3) and the bumps per 1000 units (9).
+ * @returns {import('../geometry/types.js').Shape} The shape with its edges wobbled.
+ */
+export const wobble = (shape, amp, rnd = Math.random, { step = 3, waves = 9 } = {}) => {
+	const polys = shape.length && typeof shape[0][0][0] === 'number' ? [shape] : shape;
+	const ph = [rnd(), rnd(), rnd()].map((v) => v * 2 * Math.PI);
+	const ringW = (ring) => {
+		const r = dedupe(ring.slice(0, -1).concat(ring.at(-1)[0] === ring[0][0] && ring.at(-1)[1] === ring[0][1] ? [] : [ring.at(-1)]));
+		const dense = []; r.forEach((p, i) => {
+			const q = r[(i + 1) % r.length], m = Math.max(1, Math.ceil(Math.hypot(q[0] - p[0], q[1] - p[1]) / step));
+			for (let j = 0; j < m; j++) dense.push([p[0] + ((q[0] - p[0]) * j) / m, p[1] + ((q[1] - p[1]) * j) / m]);
+		});
+		const n = dense.length, S = [0]; for (let i = 1; i < n; i++) S.push(S[i - 1] + Math.hypot(dense[i][0] - dense[i - 1][0], dense[i][1] - dense[i - 1][1]));
+		const L = S[n - 1] + Math.hypot(dense[0][0] - dense[n - 1][0], dense[0][1] - dense[n - 1][1]), k = Math.max(3, Math.round((waves * L) / 1000));
+		return dense.map((p, i) => {
+			const a = dense[(i - 1 + n) % n], b = dense[(i + 1) % n], dx = b[0] - a[0], dy = b[1] - a[1], l = Math.hypot(dx, dy) || 1, t = (2 * Math.PI * S[i]) / L;
+			const w = amp * (0.6 * Math.sin(k * t + ph[0]) + 0.3 * Math.sin((2 * k + 1) * t + ph[1]) + 0.2 * Math.sin((3 * k + 2) * t + ph[2]));
+			return [p[0] - (dy / l) * w, p[1] + (dx / l) * w];
+		});
+	};
+	return U(...polys.map((pg) => D(poly(ringW(pg[0])), ...pg.slice(1).map((h) => poly(ringW(h))))));
+};
+
+/**
+ * Scissor-cut edges: every ring of a shape redrawn as straight snips about `step` long (corners sharper than `corner`°
+ * kept where they are), each snip's end nudged along the normal by up to `jit` from the seeded `rnd`, so curves turn
+ * into short straight cuts and straight edges kink slightly, as paper cut by hand.
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @param {number} [step=34] The snips' length.
+ * @param {number} [jit=3] The most a snip's end moves.
+ * @param {() => number} [rnd=Math.random] The random source (seeded, for a repeatable edge).
+ * @param {number} [corner=140] Corners sharper than this (degrees) stay put.
+ * @returns {import('../geometry/types.js').Shape} The shape, snipped.
+ */
+export const snip = (shape, step = 34, jit = 3, rnd = Math.random, corner = 140) => {
+	const polys = shape.length && typeof shape[0][0][0] === 'number' ? [shape] : shape;
+	const ringS = (ring) => {
+		const r = dedupe(ring.at(-1)[0] === ring[0][0] && ring.at(-1)[1] === ring[0][1] ? ring.slice(0, -1) : ring), n = r.length;
+		const ang = (i) => {
+			const a = r[(i - 1 + n) % n], p = r[i], b = r[(i + 1) % n], u = [a[0] - p[0], a[1] - p[1]], v = [b[0] - p[0], b[1] - p[1]];
+			return (Math.acos(Math.max(-1, Math.min(1, (u[0] * v[0] + u[1] * v[1]) / (Math.hypot(...u) * Math.hypot(...v) || 1)))) * 180) / Math.PI;
+		};
+		const out = []; let acc = 0;
+		for (let i = 0; i < n; i++) {
+			const p = r[i], q = r[(i + 1) % n], sharp = ang(i) < corner;
+			if (sharp || acc >= step || i === 0) {
+				const a = r[(i - 1 + n) % n], dx = q[0] - a[0], dy = q[1] - a[1], l = Math.hypot(dx, dy) || 1, j = sharp ? 0 : (rnd() * 2 - 1) * jit;
+				out.push([p[0] - (dy / l) * j, p[1] + (dx / l) * j]); acc = 0;
+			}
+			acc += Math.hypot(q[0] - p[0], q[1] - p[1]);
+		}
+		return out;
+	};
+	return U(...polys.map((pg) => D(poly(ringS(pg[0])), ...pg.slice(1).map((h) => poly(ringS(h))))));
+};

package/src/forms/geo.d.ts

@@ -0,0 +1,46 @@
+import type { Geom, Point, Polygon, Shape } from '../geometry/types.js';
+
+/** The base square's side (420). */
+export const GEO_SQ: number;
+/** The base square's left edge. */
+export const GEO_X0: number;
+/** The base square's right edge. */
+export const GEO_X1: number;
+/** The base square, side s, centred. */
+export function sq(s?: number): Polygon;
+/** The unit vector from a to b, and the distance. */
+export function dirOf(a: readonly number[], b: readonly number[]): [Point, number];
+/** A needle gap from a (width w0) to b (width w1), run on past b by ext at the same taper. */
+export function needle(a: readonly number[], b: readonly number[], w0: number, w1: number, ext?: number): Polygon;
+/** A straight band of width w along a → b, square ends. */
+export function band(a: readonly number[], b: readonly number[], w: number): Polygon;
+/** The half plane on one side (s = ±1) of an open polyline that runs right across a shape. */
+export function side(L: readonly Point[], s: number): Polygon;
+/** A front strand laid over a closed band near p: the band cut free round it by g within R of p. */
+export function crossOver(all: Geom, front: Geom, p: readonly number[], R: number, g: number): Shape;
+/** A disc with at least 180 points. */
+export function geoDisc(cx: number, cy: number, r: number): Polygon;
+/** A knob: a disc with one slot at deg, split right across (full) or a pointer from the centre. */
+export function knob(cx: number, cy: number, r: number, deg: number, w: number, full?: boolean): Shape;
+/** Knobs on a grid of tokens ('|', '-', '\\', '/', 'pN', '.'), discs of radius r on a pitch of 2r + g. */
+export function knobs(rows: readonly (readonly string[])[], g: number, w: number, r: number): Shape;
+/** The disc radius that makes n discs and n − 1 gaps span 448. */
+export function rFor(n: number, g: number): number;
+/** A roof tile: a square with a half disc on its far side, the cap pointing at deg. */
+export function roofTile(cx: number, cy: number, a: number, deg?: number): Shape;
+/** Tiles laid back to front, each over the ones before and cut free by g. */
+export function layered(list: readonly Geom[], g: number): Geom;
+/** A triangle's three corners, circumradius R about (cx, cy). */
+export function triPts(cx: number, cy: number, R: number, deg?: number): Point[];
+/** The half of a disc on the side sideDeg points to. */
+export function halfDisc(cx: number, cy: number, r: number, sideDeg: number): Shape;
+/** The split disc's radius (224). */
+export const R7: number;
+/** The disc parted along L by g, each half's rim moved by sa / sb. */
+export function splitDisc(L: readonly Point[], g: number, sa: readonly number[], sb: readonly number[]): Shape;
+/** A roof tile's side in scales() (150). */
+export const SA: number;
+/** Roof tiles on a turned lattice, laid back to front; tiles in `up` face back up. */
+export function scales(cells: readonly Point[], g: number, o?: { a?: number; pi?: number; pj?: number; deg?: number; up?: readonly Point[] }): Shape;
+/** The nine points of a 3 × 3 lattice. */
+export const grid3: Point[];