@logomarks/core 0.1.9 → 0.1.11

package/src/parts/pixels.js

@@ -0,0 +1,74 @@
+/**
+ * Pixel editions: a drawn mark sampled into rows of text ('#' a pixel), the format PIX7 and the pixel animals use. From
+ * the Logomarks tools' dither parts (batches 210 and 234).
+ */
+
+/**
+ * A kit shape as a polygon set (the kit's primitives return one polygon, its booleans a set).
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @returns {import('../geometry/types.js').Shape} A polygon set.
+ */
+const polys = (shape) => /** @type {import('../geometry/types.js').Shape} */ (typeof shape[0][0][0] === 'number' ? [shape] : shape);
+
+/**
+ * Whether a point is inside a kit shape, even-odd over every ring.
+ *
+ * @param {import('../geometry/types.js').Geom} shape The shape.
+ * @param {number} x The point.
+ * @param {number} y The point.
+ * @returns {boolean} True when it is.
+ */
+export const insideShape = (shape, x, y) => {
+	let k = false;
+	for (const pg of polys(shape)) for (const r of pg) for (let a = 0, b = r.length - 1; a < r.length; b = a++) {
+		const [xa, ya] = r[a], [xb, yb] = r[b];
+		if ((ya > y) !== (yb > y) && x < xa + ((y - ya) * (xb - xa)) / (yb - ya)) k = !k;
+	}
+	return k;
+};
+
+/**
+ * A mark on the 512 canvas as rows of text. Each axis is a list of spans `[from, to, n]`: n pixels across from..to, or
+ * `[null, null, n]` for n empty pixels. A tiled mark gives each tile its own span and each gap one empty pixel, so the
+ * gaps stay whole pixels (Cove Rise on a 2 × 2 grid: `[[32, 245, 7], [null, null, 1], [267, 480, 7]]`).
+ *
+ * @param {import('../geometry/types.js').Geom} shape The mark.
+ * @param {readonly (readonly (number | null)[])[]} xs The spans across.
+ * @param {readonly (readonly (number | null)[])[]} ys The spans down.
+ * @param {{ min?: number, k?: number }} [options] A cell is set when the mark covers `min` (0.5) of a k × k (6) sample.
+ * @returns {string[]} The rows, '#' a pixel and '.' none.
+ */
+export const rasterRows = (shape, xs, ys, { min = 0.5, k = 6 } = {}) => {
+	const sh = polys(shape);
+	const cells = (/** @type {readonly (readonly (number | null)[])[]} */ spans) => spans.flatMap(([a, b, n]) => [...Array(/** @type {number} */ (n))].map((_, i) =>
+		(a == null ? null : [a + ((/** @type {number} */ (b) - a) * i) / /** @type {number} */ (n), a + ((/** @type {number} */ (b) - a) * (i + 1)) / /** @type {number} */ (n)])));
+	const X = cells(xs), Y = cells(ys);
+	return Y.map((y) => X.map((x) => {
+		if (!x || !y) return '.';
+		let n = 0;
+		for (let a = 0; a < k; a++) for (let b = 0; b < k; b++) n += +insideShape(sh, x[0] + ((x[1] - x[0]) * (a + 0.5)) / k, y[0] + ((y[1] - y[0]) * (b + 0.5)) / k);
+		return n / (k * k) >= min ? '#' : '.';
+	}).join(''));
+};
+
+/**
+ * A whole mark as rows of text on square pixels, for the pixel edition of a non-tiled mark: n pixels along its longest
+ * side, the grid starting (fx, fy) pixels before its top-left (sweep this phase so the gaps land on whole empty pixels),
+ * then each `fix` cell [i, j] toggled by hand (to fill a corner-only contact or clear a stray).
+ *
+ * @param {import('../geometry/types.js').Geom} shape The mark.
+ * @param {number} n Pixels along its longest side.
+ * @param {number} [fx] The grid's phase across, in pixels (0).
+ * @param {number} [fy] Its phase down (0).
+ * @param {{ min?: number, fix?: readonly (readonly number[])[] }} [options] The coverage a pixel needs (0.5), and cells to toggle.
+ * @returns {string[]} The rows.
+ */
+export const rasterMark = (shape, n, fx = 0, fy = 0, { min = 0.5, fix = [] } = {}) => {
+	const pts = polys(shape).flat(2), xs = pts.map((p) => p[0]), ys = pts.map((p) => p[1]);
+	const x0 = Math.min(...xs), x1 = Math.max(...xs), y0 = Math.min(...ys), y1 = Math.max(...ys), p = Math.max(x1 - x0, y1 - y0) / n;
+	const nx = Math.ceil((x1 - x0) / p + fx), ny = Math.ceil((y1 - y0) / p + fy), ox = x0 - fx * p, oy = y0 - fy * p;
+	const rows = rasterRows(shape, [[ox, ox + nx * p, nx]], [[oy, oy + ny * p, ny]], { min }).map((r) => [...r]);
+	for (const [i, j] of fix) rows[j][i] = rows[j][i] === '#' ? '.' : '#';
+	return rows.map((r) => r.join(''));
+};

