@logomarks/core 0.1.11 → 0.2.0

package/CHANGELOG.md

@@ -5,6 +5,28 @@ 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

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
@@ -33,6 +34,12 @@ checkFit(mark).problems;              // []
 - `/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`
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@logomarks/core",
-  "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.",
+  "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,36 @@
       "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",
@@ -103,7 +133,10 @@
     "embroidery",
     "satin-stitch",
     "signed-distance-field",
-    "sdf"
+    "sdf",
+    "letters",
+    "font",
+    "pixel-art"
   ],
   "author": "David Sherlock",
   "license": "MIT",
@@ -124,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/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;

package/src/font/glyphs.js

@@ -0,0 +1,228 @@
+/**
+ * A capital from a font file as a kit shape, drawn on the frame the serif and blackletter faces draw on (cap line at y 0,
+ * baseline at y H, y down, ink starting at x 0), so the house moves (/letters' rule, split, dot, plinth, frame, inline;
+ * the blackletter's parted lozenge and split stem) apply to a font's letter unchanged. From the Logomarks tools
+ * (fontparts.mjs, batches 242 and 243). Node only.
+ *
+ * Every function takes a font as a file path or as its bytes (a Buffer, Uint8Array or ArrayBuffer): core holds no fonts
+ * and no font folder. A font is parsed on first use and cached (by path, or by the bytes' object). It reads fonts with
+ * opentype.js and grows them with clipper-lib, both optional peers loaded on first use.
+ *
+ * Two traps the Logomarks font A/B found:
+ * - opentype.js getPath() writes NaN for Bodoni Moda's static instances and drops DM Serif Display's closepaths (which
+ *   merges its rings), so paths are built here from glyph.path.commands;
+ * - font contours overlap (Bodoni, DM Serif, Unifraktur), so glyphs are filled non-zero (`nonzeroShape()`).
+ */
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import { U, D, I, move, bbox, rect } from '../geometry/index.js';
+import { pathRings } from '../svg/index.js';
+import { shoelace as sArea } from '../util/vec.js';
+import { wind, runsH, runsV, strokeDepths, thinnestStroke } from './measure.js';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * A cache for values of a font (and a sub-key): a Map for paths, keyed `path` or `path|sub` as strings, and a WeakMap of
+ * Maps for fonts passed as bytes.
+ *
+ * @template T
+ * @returns {(font: import('./glyphs.js').FontSource, sub: string | undefined, make: () => T) => T} The cached lookup.
+ */
+const fontCache = () => {
+	const paths = new Map(), bytes = new WeakMap();
+	return (font, sub, make) => {
+		if (typeof font === 'string') { const k = sub === undefined ? font : `${font}|${sub}`; if (!paths.has(k)) paths.set(k, make()); return paths.get(k); }
+		let m = bytes.get(font); if (!m) bytes.set(font, (m = new Map()));
+		const k = sub ?? ''; if (!m.has(k)) m.set(k, make()); return m.get(k);
+	};
+};
+
+const fonts = fontCache();
+
+/**
+ * A font, parsed (cached): from its file's path, or from its bytes.
+ *
+ * @param {import('./glyphs.js').FontSource} source The font file's path, or its contents.
+ * @returns {import('./glyphs.js').Font} The parsed font (opentype.js's Font).
+ */
+export const loadFont = (source) => fonts(source, undefined, () => {
+	const opentype = require('opentype.js');
+	if (source instanceof ArrayBuffer) return opentype.parse(source);
+	const b = typeof source === 'string' ? fs.readFileSync(source) : source;
+	return opentype.parse(b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength));
+});
+
+/**
+ * A font's cap height in font units: the top of its H (OS/2 sCapHeight is far off in Unifraktur).
+ *
+ * @param {import('./glyphs.js').Font} font The parsed font.
+ * @returns {number} The cap height.
+ */
+export const capUnits = (font) => Math.max(...font.charToGlyph('H').path.commands.filter((c) => c.y !== undefined).map((c) => c.y));
+
+/**
+ * A glyph's outline as SVG path data, scaled by k, its baseline at y H and y down; one subpath per contour.
+ *
+ * @param {{ path: { commands: Record<string, any>[] } }} glyph The glyph.
+ * @param {number} k The scale.
+ * @param {number} H The baseline.
+ * @returns {string} The path data.
+ */
+const glyphD = (glyph, k, H) => {
+	const X = (v) => (v * k).toFixed(3), Y = (v) => (H - v * k).toFixed(3); let d = '';
+	for (const c of glyph.path.commands) {
+		if (c.type === 'M') d += (d ? 'Z' : '') + `M${X(c.x)} ${Y(c.y)}`;
+		else if (c.type === 'L') d += `L${X(c.x)} ${Y(c.y)}`;
+		else if (c.type === 'Q') d += `Q${X(c.x1)} ${Y(c.y1)} ${X(c.x)} ${Y(c.y)}`;
+		else if (c.type === 'C') d += `C${X(c.x1)} ${Y(c.y1)} ${X(c.x2)} ${Y(c.y2)} ${X(c.x)} ${Y(c.y)}`;
+	}
+	return d + 'Z';
+};
+
+/**
+ * Rings wound non-zero (outers one way, counters the other) as a shape: each counter cut from the smallest outer
+ * holding it, then the outers united.
+ *
+ * @param {readonly (readonly number[])[][]} rings The rings.
+ * @returns {import('../geometry/types.js').Shape} The shape.
+ */
+const ringsShape = (rings) => {
+	const rs = rings.filter((r) => Math.abs(sArea(r)) > 0.5); if (!rs.length) return [];
+	const big = rs.reduce((a, r) => (Math.abs(sArea(r)) > Math.abs(sArea(a)) ? r : a)), sign = Math.sign(sArea(big));
+	const outers = rs.filter((r) => Math.sign(sArea(r)) === sign), holes = rs.filter((r) => Math.sign(sArea(r)) !== sign), own = outers.map(() => []);
+	for (const h of holes) {
+		let best = -1;
+		outers.forEach((o, i) => { if (wind(o, h[0]) !== 0 && (best < 0 || Math.abs(sArea(o)) < Math.abs(sArea(outers[best])))) best = i; });
+		if (best >= 0) own[best].push(h);
+	}
+	return U(...outers.map((o, i) => D([o], ...own[i].map((h) => [h]))));
+};
+
+/**
+ * Path data filled non-zero, as a shape, for contours that may overlap: each counter (a ring wound against the outers)
+ * is cut from the smallest outer that holds it, then the outers are united.
+ *
+ * @param {string} d The path data.
+ * @param {number} [step=1] The curves' sampling step.
+ * @returns {import('../geometry/types.js').Shape} The shape.
+ */
+export const nonzeroShape = (d, step = 1) => ringsShape(pathRings(d, step));
+
+/**
+ * A font's character as a shape, scaled so the font's cap height (its H) is `cap`: the cap line at y 0, the baseline at
+ * y cap, the ink starting at x 0. Overshoots and descenders fall outside 0…cap as the font draws them.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font (a path or its bytes).
+ * @param {string} char The character.
+ * @param {{ cap?: number, step?: number }} [o] The cap height (380) and the curves' sampling step (1).
+ * @returns {{ s: import('../geometry/types.js').Shape, w: number }} The letter and its ink's width.
+ */
+export const glyphShape = (font, char, { cap = 380, step = 1 } = {}) => {
+	const f = loadFont(font), k = cap / capUnits(f);
+	const s = nonzeroShape(glyphD(f.charToGlyph(char), k, cap), step), [x0, , x1] = bbox(s);
+	return { s: move(s, -x0, 0), w: x1 - x0 };
+};
+
+/**
+ * A mitred grow: the shape grown by d with its corners kept sharp (mitred up to `limit` times d, squared off past it),
+ * where the kit's grow() rounds every corner by d. Thickening a font's hairlines with a round grow softens every serif
+ * corner; this keeps the font's cut. Clipper's offset (clipper-lib, an optional peer), in thousandths: an exact polygon
+ * offset (/geometry's offsetPolygon) can't stand in for it, since Clipper's integer grid sets every point.
+ *
+ * @param {import('../geometry/types.js').Shape} shape The shape.
+ * @param {number} d How far (0: the shape as it is).
+ * @param {number} [limit=2] The mitre limit, in multiples of d.
+ * @returns {import('../geometry/types.js').Shape} The grown shape.
+ */
+export const mitreGrow = (shape, d, limit = 2) => {
+	if (!d) return shape;
+	const CL = require('clipper-lib');
+	const P = (r) => r.map(([x, y]) => ({ X: Math.round(x * 1000), Y: Math.round(y * 1000) })), c = new CL.Clipper(), u = new CL.Paths();
+	c.AddPaths(shape.flatMap((pg) => pg.map(P)), CL.PolyType.ptSubject, true);
+	c.Execute(CL.ClipType.ctUnion, u, CL.PolyFillType.pftEvenOdd, CL.PolyFillType.pftEvenOdd); // a clean shape: outers come back positive, holes negative
+	const co = new CL.ClipperOffset(limit, 250), out = new CL.Paths(); co.AddPaths(u, CL.JoinType.jtMiter, CL.EndType.etClosedPolygon); co.Execute(out, d * 1000);
+	return ringsShape(out.map((r) => r.map(({ X, Y }) => [X / 1000, Y / 1000])));
+};
+
+/**
+ * A font's weights, read off its H at cap 1000: the stem S (the left stem across at mid-height) and the hairline h (the
+ * bar, down through the middle), as fractions of the cap.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @returns {{ S: number, h: number }} The stem and the hairline.
+ */
+export const weights = (font) => {
+	const H = glyphShape(font, 'H', { cap: 1000 }), st = runsH(H.s, 300)[0];
+	const bar = runsV(H.s, H.w / 2).find(([a, b]) => b - a < 300); return { S: (st[1] - st[0]) / 1000, h: bar ? (bar[1] - bar[0]) / 1000 : (st[1] - st[0]) / 1000 };
+};
+
+const wcache = fontCache();
+
+/**
+ * weights(), cached.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @returns {{ S: number, h: number }} The stem and the hairline.
+ */
+const fontWeights = (font) => wcache(font, undefined, () => weights(font));
+
+const hcache = fontCache();
+
+/**
+ * A font's hairline as a fraction of its cap: the `q` quantile of the stroke depths of `chars` (a font whose H has no
+ * hairline bar, such as a Fraktur, is measured this way; the serif faces use their H's bar, `weights()`). Cached.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @param {string} [chars='ABCDEGHMNRST'] The letters measured.
+ * @param {number} [q=0.1] The quantile.
+ * @returns {number} The hairline, as a fraction of the cap.
+ */
+export const hairline = (font, chars = 'ABCDEGHMNRST', q = 0.1) => hcache(font, `${chars}|${q}`, () => {
+	const d = [...chars].flatMap((c) => strokeDepths(glyphShape(font, c, { cap: 1000, step: 4 }).s, 6)).sort((a, b) => a - b);
+	return d[Math.floor(d.length * q)] / 1000;
+});
+
+const scache = fontCache();
+
+/**
+ * A font's structural hairline as a fraction of its cap: the thinnest structural stroke (thinnestStroke()) over `chars`
+ * at a 448 cap, so tips and spikes don't count (Abril Fatface 0.026, New Rocker 0.085, Germania One 0.131): pass it to
+ * fontSource() as `h`. Cached; needs @resvg/resvg-js.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @param {string} [chars='ABEFGHMNORS'] The letters measured.
+ * @returns {number} The hairline, as a fraction of the cap.
+ */
+export const structuralHairline = (font, chars = 'ABEFGHMNORS') => scache(font, chars, () => Math.min(...[...chars].map((c) => thinnestStroke(glyphShape(font, c, { cap: 448 }).s))) / 448);
+
+/**
+ * A glyph source for /letters' moves (and any build that takes a letter): `(H, { g }) => { s, w, m }`, the font's `char`
+ * at cap H on the glyph frame, with m = { H, S, h, t, dy }: its stem and hairline (after the grow), the grow t and the
+ * lift dy. Given the gap g the mark is drawn with (exact() picks g so it lands on 22 once fitted, so the fit's scale is
+ * 22 ÷ g), the glyph is grown uniformly (mitred, so its corners stay sharp) just enough that its hairline is `hair` once
+ * fitted. The hairline is the font's H bar (`weights()`), or `h` (a fraction of the cap; hairline() and
+ * structuralHairline() measure one for a face without a bar). The grow, in fitted units, is reported through `onGrow`.
+ * Without g nothing is grown. Grown, the ink is moved back so it still starts at x 0 and its baseline stays at y H (its
+ * cap line rises 2t), so base serifs, rules and plinths line up; m.dy re-centres it in a frame.
+ *
+ * @param {import('./glyphs.js').FontSource} font The font.
+ * @param {string} char The character.
+ * @param {{ hair?: number, h?: number, onGrow?: (t: number) => void }} [o] The fitted hairline wanted (29), the font's
+ *   hairline as a fraction of the cap (its H bar's by default), and a callback for the grow.
+ * @returns {import('../letters/serif.js').GlyphSource} The glyph source.
+ */
+export const fontSource = (font, char, { hair = 29, h, onGrow } = {}) => (H, o = {}) => {
+	const wt = fontWeights(font), h0 = (h ?? wt.h) * H;
+	const k = o.g ? 22 / o.g : 1, t = o.g ? Math.max(0, (hair / k - h0) / 2) : 0; if (onGrow) onGrow(+(t * k).toFixed(2));
+	const L = glyphShape(font, char, { cap: H }), s = t ? move(mitreGrow(L.s, t), t, -t) : L.s;
+	return { s, w: L.w + 2 * t, m: { H, S: wt.S * H + 2 * t, h: h0 + 2 * t, t, dy: t } };
+};
+
+/**
+ * A glyph source with its ink below the baseline trimmed off (a vertex dipping through a plinth).
+ *
+ * @param {import('../letters/serif.js').GlyphSource} src The glyph source.
+ * @returns {import('../letters/serif.js').GlyphSource} The trimmed source.
+ */
+export const onBase = (src) => (H, o) => { const L = src(H, o); return { ...L, s: I(L.s, rect(-50, -200, L.w + 100, H + 200)) }; };

