@logomarks/core 0.0.0-stage → 0.1.3

package/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+All notable changes to `@logomarks/core` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.3] — 2026-11-06
+
+### Fixed
+
+- `letterSignatures()` counts a pixel as ink only above half coverage (8-bit alpha 128 and up, as `holecheck.mjs` did): with Float32 coverage, an alpha of 127 rounded past `127 / 255` and counted, which moved letter scores by about a hundredth and could reorder near matches.
+
+## [0.1.2] — 2026-11-06
+
+### Changed
+
+- Renamed from `@logomarks/marks-kit` to `@logomarks/core`, and its bin from `marks-kit-skill` to `logomarks-skill` (the generated scripts' headers name both); no code changes. The repository is now github.com/Logomarks/core.
+
+## [0.1.1] — 2026-11-05
+
+### Changed
+
+- Renamed to `@logomarks/marks-kit`; no code changes.
+
+## [0.1.0] — 2026-11-05
+
+### Added
+
+- **Geometry** (`/geometry`): the Logomarks kit, split into modules: shapes, booleans with the opt-in `robust()` retry (and `robustOps(rand)`, which leaves polygon-clipping and `Math.random` alone), strokes, weaves, tracks, fillets, offsets, iso solids, modular systems, the house badges and PIX7, letter skeletons, glitch editions and `deneedle()`. Every generator of the Logomarks set redraws byte-identical with it.
+- **SVG** (`/svg`): one path parser for everything that reads a mark, the filled elements of a file, outline bounds, rings, and a whole mark read back as a shape.
+- **Fit** (`/fit`): `fitMark()` and `checkFit()`, byte-identical to the design skill's `fit.mjs`.
+- **Analysis** (`/analyse`): pieces and holes (vector, or a scanline raster), small-part classification, gap and stroke widths, shape tags.
+- **Similarity** (`/similar`): outline and letter signatures from coverage, IoU over all 8 rotations and flips, and `nearestAll()` for "More like this".
+- **Raster** (`/raster`): scanline fill, connected components, distance transform, even-width runs.
+- **Edits** (`/edit`): the studio's reshape (weight, soften, gap, detail with clipper-lib, an optional peer), adjustments and frames, and the pixelate grid.
+- **Parts** (`/parts`): the industry-symbol parts merged into one set: placing and sizing, curves, house lines, badges, tiles, iso scenes, letters, trade objects, faceted heads, and the batch writer.
+- **`marks-kit-skill`**: writes the design skill's single-file `kit.mjs` and `fit.mjs`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ArrayPress Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,47 @@
-# Temporary Holding Version
+# @logomarks/core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Geometry, SVG reading, fitting, analysis and similarity for logomarks on a 512 grid: the kit the [Logomarks](https://logomarks.ai) set is drawn with.
+
+## Install
+
+```bash
+npm install @logomarks/core
+npm install clipper-lib   # only for the shape edits (reshape)
+```
+
+## Quick start
+
+```js
+import { U, D, rect, circle, svg } from '@logomarks/core/geometry';
+import { fitMark, checkFit } from '@logomarks/core/fit';
+
+// Moonrise: a block with a half-moon bitten out of the top, a sun left floating in the bite.
+const raw = svg(U(D(rect(0, 0, 300, 300), circle(150, 0, 120)), circle(150, 30, 46)));
+const { svg: mark } = fitMark(raw);   // 512 canvas, longest side 448, centred, 0.1 grid
+checkFit(mark).problems;              // []
+```
+
+## 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
+- `/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
+- `/parts`: the parts the industry symbols are built from (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).
+
+## Links
+
+- [Docs](https://github.com/Logomarks/core/tree/main/docs)
+- [Changelog](https://github.com/Logomarks/core/blob/main/CHANGELOG.md)
+- [Licence](https://github.com/Logomarks/core/blob/main/LICENSE)
+- [GitHub](https://github.com/Logomarks/core)
+
+## Licence
+
+MIT © ArrayPress Limited; author David Sherlock.

package/bin/skill.js

@@ -0,0 +1,14 @@
+#!/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/package.json

@@ -1,6 +1,120 @@
 {
   "name": "@logomarks/core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.3",
+  "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, and the industry-symbol parts.",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./geometry": {
+      "types": "./src/geometry/index.d.ts",
+      "import": "./src/geometry/index.js",
+      "default": "./src/geometry/index.js"
+    },
+    "./parts": {
+      "types": "./src/parts/index.d.ts",
+      "import": "./src/parts/index.js",
+      "default": "./src/parts/index.js"
+    },
+    "./svg": {
+      "types": "./src/svg/index.d.ts",
+      "import": "./src/svg/index.js",
+      "default": "./src/svg/index.js"
+    },
+    "./fit": {
+      "types": "./src/fit/index.d.ts",
+      "import": "./src/fit/index.js",
+      "default": "./src/fit/index.js"
+    },
+    "./raster": {
+      "types": "./src/raster/index.d.ts",
+      "import": "./src/raster/index.js",
+      "default": "./src/raster/index.js"
+    },
+    "./analyse": {
+      "types": "./src/analyse/index.d.ts",
+      "import": "./src/analyse/index.js",
+      "default": "./src/analyse/index.js"
+    },
+    "./similar": {
+      "types": "./src/similar/index.d.ts",
+      "import": "./src/similar/index.js",
+      "default": "./src/similar/index.js"
+    },
+    "./edit": {
+      "types": "./src/edit/index.d.ts",
+      "import": "./src/edit/index.js",
+      "default": "./src/edit/index.js"
+    },
+    "./edit/reshape": {
+      "types": "./src/edit/reshape.d.ts",
+      "import": "./src/edit/reshape.js",
+      "default": "./src/edit/reshape.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "logomarks-skill": "bin/skill.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test tests/*.test.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "logo",
+    "logomark",
+    "logomarks",
+    "geometry",
+    "svg",
+    "polygon",
+    "boolean",
+    "isometric",
+    "path",
+    "fit",
+    "similarity"
+  ],
+  "author": "David Sherlock",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Logomarks/core.git"
+  },
+  "homepage": "https://www.npmjs.com/package/@logomarks/core",
+  "bugs": "https://github.com/Logomarks/core/issues",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "polygon-clipping": "^0.15.7"
+  },
+  "peerDependencies": {
+    "clipper-lib": "^6.4.2"
+  },
+  "peerDependenciesMeta": {
+    "clipper-lib": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.6",
+    "clipper-lib": "^6.4.2",
+    "typescript": "^6.0.3"
+  }
+}

package/src/analyse/index.d.ts

@@ -0,0 +1,6 @@
+export type { Part, PartsRead, SmallOptions, SkipReason } from './specks.js';
+export type { ShapeTag } from './tags.js';
+export type { RunGroup, WidthSettings } from './widths.js';
+export { SPECKS, vectorParts, rasterParts, markParts, smallParts } from './specks.js';
+export { shapeTags } from './tags.js';
+export { WIDTHS, groupRuns, widths } from './widths.js';

package/src/analyse/index.js

@@ -0,0 +1,6 @@
+/**
+ * Analysis of a mark: its pieces and holes (specks, slivers, pin-holes), its stroke and gap widths, and its shape tags.
+ */
+export { SPECKS, vectorParts, rasterParts, markParts, smallParts } from './specks.js';
+export { shapeTags } from './tags.js';
+export { WIDTHS, groupRuns, widths } from './widths.js';

package/src/analyse/specks.d.ts

@@ -0,0 +1,49 @@
+import type { Box } from '../geometry/types.js';
+import type { FilledPath } from '../svg/shapes.js';
+
+/** One piece or hole of a mark. */
+export interface Part {
+	kind: 'piece' | 'hole';
+	/** Square units of the 512 canvas. */
+	area: number;
+	/** Mean width: 2 · area / perimeter. */
+	width: number;
+	box: Box;
+	/** Read from the raster. */
+	raster?: boolean;
+}
+/** A mark's parts and how they were read. */
+export interface PartsRead {
+	parts: Part[];
+	raster: boolean;
+	/** Why the vector read failed, when it did. */
+	error?: string;
+}
+/** The limits for smallParts(). */
+export interface SmallOptions {
+	piece?: number;
+	hole?: number;
+	raster?: boolean;
+}
+/** Why a small part is left out: '' when it is a real speck. */
+export type SkipReason = '' | 'tiny' | 'hairline' | 'repeated';
+
+/** The house limits for specks. */
+export const SPECKS: {
+	piece: number;
+	hole: number;
+	tiny: number;
+	hairline: number;
+	sliver: number;
+	repeat: number;
+	tolerance: { vector: number; raster: number };
+	rasterScale: number;
+};
+/** Every piece and hole, read as vectors; `seed` (the slug) seeds the booleans' retry jitter. */
+export function vectorParts(paths: readonly FilledPath[], seed?: string): Part[];
+/** Every piece and hole, read from a scanline raster at `scale` px a unit (8). */
+export function rasterParts(paths: readonly FilledPath[], scale?: number): Part[];
+/** The vector read, or the raster read when the booleans throw (or `raster` is set). */
+export function markParts(paths: readonly FilledPath[], o?: { seed?: string; raster?: boolean }): PartsRead;
+/** The small parts, smallest first, each with why it is left out. */
+export function smallParts(parts: readonly Part[], o?: SmallOptions): (Part & { skip: SkipReason })[];

package/src/analyse/specks.js

@@ -0,0 +1,99 @@
+/**
+ * @module @logomarks/core/analyse/specks
+ *
+ * A mark's pieces and holes, to find the stray specks, slivers and pin-holes a boolean leaves behind. Read as vectors
+ * (every outline unioned with its fill rule, booleans retried with a jitter seeded by the mark's name, so a read
+ * repeats), or, when the booleans can't read it, from a scanline raster (connected components: 8-connected pieces,
+ * 4-connected holes). Areas are square units of the 512 canvas: run it on fitted marks.
+ */
+
+import { robustOps } from '../geometry/booleans.js';
+import { seeded } from '../geometry/random.js';
+import { area, perimeter, ringBox } from '../geometry/polygon.js';
+import { filledShape } from '../svg/shape.js';
+import { rings } from '../svg/rings.js';
+import { frameOf, fill } from '../raster/scanline.js';
+import { components } from '../raster/components.js';
+
+/** The house limits: a piece under `piece` is a speck, a hole under `hole` a pin-hole; parts `tiny`, `hairline` (mean
+ * width) or repeated `repeat` times (within `tolerance` of each other's area) are left out. */
+export const SPECKS = { piece: 60, hole: 30, tiny: 0.5, hairline: 0.12, sliver: 3, repeat: 6, tolerance: { vector: 0.02, raster: 0.05 }, rasterScale: 8 };
+
+/**
+ * Every piece and hole of a mark, read as vectors.
+ *
+ * @param {readonly import('../svg/shapes.js').Shape[]} paths The mark's outlines.
+ * @param {string} [seed] Seeds the booleans' retry jitter (the mark's slug), so a read repeats.
+ * @returns {import('./specks.js').Part[]} Its parts.
+ */
+export function vectorParts(paths, seed = '') {
+	/** @type {import('./specks.js').Part[]} */
+	const out = [];
+	for (const [outer, ...holes] of filledShape(paths, robustOps(seeded(seed)))) {
+		const a = area(outer) - holes.reduce((s, h) => s + area(h), 0);
+		const p = perimeter(outer) + holes.reduce((s, h) => s + perimeter(h), 0);
+		out.push({ kind: 'piece', area: a, width: (2 * a) / p, box: ringBox(outer) });
+		for (const h of holes) out.push({ kind: 'hole', area: area(h), width: (2 * area(h)) / perimeter(h), box: ringBox(h) });
+	}
+	return out;
+}
+
+/**
+ * The same, read from a scanline raster at `scale` pixels a unit (for marks the booleans can't read).
+ *
+ * @param {readonly import('../svg/shapes.js').Shape[]} paths The mark's outlines.
+ * @param {number} [scale] Pixels a unit (8).
+ * @returns {import('./specks.js').Part[]} Its parts, each marked `raster`.
+ */
+export function rasterParts(paths, scale = SPECKS.rasterScale) {
+	const fp = paths.map((s) => ({ rings: rings(s.segs, 0.5), evenodd: s.evenodd }));
+	const bm = fill(fp, frameOf(fp, scale));
+	const K = bm.scale;
+	return components(bm)
+		.filter((c) => c.ink || !c.border)
+		.map((c) => {
+			const a = c.pixels / (K * K);
+			return {
+				kind: c.ink ? 'piece' : 'hole',
+				area: a,
+				width: (2 * a) / Math.max(c.rim / K, 1e-9),
+				box: /** @type {import('../geometry/types.js').Box} */ ([bm.x0 + c.box[0] / K, bm.y0 + c.box[1] / K, bm.x0 + c.box[2] / K, bm.y0 + c.box[3] / K]),
+				raster: true,
+			};
+		});
+}
+
+/**
+ * A mark's parts: the vector read, or the raster read when the booleans throw (`error` says why).
+ *
+ * @param {readonly import('../svg/shapes.js').Shape[]} paths The mark's outlines.
+ * @param {{ seed?: string, raster?: boolean }} [o] The seed, and `raster` to skip the vector read.
+ * @returns {import('./specks.js').PartsRead} The parts and how they were read.
+ */
+export function markParts(paths, { seed = '', raster = false } = {}) {
+	if (!raster) {
+		try {
+			return { parts: vectorParts(paths, seed), raster: false };
+		} catch (e) {
+			return { parts: rasterParts(paths), raster: true, error: /** @type {Error} */ (e).message };
+		}
+	}
+	return { parts: rasterParts(paths), raster: true };
+}
+
+/**
+ * The small parts (pieces under `piece`, holes under `hole`), smallest first, each with why it is left out: '' when it
+ * is a real speck, else 'tiny' (two outlines touching), 'hairline' (a zero-width sliver) or 'repeated' (a pattern).
+ *
+ * @param {readonly import('./specks.js').Part[]} parts A mark's parts.
+ * @param {import('./specks.js').SmallOptions} [o] The limits, and whether the parts came from the raster read.
+ * @returns {(import('./specks.js').Part & { skip: '' | 'tiny' | 'hairline' | 'repeated' })[]} The small parts.
+ */
+export function smallParts(parts, { piece = SPECKS.piece, hole = SPECKS.hole, raster = false } = {}) {
+	const tol = raster ? SPECKS.tolerance.raster : SPECKS.tolerance.vector;
+	const same = (/** @type {import('./specks.js').Part} */ p) => parts.filter((q) => q.kind === p.kind && Math.abs(q.area - p.area) <= tol * Math.max(p.area, q.area)).length;
+	return parts
+		.filter((p) => p.area < (p.kind === 'piece' ? piece : hole))
+		.sort((a, b) => a.area - b.area)
+		.map((p) => ({ ...p, skip: p.area < SPECKS.tiny ? 'tiny' : p.width < SPECKS.hairline ? 'hairline' : same(p) >= SPECKS.repeat ? 'repeated' : '' }));
+}

package/src/analyse/tags.d.ts

@@ -0,0 +1,5 @@
+/** A shape tag measured from a mark's raster. */
+export type ShapeTag = 'wide' | 'tall' | 'round' | 'square' | 'solid' | 'light' | 'symmetric' | 'radial';
+
+/** A fitted mark's shape tags, from its coverage at `size` px (128) and its outline's width and height. */
+export function shapeTags(a: Float32Array, m: { w: number; h: number; size?: number }): ShapeTag[];

package/src/analyse/tags.js

@@ -0,0 +1,48 @@
+/**
+ * @module @logomarks/core/analyse/tags
+ *
+ * Shape tags measured from a mark's coverage: wide or tall, round or square, solid or light, symmetric, radial.
+ */
+
+import { remap, iou } from '../similar/signature.js';
+
+/**
+ * A fitted mark's shape tags, from its coverage at `size` px (128) and its outline's size on the 512 canvas.
+ * - wide / tall: wider than 1.25 or narrower than 0.8;
+ * - round: about square, every corner of its box empty and the silhouette reaching the edge midpoints and diagonals;
+ * - square: about square with three corners or more filled;
+ * - solid / light: over 62% or under 30% of its box inked;
+ * - symmetric: mirrors onto itself (IoU over 0.94); radial: a quarter turn (0.92) or a half turn (0.94) does.
+ *
+ * @param {Float32Array} a Coverage 0–1, `size` × `size`, row by row.
+ * @param {{ w: number, h: number, size?: number }} m The outline's width and height (fitted), and the raster's side.
+ * @returns {import('./tags.js').ShapeTag[]} The tags, in a fixed order.
+ */
+export function shapeTags(a, { w: mw, h: mh, size: N = 128 }) {
+  const tags = new Set();
+  const tf = (/** @type {(x: number, y: number) => number[]} */ f) => remap(a, N, f);
+  // bbox in raster px
+  const s = N / 512, x0 = Math.round((256 - mw / 2) * s), y0 = Math.round((256 - mh / 2) * s), w = Math.round(mw * s), h = Math.round(mh * s);
+  let fill = 0; for (let y = y0; y < y0 + h; y++) for (let x = x0; x < x0 + w; x++) fill += a[y * N + x] || 0;
+  const density = fill / (w * h);
+  const ratio = mw / mh;
+  if (ratio > 1.25) tags.add('wide'); else if (ratio < 0.8) tags.add('tall');
+  // corners of the bbox: empty everywhere → round silhouette; mostly filled → square
+  const c = Math.max(2, Math.round(Math.min(w, h) * 0.1));
+  const corner = (/** @type {number} */ cx, /** @type {number} */ cy) => { let f = 0; for (let y = cy; y < cy + c; y++) for (let x = cx; x < cx + c; x++) f += a[y * N + x] || 0; return f / (c * c); };
+  const cs = [corner(x0, y0), corner(x0 + w - c, y0), corner(x0, y0 + h - c), corner(x0 + w - c, y0 + h - c)];
+  const sq = ratio > 0.92 && ratio < 1.08;
+  if (sq && cs.every((v) => v < 0.04)) {
+    // also require the silhouette to reach the edge midpoints (a disc, not a diamond or a small blob)
+    const mid = (/** @type {number} */ x, /** @type {number} */ y) => a[y * N + x] > 0.5;
+    const r = Math.round(w / 2), cxp = x0 + r, cyp = y0 + r, d = Math.round(w * 0.06);
+    const diag = Math.round(r * 0.70);
+    if ([mid(cxp, y0 + d), mid(cxp, y0 + h - 1 - d), mid(x0 + d, cyp), mid(x0 + w - 1 - d, cyp)].filter(Boolean).length >= 3 &&
+        [mid(cxp - diag + d, cyp - diag + d), mid(cxp + diag - d, cyp - diag + d), mid(cxp - diag + d, cyp + diag - d), mid(cxp + diag - d, cyp + diag - d)].filter(Boolean).length >= 3) tags.add('round');
+  }
+  if (sq && cs.filter((v) => v > 0.6).length >= 3) tags.add('square');
+  if (density > 0.62) tags.add('solid'); else if (density < 0.3) tags.add('light');
+  if (iou(a, tf((x, y) => [N - 1 - x, y])) > 0.94 || iou(a, tf((x, y) => [x, N - 1 - y])) > 0.94) tags.add('symmetric');
+  if (iou(a, tf((x, y) => [y, N - 1 - x])) > 0.92 || iou(a, tf((x, y) => [N - 1 - x, N - 1 - y])) > 0.94) tags.add('radial');
+  return /** @type {import('./tags.js').ShapeTag[]} */ ([...tags]);
+}

package/src/analyse/widths.d.ts

@@ -0,0 +1,33 @@
+import type { Box } from '../geometry/types.js';
+import type { Channel } from '../raster/channels.js';
+import type { FilledPath } from '../svg/shapes.js';
+
+/** Runs of about the same width, taken together. */
+export interface RunGroup {
+	/** Their mean width, weighted by length. */
+	width: number;
+	/** Their total length. */
+	length: number;
+	count: number;
+	/** The box round them all. */
+	box: Box;
+}
+/** The raster's scale and padding, and what counts as a run (units of the 512 canvas). */
+export interface WidthSettings {
+	scale: number;
+	pad: number;
+	same: number;
+	tolerance: number;
+	spread: number;
+	run: number;
+	shortest: number;
+	widest: number;
+	narrowest: number;
+}
+
+/** The Logomarks settings. */
+export const WIDTHS: WidthSettings;
+/** Runs grouped by width: runs within `same` of each other are one group. */
+export function groupRuns(runs: readonly Channel[], same: number): RunGroup[];
+/** A mark's gaps and strokes, each grouped by width. */
+export function widths(paths: readonly FilledPath[], o?: Partial<WidthSettings>): { gaps: RunGroup[]; strokes: RunGroup[] };

package/src/analyse/widths.js

@@ -0,0 +1,48 @@
+/**
+ * @module @logomarks/core/analyse/widths
+ *
+ * A mark's gaps and strokes, measured on a raster as runs of even width (raster/channels.js) and grouped by width:
+ * what tells a mark that keeps one gap from one that doesn't, and a feature too thin to survive 32 px.
+ */
+
+import { rings } from '../svg/rings.js';
+import { frameOf, fill } from '../raster/scanline.js';
+import { channels } from '../raster/channels.js';
+
+/** What counts as a run (units of the 512 canvas), and the raster's scale: the Logomarks settings. */
+export const WIDTHS = { scale: 2, pad: 4, same: 3, tolerance: 2, spread: 1, run: 3, shortest: 16, widest: 32, narrowest: 1 };
+
+/**
+ * Runs grouped by width: runs within `same` of each other are one group.
+ *
+ * @param {readonly import('../raster/channels.js').Channel[]} runs The runs, narrowest first.
+ * @param {number} same How far apart two widths can be and still be one group.
+ * @returns {import('./widths.js').RunGroup[]} The groups, each with its mean width, total length, count and box.
+ */
+export function groupRuns(runs, same) {
+	/** @type {import('./widths.js').RunGroup[]} */
+	const out = [];
+	for (const c of runs) {
+		const g = out.find((x) => Math.abs(x.width - c.width) <= same);
+		if (!g) { out.push({ width: c.width, length: c.length, count: 1, box: [...c.box] }); continue; }
+		g.width = (g.width * g.length + c.width * c.length) / (g.length + c.length);
+		g.length += c.length;
+		g.count++;
+		g.box = [Math.min(g.box[0], c.box[0]), Math.min(g.box[1], c.box[1]), Math.max(g.box[2], c.box[2]), Math.max(g.box[3], c.box[3])];
+	}
+	return out;
+}
+
+/**
+ * A mark's gaps and strokes, each grouped by width.
+ *
+ * @param {readonly import('../svg/shapes.js').Shape[]} paths The mark's outlines.
+ * @param {Partial<typeof WIDTHS>} [o] The settings (WIDTHS by default).
+ * @returns {{ gaps: import('./widths.js').RunGroup[], strokes: import('./widths.js').RunGroup[] }} The groups.
+ */
+export function widths(paths, o = {}) {
+	const s = { ...WIDTHS, ...o };
+	const fp = paths.map((p) => ({ rings: rings(p.segs, 0.5), evenodd: p.evenodd }));
+	const bm = fill(fp, frameOf(fp, s.scale, s.pad));
+	return { gaps: groupRuns(channels(bm, 0, s), s.same), strokes: groupRuns(channels(bm, 1, s), s.same) };
+}

package/src/edit/adjust.d.ts

@@ -0,0 +1,46 @@
+/** A frame round the mark. */
+export type Frame = 'none' | 'circle' | 'tile' | 'ring';
+/** An adjustment: quarter turns, a fine tilt (degrees), a flip, a frame, and the shape edits. */
+export interface Adjust {
+	turns: number;
+	flip: boolean;
+	frame: Frame;
+	angle: number;
+	weight: number;
+	soften: number;
+	gap?: number;
+	detail?: number;
+	pixel?: number;
+}
+/** A similarity transform: scale k and rotation deg about (cx, cy), an optional mirror, then to (tx, ty). */
+export interface Similarity {
+	k: number;
+	deg: number;
+	flip: boolean;
+	cx: number;
+	cy: number;
+	tx: number;
+	ty: number;
+}
+/** What adjustPaths() needs from a renderer. */
+export interface AdjustEnv {
+	/** The exact bounds of some path data. */
+	measure?: (ds: string[]) => { x: number; y: number; width: number; height: number };
+	/** Whether the mark can be cut out of a frame with one even-odd path. */
+	canCut?: (paths: string) => boolean;
+	/** The pixelated mark as one path's d (null when nothing is drawn). */
+	pixelate?: (els: { d: string; rule?: string }[], amount: number, box: { x: number; y: number; width: number; height: number }) => string | null;
+	/** reshape(), once loaded. */
+	shaper?: (paths: string, weight: number, soften: number, gap: number, detail: number) => string | null;
+}
+
+/** No adjustment. */
+export const NO_ADJUST: Adjust;
+/** Whether an adjustment changes anything. */
+export function isAdjusted(a: Adjust): boolean;
+/** A short filename suffix for an adjustment, e.g. "-r90-flip-circle". */
+export function adjustSuffix(a: Adjust): string;
+/** Path data through a similarity transform, written absolute on the 0.1 grid (arcs stay arcs). */
+export function transformPath(d: string, f: Similarity): string;
+/** The adjusted mark, as <path> elements for a 512 canvas. */
+export function adjustPaths(paths: string, a: Adjust, env?: AdjustEnv): string;