package/src/parts/run.js

@@ -7,12 +7,14 @@ import { seeded, toPath } from '../geometry/index.js';
 import { exact } from './frame.js';
 
 /** Writes a batch: every mark in `M` ({ name: { trade, style, fn(g) } }) drawn with exact() so its gap is 22 once fitted,
- * seeded per mark (a re-run is byte-identical); `node genbatchN.mjs <workdir> ["Name,Name" | "fam:Industry · Law"]`. */
+ * seeded per mark (a re-run is byte-identical); `node genbatchN.mjs <workdir> ["Name,Name" | "fam:Industry · Law"]`.
+ * `fam:` also takes the trade as written, for batches that pass a whole family as the trade ("fam:Letters · Latch").
+ * New batches use `runBatch` from `@logomarks/core/batch`. */
 export const runIndustry = (batch, M) => {
   const [S, only = ''] = process.argv.slice(2), OUT = path.join(S, `newraw${batch}`), slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, '-');
   fs.mkdirSync(OUT, { recursive: true }); let n = 0;
   for (const [name, { trade, fn }] of Object.entries(M)) {
-    if (only.startsWith('fam:') ? 'Industry · ' + trade !== only.slice(4) : only && !only.split(',').includes(name)) continue;
+    if (only.startsWith('fam:') ? !['Industry · ' + trade, trade].includes(only.slice(4)) : only && !only.split(',').includes(name)) continue;
     try { const s = exact(fn, () => { Math.random = seeded(name); });
       fs.writeFileSync(path.join(OUT, slug(name) + '.svg'), `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" fill="currentColor"><path fill-rule="evenodd" d="${toPath(s)}"/></svg>\n`); n++; }
     catch (e) { console.log('FAIL', name, e.message.slice(0, 160)); } }

package/src/parts/span.d.ts

@@ -0,0 +1,13 @@
+import type { Geom, Shape } from '../geometry/types.js';
+import type { Cell } from './tiles.js';
+
+/** One tile token over a w × h block of cells, the gaps inside it filled (oblong blocks: S, t<k>, d<k>, h<k>, q<k>). */
+export function spanTile(tok: string, cs: readonly Cell[], n: number, i: number, j: number, w: number, h: number): Geom;
+/** A grid of tiles from rows of tokens, a token spanning cells as tok^2, tok>2, tok_2 or tok@2x3. */
+export function spanGrid(rows: readonly string[], s: number): Shape;
+/** A shape's longest side. */
+export function longSide(sh: Geom): number;
+/** The cell size that draws the rows 422 at their longest with the gap 22. */
+export function evenCell(rows: readonly string[]): number;
+/** The span grid at evenCell(rows). */
+export function evenGrid(rows: readonly string[]): Shape;

package/src/parts/span.js

