@logomarks/core 0.1.9 → 0.2.0

package/CHANGELOG.md

@@ -5,6 +5,55 @@ 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.2.0] — 2026-11-15
+
+### Added
+
+Every generic parts module the Logomarks generators still kept locally, moved here (the code unchanged, each part documented and typed), so the site keeps only its marks. Six new subpaths, none re-exported from the root:
+
+- **`/iso`:** iso objects on `/parts`' `scene()` (cylinders, frustums, lathes, poles, roofs, shops and `shopMark()`, openings cut on the fitted faces with `isoCut()`, cut-outs square to the viewer drawn by `isoFlat()`, tipped slabs), flat planes hinged and folded into one mark (`planeScene()`, `planeMark()`, `planeGlyph()`, iso or oblique `ISO`/`OBL`), and voxels (`voxRight`, `voxPlan`, `pixDepth`, `slabs`, corner monograms `cornerMark()`). From the tools' isoparts, planeparts and blockparts.
+- **`/letters`:** letters built from geometry: a Didone capital alphabet with its frames, interlace and one-move builds (`face`, `SERIF_GLYPHS`, `serifLetter`, `pairOf`, `split`, `ruled`, `framed`…), blackletter from one 30° nib (`nib`, `parted`, `BLACKLETTERS`, `blackLetter`), condensed pairs on one stem (`pillar`, `stack`), the monogram letters, and the Echo, Dot Stroke, Ink Trap and Stair faces, the last two on one 448 frame `T`, `B`, `H`.
+- **`/font`:** a capital from a font file as a shape (`glyphShape`, `fontSource`, grown mitred to a fitted hairline), its measures (`weights`, `hairline`, `structuralHairline`, `thinnestStroke`, `runsH`…) and the moves placed on it (`underCrossbar`, `armLozenge`, `stemSplit`, `inlineOpen`…). `loadFont()` takes a path or the font's bytes and names no folder: the fonts stay with whoever draws with them.
+- **`/pixels`:** dither tapers (cells, ramps, ordered-dither `taper()`, `sprite()`, free squares) and typed pixel emotes (`emote`).
+- **`/objects`:** devices and code glyphs, blades, dishes, the boxing glove and pixel sprites, cells, faces and mascot features, animals (the gecko build, two-track animals, bold outlines) and rosettes.
+- **`/forms`:** the Bold, Line and Track constructions: needle gaps and knobs, split discs, hooked capsules, jogs and chamfer checkers, tech sparkles and ribbons, split emblems, shatter, turning slats, flow grids, fold seams, swashes, rotation, stripes, guilloche and speed letters, the Track editions' kit, and soft blobs, Rail lines and interlocking locks.
+- **`/sdf`** gains the Y2K parts built from its fields: `pinch`, `ballArm`, `node`, `blob`, `stadium`.
+
+Renamed where two modules' names met in one subpath (`blackLetter`, `serifLetter`, `monoBowl`, `DOT_S`, `TRAP_S`, `PILLAR_LEFT`, `waveArm`, `geoDisc`, `discAt`, `hookAt`, `discSide`, `techChevron`, `foldQuad`, `swashQuad`, `evenBands`, `evenRing`, `shardStrip`, `GEO_X0`, `EMBLEM_W`, `HOOK_W`, `DISC_R`, `planeMark`, `planeGlyph`…). Copies of what core already had were dropped for core's own (`GAP`, `rad`, `openRing`, `mitreOffset`, `mitreBand`, `joinPts`, `chain`, `filletClosed`), and the vector helpers the families repeated are written once.
+
+### Dependencies
+
+- `/font` loads three optional peers on first use: **opentype.js** (reading the font), **clipper-lib** (already a peer for `/edit`: `mitreGrow()` keeps Clipper's integer offset, which the exact `mitreOffset`/`offsetPolygon` can't match byte for byte) and **@resvg/resvg-js** (`thinnestStroke()`'s mask: core's own scanline fill was tried and differs on the edge pixels of 172 of 176 glyphs, so it would change the measured hairlines). Nothing else needs them.
+
+Proved on the Logomarks generators: all 206 that import these parts redraw byte-identical with core in place of the local modules. The golden tests cover every new export the behaviour tests don't reach.
+
+## [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

@@ -7,6 +7,7 @@ Geometry, SVG reading, fitting, analysis and similarity for logomarks on a 512 g
 ```bash
 npm install @logomarks/core
 npm install clipper-lib   # only for the shape edits (reshape)
+npm install opentype.js clipper-lib @resvg/resvg-js   # only for /font
 ```
 
 ## Quick start
