@templatical/template-tools 0.38.0

package/dist/bin.js

@@ -0,0 +1,698 @@
+#!/usr/bin/env node
+import { a as validateTemplate, i as schema, r as runQualityLint, t as applyOperation } from "./src-unNYVMlC.js";
+import { DEFAULT_PORT, WORKING_DIR, listWorkingFiles, openBrowser, pidfilePath, processAlive, readPidfile, readWorkingFile, startBridgePreferring } from "./live/index.js";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { renderToMjml } from "@templatical/renderer";
+//#region src/cli/args.ts
+/** Flags that consume the next argv entry as their value. */
+const VALUE_FLAGS = /* @__PURE__ */ new Set([
+	"format",
+	"out",
+	"o",
+	"op",
+	"ops",
+	"file",
+	"port",
+	"cwd"
+]);
+function parseArgs(argv) {
+	const positional = [];
+	const flags = {};
+	let json = false;
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (!arg.startsWith("-")) {
+			positional.push(arg);
+			continue;
+		}
+		const bare = arg.replace(/^--?/, "");
+		const eq = bare.indexOf("=");
+		if (eq !== -1) {
+			flags[bare.slice(0, eq)] = bare.slice(eq + 1);
+			continue;
+		}
+		if (bare === "json") {
+			json = true;
+			continue;
+		}
+		flags[bare] = VALUE_FLAGS.has(bare) && i + 1 < argv.length ? argv[++i] : true;
+	}
+	return {
+		command: positional.shift(),
+		positional,
+		json,
+		flags
+	};
+}
+/** Read a value flag as a string, or undefined when absent or valueless. */
+function flagValue(args, ...names) {
+	for (const name of names) {
+		const v = args.flags[name];
+		if (typeof v === "string") return v;
+	}
+}
+//#endregion
+//#region src/cli/output.ts
+let jsonMode = false;
+function setJsonMode(on) {
+	jsonMode = on;
+}
+/**
+* Emit a command's result. Under `--json` the payload is serialized; otherwise
+* `human()` is called for the readable form — as a thunk, so building the
+* pretty output costs nothing in JSON mode.
+*/
+function emit(payload, human) {
+	process.stdout.write(jsonMode ? `${JSON.stringify(payload)}\n` : `${human()}\n`);
+}
+/** Diagnostics, progress and errors. Always stderr, in both modes. */
+function note(message) {
+	process.stderr.write(`${message}\n`);
+}
+//#endregion
+//#region src/cli/io.ts
+const EXIT = {
+	ok: 0,
+	/** Structural errors, or quality issues of severity "error". */
+	invalid: 1,
+	/** Bad flags, missing arguments, unreadable input. */
+	usage: 2,
+	/** An optional dependency is not installed; the message names the install. */
+	missingDep: 3
+};
+var UsageError = class extends Error {};
+var InvalidTemplateError = class extends Error {
+	errors;
+	constructor(message, errors = []) {
+		super(message);
+		this.errors = errors;
+	}
+};
+var MissingDependencyError = class extends Error {
+	pkg;
+	constructor(pkg, message) {
+		super(message);
+		this.pkg = pkg;
+	}
+};
+function resolveFrom(file, cwd = process.cwd()) {
+	return isAbsolute(file) ? file : resolve(cwd, file);
+}
+function readTemplateFile(file, cwd = process.cwd()) {
+	const path = resolveFrom(file, cwd);
+	let raw;
+	try {
+		raw = readFileSync(path, "utf8");
+	} catch {
+		throw new UsageError(`Could not read ${file}`);
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (err) {
+		throw new UsageError(`${file} is not valid JSON: ${err.message}`);
+	}
+}
+/** Write a template, creating the parent directory. Returns the path written. */
+function writeTemplateFile(file, content, cwd = process.cwd()) {
+	const path = resolveFrom(file, cwd);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(content, null, 2)}\n`, "utf8");
+	return path;
+}
+//#endregion
+//#region src/cli/commands/schema.ts
+function runSchema(args) {
+	const out = flagValue(args, "out", "o");
+	if (out) {
+		note(`Wrote ${writeTemplateFile(out, schema)}`);
+		return EXIT.ok;
+	}
+	emit(schema, () => JSON.stringify(schema, null, 2));
+	return EXIT.ok;
+}
+//#endregion
+//#region src/cli/commands/validate.ts
+function runValidate(args) {
+	const file = args.positional[0];
+	if (!file) throw new UsageError("validate needs a template file.");
+	const data = readTemplateFile(file, flagValue(args, "cwd") ?? process.cwd());
+	const { valid, errors } = validateTemplate(data);
+	if (!valid) {
+		emit({
+			valid: false,
+			errors,
+			issues: []
+		}, () => [`✗ Structural validation failed (${errors.length}):`, ...errors.map((e) => `  - ${e}`)].join("\n"));
+		return EXIT.invalid;
+	}
+	const quality = runQualityLint(data);
+	if (quality.error) note(`Quality lint could not run: ${quality.error}`);
+	const issues = quality.issues;
+	const blocking = issues.filter((i) => i.severity === "error");
+	emit({
+		valid: true,
+		errors: [],
+		issues
+	}, () => {
+		if (issues.length === 0) return "✓ Valid — no quality issues";
+		const lines = issues.map((i) => `  - [${i.severity}] ${i.ruleId}: ${i.message}`);
+		return [`✓ Structurally valid · ${issues.length} quality issue(s):`, ...lines].join("\n");
+	});
+	return blocking.length > 0 ? EXIT.invalid : EXIT.ok;
+}
+//#endregion
+//#region src/cli/resolve-optional.ts
+/**
+* Walk up from `dir` through every ancestor's node_modules looking for
+* <specifier>/package.json — the same directory-walk Node's own resolver uses
+* to locate a package, without then asking Node to apply exports-map
+* resolution. `dir` is normalized to an absolute path via `resolve()` before
+* the walk starts, so a relative anchor (e.g. ".") climbs real ancestors —
+* unnormalized, `dirname(".")` is "." forever and the walk would give up
+* after the first miss.
+*/
+function findPackageDir(specifier, dir) {
+	let current = resolve(dir);
+	for (;;) {
+		const candidate = join(current, "node_modules", specifier);
+		if (existsSync(join(candidate, "package.json"))) return candidate;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+/**
+* Pick a found package's entry file straight from its own manifest, honoring
+* exports["."].import, a string exports["."], exports["."].default, a
+* root-string exports field, "module", then "main" — the fields an ESM
+* consumer needs, read without Node's exports-map gating.
+*/
+function entryFileFor(pkgDir) {
+	const manifest = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf8"));
+	const dot = manifest.exports && typeof manifest.exports === "object" ? manifest.exports["."] : void 0;
+	const conditions = dot && typeof dot === "object" ? dot : void 0;
+	const rootExports = typeof manifest.exports === "string" ? manifest.exports : void 0;
+	const entry = conditions?.import ?? (typeof dot === "string" ? dot : void 0) ?? conditions?.default ?? rootExports ?? manifest.module ?? manifest.main;
+	if (!entry || typeof entry !== "string") throw new Error(`${pkgDir} has no resolvable entry point (exports/module/main).`);
+	return join(pkgDir, entry);
+}
+async function resolveOptional(specifier, cwd = process.cwd()) {
+	const anchors = [cwd, dirname(fileURLToPath(import.meta.url))];
+	for (const anchor of anchors) {
+		const pkgDir = findPackageDir(specifier, anchor);
+		if (!pkgDir) continue;
+		const resolved = entryFileFor(pkgDir);
+		try {
+			return await import(pathToFileURL(resolved).href);
+		} catch {
+			continue;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/cli/commands/render.ts
+const FORMATS$1 = /* @__PURE__ */ new Set(["mjml", "html"]);
+async function runRender(args) {
+	const file = args.positional[0];
+	if (!file) throw new UsageError("render needs a template file.");
+	const format = flagValue(args, "format") ?? "mjml";
+	if (!FORMATS$1.has(format)) throw new UsageError(`Unknown --format "${format}". Use mjml or html.`);
+	const cwd = flagValue(args, "cwd") ?? process.cwd();
+	const data = readTemplateFile(file, cwd);
+	const { valid, errors } = validateTemplate(data);
+	if (!valid) throw new InvalidTemplateError(`${file} is not structurally valid (${errors.length} error(s)).`, errors);
+	const mjml = await renderToMjml(data);
+	let output = mjml;
+	if (format === "html") {
+		const mod = await resolveOptional("mjml", cwd);
+		if (!mod) throw new MissingDependencyError("mjml", "Rendering HTML needs the optional `mjml` package, which isn't installed.\n  npm install mjml");
+		output = (await mod.default(mjml, { validationLevel: "soft" })).html;
+	}
+	const out = flagValue(args, "out", "o");
+	if (out) {
+		const path = resolveFrom(out, cwd);
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, output, "utf8");
+		note(`Wrote ${path}`);
+		return EXIT.ok;
+	}
+	emit({
+		format,
+		output
+	}, () => output);
+	return EXIT.ok;
+}
+//#endregion
+//#region src/cli/commands/edit.ts
+function parseOperations(args, cwd) {
+	const inline = flagValue(args, "op");
+	const batchFile = flagValue(args, "ops");
+	if (inline !== void 0 && batchFile !== void 0) throw new UsageError("Pass either --op or --ops, not both.");
+	if (inline) try {
+		return [JSON.parse(inline)];
+	} catch (err) {
+		throw new UsageError(`--op is not valid JSON: ${err.message}`);
+	}
+	if (batchFile) {
+		const parsed = readTemplateFile(batchFile, cwd);
+		if (!Array.isArray(parsed)) throw new UsageError("--ops must point at a JSON array of operations.");
+		return parsed;
+	}
+	throw new UsageError("edit needs --op '<json>' for one operation or --ops <file> for a batch.");
+}
+function runEdit(args) {
+	const file = args.positional[0];
+	if (!file) throw new UsageError("edit needs a template file.");
+	const cwd = flagValue(args, "cwd") ?? process.cwd();
+	const operations = parseOperations(args, cwd);
+	let content = readTemplateFile(file, cwd);
+	for (const [index, input] of operations.entries()) {
+		const result = applyOperation(content, {
+			operation: input.operation,
+			data: input.data ?? {},
+			timestamp: Date.now()
+		});
+		if (!result.ok) throw new UsageError(`Operation ${index + 1} (${String(input.operation)}) was rejected: ${result.error}`);
+		content = result.content;
+	}
+	const { valid, errors } = validateTemplate(content);
+	if (!valid) throw new InvalidTemplateError(`The edited template is not structurally valid (${errors.length} error(s)); ${file} was not written.`, errors);
+	const path = writeTemplateFile(file, content, cwd);
+	emit({
+		applied: operations.length,
+		file: path
+	}, () => `Applied ${operations.length} operation(s) to ${path}`);
+	return EXIT.ok;
+}
+//#endregion
+//#region src/cli/commands/import.ts
+const FORMATS = {
+	unlayer: {
+		pkg: "@templatical/import-unlayer",
+		fn: "convertUnlayerTemplate",
+		input: "json"
+	},
+	beefree: {
+		pkg: "@templatical/import-beefree",
+		fn: "convertBeeFreeTemplate",
+		input: "json"
+	},
+	stripo: {
+		pkg: "@templatical/import-stripo",
+		fn: "convertStripoTemplate",
+		input: "stripo"
+	},
+	topol: {
+		pkg: "@templatical/import-topol",
+		fn: "convertTopolTemplate",
+		input: "json"
+	},
+	chamaileon: {
+		pkg: "@templatical/import-chamaileon",
+		fn: "convertChamaileonTemplate",
+		input: "json"
+	},
+	"easy-email-pro": {
+		pkg: "@templatical/import-easy-email-pro",
+		fn: "convertEasyEmailProTemplate",
+		input: "json"
+	},
+	mjml: {
+		pkg: "@templatical/import-mjml",
+		fn: "convertMjmlTemplate",
+		input: "text"
+	},
+	html: {
+		pkg: "@templatical/import-html",
+		fn: "convertHtmlTemplate",
+		input: "text"
+	}
+};
+/** Strip a tag and its contents, so class scanning never reads CSS or script. */
+function withoutElements(html, tag) {
+	const open = `<${tag}`;
+	const close = `</${tag}`;
+	const lower = html.toLowerCase();
+	let out = "";
+	let pos = 0;
+	while (pos < html.length) {
+		const start = lower.indexOf(open, pos);
+		if (start === -1) {
+			out += html.slice(pos);
+			break;
+		}
+		const next = lower[start + open.length];
+		if (next !== void 0 && /[a-z0-9-]/.test(next)) {
+			out += html.slice(pos, start + open.length);
+			pos = start + open.length;
+			continue;
+		}
+		out += html.slice(pos, start);
+		const gt = html.indexOf(">", start);
+		if (gt === -1) break;
+		const closeAt = lower.indexOf(close, gt + 1);
+		if (closeAt === -1) break;
+		const closeGt = html.indexOf(">", closeAt);
+		if (closeGt === -1) break;
+		out += " ";
+		pos = closeGt + 1;
+	}
+	return out;
+}
+/** Every class token in the markup, ignoring <style> and <script> contents. */
+function markupClassTokens(html) {
+	const stripped = withoutElements(withoutElements(html, "style"), "script");
+	const tokens = [];
+	const re = /\bclass\s*=\s*(["'])([^"']*)\1/gi;
+	let m;
+	while (m = re.exec(stripped)) tokens.push(...m[2].trim().split(/\s+/).filter(Boolean));
+	return tokens;
+}
+/** Stripo's own class prefixes, which survive both of its export shapes. */
+function looksLikeStripoHtml(html) {
+	if (typeof html !== "string" || html.trim().length === 0) return false;
+	const tokens = markupClassTokens(html);
+	if (tokens.some((t) => t === "esd-stripe" || t === "esd-structure" || t === "esd-container-frame" || t.startsWith("esd-block-"))) return true;
+	return tokens.some((t) => t === "es-wrapper" || t === "es-content-body" || t === "es-header-body");
+}
+/** Easy Email Pro marks its own nodes `standard-*`; OSS Easy Email does not. */
+function hasStandardType(node) {
+	if (!node || typeof node !== "object") return false;
+	const n = node;
+	if (typeof n.type === "string" && n.type.startsWith("standard-")) return true;
+	if (Array.isArray(n.children)) return n.children.some(hasStandardType);
+	return false;
+}
+/** Guess the source format, or null when the caller must pass --format. */
+function detectFormat(fileName, content) {
+	const ext = extname(fileName).toLowerCase();
+	const trimmed = content.trimStart();
+	if (ext === ".mjml") return "mjml";
+	if (/^<(\?xml[^>]*\?>\s*)?<?\s*mjml[\s>]/i.test(trimmed)) return "mjml";
+	if (/^<\s*mj-body[\s>]/i.test(trimmed)) return "mjml";
+	if (looksLikeStripoHtml(content)) return "stripo";
+	if (ext === ".html" || ext === ".htm") return "html";
+	if (trimmed.startsWith("<")) return "html";
+	if (trimmed.startsWith("{")) {
+		let obj;
+		try {
+			obj = JSON.parse(content);
+		} catch {
+			return null;
+		}
+		if (obj?.body?.rows) return "unlayer";
+		if (obj?.page?.rows) return "beefree";
+		if (obj?.tagName === "mj-global-style") return "topol";
+		if (obj?.body?.type === "body") return "chamaileon";
+		const page = obj?.content?.type === "page" ? obj.content : obj?.type === "page" ? obj : null;
+		if (page && hasStandardType(page)) return "easy-email-pro";
+		if (typeof obj?.html === "string" && looksLikeStripoHtml(obj.html)) return "stripo";
+		return null;
+	}
+	return null;
+}
+/** Split a Stripo source into html + css, whichever shape it arrived in. */
+function unpackStripoSource(source) {
+	if (source.trimStart().startsWith("{")) try {
+		const obj = JSON.parse(source);
+		if (typeof obj?.html === "string") return {
+			html: obj.html,
+			css: typeof obj.css === "string" ? obj.css : void 0
+		};
+	} catch {}
+	return { html: source };
+}
+/** The stylesheet a plugin host wrote beside an HTML export, if there is one. */
+function siblingCss(sourcePath, source) {
+	if (source.trimStart().startsWith("{")) return void 0;
+	const cssPath = sourcePath.replace(/\.[^.]+$/, ".css");
+	if (cssPath === sourcePath || !existsSync(cssPath)) return void 0;
+	return readFileSync(cssPath, "utf8");
+}
+/**
+* Status counts from a converter's report. Derived from `report.entries` (every
+* entry carries a `status`) rather than each package's own `summary` shape, so
+* it works identically across all three converters and any future one.
+*/
+function summarizeReport(report) {
+	const r = report;
+	const counts = {
+		total: 0,
+		converted: 0,
+		approximated: 0,
+		htmlFallback: 0,
+		skipped: 0,
+		warnings: r?.warnings ?? []
+	};
+	for (const e of r?.entries ?? []) {
+		counts.total++;
+		if (e.status === "converted") counts.converted++;
+		else if (e.status === "approximated") counts.approximated++;
+		else if (e.status === "html-fallback") counts.htmlFallback++;
+		else if (e.status === "skipped") counts.skipped++;
+	}
+	return counts;
+}
+async function listFormats(cwd) {
+	const formats = [];
+	for (const [format, spec] of Object.entries(FORMATS)) formats.push({
+		format,
+		package: spec.pkg,
+		available: await resolveOptional(spec.pkg, cwd) !== null
+	});
+	emit({ formats }, () => formats.map((f) => `  ${f.format.padEnd(14)} ${f.package}${f.available ? "" : "  (not installed)"}`).join("\n"));
+	return EXIT.ok;
+}
+async function runImport(args) {
+	const cwd = flagValue(args, "cwd") ?? process.cwd();
+	if (args.flags["list-formats"]) return listFormats(cwd);
+	const file = args.positional[0];
+	if (!file) throw new UsageError("import needs a source file.");
+	const path = resolveFrom(file, cwd);
+	let source;
+	try {
+		source = readFileSync(path, "utf8");
+	} catch {
+		throw new UsageError(`Could not read ${file}`);
+	}
+	const known = Object.keys(FORMATS).join(", ");
+	const requested = flagValue(args, "format");
+	if (requested && !FORMATS[requested]) throw new UsageError(`Unknown --format "${requested}". Known formats: ${known}.`);
+	const format = requested ?? detectFormat(path, source);
+	if (!format) throw new UsageError(`Could not detect the format of ${file}. Pass --format with one of: ${known}.`);
+	const spec = FORMATS[format];
+	const mod = await resolveOptional(spec.pkg, cwd);
+	if (!mod) throw new MissingDependencyError(spec.pkg, `Importing ${format} needs ${spec.pkg}, which isn't installed.\n  npm install ${spec.pkg}`);
+	const convert = mod[spec.fn];
+	let content;
+	let report;
+	if (spec.input === "stripo") {
+		const unpacked = unpackStripoSource(source);
+		const css = unpacked.css ?? siblingCss(path, source);
+		({content, report} = convert(unpacked.html, css ? { css } : void 0));
+	} else {
+		const input = spec.input === "json" ? JSON.parse(source) : source;
+		({content, report} = convert(input));
+	}
+	const outName = flagValue(args, "out") ?? basename(path, extname(path));
+	const written = writeTemplateFile(`${WORKING_DIR}/${outName}.json`, content, cwd);
+	const counts = summarizeReport(report);
+	const lossy = counts.htmlFallback + counts.skipped > 0;
+	emit({
+		format,
+		file: written,
+		report: counts
+	}, () => [
+		`Imported ${format} to ${written}`,
+		`  ${counts.converted} converted, ${counts.approximated} approximated, ${counts.htmlFallback} html fallback, ${counts.skipped} skipped`,
+		...counts.warnings.map((w) => `  ! ${w}`),
+		lossy ? "  Import is lossy. Open it in live mode and refine the fallback blocks." : ""
+	].filter(Boolean).join("\n"));
+	return EXIT.ok;
+}
+//#endregion
+//#region src/cli/commands/live.ts
+/**
+* The first title block's text in document order, as a hint for `list`.
+*
+* It must descend into a section's columns, not scan top-level blocks only:
+* templates put their content inside sections (that is the documented
+* structure), so a top-level scan finds nothing for a real template. Measured
+* across all five of the templatical skill's examples — event-invite, newsletter,
+* product-sale, receipt, welcome — none has a top-level title block, so a
+* shallow version of this returns null every time and the hint is dead code.
+*/
+function titleHint(content) {
+	return findTitle(content?.blocks);
+}
+function findTitle(blocks) {
+	if (!Array.isArray(blocks)) return null;
+	for (const block of blocks) {
+		if (block?.type === "title" && typeof block.content === "string") return block.content;
+		if (block?.type === "section" && Array.isArray(block.children)) for (const column of block.children) {
+			const hit = findTitle(column);
+			if (hit) return hit;
+		}
+	}
+	return null;
+}
+function runList(args) {
+	const cwd = flagValue(args, "cwd") ?? process.cwd();
+	const templates = listWorkingFiles(cwd).map((name) => ({
+		name,
+		title: titleHint(readWorkingFile(join(cwd, WORKING_DIR, name)))
+	}));
+	emit({ templates }, () => templates.length === 0 ? `No templates in ${WORKING_DIR}/` : templates.map((t) => `  ${t.name}${t.title ? ` - ${t.title}` : ""}`).join("\n"));
+	return EXIT.ok;
+}
+async function postTo(port, path) {
+	return fetch(`http://localhost:${port}${path}`, {
+		method: "POST",
+		headers: { "content-type": "application/json" }
+	});
+}
+async function runLive(args) {
+	const sub = args.positional[0];
+	const cwd = resolveFrom(flagValue(args, "cwd") ?? ".", process.cwd());
+	if (sub === "reload" || sub === "stop") {
+		const info = readPidfile(cwd);
+		if (!info || !processAlive(info.pid)) throw new UsageError(`No live server is running here (no live pidfile at ${WORKING_DIR}/live-server.pid).`);
+		if (sub === "reload") {
+			const body = await (await postTo(info.port, "/reload")).json().catch(() => ({}));
+			emit({
+				reloaded: true,
+				clients: body.clients ?? 0
+			}, () => `Pushed the working file to ${body.clients ?? 0} connected page(s).`);
+			return EXIT.ok;
+		}
+		try {
+			process.kill(info.pid, "SIGTERM");
+		} catch {}
+		rmSync(pidfilePath(cwd), { force: true });
+		emit({ stopped: true }, () => "Stopped the live server.");
+		return EXIT.ok;
+	}
+	if (sub !== void 0) throw new UsageError(`Unknown "live ${sub}". Use \`live\`, \`live reload\` or \`live stop\`.`);
+	const portFlag = flagValue(args, "port");
+	const preferredPort = portFlag ? Number(portFlag) : DEFAULT_PORT;
+	const existing = readPidfile(cwd);
+	if (existing && processAlive(existing.pid)) {
+		emit({
+			url: `http://localhost:${existing.port}/`,
+			pid: existing.pid,
+			alreadyRunning: true
+		}, () => `Live server already running (pid ${existing.pid}) at http://localhost:${existing.port}/`);
+		return EXIT.ok;
+	}
+	if (existing) rmSync(pidfilePath(cwd), { force: true });
+	const file = flagValue(args, "file");
+	const handle = await startBridgePreferring({
+		cwd,
+		preferredPort,
+		file
+	});
+	mkdirSync(dirname(pidfilePath(cwd)), { recursive: true });
+	writeFileSync(pidfilePath(cwd), JSON.stringify({
+		pid: process.pid,
+		port: handle.port
+	}), "utf8");
+	const cleanup = () => {
+		rmSync(pidfilePath(cwd), { force: true });
+		handle.close().finally(() => process.exit(EXIT.ok));
+	};
+	process.on("SIGINT", cleanup);
+	process.on("SIGTERM", cleanup);
+	emit({
+		url: handle.url,
+		port: handle.port,
+		preferredPort,
+		fellBack: handle.fellBack,
+		workingFile: handle.workingPath
+	}, () => [
+		`Templatical live preview running at ${handle.url}`,
+		handle.fellBack ? `(port ${preferredPort} was busy - using ${handle.port})` : "",
+		`Working file: ${handle.workingPath}`
+	].filter(Boolean).join("\n"));
+	if (args.flags["no-open"]) note(`Open ${handle.url} in a browser.`);
+	else {
+		note(`Opening ${handle.url} in your default browser...`);
+		openBrowser(handle.url);
+	}
+	note("After writing the working file, run: templatical live reload");
+	return new Promise(() => {});
+}
+//#endregion
+//#region src/bin.ts
+const USAGE = `templatical <command> [options]
+
+  validate <file>                       structural + quality lint
+  schema   [--out <file>]               print the block JSON Schema
+  render   <file> [--format mjml|html] [-o <file>]  render to MJML or HTML
+  edit     <file> --op '<json>' | --ops <file>  apply operations, write the result
+  import   <file> [--format <fmt>] | --list-formats  convert a design to Templatical JSON
+  live     [--file <f>] [--port <n>] [--cwd <d>] [--no-open]
+  live reload | live stop
+  list                                           working files in .templatical/
+
+Options:
+  --json                                machine-readable output on stdout
+`;
+async function main(argv) {
+	const args = parseArgs(argv);
+	setJsonMode(args.json);
+	switch (args.command) {
+		case "validate": return runValidate(args);
+		case "schema": return runSchema(args);
+		case "render": return await runRender(args);
+		case "edit": return runEdit(args);
+		case "import": return await runImport(args);
+		case "live": return await runLive(args);
+		case "list": return runList(args);
+		case "help":
+			note(USAGE);
+			return EXIT.ok;
+		case void 0:
+			if (args.flags.help === true || args.flags.h === true) {
+				note(USAGE);
+				return EXIT.ok;
+			}
+			note(USAGE);
+			return EXIT.usage;
+		default:
+			note(`Unknown command "${args.command}".\n\n${USAGE}`);
+			return EXIT.usage;
+	}
+}
+function isEntryPoint() {
+	const argv1 = process.argv[1];
+	if (!argv1) return false;
+	try {
+		return pathToFileURL(realpathSync(argv1)).href === import.meta.url;
+	} catch {
+		return false;
+	}
+}
+if (isEntryPoint()) main(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {
+	if (err instanceof InvalidTemplateError) {
+		note(err.message);
+		for (const e of err.errors) note(`  - ${e}`);
+		process.exit(EXIT.invalid);
+	}
+	if (err instanceof MissingDependencyError) {
+		note(err.message);
+		process.exit(EXIT.missingDep);
+	}
+	if (err instanceof UsageError) {
+		note(err.message);
+		process.exit(EXIT.usage);
+	}
+	note(`Unexpected error: ${err?.message ?? String(err)}`);
+	process.exit(EXIT.usage);
+});
+//#endregion
+export { isEntryPoint, main };
+
+//# sourceMappingURL=bin.js.map