@@ -0,0 +1,100 @@
+/**
+ * Span tiles: a grid of tile() tokens on the 422 span with the house gap, where one token may span a block of cells (the
+ * gaps inside it filled), so a big tile sits among unit tiles. From the Logomarks tools (batch 269, shared since 280).
+ */
+import { rr, rect, poly, bbox, ellipse, I, U } from '../geometry/index.js';
+import { gridCells, tile } from './tiles.js';
+
+/**
+ * One tile token over a w × h block of cells, the gaps inside the block filled. A square block takes every tile() token;
+ * an oblong one takes `S` (a slab), `t<k>` (a right triangle keeping corner k: tl, tr, br, bl), `d<k>` (a slab with side
+ * k fully round: t, r, b, l; `dp` a pill), `h<k>` (a half ellipse filling the block, flat on side k) and `q<k>` (a
+ * quarter ellipse centred on corner k).
+ *
+ * @param {string} tok The token.
+ * @param {readonly import('./tiles.js').Cell[]} cs The grid's cells (gridCells), row by row.
+ * @param {number} n Cells across.
+ * @param {number} i The block's first column.
+ * @param {number} j Its first row.
+ * @param {number} w Its width, in cells.
+ * @param {number} h Its height, in cells.
+ * @returns {import('../geometry/types.js').Geom} The tile.
+ * @throws {Error} For a token an oblong block doesn't take.
+ */
+export const spanTile = (tok, cs, n, i, j, w, h) => {
+	const a = cs[j * n + i], b = cs[(j + h - 1) * n + (i + w - 1)], x = a.x, y = a.y, W = b.x + b.s - a.x, H = b.y + b.s - a.y;
+	if (Math.abs(W - H) < 1e-6) return tile(tok, { i, j, x, y, s: W });
+	if (tok === 'S') return rect(x, y, W, H);
+	if (tok[0] === 't') {
+		/** @type {Record<string, number[]>} */ const K = { tl: [x, y], tr: [x + W, y], br: [x + W, y + H], bl: [x, y + H] };
+		const O = ['tl', 'tr', 'br', 'bl'], q = O.indexOf(tok.slice(1));
+		return poly([K[O[(q + 3) % 4]], K[O[q]], K[O[(q + 1) % 4]]]);
+	}
+	if (tok[0] === 'd') {
+		const r = Math.min(W, H) / 2, k = tok[1];
+		return rr(x, y, W, H, /** @type {Record<string, number[]>} */ ({ t: [r, r, 0, 0], r: [0, r, r, 0], b: [0, 0, r, r], l: [r, 0, 0, r], p: [r, r, r, r] })[k]);
+	}
+	if (tok[0] === 'h') {
+		const k = tok[1], box = rect(x, y, W, H), v = k === 't' || k === 'b';
+		const [cx, cy] = /** @type {Record<string, number[]>} */ ({ t: [x + W / 2, y], b: [x + W / 2, y + H], l: [x, y + H / 2], r: [x + W, y + H / 2] })[k];
+		return I(ellipse(cx, cy, v ? W / 2 : W, v ? H : H / 2, 0, 400), box);
+	}
+	if (tok[0] === 'q') {
+		const k = tok.slice(1), cx = k[1] === 'r' ? x + W : x, cy = k[0] === 'b' ? y + H : y;
+		return I(ellipse(cx, cy, W, H, 0, 400), rect(x, y, W, H));
+	}
+	throw new Error('span tile ' + tok);
+};
+
+/**
+ * A grid of tiles from rows of tokens, where a token may span cells: `tok^2` a 2 × 2 block (`tok^3` 3 × 3), `tok>2` two
+ * cells across, `tok_2` two cells down, `tok@2x3` any block (2 across, 3 down). The cells a block covers are written `-`,
+ * an empty cell `.`.
+ *
+ * @param {readonly string[]} rows The rows of tokens.
+ * @param {number} s The cell's size.
+ * @returns {import('../geometry/types.js').Shape} The grid.
+ */
+export const spanGrid = (rows, s) => {
+	const g = rows.map((r) => r.trim().split(/\s+/)), n = Math.max(...g.map((r) => r.length)), m = g.length, cs = gridCells(n, m, { s }), out = [];
+	g.forEach((row, j) => row.forEach((t, i) => {
+		if (t === '.' || t === '-') return;
+		const bx = t.match(/^(.+?)@(\d)x(\d)$/);
+		if (bx) { out.push(spanTile(bx[1], cs, n, i, j, +bx[2], +bx[3])); return; }
+		const mm = t.match(/^(.+?)(?:\^(\d)|>(\d)|_(\d))$/);
+		if (!mm) { out.push(tile(t, cs[j * n + i])); return; }
+		const [, tok, sq, wd, ht] = mm, w = +(sq || wd || 1), h = +(sq || ht || 1);
+		out.push(spanTile(tok, cs, n, i, j, w, h));
+	}));
+	return U(...out);
+};
+
+/**
+ * A shape's longest side.
+ *
+ * @param {import('../geometry/types.js').Geom} sh The shape.
+ * @returns {number} Its longer box side.
+ */
+export const longSide = (sh) => { const [x0, y0, x1, y1] = bbox(sh); return Math.max(x1 - x0, y1 - y0); };
+
+/**
+ * The cell size that draws `rows` so the mark (not the grid) is 422 at its longest with the gap 22, so a mark whose
+ * tiles stop short of the grid's edge fits to 448 with the family's gap. The longest side is linear in the cell, so
+ * two trial builds find it.
+ *
+ * @param {readonly string[]} rows The rows of tokens.
+ * @returns {number} The cell size.
+ */
+export const evenCell = (rows) => {
+	const n = Math.max(...rows.map((r) => r.trim().split(/\s+/).length), rows.length), s0 = (422 - (n - 1) * 22) / n;
+	const a = longSide(spanGrid(rows, s0)), b = longSide(spanGrid(rows, s0 * 1.2));
+	return s0 + ((422 - a) * 0.2 * s0) / (b - a);
+};
+
+/**
+ * The span grid at evenCell(rows).
+ *
+ * @param {readonly string[]} rows The rows of tokens.
+ * @returns {import('../geometry/types.js').Shape} The grid.
+ */
+export const evenGrid = (rows) => spanGrid(rows, evenCell(rows));

