@homepages/template-kit 0.2.0 → 0.4.0

package/dist/cli/new/scaffold/template/theme.css

@@ -0,0 +1,24 @@
+/* Generated by `template-kit theme` from theme.ts — do not edit.
+   Re-run `template-kit theme` after changing theme.ts. */
+@theme inline {
+  --color-accent: var(--tr-color-accent);
+  --color-background: var(--tr-color-background);
+  --color-ink: var(--tr-color-ink);
+  --font-body: var(--tr-font-body);
+  --text-base: var(--tr-text-base);
+}
+
+:root {
+  --tr-color-accent: #2f6df6;
+  --tr-color-background: #ffffff;
+  --tr-color-ink: #1a1d21;
+  --tr-font-body: system-ui, -apple-system, sans-serif;
+  --tr-text-base: 1rem;
+}
+
+body {
+  font-family: var(--tr-font-body);
+  color: var(--tr-color-ink);
+  background: var(--tr-color-background);
+  font-size: var(--tr-text-base);
+}

package/dist/cli/new/scaffold/template/theme.ts

@@ -0,0 +1,27 @@
+import type { TokenTheme } from "@homepages/template-kit";
+
+// A template's design tokens. `template-kit theme` compiles this to theme.css;
+// `template-kit dev` reads it directly. The `document` refs must name declared
+// tokens (color/background → colors, font → fonts, fontSize → type).
+export const theme: TokenTheme = {
+  colors: {
+    ink: "#1a1d21",
+    background: "#ffffff",
+    accent: "#2f6df6",
+  },
+  fonts: {
+    body: "system-ui, -apple-system, sans-serif",
+  },
+  type: {
+    base: "1rem",
+  },
+  radii: {},
+  shadows: {},
+  layout: {},
+  document: {
+    font: "body",
+    color: "ink",
+    background: "background",
+    fontSize: "base",
+  },
+};

package/dist/cli/new/scaffold-assets.js

@@ -0,0 +1,20 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+//#region src/cli/new/scaffold-assets.ts
+const here = dirname(fileURLToPath(import.meta.url));
+function assetsRoot() {
+	const dist = join(here, "scaffold");
+	if (existsSync(dist)) return dist;
+	return join(here, "..", "..", "..", "create-homepages-workspace", "scaffold");
+}
+function templateAssetsDir() {
+	return join(assetsRoot(), "template");
+}
+function sectionAssetsDir() {
+	return join(assetsRoot(), "section");
+}
+
+//#endregion
+export { sectionAssetsDir, templateAssetsDir };

package/dist/cli/pack/collect.js

@@ -0,0 +1,44 @@
+import { join, relative, sep } from "node:path";
+import { createHash } from "node:crypto";
+import { readFile, readdir } from "node:fs/promises";
+
+//#region src/cli/pack/collect.ts
+const toPosix = (p) => p.split(sep).join("/");
+async function walk(dir, out) {
+	for (const entry of await readdir(dir, { withFileTypes: true })) if (entry.isDirectory()) {
+		if (entry.name === "node_modules") continue;
+		await walk(join(dir, entry.name), out);
+	} else if (entry.isFile()) out.push(join(dir, entry.name));
+}
+/**
+* Reads a template's regular files into sorted, hashable entries.
+*
+* Only real files and directories are walked: `node_modules` is skipped at any
+* depth, and symlinks are omitted (a `Dirent` is neither `isFile()` nor
+* `isDirectory()`), so a symlinked source file will not appear in the pack.
+* Templates are authored as plain trees, so this is a non-issue in practice —
+* but a submission that relies on a symlinked file would pack without it.
+*/
+async function collectTemplateFiles(workspaceRoot, templateDir) {
+	const absPaths = [];
+	await walk(templateDir, absPaths);
+	const files = await Promise.all(absPaths.map(async (abs) => ({
+		archivePath: toPosix(relative(workspaceRoot, abs)),
+		templatePath: toPosix(relative(templateDir, abs)),
+		bytes: await readFile(abs)
+	})));
+	files.sort((a, b) => a.archivePath < b.archivePath ? -1 : a.archivePath > b.archivePath ? 1 : 0);
+	return files;
+}
+function contentHash(files) {
+	const ordered = [...files].sort((a, b) => a.templatePath < b.templatePath ? -1 : a.templatePath > b.templatePath ? 1 : 0);
+	const top = createHash("sha256");
+	for (const file of ordered) {
+		const inner = createHash("sha256").update(file.bytes).digest("hex");
+		top.update(file.templatePath).update("\0").update(inner).update("\n");
+	}
+	return `sha256:${top.digest("hex")}`;
+}
+
+//#endregion
+export { collectTemplateFiles, contentHash };