@@ -25,13 +26,21 @@ 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)
+- `/iso`: iso objects (lathes, roofs, shops, cut-outs square to the viewer, tipped slabs), folded planes and voxels
+- `/letters`: letters built from geometry: a Didone serif, a blackletter nib, monogram, pillar and stem pairs, and the echo, dot-stroke, ink-trap and stair faces
+- `/font`: a capital from a font file (a path or its bytes) as a shape, its hairline measured and grown, and the house moves placed on it (Node)
+- `/pixels`: dither tapers that break a pixel mark up, and typed pixel emotes
+- `/objects`: devices and code glyphs, blades, dishes, sport, cells, faces, animals and rosettes
+- `/forms`: the Bold, Line and Track forms: discs, hooks, jogs, emblems, shatter, slats, flow grids, folds, swashes, stripes, rails, locks and track editions
+- `/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.2.0",
+  "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, and the parts the generators draw with: iso objects, letters and type, font glyphs, pixel dither, objects and the Bold, Line and Track forms, plus the batch runner.",
   "type": "module",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -22,6 +22,41 @@
       "import": "./src/parts/index.js",
       "default": "./src/parts/index.js"
     },
+    "./iso": {
+      "types": "./src/iso/index.d.ts",
+      "import": "./src/iso/index.js",
+      "default": "./src/iso/index.js"
+    },
+    "./letters": {
+      "types": "./src/letters/index.d.ts",
+      "import": "./src/letters/index.js",
+      "default": "./src/letters/index.js"
+    },
+    "./font": {
+      "types": "./src/font/index.d.ts",
+      "import": "./src/font/index.js",
+      "default": "./src/font/index.js"
+    },
+    "./pixels": {
+      "types": "./src/pixels/index.d.ts",
+      "import": "./src/pixels/index.js",
+      "default": "./src/pixels/index.js"
+    },
+    "./objects": {
+      "types": "./src/objects/index.d.ts",
+      "import": "./src/objects/index.js",
+      "default": "./src/objects/index.js"
+    },
+    "./forms": {
+      "types": "./src/forms/index.d.ts",
+      "import": "./src/forms/index.js",
+      "default": "./src/forms/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 +82,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 +131,12 @@
     "fit",
     "similarity",
     "embroidery",
-    "satin-stitch"
+    "satin-stitch",
+    "signed-distance-field",
+    "sdf",
+    "letters",
+    "font",
+    "pixel-art"
   ],
   "author": "David Sherlock",
   "license": "MIT",
@@ -112,16 +157,26 @@
     "polygon-clipping": "^0.15.7"
   },
   "peerDependencies": {
-    "clipper-lib": "^6.4.2"
+    "@resvg/resvg-js": "^2.6.2",
+    "clipper-lib": "^6.4.2",
+    "opentype.js": "^2.0.0"
   },
   "peerDependenciesMeta": {
+    "@resvg/resvg-js": {
+      "optional": true
+    },
     "clipper-lib": {
       "optional": true
+    },
+    "opentype.js": {
+      "optional": true
     }
   },
   "devDependencies": {
+    "@resvg/resvg-js": "^2.6.2",
     "@types/node": "^26.6.6",
     "clipper-lib": "^6.4.2",
+    "opentype.js": "^2.0.0",
     "typescript": "^6.0.3"
   }
 }

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/font/glyphs.d.ts

@@ -0,0 +1,31 @@
+import type { Shape } from '../geometry/types.js';
+import type { GlyphSource } from '../letters/serif.js';
+
+/** A font: its file's path, or its bytes. */
+export type FontSource = string | Uint8Array | ArrayBuffer;
+/** A parsed font (opentype.js's Font): what /font reads of it. */
+export interface Font {
+	charToGlyph(char: string): { path: { commands: { type: string; x?: number; y?: number; x1?: number; y1?: number; x2?: number; y2?: number }[] } };
+	[key: string]: unknown;
+}
+
+/** A font, parsed and cached (needs opentype.js). */
+export function loadFont(source: FontSource): Font;
+/** A font's cap height in font units: the top of its H. */
+export function capUnits(font: Font): number;
+/** Path data filled non-zero, as a shape. */
+export function nonzeroShape(d: string, step?: number): Shape;
+/** A font's character at cap height `cap`, its ink from x 0. */
+export function glyphShape(font: FontSource, char: string, o?: { cap?: number; step?: number }): { s: Shape; w: number };
+/** The shape grown by d, its corners mitred (needs clipper-lib). */
+export function mitreGrow(shape: Shape, d: number, limit?: number): Shape;
+/** A font's stem and hairline, from its H, as fractions of the cap. */
+export function weights(font: FontSource): { S: number; h: number };
+/** A font's hairline: a quantile of its letters' stroke depths, as a fraction of the cap. */
+export function hairline(font: FontSource, chars?: string, q?: number): number;
+/** A font's structural hairline, by erosion, as a fraction of the cap (needs @resvg/resvg-js). */
+export function structuralHairline(font: FontSource, chars?: string): number;
+/** A font's character as a glyph source, grown so its hairline fits to `hair`. */
+export function fontSource(font: FontSource, char: string, o?: { hair?: number; h?: number; onGrow?: (t: number) => void }): GlyphSource;
+/** A glyph source with its ink below the baseline trimmed off. */
+export function onBase(src: GlyphSource): GlyphSource;