hollware 0.11.0 → 1.0.0-rc.1

package/dist/{args-CljWh-kZ.mjs → args-D42wi6n2.mjs}

@@ -1,4 +1,4 @@
-import { i as UsageError } from "./format-BpRYEsGB.mjs";
+import { n as UsageError } from "./errors-DJX_jiSP.mjs";
 import { parseArgs } from "node:util";
 //#region src/args.ts
 /**

package/dist/{d1-BGChD8_u.mjs → d1-BvAz-iyW.mjs}

@@ -1,76 +1,11 @@
-import { i as UsageError, r as CliError, t as printable } from "./format-BpRYEsGB.mjs";
-import { n as failureReason } from "./wrangler-BLIfwbcu.mjs";
+import { n as UsageError, t as CliError } from "./errors-DJX_jiSP.mjs";
+import { t as printable } from "./format-Dvk_h5ys.mjs";
+import { n as failureReason } from "./wrangler-DO3h-eNH.mjs";
+import { t as parseJsonc } from "./jsonc-CA2ezIB6.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import * as z from "zod";
 import { SCOPES, SITE_KEY_MAX_LENGTH, isId, isScope, isSiteKey } from "@hollware/core";
-//#region src/jsonc.ts
-/**
-* Reads JSON with comments, the format of `wrangler.jsonc`: `//` and `/* *\/` comments and a
-* comma before a closing bracket are dropped, and a comment marker inside a string is left
-* alone. It does nothing else: whatever `JSON.parse` rejects after that is an error.
-*/
-function parseJsonc(text) {
-	return JSON.parse(stripJsonc(text));
-}
-function stripJsonc(text) {
-	const source = text.startsWith("") ? text.slice(1) : text;
-	let out = "";
-	let mode = "code";
-	for (let i = 0; i < source.length; i += 1) {
-		const char = source.charAt(i);
-		const next = source.charAt(i + 1);
-		if (mode === "string") {
-			out += char;
-			if (char === "\\") {
-				out += next;
-				i += 1;
-			} else if (char === "\"") mode = "code";
-		} else if (mode === "line-comment") {
-			if (char === "\n") {
-				out += char;
-				mode = "code";
-			}
-		} else if (mode === "block-comment") {
-			if (char === "*" && next === "/") {
-				i += 1;
-				mode = "code";
-			} else if (char === "\n") out += char;
-		} else if (char === "\"") {
-			out += char;
-			mode = "string";
-		} else if (char === "/" && next === "/") {
-			i += 1;
-			mode = "line-comment";
-		} else if (char === "/" && next === "*") {
-			i += 1;
-			mode = "block-comment";
-		} else out += char;
-	}
-	if (mode === "block-comment") throw new SyntaxError("a /* comment is never closed");
-	return dropTrailingCommas(out);
-}
-/** Drops a comma that only whitespace separates from a closing bracket, outside strings. */
-function dropTrailingCommas(code) {
-	let out = "";
-	let inString = false;
-	for (let i = 0; i < code.length; i += 1) {
-		const char = code.charAt(i);
-		if (inString) {
-			out += char;
-			if (char === "\\") {
-				out += code.charAt(i + 1);
-				i += 1;
-			} else if (char === "\"") inString = false;
-		} else if (char === "\"") {
-			out += char;
-			inString = true;
-		} else if (char === "," && /^\s*[}\]]/.test(code.slice(i + 1))) continue;
-		else out += char;
-	}
-	return out;
-}
-//#endregion
 //#region src/sql.ts
 /**
 * Everything the CLI says to the database. A value a person types is checked first and then
@@ -322,4 +257,4 @@ function jsonOf(stdout) {
 	} catch {}
 }
 //#endregion
-export { parseJsonc as S, parseSiteKey as _, runFile as a, sitesAndOwnerQuery as b, insertInvitation as c, ownerOfSiteQuery as d, ownerQuery as f, parseScopes as g, parseOwnerName as h, resolveDatabase as i, insertToken as l, parseLabel as m, describeDatabase as n, anotherSiteScript as o, parseExpiresInDays as p, query as r, initScript as s, chooseTarget as t, listTokens as u, parseTokenId as v, sitesQuery as x, revokeToken as y };
+export { parseSiteKey as _, runFile as a, sitesAndOwnerQuery as b, insertInvitation as c, ownerOfSiteQuery as d, ownerQuery as f, parseScopes as g, parseOwnerName as h, resolveDatabase as i, insertToken as l, parseLabel as m, describeDatabase as n, anotherSiteScript as o, parseExpiresInDays as p, query as r, initScript as s, chooseTarget as t, listTokens as u, parseTokenId as v, sitesQuery as x, revokeToken as y };

package/dist/{deploy-8_Nvbr3b.mjs → deploy-DsHNryRG.mjs}

@@ -1,9 +1,9 @@
-import { r as CliError } from "./format-BpRYEsGB.mjs";
-import { n as failureReason, r as stripAnsi } from "./wrangler-BLIfwbcu.mjs";
-import { t as parseFlags } from "./args-CljWh-kZ.mjs";
-import { f as ownerQuery, i as resolveDatabase, r as query } from "./d1-BGChD8_u.mjs";
-import { t as publicUrlOf } from "./public-url-B2BXf_pj.mjs";
-import { i as migrate } from "./migrate-BqdgcoRJ.mjs";
+import { t as CliError } from "./errors-DJX_jiSP.mjs";
+import { i as stripAnsi, n as failureReason } from "./wrangler-DO3h-eNH.mjs";
+import { t as parseFlags } from "./args-D42wi6n2.mjs";
+import { f as ownerQuery, i as resolveDatabase, r as query } from "./d1-BvAz-iyW.mjs";
+import { t as publicUrlOf } from "./public-url-d_yOsEMO.mjs";
+import { i as migrate } from "./migrate-D2QcagMk.mjs";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/commands/deploy.ts

package/dist/dev--aG_y4gx.mjs

@@ -0,0 +1,182 @@
+import { n as UsageError, t as CliError } from "./errors-DJX_jiSP.mjs";
+import { r as findBin } from "./wrangler-DO3h-eNH.mjs";
+import { t as parseFlags } from "./args-D42wi6n2.mjs";
+import { t as publicUrlOf } from "./public-url-d_yOsEMO.mjs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/commands/dev.ts
+const DEV_USAGE = [
+	"Usage: hollware dev [--url <url>] [--timeout <seconds>] [--json]",
+	"       hollware dev --detach [--url <url>] [--timeout <seconds>] [--json]",
+	"       hollware dev --stop [--json]",
+	"",
+	"Starts the project's local server, the way its \"dev\" script does (the project's own vp dev),",
+	"waits until GET <url>/health answers, and prints \"Hollware is ready at <url>\". It stays in the",
+	"foreground until SIGINT or SIGTERM, then stops the server and everything it started.",
+	"With --detach it starts the server in the background, writes its process id and URL to",
+	`.wrangler/hollware-dev.json, prints the ready line and exits 0. "hollware dev --stop" stops what`,
+	"that file names.",
+	"",
+	"Options:",
+	"  --url <url>          Where the server listens (default: HOLLWARE_PUBLIC_URL of wrangler.jsonc,",
+	"                       else http://localhost:5199)",
+	"  --timeout <seconds>  How long to wait for /health, 1 to 600 (default: 60)",
+	"  --detach             Start it in the background and exit",
+	"  --stop               Stop the server that --detach started",
+	"  --json               One JSON object on stdout instead of the line",
+	"  --help               Show this help"
+].join("\n");
+/** The file that names the server `--detach` started, relative to the project. */
+const DEV_STATE_FILE = join(".wrangler", "hollware-dev.json");
+const DEFAULT_URL = "http://localhost:5199";
+const POLL_MS = 250;
+const GRACE_MS = 5e3;
+async function dev(argv, io) {
+	const { values } = parseFlags({
+		args: [...argv],
+		allowPositionals: false,
+		options: {
+			url: { type: "string" },
+			timeout: { type: "string" },
+			detach: { type: "boolean" },
+			stop: { type: "boolean" },
+			json: { type: "boolean" },
+			help: { type: "boolean" }
+		}
+	});
+	if (values.help === true) {
+		io.out(DEV_USAGE);
+		return 0;
+	}
+	const host = io.dev;
+	if (host === void 0) throw new CliError("this environment cannot run a local server.");
+	const json = values.json === true;
+	if (values.stop === true) {
+		if (values.detach === true || values.url !== void 0 || values.timeout !== void 0) throw new UsageError("--stop goes alone: it stops what --detach started.");
+		return stop(io, host, json);
+	}
+	const timeout = timeoutOf(values.timeout);
+	const url = (publicUrlOf(io.cwd, values.url) ?? DEFAULT_URL).replace(/\/$/, "");
+	const bin = findBin(io.cwd, "vp");
+	if (bin === void 0) throw new CliError(`vp is not installed in ${io.cwd} or any directory above it. Install the dependencies of the project (for example "pnpm install") and run hollware dev from the project directory.`);
+	const detach = values.detach === true;
+	const state = readState(io.cwd);
+	if (state !== void 0 && host.isAlive(state.pid)) throw new CliError(`a server started by --detach runs already (process ${state.pid}, ${state.url}). Stop it with "hollware dev --stop".`);
+	const child = host.spawn(bin, ["dev"], io.cwd, { detached: detach });
+	let interrupted = false;
+	let signalled = () => void 0;
+	const asked = new Promise((resolve) => {
+		signalled = () => resolve("signal");
+	});
+	const off = host.onSignal(() => {
+		interrupted = true;
+		signalled();
+	});
+	try {
+		const ready = await waitUntilHealthy(host, child, url, timeout, () => interrupted);
+		if (ready !== "ready") {
+			await terminate(host, child);
+			if (ready === "interrupted") return 0;
+			throw new CliError(ready === "exited" ? `the dev server stopped before it was ready.${detail(child)}` : `the dev server did not answer ${url}/health within ${timeout} seconds.${detail(child)}`);
+		}
+		announce(io, json, {
+			ready: true,
+			url,
+			pid: child.pid,
+			detached: detach
+		});
+		if (detach) {
+			const file = join(io.cwd, DEV_STATE_FILE);
+			mkdirSync(join(io.cwd, ".wrangler"), { recursive: true });
+			const record = {
+				pid: child.pid,
+				url,
+				startedAt: io.now().toISOString()
+			};
+			writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
+			return 0;
+		}
+		if (await Promise.race([asked, child.exited.then(() => "exited")]) === "exited") throw new CliError(`the dev server stopped by itself.${detail(child)}`);
+		await terminate(host, child);
+		return 0;
+	} finally {
+		off();
+	}
+}
+async function stop(io, host, json) {
+	const state = readState(io.cwd);
+	if (state === void 0) {
+		if (json) io.out(JSON.stringify({ stopped: false }));
+		else io.out(`No detached server to stop: ${DEV_STATE_FILE} does not exist.`);
+		return 0;
+	}
+	const wasAlive = host.isAlive(state.pid);
+	if (wasAlive) {
+		host.killGroup(state.pid, "SIGTERM");
+		const until = GRACE_MS / POLL_MS;
+		for (let waited = 0; host.isAlive(state.pid) && waited < until; waited += 1) await host.sleep(POLL_MS);
+		host.killGroup(state.pid, "SIGKILL");
+	}
+	rmSync(join(io.cwd, DEV_STATE_FILE), { force: true });
+	if (json) io.out(JSON.stringify({
+		stopped: wasAlive,
+		pid: state.pid,
+		url: state.url
+	}));
+	else io.out(wasAlive ? `Stopped the server at ${state.url} (process ${state.pid}).` : `The server at ${state.url} (process ${state.pid}) was not running; removed ${DEV_STATE_FILE}.`);
+	return 0;
+}
+function announce(io, json, what) {
+	io.out(json ? JSON.stringify(what) : `Hollware is ready at ${what.url}`);
+}
+function timeoutOf(value) {
+	if (value === void 0) return 60;
+	const seconds = /^\d+$/.test(value) ? Number(value) : NaN;
+	if (!(seconds >= 1 && seconds <= 600)) throw new UsageError(`--timeout is a whole number of seconds from 1 to 600, not "${value}".`);
+	return seconds;
+}
+/** Polls /health until it answers, the server ends, a signal comes or the time is up. */
+async function waitUntilHealthy(host, child, url, seconds, interrupted) {
+	let ended = false;
+	child.exited.then(() => {
+		ended = true;
+	});
+	for (let waited = 0; waited <= seconds * 1e3; waited += POLL_MS) {
+		if (interrupted()) return "interrupted";
+		if (ended) return "exited";
+		if (await host.healthy(url)) return "ready";
+		await host.sleep(POLL_MS);
+	}
+	return "timeout";
+}
+/** Stops the server: SIGTERM to its group, SIGKILL when it has not ended after a grace period. */
+async function terminate(host, child) {
+	host.killGroup(child.pid, "SIGTERM");
+	const clear = new AbortController();
+	const ended = await Promise.race([child.exited.then(() => true), host.sleep(GRACE_MS, clear.signal).then(() => false)]);
+	clear.abort();
+	if (!ended) {
+		host.killGroup(child.pid, "SIGKILL");
+		await child.exited;
+	}
+	await host.sleep(POLL_MS);
+	host.killGroup(child.pid, "SIGKILL");
+}
+function detail(child) {
+	const tail = child.tail().trim();
+	return tail === "" ? "" : `\n${tail}`;
+}
+function readState(cwd) {
+	const file = join(cwd, DEV_STATE_FILE);
+	if (!existsSync(file)) return void 0;
+	try {
+		const parsed = JSON.parse(readFileSync(file, "utf8"));
+		if (typeof parsed === "object" && parsed !== null && "pid" in parsed && "url" in parsed && typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 1 && typeof parsed.url === "string") return {
+			pid: parsed.pid,
+			url: parsed.url,
+			startedAt: "startedAt" in parsed && typeof parsed.startedAt === "string" ? parsed.startedAt : ""
+		};
+	} catch {}
+}
+//#endregion
+export { dev };