package/src/sdf/fields.js

@@ -0,0 +1,135 @@
+/**
+ * Signed distance fields: a field is a function (x, y) → distance, negative inside, positive outside, on the 512 canvas.
+ */
+
+/**
+ * A disc.
+ *
+ * @param {number} cx Its centre.
+ * @param {number} cy Its centre.
+ * @param {number} r Its radius.
+ * @returns {import('./index.js').Field} The field.
+ */
+export const sdCircle = (cx, cy, r) => (x, y) => Math.hypot(x - cx, y - cy) - r;
+
+/**
+ * The distance from a point to the segment a–b, and where along it the nearest point lies.
+ *
+ * @param {readonly number[]} a The segment's start.
+ * @param {readonly number[]} b Its end.
+ * @param {number} x The point.
+ * @param {number} y The point.
+ * @returns {[number, number]} The distance, and t from 0 (at a) to 1 (at b).
+ */
+export const segT = ([ax, ay], [bx, by], x, y) => {
+	const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy || 1e-9;
+	const t = Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / L2));
+	return [Math.hypot(x - ax - t * dx, y - ay - t * dy), t];
+};
+
+/**
+ * A capsule: the segment a–b with round ends.
+ *
+ * @param {readonly number[]} a One end's centre.
+ * @param {readonly number[]} b The other's.
+ * @param {number} w Its width.
+ * @returns {import('./index.js').Field} The field.
+ */
+export const sdCapsule = (a, b, w) => (x, y) => segT(a, b, x, y)[0] - w / 2;
+
+/**
+ * A stroke along a polyline with round ends. Its width may be a function of the run t (0 to 1), for a waist or a swell.
+ *
+ * @param {readonly (readonly number[])[]} pts The polyline.
+ * @param {number | ((t: number) => number)} w The width, or the width along the run.
+ * @returns {import('./index.js').Field} The field.
+ */
+export const sdPath = (pts, w) => {
+	const n = pts.length - 1, W = typeof w === 'function' ? w : () => w;
+	return (x, y) => {
+		let m = Infinity;
+		for (let i = 1; i <= n; i++) {
+			const [d, t] = segT(pts[i - 1], pts[i], x, y);
+			m = Math.min(m, d - W((i - 1 + t) / n) / 2);
+		}
+		return m;
+	};
+};
+
+/**
+ * Points along an arc (y down, so increasing angles run clockwise), for sdPath.
+ *
+ * @param {number} cx Its centre.
+ * @param {number} cy Its centre.
+ * @param {number} r Its radius.
+ * @param {number} a0 The start angle, in degrees.
+ * @param {number} a1 The end angle, in degrees.
+ * @param {number} [n] The number of steps (48).
+ * @returns {[number, number][]} n + 1 points.
+ */
+export const arcPts = (cx, cy, r, a0, a1, n = 48) => [...Array(n + 1)].map((_, i) => {
+	const a = ((a0 + ((a1 - a0) * i) / n) * Math.PI) / 180;
+	return /** @type {[number, number]} */ ([cx + r * Math.cos(a), cy + r * Math.sin(a)]);
+});
+
+/**
+ * A rounded box.
+ *
+ * @param {number} cx Its centre.
+ * @param {number} cy Its centre.
+ * @param {number} w Its width.
+ * @param {number} h Its height.
+ * @param {number} [r] Its corner radius (0).
+ * @returns {import('./index.js').Field} The field.
+ */
+export const sdBox = (cx, cy, w, h, r = 0) => (x, y) => {
+	const qx = Math.abs(x - cx) - w / 2 + r, qy = Math.abs(y - cy) - h / 2 + r;
+	return Math.hypot(Math.max(qx, 0), Math.max(qy, 0)) + Math.min(Math.max(qx, qy), 0) - r;
+};
+
+/**
+ * An ellipse, as a scaled disc: exact enough for its outline, not for a gap cut against it.
+ *
+ * @param {number} cx Its centre.
+ * @param {number} cy Its centre.
+ * @param {number} rx Its radius across.
+ * @param {number} ry Its radius down.
+ * @param {number} [deg] Its turn, in degrees (0).
+ * @returns {import('./index.js').Field} The field (approximate).
+ */
+export const sdEllipse = (cx, cy, rx, ry, deg = 0) => {
+	const a = (deg * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a), m = Math.min(rx, ry);
+	return (x, y) => {
+		const u = (x - cx) * c + (y - cy) * s, v = -(x - cx) * s + (y - cy) * c;
+		return (Math.hypot(u / rx, v / ry) - 1) * m;
+	};
+};
+
+/**
+ * A ring (an annulus).
+ *
+ * @param {number} cx Its centre.
+ * @param {number} cy Its centre.
+ * @param {number} r Its centre line's radius.
+ * @param {number} w Its width.
+ * @returns {import('./index.js').Field} The field.
+ */
+export const sdRing = (cx, cy, r, w) => (x, y) => Math.abs(Math.hypot(x - cx, y - cy) - r) - w / 2;
+
+/**
+ * A polygon: exact, so it rounds (offset) and takes a gap cleanly.
+ *
+ * @param {readonly (readonly number[])[]} pts Its corners, in order (either winding).
+ * @returns {import('./index.js').Field} The field.
+ */
+export const sdPoly = (pts) => (x, y) => {
+	let d = Infinity, s = 1;
+	for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
+		const [ax, ay] = pts[j], [bx, by] = pts[i], ex = bx - ax, ey = by - ay, wx = x - ax, wy = y - ay;
+		const t = Math.max(0, Math.min(1, (wx * ex + wy * ey) / (ex * ex + ey * ey || 1e-9))), dx = wx - ex * t, dy = wy - ey * t;
+		d = Math.min(d, dx * dx + dy * dy);
+		const c1 = y >= ay, c2 = y < by, c3 = ex * wy > ey * wx;
+		if ((c1 && c2 && c3) || (!c1 && !c2 && !c3)) s = -s;
+	}
+	return s * Math.sqrt(d);
+};

