logomarks 0.0.0-stage → 1.0.0

package/src/edit/preview.js

@@ -0,0 +1,51 @@
+/**
+ * @module logomarks/edit/preview
+ *
+ * Edited marks to look at: the result on white, its two tones drawn as
+ * their colours; and its parts numbered, so an agent can name them in an
+ * edit.
+ */
+
+import { render } from '../raster/render.js';
+import { mark, text, panel } from '../sheet/draw.js';
+
+/** The preview's side in pixels. */
+export const PREVIEW_SIZE = 512;
+
+/**
+ * A colour variable drawn as its fallback (`var(--tone-2, #FF5C3A)` → `#FF5C3A`), which resvg can't resolve.
+ *
+ * @param {string} svg The mark.
+ * @returns {string} It, with plain fills.
+ */
+const plainFills = (svg) => svg.replace(/var\(--[\w-]+,\s*(#[0-9a-fA-F]{3,8})\s*\)/g, '$1');
+
+/**
+ * A PNG of an SVG drawn at the preview's size.
+ *
+ * @param {string} body The markup, on the 512 canvas.
+ * @returns {Promise<Uint8Array>} The PNG.
+ */
+const png = async (body) =>
+	/** @type {Uint8Array} */ ((await render(`<svg xmlns="http://www.w3.org/2000/svg" width="${PREVIEW_SIZE}" height="${PREVIEW_SIZE}" viewBox="0 0 512 512"><rect width="512" height="512" fill="#FFFFFF"/>${body}</svg>`, { text: true, png: true })).png);
+
+/**
+ * The mark on white, in its own colours (`currentColor` as near-black).
+ *
+ * @param {string} svg The mark.
+ * @returns {Promise<Uint8Array>} The PNG.
+ */
+export const markPreview = (svg) => png(mark(plainFills(svg), 0, 0, 512, '#111111'));
+
+/**
+ * The mark in grey with each part's box and index, as `listParts` numbers them.
+ *
+ * @param {string} svg The mark.
+ * @param {readonly import('./doc.js').PartInfo[]} parts Its parts.
+ * @returns {Promise<Uint8Array>} The PNG.
+ */
+export function partsPreview(svg, parts) {
+	const labels = parts.map(({ index, box: [x0, y0, x1, y1], centre: [cx, cy] }) =>
+		`<rect x="${x0}" y="${y0}" width="${x1 - x0}" height="${y1 - y0}" fill="none" stroke="#FF5C3A" stroke-width="1.5" stroke-dasharray="4 3"/>${panel(cx - 15, cy - 13, 30, 26, '#111111', { r: 6 })}${text(cx, cy + 6, String(index), { size: 16, weight: 600, color: '#FFFFFF', anchor: 'middle' })}`);
+	return png(mark(svg, 0, 0, 512, '#C9C9C9') + labels.join(''));
+}

package/src/find/index.d.ts

@@ -0,0 +1,54 @@
+import type { MarkIndex } from '../similar/store.js';
+
+/** Exact filters for a search, and how many to return. */
+export interface FindOptions {
+	/** One style (`letter`, `badge`, `iso`, `line`, `animal` …; see `facets`). */
+	style?: string;
+	/** Tags a mark must all have (`round`, `symmetric`, `solid` …). */
+	tags?: string[];
+	/** An industry it suits (`coffee`, `fintech`, `law-firm` …). */
+	industry?: string;
+	/** The letter or number it shows (`K`, `7`). */
+	letter?: string;
+	/** How many to return (20). */
+	limit?: number;
+	/** The live set (the bundled index). */
+	index?: MarkIndex;
+}
+
+/** A mark found: what it is and its page. */
+export interface Found {
+	slug: string;
+	name: string;
+	style: string;
+	tags: string[];
+	mood: string[];
+	letter?: string;
+	industries: string[];
+	description: string;
+	/** Its page on logomarks.ai. */
+	url: string;
+}
+
+/** A search's result. */
+export interface FindResult {
+	/** How many marks matched (more than `marks` when the limit cut it). */
+	total: number;
+	/** The best matches, best first. */
+	marks: Found[];
+}
+
+/** Each filter's values, with how many marks have each. */
+export interface Facets {
+	styles: Record<string, number>;
+	tags: Record<string, number>;
+	moods: Record<string, number>;
+	industries: Record<string, number>;
+}
+
+/** How many marks a search returns when no limit is given: 20. */
+export const DEFAULT_LIMIT: number;
+/** Searches the live set as the board does (every word found, synonyms too, best first) and by exact filters. */
+export function findMarks(query?: string, o?: FindOptions): FindResult;
+/** The values the filters take, with how many marks have each, most first. */
+export function facets(index?: MarkIndex): Facets;

package/src/find/index.js

@@ -0,0 +1,88 @@
+/**
+ * @module logomarks/find
+ *
+ * Searches the bundled live set the way the board on logomarks.ai does (its
+ * packed @arraypress/search index): every word must be found, typed at the
+ * start of a word or as a synonym (UK and US trades: "solicitor" finds the
+ * lawyers' marks), best first (a word of the name or a search word, then an
+ * industry, then elsewhere). Filler words (`a`, `for`, `logo` …) are left out.
+ * Exact filters (style, tags, industry, letter) narrow it; the vocabulary to
+ * filter by comes from the set itself (`facets`).
+ */
+
+import { unpack, facets as count } from '@arraypress/search';
+import { loadIndex } from '../similar/store.js';
+import { MARK_URL } from '../brand/mark.js';
+
+/** Words a brief is full of that say nothing about a mark. */
+const STOP = ['a', 'an', 'and', 'the', 'for', 'of', 'with', 'in', 'on', 'to', 'my', 'our', 'logo', 'logos', 'mark', 'marks', 'icon', 'brand', 'company', 'something', 'like'];
+
+/** How many marks a search returns when no limit is given. */
+export const DEFAULT_LIMIT = 20;
+
+/** Each index's search, built once. */
+const searches = new WeakMap();
+
+/**
+ * An index's search (the board's, with filler words left out).
+ *
+ * @param {import('../similar/store.js').MarkIndex} index The live set.
+ * @returns {import('@arraypress/search').Search<Record<string, unknown>>} Its search.
+ * @throws {Error} When the index has no search (only the bundled one does).
+ */
+function searchOf(index) {
+	let s = searches.get(index);
+	if (!s) {
+		if (!index.search) throw new Error('this index has no search: findMarks needs the bundled index (npm run index)');
+		searches.set(index, (s = unpack(index.search, { stopWords: STOP })));
+	}
+	return s;
+}
+
+/**
+ * Whether a mark passes the exact filters.
+ *
+ * @param {import('../similar/store.js').IndexedMark} m The mark.
+ * @param {import('./index.js').FindOptions} o The filters.
+ * @returns {boolean} Whether it passes.
+ */
+function passes(m, { style, tags = [], industry, letter }) {
+	if (style && m.style !== style.toLowerCase()) return false;
+	if (tags.some((t) => !m.tags.includes(t.toLowerCase()))) return false;
+	if (industry && !m.industries.includes(industry.toLowerCase())) return false;
+	return !letter || m.letter?.toLowerCase() === letter.toLowerCase();
+}
+
+/**
+ * A mark as a search result: what it is, without its drawing.
+ *
+ * @param {import('../similar/store.js').IndexedMark} m The mark.
+ * @returns {import('./index.js').Found} The result.
+ */
+const found = ({ slug, name, style, tags, mood, letter, industries, description }) =>
+	({ slug, name, style, tags, mood, ...(letter && { letter }), industries, description, url: MARK_URL + slug });
+
+/**
+ * Searches the live set as the board does: a mark matches when every query
+ * word (or synonym phrase) is found in it; the best come first, ties in the
+ * board's order. With no words, the filtered marks come back in that order.
+ *
+ * @param {string} [query] Free words (`fox`, `calm letter k`, `solicitor`).
+ * @param {import('./index.js').FindOptions} [o] Filters and the limit.
+ * @returns {import('./index.js').FindResult} The total that matched and the first `limit`.
+ */
+export function findMarks(query = '', { index = loadIndex(), limit = DEFAULT_LIMIT, ...filters } = {}) {
+	const r = searchOf(index).search(query, { filter: (_, i) => passes(index.marks[i], filters), limit });
+	return { total: r.total, marks: r.hits.map((h) => found(index.marks[h.index])) };
+}
+
+/**
+ * The values the filters take, with how many marks have each, most first.
+ *
+ * @param {import('../similar/store.js').MarkIndex} [index] The live set.
+ * @returns {import('./index.js').Facets} Styles, tags, moods and industries.
+ */
+export function facets(index = loadIndex()) {
+	const { style, tags, mood, industries } = count(index.marks, ['style', 'tags', 'mood', 'industries']);
+	return { styles: style, tags, moods: mood, industries };
+}

package/src/index.d.ts

@@ -0,0 +1,30 @@
+export { check, fix } from './checks/index.js';
+export type { CheckOptions, Report, Finding, FindingId, Severity } from './checks/index.js';
+export { FINDINGS } from './checks/finding.js';
+export type { FindingKind } from './checks/finding.js';
+export { similar } from './similar/nearest.js';
+export type { Match, Verdict, SimilarOptions } from './similar/nearest.js';
+export { loadIndex } from './similar/store.js';
+export type { MarkIndex, IndexedMark, IndexedLetter, MarkAbout } from './similar/store.js';
+export { findMarks, facets } from './find/index.js';
+export type { FindOptions, FindResult, Found, Facets } from './find/index.js';
+export { sheet } from './sheet/index.js';
+export type { Sheet, SheetMark, SheetOptions } from './sheet/index.js';
+export { fitMark } from '@logomarks/core/fit';
+export type { Fitted } from '@logomarks/core/fit';
+export * as rules from './rules.js';
+export { loadMark, findMark, paint, markPng, MarkNotFound } from './brand/mark.js';
+export type { Mark, TileOptions } from './brand/mark.js';
+export { parseColor } from './util/color.js';
+export { FONTS, brandFont } from './brand/fonts.js';
+export type { Font, FontId, BrandFont } from './brand/fonts.js';
+export { brandInput } from './brand/brand.js';
+export type { BrandOptions } from './brand/brand.js';
+export { kit, social } from './kit/index.js';
+export type { KitOptions, SocialOptions, PackOptions } from './kit/index.js';
+export { glitchMark, editMark, markParts, combineMarks, markPreview, partsPreview, PRESETS, OPS, COMBINE_OPS } from './edit/index.js';
+export type { GlitchPreset, GlitchOptions, Glitched, EditOp, OpName, EditResult, CombineOp, CombineOptions, Placement, Edited, PartInfo } from './edit/index.js';
+export { mockup, OBJECTS } from './mockup/index.js';
+export type { Mockup, MockupOptions } from './mockup/index.js';
+export { cover, RECIPES } from './cover/index.js';
+export type { Cover, CoverOptions } from './cover/index.js';

package/src/index.js

@@ -0,0 +1,28 @@
+/**
+ * @module logomarks
+ *
+ * Check logomarks the way the Logomarks set is checked: the house rules
+ * (`check`, `fix`), the nearest live marks (`similar`), and review cards to
+ * look at (`sheet`); searching the live set (`findMarks`). Then build a brand on one: the mark itself (`loadMark`,
+ * `paint`, `markPng`), edits (`glitchMark`, `editMark`, `combineMarks`), the
+ * brand kit and social pack (`kit`, `social`, from `@logomarks/brand-kit`),
+ * mockups (`mockup`) and covers (`cover`). The same functions run the `logomarks` command and its MCP
+ * server (`logomarks/mcp`).
+ */
+
+export { check, fix } from './checks/index.js';
+export { FINDINGS } from './checks/finding.js';
+export { similar } from './similar/nearest.js';
+export { loadIndex } from './similar/store.js';
+export { findMarks, facets } from './find/index.js';
+export { sheet } from './sheet/index.js';
+export { fitMark } from '@logomarks/core/fit';
+export * as rules from './rules.js';
+export { loadMark, findMark, paint, markPng, MarkNotFound } from './brand/mark.js';
+export { parseColor } from './util/color.js';
+export { FONTS, brandFont } from './brand/fonts.js';
+export { brandInput } from './brand/brand.js';
+export { kit, social } from './kit/index.js';
+export { glitchMark, editMark, markParts, combineMarks, markPreview, partsPreview, PRESETS, OPS, COMBINE_OPS } from './edit/index.js';
+export { mockup, OBJECTS } from './mockup/index.js';
+export { cover, RECIPES } from './cover/index.js';

package/src/kit/index.d.ts

@@ -0,0 +1,26 @@
+import type { BrandKit, SocialPack, StyleId } from '@logomarks/brand-kit';
+import type { BrandOptions } from '../brand/brand.js';
+
+/** What goes in a social pack. */
+export interface PackOptions {
+	/** Image ids (`x-header`) or platform names (`instagram`). Every image by default. */
+	platforms?: string[];
+	/** `minimal`, `bold`, `pattern`, `gradient`. The first three by default. */
+	styles?: StyleId[];
+	/** Animated SVGs for avatars, stories and banners too. Default false. */
+	animated?: boolean;
+}
+
+/** What a kit is made from. */
+export interface KitOptions extends BrandOptions, PackOptions {
+	/** Include the social pack (`social/`). Default true. */
+	social?: boolean;
+}
+
+/** What a social pack is made from. */
+export interface SocialOptions extends BrandOptions, PackOptions {}
+
+/** The brand kit, every file in memory. */
+export function kit(o: KitOptions): Promise<BrandKit>;
+/** The social pack, every file in memory. */
+export function social(o: SocialOptions): Promise<SocialPack>;

package/src/kit/index.js

@@ -0,0 +1,31 @@
+/**
+ * @module logomarks/kit
+ *
+ * The brand kit and the social pack, from `@logomarks/brand-kit`: the CLI's
+ * marks and bundled faces handed in, PNGs drawn by resvg (WebAssembly), so
+ * neither needs sharp. Every file comes back in memory, by path.
+ */
+
+import { brandKit, socialPack } from '@logomarks/brand-kit';
+import { brandInput } from '../brand/brand.js';
+import { rasterize } from '../raster/render.js';
+
+/**
+ * A brand kit: the mark, favicons, lockups, colours, the brand sheet, `brand.json`, a README and the social pack.
+ *
+ * @param {import('./index.js').KitOptions} o The brand, and what goes in the social pack.
+ * @returns {Promise<import('@logomarks/brand-kit').BrandKit>} The files and `brand.json`'s contents.
+ */
+export function kit({ styles, platforms, animated = false, social, ...brand }) {
+	return brandKit({ ...brandInput(brand), styles, platforms, animated, social, rasterize });
+}
+
+/**
+ * A social pack: every platform image in each style, the email signature, the Open Graph card and a README.
+ *
+ * @param {import('./index.js').SocialOptions} o The brand, the images and the styles.
+ * @returns {Promise<import('@logomarks/brand-kit').SocialPack>} The files and the brand.
+ */
+export function social({ styles, platforms, animated = false, ...brand }) {
+	return socialPack(brandInput(brand), { styles, platforms, animated, rasterize });
+}

package/src/mcp/content.d.ts

@@ -0,0 +1,30 @@
+/** Text content. */
+export interface TextContent {
+	type: 'text';
+	text: string;
+}
+
+/** Image content: base64 bytes and their type. */
+export interface ImageContent {
+	type: 'image';
+	data: string;
+	mimeType: 'image/png';
+}
+
+/** A tool's result: its content, and whether it failed. */
+export interface ToolResult {
+	[key: string]: unknown;
+	content: (TextContent | ImageContent)[];
+	isError?: boolean;
+}
+
+/** A value as text content: pretty JSON, or a string as it is. */
+export function text(value: unknown): TextContent;
+/** A PNG as image content. */
+export function image(png: Uint8Array): ImageContent;
+/** A tool's result from its content. */
+export function result(...content: (TextContent | ImageContent)[]): ToolResult;
+/** What went wrong, as the caller should read it. */
+export function explain(e: unknown): string;
+/** A tool error: the message, flagged `isError`. */
+export function failure(e: unknown): ToolResult;

package/src/mcp/content.js

@@ -0,0 +1,56 @@
+/**
+ * @module logomarks/mcp/content
+ *
+ * What a tool hands back: JSON as text, PNGs as images, and errors the
+ * caller can act on.
+ */
+
+import { MarkNotFound } from '../brand/mark.js';
+
+/**
+ * A value as MCP text content: pretty JSON, or a string as it is.
+ *
+ * @param {unknown} value The value.
+ * @returns {import('./content.js').TextContent} The content.
+ */
+export const text = (value) => ({ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) });
+
+/**
+ * A PNG as MCP image content.
+ *
+ * @param {Uint8Array} png The PNG's bytes.
+ * @returns {import('./content.js').ImageContent} The content.
+ */
+export const image = (png) => ({ type: 'image', data: Buffer.from(png).toString('base64'), mimeType: 'image/png' });
+
+/**
+ * A tool's result.
+ *
+ * @param {...(import('./content.js').TextContent | import('./content.js').ImageContent)} content What it returns, in order.
+ * @returns {import('./content.js').ToolResult} The result.
+ */
+export const result = (...content) => ({ content });
+
+/**
+ * What went wrong, as the caller should read it: a missing mark with the
+ * closest slugs and where to look, a missing file by its path, anything
+ * else by its message.
+ *
+ * @param {unknown} e The error.
+ * @returns {string} The message.
+ */
+export function explain(e) {
+	if (e instanceof MarkNotFound) return `${e.message} Search the set with find_marks, or pass the path to an .svg file.`;
+	const err = /** @type {NodeJS.ErrnoException} */ (e);
+	if (err?.code === 'ENOENT') return `no such file: ${err.path}`;
+	if (err?.code === 'EACCES') return `can't write ${err.path}: permission denied`;
+	return err instanceof Error ? err.message : String(e);
+}
+
+/**
+ * A tool error: the message as text, flagged so the caller knows the call failed.
+ *
+ * @param {unknown} e The error.
+ * @returns {import('./content.js').ToolResult} The result.
+ */
+export const failure = (e) => ({ content: [text(explain(e))], isError: true });

package/src/mcp/edited.d.ts

@@ -0,0 +1,5 @@
+import type { Edited } from '../edit/doc.js';
+import type { ToolResult } from './content.js';
+
+/** An edited mark as a tool result: `{ ok, …, file?, svg, checks }` and its image; written to `out` when given. */
+export function edited(r: Edited & Record<string, unknown>, o: { out?: string; cwd: string }): Promise<ToolResult>;

package/src/mcp/edited.js

@@ -0,0 +1,25 @@
+/**
+ * @module logomarks/mcp/edited
+ *
+ * What the editing tools hand back: the result's SVG (or, when it was
+ * written to a file, its path) and its checks as JSON, and the mark as an
+ * image to look at.
+ */
+
+import { markPreview } from '../edit/preview.js';
+import { writeFile } from '../util/files.js';
+import { resolvePath } from './inputs.js';
+import { result, text, image } from './content.js';
+
+/**
+ * An edited mark as a tool result.
+ *
+ * @param {import('../edit/doc.js').Edited & Record<string, unknown>} r The result, and anything more to report.
+ * @param {{ out?: string, cwd: string }} o Where to write it, if anywhere.
+ * @returns {Promise<import('./content.js').ToolResult>} The result.
+ */
+export async function edited({ svg, checks, ...more }, { out, cwd }) {
+	const file = out && resolvePath(cwd, out);
+	if (file) writeFile(file, svg);
+	return result(text({ ok: checks.ok, ...more, ...(file ? { file } : { svg }), checks }), image(await markPreview(svg)));
+}

package/src/mcp/index.d.ts

@@ -0,0 +1,41 @@
+import type { ZodRawShape } from 'zod';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolResult } from './content.js';
+
+/** What a tool's run is given besides its arguments. */
+export interface ToolContext {
+	/** Where relative paths resolve. */
+	cwd: string;
+}
+
+/** One tool: what the agent sees, and what runs. */
+export interface Tool<Input = Record<string, unknown>> {
+	/** The tool's name (snake_case). */
+	name: string;
+	title: string;
+	/** Written for the agent: what it does, what it returns, when to use it. */
+	description: string;
+	/** Its arguments, as zod (the server publishes them as JSON Schema). */
+	inputSchema: ZodRawShape;
+	annotations: ToolAnnotations;
+	/** Runs it on validated arguments; throws on failure (the server returns a tool error). */
+	run(args: Input, ctx: ToolContext): Promise<ToolResult>;
+}
+
+/** How to set the server up. */
+export interface ServerOptions {
+	/** Where relative paths resolve (the process's working folder). */
+	cwd?: string;
+}
+
+/** Every tool, in the order an agent uses them. */
+export const TOOLS: Tool<never>[];
+/** What the server tells the agent when it connects. */
+export const INSTRUCTIONS: string;
+/** An MCP server with every tool registered, not yet connected. */
+export function createServer(o?: ServerOptions): McpServer;
+/** Loads the renderer, the typefaces and the live set. */
+export function warm(): Promise<void>;
+/** Runs the server over stdio until the client hangs up. */
+export function serve(o?: ServerOptions): Promise<McpServer>;

package/src/mcp/index.js

@@ -0,0 +1,72 @@
+/**
+ * @module logomarks/mcp
+ *
+ * The MCP server: the library's functions as typed tools for an AI agent
+ * (Claude Code, Codex, Cursor …), over stdio. It runs on the user's machine;
+ * nothing leaves it. The renderer, the typefaces and the live set load once
+ * and stay warm across calls. `logomarks mcp` starts it.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { TOOLS } from './tools/index.js';
+import { failure } from './content.js';
+import { loadIndex } from '../similar/store.js';
+import { warmRenderer } from '../raster/render.js';
+import { VERSION } from '../util/version.js';
+
+export { TOOLS };
+
+/** What the server tells the agent when it connects. */
+export const INSTRUCTIONS = `Logomarks: the free Logomarks set of geometric logomarks (CC0, bundled, searched offline), and the checks the set is held to, run locally.
+- Pick a mark: find_marks, then get_mark.
+- Draw your own: write the SVG to the house rules (512 canvas, longest side 448, centred; filled paths in currentColor; one gap of 22; nothing under 10 units), then check_mark, similar_marks and review_sheet. Fix every error, look at the sheet, and repeat until check_mark is ok.
+- Make it your own: list_parts, then edit_mark (delete, move, round, offset, mirror, two-tone …), glitch_mark, combine_marks. Each result is fitted and checked.
+- Build on a mark: build_brand_kit and build_social_pack (folders of files), render_mockup, render_cover.
+Tools that make images return a preview to look at; pass out to write the file. Relative paths resolve against the server's working folder. The full brand kit, photoreal mockups and custom logos are at https://logomarks.ai/pricing.`;
+
+/**
+ * An MCP server with every tool registered. Errors come back as tool errors
+ * (`isError`) with a message the agent can act on.
+ *
+ * @param {import('./index.js').ServerOptions} [o] Where relative paths resolve.
+ * @returns {McpServer} The server, not yet connected.
+ */
+export function createServer({ cwd = process.cwd() } = {}) {
+	const server = new McpServer({ name: 'logomarks', title: 'Logomarks', version: VERSION, websiteUrl: 'https://logomarks.ai' }, { instructions: INSTRUCTIONS });
+	for (const t of TOOLS) {
+		const run = /** @type {(args: object, ctx: import('./index.js').ToolContext) => Promise<import('./content.js').ToolResult>} */ (t.run);
+		server.registerTool(t.name, { title: t.title, description: t.description, inputSchema: t.inputSchema, annotations: t.annotations }, async (args) => {
+			try {
+				return await run(args, { cwd });
+			} catch (e) {
+				return failure(e);
+			}
+		});
+	}
+	return server;
+}
+
+/**
+ * Loads the renderer, the typefaces and the live set in the background, so
+ * the first call is as quick as the rest.
+ *
+ * @returns {Promise<void>} Resolves when all three are ready.
+ */
+export async function warm() {
+	loadIndex();
+	await warmRenderer();
+}
+
+/**
+ * Runs the server on stdin and stdout until the client hangs up.
+ *
+ * @param {import('./index.js').ServerOptions} [o] Where relative paths resolve.
+ * @returns {Promise<McpServer>} The connected server.
+ */
+export async function serve(o) {
+	const server = createServer(o);
+	await server.connect(new StdioServerTransport());
+	setImmediate(() => warm().catch((e) => console.error(`logomarks: ${e.message}`)));
+	return server;
+}

package/src/mcp/inputs.d.ts

@@ -0,0 +1,46 @@
+import type { z } from 'zod';
+import type { Mark } from '../brand/mark.js';
+
+/** A mark to check: its name, its file (absolute; none for SVG text) and its SVG. */
+export interface SvgInput {
+	name: string;
+	file?: string;
+	svg: string;
+}
+
+/** The schemas the tools share. */
+export const schema: {
+	mark: z.ZodString;
+	color: z.ZodOptional<z.ZodString>;
+	font: z.ZodOptional<z.ZodEnum<Record<string, string>>>;
+	name: z.ZodOptional<z.ZodString>;
+	svg: z.ZodOptional<z.ZodString>;
+	svgName: z.ZodOptional<z.ZodString>;
+	paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	strict: z.ZodOptional<z.ZodBoolean>;
+	seed: z.ZodOptional<z.ZodString>;
+	source: z.ZodOptional<z.ZodString>;
+	sourceSvg: z.ZodOptional<z.ZodString>;
+	out: z.ZodOptional<z.ZodString>;
+	tagline: z.ZodOptional<z.ZodString>;
+	url: z.ZodOptional<z.ZodString>;
+	handle: z.ZodOptional<z.ZodString>;
+	platforms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+	styles: z.ZodOptional<z.ZodArray<z.ZodEnum<{ minimal: 'minimal'; bold: 'bold'; pattern: 'pattern'; gradient: 'gradient' }>>>;
+	animated: z.ZodOptional<z.ZodBoolean>;
+};
+
+/** A path resolved against the working folder. */
+export function resolvePath(cwd: string, p: string): string;
+/** A mark by slug, name or file (relative to the working folder); throws `MarkNotFound`. */
+export function readMark(ref: string, cwd: string): Mark;
+/** A colour input as `#RRGGBB` (undefined when not given); throws when it isn't one. */
+export function readColor(value: string | undefined): string | undefined;
+/** The marks a check names: SVG text, or files and folders; throws when neither, both, or missing. */
+export function readSvgs(input: { svg?: string; svgName?: string; paths?: string[] }, cwd: string): SvgInput[];
+
+/** A mark as SVG from a live slug or name, an .svg path, or SVG text (fitted). */
+export function readAnyMark(ref: string, cwd: string): { name: string; svg: string };
+/** The mark an edit starts from: `mark` (a slug, name or file) or `svg` (text, fitted); throws when neither or both are given. */
+export function readSource(input: { mark?: string; svg?: string }, cwd: string): { name: string; svg: string };