hollware 1.0.0-rc.0 → 1.0.0-rc.2

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-B6dc_ugC.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-C0QYL8dC.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-sYjaZ0d4.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-C0QYL8dC.mjs";
+import { t as parseFlags } from "./args-D42wi6n2.mjs";
+import { f as ownerQuery, i as resolveDatabase, r as query } from "./d1-B6dc_ugC.mjs";
+import { t as publicUrlOf } from "./public-url-d_yOsEMO.mjs";
+import { i as migrate } from "./migrate-Dx-imcel.mjs";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/commands/deploy.ts
@@ -16,13 +16,30 @@ const DEPLOY_USAGE = [
 	"",
 	"HOLLWARE_PUBLIC_URL must be the public URL of the Worker. While it is a localhost URL, the",
 	"workers.dev URL that wrangler prints is written into wrangler.jsonc, and the Worker is deployed",
-	"again with it. Run \"wrangler login\" first.",
+	"again with it. A URL on a domain of your own (not workers.dev) also gets a route in",
+	"wrangler.jsonc that serves the Worker there as a custom domain: Cloudflare makes its DNS record",
+	"and its certificate, in a zone of the same account. Run \"wrangler login\" first.",
 	"",
 	"Options:",
 	"  --url <url>  The public URL of the Worker, such as https://cms.example.com (default: the",
 	"               HOLLWARE_PUBLIC_URL of wrangler.jsonc, or the workers.dev URL)",
 	"  --help       Show this help"
 ].join("\n");