package/src/sdf/gap.js

@@ -0,0 +1,42 @@
+/**
+ * The house gap in fields: cuts that stay exactly g wide, and one shape laid over another.
+ */
+import { segT } from './fields.js';
+
+/**
+ * A band g wide cut along each line, its edges left crisp.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {readonly (readonly (readonly number[])[])[]} lines Segments or polylines, each a list of points.
+ * @param {number} g The gap.
+ * @returns {import('./index.js').Field} The field, cut.
+ */
+export const gapCut = (f, lines, g) => (x, y) => {
+	let m = Infinity;
+	for (const L of lines) for (let i = 1; i < L.length; i++) m = Math.min(m, segT(L[i - 1], L[i], x, y)[0]);
+	return Math.max(f(x, y), g / 2 - m);
+};
+
+/**
+ * One field laid over another, cut free of it by the gap. `front` must be a true distance near its edge.
+ *
+ * @param {import('./index.js').Field} back The field behind.
+ * @param {import('./index.js').Field} front The field in front.
+ * @param {number} g The gap.
+ * @returns {import('./index.js').Field} Both, front over back.
+ */
+export const fover = (back, front, g) => (x, y) => Math.min(front(x, y), Math.max(back(x, y), g - front(x, y)));
+
+/**
+ * Two fields linked: a over b where `aOver` holds (a half-plane, say), b over a elsewhere.
+ *
+ * @param {import('./index.js').Field} a One field.
+ * @param {import('./index.js').Field} b The other.
+ * @param {number} g The gap.
+ * @param {(x: number, y: number) => boolean} aOver Where a goes over.
+ * @returns {import('./index.js').Field} The link.
+ */
+export const flink = (a, b, g, aOver) => {
+	const ab = fover(b, a, g), ba = fover(a, b, g);
+	return (x, y) => (aOver(x, y) ? ab(x, y) : ba(x, y));
+};

package/src/sdf/index.d.ts