package/dist/cli/pack/guards.js

@@ -0,0 +1,57 @@
+import { readLinkMarker } from "../link/overlay.js";
+import { z } from "zod";
+import { join } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+
+//#region src/cli/pack/guards.ts
+const depsSchema = z.object({
+	dependencies: z.record(z.string(), z.string()).optional(),
+	devDependencies: z.record(z.string(), z.string()).optional(),
+	optionalDependencies: z.record(z.string(), z.string()).optional()
+}).passthrough();
+async function isFile(p) {
+	try {
+		return (await stat(p)).isFile();
+	} catch {
+		return false;
+	}
+}
+function localProtocolDeps(pkg) {
+	const offenders = [];
+	for (const block of [
+		pkg.dependencies,
+		pkg.devDependencies,
+		pkg.optionalDependencies
+	]) for (const [name, spec] of Object.entries(block ?? {})) if (spec.startsWith("file:") || spec.startsWith("link:")) offenders.push(`${name} (${spec})`);
+	return offenders;
+}
+async function preflightGuards(workspaceRoot) {
+	const refusals = [];
+	if (await readLinkMarker(workspaceRoot) !== void 0) refusals.push({
+		reason: "a linked kit overlay is active in this workspace.",
+		fix: "Run `template-kit unlink` to restore the published kit, then pack."
+	});
+	if (!await isFile(join(workspaceRoot, "package-lock.json"))) refusals.push({
+		reason: "missing lockfile (package-lock.json) at workspace root.",
+		fix: "Run npm install and commit the lockfile — a submission without one cannot be reproduced."
+	});
+	let pkgJson;
+	try {
+		pkgJson = JSON.parse(await readFile(join(workspaceRoot, "package.json"), "utf8"));
+	} catch {
+		refusals.push({
+			reason: "package.json at the workspace root is missing or not valid JSON.",
+			fix: "Ensure the workspace root has a well-formed package.json before packing."
+		});
+		return refusals;
+	}
+	const parsed = depsSchema.safeParse(pkgJson);
+	if (parsed.success) for (const dep of localProtocolDeps(parsed.data)) refusals.push({
+		reason: `dependency ${dep} uses a local file:/link: protocol.`,
+		fix: "Depend on published versions only — a submission must install from the registry."
+	});
+	return refusals;
+}
+
+//#endregion
+export { preflightGuards };

package/dist/cli/pack/index.js