package/dist/{doctor-BT_bTF1M.mjs → doctor-fpXiQgnU.mjs}

@@ -1,13 +1,14 @@
-import { r as CliError } from "./format-BpRYEsGB.mjs";
-import { n as failureReason } from "./wrangler-BLIfwbcu.mjs";
-import { t as parseFlags } from "./args-CljWh-kZ.mjs";
-import { S as parseJsonc, f as ownerQuery, r as query, t as chooseTarget } from "./d1-BGChD8_u.mjs";
-import { a as parsePendingMigrations } from "./migrate-BqdgcoRJ.mjs";
+import { t as CliError } from "./errors-DJX_jiSP.mjs";
+import { n as failureReason } from "./wrangler-DO3h-eNH.mjs";
+import { t as parseFlags } from "./args-D42wi6n2.mjs";
+import { t as parseJsonc } from "./jsonc-CA2ezIB6.mjs";
+import { f as ownerQuery, r as query, t as chooseTarget } from "./d1-BvAz-iyW.mjs";
+import { a as parsePendingMigrations } from "./migrate-D2QcagMk.mjs";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 //#region src/commands/doctor.ts
 const DOCTOR_USAGE = [
-	"Usage: hollware doctor [--local | --remote]",
+	"Usage: hollware doctor [--local | --remote] [--json]",
 	"",
 	"Checks the project in the current directory: its wrangler.jsonc, the bindings and flags",
 	"Hollware needs, the built files of the admin, the migrations of the database and its owner.",
@@ -16,6 +17,8 @@ const DOCTOR_USAGE = [
 	"Options:",
 	"  --local   Check the local database (the default)",
 	"  --remote  Check the database in Cloudflare",
+	"  --json    One JSON object on stdout: { ok, checks: [{ name, ok, message, fix }] }; the exit code",
+	"            is the same (fix is \"\" for a check that passed)",
 	"  --help    Show this help"
 ].join("\n");
 /** The flags of `compatibility_flags` that Hollware runs with (ADR-018, ADR-026). */
@@ -24,11 +27,13 @@ const REQUIRED_FLAGS = [
 	"no_nodejs_compat_v2",
 	"global_fetch_strictly_public"
 ];
-const pass = (what) => ({
+const pass = (name, what) => ({
+	name,
 	ok: true,
 	what
 });
-const fail = (what, fix) => ({
+const fail = (name, what, fix) => ({
+	name,
 	ok: false,
 	what,
 	fix
@@ -44,20 +49,20 @@ function checkConfig(cwd, config) {
 	const findings = [];
 	const flags = Array.isArray(config["compatibility_flags"]) ? config["compatibility_flags"] : [];
 	const missing = REQUIRED_FLAGS.filter((flag) => !flags.includes(flag));
-	findings.push(missing.length === 0 ? pass(`compatibility_flags has ${REQUIRED_FLAGS.join(", ")}`) : fail(`compatibility_flags lacks ${missing.join(", ")}`, `Add ${missing.map((flag) => `"${flag}"`).join(", ")} to compatibility_flags in wrangler.jsonc.`));
+	findings.push(missing.length === 0 ? pass("compatibility-flags", `compatibility_flags has ${REQUIRED_FLAGS.join(", ")}`) : fail("compatibility-flags", `compatibility_flags lacks ${missing.join(", ")}`, `Add ${missing.map((flag) => `"${flag}"`).join(", ")} to compatibility_flags in wrangler.jsonc.`));
 	const url = (isRecord(config["vars"]) ? config["vars"] : {})["HOLLWARE_PUBLIC_URL"];
 	const urlOk = typeof url === "string" && URL.canParse(url) && /^https?:$/.test(new URL(url).protocol);
-	findings.push(urlOk ? pass(`HOLLWARE_PUBLIC_URL is ${new URL(url).origin}`) : fail("HOLLWARE_PUBLIC_URL is missing or is no http or https URL", "Set vars.HOLLWARE_PUBLIC_URL in wrangler.jsonc to the public URL of the Worker, such as https://cms.example.com."));
+	findings.push(urlOk ? pass("public-url", `HOLLWARE_PUBLIC_URL is ${new URL(url).origin}`) : fail("public-url", "HOLLWARE_PUBLIC_URL is missing or is no http or https URL", "Set vars.HOLLWARE_PUBLIC_URL in wrangler.jsonc to the public URL of the Worker, such as https://cms.example.com."));
 	const db = records(config["d1_databases"]).find((entry) => entry["binding"] === "DB");
 	const migrationsDir = db !== void 0 && typeof db["migrations_dir"] === "string" ? join(cwd, db["migrations_dir"]) : void 0;
 	const migrations = migrationsDir !== void 0 && existsSync(migrationsDir) ? readdirSync(migrationsDir).filter((name) => name.endsWith(".sql")) : [];
-	findings.push(db === void 0 ? fail(`there is no D1 binding "DB"`, "Add it to d1_databases in wrangler.jsonc, as the starter has it.") : migrations.length === 0 ? fail(`the D1 binding "DB" has no migrations in its migrations_dir`, "Set migrations_dir to \"node_modules/@hollware/server/migrations\", and install the dependencies.") : pass(`the D1 binding "DB" has ${migrations.length} migrations`));
+	findings.push(db === void 0 ? fail("d1-binding", `there is no D1 binding "DB"`, "Add it to d1_databases in wrangler.jsonc, as the starter has it.") : migrations.length === 0 ? fail("d1-binding", `the D1 binding "DB" has no migrations in its migrations_dir`, "Set migrations_dir to \"node_modules/@hollware/server/migrations\", and install the dependencies.") : pass("d1-binding", `the D1 binding "DB" has ${migrations.length} migrations`));
 	const kv = records(config["kv_namespaces"]).some((entry) => entry["binding"] === "OAUTH_KV");
-	findings.push(kv ? pass("the KV binding \"OAUTH_KV\" is there") : fail("there is no KV binding \"OAUTH_KV\", which the OAuth server needs", "Add { \"binding\": \"OAUTH_KV\" } to kv_namespaces in wrangler.jsonc."));
+	findings.push(kv ? pass("kv-binding", "the KV binding \"OAUTH_KV\" is there") : fail("kv-binding", "there is no KV binding \"OAUTH_KV\", which the OAuth server needs", "Add { \"binding\": \"OAUTH_KV\" } to kv_namespaces in wrangler.jsonc."));
 	const assets = isRecord(config["assets"]) ? config["assets"] : void 0;
 	const directory = typeof assets?.["directory"] === "string" ? assets["directory"] : void 0;
 	const admin = directory !== void 0 && existsSync(join(cwd, directory, "admin"));
-	findings.push(admin ? pass("the admin is built, in the static assets") : fail("the static assets do not hold the admin", "Install the dependencies; assets.directory of wrangler.jsonc must be \"node_modules/@hollware/admin/dist/client\"."));
+	findings.push(admin ? pass("admin-assets", "the admin is built, in the static assets") : fail("admin-assets", "the static assets do not hold the admin", "Install the dependencies; assets.directory of wrangler.jsonc must be \"node_modules/@hollware/admin/dist/client\"."));
 	return findings;
 }
 /** What the database says: the migrations it lacks and whether it has an owner. */
@@ -69,11 +74,11 @@ async function checkDatabase(io, target) {
 		"DB",
 		`--${target}`
 	]);
-	if (listed.code !== 0) return [fail(`wrangler could not list the migrations of the ${target} database: ${failureReason(listed)}`, target === "remote" ? "Run \"wrangler login\", then \"hollware deploy\"." : "Check wrangler.jsonc.")];
+	if (listed.code !== 0) return [fail("migrations-list", `wrangler could not list the migrations of the ${target} database: ${failureReason(listed)}`, target === "remote" ? "Run \"wrangler login\", then \"hollware deploy\"." : "Check wrangler.jsonc.")];
 	const pending = parsePendingMigrations(listed.stdout);
-	if (pending.length > 0) return [fail(`the ${target} database lacks ${pending.length} ${pending.length === 1 ? "migration" : "migrations"}`, `Run "hollware migrate --${target}".`)];
+	if (pending.length > 0) return [fail("migrations", `the ${target} database lacks ${pending.length} ${pending.length === 1 ? "migration" : "migrations"}`, `Run "hollware migrate --${target}".`)];
 	const [owners = []] = await query(io.wrangler, "DB", target, ownerQuery());
-	return [pass(`the ${target} database has every migration`), owners.length > 0 ? pass(`the ${target} database has an owner`) : fail(`the ${target} database has no owner yet`, `Run "hollware init --site <key> --${target}", with the key your site is to have, such as my-site.`)];
+	return [pass("migrations", `the ${target} database has every migration`), owners.length > 0 ? pass("owner", `the ${target} database has an owner`) : fail("owner", `the ${target} database has no owner yet`, `Run "hollware init --site <key> --${target}", with the key your site is to have, such as my-site.`)];
 }
 async function doctor(argv, io) {
 	const { values } = parseFlags({
@@ -82,6 +87,7 @@ async function doctor(argv, io) {
 		options: {
 			local: { type: "boolean" },
 			remote: { type: "boolean" },
+			json: { type: "boolean" },
 			help: { type: "boolean" }
 		}
 	});
@@ -100,8 +106,20 @@ async function doctor(argv, io) {
 	}
 	if (!isRecord(config)) throw new CliError("wrangler.jsonc holds no object.");
 	const findings = [...checkConfig(io.cwd, config), ...await checkDatabase(io, target)];
-	io.out(findings.map((finding) => finding.ok ? `ok    ${finding.what}` : `FAIL  ${finding.what}\n      ${finding.fix ?? ""}`).join("\n"));
 	const failed = findings.filter((finding) => !finding.ok).length;
+	if (values.json === true) {
+		io.out(JSON.stringify({
+			ok: failed === 0,
+			checks: findings.map((finding) => ({
+				name: finding.name,
+				ok: finding.ok,
+				message: finding.what,
+				fix: finding.fix ?? ""
+			}))
+		}));
+		return failed === 0 ? 0 : 1;
+	}
+	io.out(findings.map((finding) => finding.ok ? `ok    ${finding.what}` : `FAIL  ${finding.what}\n      ${finding.fix ?? ""}`).join("\n"));
 	if (failed === 0) {
 		io.out("Everything Hollware needs is in place.");
 		return 0;

package/dist/errors-DJX_jiSP.mjs

@@ -0,0 +1,18 @@
+//#region src/errors.ts
+/**
+* An error the person at the keyboard can act on. `main` prints its message on stderr, behind
+* the name of the command, and exits with code 1. Anything that is not a `CliError` is a bug or
+* a broken install, and escapes with its stack trace.
+*/
+var CliError = class extends Error {
+	name = "CliError";
+};
+/**
+* A mistake in the arguments: an unknown option, a missing or a malformed value. `main` adds a
+* pointer to the help of the command after the message.
+*/
+var UsageError = class extends CliError {
+	name = "UsageError";
+};
+//#endregion
+export { UsageError as n, CliError as t };

package/dist/{export-DprcsjU_.mjs → export-Ims-m9Rl.mjs}

@@ -1,7 +1,8 @@
-import { i as UsageError, r as CliError, t as printable } from "./format-BpRYEsGB.mjs";
+import { n as UsageError, t as CliError } from "./errors-DJX_jiSP.mjs";
+import { t as printable } from "./format-Dvk_h5ys.mjs";
 import { t as readVersion } from "./version-BMhdZaNo.mjs";
-import { t as parseFlags } from "./args-CljWh-kZ.mjs";
-import { a as redact, c as openSession, i as readToken, o as withoutToken, r as mcpEndpoint, s as ToolFailure } from "./import-D9LRrYtb.mjs";
+import { t as parseFlags } from "./args-D42wi6n2.mjs";
+import { a as redact, c as openSession, i as readToken, o as withoutToken, r as mcpEndpoint, s as ToolFailure } from "./import-CR4G8q5W.mjs";
 import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { describeSite, getEntry, listEntries, schemas } from "@hollware/core";

package/dist/{format-BpRYEsGB.mjs → format-Dvk_h5ys.mjs}

@@ -1,20 +1,3 @@
-//#region src/errors.ts
-/**
-* An error the person at the keyboard can act on. `main` prints its message on stderr, behind
-* the name of the command, and exits with code 1. Anything that is not a `CliError` is a bug or
-* a broken install, and escapes with its stack trace.
-*/
-var CliError = class extends Error {
-	name = "CliError";
-};
-/**
-* A mistake in the arguments: an unknown option, a missing or a malformed value. `main` adds a
-* pointer to the help of the command after the message.
-*/
-var UsageError = class extends CliError {
-	name = "UsageError";
-};
-//#endregion
 //#region src/format.ts
 /**
 * Text for the terminal: a value that came from the database or from a server is made safe to
@@ -35,4 +18,4 @@ function table(header, rows) {
 	}).join("  ")).join("\n");
 }
 //#endregion
-export { UsageError as i, table as n, CliError as r, printable as t };
+export { table as n, printable as t };

package/dist/{import-D9LRrYtb.mjs → import-CR4G8q5W.mjs}

@@ -1,6 +1,7 @@
-import { i as UsageError, r as CliError, t as printable } from "./format-BpRYEsGB.mjs";
+import { n as UsageError, t as CliError } from "./errors-DJX_jiSP.mjs";
+import { t as printable } from "./format-Dvk_h5ys.mjs";
 import { t as readVersion } from "./version-BMhdZaNo.mjs";
-import { t as parseFlags } from "./args-CljWh-kZ.mjs";
+import { t as parseFlags } from "./args-D42wi6n2.mjs";
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { REFUSAL_CONTRACT_IDS, createDraft, getEntry, isPersonalToken, publish, schemas, updateDraft, validate } from "@hollware/core";
@@ -379,7 +380,7 @@ async function importFiles({ io, token, endpoint, directory, corpus, publish: pu
 			return 0;
 		}
 		out(`Validated ${count(checks.length, "file")}: none would be refused.`);
-		const drafts = await writeDrafts(session, corpus.files, out);
+		const drafts = await writeDrafts(session, corpus.files, out, checks);
 		out(`Drafts: ${drafts.created} created, ${drafts.updated} updated, ${drafts.unchanged} unchanged${drafts.failed === 0 ? "" : `, ${drafts.failed} failed`}.`);
 		if (drafts.failed > 0) throw new CliError(`${count(drafts.failed, "file")} could not be imported (see above).${publishToo ? " Nothing was published." : ""} Fix ${drafts.failed === 1 ? "it" : "them"} and run the import again: what is already there stays unchanged.`);
 		if (!publishToo) return 0;
@@ -498,7 +499,7 @@ function violationLine(violation) {
 * does is updated at the version just read, which Hollware answers with `unchanged` when the
 * Markdown is the same. A failure of one file does not stop the others.
 */
-async function writeDrafts(session, files, out) {
+async function writeDrafts(session, files, out, checks = []) {
 	const drafts = {
 		created: 0,
 		updated: 0,
@@ -506,6 +507,7 @@ async function writeDrafts(session, files, out) {
 		failed: 0,
 		entries: []
 	};
+	const fresh = new Map(checks.map((check) => [check.file, check.verdict]));
 	for (const file of files) {
 		const label = printable(file.path.replace(/\.md$/, ""));
 		try {
@@ -545,7 +547,7 @@ async function writeDrafts(session, files, out) {
 					file,
 					summary: entry
 				});
-				out(draftLine(kind, label, entry, updated.verdict));
+				out(draftLine(kind, label, entry, kind === "unchanged" ? fresh.get(file) ?? updated.verdict : updated.verdict));
 				continue;
 			}
 			throw new ToolFailure(`update_draft ${updated.outcome}${refusalReasons(updated.verdict)}`);

package/dist/import-D4_IhUC7.mjs

@@ -0,0 +1 @@
+export { n as importContent } from "./import-CR4G8q5W.mjs";

package/dist/index.d.mts

@@ -1,3 +1,39 @@
+//#region src/dev-host.d.ts
+/** How a child process ended. */
+interface DevExit {
+  readonly code: number | null;
+  readonly signal: string | null;
+}
+/** A process the local server runs in, started as the leader of a group of its own. */
+interface DevChild {
+  readonly pid: number;
+  /** Settles when the process ends. */
+  readonly exited: Promise<DevExit>;
+  /** The last lines it printed (stdout and stderr), for the message of a failure. Empty when detached. */
+  readonly tail: () => string;
+}
+/**
+ * What `hollware dev` takes from the machine, so that a test hands in a fake: processes (each the
+ * leader of its own group, so that the server and what it started stop together), the signals
+ * that stop it, the health check, and time. The entry point of `index.ts` builds the real one.
+ */
+interface DevHost {
+  /** Starts `bin` with `args` in `cwd`. Detached: the process outlives this one, in a group of its own. */
+  spawn: (bin: string, args: readonly string[], cwd: string, options: {
+    detached: boolean;
+  }) => DevChild;
+  /** Sends the signal to the whole group of the process. Never throws when the group is gone. */
+  killGroup: (pid: number, signal: 'SIGTERM' | 'SIGKILL') => void;
+  /** Whether a process with this id exists. */
+  isAlive: (pid: number) => boolean;
+  /** Calls `callback` on SIGINT or SIGTERM, once. Returns a function that stops listening. */
+  onSignal: (callback: () => void) => () => void;
+  /** True when `GET <url>/health` answers 200. Never throws. */
+  healthy: (url: string) => Promise<boolean>;
+  /** Resolves after `ms` milliseconds, or at once when `cancel` aborts (and the timer is cleared). */
+  sleep: (ms: number, cancel?: AbortSignal) => Promise<void>;
+}
+//#endregion
 //#region src/wrangler.d.ts
 /** What a run of wrangler left behind. */
 interface WranglerResult {
@@ -38,6 +74,8 @@ interface Io {
   wrangler: RunWrangler;
   /** A new empty directory for temporary files. Whoever asks for it removes it. */
   tempDir: () => string;
+  /** What `hollware dev` needs of the machine: processes, signals and the health check. */
+  dev?: DevHost;
 }
 //#endregion
 //#region src/index.d.ts