@@ -0,0 +1,56 @@
+import type { Shape } from '../geometry/types.js';
+
+/** A signed distance field: (x, y) → distance, negative inside, positive outside. */
+export type Field = (x: number, y: number) => number;
+/** A point. */
+export type Pt = readonly number[];
+
+/** A disc. */
+export function sdCircle(cx: number, cy: number, r: number): Field;
+/** The distance to the segment a–b, and t (0 at a, 1 at b) where the nearest point lies. */
+export function segT(a: Pt, b: Pt, x: number, y: number): [number, number];
+/** The segment a–b with round ends, w wide. */
+export function sdCapsule(a: Pt, b: Pt, w: number): Field;
+/** A round-ended stroke along a polyline, w wide (or w(t) along the run). */
+export function sdPath(pts: readonly Pt[], w: number | ((t: number) => number)): Field;
+/** Points along an arc from a0 to a1 degrees (y down), n + 1 of them (n = 48). */
+export function arcPts(cx: number, cy: number, r: number, a0: number, a1: number, n?: number): [number, number][];
+/** A rounded box centred on (cx, cy). */
+export function sdBox(cx: number, cy: number, w: number, h: number, r?: number): Field;
+/** An ellipse turned deg, as a scaled disc (approximate). */
+export function sdEllipse(cx: number, cy: number, rx: number, ry: number, deg?: number): Field;
+/** A ring of centre-line radius r and width w. */
+export function sdRing(cx: number, cy: number, r: number, w: number): Field;
+/** A polygon, exact. */
+export function sdPoly(pts: readonly Pt[]): Field;
+
+/** A band w wide along a field's zero line. */
+export function shell(f: Field, w: number): Field;
+/** A field turned deg about (cx, cy) (256, 256). */
+export function turn(f: Field, deg: number, cx?: number, cy?: number): Field;
+/** A field grown (d > 0) or shrunk (d < 0). */
+export function offset(f: Field, d: number): Field;
+/** The polynomial smooth minimum of two distances, blend k. */
+export function smin2(a: number, b: number, k: number): number;
+/** A smooth union, blend k. */
+export function smin(k: number, ...fs: Field[]): Field;
+/** A smooth intersection, blend k. */
+export function smax(k: number, ...fs: Field[]): Field;
+/** a minus b, the cut's edges softened by k. */
+export function ssub(k: number, a: Field, b: Field): Field;
+/** A sharp union. */
+export function fmin(...fs: Field[]): Field;
+/** A sharp intersection. */
+export function fmax(...fs: Field[]): Field;
+/** a minus b, sharp. */
+export function fsub(a: Field, b: Field): Field;
+
+/** A band g wide cut along each line (a list of points), edges crisp. */
+export function gapCut(f: Field, lines: readonly (readonly Pt[])[], g: number): Field;
+/** front laid over back, cut free of it by the gap. */
+export function fover(back: Field, front: Field, g: number): Field;
+/** a over b where aOver holds, b over a elsewhere. */
+export function flink(a: Field, b: Field, g: number, aOver: (x: number, y: number) => boolean): Field;
+
+/** A field's zero contour traced into a kit shape (marching squares, step h = 1, over −64…576). */
+export function shapeOf(f: Field, area?: { h?: number; x0?: number; y0?: number; x1?: number; y1?: number }): Shape;

package/src/sdf/index.js

@@ -0,0 +1,12 @@
+/**
+ * @module @logomarks/core/sdf
+ *
+ * Shapes drawn as signed distance fields and traced to polygons, so unions melt into each other with real fillets
+ * (a smooth minimum) instead of meeting at a crease. A field is (x, y) → distance, negative inside, on the 512 canvas.
+ * Build fields, combine them (smin, smax, ssub, fmin, fmax, fsub), cut the house gap (gapCut, fover, flink), then
+ * shapeOf() traces the result into a kit shape for the usual booleans and fit.
+ */
+export { sdCircle, segT, sdCapsule, sdPath, arcPts, sdBox, sdEllipse, sdRing, sdPoly } from './fields.js';
+export { shell, turn, offset, smin2, smin, smax, ssub, fmin, fmax, fsub } from './ops.js';
+export { gapCut, fover, flink } from './gap.js';
+export { shapeOf } from './trace.js';

package/src/sdf/ops.js

