@logomarks/core 0.1.9 → 0.1.11

package/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to `@logomarks/core` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.11] — 2026-11-15
+
+### Added
+
+- **Exact mitred offsets in `/geometry`:** `mitreOffset(pts, d)` (an open polyline's parallel, corners mitred), `mitreBand(pts, w)` (a solid band along it, ends square) and `offsetPolygon(pts, d)` (a closed polygon grown or shrunk, either winding). The Logomarks tools had them five ways; these are the same arithmetic as the ones there.
+- **Span tiles in `/parts`:** `spanGrid`, `spanTile`, `evenGrid`, `evenCell` and `longSide`: a tile grid where one token may span a block of cells (`tok^2`, `tok>2`, `tok_2`, `tok@2x3`), from the tools' span parts.
+- **Pixel editions in `/parts`:** `rasterRows`, `rasterMark` (a drawn mark sampled into rows of text, `#` a pixel, on spans or square pixels with a phase and hand fixes) and `insideShape` (even-odd point in shape), from the tools' dither parts.
+- **Golden tests:** a hash of a drawing by every geometry and parts export the other tests don't reach (`tests/golden.json`; refresh with `GOLDEN=update npm test`).
+
+### Fixed
+
+- `nest()`'s type: `cut` is a function `(w, h, side) => number`, as the code has always read it (the type said a number would do).
+
+Proved on the Logomarks generators: the nineteen drawn with span tiles or pixel rasters, the ten drawn with the tools' mitred offsets and the twelve drawn with distance fields all redraw byte-identical with these in place of their local copies.
+
+## [0.1.10] — 2026-11-15
+
+### Fixed
+
+- **`fitMark()` no longer moves a mark that's already fitted.** A finished mark's points sit on the 0.1 grid, so it measured a hair off 448 and was scaled by that hair: points tipped over a rounding edge and arc radii, rounded down, lost 0.1 on every refit. Of the 5,255 Logomarks marks, 24 changed on a refit and 16 never settled (Trio 52.9 → 52.8 → 52.7 …). A mark on the 512 canvas whose longest side and centre are within `REFIT_TOLERANCE` (0.25) keeps its scale and position, and an arc radius within `ARC_SLACK` (0.005) of the next 0.1 step is taken as it. Every live mark now refits to the same numbers (four older files only have their spacing normalised, once). Semicircles still round down.
+- `runIndustry()`'s `fam:` also takes the family as passed, so `fam:Letters · Latch` builds a batch that passes whole families as its trades (it built none).
+
+### Added
+
+- **`/batch`: running a generator (Node).** `runBatch(batch, marks, options)` draws each mark seeded by its name (and puts `Math.random` back), with `exact()` so the gap is 22 once fitted, into `<workdir>/newraw<N>/`, and writes `_names.json`, `_families.json`, `_styles.json`, and `_variants.json` / `_pairs.json` when used; held marks are left out, and re-running one mark keeps every sidecar whole. Also `batchArgs` and `selected` (`"Name,Name"`, `fam:`, `pair:` and the generator's own modes), `sidecars`, `rawSvg`, `withSeed`, `slug` (the one slug: no hyphen at either end) and `sourceMark` (an edition's source: live first, then the queue; `LOGOMARKS_SVG`, `LOGOMARKS_QUEUE`). See [docs/api.md](docs/api.md#batches).
+- **`/sdf`: signed distance fields**, from the Logomarks tools' Y2K parts: the fields (`sdCircle`, `sdCapsule`, `sdPath`, `sdBox`, `sdEllipse`, `sdRing`, and the new exact `sdPoly`), smooth and sharp combining (`smin`, `smax`, `ssub`, `fmin`, and the new `fmax` and `fsub`), the gap (`gapCut`, `fover`, `flink`) and `shapeOf`, which traces a field into a kit shape. The twelve generators drawn with them redraw byte-identical on it. See [docs/api.md](docs/api.md#distance-fields).
+
 ## [0.1.9] — 2026-11-08
 
 ### Added

package/README.md

@@ -25,13 +25,15 @@ checkFit(mark).problems;              // []
 
 - `/geometry`: shapes and real booleans, strokes, tracks, iso solids, badges and letter skeletons
 - `/svg`: one SVG path parser, filled shapes, bounds and rings
-- `/fit`: the 448 fit and its check
+- `/fit`: the 448 fit and its check (refitting a fitted mark gives the same file)
 - `/analyse`: specks, slivers and pin-holes, gap and stroke widths, shape tags
 - `/similar`: outline and letter signatures, IoU and nearest marks
 - `/raster`: scanline fill, components, distance transform
 - `/edit`: the studio's shape edits (weight, soften, gap, detail) and pixelate
+- `/sdf`: shapes as signed distance fields, smooth unions and exact gap cuts, traced to kit shapes
 - `/stitch`: a mark planned as machine embroidery (fill, satin and border stitches), for a renderer to draw as thread
 - `/parts`: the parts the industry symbols are built from (Node)
+- `/batch`: a generator's runner: seeded marks, the sidecars, the command line, `slug` (Node)
 - `logomarks-skill <dir>`: writes the design skill's `kit.mjs` and `fit.mjs`
 
 Every export, repeatable drawings and the skill scripts: [API](https://github.com/Logomarks/core/blob/main/docs/api.md).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@logomarks/core",
-  "version": "0.1.9",
-  "description": "Geometry, SVG reading, fitting, analysis and similarity for logomarks on a 512 grid: the kit the Logomarks set is drawn with (shapes, real booleans, strokes, tracks, iso solids, badges, letter skeletons), one SVG path parser, the 448 fit, speck and shape-tag analysis, outline signatures, stitch plans for embroidery, and the industry-symbol parts.",
+  "version": "0.1.11",
+  "description": "Geometry, SVG reading, fitting, analysis and similarity for logomarks on a 512 grid: the kit the Logomarks set is drawn with (shapes, real booleans, strokes, tracks, iso solids, badges, letter skeletons), one SVG path parser, the 448 fit, speck and shape-tag analysis, outline signatures, signed distance fields traced to shapes, stitch plans for embroidery, the industry-symbol parts and the batch runner generators use.",
   "type": "module",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -22,6 +22,11 @@
       "import": "./src/parts/index.js",
       "default": "./src/parts/index.js"
     },
+    "./batch": {
+      "types": "./src/batch/index.d.ts",
+      "import": "./src/batch/index.js",
+      "default": "./src/batch/index.js"
+    },
     "./svg": {
       "types": "./src/svg/index.d.ts",
       "import": "./src/svg/index.js",
@@ -47,6 +52,11 @@
       "import": "./src/similar/index.js",
       "default": "./src/similar/index.js"
     },
+    "./sdf": {
+      "types": "./src/sdf/index.d.ts",
+      "import": "./src/sdf/index.js",
+      "default": "./src/sdf/index.js"
+    },
     "./edit": {
       "types": "./src/edit/index.d.ts",
       "import": "./src/edit/index.js",
@@ -91,7 +101,9 @@
     "fit",
     "similarity",
     "embroidery",
-    "satin-stitch"
+    "satin-stitch",
+    "signed-distance-field",
+    "sdf"
   ],
   "author": "David Sherlock",
   "license": "MIT",

package/src/batch/args.d.ts

@@ -0,0 +1,18 @@
+/** What a generator was asked to build. */
+export interface BatchArgs {
+	/** Where the batch's `newraw<N>/` folder goes. */
+	workdir: string;
+	/** Only these marks, by name; null for no name list. */
+	names: string[] | null;
+	/** Only this family's marks; null for any. */
+	family: string | null;
+	/** Only the monograms of these letter pairs; null for any. */
+	pairs: string[] | null;
+	/** A mode the generator handles itself (one of its `modes`); null for none. */
+	mode: string | null;
+}
+
+/** The work folder and the selection from `node genbatchN.mjs <workdir> ["Name,Name" | "fam:…" | "pair:DS,JS" | mode]`. */
+export function batchArgs(argv?: readonly string[], options?: { modes?: readonly string[] }): BatchArgs;
+/** Whether a mark is in the selection (in no mark when a mode was asked for). */
+export function selected(args: BatchArgs, name: string, mark: { family?: string; pair?: string }): boolean;

package/src/batch/args.js

@@ -0,0 +1,44 @@
+/**
+ * A generator's command line: `node genbatchN.mjs <workdir> [what]`.
+ */
+
+/**
+ * What a generator was asked to build. `what` is one of:
+ * - nothing: every mark;
+ * - `"Name,Name"`: those marks;
+ * - `"fam:<family>"`: one family's marks;
+ * - `"pair:DS,JS"`: the monograms of those letter pairs;
+ * - one of `modes` (e.g. `"matrix"`): a mode the generator handles itself.
+ *
+ * @param {readonly string[]} [argv] The arguments after the script (default `process.argv.slice(2)`).
+ * @param {{ modes?: readonly string[] }} [options] The generator's own modes.
+ * @returns {import('./args.js').BatchArgs} The work folder and the selection.
+ * @throws {Error} When there's no work folder.
+ */
+export function batchArgs(argv = process.argv.slice(2), { modes = [] } = {}) {
+	const [workdir, what = ''] = argv;
+	if (!workdir) throw new Error('usage: node genbatchN.mjs <workdir> ["Name,Name" | "fam:<family>" | "pair:DS,JS"]');
+	const list = (/** @type {string} */ s) => s.split(',').map((x) => x.trim()).filter(Boolean);
+	return {
+		workdir,
+		names: what && !/^(fam|pair):/.test(what) && !modes.includes(what) ? list(what) : null,
+		family: what.startsWith('fam:') ? what.slice(4).trim() : null,
+		pairs: what.startsWith('pair:') ? list(what.slice(5)) : null,
+		mode: modes.includes(what) ? what : null,
+	};
+}
+
+/**
+ * Whether a mark is in the selection.
+ *
+ * @param {import('./args.js').BatchArgs} args The selection.
+ * @param {string} name The mark's name.
+ * @param {{ family?: string, pair?: string }} mark Its family and letter pair.
+ * @returns {boolean} True when it should be built.
+ */
+export function selected(args, name, mark) {
+	if (args.names) return args.names.includes(name);
+	if (args.family) return mark.family === args.family;
+	if (args.pairs) return !!mark.pair && args.pairs.includes(mark.pair);
+	return !args.mode;
+}

package/src/batch/index.d.ts

@@ -0,0 +1,7 @@
+export { slug } from './slug.js';
+export { batchArgs, selected } from './args.js';
+export type { BatchArgs } from './args.js';
+export { sourceMark } from './source.js';
+export type { SourceMark } from './source.js';
+export { runBatch, sidecars, rawSvg, withSeed } from './run.js';
+export type { BatchMark, BatchOptions, BatchResult } from './run.js';

package/src/batch/index.js

@@ -0,0 +1,10 @@
+/**
+ * @module @logomarks/core/batch
+ *
+ * Running a generator (Node only): the command line, a mark's slug, reading an existing mark for an edition, and the
+ * runner that draws a batch seeded per mark and writes the sidecars the export and the review page read.
+ */
+export { slug } from './slug.js';
+export { batchArgs, selected } from './args.js';
+export { sourceMark } from './source.js';
+export { runBatch, sidecars, rawSvg, withSeed } from './run.js';

package/src/batch/run.d.ts

@@ -0,0 +1,53 @@
+import type { Shape } from '../geometry/types.js';
+import type { BatchArgs } from './args.js';
+
+/** One mark in a batch. */
+export interface BatchMark {
+	/** Its family, e.g. "Letters · Latch" (`_families.json`; `fam:` selects by it). */
+	family: string;
+	/** Its style, e.g. "Bold" (`_styles.json`). */
+	style?: string;
+	/** The live mark it is an edition or variation of, by slug (`_variants.json`). */
+	variantOf?: string;
+	/** Its letter pair, for monograms (`_pairs.json`; `pair:` selects by it). */
+	pair?: string;
+	/** The drawing: takes the gap (or nothing with `gap: false`) and returns the mark. */
+	build: (g: number) => Shape;
+}
+
+/** How a batch is drawn. */
+export interface BatchOptions {
+	/** Draw each build with the gap and exact(), so the gap is 22 once fitted (default true). */
+	gap?: boolean;
+	/** Drop the pieces under `piece` and the holes under `hole` square units after drawing. */
+	despeck?: { piece?: number; hole?: number };
+	/** Names held back for a later drop: built by nobody, left out of the sidecars. */
+	held?: readonly string[];
+	/** The command line (default `process.argv.slice(2)`). */
+	argv?: readonly string[];
+	/** The generator's own modes (e.g. "matrix"): asking for one builds no mark here. */
+	modes?: readonly string[];
+	/** Where progress goes (default console.log). */
+	log?: (line: string) => void;
+}
+
+/** What a batch run did. */
+export interface BatchResult {
+	/** The `newraw<N>` folder. */
+	out: string;
+	/** The command line it read. */
+	args: BatchArgs;
+	/** The names it drew. */
+	built: string[];
+	/** The names that threw, and why. */
+	failed: { name: string; error: string }[];
+}
+
+/** A raw mark's file: one even-odd path on the 512 canvas. */
+export function rawSvg(shape: Shape): string;
+/** Runs a drawing with Math.random seeded by the name, then puts Math.random back. */
+export function withSeed<T>(name: string, draw: () => T): T;
+/** The batch's sidecar files: file name → contents (`_names`, `_families`, `_styles`, and `_variants` / `_pairs` when used). */
+export function sidecars(marks: Readonly<Record<string, BatchMark>>): Record<string, unknown>;
+/** Draws a batch into `<workdir>/newraw<batch>/`, seeded per mark, and writes its sidecars. */
+export function runBatch(batch: number, marks: Readonly<Record<string, BatchMark>>, options?: BatchOptions): BatchResult;

package/src/batch/run.js

@@ -0,0 +1,92 @@
+/**
+ * The batch runner: draws a generator's marks into `<workdir>/newraw<N>/` with the sidecars the export and the review
+ * page read (Node only: it writes files).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { seeded, toPath } from '../geometry/index.js';
+import { exact, despeckShape } from '../parts/frame.js';
+import { batchArgs, selected } from './args.js';
+import { slug } from './slug.js';
+
+/**
+ * A finished raw mark: one even-odd path on the 512 canvas (normalize fits it).
+ *
+ * @param {import('../geometry/types.js').Shape} shape The mark.
+ * @returns {string} The SVG file's text.
+ */
+export const rawSvg = (shape) => `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" fill="currentColor"><path fill-rule="evenodd" d="${toPath(shape)}"/></svg>\n`;
+
+/**
+ * Runs a drawing with Math.random seeded by the mark's name, putting Math.random back afterwards, so the mark is the
+ * same on every run whatever else ran first.
+ *
+ * @template T
+ * @param {string} name The mark's name (the seed).
+ * @param {() => T} draw The drawing.
+ * @returns {T} What it drew.
+ */
+export function withSeed(name, draw) {
+	const random = Math.random;
+	Math.random = seeded(name);
+	try { return draw(); } finally { Math.random = random; }
+}
+
+/**
+ * The sidecars for a batch's marks: `_names.json` (how normalize finds the batch), `_families.json` and `_styles.json`,
+ * and `_variants.json` and `_pairs.json` when any mark has a `variantOf` or a `pair`. Each maps slug → value.
+ *
+ * @param {Readonly<Record<string, import('./run.js').BatchMark>>} marks The batch's marks, by name.
+ * @returns {Record<string, unknown>} File name → contents.
+ */
+export function sidecars(marks) {
+	const entries = Object.entries(marks);
+	const map = (/** @type {keyof import('./run.js').BatchMark} */ key) =>
+		Object.fromEntries(entries.filter(([, m]) => m[key] !== undefined).map(([name, m]) => [slug(name), m[key]]));
+	/** @type {Record<string, unknown>} */
+	const files = { '_names.json': Object.keys(marks), '_families.json': map('family'), '_styles.json': map('style') };
+	for (const [key, file] of /** @type {const} */ ([['variantOf', '_variants.json'], ['pair', '_pairs.json']])) {
+		const m = map(key);
+		if (Object.keys(m).length) files[file] = m;
+	}
+	return files;
+}
+
+/**
+ * Draws a batch: every mark (or the ones the command line names: `"Name,Name"`, `"fam:<family>"`, `"pair:DS,JS"`)
+ * into `<workdir>/newraw<batch>/<slug>.svg`, seeded per mark so a re-run is byte-identical, then writes the sidecars
+ * for every mark that isn't held (so re-running one mark never trims them). A mark that throws is reported and the
+ * rest still drawn.
+ *
+ * With `gap: true` (the default) each build takes the gap and is drawn with exact(), so its gap is 22 once fitted;
+ * with `gap: false` it takes nothing. `despeck` drops the pieces and holes a boolean left under those areas.
+ *
+ * @param {number} batch The batch number.
+ * @param {Readonly<Record<string, import('./run.js').BatchMark>>} marks The marks, by name.
+ * @param {import('./run.js').BatchOptions} [options] The drawing and the command line.
+ * @returns {import('./run.js').BatchResult} What was built and what failed.
+ */
+export function runBatch(batch, marks, { gap = true, despeck, held = [], argv, modes, log = console.log } = {}) {
+	const args = batchArgs(argv, { modes });
+	const out = path.join(args.workdir, `newraw${batch}`);
+	fs.mkdirSync(out, { recursive: true });
+	const live = Object.fromEntries(Object.entries(marks).filter(([name]) => !held.includes(name)));
+	/** @type {string[]} */ const built = [];
+	/** @type {{ name: string, error: string }[]} */ const failed = [];
+	for (const [name, mark] of Object.entries(live)) {
+		if (!selected(args, name, mark)) continue;
+		try {
+			// exact() redraws up to three times to land the gap: each attempt starts from the same seed
+			let shape = withSeed(name, () => (gap ? exact(mark.build, () => { Math.random = seeded(name); }) : mark.build(0)));
+			if (despeck) shape = despeckShape(shape, despeck.piece, despeck.hole);
+			fs.writeFileSync(path.join(out, `${slug(name)}.svg`), rawSvg(shape));
+			built.push(name);
+		} catch (e) {
+			failed.push({ name, error: e instanceof Error ? e.message : String(e) });
+			log(`FAIL ${name}: ${failed[failed.length - 1].error.slice(0, 160)}`);
+		}
+	}
+	for (const [file, data] of Object.entries(sidecars(live))) fs.writeFileSync(path.join(out, file), JSON.stringify(data, null, 1));
+	log(`built ${built.length} of ${Object.keys(live).length}${held.length ? ` (${held.length} held)` : ''} into ${out}`);
+	return { out, args, built, failed };
+}

package/src/batch/slug.d.ts

@@ -0,0 +1,2 @@
+/** A mark's slug from its name: lower case, runs of anything but a–z and 0–9 one hyphen, none at either end. */
+export function slug(name: string): string;

package/src/batch/slug.js

@@ -0,0 +1,12 @@
+/**
+ * A mark's slug: the name its file, its page and every sidecar are keyed by.
+ */
+
+/**
+ * A mark's slug from its name: lower case, each run of anything but a–z and 0–9 one hyphen, no hyphen at either end
+ * ("Ship's Wheel" → "ship-s-wheel", "Tree (r)" → "tree-r"). The site, normalize and the review tools all use this one.
+ *
+ * @param {string} name The mark's name.
+ * @returns {string} Its slug.
+ */
+export const slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');

package/src/batch/source.d.ts

@@ -0,0 +1,12 @@
+/** An existing mark read for an edition or a variation. */
+export interface SourceMark {
+	/** The file's text. */
+	svg: string;
+	/** Where it was read from. */
+	file: string;
+	/** The live set, or the review queue. */
+	from: 'live' | 'queue';
+}
+
+/** An existing mark: the live file first, then the queue's `<prefix>NNN-<slug>.svg` (`LOGOMARKS_SVG` / `LOGOMARKS_QUEUE` replace the folders); null when it's in neither. */
+export function sourceMark(slug: string, folders: { live: string; queue?: string }): SourceMark | null;

package/src/batch/source.js

@@ -0,0 +1,23 @@
+/**
+ * Reading a mark that already exists, for editions and variations drawn from it (Node only).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * An existing mark's SVG: the live file first, then the review queue, where a mark approved for the next drop waits
+ * as `<prefix>NNN-<slug>.svg`. `LOGOMARKS_SVG` and `LOGOMARKS_QUEUE` replace the two folders, so a proof can read a
+ * snapshot while an export rewrites them.
+ *
+ * @param {string} slug The mark's slug.
+ * @param {{ live: string, queue?: string }} folders The live svg folder and the queue folder.
+ * @returns {import('./source.js').SourceMark | null} The file, or null when it's in neither.
+ */
+export function sourceMark(slug, { live, queue }) {
+	const liveDir = process.env.LOGOMARKS_SVG || live, queueDir = process.env.LOGOMARKS_QUEUE || queue;
+	const file = path.join(liveDir, `${slug}.svg`);
+	if (fs.existsSync(file)) return { svg: fs.readFileSync(file, 'utf8'), file, from: 'live' };
+	if (!queueDir || !fs.existsSync(queueDir)) return null;
+	const queued = fs.readdirSync(queueDir).find((f) => f.replace(/^[a-z]+\d+-/, '') === `${slug}.svg`);
+	return queued ? { svg: fs.readFileSync(path.join(queueDir, queued), 'utf8'), file: path.join(queueDir, queued), from: 'queue' } : null;
+}

package/src/fit/index.d.ts

@@ -21,6 +21,10 @@ export const CANVAS: 512;
 export const FIT: 448;
 /** How far size, centre and edges may drift: 0.5. */
 export const FIT_TOLERANCE: 0.5;
+/** How far an already-fitted mark may sit from 448 and the centre and keep its scale on a refit: 0.25. */
+export const REFIT_TOLERANCE: 0.25;
+/** How close an arc radius may sit below the next 0.1 step and still be taken as it: 0.005. */
+export const ARC_SLACK: 0.005;
 /** Markup a finished mark must not contain. */
 export const FORBIDDEN_MARKUP: RegExp;
 /** A mark fitted to the standard; throws when the file has no filled shapes. */

package/src/fit/index.js

@@ -16,6 +16,10 @@ export const CANVAS = 512;
 export const FIT = 448;
 /** How far size, centre and canvas edges may drift before a check fails. */
 export const FIT_TOLERANCE = 0.5;
+/** How far a mark already on the 512 canvas may sit from 448 and the centre and still keep its scale and position on a refit. */
+export const REFIT_TOLERANCE = 0.25;
+/** How close (in units) an arc radius may sit below the next 0.1 step and still be taken as it. */
+export const ARC_SLACK = 0.005;
 /** Markup a finished mark must not contain: flatten to filled paths. */
 export const FORBIDDEN_MARKUP = /<(g|style|mask|clipPath|use|text|image)\b|transform=|stroke=/;
 
@@ -31,7 +35,9 @@ const snap = (v) => Math.round(v * 10) / 10;
  * Segments as compact relative path data. Points are snapped to the 0.1 grid
  * first and the relative steps taken between snapped points, so rounding never
  * drifts. Arc radii are rounded down: a semicircle stays exact (a radius a
- * hair too big would bulge the arc).
+ * hair too big would bulge the arc). A radius within ARC_SLACK of the next
+ * step up is taken as that step, so refitting a fitted mark (its scale a hair
+ * under 1) keeps its radii instead of shaving 0.1 off each time.
  *
  * @param {readonly import('./path.js').Segment[]} segs The segments.
  * @param {(x: number, y: number) => number[]} f Where each point goes.
@@ -60,7 +66,7 @@ function serialise(segs, f, k) {
 			cx = sx = x; cy = sy = y;
 		} else if (s[0] === 'A') {
 			const [x, y] = f(s[6], s[7]).map(snap);
-			const r = (/** @type {number} */ v) => r1(Math.floor(v * k * 10) / 10);
+			const r = (/** @type {number} */ v) => r1(Math.floor(v * k * 10 + ARC_SLACK * 10) / 10);
 			d += cmd('a', `${r(s[1])} ${r(s[2])} ${r1(s[3])} ${s[4] ? 1 : 0} ${s[5] ? 1 : 0} ${rel(x, y)}`);
 			cx = x; cy = y;
 		} else {
@@ -74,7 +80,24 @@ function serialise(segs, f, k) {
 }
 
 /**
- * A mark fitted to the standard.
+ * Whether a mark is already fitted: on the 512 canvas, its longest side and centre within REFIT_TOLERANCE. Its
+ * points sit on the 0.1 grid, so it measures a hair off 448; scaling it by that hair would tip points and arc radii
+ * over a rounding edge, so a refit keeps it as it is.
+ *
+ * @param {string} svg The file's text.
+ * @param {{ x: number, y: number, w: number, h: number }} b Its outline's box.
+ * @returns {boolean} True when it is.
+ */
+function isFitted(svg, b) {
+	const vb = viewBox(svg);
+	if (!vb || vb.join(' ') !== `0 0 ${CANVAS} ${CANVAS}`) return false;
+	const near = (/** @type {number} */ a, /** @type {number} */ e) => Math.abs(a - e) <= REFIT_TOLERANCE;
+	return near(Math.max(b.w, b.h), FIT) && near(b.x + b.w / 2, CANVAS / 2) && near(b.y + b.h / 2, CANVAS / 2);
+}
+
+/**
+ * A mark fitted to the standard. A mark already fitted keeps its scale and position (see isFitted), so refitting a
+ * finished file gives the same file.
  *
  * @param {string} svg The file's text.
  * @returns {import('./index.js').Fitted} The fitted file and the box it had.
@@ -84,8 +107,9 @@ export function fitMark(svg) {
 	const all = shapes(svg);
 	if (!all.length) throw new Error('no filled shapes found');
 	const before = bounds(all);
-	const k = FIT / Math.max(before.w, before.h);
-	const tx = CANVAS / 2 - (before.x + before.w / 2) * k, ty = CANVAS / 2 - (before.y + before.h / 2) * k;
+	const fitted = isFitted(svg, before);
+	const k = fitted ? 1 : FIT / Math.max(before.w, before.h);
+	const tx = fitted ? 0 : CANVAS / 2 - (before.x + before.w / 2) * k, ty = fitted ? 0 : CANVAS / 2 - (before.y + before.h / 2) * k;
 	const f = (/** @type {number} */ x, /** @type {number} */ y) => [x * k + tx, y * k + ty];
 	const paths = all.map((s) => `<path${s.evenodd ? ' fill-rule="evenodd"' : ''} d="${serialise(s.segs, f, k)}"/>`).join('');
 	return { svg: `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${CANVAS} ${CANVAS}" fill="currentColor">${paths}</svg>\n`, before };

package/src/geometry/index.d.ts

@@ -16,6 +16,7 @@ export { signedArea, area, perimeter, ringBox, bbox, winding, dedupe, openRing,
 export { seeded } from './random.js';
 export { circle, ellipse, rect, regular, annulus, sector, arcBand, rotN, bar, ring, roundPoly, rr, lens, drop, squircle, pill, egg } from './shapes.js';
 export { stroke, weave, offsetPts, fillet, tracks, filletClosed, trackLoop, walk, balloon, linePts, arcPts, joinPts } from './stroke.js';
+export { mitreOffset, mitreBand, offsetPolygon } from './mitre.js';
 export { toPath, svg, write } from './path.js';
 export { grow, soften, grown, over, slices } from './offset.js';
 export { iso, cubes, isoPrism, isoBlock, isoRing, isoPile } from './iso.js';

package/src/geometry/index.js

@@ -9,6 +9,7 @@ export { signedArea, area, perimeter, ringBox, bbox, winding, dedupe, openRing,
 export { seeded } from './random.js';
 export { circle, ellipse, rect, regular, annulus, sector, arcBand, rotN, bar, ring, roundPoly, rr, lens, drop, squircle, pill, egg } from './shapes.js';
 export { stroke, weave, offsetPts, fillet, tracks, filletClosed, trackLoop, walk, balloon, linePts, arcPts, joinPts } from './stroke.js';
+export { mitreOffset, mitreBand, offsetPolygon } from './mitre.js';
 export { toPath, svg, write } from './path.js';
 export { grow, soften, grown, over, slices } from './offset.js';
 export { iso, cubes, isoPrism, isoBlock, isoRing, isoPile } from './iso.js';

package/src/geometry/mitre.d.ts

@@ -0,0 +1,8 @@
+import type { Point, Shape } from './types.js';
+
+/** An open polyline offset d to its left (y down), corners mitred so it runs exactly parallel; d < 0 goes right. */
+export function mitreOffset(pts: readonly (readonly number[])[], d: number): Point[];
+/** A solid band w wide along an open polyline, corners mitred, ends square. */
+export function mitreBand(pts: readonly (readonly number[])[], w: number): Shape;
+/** A closed polygon grown (d > 0) or shrunk (d < 0), corners mitred; either winding. */
+export function offsetPolygon(pts: readonly (readonly number[])[], d: number): Point[];

package/src/geometry/mitre.js

@@ -0,0 +1,64 @@
+/**
+ * Exact offsets with mitred corners: a polyline's parallel, a band along it, and a polygon grown or shrunk.
+ */
+import { poly } from './core.js';
+
+/**
+ * The unit left normal (y down) of the step a → b.
+ *
+ * @param {readonly number[]} a From.
+ * @param {readonly number[]} b To.
+ * @returns {number[]} The normal.
+ */
+const leftNormal = (a, b) => {
+	const v = [b[0] - a[0], b[1] - a[1]], l = Math.hypot(...v) || 1;
+	return [v[1] / l, -(v[0] / l)];
+};
+
+/**
+ * An open polyline offset to its left (y down) by d, every corner mitred, so the offset runs exactly parallel to it
+ * (d < 0 offsets to the right). The ends move square to their segments.
+ *
+ * @param {readonly (readonly number[])[]} pts The polyline.
+ * @param {number} d How far.
+ * @returns {number[][]} The offset polyline, a point for each point.
+ */
+export const mitreOffset = (pts, d) => pts.map((p, i) => {
+	const n1 = i > 0 ? leftNormal(pts[i - 1], p) : null, n2 = i < pts.length - 1 ? leftNormal(p, pts[i + 1]) : null;
+	if (!n1) return [p[0] + /** @type {number[]} */ (n2)[0] * d, p[1] + /** @type {number[]} */ (n2)[1] * d];
+	if (!n2) return [p[0] + n1[0] * d, p[1] + n1[1] * d];
+	const s = [n1[0] + n2[0], n1[1] + n2[1]], l = Math.hypot(...s) || 1, m = [s[0] / l, s[1] / l], k = d / (m[0] * n1[0] + m[1] * n1[1]);
+	return [p[0] + m[0] * k, p[1] + m[1] * k];
+});
+
+/**
+ * A solid band w wide along an open polyline, every corner mitred sharp and both ends cut square.
+ *
+ * @param {readonly (readonly number[])[]} pts The polyline (its centre line).
+ * @param {number} w The width.
+ * @returns {import('./types.js').Shape} The band.
+ */
+export const mitreBand = (pts, w) => poly([...mitreOffset(pts, w / 2), ...mitreOffset(pts, -w / 2).reverse()]);
+
+/**
+ * A closed polygon grown (d > 0) or shrunk (d < 0) by d, every corner mitred: each edge moves out along its normal and
+ * neighbouring edges meet where their lines cross. Either winding. Shrinking past a corner's reach turns it inside out,
+ * so keep |d| under the shortest edge's reach.
+ *
+ * @param {readonly (readonly number[])[]} pts The polygon's corners, in order (open: no repeated first point).
+ * @param {number} d How far.
+ * @returns {number[][]} The offset polygon, a corner for each corner.
+ */
+export const offsetPolygon = (pts, d) => {
+	const n = pts.length;
+	let a = 0;
+	for (let i = 0; i < n; i++) { const p = pts[i], q = pts[(i + 1) % n]; a += p[0] * q[1] - q[0] * p[1]; }
+	const sg = a > 0 ? 1 : -1, L = pts.map((p, i) => {
+		const q = pts[(i + 1) % n], dx = q[0] - p[0], dy = q[1] - p[1], l = Math.hypot(dx, dy), nx = sg * dy / l, ny = -sg * dx / l;
+		return [p[0] + nx * d, p[1] + ny * d, dx, dy];
+	});
+	return L.map((b, i) => {
+		const a2 = L[(i + n - 1) % n], den = a2[2] * b[3] - a2[3] * b[2], t = ((b[0] - a2[0]) * b[3] - (b[1] - a2[1]) * b[2]) / den;
+		return [a2[0] + a2[2] * t, a2[1] + a2[3] * t];
+	});
+};

package/src/geometry/modular.d.ts

@@ -9,6 +9,6 @@ export function isoPieces(pieces: [Point3, Point3][], u?: number, g?: number, ox
 /** Blocks [x, y, w, h] on a W × H grid, scaled to 448 and parted by g. */
 export function blocks(list: [number, number, number, number][], W: number, H: number, g?: number): Shape;
 /** A nested subdivision for blocks(): n − 1 blocks peeled off the sides named in turn (l t r b), each `cut` of what's left. */
-export function nest(W: number, H: number, n: number, sides: string, cut: number | ((i: number) => number)): [number, number, number, number][];
+export function nest(W: number, H: number, n: number, sides: string, cut: (w: number, h: number, side: string) => number): [number, number, number, number][];
 /** Capsules w wide pinned together, back to front, each cut free by g; pin holes at `pins`. */
 export function linkage(bars: [Point, Point][], pins?: Point[], o?: { w?: number; g?: number; pin?: number }): Shape;

package/src/parts/index.d.ts

@@ -13,4 +13,6 @@ export * from './iso.js';
 export * from './letters.js';
 export * from './objects.js';
 export * from './faces.js';
+export * from './span.js';
+export * from './pixels.js';
 export * from './run.js';

package/src/parts/index.js

@@ -12,4 +12,6 @@ export * from './iso.js';
 export * from './letters.js';
 export * from './objects.js';
 export * from './faces.js';
+export * from './span.js';
+export * from './pixels.js';
 export * from './run.js';

package/src/parts/pixels.d.ts

@@ -0,0 +1,11 @@
+import type { Geom } from '../geometry/types.js';
+
+/** A span of pixels: [from, to, n], or [null, null, n] for n empty pixels. */
+export type PixelSpan = readonly [number | null, number | null, number];
+
+/** Whether a point is inside a kit shape (even-odd). */
+export function insideShape(shape: Geom, x: number, y: number): boolean;
+/** A mark as rows of text ('#' a pixel) over spans of pixels on each axis. */
+export function rasterRows(shape: Geom, xs: readonly PixelSpan[], ys: readonly PixelSpan[], options?: { min?: number; k?: number }): string[];
+/** A whole mark as rows of text on square pixels, n along its longest side, phase (fx, fy), cells to toggle. */
+export function rasterMark(shape: Geom, n: number, fx?: number, fy?: number, options?: { min?: number; fix?: readonly (readonly number[])[] }): string[];