package/src/font/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Letters from font files (Node): a font's capital as a kit shape on the serif and blackletter faces' frame, grown so its
+ * hairline holds, the measures to place a move on it, and the moves. Fonts are passed in as paths or bytes; opentype.js,
+ * clipper-lib and @resvg/resvg-js are optional peers, loaded on first use.
+ */
+export type { FontSource, Font } from './glyphs.js';
+export type { LetterMove } from './moves.js';
+export { loadFont, capUnits, nonzeroShape, glyphShape, mitreGrow, weights, hairline, structuralHairline, fontSource, onBase } from './glyphs.js';
+export { inside, runsH, runsV, strokeDepths, armEnd, thinnestStroke } from './measure.js';
+export { underCrossbar, underTopBar, underBowl, cornerDot, fullStop, starBefore, underFork, underBowlR, inlineOpen, inlineStraight, armLozenge, stemSplit, barLozenge, leftLozenge, tongueLozenge, barEnd, barEnds, crossLozenge } from './moves.js';

package/src/font/index.js

@@ -0,0 +1,10 @@
+/**
+ * @module @logomarks/core/font
+ *
+ * Letters from font files (Node): a font's capital as a kit shape on the serif and blackletter faces' frame, grown so its
+ * hairline holds, the measures to place a move on it, and the moves. Fonts are passed in as paths or bytes; opentype.js,
+ * clipper-lib and @resvg/resvg-js are optional peers, loaded on first use.
+ */
+export { loadFont, capUnits, nonzeroShape, glyphShape, mitreGrow, weights, hairline, structuralHairline, fontSource, onBase } from './glyphs.js';
+export { inside, runsH, runsV, strokeDepths, armEnd, thinnestStroke } from './measure.js';
+export { underCrossbar, underTopBar, underBowl, cornerDot, fullStop, starBefore, underFork, underBowlR, inlineOpen, inlineStraight, armLozenge, stemSplit, barLozenge, leftLozenge, tongueLozenge, barEnd, barEnds, crossLozenge } from './moves.js';