@@ -0,0 +1,66 @@
+import { findWorkspaceRoot, selectTemplates, templateFromCwd } from "../check/workspace.js";
+import { runCheck } from "../check/index.js";
+import { collectTemplateFiles, contentHash } from "./collect.js";
+import { preflightGuards } from "./guards.js";
+import { buildPackManifest } from "./manifest.js";
+import { buildZip } from "./zip.js";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { readFile, writeFile } from "node:fs/promises";
+
+//#region src/cli/pack/index.ts
+function refusal(lines) {
+	return {
+		code: 1,
+		output: `template-kit pack: cannot pack.\n${lines.join("\n")}\n`
+	};
+}
+async function runPack(argv, cwd) {
+	const { positionals } = parseArgs({
+		args: argv,
+		allowPositionals: true
+	});
+	const root = await findWorkspaceRoot(cwd);
+	const template = (await selectTemplates(root, positionals[0] ?? templateFromCwd(root, cwd), false, "pack"))[0];
+	if (template === void 0) return refusal(["  this workspace has no template to pack: templates/ holds no template folder."]);
+	const preflight = await preflightGuards(root);
+	if (preflight.length > 0) return refusal(preflight.map((r) => `  ${r.reason}\n    fix: ${r.fix}`));
+	const { code: checkCode, output: checkOut } = await runCheck([template.key], cwd);
+	if (checkCode !== 0) return {
+		code: 1,
+		output: `template-kit pack: \`check\` must pass before packing.\n\n${checkOut}`
+	};
+	const files = await collectTemplateFiles(root, template.dir);
+	const hash = contentHash(files);
+	const manifest = buildPackManifest({
+		template: template.key,
+		contentHash: hash,
+		packedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	const entries = [
+		{
+			path: "pack-manifest.json",
+			bytes: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8")
+		},
+		{
+			path: "package.json",
+			bytes: await readFile(join(root, "package.json"))
+		},
+		{
+			path: "package-lock.json",
+			bytes: await readFile(join(root, "package-lock.json"))
+		},
+		...files.map((f) => ({
+			path: f.archivePath,
+			bytes: f.bytes
+		}))
+	];
+	await writeFile(join(root, `${template.key}.zip`), buildZip(entries));
+	return {
+		code: 0,
+		output: `template-kit pack\n  wrote ${template.key}.zip\n  ${hash}\n  kit ${manifest.kitVersion}`
+	};
+}
+
+//#endregion
+export { runPack };

package/dist/cli/pack/manifest.js

@@ -0,0 +1,15 @@
+import { KIT_VERSION } from "../../index.js";
+
+//#region src/cli/pack/manifest.ts
+function buildPackManifest(input) {
+	return {
+		kitVersion: KIT_VERSION,
+		template: input.template,
+		contentHash: input.contentHash,
+		packedAt: input.packedAt,
+		check: { ok: true }
+	};
+}
+
+//#endregion
+export { buildPackManifest };

package/dist/cli/pack/zip.js

@@ -0,0 +1,86 @@
+import { deflateRawSync } from "node:zlib";
+
+//#region src/cli/pack/zip.ts
+const DOS_DATE = 33;
+const DOS_TIME = 0;
+const CRC_TABLE = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let n = 0; n < 256; n++) {
+		let c = n;
+		for (let k = 0; k < 8; k++) c = (c & 1) !== 0 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		table[n] = c >>> 0;
+	}
+	return table;
+})();
+function crc32(bytes) {
+	let c = 4294967295;
+	for (const byte of bytes) c = CRC_TABLE[(c ^ byte) & 255] ^ c >>> 8;
+	return (c ^ 4294967295) >>> 0;
+}
+/** A standard DEFLATE zip built from `entries`, in order. No zip64 — pack inputs
+* are source files, far under the 4 GiB per-entry limit. */
+function buildZip(entries) {
+	const locals = [];
+	const centrals = [];
+	let offset = 0;
+	for (const entry of entries) {
+		const name = Buffer.from(entry.path, "utf8");
+		const source = Buffer.from(entry.bytes);
+		const crc = crc32(source);
+		const compressed = deflateRawSync(source);
+		const local = Buffer.alloc(30 + name.length);
+		local.writeUInt32LE(67324752, 0);
+		local.writeUInt16LE(20, 4);
+		local.writeUInt16LE(2048, 6);
+		local.writeUInt16LE(8, 8);
+		local.writeUInt16LE(DOS_TIME, 10);
+		local.writeUInt16LE(DOS_DATE, 12);
+		local.writeUInt32LE(crc, 14);
+		local.writeUInt32LE(compressed.length, 18);
+		local.writeUInt32LE(source.length, 22);
+		local.writeUInt16LE(name.length, 26);
+		local.writeUInt16LE(0, 28);
+		name.copy(local, 30);
+		locals.push(local, compressed);
+		const central = Buffer.alloc(46 + name.length);
+		central.writeUInt32LE(33639248, 0);
+		central.writeUInt16LE(788, 4);
+		central.writeUInt16LE(20, 6);
+		central.writeUInt16LE(2048, 8);
+		central.writeUInt16LE(8, 10);
+		central.writeUInt16LE(DOS_TIME, 12);
+		central.writeUInt16LE(DOS_DATE, 14);
+		central.writeUInt32LE(crc, 16);
+		central.writeUInt32LE(compressed.length, 20);
+		central.writeUInt32LE(source.length, 24);
+		central.writeUInt16LE(name.length, 28);
+		central.writeUInt16LE(0, 30);
+		central.writeUInt16LE(0, 32);
+		central.writeUInt16LE(0, 34);
+		central.writeUInt16LE(0, 36);
+		central.writeUInt32LE(33188 << 16 >>> 0, 38);
+		central.writeUInt32LE(offset, 42);
+		name.copy(central, 46);
+		centrals.push(central);
+		offset += local.length + compressed.length;
+	}
+	const localData = Buffer.concat(locals);
+	const centralDir = Buffer.concat(centrals);
+	const eocd = Buffer.alloc(22);
+	eocd.writeUInt32LE(101010256, 0);
+	eocd.writeUInt16LE(0, 4);
+	eocd.writeUInt16LE(0, 6);
+	eocd.writeUInt16LE(entries.length, 8);
+	eocd.writeUInt16LE(entries.length, 10);
+	eocd.writeUInt32LE(centralDir.length, 12);
+	eocd.writeUInt32LE(localData.length, 16);
+	eocd.writeUInt16LE(0, 20);
+	return Buffer.concat([
+		localData,
+		centralDir,
+		eocd
+	]);
+}
+
+//#endregion
+export { buildZip };

