@loadmap/cli 0.2.0 → 0.3.1

package/dist/{src-IlCf12IX.js → src-CCAswkjM.js}

@@ -38,7 +38,7 @@ function boundOf(c, bound) {
 }
 // ../core/src/format.ts
 /** A number for a reader: 1,234 / 12.3 / 0.4. */
-function fmt(n) {
+function fmt$1(n) {
 	if (!Number.isFinite(n)) return n > 0 ? "∞" : "—";
 	if (Math.abs(n) >= 1e3) return Math.round(n).toLocaleString("en-US");
 	return (Math.round(n * 10) / 10).toString();
@@ -55,7 +55,7 @@ function compact(n) {
 /** A load multiple, rounded down so it never promises more than the model: 2.6× / 53×. */
 function multiple(u, searchMax = 2e3) {
 	if (u == null) return "—";
-	if (!Number.isFinite(u)) return `beyond ${fmt(searchMax)}×`;
+	if (!Number.isFinite(u)) return `beyond ${fmt$1(searchMax)}×`;
 	return u >= 10 ? `${Math.floor(u)}×` : `${Math.floor(u * 10) / 10}×`;
 }
 /**
@@ -1041,7 +1041,7 @@ function sureness(c) {
 	return ` (capacity ${c.provenance}${c.within ? ` ±${pct(c.within)}` : ""})`;
 }
 function verdict(load, live, first, range, th, searchMax, when) {
-	const at = `At ${fmt(load)}×`;
+	const at = `At ${fmt$1(load)}×`;
 	const target = `${pct(th.target)} target`;
 	if (!first) return {
 		tier: "ok",
@@ -1157,7 +1157,7 @@ function check$1(model, expectations = model.expectations) {
 			});
 		}
 		const failed = claims.filter((x) => !x.ok);
-		const message = failed.length ? failed.map((x) => `expected at least ${fmt(x.min)}×, but ${x.text}`).join("; ") : claims.map((x) => x.text).join("; ");
+		const message = failed.length ? failed.map((x) => `expected at least ${fmt$1(x.min)}×, but ${x.text}`).join("; ") : claims.map((x) => x.text).join("; ");
 		return {
 			expectation: e,
 			ok: !failed.length,
@@ -1361,6 +1361,26 @@ function distance(a, b) {
 function own(o, k) {
 	return Object.hasOwn(o, k) ? o[k] : void 0;
 }
+/**
+* Which argument of a statement fills which slot: by kind, in order, optional slots skipped. `bad` are the ones that
+* fit no slot, `missing` the first required slot left empty.
+*/
+function matchArgs(slots, args) {
+	const open = [...slots];
+	const filled = /* @__PURE__ */ new Map();
+	const bad = [];
+	for (const a of args) {
+		const kind = a.t === "id" ? "id" : a.t === "str" || a.t === "tpl" ? "text" : a.t === "num" ? "number" : null;
+		const i = open.findIndex((s) => s.kind === kind);
+		if (kind == null || i < 0 || open.slice(0, i).some((s) => !s.optional)) bad.push(a);
+		else filled.set(open.splice(0, i + 1).at(-1), a);
+	}
+	return {
+		filled,
+		bad,
+		missing: open.find((s) => !s.optional)
+	};
+}
 const STAGE_LABEL = [{
 	name: "id",
 	kind: "id",
@@ -1393,11 +1413,13 @@ const COMPONENT_PROPS = {
 		doc: "\"are past capacity\" instead of \"is\"."
 	},
 	demand: {
+		inspector: "main",
 		value: "number",
 		scope: "ctx",
 		doc: "What the component must handle, in its capacity's unit. Without one: the units per second reaching its stages."
 	},
 	capacity: {
+		inspector: "main",
 		value: "capacity",
 		scope: "ctx",
 		doc: "What it can handle: measured(value, unit, source) or estimated(value, unit, source), `value ± 30%` saying how sure it is; configured(value, unit, source) for a limit someone set."
@@ -1461,6 +1483,7 @@ const SCHEMA = {
 		args: [],
 		props: {
 			title: {
+				inspector: "main",
 				value: "string",
 				scope: "const",
 				doc: "The heading above the diagram."
@@ -1519,6 +1542,7 @@ const SCHEMA = {
 		children: []
 	},
 	load: {
+		inspector: "model",
 		doc: "The load, as a multiple of today. It drives the limits.",
 		example: "load \"Users, × today\" { max: 100; default: 10 }",
 		args: [{
@@ -1533,6 +1557,7 @@ const SCHEMA = {
 				doc: "The lowest multiple. Default 1."
 			},
 			max: {
+				inspector: "main",
 				value: "number",
 				scope: "const",
 				doc: "The highest multiple on the slider.",
@@ -1544,6 +1569,7 @@ const SCHEMA = {
 				doc: "The slider step. Default 1."
 			},
 			default: {
+				inspector: "main",
 				value: "number",
 				scope: "const",
 				doc: "Where the slider starts. Default the minimum."
@@ -1552,6 +1578,7 @@ const SCHEMA = {
 		children: []
 	},
 	param: {
+		inspector: "model",
 		doc: "A control: options make a select, min and max a slider, a true or false default a switch.",
 		example: "param pods \"Worker pods\" { options: [2, 3, 4, 6]; default: 3 }",
 		args: [{
@@ -1564,26 +1591,31 @@ const SCHEMA = {
 		}],
 		props: {
 			options: {
+				inspector: "main",
 				value: "options",
 				scope: "const",
 				doc: "The choices of a select: [2, 3, 4] or [\"a\", \"b\"]."
 			},
 			min: {
+				inspector: "main",
 				value: "number",
 				scope: "const",
 				doc: "The lowest value of a slider."
 			},
 			max: {
+				inspector: "main",
 				value: "number",
 				scope: "const",
 				doc: "The highest value of a slider."
 			},
 			step: {
+				inspector: "main",
 				value: "number",
 				scope: "const",
 				doc: "The step of a slider. Default 1."
 			},
 			default: {
+				inspector: "main",
 				value: "value",
 				scope: "const",
 				doc: "The starting value.",
@@ -1649,11 +1681,13 @@ const SCHEMA = {
 		}
 	},
 	growth: {
+		inspector: "model",
 		doc: "How fast the load grows, compounded from asOf, where it is 1×: load multiples become dates.",
 		example: "growth { rate: 0.06; per: month; asOf: \"2026-11-01\" }",
 		args: [],
 		props: {
 			rate: {
+				inspector: "main",
 				value: "number",
 				scope: "const",
 				required: true,
@@ -1742,6 +1776,7 @@ const SCHEMA = {
 		}
 	},
 	let: {
+		inspector: "model",
 		doc: "A named formula other formulas can use by its name.",
 		example: "let perPosition = watchOnly ? 0.3 : 1.2",
 		args: [{
@@ -1753,6 +1788,7 @@ const SCHEMA = {
 		children: []
 	},
 	fit: {
+		inspector: "model",
 		doc: "cost = a + b × x, fitted from measured points. Call it like a function: workerCores(rate).",
 		example: "fit workerCores \"Worker CPU per request\" { source: \"load test\"; points rate cores { 200 0.26 } }",
 		args: [{
@@ -1793,6 +1829,7 @@ const SCHEMA = {
 		rows: true
 	},
 	flow: {
+		inspector: "model",
 		doc: "Something that moves through the system, with its rate and its route.",
 		example: "flow orders \"orders\" { unit: \"order\"; rate: 40 * load; route: gateway -> topic -> workers }",
 		args: [{
@@ -1810,6 +1847,7 @@ const SCHEMA = {
 				doc: "One unit of the flow, singular: \"order\"."
 			},
 			rate: {
+				inspector: "main",
 				value: "number",
 				scope: "ctx",
 				doc: "Units per second.",
@@ -1891,12 +1929,14 @@ const SCHEMA = {
 		args: [],
 		props: {
 			times: {
+				inspector: "main",
 				value: "number",
 				scope: "values",
 				doc: "Retries after the first attempt: a whole number. Reads only the parameters.",
 				required: true
 			},
 			budget: {
+				inspector: "main",
 				value: "number",
 				scope: "values",
 				doc: "At most this share of the flow is added as retries: 0.1 adds at most 10 %. Without one, every retry is sent."
@@ -1955,6 +1995,7 @@ const SCHEMA = {
 		props: {
 			sub: SUB,
 			members: {
+				inspector: "main",
 				value: "number",
 				scope: "ctx",
 				doc: "How many members.",
@@ -1997,6 +2038,7 @@ const SCHEMA = {
 		args: STAGE_LABEL,
 		props: {
 			hit: {
+				inspector: "main",
 				value: "number",
 				scope: "ctx",
 				doc: "The share answered here, 0 to 1.",
@@ -2055,11 +2097,13 @@ const SCHEMA = {
 		args: STAGE_LABEL,
 		props: {
 			pods: {
+				inspector: "main",
 				value: "number",
 				scope: "ctx",
 				doc: "How many pods; an autoscaled pool has autoscale instead."
 			},
 			perPod: {
+				inspector: "main",
 				value: "number",
 				scope: "ctx",
 				doc: "Workers per pod.",
@@ -2081,18 +2125,21 @@ const SCHEMA = {
 		args: [],
 		props: {
 			min: {
+				inspector: "main",
 				value: "number",
 				scope: "ctx",
 				doc: "The fewest pods, at least 1.",
 				required: true
 			},
 			max: {
+				inspector: "main",
 				value: "number",
 				scope: "ctx",
 				doc: "The most pods.",
 				required: true
 			},
 			target: {
+				inspector: "main",
 				value: "number",
 				scope: "ctx",
 				doc: "The utilization each running pod is held at, above 0 and at most 1: 0.7 scales out above 70 %.",
@@ -2110,6 +2157,7 @@ const SCHEMA = {
 		edges: "branches"
 	},
 	thresholds: {
+		inspector: "model",
 		doc: "The utilization of the target and of \"runs out\".",
 		example: "thresholds { target: 0.5; full: 1 }",
 		args: [],
@@ -2226,7 +2274,7 @@ const BUILTINS = {
 	fmt: {
 		args: ["number"],
 		result: "string",
-		fn: fmt
+		fn: fmt$1
 	},
 	compact: {
 		args: ["number"],
@@ -2638,8 +2686,11 @@ const PUNCT = [
 /**
 * Splits `source[from, to)` into tokens. Newlines end statements, except inside parentheses and brackets, so a long
 * formula can wrap there. `#` starts a comment to the end of the line.
+*
+* With `trivia` (for the formatter, never the parser) every newline is a token, blank lines and wrapped formulas
+* included, and so is every comment.
 */
-function lex(source, report, from = 0, to = source.length) {
+function lex(source, report, from = 0, to = source.length, trivia = false) {
 	const out = [];
 	let depth = 0;
 	let i = from;
@@ -2647,7 +2698,7 @@ function lex(source, report, from = 0, to = source.length) {
 	while (i < to) {
 		const c = source[i];
 		if (c === "\n") {
-			if (depth === 0 && out.at(-1)?.kind !== "newline") push({
+			if (trivia || depth === 0 && out.at(-1)?.kind !== "newline") push({
 				kind: "newline",
 				text: "\n",
 				from: i,
@@ -2655,8 +2706,16 @@ function lex(source, report, from = 0, to = source.length) {
 			});
 			i++;
 		} else if (c === " " || c === "	" || c === "\r") i++;
-		else if (c === "#") while (i < to && source[i] !== "\n") i++;
-		else if (isIdStart(c)) {
+		else if (c === "#") {
+			const s = i;
+			while (i < to && source[i] !== "\n") i++;
+			if (trivia) push({
+				kind: "comment",
+				text: source.slice(s, i).trimEnd(),
+				from: s,
+				to: i
+			});
+		} else if (isIdStart(c)) {
 			const s = i;
 			while (i < to && isIdPart(source[i])) i++;
 			push({
@@ -2859,7 +2918,7 @@ const PREC = {
 /** Thrown after a syntax error has been reported, to skip to the next statement. */
 var Bail$1 = class {};
 /** Parses a definition into statements. Never throws: errors go to the reporter, and parsing goes on at the next line. */
-function parse$1(source, report = new Reporter(source)) {
+function parse$2(source, report = new Reporter(source)) {
 	if (source.length > 2e5) {
 		report.error({
 			from: 0,
@@ -3343,7 +3402,7 @@ function compile(source, o = {}) {
 	let definition;
 	let expectations = [];
 	try {
-		doc = parse$1(source, report).doc;
+		doc = parse$2(source, report).doc;
 		definition = c.run(doc);
 		if (definition) expectations = check$1(definition.model).map((result, i) => {
 			const at = c.expectSpans[i];
@@ -3748,16 +3807,9 @@ var Compiler = class {
 		return b;
 	}
 	args(b, d) {
-		const slots = [...b.spec.args];
-		for (const a of d.args) {
-			const kind = a.t === "id" ? "id" : a.t === "str" || a.t === "tpl" ? "text" : a.t === "num" ? "number" : null;
-			const i = slots.findIndex((s) => s.kind === kind);
-			if (kind == null || i < 0 || slots.slice(0, i).some((s) => !s.optional)) {
-				this.report.error(a, `unexpected ${this.slice(a)} after "${b.keyword}"`, usage(b.keyword));
-				continue;
-			}
-			const slot = slots[i];
-			slots.splice(0, i + 1);
+		const { filled, bad, missing } = matchArgs(b.spec.args, d.args);
+		for (const a of bad) this.report.error(a, `unexpected ${this.slice(a)} after "${b.keyword}"`, usage(b.keyword));
+		for (const [slot, a] of filled) {
 			if (a.t === "tpl" && !slot.dynamic && !a.parts.length) {
 				b.args[slot.name] = {
 					t: "str",
@@ -3775,7 +3827,6 @@ var Compiler = class {
 			};
 			else b.args[slot.name] = a;
 		}
-		const missing = slots.find((s) => !s.optional);
 		if (missing) this.report.error(b.at, `"${b.keyword}" needs its ${missing.name}`, usage(b.keyword));
 		if (b.spec.init && !d.init) this.report.error(b.at, `"${b.keyword}" needs "= formula"`, usage(b.keyword));
 		if (!b.spec.init && d.init) this.report.error(d.init, `"${b.keyword}" takes no "="`);
@@ -4467,6 +4518,200 @@ function where(keyword) {
 	const parents = Object.entries(SCHEMA).filter(([, s]) => s.children.includes(keyword)).map(([k]) => k === "" ? "the top level" : k);
 	return parents.length ? `it goes in ${parents.join(" or ")}` : void 0;
 }
+// ../dsl/src/ast.ts
+/** The formulas directly inside a formula, in order; a template's parts only when asked (they are its own text). */
+function childrenOf(e, templates = false) {
+	switch (e.t) {
+		case "unary": return [e.arg];
+		case "pm": return [e.value, e.within];
+		case "cond": return [
+			e.test,
+			e.then,
+			e.else
+		];
+		case "bin": return [e.left, e.right];
+		case "call": return e.args;
+		case "array": return e.items;
+		case "tpl": return templates ? e.parts : [];
+		default: return [];
+	}
+}
+/**
+* Lays a definition out the one way: two spaces a block, a statement a line, at most one blank line, one space
+* around operators. It works on the tokens, so numbers, texts, templates and parentheses stay exactly as written and
+* a formula never changes. A block written on one line stays on one line while it fits. A text with a syntax error is
+* left alone.
+*/
+function format(source) {
+	const { doc, report } = parse$2(source);
+	if (report.failed) return {
+		ok: false,
+		text: source,
+		diagnostics: report.list
+	};
+	const toks = lex(source, new Reporter(source), 0, source.length, true).filter((t) => t.kind !== "eof");
+	const marks = marksOf(doc.body, toks);
+	const lines = new Reporter(source);
+	const match = /* @__PURE__ */ new Map();
+	const open = [];
+	for (let i = 0; i < toks.length; i++) if (isPunct(toks[i], "{")) open.push(i);
+	else if (isPunct(toks[i], "}")) match.set(open.pop(), i);
+	const empty = /* @__PURE__ */ new Set();
+	const written = /* @__PURE__ */ new Set();
+	for (const [i, j] of match) if (toks.slice(i + 1, j).every((t) => t.kind === "newline")) empty.add(i);
+	else if (lines.position(toks[i].from).line !== lines.position(toks[j].from).line) written.add(i);
+	const index = new Map(toks.map((t, i) => [t, i]));
+	const split = /* @__PURE__ */ new Set();
+	const oneLine = (t) => {
+		const i = index.get(t);
+		return isPunct(t, "{") && !empty.has(i) && !written.has(i) && !split.has(i);
+	};
+	for (;;) {
+		const out = layout(toks, match, (i) => split.has(i) || written.has(i), empty);
+		const text = out.map((l) => l.toks.length ? "  ".repeat(l.depth) + join$1(l.toks, marks) : "");
+		const long = out.find((l, n) => [...text[n]].length > 120 && l.toks.some(oneLine));
+		if (!long) return {
+			ok: true,
+			text: text.length ? `${text.join("\n")}\n` : "",
+			diagnostics: []
+		};
+		split.add(index.get(long.toks.find(oneLine)));
+	}
+}
+/** The tokens in lines with their depth. `multi` tells a block laid out a statement a line. */
+function layout(toks, match, multi, empty) {
+	const out = [];
+	let cur = [];
+	let depth = 0;
+	let lineDepth = 0;
+	let newlines = 0;
+	let start = true;
+	const blocks = [true];
+	const end = () => {
+		if (cur.length) out.push({
+			depth: lineDepth,
+			toks: cur
+		});
+		cur = [];
+	};
+	const add = (t) => {
+		if (!cur.length) {
+			if (newlines > 1 && !start && !isPunct(t, "}")) out.push({
+				depth: 0,
+				toks: []
+			});
+			lineDepth = depth - (isPunct(t, "}") || isPunct(t, ")") || isPunct(t, "]") ? 1 : 0);
+		}
+		newlines = 0;
+		start = false;
+		cur.push(t);
+	};
+	for (let i = 0; i < toks.length; i++) {
+		const t = toks[i];
+		if (t.kind === "newline") {
+			end();
+			newlines++;
+		} else if (isPunct(t, ";")) {
+			if (blocks.at(-1)) {
+				if (toks[i + 1]?.kind !== "comment") end();
+			} else {
+				const next = toks[i + 1];
+				const last = cur.at(-1);
+				if (!(!next || next.kind === "newline" || next.kind === "comment" || isPunct(next, "}") || !last || isPunct(last, "{") || isPunct(last, ";"))) add(t);
+			}
+		} else if (isPunct(t, "{")) {
+			if (empty.has(i)) {
+				add(t);
+				i = match.get(i);
+				add(toks[i]);
+				continue;
+			}
+			const m = multi(i);
+			add(t);
+			depth++;
+			blocks.push(m);
+			if (m) {
+				if (toks[i + 1]?.kind === "comment") add(toks[++i]);
+				end();
+				start = true;
+			}
+		} else if (isPunct(t, "}")) {
+			if (blocks.pop()) end();
+			add(t);
+			depth--;
+		} else if (isPunct(t, "(") || isPunct(t, "[")) {
+			add(t);
+			depth++;
+		} else if (isPunct(t, ")") || isPunct(t, "]")) {
+			add(t);
+			depth--;
+		} else add(t);
+	}
+	end();
+	return out;
+}
+function marksOf(body, toks) {
+	const m = {
+		unary: /* @__PURE__ */ new Set(),
+		percent: /* @__PURE__ */ new Set(),
+		ternary: /* @__PURE__ */ new Set()
+	};
+	const after = (at) => {
+		let lo = 0;
+		let hi = toks.length;
+		while (lo < hi) {
+			const mid = lo + hi >> 1;
+			if (toks[mid].from < at) lo = mid + 1;
+			else hi = mid;
+		}
+		return lo;
+	};
+	const find = (from, text) => {
+		for (let i = after(from); i < toks.length; i++) if (isPunct(toks[i], text)) return toks[i].from;
+		return -1;
+	};
+	const expr = (e) => {
+		if (!e) return;
+		if (e.t === "unary") {
+			let at = -1;
+			for (let i = after(e.from); i < toks.length && toks[i].from < e.arg.from; i++) if (isPunct(toks[i], e.op)) at = toks[i].from;
+			m.unary.add(at);
+		} else if (e.t === "pm" && e.percent) m.percent.add(find(e.within.to, "%"));
+		else if (e.t === "cond") m.ternary.add(find(e.then.to, ":"));
+		for (const k of childrenOf(e)) expr(k);
+	};
+	const stmt = (s) => {
+		if (s.kind === "row") s.values.forEach(expr);
+		else if (s.kind === "prop") expr(s.value);
+		else {
+			if (s.kind === "decl") {
+				s.args.forEach(expr);
+				expr(s.init);
+			} else expr(s.value);
+			s.body?.forEach(stmt);
+		}
+	};
+	body.forEach(stmt);
+	return m;
+}
+function join$1(toks, m) {
+	let s = toks[0].text;
+	for (let i = 1; i < toks.length; i++) s += gap(toks[i - 1], toks[i], m) + toks[i].text;
+	return s;
+}
+function gap(a, b, m) {
+	const A = a.kind === "punct" ? a.text : "";
+	const B = b.kind === "punct" ? b.text : "";
+	if (A === "{" && B === "}") return "";
+	if (A === "(" || A === "[" || A === ".") return "";
+	if ((A === "-" || A === "+" || A === "!") && m.unary.has(a.from)) return "";
+	if (B === ")" || B === "]" || B === "," || B === ";" || B === ".") return "";
+	if (B === "%" && m.percent.has(b.from)) return "";
+	if (B === ":" && !m.ternary.has(b.from)) return "";
+	if (B === "(" && a.kind === "ident") return "";
+	return " ";
+}
+const isPunct = (t, text) => t.kind === "punct" && t.text === text;
 // src/check.ts
 /**
 * `loadmap check`: compiles each definition and tests its expect lines. Resolves to the exit code: 1 when a
@@ -4476,7 +4721,7 @@ async function check(argv, o = {}) {
 	const log = o.log ?? console.log;
 	let parsed;
 	try {
-		parsed = parse(argv, o.env ?? process.env);
+		parsed = parse$1(argv, o.env ?? process.env);
 	} catch (err) {
 		log(err.message);
 		return 2;
@@ -4505,7 +4750,7 @@ async function check(argv, o = {}) {
 	}
 	return failed ? 1 : 0;
 }
-function parse(argv, env) {
+function parse$1(argv, env) {
 	const { values, positionals } = parseArgs({
 		args: argv,
 		allowPositionals: true,
@@ -4540,8 +4785,90 @@ function github(d, file, source) {
 }
 const data = (s) => s.replaceAll("%", "%25").replaceAll("\r", "%0D").replaceAll("\n", "%0A");
 const prop = (s) => data(s).replaceAll(":", "%3A").replaceAll(",", "%2C");
+// src/fmt.ts
+/**
+* `loadmap fmt`: lays each definition out the one way (`format()` of @loadmap/dsl), in place. With `--check` it only
+* names the files that are not laid out so. `-` reads standard input and writes standard output. Resolves to 1 when a
+* file has a syntax error, cannot be read, or (with --check) needs formatting; 2 for a usage mistake.
+*/
+async function fmt(argv, o = {}) {
+	const log = o.log ?? console.log;
+	let parsed;
+	try {
+		parsed = parse(argv);
+	} catch (err) {
+		log(err.message);
+		return 2;
+	}
+	if (parsed.stdin) {
+		const source = await (o.read ?? readStdin)();
+		const r = format(source);
+		if (!r.ok) for (const d of r.diagnostics) log(formatDiagnostic(d, source, "<stdin>"));
+		else (o.write ?? ((s) => process.stdout.write(s)))(r.text);
+		return r.ok ? 0 : 1;
+	}
+	let failed = false;
+	let changed = 0;
+	let skipped = 0;
+	for (const file of parsed.files) {
+		let source;
+		try {
+			source = await readFile(file, "utf8");
+		} catch (err) {
+			log(`${file}: cannot read it (${err.code ?? err.message})`);
+			failed = true;
+			skipped++;
+			continue;
+		}
+		const r = format(source);
+		if (!r.ok) {
+			for (const d of r.diagnostics) log(formatDiagnostic(d, source, file));
+			log(`${file}: left as it is, it has a syntax error`);
+			failed = true;
+			skipped++;
+		} else if (r.text !== source) {
+			changed++;
+			if (parsed.check) {
+				log(`${file}: not laid out by loadmap fmt`);
+				failed = true;
+			} else {
+				await writeFile(file, r.text);
+				log(`${file}: formatted`);
+			}
+		}
+	}
+	const n = parsed.files.length;
+	const files = (k) => `${k} ${k === 1 ? "file" : "files"}`;
+	const left = skipped ? `; ${skipped} left out (unreadable or a syntax error)` : "";
+	let summary = `${changed} of ${files(n)} formatted`;
+	if (parsed.check && changed) summary = `${changed} of ${files(n)} need loadmap fmt`;
+	else if (parsed.check) summary = skipped ? `${n - skipped} of ${files(n)} laid out already` : `${files(n)} laid out already`;
+	log(summary + left);
+	return failed ? 1 : 0;
+}
+function parse(argv) {
+	const { values, positionals } = parseArgs({
+		args: argv,
+		allowPositionals: true,
+		options: { check: { type: "boolean" } }
+	});
+	if (!positionals.length) throw new Error("loadmap fmt needs one or more .loadmap files, or - for standard input");
+	const stdin = positionals.includes("-");
+	if (stdin && (positionals.length > 1 || values.check)) throw new Error("loadmap fmt - reads standard input alone, without files or --check");
+	return {
+		files: positionals,
+		check: !!values.check,
+		stdin
+	};
+}
+async function readStdin() {
+	const chunks = [];
+	for await (const c of process.stdin) chunks.push(c);
+	return Buffer.concat(chunks).toString("utf8");
+}
 // src/index.ts
 const USAGE = `loadmap check <file.loadmap>… [--format text|github]
+loadmap fmt <file.loadmap>… [--check] | loadmap fmt -
 loadmap record <url | file.loadmap> --out <file.gif|.webm|.mp4|.png|.svg> [options]
 
 check compiles each definition and tests its expect lines on the pessimistic edge (every capacity at its low
@@ -4549,6 +4876,12 @@ bound). It exits 1 when a definition has an error or an expectation fails, 0 whe
 
   --format <f>          text, or github to add annotations on the lines (the default under GitHub Actions)
 
+fmt lays each definition out the one way, in place: two spaces a block, a statement a line, one space around
+operators; numbers, texts and formulas stay as written. A file with a syntax error is left alone (exit 1).
+
+  --check               change nothing; exit 1 when a file is not laid out so (for CI)
+  -                     read standard input, write standard output
+
 record opens the page in headless Chromium, finds the loadmap it exposes (expose() from @loadmap/export) and
 records it on a fixed clock, so the same options give the same file. A .loadmap file is drawn by the viewer that
 comes with the command.
@@ -4572,6 +4905,7 @@ comes with the command.
 async function main(argv, log = console.log) {
 	const [command, ...rest] = argv;
 	if (command === "check") return check(rest, { log });
+	if (command === "fmt") return fmt(rest, { log });
 	if (command !== "record") {
 		log(USAGE);
 		return command === "--help" || command === "-h" ? 0 : 2;
@@ -4775,4 +5109,4 @@ async function recordPage(a, format) {
 		await browser.close();
 	}
 }
-export { check as a, record as i, main as n, github as o, parseRecord as r, USAGE as t };
+export { fmt as a, record as i, main as n, check as o, parseRecord as r, github as s, USAGE as t };