@@ -0,0 +1,102 @@
+/**
+ * Combining and changing fields: smooth and sharp unions, intersections and cuts, turns, offsets and outlines.
+ */
+
+/**
+ * A band along a field's zero line: any outline turned into a ring of width w.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {number} w The band's width.
+ * @returns {import('./index.js').Field} The band.
+ */
+export const shell = (f, w) => (x, y) => Math.abs(f(x, y)) - w / 2;
+
+/**
+ * A field turned about a point.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {number} deg The turn, in degrees (clockwise on the y-down canvas).
+ * @param {number} [cx] The pivot (256).
+ * @param {number} [cy] The pivot (256).
+ * @returns {import('./index.js').Field} The turned field.
+ */
+export const turn = (f, deg, cx = 256, cy = 256) => {
+	const a = (-deg * Math.PI) / 180, c = Math.cos(a), s = Math.sin(a);
+	return (x, y) => f(cx + (x - cx) * c - (y - cy) * s, cy + (x - cx) * s + (y - cy) * c);
+};
+
+/**
+ * A field grown (d > 0) or shrunk (d < 0). Shrinking a polygon by k and growing it back rounds its convex corners to k.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {number} d How far.
+ * @returns {import('./index.js').Field} The field, offset.
+ */
+export const offset = (f, d) => (x, y) => f(x, y) - d;
+
+/**
+ * The polynomial smooth minimum of two distances: a union whose seam melts into a fillet about k wide.
+ *
+ * @param {number} a One distance.
+ * @param {number} b The other.
+ * @param {number} k The blend (0 for a sharp minimum).
+ * @returns {number} The blended distance.
+ */
+export const smin2 = (a, b, k) => {
+	if (k <= 0) return Math.min(a, b);
+	const h = Math.max(k - Math.abs(a - b), 0) / k;
+	return Math.min(a, b) - (h * h * k) / 4;
+};
+
+/**
+ * A smooth union.
+ *
+ * @param {number} k The blend.
+ * @param {...import('./index.js').Field} fs The fields.
+ * @returns {import('./index.js').Field} Their union, seams filleted.
+ */
+export const smin = (k, ...fs) => (x, y) => fs.reduce((m, f, i) => (i ? smin2(m, f(x, y), k) : f(x, y)), 0);
+
+/**
+ * A smooth intersection.
+ *
+ * @param {number} k The blend.
+ * @param {...import('./index.js').Field} fs The fields.
+ * @returns {import('./index.js').Field} Their intersection, edges softened.
+ */
+export const smax = (k, ...fs) => (x, y) => -fs.reduce((m, f, i) => (i ? smin2(m, -f(x, y), k) : -f(x, y)), 0);
+
+/**
+ * One field cut by another, the cut's edges softened.
+ *
+ * @param {number} k The blend.
+ * @param {import('./index.js').Field} a The field.
+ * @param {import('./index.js').Field} b What is cut out of it.
+ * @returns {import('./index.js').Field} a minus b.
+ */
+export const ssub = (k, a, b) => (x, y) => -smin2(-a(x, y), b(x, y), k);
+
+/**
+ * A sharp union.
+ *
+ * @param {...import('./index.js').Field} fs The fields.
+ * @returns {import('./index.js').Field} Their union.
+ */
+export const fmin = (...fs) => (x, y) => Math.min(...fs.map((f) => f(x, y)));
+
+/**
+ * A sharp intersection.
+ *
+ * @param {...import('./index.js').Field} fs The fields.
+ * @returns {import('./index.js').Field} Their intersection.
+ */
+export const fmax = (...fs) => (x, y) => Math.max(...fs.map((f) => f(x, y)));
+
+/**
+ * A sharp cut.
+ *
+ * @param {import('./index.js').Field} a The field.
+ * @param {import('./index.js').Field} b What is cut out of it.
+ * @returns {import('./index.js').Field} a minus b.
+ */
+export const fsub = (a, b) => (x, y) => Math.max(a(x, y), -b(x, y));

package/src/sdf/trace.js