package/dist/cli/theme/generate.js

@@ -0,0 +1,43 @@
+import { TokenThemeSchema, compileThemeToCss } from "../../design-system/theme.js";
+import { loadTheme } from "./load-theme.js";
+import { join } from "node:path";
+import { writeFile } from "node:fs/promises";
+
+//#region src/cli/theme/generate.ts
+const OUT_FILE = "theme.css";
+const HEADER = "/* Generated by `template-kit theme` from theme.ts — do not edit.\n   Re-run `template-kit theme` after changing theme.ts. */\n";
+/** theme.ts's `theme` export failed TokenThemeSchema; `issues` are `path: message` lines. */
+var InvalidTheme = class extends Error {
+	path;
+	issues;
+	constructor(path, issues) {
+		super(`${path} is not a valid TokenTheme:\n${issues.map((i) => `  - ${i}`).join("\n")}`);
+		this.path = path;
+		this.issues = issues;
+		this.name = "InvalidTheme";
+	}
+};
+/**
+* Compile `templates/<key>/theme.ts` to `templates/<key>/theme.css`. Throws
+* MissingThemeFile / MissingThemeExport (load-theme.ts) or InvalidTheme.
+*/
+async function generateTemplateTheme(root, template) {
+	const raw = await loadTheme(root, template);
+	const parsed = TokenThemeSchema.safeParse(raw);
+	if (!parsed.success) {
+		const issues = parsed.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`);
+		throw new InvalidTheme(join("templates", template.key, "theme.ts"), issues);
+	}
+	const theme = parsed.data;
+	const outPath = join(template.dir, OUT_FILE);
+	await writeFile(outPath, `${HEADER}${compileThemeToCss(theme)}`, "utf8");
+	const tokenCount = Object.keys(theme.colors).length + Object.keys(theme.fonts).length + Object.keys(theme.type).length + Object.keys(theme.radii).length + Object.keys(theme.shadows).length + Object.keys(theme.layout).length;
+	return {
+		outPath,
+		relPath: join("templates", template.key, OUT_FILE),
+		tokenCount
+	};
+}
+
+//#endregion
+export { InvalidTheme, generateTemplateTheme };

package/dist/cli/theme/index.js

@@ -0,0 +1,33 @@
+import { findWorkspaceRoot, selectTemplates, templateFromCwd } from "../check/workspace.js";
+import { generateTemplateTheme } from "./generate.js";
+import { parseArgs } from "node:util";
+
+//#region src/cli/theme/index.ts
+async function runTheme(argv, cwd) {
+	const { values, positionals } = parseArgs({
+		args: argv,
+		options: { all: {
+			type: "boolean",
+			default: false
+		} },
+		allowPositionals: true
+	});
+	const root = await findWorkspaceRoot(cwd);
+	const selected = await selectTemplates(root, positionals[0] ?? (values.all ? void 0 : templateFromCwd(root, cwd)), values.all, "theme");
+	if (selected.length === 0) return {
+		code: 1,
+		output: "No template to generate theme CSS for: templates/ holds no template folder."
+	};
+	const lines = [];
+	for (const template of selected) {
+		const { relPath, tokenCount } = await generateTemplateTheme(root, template);
+		lines.push(`  ${template.key}  wrote ${relPath} (${tokenCount} tokens)`);
+	}
+	return {
+		code: 0,
+		output: `template-kit theme\n${lines.join("\n")}`
+	};
+}
+
+//#endregion
+export { runTheme };

package/dist/cli/theme/load-theme.js

@@ -0,0 +1,69 @@
+import { loadEsbuild } from "../check/resolve-tool.js";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, stat } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+//#region src/cli/theme/load-theme.ts
+const THEME_FILE = "theme.ts";
+const THEME_EXPORT = "theme";
+/** A template has no theme.ts. `path` is workspace-relative. */
+var MissingThemeFile = class extends Error {
+	path;
+	constructor(path) {
+		super(`${path} not found. A template's design tokens live in theme.ts — create it exporting \`${THEME_EXPORT}\` (a TokenTheme).`);
+		this.path = path;
+		this.name = "MissingThemeFile";
+	}
+};
+/** theme.ts built, but exports no `theme` binding. `path` is workspace-relative. */
+var MissingThemeExport = class extends Error {
+	path;
+	constructor(path) {
+		super(`${path} does not export \`${THEME_EXPORT}\`. It must \`export const ${THEME_EXPORT}: TokenTheme = { … }\`.`);
+		this.path = path;
+		this.name = "MissingThemeExport";
+	}
+};
+const isFile = async (p) => {
+	try {
+		return (await stat(p)).isFile();
+	} catch {
+		return false;
+	}
+};
+/**
+* Transpile + evaluate `templates/<key>/theme.ts` and return its `theme` export,
+* unvalidated (the caller parses it with TokenThemeSchema). Throws MissingThemeFile
+* when theme.ts is absent and MissingThemeExport when it builds without a `theme`
+* binding.
+*/
+async function loadTheme(root, template) {
+	const source = join(template.dir, THEME_FILE);
+	const rel = join("templates", template.key, THEME_FILE);
+	if (!await isFile(source)) throw new MissingThemeFile(rel);
+	const outdir = join(root, "node_modules", ".template-kit", "theme", createHash("sha256").update(template.dir).digest("hex").slice(0, 12));
+	await rm(outdir, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(outdir, { recursive: true });
+	const { build } = await loadEsbuild(root);
+	await build({
+		entryPoints: [source],
+		outdir,
+		bundle: true,
+		format: "esm",
+		platform: "neutral",
+		packages: "external",
+		logLevel: "silent",
+		absWorkingDir: root
+	});
+	const version = createHash("sha256").update(await readFile(source)).digest("hex").slice(0, 12);
+	const value = (await import(`${pathToFileURL(join(outdir, "theme.js")).href}?v=${version}`))[THEME_EXPORT];
+	if (value === void 0) throw new MissingThemeExport(rel);
+	return value;
+}
+
+//#endregion
+export { MissingThemeExport, MissingThemeFile, loadTheme };

package/dist/cli.js

@@ -1,5 +1,12 @@
 #!/usr/bin/env node
 import { KIT_VERSION } from "./index.js";
+import { runCheck } from "./cli/check/index.js";
+import { runDev } from "./cli/dev/index.js";
+import { rebuildOverlay, runLinkOnce, runStatus, runUnlink } from "./cli/link/index.js";
+import { watchAndRebuild } from "./cli/link/watch.js";
+import { runNew, runNewSection } from "./cli/new/index.js";
+import { runPack } from "./cli/pack/index.js";
+import { runTheme } from "./cli/theme/index.js";
 
 //#region src/cli/index.ts
 /**
@@ -8,31 +15,27 @@ import { KIT_VERSION } from "./index.js";
 * printed to template authors outside HomePages. The command → issue map is in
 * CLAUDE.md, which does not ship in the tarball.
 */
-const NOT_IMPLEMENTED = /* @__PURE__ */ new Set([
-	"dev",
-	"check",
-	"pack",
-	"link",
-	"unlink",
-	"status"
-]);
+const NOT_IMPLEMENTED = /* @__PURE__ */ new Set();
 const USAGE = `template-kit ${KIT_VERSION}
 
 Usage: template-kit <command>
 
 Commands:
-  dev       Local preview server                 (not implemented yet)
-  check     Typecheck, lint, and validate        (not implemented yet)
-  pack      Build the submission artifact        (not implemented yet)
-  link      Overlay a local kit build            (not implemented yet)
-  unlink    Remove the overlay                   (not implemented yet)
-  status    Show overlay state                   (not implemented yet)
+  dev          Start the local preview server
+  check        Typecheck, lint, and validate a template
+  new          Add a template to the workspace
+  new-section  Add a section to a template
+  theme        Generate a template's theme CSS from its theme.ts
+  pack         Build a template's submission zip
+  link         Overlay a local kit build into a consumer (kit devs)
+  unlink       Restore the registry install              (kit devs)
+  status       Show overlay state                        (kit devs)
 
 Options:
   -v, --version   Print the kit version
   -h, --help      Print this message
 `;
-function main(argv) {
+async function main(argv) {
 	const cmd = argv[0];
 	if (cmd === "--version" || cmd === "-v") {
 		process.stdout.write(`${KIT_VERSION}\n`);
@@ -42,6 +45,87 @@ function main(argv) {
 		process.stdout.write(USAGE);
 		return 0;
 	}
+	if (cmd === "check") try {
+		const { code, output } = await runCheck(argv.slice(1), process.cwd());
+		process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+		return code;
+	} catch (cause) {
+		process.stderr.write(`template-kit check: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+		return 1;
+	}
+	if (cmd === "dev") try {
+		return await runDev(argv.slice(1), process.cwd());
+	} catch (cause) {
+		process.stderr.write(`template-kit dev: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+		return 1;
+	}
+	if (cmd === "theme") try {
+		const { code, output } = await runTheme(argv.slice(1), process.cwd());
+		process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+		return code;
+	} catch (cause) {
+		process.stderr.write(`template-kit theme: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+		return 1;
+	}
+	if (cmd === "pack") try {
+		const { code, output } = await runPack(argv.slice(1), process.cwd());
+		process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+		return code;
+	} catch (cause) {
+		process.stderr.write(`template-kit pack: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+		return 1;
+	}
+	if (cmd === "status" || cmd === "unlink") {
+		const run = cmd === "status" ? runStatus : runUnlink;
+		try {
+			const { code, output } = await run(argv.slice(1), process.cwd());
+			process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+			return code;
+		} catch (cause) {
+			process.stderr.write(`template-kit ${cmd}: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+			return 1;
+		}
+	}
+	if (cmd === "link") try {
+		const result = await runLinkOnce(argv.slice(1), process.cwd());
+		process.stdout.write(`${result.output}\n`);
+		const { kitSrcDir, kitRoot, workspaceRoot } = result.watch;
+		process.stdout.write("  watching for kit changes — Ctrl-C to stop\n");
+		let watchFailed = false;
+		await new Promise((resolvePromise) => {
+			const stop = watchAndRebuild(kitSrcDir, () => {
+				rebuildOverlay(kitRoot, workspaceRoot).then(() => process.stdout.write("  rebuilt + recopied\n"), (err) => process.stderr.write(`  rebuild failed: ${err instanceof Error ? err.message : String(err)}\n`));
+			}, (err) => {
+				watchFailed = true;
+				process.stderr.write(`  watch error — stopping: ${err instanceof Error ? err.message : String(err)}\n`);
+				resolvePromise();
+			});
+			process.on("SIGINT", () => {
+				stop();
+				resolvePromise();
+			});
+		});
+		return watchFailed ? 1 : 0;
+	} catch (cause) {
+		process.stderr.write(`template-kit link: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+		return 1;
+	}
+	if (cmd === "new") try {
+		const { code, output } = await runNew(argv.slice(1), process.cwd());
+		process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+		return code;
+	} catch (cause) {
+		process.stderr.write(`template-kit new: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+		return 1;
+	}
+	if (cmd === "new-section") try {
+		const { code, output } = await runNewSection(argv.slice(1), process.cwd());
+		process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+		return code;
+	} catch (cause) {
+		process.stderr.write(`template-kit new-section: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+		return 1;
+	}
 	if (NOT_IMPLEMENTED.has(cmd)) {
 		process.stderr.write(`template-kit ${cmd}: not implemented yet.\nThis 0.0.x release ships the package skeleton only.\n`);
 		return 1;
@@ -49,6 +133,6 @@ function main(argv) {
 	process.stderr.write(`template-kit: unknown command '${cmd}'\n\n${USAGE}`);
 	return 1;
 }
-process.exit(main(process.argv.slice(2)));
+process.exit(await main(process.argv.slice(2)));
 
 //#endregion