+/** "Run wrangler login" only when wrangler says so: another failure has nothing to do with it. */
+function loginHint(result) {
+	return /not logged in|log ?in|authenticat|oauth|api token/i.test(`${result.stdout}\n${result.stderr}`) ? " Is wrangler logged in (\"wrangler login\")?" : "";
+}
+/**
+* `wrangler types` after deploy rewrote wrangler.jsonc: the types of the Worker hold the value of
+* HOLLWARE_PUBLIC_URL, and `wrangler types --check` fails on the old one. A project without the
+* generated file has nothing to keep current.
+*/
+async function regenerateTypes(io) {
+	if (!existsSync(join(io.cwd, "worker-configuration.d.ts"))) return;
+	const typed = await io.wrangler(["types"]);
+	if (typed.code !== 0) throw new CliError(`wrangler could not write the types of the Worker: ${failureReason(typed)}`);
+	io.out("Wrote worker-configuration.d.ts again, for the new wrangler.jsonc.");
+}
 /** The workers.dev URL that `wrangler deploy` prints, or `undefined`. */
 function workersDevUrlOf(stdout) {
 	const match = /https:\/\/[a-z0-9-]+(?:\.[a-z0-9-]+)*\.workers\.dev(?![\w.-])/i.exec(stripAnsi(stdout));
@@ -33,6 +50,24 @@ function isLoopback(url) {
 	const { hostname } = new URL(url);
 	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
 }
+/** The host of a public URL on a domain of its own: neither this machine nor workers.dev. */
+function customDomainOf(url) {
+	if (isLoopback(url)) return void 0;
+	const { hostname } = new URL(url);
+	return /(?:^|\.)workers\.dev$/i.test(hostname) ? void 0 : hostname;
+}
+const ROUTES_KEY = /^\s*"routes"\s*:/m;
+/** The first key of the starter's wrangler.jsonc, at the top level of the object. */
+const TOP_LEVEL_NAME = /^ {2}"name"\s*:\s*"[^"\n]*",[^\n]*\n/m;
+/**
+* `wrangler.jsonc` with a route that serves the Worker at `host` as a custom domain, after its
+* `name`, and everything else as it was. A config with routes of its own is left as it is.
+*/
+function withCustomDomain(text, host) {
+	if (ROUTES_KEY.test(text)) return text;
+	if (!TOP_LEVEL_NAME.test(text)) throw new CliError(`wrangler.jsonc has no "name" at its top. Add "routes": [{ "pattern": "${host}", "custom_domain": true }] to it.`);
+	return text.replace(TOP_LEVEL_NAME, (line) => `${line}  // The custom domain of the Worker: Cloudflare makes its DNS record and its certificate.\n  "routes": [{ "pattern": ${JSON.stringify(host)}, "custom_domain": true }],\n`);
+}
 const PUBLIC_URL_VALUE = /("HOLLWARE_PUBLIC_URL"\s*:\s*)"[^"\n]*"/;
 /**
 * `wrangler.jsonc` with `HOLLWARE_PUBLIC_URL` set to `url`, and everything else as it was: its
@@ -44,7 +79,7 @@ function withPublicUrl(text, url) {
 }
 async function wranglerDeploy(io) {
 	const deployed = await io.wrangler(["deploy"]);
-	if (deployed.code !== 0) throw new CliError(`wrangler could not deploy: ${failureReason(deployed)}. Is wrangler logged in ("wrangler login")?`);
+	if (deployed.code !== 0) throw new CliError(`wrangler could not deploy: ${failureReason(deployed).replace(/\.$/, "")}.${loginHint(deployed)}`);
 	return deployed.stdout;
 }
 async function deploy(argv, io) {
@@ -65,14 +100,29 @@ async function deploy(argv, io) {
 	const configured = publicUrlOf(io.cwd, void 0);
 	const asked = values.url === void 0 ? void 0 : publicUrlOf(io.cwd, values.url);
 	const database = resolveDatabase(io.cwd, void 0);
+	const known = asked ?? (configured !== void 0 && !isLoopback(configured) ? configured : void 0);
+	const domain = known === void 0 ? void 0 : customDomainOf(known);
+	let written = configured;
+	if (known !== void 0 && domain !== void 0) {
+		const before = readFileSync(file, "utf8");
+		const withUrl = known === configured ? before : withPublicUrl(before, known);
+		const after = withCustomDomain(withUrl, domain);
+		if (after === withUrl && !withUrl.includes(JSON.stringify(domain))) io.out(`wrangler.jsonc has routes of its own and none for ${domain}: add { "pattern": "${domain}", "custom_domain": true } to them.`);
+		if (after !== before) {
+			writeFileSync(file, after);
+			io.out(`Serving the Worker at ${domain}: set HOLLWARE_PUBLIC_URL and its route in wrangler.jsonc.`);
+			await regenerateTypes(io);
+		}
+		written = known;
+	}
 	io.out("Deploying with wrangler ...");
 	const printed = await wranglerDeploy(io);
-	let url = asked ?? (configured !== void 0 && !isLoopback(configured) ? configured : void 0);
-	url ??= workersDevUrlOf(printed);
+	const url = known ?? workersDevUrlOf(printed);
 	if (url === void 0) throw new CliError("wrangler deployed the Worker but printed no workers.dev URL. Run \"hollware deploy --url <the public URL of the Worker>\".");
-	if (url !== configured) {
+	if (url !== written) {
 		writeFileSync(file, withPublicUrl(readFileSync(file, "utf8"), url));
 		io.out(`Set HOLLWARE_PUBLIC_URL to ${url} in wrangler.jsonc. Deploying again with it ...`);
+		await regenerateTypes(io);
 		await wranglerDeploy(io);
 	}
 	await ensureMasterSecret(io);
@@ -88,7 +138,7 @@ async function deploy(argv, io) {
 		`  MCP    ${url}/mcp`,
 		`  Admin  ${url}/admin/`,
 		"",
-		"Commit wrangler.jsonc: it holds the ids of what the deploy created, and the public URL.",
+		"Commit wrangler.jsonc: it holds the public URL, and any id wrangler wrote into it.",
 		...owners.length === 0 ? [
 			"",
 			"Next: create your site and its owner in the remote database. It prints a token for your",

package/dist/dev-B2gk-YHQ.mjs

@@ -0,0 +1,191 @@
+import { n as UsageError, t as CliError } from "./errors-DJX_jiSP.mjs";
+import { r as findBin } from "./wrangler-C0QYL8dC.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.",
+	"Once \"hollware deploy\" has written the public URL into wrangler.jsonc, the local server still",
+	"answers at localhost: the vite.config.ts of the project sets HOLLWARE_PUBLIC_URL to it in",
+	"development, and hollware dev waits for it there.",
+	"",
+	"Options:",
+	"  --url <url>          Where the server listens (default: HOLLWARE_PUBLIC_URL of wrangler.jsonc",
+	"                       when it is a localhost URL, 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 configured = publicUrlOf(io.cwd, void 0);
+	const url = values.url !== void 0 ? publicUrlOf(io.cwd, values.url) ?? DEFAULT_URL : configured !== void 0 && isLoopback(configured) ? configured : DEFAULT_URL;
+	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();
+	}
+}
+/** Whether a URL is this machine's. */
+function isLoopback(url) {
+	const { hostname } = new URL(url);
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+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-DjRkQKrh.mjs

@@ -0,0 +1,135 @@
+import { t as CliError } from "./errors-DJX_jiSP.mjs";
+import { n as failureReason } from "./wrangler-C0QYL8dC.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-B6dc_ugC.mjs";
+import { a as parsePendingMigrations } from "./migrate-Dx-imcel.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] [--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.",
+	"Each problem comes with what to do about it. Exits with code 1 when something is wrong.",
+	"",
+	"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). */
+const REQUIRED_FLAGS = [
+	"no_nodejs_compat",
+	"no_nodejs_compat_v2",
+	"global_fetch_strictly_public"
+];
+const pass = (name, what) => ({
+	name,
+	ok: true,
+	what
+});
+const fail = (name, what, fix) => ({
+	name,
+	ok: false,
+	what,
+	fix
+});
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function records(value) {
+	return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+/** What `wrangler.jsonc` says, checked without reaching Cloudflare or the database. */
+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", `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("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("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("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 media = records(config["r2_buckets"]).some((entry) => entry["binding"] === "MEDIA");
+	findings.push(media ? pass("media-bucket", "the R2 bucket \"MEDIA\" keeps the images of the sites") : fail("media-bucket", "there is no R2 bucket \"MEDIA\", so upload_asset answers unavailable", "Add { \"binding\": \"MEDIA\", \"bucket_name\": \"<name>-media\" } to r2_buckets in wrangler.jsonc; hollware deploy creates the bucket."));
+	const images = isRecord(config["images"]) && config["images"]["binding"] === "IMAGES";
+	findings.push(pass("images-binding", images ? "the Images binding \"IMAGES\" converts each image once, by the media setting of its site" : "there is no Images binding \"IMAGES\": images are kept as they come, unconverted (add \"images\": { \"binding\": \"IMAGES\" } to convert them)"));
+	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("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. */
+async function checkDatabase(io, target) {
+	const listed = await io.wrangler([
+		"d1",
+		"migrations",
+		"list",
+		"DB",
+		`--${target}`
+	]);
+	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("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("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({
+		args: [...argv],
+		allowPositionals: false,
+		options: {
+			local: { type: "boolean" },
+			remote: { type: "boolean" },
+			json: { type: "boolean" },
+			help: { type: "boolean" }
+		}
+	});
+	if (values.help === true) {
+		io.out(DOCTOR_USAGE);
+		return 0;
+	}
+	const target = chooseTarget(values);
+	const file = join(io.cwd, "wrangler.jsonc");
+	if (!existsSync(file)) throw new CliError(`${file} is missing: run hollware doctor in the directory of the project.`);
+	let config;
+	try {
+		config = parseJsonc(readFileSync(file, "utf8"));
+	} catch (error) {
+		throw new CliError(`wrangler.jsonc is not valid JSONC: ${String(error)}`);
+	}
+	if (!isRecord(config)) throw new CliError("wrangler.jsonc holds no object.");
+	const findings = [...checkConfig(io.cwd, config), ...await checkDatabase(io, target)];
+	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;
+	}
+	io.err(`hollware doctor: ${failed} ${failed === 1 ? "problem" : "problems"} to fix.`);
+	return 1;
+}
+//#endregion
+export { doctor };

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 };