@@ -0,0 +1,90 @@
+/**
+ * Tracing a field into a kit shape: marching squares on its zero contour, so the kit's booleans work on the result.
+ */
+import { X } from '../geometry/index.js';
+
+/**
+ * A closed ring with the points that lie (within tol) on the line through their neighbours dropped.
+ *
+ * @param {number[][]} r The ring.
+ * @param {number} [tol] How far off the line a point must be to stay (0.04).
+ * @returns {number[][]} The ring, thinned.
+ */
+const thin = (r, tol = 0.04) => {
+	const out = [];
+	for (let i = 0; i < r.length; i++) {
+		const a = out.length ? out[out.length - 1] : r[r.length - 1], p = r[i], b = r[(i + 1) % r.length];
+		const L = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1e-9, d = Math.abs((b[0] - a[0]) * (a[1] - p[1]) - (a[0] - p[0]) * (b[1] - a[1])) / L;
+		if (d > tol) out.push(p);
+	}
+	return out;
+};
+
+/**
+ * A field's zero contour (inside < 0) as a kit shape: marching squares on a grid of step h with linear interpolation,
+ * saddles split by the cell's mean, rings XORed so holes come out as holes.
+ *
+ * @param {import('./index.js').Field} f The field.
+ * @param {{ h?: number, x0?: number, y0?: number, x1?: number, y1?: number }} [area] The grid step (1) and the area
+ *   traced (−64 to 576 each way).
+ * @returns {import('../geometry/types.js').Shape} The shape (empty when the field is nowhere inside).
+ */
+export function shapeOf(f, { h = 1, x0 = -64, y0 = -64, x1 = 576, y1 = 576 } = {}) {
+	const nx = Math.ceil((x1 - x0) / h) + 1, ny = Math.ceil((y1 - y0) / h) + 1, v = new Float64Array(nx * ny);
+	for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) {
+		let d = f(x0 + i * h, y0 + j * h);
+		if (d === 0) d = 1e-9;
+		v[j * nx + i] = d;
+	}
+	const V = (/** @type {number} */ i, /** @type {number} */ j) => v[j * nx + i];
+	/** @type {Map<string, number[]>} */ const P = new Map();
+	/** @type {Map<string, string[]>} */ const adj = new Map();
+	// an edge point, keyed by its grid edge: 'h' runs from (i, j) to (i+1, j), 'v' from (i, j) to (i, j+1)
+	const pt = (/** @type {'h' | 'v'} */ kind, /** @type {number} */ i, /** @type {number} */ j) => {
+		const key = `${kind}${i},${j}`;
+		if (!P.has(key)) {
+			const a = V(i, j), b = kind === 'h' ? V(i + 1, j) : V(i, j + 1), t = a / (a - b);
+			P.set(key, kind === 'h' ? [x0 + (i + t) * h, y0 + j * h] : [x0 + i * h, y0 + (j + t) * h]);
+		}
+		return key;
+	};
+	const link = (/** @type {string} */ a, /** @type {string} */ b) => {
+		(adj.get(a) || adj.set(a, []).get(a))?.push(b);
+		(adj.get(b) || adj.set(b, []).get(b))?.push(a);
+	};
+	for (let j = 0; j < ny - 1; j++) for (let i = 0; i < nx - 1; i++) {
+		const tl = V(i, j) < 0, tr = V(i + 1, j) < 0, br = V(i + 1, j + 1) < 0, bl = V(i, j + 1) < 0;
+		const c = +tl * 8 + +tr * 4 + +br * 2 + +bl;
+		if (c === 0 || c === 15) continue;
+		const T = () => pt('h', i, j), B = () => pt('h', i, j + 1), L = () => pt('v', i, j), R = () => pt('v', i + 1, j);
+		const mid = (V(i, j) + V(i + 1, j) + V(i + 1, j + 1) + V(i, j + 1)) / 4 < 0;
+		switch (c) {
+			case 1: case 14: link(L(), B()); break;
+			case 2: case 13: link(B(), R()); break;
+			case 3: case 12: link(L(), R()); break;
+			case 4: case 11: link(T(), R()); break;
+			case 6: case 9: link(T(), B()); break;
+			case 7: case 8: link(L(), T()); break;
+			case 5: if (mid) { link(L(), T()); link(B(), R()); } else { link(T(), R()); link(L(), B()); } break;
+			case 10: if (mid) { link(T(), R()); link(L(), B()); } else { link(L(), T()); link(B(), R()); } break;
+		}
+	}
+	const seen = new Set(), rings = [];
+	for (const start of adj.keys()) {
+		if (seen.has(start)) continue;
+		const ring = [];
+		/** @type {string | null} */ let prev = null;
+		/** @type {string | undefined} */ let cur = start;
+		while (cur && !seen.has(cur)) {
+			seen.add(cur);
+			ring.push(/** @type {number[]} */ (P.get(cur)));
+			const nb = /** @type {string[]} */ (adj.get(cur));
+			const nxt = nb[0] === prev ? nb[1] : nb[0];
+			prev = cur;
+			cur = nxt;
+		}
+		const r = thin(ring);
+		if (r.length >= 3) rings.push(r);
+	}
+	return rings.length ? X(...rings.map((r) => [[...r, r[0]]])) : [];
+}

package/src/skill/bundle.js

@@ -14,7 +14,7 @@ const SRC = new URL('../', import.meta.url);
 
 /** The geometry kit's modules, in dependency order. */
 const KIT = ['geometry/core.js', 'geometry/booleans.js', 'geometry/polygon.js', 'geometry/random.js', 'geometry/shapes.js', 'geometry/stroke.js',
-	'geometry/path.js', 'geometry/offset.js', 'geometry/iso.js', 'geometry/modular.js', 'geometry/badges.js', 'geometry/letters.js',
+	'geometry/path.js', 'geometry/offset.js', 'geometry/mitre.js', 'geometry/iso.js', 'geometry/modular.js', 'geometry/badges.js', 'geometry/letters.js',
 	'svg/path.js', 'svg/shapes.js', 'svg/rings.js', 'svg/nonzero.js', 'svg/shape.js', 'geometry/glitch.js', 'geometry/needle.js'];
 
 /** The fit's modules, in dependency order. */