@logomarks/core 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -5,6 +5,31 @@ 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.2] — 2026-11-15
+
+### Added
+
+- **`logomarks-fit`, the fit as a command:** `fitMark()` and `checkFit()` on files. It fits a file in place, several files, or every `.svg` in a folder; `-o` (or a second path that doesn't exist yet) writes one file's fit to another; `--check` only reports and exits 1 when anything is off; a bad call exits 2 with the usage. It is the design skill's `fit.mjs` command line, on the library instead of a pasted copy: on the 5,300 Logomarks marks and the skill's six examples it writes byte-identical files and prints the same lines. See [docs/api.md](docs/api.md#the-fit-command).
+
+### Removed
+
+- **The `logomarks-skill` bin and `src/skill/`** (`bundleKit`, `bundleFit`, `writeSkillScripts`). They pasted `/geometry` into one `kit.mjs` and the fit into one `fit.mjs` for the design skill, which left the skill a second copy of the kit and none of the parts (`/parts`, `/sdf`, `/iso`, `/letters`, `/forms`, `/objects`, `/pixels`: their names clash, so they can't be pasted into one file). The skill now installs `@logomarks/core` and imports its subpaths, and fits with `npx logomarks-fit`. A patch: nothing outside the skill used the bin, and every export is unchanged, so the libraries on `^0.2` keep one copy of core.
+
+### Changed
+
+- `checkFit()`'s "runs outside the 512 canvas" problem says "run logomarks-fit on it" (it named `fit.mjs`).
+
+## [0.2.1] — 2026-11-15
+
+### Added
+
+The Lookbook's mark measures, moved here from `@logomarks/lookbook/marks` (the code unchanged, documented and typed), so the cards and anything else that sizes a mark share one copy. Browser-safe, like the rest of `/analyse` and `/edit`.
+
+- **The optical size in `/analyse`:** `markBox(paths)` (the real box round a mark's outlines, the 448 fit's box when there is nothing to read), `inkShare(paths)` (how much of that box is ink, by scanline coverage 16 cells across), `opticalScale(box, ink)` (how much bigger to draw a wide, slim or light mark: 1 for a square solid, 448 × 200 about 1.22, never above 1.3) and `OPTICAL`, its limits.
+- **Cells by count in `/edit`:** `cellsAcross(n, box)` beside `pixelGrid` (a grid `n` cells across the box's longest side, any `n`, where `pixelGrid` takes an amount and stops at 14 across), and `markCells(paths, n)` (shapes → rings → coverage → filled cells and their path in one call).
+
+Proved on `@logomarks/lookbook` 0.1.0: its own functions give the same values as these on the golden cases, and its equivalence tests pass unchanged on them. The golden tests gain the five cases (`optical.*`, `cells.*`), on six live marks.
+
 ## [0.2.0] — 2026-11-15
 
 ### Added

package/README.md

@@ -22,15 +22,20 @@ const { svg: mark } = fitMark(raw);   // 512 canvas, longest side 448, centred,
 checkFit(mark).problems;              // []
 ```
 
+```bash
+npx logomarks-fit marks/            # fit every .svg in marks/ in place
+npx logomarks-fit --check marks/    # only report; exits 1 if anything is off
+```
+
 ## What's in it
 
 - `/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 (refitting a fitted mark gives the same file)
-- `/analyse`: specks, slivers and pin-holes, gap and stroke widths, shape tags
+- `/analyse`: specks, slivers and pin-holes, gap and stroke widths, shape tags, the optical size (a mark's box, its ink, how much bigger to draw it)
 - `/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
+- `/edit`: the studio's shape edits (weight, soften, gap, detail) and pixelate, by amount or by a count of cells
 - `/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)
@@ -41,9 +46,9 @@ checkFit(mark).problems;              // []
 - `/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`
+- `logomarks-fit`: the fit as a command: fits marks in place (a file, several, or every `.svg` in a folder), `-o` to another file, `--check` only reports and exits 1 when anything is off
 
-Every export, repeatable drawings and the skill scripts: [API](https://github.com/Logomarks/core/blob/main/docs/api.md).
+Every export, repeatable drawings and the fit command: [API](https://github.com/Logomarks/core/blob/main/docs/api.md).
 
 ## Links
 

package/bin/fit.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * logomarks-fit: fits SVG marks to the Logomarks standard (a 512 canvas, the mark's longest side exactly 448, centred,
+ * filled paths in currentColor) with `fitMark()`, and reports with `checkFit()`.
+ *
+ *   logomarks-fit mark.svg                 fit in place
+ *   logomarks-fit in.svg -o out.svg        fit to another file (in.svg out.svg too, while out.svg doesn't exist)
+ *   logomarks-fit a.svg b.svg marks/       fit each file, and every .svg in a folder, in place
+ *   logomarks-fit --check mark.svg marks/  only report; exits 1 if anything is off
+ *
+ * Reads <path d> (with fill-rule), <circle>, <ellipse>, <rect> and <polygon>; nested <g> transforms are NOT applied,
+ * so flatten those first. Measures the real outline, curves and arcs included (sampled), never the viewBox.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fitMark, checkFit } from '../src/fit/index.js';
+
+const USAGE = `Usage: logomarks-fit [--check] <file.svg | folder>... [-o out.svg]
+  Fits each file in place (a folder: every .svg in it). -o writes one file's fit to another file;
+  so does a second path that doesn't exist yet (in.svg out.svg). --check only reports.`;
+
+/**
+ * Stops with a message and the usage.
+ *
+ * @param {string} msg What is wrong.
+ * @returns {never}
+ */
+const fail = (msg) => { console.error(`logomarks-fit: ${msg}\n${USAGE}`); process.exit(2); };
+
+const args = process.argv.slice(2);
+if (args.some((a) => a === '--help' || a === '-h')) { console.log(USAGE); process.exit(0); }
+const checking = args.includes('--check');
+/** @type {string | null} */
+let out = null;
+/** @type {string[]} */
+const paths = [];
+for (let i = 0; i < args.length; i++) {
+	if (args[i] === '--check') continue;
+	if (args[i] === '-o' || args[i] === '--out') { out = args[++i] ?? fail(`${args[i - 1]} needs a file`); continue; }
+	if (args[i].startsWith('-')) fail(`unknown option ${args[i]}`);
+	paths.push(args[i]);
+}
+if (!paths.length) fail('no file or folder given');
+for (const p of paths) if (!fs.existsSync(p)) {
+	// in.svg out.svg: the second path names the file to write, as -o does
+	if (!checking && !out && paths.length === 2 && p === paths[1] && p.endsWith('.svg')) out = /** @type {string} */ (paths.pop());
+	else fail(`${p} doesn't exist`);
+}
+if (out && (checking || paths.length !== 1 || fs.statSync(paths[0]).isDirectory())) fail('-o takes one .svg file to fit, without --check');
+/** @type {string[]} */
+const files = [];
+for (const a of paths) {
+	if (fs.statSync(a).isDirectory()) for (const f of fs.readdirSync(a)) { if (f.endsWith('.svg')) files.push(path.join(a, f)); }
+	else files.push(a);
+}
+let bad = 0;
+for (const file of files) {
+	const svg = fs.readFileSync(file, 'utf8');
+	try {
+		if (checking) {
+			const { problems, size } = checkFit(svg);
+			if (problems.length) bad++;
+			console.log(`${problems.length ? '✗' : '✓'} ${file} ${size}${problems.length ? ' — ' + problems.join('; ') : ''}`);
+		} else {
+			const r = fitMark(svg);
+			fs.writeFileSync(out ?? file, r.svg);
+			const c = checkFit(r.svg);
+			console.log(`${c.problems.length ? '✗' : '✓'} ${out ?? file} (was ${r.before.w.toFixed(1)}×${r.before.h.toFixed(1)}, now ${c.size})`);
+			if (c.problems.length) bad++;
+		}
+	} catch (e) {
+		bad++;
+		console.log(`✗ ${file} — ${/** @type {Error} */ (e).message}`);
+	}
+}
+process.exit(bad ? 1 : 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logomarks/core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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",
@@ -105,7 +105,7 @@
     "./package.json": "./package.json"
   },
   "bin": {
-    "logomarks-skill": "bin/skill.js"
+    "logomarks-fit": "bin/fit.js"
   },
   "files": [
     "bin",

package/src/analyse/index.d.ts

@@ -6,3 +6,4 @@ export { SPECKS, vectorParts, rasterParts, markParts, smallParts } from './speck
 export { SHAPE, shapeTags, tagsOf } from './tags.js';
 export { MEASURE, shapeMeasures } from './shape/measures.js';
 export { WIDTHS, groupRuns, widths } from './widths.js';
+export { OPTICAL, markBox, inkShare, opticalScale } from './optical.js';

package/src/analyse/index.js

@@ -1,8 +1,9 @@
 /**
- * Analysis of a mark: its pieces and holes (specks, slivers, pin-holes), its stroke and gap widths, and its shape tags
- * (with the measures they are decided on).
+ * Analysis of a mark: its pieces and holes (specks, slivers, pin-holes), its stroke and gap widths, its shape tags
+ * (with the measures they are decided on), and its optical size (its real box and how much of it is ink).
  */
 export { SPECKS, vectorParts, rasterParts, markParts, smallParts } from './specks.js';
 export { SHAPE, shapeTags, tagsOf } from './tags.js';
 export { MEASURE, shapeMeasures } from './shape/measures.js';
 export { WIDTHS, groupRuns, widths } from './widths.js';
+export { OPTICAL, markBox, inkShare, opticalScale } from './optical.js';

package/src/analyse/optical.d.ts

@@ -0,0 +1,20 @@
+import type { Bounds } from '../svg/outline.js';
+
+/** The optical size's limits: the most a mark grows, and how much its box and its ink count. */
+export const OPTICAL: {
+	/** The most a mark grows (× its 448 fit). */
+	readonly max: 1.3;
+	/** The box's term: (448² / its area) to this power, so a square is 1, 448 × 200 about 1.22. */
+	readonly power: 0.25;
+	/** The ink's term: up to this much more for a light mark … */
+	readonly light: 0.1;
+	/** … in full at or below this share of its box inked, none at or above `solid`. */
+	readonly thin: 0.2;
+	readonly solid: 0.45;
+};
+/** The real box round a mark's outlines (its paths, or the whole file), on the 512 canvas; the 448 fit's box when there is nothing to read. */
+export function markBox(paths: string): Bounds;
+/** How much of a mark's own box is ink, 0–1 (scanline coverage, 16 cells across its longest side); 1 when there is nothing to read. */
+export function inkShare(paths: string): number;
+/** The mark's optical size: how much bigger to draw a wide, slim or light mark, 1 to `OPTICAL.max`; `ink` 1 leaves the ink out of it. */
+export function opticalScale(box: Pick<Bounds, 'w' | 'h'>, ink?: number): number;

package/src/analyse/optical.js

@@ -0,0 +1,76 @@
+/**
+ * @module @logomarks/core/analyse/optical
+ *
+ * A mark's optical size: its real box, how much of that box is ink, and how much bigger to draw it so a wide, slim or
+ * light mark holds as much of the eye as a square, solid one at the 448 fit. Browser-safe (core's SVG reader and
+ * scanline coverage, no renderer). From the Lookbook's mark measures (`@logomarks/lookbook/marks`).
+ */
+
+import { shapes } from '../svg/shapes.js';
+import { bounds } from '../svg/outline.js';
+import { rings } from '../svg/rings.js';
+import { cellsAcross, pixelCoverage } from '../edit/pixelate.js';
+import { CANVAS, FIT } from '../fit/index.js';
+
+/** The 448 fit's box on the 512 canvas: what `markBox` gives when there is nothing to read. */
+const FITTED = { x: (CANVAS - FIT) / 2, y: (CANVAS - FIT) / 2, w: FIT, h: FIT };
+
+/** The optical size's limits: the most a mark grows, and how much its box and its ink count. */
+export const OPTICAL = {
+	/** The most a mark grows (× its 448 fit). */
+	max: 1.3,
+	/** The box's term: (448² / its area) to this power, so a square is 1, 448 × 200 about 1.22. */
+	power: 0.25,
+	/** The ink's term: up to this much more for a light mark … */
+	light: 0.1,
+	/** … in full at or below this share of its box inked, none at or above `solid`. */
+	thin: 0.2,
+	solid: 0.45,
+};
+
+/**
+ * The real box round a mark's outlines, on the 512 canvas (curves and arcs sampled, as the fit measures them); the
+ * 448 fit's box when there is nothing to read.
+ *
+ * @param {string} paths The mark's markup: its paths, or the whole file.
+ * @returns {import('../svg/outline.js').Bounds} The box.
+ */
+export function markBox(paths) {
+	const list = shapes(paths);
+	if (!list.length) return { ...FITTED };
+	const b = bounds(list);
+	return Number.isFinite(b.w) && b.w > 0 ? b : { ...FITTED };
+}
+
+/**
+ * How much of a mark's own box is ink, 0–1: the scanline coverage on a grid 16 cells across its longest side.
+ *
+ * @param {string} paths The mark's markup: its paths, or the whole file.
+ * @returns {number} The share inked; 1 when there is nothing to read.
+ */
+export function inkShare(paths) {
+	const list = shapes(paths);
+	if (!list.length) return 1;
+	const grid = cellsAcross(16, markBox(paths));
+	const cov = pixelCoverage(list.map((s) => ({ rings: rings(s.segs, 3), evenodd: s.evenodd })), grid);
+	let sum = 0;
+	for (const v of cov) sum += v;
+	return cov.length ? sum / cov.length : 1;
+}
+
+/**
+ * The mark's optical size: how much bigger to draw it so it holds as much of the eye as a square, solid mark at the
+ * 448 fit. Every mark is fitted to 448 on its longest side, so a wide, short one (448 × 200) or a slim one (266 × 448)
+ * carries far less area, and a light, line-drawn one less weight. 1 for a square solid; 448 × 200 about 1.22; never
+ * below 1, never above `OPTICAL.max`.
+ *
+ * @param {{ w: number, h: number }} box The mark's box (`markBox`).
+ * @param {number} [ink=1] The share of its box inked (`inkShare`); 1 leaves the ink out of it.
+ * @returns {number} The scale, 1 to `OPTICAL.max`.
+ */
+export function opticalScale(box, ink = 1) {
+	const { max, power, light, thin, solid } = OPTICAL;
+	const area = (FIT * FIT) / Math.max(1, box.w * box.h);
+	const weight = 1 + light * Math.min(1, Math.max(0, (solid - ink) / (solid - thin)));
+	return Math.min(max, Math.max(1, area ** power * weight));
+}

package/src/edit/cells.d.ts

@@ -0,0 +1,13 @@
+import type { PixelGrid } from './pixelate.js';
+
+/** A mark as square cells: the grid, which cells are filled (row by row), and the filled cells as one path. */
+export interface MarkCells {
+	grid: PixelGrid;
+	/** 1 per filled cell, row by row. */
+	on: Uint8Array;
+	/** The filled cells merged into rectangles, as one path's d; empty when none is filled. */
+	d: string;
+}
+
+/** The mark (its paths, or the whole file) as square cells, `n` across its longest side, by scanline coverage. */
+export function markCells(paths: string, n: number): MarkCells;

package/src/edit/cells.js

@@ -0,0 +1,26 @@
+/**
+ * @module @logomarks/core/edit/cells
+ *
+ * A mark as square cells by count: shapes → rings → scanline coverage → filled cells in one call, on a grid `n` cells
+ * across the mark's real box (`cellsAcross`). Browser-safe. From the Lookbook's mark measures (its pixel and LED looks).
+ */
+
+import { shapes } from '../svg/shapes.js';
+import { rings } from '../svg/rings.js';
+import { markBox } from '../analyse/optical.js';
+import { cellsAcross, pixelCoverage, pixelCells, pixelPath } from './pixelate.js';
+
+/**
+ * The mark as square cells, `n` across its longest side, measured by scanline coverage (half a cell covered, or a
+ * fifth where a cell would otherwise break a thin line: `pixelCells`).
+ *
+ * @param {string} paths The mark's markup: its paths, or the whole file.
+ * @param {number} n Cells across the longest side.
+ * @returns {import('./cells.js').MarkCells} The grid, the filled cells and the filled cells as one path (empty when none).
+ */
+export function markCells(paths, n) {
+	const list = shapes(paths);
+	const grid = cellsAcross(n, markBox(paths));
+	const cov = pixelCoverage(list.map((s) => ({ rings: rings(s.segs), evenodd: s.evenodd })), grid);
+	return { grid, on: pixelCells(cov, grid), d: pixelPath(cov, grid) ?? '' };
+}

package/src/edit/index.d.ts

@@ -1,6 +1,8 @@
 export type { ShapeInfo, SmallSizeInfo } from './reshape.js';
 export type { Adjust, Frame, Similarity, AdjustEnv } from './adjust.js';
 export type { PixelGrid } from './pixelate.js';
+export type { MarkCells } from './cells.js';
 export { loadShaper, shaperReady, hasCorners, reshape, pieceCount, shapeInfo, smallSizeInfo } from './reshape.js';
 export { NO_ADJUST, isAdjusted, adjustSuffix, transformPath, adjustPaths } from './adjust.js';
-export { SS, pixelGrid, pixelPath, pixelCells, pixelCoverage } from './pixelate.js';
+export { SS, pixelGrid, cellsAcross, pixelPath, pixelCells, pixelCoverage } from './pixelate.js';
+export { markCells } from './cells.js';

package/src/edit/index.js

@@ -1,7 +1,9 @@
 /**
  * Shape edits for a studio: weight, soften, gap and detail (Clipper, loaded on first use), turns, tilts, flips and
- * frames, and pixel-art redraws. Browser-safe: what needs a renderer (exact bounds, a canvas) is passed in.
+ * frames, and pixel-art redraws (by amount, or by a count of cells across). Browser-safe: what needs a renderer (exact
+ * bounds, a canvas) is passed in.
  */
 export { loadShaper, shaperReady, hasCorners, reshape, pieceCount, shapeInfo, smallSizeInfo } from './reshape.js';
 export { NO_ADJUST, isAdjusted, adjustSuffix, transformPath, adjustPaths } from './adjust.js';
-export { SS, pixelGrid, pixelPath, pixelCells, pixelCoverage } from './pixelate.js';
+export { SS, pixelGrid, cellsAcross, pixelPath, pixelCells, pixelCoverage } from './pixelate.js';
+export { markCells } from './cells.js';

package/src/edit/pixelate.d.ts

@@ -13,6 +13,8 @@ export interface PixelGrid {
 export const SS: 6;
 /** The grid for a box: 48 cells across its longest side at amount 0, 14 at amount 1, centred. */
 export function pixelGrid(amount: number, box: { x: number; y: number; width: number; height: number }): PixelGrid;
+/** The grid for a box by count: `n` cells across its longest side (any `n`), centred. */
+export function cellsAcross(n: number, box: { x: number; y: number; w: number; h: number }): PixelGrid;
 /** How much of each cell the mark's rings cover (0–1, row by row), by scanline at SS × SS samples a cell. */
 export function pixelCoverage(paths: readonly FillPath[], grid: PixelGrid): Float32Array;
 /** The filled cells (1 each, row by row): half covered, or a fifth where a cell stands alone or bridges two. */

package/src/edit/pixelate.js

@@ -36,6 +36,21 @@ export function pixelGrid(amount, box) {
 	return { cols, rows, cell, x0, y0 };
 }
 
+/**
+ * A pixel grid of `n` cells across a box's longest side, centred on it: `pixelGrid` sized by a count, any count
+ * (`pixelGrid` takes an amount and stops at 14 across).
+ *
+ * @param {number} n Cells across the longest side.
+ * @param {{ x: number, y: number, w: number, h: number }} box The mark's box (`markBox` in `/analyse`, or `bounds`).
+ * @returns {import('./index.js').PixelGrid} The grid: columns, rows, cell size and top-left corner.
+ */
+export function cellsAcross(n, box) {
+	const cell = Math.max(box.w, box.h) / n;
+	const cols = Math.max(1, Math.round(box.w / cell)), rows = Math.max(1, Math.round(box.h / cell));
+	const x0 = box.x + box.w / 2 - (cols * cell) / 2, y0 = box.y + box.h / 2 - (rows * cell) / 2;
+	return { cols, rows, cell, x0, y0 };
+}
+
 /**
  * How much of each cell the mark covers, measured from its rings by scanline at `SS` × `SS` samples a cell: what a
  * canvas would measure, without one.

package/src/fit/index.js

@@ -129,7 +129,7 @@ export function checkFit(svg) {
 	if (!vb || vb.join(' ') !== `0 0 ${CANVAS} ${CANVAS}`) problems.push(`viewBox is "${vb?.join(' ')}", not "0 0 ${CANVAS} ${CANVAS}"`);
 	if (Math.abs(long - FIT) > FIT_TOLERANCE) problems.push(`longest side ${long.toFixed(1)}, not ${FIT}`);
 	if (Math.abs(cx - CANVAS / 2) > FIT_TOLERANCE || Math.abs(cy - CANVAS / 2) > FIT_TOLERANCE) problems.push(`centre (${cx.toFixed(1)}, ${cy.toFixed(1)}), not (${CANVAS / 2}, ${CANVAS / 2})`);
-	if (b.x < -FIT_TOLERANCE || b.y < -FIT_TOLERANCE || b.x + b.w > CANVAS + FIT_TOLERANCE || b.y + b.h > CANVAS + FIT_TOLERANCE) problems.push(`runs outside the ${CANVAS} canvas — it will be cut off; run fit.mjs on it`);
+	if (b.x < -FIT_TOLERANCE || b.y < -FIT_TOLERANCE || b.x + b.w > CANVAS + FIT_TOLERANCE || b.y + b.h > CANVAS + FIT_TOLERANCE) problems.push(`runs outside the ${CANVAS} canvas — it will be cut off; run logomarks-fit on it`);
 	if (FORBIDDEN_MARKUP.test(svg)) problems.push('contains groups, transforms, strokes, styles or masks — flatten to filled paths');
 	return { problems, size: `${b.w.toFixed(1)}×${b.h.toFixed(1)}`, bounds: b };
 }

package/src/geometry/glitch.js

@@ -12,7 +12,7 @@ import { slices } from './offset.js';
  *   { kind: 'steps', cuts: [a, b, c(, d)], shift: 22 } four or five thin bands, slid +shift, −shift alternately
  *   { kind: 'cut', cuts: [a], shift: 44 }             one cut, the lower (or right) band slid
  *   { kind: 'shear', cuts: [a(, b)], deg: 30, shift: 44 } a diagonal cut (deg from horizontal); two or three bands
- * `shifts` (one per band) overrides the pattern. Run scripts/fit.mjs on the result.
+ * `shifts` (one per band) overrides the pattern. Fit the result with fitMark() or logomarks-fit.
  */
 export function glitchMark(src, { kind = 'bands', cuts, shift = 44, shifts, deg, g = 22 } = {}) {
   const s = typeof src === 'string' ? svgShape(src) : src, n = cuts.length + 1;

package/src/geometry/path.js

@@ -24,7 +24,7 @@ export function toPath(mp, tol = 0.12) {
 }
 
 
-/** The SVG file for a shape (any size; run scripts/fit.mjs to fit it to the standard). */
+/** The SVG file for a shape (any size; fitMark(), or logomarks-fit, fits it to the standard). */
 export const svg = (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`;
 
 /** Writes a shape to an SVG file. */

package/src/parts/frame.js

@@ -27,7 +27,7 @@ export const centre = (g) => { const [x0, y0, x1, y1] = bbox(g); return mapPts(g
 export const outline = (shape) => (typeof shape[0][0][0] === 'number' ? shape[0] : shape[0][0]);
 /** Stacks parts back to front, each later part in front of everything before it and cut free by the gap g. */
 export const chain = (g, ...parts) => parts.reduce((scene, p) => over(scene, p, g));
-/** Builds a mark whose gap lands on exactly `G` once fit.mjs scales it to 448: `build(g)` draws it with gap g; it's drawn,
+/** Builds a mark whose gap lands on exactly `G` once the fit scales it to 448: `build(g)` draws it with gap g; it's drawn,
  * measured, and drawn again with the gap divided by the fit's scale (twice, as the gap changes the size a little).
  * `before()` runs before every draw (seed Math.random there, so robust()'s jitter repeats). */
 export const exact = (build, before = () => {}, target = G) => { let g = target, s;

package/bin/skill.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-/**
- * logomarks-skill <dir> [--url <url>]: writes the design skill's scripts/kit.mjs and scripts/fit.mjs into <dir>,
- * generated from @logomarks/core. `{{url}}` stays in their headers unless --url fills it.
- */
-import { writeSkillScripts } from '../src/skill/bundle.js';
-
-const args = process.argv.slice(2), at = args.indexOf('--url');
-const url = at >= 0 ? args.splice(at, 2)[1] : undefined;
-if (!args[0]) {
-	console.log('Usage: logomarks-skill <dir> [--url <url>]');
-	process.exit(1);
-}
-for (const file of writeSkillScripts(args[0], { url })) console.log('wrote', file);

package/src/skill/bundle.d.ts

@@ -1,6 +0,0 @@
-/** The skill's kit.mjs: the geometry kit as one file needing only polygon-clipping, `{{url}}` unfilled. */
-export function bundleKit(): string;
-/** The skill's fit.mjs: the fit and check as one script with no dependencies, `{{url}}` unfilled. */
-export function bundleFit(): string;
-/** Writes both scripts into a folder; `url` fills `{{url}}`. Returns the files written. */
-export function writeSkillScripts(dir: string, o?: { url?: string }): string[];

package/src/skill/bundle.js

@@ -1,181 +0,0 @@
-/**
- * @module @logomarks/core/skill
- *
- * The design skill's two scripts, generated from the library so they never drift: `kit.mjs` (the geometry kit as one
- * file, needing only polygon-clipping) and `fit.mjs` (the fit and check, no dependencies). Each module's code goes in
- * as it is, its imports dropped and its exports kept only where the script exposes them. `{{url}}` in each header is
- * left for the skill's build to fill.
- */
-
-import fs from 'node:fs';
-import * as geometry from '../geometry/index.js';
-
-const SRC = new URL('../', import.meta.url);
-
-/** The geometry kit's modules, in dependency order. */
-const KIT = ['geometry/core.js', 'geometry/booleans.js', 'geometry/polygon.js', 'geometry/random.js', 'geometry/shapes.js', 'geometry/stroke.js',
-	'geometry/path.js', 'geometry/offset.js', 'geometry/mitre.js', 'geometry/iso.js', 'geometry/modular.js', 'geometry/badges.js', 'geometry/letters.js',
-	'svg/path.js', 'svg/shapes.js', 'svg/rings.js', 'svg/nonzero.js', 'svg/shape.js', 'geometry/glitch.js', 'geometry/needle.js'];
-
-/** The fit's modules, in dependency order. */
-const FIT = ['svg/path.js', 'svg/shapes.js', 'svg/outline.js', 'util/number.js', 'fit/index.js'];
-
-const KIT_HEADER = `// Logomarks geometry kit — the helpers the Logomarks set was built with.
-// {{url}} · CC0
-//
-// Shapes are polygon sets (arrays of rings of [x, y] points, y pointing down) on a
-// 512 canvas with C = 256 as the centre. Combine them with real booleans:
-//   U(...shapes) union · D(a, ...b) subtract · I(...) intersect · X(...) exclude
-// then write the result with svg(shape) or write('name.svg', shape).
-// Sizes don't need to be exact: scripts/fit.mjs scales every mark to the set's
-// standard (longest side 448, centred) afterwards.
-//
-// Needs one package: npm install polygon-clipping
-// Generated from @logomarks/core (its geometry) by logomarks-skill: edit the library, not this file.
-import pc from 'polygon-clipping';
-`;
-
-const FIT_HEADER = `#!/usr/bin/env node
-// Fits SVG marks to the Logomarks standard: 512×512 canvas, the mark's longest side
-// exactly 448, centred (a 32 margin), filled paths in currentColor, nothing else.
-// {{url}} · CC0 · no dependencies
-//
-//   node fit.mjs mark.svg                 fit in place
-//   node fit.mjs in.svg -o out.svg        fit to another file (in.svg out.svg too, while out.svg doesn't exist)
-//   node fit.mjs a.svg b.svg marks/       fit each file, and every .svg in a folder, in place
-//   node fit.mjs --check mark.svg marks/  only report; exits 1 if anything is off
-//
-// Reads <path d> (with fill-rule), <circle>, <ellipse>, <rect> and <polygon>; nested
-// <g> transforms are NOT applied, so flatten those first. Measures the real outline,
-// curves and arcs included (sampled), never the viewBox.
-// Generated from @logomarks/core (its svg and fit) by logomarks-skill: edit the library, not this file.
-
-import fs from 'node:fs';
-import path from 'node:path';
-`;
-
-/** fit.mjs's command line. */
-const FIT_MAIN = `
-// ---------- command line ----------
-
-const USAGE = \`Usage: node fit.mjs [--check] <file.svg | folder>... [-o out.svg]
-  Fits each file in place (a folder: every .svg in it). -o writes one file's fit to another file;
-  so does a second path that doesn't exist yet (in.svg out.svg). --check only reports.\`;
-
-/** Stops with a message and the usage. */
-const fail = (msg) => { console.error(\`fit.mjs: \${msg}\\n\${USAGE}\`); process.exit(2); };
-
-const args = process.argv.slice(2);
-if (args.some((a) => a === '--help' || a === '-h')) { console.log(USAGE); process.exit(0); }
-const checking = args.includes('--check');
-let out = null;
-const paths = [];
-for (let i = 0; i < args.length; i++) {
-	if (args[i] === '--check') continue;
-	if (args[i] === '-o' || args[i] === '--out') { out = args[++i] ?? fail(\`\${args[i - 1]} needs a file\`); continue; }
-	if (args[i].startsWith('-')) fail(\`unknown option \${args[i]}\`);
-	paths.push(args[i]);
-}
-if (!paths.length) fail('no file or folder given');
-for (const p of paths) if (!fs.existsSync(p)) {
-	// in.svg out.svg: the second path names the file to write, as -o does
-	if (!checking && !out && paths.length === 2 && p === paths[1] && p.endsWith('.svg')) out = paths.pop();
-	else fail(\`\${p} doesn't exist\`);
-}
-if (out && (checking || paths.length !== 1 || fs.statSync(paths[0]).isDirectory())) fail('-o takes one .svg file to fit, without --check');
-const files = [];
-for (const a of paths) {
-	if (fs.statSync(a).isDirectory()) for (const f of fs.readdirSync(a)) { if (f.endsWith('.svg')) files.push(path.join(a, f)); }
-	else files.push(a);
-}
-let bad = 0;
-for (const file of files) {
-	const svg = fs.readFileSync(file, 'utf8');
-	try {
-		if (checking) {
-			const { problems, size } = checkFit(svg);
-			if (problems.length) bad++;
-			console.log(\`\${problems.length ? '✗' : '✓'} \${file} \${size}\${problems.length ? ' — ' + problems.join('; ') : ''}\`);
-		} else {
-			const r = fitMark(svg);
-			fs.writeFileSync(out ?? file, r.svg);
-			const c = checkFit(r.svg);
-			console.log(\`\${c.problems.length ? '✗' : '✓'} \${out ?? file} (was \${r.before.w.toFixed(1)}×\${r.before.h.toFixed(1)}, now \${c.size})\`);
-			if (c.problems.length) bad++;
-		}
-	} catch (e) {
-		bad++;
-		console.log(\`✗ \${file} — \${e.message}\`);
-	}
-}
-process.exit(bad ? 1 : 0);
-`;
-
-/**
- * One module's code for a single-file script: its header docblock as a section line, its imports dropped, and
- * `export` kept only on the names in `keep`.
- *
- * @param {string} file The module, relative to src/.
- * @param {ReadonlySet<string>} keep The names the script exports.
- * @returns {{ code: string, names: string[] }} The code, and the top-level names it declares.
- */
-function inline(file, keep) {
-	let s = fs.readFileSync(new URL(file, SRC), 'utf8');
-	const doc = /^\/\*\*([\s\S]*?)\*\/\n/.exec(s);
-	const title = doc ? doc[1].split('\n').map((l) => l.replace(/^\s*\*\s?/, '')).filter((l) => l && !l.startsWith('@module')).join(' ').split(/[.:](\s|$)/)[0] : file;
-	if (doc) s = s.slice(doc[0].length);
-	if (/^import \{[^}]* as /m.test(s)) throw new Error(`skill bundle: ${file} renames an import, which a single file can't keep`);
-	s = s.replace(/^import [^\n]*\n/gm, '').replace(/^\n+/, '');
-	const names = [];
-	s = s.replace(/^export (const|function|async function|let) ([\w$]+)/gm, (m, kind, name) => { names.push(name); return keep.has(name) ? m : `${kind} ${name}`; });
-	for (const m of s.matchAll(/^(?:const|function|async function|let) ([\w$]+)/gm)) if (!names.includes(m[1])) names.push(m[1]);
-	return { code: `// ---------- ${title.trim()} (${file}) ----------\n\n${s.trimEnd()}\n`, names };
-}
-
-/**
- * Modules joined into one script; throws when two declare the same top-level name.
- *
- * @param {readonly string[]} files The modules.
- * @param {ReadonlySet<string>} keep The names the script exports.
- * @returns {string} The code.
- */
-function join(files, keep) {
-	const seen = new Map();
-	return files.map((f) => {
-		const { code, names } = inline(f, keep);
-		for (const n of names) {
-			if (seen.has(n)) throw new Error(`skill bundle: ${n} is declared in both ${seen.get(n)} and ${f}`);
-			seen.set(n, f);
-		}
-		return code;
-	}).join('\n');
-}
-
-/**
- * The skill's `kit.mjs`: the geometry kit as one file (every export of `@logomarks/core/geometry`).
- *
- * @returns {string} The script, `{{url}}` unfilled.
- */
-export const bundleKit = () => KIT_HEADER + '\n' + join(KIT, new Set(Object.keys(geometry)));
-
-/**
- * The skill's `fit.mjs`: the fit and the check as one script with no dependencies.
- *
- * @returns {string} The script, `{{url}}` unfilled.
- */
-export const bundleFit = () => FIT_HEADER + '\n' + join(FIT, new Set()) + FIT_MAIN;
-
-/**
- * Writes both scripts into a folder (the skill's `scripts/`).
- *
- * @param {string} dir The folder.
- * @param {{ url?: string }} [o] A URL to fill `{{url}}` with (left as is by default).
- * @returns {string[]} The files written.
- */
-export function writeSkillScripts(dir, { url } = {}) {
-	const fill = (/** @type {string} */ s) => (url ? s.replaceAll('{{url}}', url) : s);
-	fs.mkdirSync(dir, { recursive: true });
-	const out = [[`${dir}/kit.mjs`, bundleKit()], [`${dir}/fit.mjs`, bundleFit()]];
-	for (const [file, text] of out) fs.writeFileSync(file, fill(text));
-	return out.map(([file]) => file);
-}