package/src/font/measure.d.ts

@@ -0,0 +1,16 @@
+import type { Shape } from '../geometry/types.js';
+
+/** The winding number of a ring about a point. */
+export function wind(ring: readonly (readonly number[])[], p: readonly number[]): number;
+/** Whether (x, y) is in the shape's ink, by winding. */
+export function inside(s: Shape, x: number, y: number): boolean;
+/** The ink runs [a, b] along the horizontal line y. */
+export function runsH(s: Shape, y: number, x0?: number, x1?: number): number[][];
+/** The ink runs [a, b] along the vertical line x. */
+export function runsV(s: Shape, x: number, y0?: number, y1?: number): number[][];
+/** The ink's depth across its strokes from points along the outline, smallest first. */
+export function strokeDepths(s: Shape, step?: number): number[];
+/** Where a stroke ends on the right between y0 and y1, and its depth there. */
+export function armEnd(s: Shape, y0: number, y1: number, o?: { step?: number; back?: number }): { x: number; y: number; th: number; yc: number };
+/** The thinnest structural stroke, by erosion (needs @resvg/resvg-js). */
+export function thinnestStroke(s: Shape, k?: number): number;

package/src/font/measure.js

@@ -0,0 +1,201 @@
+/**
+ * Measures for placing a move on a letter (a font's or any shape): the ink's runs along a line, the depth across its
+ * strokes, where an arm ends, and the thinnest stroke holding it together. From the Logomarks tools (fontparts.mjs,
+ * batches 242 and 243).
+ */
+import { createRequire } from 'node:module';
+import { bbox, toPath } from '../geometry/index.js';
+
+/**
+ * The winding number of a ring about a point.
+ *
+ * @param {readonly (readonly number[])[]} ring The ring.
+ * @param {readonly number[]} p The point.
+ * @returns {number} The winding number.
+ */
+export const wind = (ring, [px, py]) => {
+	let w = 0;
+	for (let i = 0, n = ring.length; i < n; i++) {
+		const [x1, y1] = ring[i], [x2, y2] = ring[(i + 1) % n], c = (x2 - x1) * (py - y1) - (px - x1) * (y2 - y1);
+		if (y1 <= py ? y2 > py && c > 0 : y2 <= py && c < 0) w += y1 <= py ? 1 : -1;
+	}
+	return w;
+};
+
+/**
+ * Whether (x, y) is in the shape's ink: inside an outer ring and outside its holes, by winding.
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} x The point.
+ * @param {number} y The point.
+ * @returns {boolean} True when it is.
+ */
+export const inside = (s, x, y) => s.some((pg) => wind(pg[0], [x, y]) !== 0 && !pg.slice(1).some((h) => wind(h, [x, y]) !== 0));
+
+/**
+ * The runs [a, b] where `on(t)` holds, for t from a0 to a1 in steps of 0.25.
+ *
+ * @param {(t: number) => boolean} on The test.
+ * @param {number} a0 Where to start.
+ * @param {number} a1 Where to stop.
+ * @returns {number[][]} The runs.
+ */
+const runs = (on, a0, a1) => {
+	const r = []; let a = null;
+	for (let t = a0; t <= a1; t += 0.25) { const v = on(t); if (v && a === null) a = t; if (!v && a !== null) { r.push([a, t]); a = null; } }
+	if (a !== null) r.push([a, a1]);
+	return r;
+};
+
+/**
+ * The ink runs [a, b] along the horizontal line y (x from x0 to x1, in steps of 0.25).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} y The line.
+ * @param {number} [x0=-50] Where to start.
+ * @param {number} [x1=1000] Where to stop.
+ * @returns {number[][]} The runs, left to right.
+ */
+export const runsH = (s, y, x0 = -50, x1 = 1000) => runs((x) => inside(s, x, y), x0, x1);
+
+/**
+ * The ink runs [a, b] along the vertical line x (y from y0 to y1, in steps of 0.25).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} x The line.
+ * @param {number} [y0=-50] Where to start.
+ * @param {number} [y1=1000] Where to stop.
+ * @returns {number[][]} The runs, top to bottom.
+ */
+export const runsV = (s, x, y0 = -50, y1 = 1000) => runs((y) => inside(s, x, y), y0, y1);
+
+/**
+ * The ink's depth across its strokes, sorted: from points every `step` along the outline, the distance along the inward
+ * normal to the far side (the ray against every edge). Its low end is the thinnest stroke (tips and tapered swash ends
+ * included, as a reader at 32 px sees them).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} [step=3] The spacing along the outline.
+ * @returns {number[]} The depths, smallest first.
+ */
+export const strokeDepths = (s, step = 3) => {
+	const E = s.flatMap((pg) => pg.flatMap((r) => r.map((p, i) => [p, r[(i + 1) % r.length]]))), out = [];
+	for (const [p, q] of E) {
+		const L = Math.hypot(q[0] - p[0], q[1] - p[1]); if (L < 0.5) continue; const u = [(q[0] - p[0]) / L, (q[1] - p[1]) / L];
+		for (let t = step / 2; t < L; t += step) {
+			const x = p[0] + u[0] * t, y = p[1] + u[1] * t; let n = [u[1], -u[0]];
+			if (!inside(s, x + n[0] * 0.5, y + n[1] * 0.5)) n = [-n[0], -n[1]];
+			let best = Infinity;
+			for (const [a, b] of E) {
+				const ex = b[0] - a[0], ey = b[1] - a[1], den = n[0] * ey - n[1] * ex; if (Math.abs(den) < 1e-12) continue;
+				const wx = a[0] - x, wy = a[1] - y, d = (wx * ey - wy * ex) / den, v = (wx * n[1] - wy * n[0]) / den;
+				if (d > 0.3 && v >= 0 && v <= 1 && d < best) best = d;
+			}
+			if (best < Infinity) out.push(best);
+		}
+	}
+	return out.sort((a, b) => a - b);
+};
+
+/**
+ * Where a stroke ends on the right inside the band of heights y0…y1 (a middle arm's tip): the rightmost ink point found
+ * on rows `step` apart, and the stroke's depth a little back from it (the run down through x − back).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} y0 The band's top.
+ * @param {number} y1 Its bottom.
+ * @param {{ step?: number, back?: number }} [o] The rows' spacing (2) and how far back the depth is read (24).
+ * @returns {{ x: number, y: number, th: number, yc: number }} The tip, the stroke's depth there and its middle.
+ */
+export const armEnd = (s, y0, y1, { step = 2, back = 24 } = {}) => {
+	let best = { x: -Infinity, y: y0 };
+	for (let y = y0; y <= y1; y += step) { const r = runsH(s, y); if (r.length && r.at(-1)[1] > best.x) best = { x: r.at(-1)[1], y }; }
+	const run = runsV(s, best.x - back).find(([a, b]) => a <= best.y + 2 && b >= best.y - 2) || [best.y - 30, best.y + 30];
+	return { ...best, th: run[1] - run[0], yc: (run[0] + run[1]) / 2 };
+};
+
+/* ---------- the structural stroke ---------- */
+// strokeDepths() counts tips and spurs: right for a swash face, but a spiked face has so many sharp tips that its low end
+// reads far thinner than its thinnest real stroke. thinnestStroke() measures by erosion instead: the glyph is rasterised k
+// px a unit, eroded by r (a pixel survives while it is r or more from paper), and r raised until the topology changes (a
+// piece splits off, or a counter opens into another). The stroke that breaks first is the thinnest stroke holding the
+// letter together; tips, serif ends and spurs shrink without changing the topology, so they don't count. The raster is
+// @resvg/resvg-js's (an optional peer, loaded on first use): core's own scanline fill differs from it on edge pixels.
+
+/**
+ * The shape as a 0/1 mask, k px a unit, with a 6 px margin of paper.
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} k Pixels a unit.
+ * @returns {{ M: Uint8Array, W: number, H: number }} The mask and its size.
+ */
+const mask = (s, k) => {
+	const { Resvg } = createRequire(import.meta.url)('@resvg/resvg-js'), [x0, y0, x1, y1] = bbox(s), m = 6;
+	const W = Math.ceil((x1 - x0) * k) + 2 * m, H = Math.ceil((y1 - y0) * k) + 2 * m;
+	const px = new Resvg(`<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}"><path shape-rendering="crispEdges" fill-rule="evenodd" fill="#000" transform="translate(${m} ${m}) scale(${k}) translate(${-x0} ${-y0})" d="${toPath(s)}"/></svg>`).render().pixels;
+	const M = new Uint8Array(W * H); for (let i = 0; i < W * H; i++) M[i] = px[i * 4 + 3] > 127 ? 1 : 0;
+	return { M, W, H };
+};
+
+/**
+ * The squared distance from each ink pixel to the nearest paper pixel (Felzenszwalb and Huttenlocher's two-pass
+ * transform).
+ *
+ * @param {{ M: Uint8Array, W: number, H: number }} mk The mask.
+ * @returns {Float64Array} The squared distances, row by row.
+ */
+const edt = ({ M, W, H }) => {
+	const INF = 1e12, Dt = new Float64Array(W * H), n = Math.max(W, H), f = new Float64Array(n), d = new Float64Array(n), v = new Int32Array(n), z = new Float64Array(n + 1);
+	const pass = (len) => {
+		let k = 0; v[0] = 0; z[0] = -INF; z[1] = INF;
+		for (let q = 1; q < len; q++) {
+			let s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]);
+			while (s <= z[k]) { k--; s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k]); }
+			k++; v[k] = q; z[k] = s; z[k + 1] = INF;
+		}
+		k = 0; for (let q = 0; q < len; q++) { while (z[k + 1] < q) k++; d[q] = (q - v[k]) * (q - v[k]) + f[v[k]]; }
+	};
+	for (let x = 0; x < W; x++) { for (let y = 0; y < H; y++) f[y] = M[y * W + x] ? INF : 0; pass(H); for (let y = 0; y < H; y++) Dt[y * W + x] = d[y]; }
+	for (let y = 0; y < H; y++) { for (let x = 0; x < W; x++) f[x] = Dt[y * W + x]; pass(W); for (let x = 0; x < W; x++) Dt[y * W + x] = d[x]; }
+	return Dt;
+};
+
+/**
+ * How many connected pieces there are where on(i) holds (8-connected for ink, 4 for paper), ignoring any under minPx.
+ *
+ * @param {number} W The width.
+ * @param {number} H The height.
+ * @param {(i: number) => boolean} on Whether pixel i counts.
+ * @param {boolean} eight 8-connected (else 4).
+ * @param {number} [minPx=4] The smallest piece that counts.
+ * @returns {number} The count.
+ */
+const pieces = (W, H, on, eight, minPx = 4) => {
+	const seen = new Uint8Array(W * H), st = new Int32Array(W * H); let n = 0;
+	const nb = eight ? [[1, 0], [-1, 0], [0, 1], [0, -1], [1, 1], [1, -1], [-1, 1], [-1, -1]] : [[1, 0], [-1, 0], [0, 1], [0, -1]];
+	for (let i = 0; i < W * H; i++) {
+		if (seen[i] || !on(i)) continue; let sp = 0, size = 0; st[sp++] = i; seen[i] = 1;
+		while (sp) {
+			const j = st[--sp], x = j % W, y = (j - x) / W; size++;
+			for (const [dx, dy] of nb) { const X = x + dx, Y = y + dy; if (X < 0 || Y < 0 || X >= W || Y >= H) continue; const q = Y * W + X; if (!seen[q] && on(q)) { seen[q] = 1; st[sp++] = q; } }
+		}
+		if (size >= minPx) n++;
+	}
+	return n;
+};
+
+/**
+ * The thinnest structural stroke of a shape, in its units (±1/k): the erosion radius at which a piece splits off or a
+ * counter opens. Needs @resvg/resvg-js (an optional peer).
+ *
+ * @param {import('../geometry/types.js').Shape} s The shape.
+ * @param {number} [k=2] Pixels a unit.
+ * @returns {number} The stroke's width (Infinity when nothing breaks before r 80).
+ */
+export const thinnestStroke = (s, k = 2) => {
+	const mk = mask(s, k), Dt = edt(mk), { W, H } = mk;
+	const topo = (r) => { const r2 = r * r; return [pieces(W, H, (i) => Dt[i] >= r2, true), pieces(W, H, (i) => Dt[i] < r2, false)]; };
+	let [ink, paper] = topo(1);
+	for (let r = 1.5; r < 80; r += 0.5) { const [a, b] = topo(r); if (a > ink || b < paper) return (2 * (r - 0.75)) / k; ink = Math.min(ink, a); paper = b; }
+	return Infinity;
+};