@takuhon/cli 0.10.0 → 0.11.0

package/dist/index.js

@@ -1,83 +1,31 @@
 #!/usr/bin/env node
+import {
+  resolveAdminBundleDir
+} from "./chunk-JI2AH5Y3.js";
 
 // src/index.ts
-import { readFileSync as readFileSync9, realpathSync } from "fs";
+import { readFileSync as readFileSync11, realpathSync } from "fs";
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
 import { fileURLToPath } from "url";
 
-// src/build-command.ts
-import { mkdirSync as mkdirSync2, readFileSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { applyPublicPrivacyFilter, normalize, validate } from "@takuhon/core";
-
-// src/backup.ts
-import { mkdirSync, renameSync, rmSync, writeFileSync } from "fs";
-import { basename, dirname, join } from "path";
-var BACKUP_DIR_NAME = ".takuhon-backups";
-var BackupError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "BackupError";
-  }
-};
-function compactTimestamp(date, withMillis = false) {
-  const iso = date.toISOString();
-  const trimmed = withMillis ? iso : iso.replace(/\.\d{3}Z$/, "Z");
-  return trimmed.replace(/[-:]/g, "");
-}
-function migrateBackupName(version, date, withMillis = false) {
-  return `takuhon-backup-v${version}-${compactTimestamp(date, withMillis)}.json`;
-}
-function preRestoreName(date, withMillis = false) {
-  return `pre-restore-${compactTimestamp(date, withMillis)}.json`;
-}
-function preImportName(date, withMillis = false) {
-  return `pre-import-${compactTimestamp(date, withMillis)}.json`;
-}
-function backupDirFor(targetPath) {
-  return join(dirname(targetPath), BACKUP_DIR_NAME);
-}
-function createBackup(params) {
-  const dir = backupDirFor(params.targetPath);
-  mkdirSync(dir, { recursive: true });
-  const primary = join(dir, params.name(false));
-  try {
-    writeFileSync(primary, params.content, { flag: "wx" });
-    return primary;
-  } catch (error) {
-    if (!isAlreadyExists(error)) throw error;
-  }
-  const fallback = join(dir, params.name(true));
-  try {
-    writeFileSync(fallback, params.content, { flag: "wx" });
-    return fallback;
-  } catch (error) {
-    if (isAlreadyExists(error)) {
-      throw new BackupError(
-        `backup target already exists and could not be disambiguated: ${fallback}`,
-        { cause: error }
-      );
-    }
-    throw error;
-  }
-}
-function isAlreadyExists(error) {
-  return typeof error === "object" && error !== null && error.code === "EEXIST";
-}
-function writeFileAtomic(target, content) {
-  const tmp = join(dirname(target), `.${basename(target)}.${process.pid}.tmp`);
-  try {
-    writeFileSync(tmp, content, "utf8");
-    renameSync(tmp, target);
-  } catch (error) {
-    rmSync(tmp, { force: true });
-    throw error;
-  }
-}
+// src/admin-command.ts
+import { randomBytes } from "crypto";
+import { readFileSync as readFileSync3 } from "fs";
+import { extname, join as join2, resolve, sep } from "path";
+import { serve } from "@hono/node-server";
+import {
+  adminAssetSecurityHeaders,
+  createAdminApiApp,
+  noopAuditLogger,
+  noopCachePurger
+} from "@takuhon/api";
+import { Hono } from "hono";
 
-// src/site.ts
-import { resolveLocale } from "@takuhon/core";
+// src/dev-command.ts
+import { readFileSync } from "fs";
+import { createServer } from "http";
+import { applyPublicPrivacyFilter, normalize, validate } from "@takuhon/core";
 
 // src/build-html.ts
 import { generateJsonLd } from "@takuhon/core";
@@ -366,6 +314,7 @@ ${footer ? `${footer}
 }
 
 // src/site.ts
+import { resolveLocale } from "@takuhon/core";
 function generateSite(profile, options = {}) {
   const { baseUrl } = options;
   const defaultLocale = profile.settings.defaultLocale;
@@ -410,161 +359,10 @@ function localeHref(from, to, defaultLocale) {
   return toRoot ? "../" : `../${to}/`;
 }
 
-// src/build-command.ts
-var DEFAULT_PATH = "takuhon.json";
-var DEFAULT_OUTPUT = "dist";
-var USAGE = `Usage: takuhon build [path] [--output <dir>] [--base-url <url>]
-
-Render a takuhon.json into a static site (one HTML page per locale, with
-build-time Schema.org JSON-LD). With no path, builds ./takuhon.json.
-
-Options:
-  --output <dir>   Output directory (default: ${DEFAULT_OUTPUT}). The default
-                   locale is written to <dir>/index.html and each other locale
-                   to <dir>/<locale>/index.html.
-  --base-url <url> Site origin (e.g. https://me.example). Enables absolute
-                   canonical and hreflang links; without it those are omitted.
-
-The public privacy filter is applied (meta.privacy is honoured). Asset URLs are
-referenced as-is and are not copied. The output directory is written into, not
-cleaned \u2014 use a dedicated/empty directory so stale pages do not linger.
-
-Exit codes: 0 = built, 1 = source is not a valid profile,
-2 = bad arguments / file missing / unreadable / not JSON / write failed.
-`;
-function runBuild(args = []) {
-  if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE, stderr: "" };
-  }
-  const parsed = parseArgs(args);
-  if ("error" in parsed) {
-    return {
-      code: 2,
-      stdout: "",
-      stderr: `${parsed.error}
-Run \`takuhon build --help\` for usage.
-`
-    };
-  }
-  return buildSite(parsed);
-}
-function parseArgs(args) {
-  let path;
-  let output;
-  let baseUrl;
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--output" || arg === "--base-url") {
-      const value = args[i + 1];
-      if (value === void 0 || value === "" || value.startsWith("-")) {
-        return { error: `takuhon: \`${arg}\` requires a value.` };
-      }
-      if (arg === "--output") output = value;
-      else baseUrl = value;
-      i++;
-      continue;
-    }
-    if (arg.startsWith("--output=")) {
-      const value = arg.slice("--output=".length);
-      if (value === "") return { error: "takuhon: `--output` requires a value." };
-      output = value;
-      continue;
-    }
-    if (arg.startsWith("--base-url=")) {
-      const value = arg.slice("--base-url=".length);
-      if (value === "") return { error: "takuhon: `--base-url` requires a value." };
-      baseUrl = value;
-      continue;
-    }
-    if (arg.startsWith("-")) {
-      return { error: `takuhon: unknown option \`${arg}\` for \`build\`.` };
-    }
-    if (path !== void 0) {
-      return { error: "takuhon: `build` takes at most one path argument." };
-    }
-    path = arg;
-  }
-  if (baseUrl !== void 0 && !isHttpUrl(baseUrl)) {
-    return { error: "takuhon: `--base-url` must be an absolute http(s) URL." };
-  }
-  return {
-    path: path ?? DEFAULT_PATH,
-    output: output ?? DEFAULT_OUTPUT,
-    // Drop any trailing slash so URL joins are predictable.
-    baseUrl: baseUrl?.replace(/\/+$/, "")
-  };
-}
-function isHttpUrl(value) {
-  try {
-    const url = new URL(value);
-    return url.protocol === "http:" || url.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-function buildSite(parsed) {
-  const { path, output, baseUrl } = parsed;
-  let raw;
-  try {
-    raw = readFileSync(path, "utf8");
-  } catch {
-    return {
-      code: 2,
-      stdout: "",
-      stderr: `takuhon: cannot read '${path}'. Pass a path, or run from a directory containing a takuhon.json.
-`
-    };
-  }
-  let data;
-  try {
-    data = JSON.parse(raw);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    return { code: 2, stdout: "", stderr: `takuhon: '${path}' is not valid JSON: ${detail}
-` };
-  }
-  const result = validate(data);
-  if (!result.ok) {
-    const lines = result.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
-    return {
-      code: 1,
-      stdout: "",
-      stderr: `takuhon: '${path}' is not a valid takuhon profile; refusing to build:
-${lines.join("\n")}
-`
-    };
-  }
-  const filtered = applyPublicPrivacyFilter(normalize(result.data));
-  const written = [];
-  try {
-    for (const page of generateSite(filtered, { baseUrl })) {
-      const outFile = join2(output, page.file);
-      mkdirSync2(dirname2(outFile), { recursive: true });
-      writeFileAtomic(outFile, page.html);
-      written.push(outFile);
-    }
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    return { code: 2, stdout: "", stderr: `takuhon: failed to write the site: ${detail}
-` };
-  }
-  const summary = written.map((w) => `  ${w}`).join("\n");
-  return {
-    code: 0,
-    stdout: `built ${written.length} page${written.length === 1 ? "" : "s"} from ${path}:
-${summary}
-`,
-    stderr: ""
-  };
-}
-
 // src/dev-command.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { createServer } from "http";
-import { applyPublicPrivacyFilter as applyPublicPrivacyFilter2, normalize as normalize2, validate as validate2 } from "@takuhon/core";
-var DEFAULT_PATH2 = "takuhon.json";
+var DEFAULT_PATH = "takuhon.json";
 var DEFAULT_PORT = 4321;
-var USAGE2 = `Usage: takuhon dev [path] [--port <n>] [--base-url <url>]
+var USAGE = `Usage: takuhon dev [path] [--port <n>] [--base-url <url>]
 
 Serve a takuhon.json as a local static preview (one page per locale) \u2014 the same
 surface \`takuhon build\` produces. With no path, serves ./takuhon.json. The file
@@ -585,7 +383,7 @@ unreadable / port in use.
 function loadSiteState(path, baseUrl) {
   let raw;
   try {
-    raw = readFileSync2(path, "utf8");
+    raw = readFileSync(path, "utf8");
   } catch {
     return { ok: false, status: 500, message: `cannot read '${path}'.` };
   }
@@ -596,7 +394,7 @@ function loadSiteState(path, baseUrl) {
     const detail = error instanceof Error ? error.message : String(error);
     return { ok: false, status: 500, message: `'${path}' is not valid JSON: ${detail}` };
   }
-  const result = validate2(data);
+  const result = validate(data);
   if (!result.ok) {
     const lines = result.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
     return {
@@ -606,7 +404,7 @@ function loadSiteState(path, baseUrl) {
 ${lines.join("\n")}`
     };
   }
-  const filtered = applyPublicPrivacyFilter2(normalize2(result.data));
+  const filtered = applyPublicPrivacyFilter(normalize(result.data));
   const pages = new Map(generateSite(filtered, { baseUrl }).map((p) => [p.route, p.html]));
   return { ok: true, pages };
 }
@@ -661,10 +459,10 @@ async function runDev(args = [], deps = {}) {
   const out = deps.stdout ?? ((text) => void process.stdout.write(text));
   const err = deps.stderr ?? ((text) => void process.stderr.write(text));
   if (args[0] === "--help" || args[0] === "-h") {
-    out(USAGE2);
+    out(USAGE);
     return 0;
   }
-  const parsed = parseArgs2(args);
+  const parsed = parseArgs(args);
   if ("error" in parsed) {
     err(`${parsed.error}
 Run \`takuhon dev --help\` for usage.
@@ -672,7 +470,7 @@ Run \`takuhon dev --help\` for usage.
     return 2;
   }
   try {
-    readFileSync2(parsed.path, "utf8");
+    readFileSync(parsed.path, "utf8");
   } catch {
     err(
       `takuhon: cannot read '${parsed.path}'. Pass a path, or run from a directory containing a takuhon.json.
@@ -680,18 +478,512 @@ Run \`takuhon dev --help\` for usage.
     );
     return 2;
   }
-  const server = createDevServer({ path: parsed.path, baseUrl: parsed.baseUrl });
-  return await new Promise((resolve3) => {
+  const server = createDevServer({ path: parsed.path, baseUrl: parsed.baseUrl });
+  return await new Promise((resolve4) => {
+    let closing = false;
+    const shutdown = () => {
+      if (closing) return;
+      closing = true;
+      process.removeListener("SIGINT", shutdown);
+      process.removeListener("SIGTERM", shutdown);
+      server.close(() => resolve4(0));
+      server.closeAllConnections();
+    };
+    server.once("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        err(`takuhon: port ${parsed.port} is already in use; pass --port <n> to choose another.
+`);
+      } else {
+        err(`takuhon: ${error.message}
+`);
+      }
+      resolve4(2);
+    });
+    server.listen(parsed.port, "127.0.0.1", () => {
+      out(
+        `takuhon dev: serving ${parsed.path} at http://localhost:${parsed.port}/ (Ctrl-C to stop)
+`
+      );
+      const state = loadSiteState(parsed.path, parsed.baseUrl);
+      if (!state.ok) {
+        err(
+          `takuhon dev: ${parsed.path} is not a valid profile yet; the preview will show the error until it is fixed.
+`
+        );
+      }
+      process.once("SIGINT", shutdown);
+      process.once("SIGTERM", shutdown);
+    });
+  });
+}
+function parseArgs(args) {
+  let path;
+  let portRaw;
+  let baseUrl;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" || arg === "--base-url") {
+      const value = args[i + 1];
+      if (value === void 0 || value === "" || value.startsWith("-")) {
+        return { error: `takuhon: \`${arg}\` requires a value.` };
+      }
+      if (arg === "--port") portRaw = value;
+      else baseUrl = value;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      const value = arg.slice("--port=".length);
+      if (value === "") return { error: "takuhon: `--port` requires a value." };
+      portRaw = value;
+      continue;
+    }
+    if (arg.startsWith("--base-url=")) {
+      const value = arg.slice("--base-url=".length);
+      if (value === "") return { error: "takuhon: `--base-url` requires a value." };
+      baseUrl = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      return { error: `takuhon: unknown option \`${arg}\` for \`dev\`.` };
+    }
+    if (path !== void 0) {
+      return { error: "takuhon: `dev` takes at most one path argument." };
+    }
+    path = arg;
+  }
+  let port = DEFAULT_PORT;
+  if (portRaw !== void 0) {
+    const parsedPort = parsePort(portRaw);
+    if (parsedPort === void 0) {
+      return {
+        error: `takuhon: \`--port\` must be an integer between 1 and 65535 (got \`${portRaw}\`).`
+      };
+    }
+    port = parsedPort;
+  }
+  if (baseUrl !== void 0 && !isHttpUrl(baseUrl)) {
+    return { error: "takuhon: `--base-url` must be an absolute http(s) URL." };
+  }
+  return {
+    path: path ?? DEFAULT_PATH,
+    port,
+    // Drop any trailing slash so URL joins are predictable.
+    baseUrl: baseUrl?.replace(/\/+$/, "")
+  };
+}
+function parsePort(value) {
+  if (!/^\d+$/.test(value)) return void 0;
+  const n = Number(value);
+  return Number.isInteger(n) && n >= 1 && n <= 65535 ? n : void 0;
+}
+function isHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function pathnameOf(url) {
+  try {
+    return new URL(url, "http://localhost").pathname;
+  } catch {
+    return url;
+  }
+}
+function devPage(title, body) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>body{margin:0;font:16px/1.6 system-ui,-apple-system,sans-serif;color:#1a1a1a}main{max-width:42rem;margin:2rem auto;padding:0 1.25rem}pre{background:#f6f6f6;padding:1rem;border-radius:.4rem;overflow:auto;white-space:pre-wrap}code{background:#f2f2f2;padding:.1rem .3rem;border-radius:.2rem}</style>
+</head>
+<body>
+<main>
+${body}
+</main>
+</body>
+</html>
+`;
+}
+function renderErrorPage(message) {
+  return devPage(
+    "takuhon dev \u2014 error",
+    `<h1>takuhon dev</h1>
+<p>The profile could not be rendered:</p>
+<pre>${escapeHtml(message)}</pre>
+<p>Fix the file and reload.</p>`
+  );
+}
+function renderNotFoundPage(route, routes) {
+  const links = routes.map((r) => `<li><a href="${escapeHtml(r)}">${escapeHtml(r)}</a></li>`).join("");
+  return devPage(
+    "takuhon dev \u2014 404",
+    `<h1>404</h1>
+<p>No page for <code>${escapeHtml(route)}</code>.</p>
+<p>Available pages:</p>
+<ul>${links}</ul>`
+  );
+}
+
+// src/file-storage.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
+import { ConflictError, NotFoundError } from "@takuhon/core";
+
+// src/backup.ts
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "fs";
+import { basename, dirname, join } from "path";
+var BACKUP_DIR_NAME = ".takuhon-backups";
+var BackupError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BackupError";
+  }
+};
+function compactTimestamp(date, withMillis = false) {
+  const iso = date.toISOString();
+  const trimmed = withMillis ? iso : iso.replace(/\.\d{3}Z$/, "Z");
+  return trimmed.replace(/[-:]/g, "");
+}
+function migrateBackupName(version, date, withMillis = false) {
+  return `takuhon-backup-v${version}-${compactTimestamp(date, withMillis)}.json`;
+}
+function preRestoreName(date, withMillis = false) {
+  return `pre-restore-${compactTimestamp(date, withMillis)}.json`;
+}
+function preImportName(date, withMillis = false) {
+  return `pre-import-${compactTimestamp(date, withMillis)}.json`;
+}
+function preAdminSaveName(date, withMillis = false) {
+  return `pre-admin-${compactTimestamp(date, withMillis)}.json`;
+}
+function backupDirFor(targetPath) {
+  return join(dirname(targetPath), BACKUP_DIR_NAME);
+}
+function createBackup(params) {
+  const dir = backupDirFor(params.targetPath);
+  mkdirSync(dir, { recursive: true });
+  const primary = join(dir, params.name(false));
+  try {
+    writeFileSync(primary, params.content, { flag: "wx" });
+    return primary;
+  } catch (error) {
+    if (!isAlreadyExists(error)) throw error;
+  }
+  const fallback = join(dir, params.name(true));
+  try {
+    writeFileSync(fallback, params.content, { flag: "wx" });
+    return fallback;
+  } catch (error) {
+    if (isAlreadyExists(error)) {
+      throw new BackupError(
+        `backup target already exists and could not be disambiguated: ${fallback}`,
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+}
+function isAlreadyExists(error) {
+  return typeof error === "object" && error !== null && error.code === "EEXIST";
+}
+function writeFileAtomic(target, content) {
+  const tmp = join(dirname(target), `.${basename(target)}.${process.pid}.tmp`);
+  try {
+    writeFileSync(tmp, content, "utf8");
+    renameSync(tmp, target);
+  } catch (error) {
+    rmSync(tmp, { force: true });
+    throw error;
+  }
+}
+
+// src/file-storage.ts
+function sha256Hex(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function isNotFound(err) {
+  return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
+function readMaybe(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch (err) {
+    if (isNotFound(err)) return void 0;
+    throw err;
+  }
+}
+var FileStorage = class {
+  constructor(path, deps = {}) {
+    this.path = path;
+    this.now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  path;
+  now;
+  // The filesystem work is synchronous, but the TakuhonStorage contract is
+  // async. Each method runs its body inside `Promise.resolve().then(...)` so a
+  // synchronous throw becomes a rejected promise (e.g. NotFoundError →
+  // ConflictError mapping in the admin API) rather than an exception the caller
+  // must catch outside `await`.
+  getProfile() {
+    return Promise.resolve().then(() => {
+      const raw = readMaybe(this.path);
+      if (raw === void 0) {
+        throw new NotFoundError("No profile is stored yet.");
+      }
+      let data;
+      try {
+        data = JSON.parse(raw);
+      } catch (err) {
+        throw new Error("The profile file is not valid JSON.", { cause: err });
+      }
+      return { data, version: sha256Hex(raw) };
+    });
+  }
+  saveProfile(data, ifMatch) {
+    return Promise.resolve().then(() => {
+      const current = readMaybe(this.path);
+      if (ifMatch !== void 0) {
+        const currentVersion = current === void 0 ? void 0 : sha256Hex(current);
+        if (currentVersion !== ifMatch) {
+          throw new ConflictError(
+            `If-Match preconditioned on version "${ifMatch}" but current is "${currentVersion ?? "absent"}".`,
+            { currentVersion }
+          );
+        }
+      }
+      if (current !== void 0) {
+        const stamp = this.now();
+        createBackup({
+          targetPath: this.path,
+          content: current,
+          name: (withMillis) => preAdminSaveName(stamp, withMillis)
+        });
+      }
+      const content = `${JSON.stringify(data, null, 2)}
+`;
+      writeFileAtomic(this.path, content);
+      return { version: sha256Hex(content) };
+    });
+  }
+  deleteProfile() {
+    return Promise.resolve().then(() => {
+      const current = readMaybe(this.path);
+      if (current === void 0) return;
+      const stamp = this.now();
+      createBackup({
+        targetPath: this.path,
+        content: current,
+        name: (withMillis) => preAdminSaveName(stamp, withMillis)
+      });
+      rmSync2(this.path, { force: true });
+    });
+  }
+};
+
+// src/admin-command.ts
+var DEFAULT_PATH2 = "takuhon.json";
+var DEFAULT_PORT2 = 4322;
+var USAGE2 = `Usage: takuhon admin [path] [--port <n>] [--base-url <url>]
+
+Run a local admin server: the form editor at /admin, the admin API at
+/api/admin/*, and a preview at /. With no path, edits ./takuhon.json. A fresh
+admin token is printed each run; paste it into the sign-in form. The server
+binds 127.0.0.1 only. Stop with Ctrl-C.
+
+Options:
+  --port <n>       Port to listen on (default: ${DEFAULT_PORT2}).
+  --base-url <url> Site origin for the preview's canonical / hreflang links.
+
+Exit codes: 0 = served then stopped, 2 = bad arguments / port in use.
+`;
+var CONTENT_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".map": "application/json; charset=utf-8"
+};
+function contentTypeFor(file) {
+  return CONTENT_TYPES[extname(file).toLowerCase()] ?? "application/octet-stream";
+}
+function isNotFound2(err) {
+  return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
+function localAdminHeaders() {
+  const headers = { ...adminAssetSecurityHeaders() };
+  delete headers["strict-transport-security"];
+  const csp = headers["content-security-policy"];
+  if (csp !== void 0) {
+    headers["content-security-policy"] = csp.split(";").map((directive) => directive.trim()).filter((directive) => directive !== "" && directive !== "upgrade-insecure-requests").join("; ");
+  }
+  return headers;
+}
+var plain = (status, body) => new Response(body, { status, headers: { "content-type": "text/plain; charset=utf-8" } });
+function serveAdminBundle(bundleDir, method, pathname) {
+  if (method !== "GET" && method !== "HEAD") return plain(405, "Method Not Allowed\n");
+  const rest = pathname.slice("/admin".length);
+  let rel;
+  try {
+    rel = decodeURIComponent(rest).replace(/^\/+/, "");
+  } catch {
+    rel = "";
+  }
+  if (rel === "") rel = "index.html";
+  const root = resolve(bundleDir);
+  let full = resolve(root, rel);
+  if (full !== root && !full.startsWith(root + sep)) return plain(403, "Forbidden\n");
+  let body;
+  try {
+    body = readFileSync3(full);
+  } catch (err) {
+    if (!isNotFound2(err)) throw err;
+    if (extname(rel) !== "") return plain(404, "Not Found\n");
+    full = join2(root, "index.html");
+    try {
+      body = readFileSync3(full);
+    } catch {
+      return plain(404, "Not Found\n");
+    }
+  }
+  const headers = new Headers(localAdminHeaders());
+  headers.set("content-type", contentTypeFor(full));
+  return new Response(method === "HEAD" ? null : body, { status: 200, headers });
+}
+function createAdminApp(opts) {
+  const bundleDir = opts.bundleDir ?? resolveAdminBundleDir();
+  const storage = new FileStorage(opts.path);
+  const app = new Hono();
+  app.route(
+    "/api/admin",
+    createAdminApiApp({
+      storage,
+      getAdminToken: () => opts.token,
+      // Loopback, same-origin SPA: no Origin allowlist needed (empty = skip).
+      getAdminOrigins: () => [],
+      cachePurger: noopCachePurger,
+      auditLogger: noopAuditLogger
+    })
+  );
+  app.all("*", (c) => {
+    const { method, path } = c.req;
+    if (path === "/admin" || path.startsWith("/admin/")) {
+      return serveAdminBundle(bundleDir, method, path);
+    }
+    const state = loadSiteState(opts.path, opts.baseUrl);
+    const res = handleRequest(method, path, state);
+    return new Response(method === "HEAD" ? null : res.body, {
+      status: res.status,
+      headers: { "content-type": res.contentType }
+    });
+  });
+  return app;
+}
+function parseArgs2(args) {
+  let path;
+  let portRaw;
+  let baseUrl;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" || arg === "--base-url") {
+      const value = args[i + 1];
+      if (value === void 0 || value === "" || value.startsWith("-")) {
+        return { error: `takuhon: \`${arg}\` requires a value.` };
+      }
+      if (arg === "--port") portRaw = value;
+      else baseUrl = value;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      portRaw = arg.slice("--port=".length);
+      if (portRaw === "") return { error: "takuhon: `--port` requires a value." };
+      continue;
+    }
+    if (arg.startsWith("--base-url=")) {
+      baseUrl = arg.slice("--base-url=".length);
+      if (baseUrl === "") return { error: "takuhon: `--base-url` requires a value." };
+      continue;
+    }
+    if (arg.startsWith("-")) return { error: `takuhon: unknown option \`${arg}\` for \`admin\`.` };
+    if (path !== void 0) return { error: "takuhon: `admin` takes at most one path argument." };
+    path = arg;
+  }
+  let port = DEFAULT_PORT2;
+  if (portRaw !== void 0) {
+    if (!/^\d+$/.test(portRaw)) {
+      return {
+        error: `takuhon: \`--port\` must be an integer between 1 and 65535 (got \`${portRaw}\`).`
+      };
+    }
+    const n = Number(portRaw);
+    if (!Number.isInteger(n) || n < 1 || n > 65535) {
+      return {
+        error: `takuhon: \`--port\` must be an integer between 1 and 65535 (got \`${portRaw}\`).`
+      };
+    }
+    port = n;
+  }
+  if (baseUrl !== void 0 && !isHttpUrl2(baseUrl)) {
+    return { error: "takuhon: `--base-url` must be an absolute http(s) URL." };
+  }
+  return { path: path ?? DEFAULT_PATH2, port, baseUrl: baseUrl?.replace(/\/+$/, "") };
+}
+function isHttpUrl2(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+async function runAdmin(args = [], deps = {}) {
+  const out = deps.stdout ?? ((text) => void process.stdout.write(text));
+  const err = deps.stderr ?? ((text) => void process.stderr.write(text));
+  if (args[0] === "--help" || args[0] === "-h") {
+    out(USAGE2);
+    return 0;
+  }
+  const parsed = parseArgs2(args);
+  if ("error" in parsed) {
+    err(`${parsed.error}
+Run \`takuhon admin --help\` for usage.
+`);
+    return 2;
+  }
+  const token = deps.token ?? randomBytes(32).toString("base64url");
+  const app = createAdminApp({ path: parsed.path, token, baseUrl: parsed.baseUrl });
+  return await new Promise((resolvePromise) => {
     let closing = false;
-    const shutdown = () => {
+    function shutdown() {
       if (closing) return;
       closing = true;
       process.removeListener("SIGINT", shutdown);
       process.removeListener("SIGTERM", shutdown);
-      server.close(() => resolve3(0));
-      server.closeAllConnections();
-    };
-    server.once("error", (error) => {
+      server.close(() => resolvePromise(0));
+    }
+    const server = serve({ fetch: app.fetch, hostname: "127.0.0.1", port: parsed.port }, () => {
+      const origin = `http://127.0.0.1:${parsed.port}`;
+      out(`takuhon admin: editing ${parsed.path} at ${origin}/ (Ctrl-C to stop)
+`);
+      out(`  Admin UI:    ${origin}/admin
+`);
+      out(`  Admin token: ${token}
+`);
+      out(`  Paste the token into the sign-in form; it is valid for this run only.
+`);
+      process.once("SIGINT", shutdown);
+      process.once("SIGTERM", shutdown);
+    });
+    server.on("error", (error) => {
       if (error.code === "EADDRINUSE") {
         err(`takuhon: port ${parsed.port} is already in use; pass --port <n> to choose another.
 `);
@@ -699,45 +991,72 @@ Run \`takuhon dev --help\` for usage.
         err(`takuhon: ${error.message}
 `);
       }
-      resolve3(2);
-    });
-    server.listen(parsed.port, "127.0.0.1", () => {
-      out(
-        `takuhon dev: serving ${parsed.path} at http://localhost:${parsed.port}/ (Ctrl-C to stop)
-`
-      );
-      const state = loadSiteState(parsed.path, parsed.baseUrl);
-      if (!state.ok) {
-        err(
-          `takuhon dev: ${parsed.path} is not a valid profile yet; the preview will show the error until it is fixed.
-`
-        );
-      }
-      process.once("SIGINT", shutdown);
-      process.once("SIGTERM", shutdown);
+      resolvePromise(2);
     });
   });
 }
-function parseArgs2(args) {
+
+// src/build-command.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { applyPublicPrivacyFilter as applyPublicPrivacyFilter2, normalize as normalize2, validate as validate2 } from "@takuhon/core";
+var DEFAULT_PATH3 = "takuhon.json";
+var DEFAULT_OUTPUT = "dist";
+var USAGE3 = `Usage: takuhon build [path] [--output <dir>] [--base-url <url>]
+
+Render a takuhon.json into a static site (one HTML page per locale, with
+build-time Schema.org JSON-LD). With no path, builds ./takuhon.json.
+
+Options:
+  --output <dir>   Output directory (default: ${DEFAULT_OUTPUT}). The default
+                   locale is written to <dir>/index.html and each other locale
+                   to <dir>/<locale>/index.html.
+  --base-url <url> Site origin (e.g. https://me.example). Enables absolute
+                   canonical and hreflang links; without it those are omitted.
+
+The public privacy filter is applied (meta.privacy is honoured). Asset URLs are
+referenced as-is and are not copied. The output directory is written into, not
+cleaned \u2014 use a dedicated/empty directory so stale pages do not linger.
+
+Exit codes: 0 = built, 1 = source is not a valid profile,
+2 = bad arguments / file missing / unreadable / not JSON / write failed.
+`;
+function runBuild(args = []) {
+  if (args[0] === "--help" || args[0] === "-h") {
+    return { code: 0, stdout: USAGE3, stderr: "" };
+  }
+  const parsed = parseArgs3(args);
+  if ("error" in parsed) {
+    return {
+      code: 2,
+      stdout: "",
+      stderr: `${parsed.error}
+Run \`takuhon build --help\` for usage.
+`
+    };
+  }
+  return buildSite(parsed);
+}
+function parseArgs3(args) {
   let path;
-  let portRaw;
+  let output;
   let baseUrl;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === "--port" || arg === "--base-url") {
+    if (arg === "--output" || arg === "--base-url") {
       const value = args[i + 1];
       if (value === void 0 || value === "" || value.startsWith("-")) {
         return { error: `takuhon: \`${arg}\` requires a value.` };
       }
-      if (arg === "--port") portRaw = value;
+      if (arg === "--output") output = value;
       else baseUrl = value;
       i++;
       continue;
     }
-    if (arg.startsWith("--port=")) {
-      const value = arg.slice("--port=".length);
-      if (value === "") return { error: "takuhon: `--port` requires a value." };
-      portRaw = value;
+    if (arg.startsWith("--output=")) {
+      const value = arg.slice("--output=".length);
+      if (value === "") return { error: "takuhon: `--output` requires a value." };
+      output = value;
       continue;
     }
     if (arg.startsWith("--base-url=")) {
@@ -747,39 +1066,24 @@ function parseArgs2(args) {
       continue;
     }
     if (arg.startsWith("-")) {
-      return { error: `takuhon: unknown option \`${arg}\` for \`dev\`.` };
+      return { error: `takuhon: unknown option \`${arg}\` for \`build\`.` };
     }
     if (path !== void 0) {
-      return { error: "takuhon: `dev` takes at most one path argument." };
+      return { error: "takuhon: `build` takes at most one path argument." };
     }
     path = arg;
   }
-  let port = DEFAULT_PORT;
-  if (portRaw !== void 0) {
-    const parsedPort = parsePort(portRaw);
-    if (parsedPort === void 0) {
-      return {
-        error: `takuhon: \`--port\` must be an integer between 1 and 65535 (got \`${portRaw}\`).`
-      };
-    }
-    port = parsedPort;
-  }
-  if (baseUrl !== void 0 && !isHttpUrl2(baseUrl)) {
+  if (baseUrl !== void 0 && !isHttpUrl3(baseUrl)) {
     return { error: "takuhon: `--base-url` must be an absolute http(s) URL." };
   }
   return {
-    path: path ?? DEFAULT_PATH2,
-    port,
+    path: path ?? DEFAULT_PATH3,
+    output: output ?? DEFAULT_OUTPUT,
     // Drop any trailing slash so URL joins are predictable.
     baseUrl: baseUrl?.replace(/\/+$/, "")
   };
 }
-function parsePort(value) {
-  if (!/^\d+$/.test(value)) return void 0;
-  const n = Number(value);
-  return Number.isInteger(n) && n >= 1 && n <= 65535 ? n : void 0;
-}
-function isHttpUrl2(value) {
+function isHttpUrl3(value) {
   try {
     const url = new URL(value);
     return url.protocol === "http:" || url.protocol === "https:";
@@ -787,56 +1091,68 @@ function isHttpUrl2(value) {
     return false;
   }
 }
-function pathnameOf(url) {
+function buildSite(parsed) {
+  const { path, output, baseUrl } = parsed;
+  let raw;
   try {
-    return new URL(url, "http://localhost").pathname;
+    raw = readFileSync4(path, "utf8");
   } catch {
-    return url;
+    return {
+      code: 2,
+      stdout: "",
+      stderr: `takuhon: cannot read '${path}'. Pass a path, or run from a directory containing a takuhon.json.
+`
+    };
   }
-}
-function devPage(title, body) {
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>${escapeHtml(title)}</title>
-<style>body{margin:0;font:16px/1.6 system-ui,-apple-system,sans-serif;color:#1a1a1a}main{max-width:42rem;margin:2rem auto;padding:0 1.25rem}pre{background:#f6f6f6;padding:1rem;border-radius:.4rem;overflow:auto;white-space:pre-wrap}code{background:#f2f2f2;padding:.1rem .3rem;border-radius:.2rem}</style>
-</head>
-<body>
-<main>
-${body}
-</main>
-</body>
-</html>
-`;
-}
-function renderErrorPage(message) {
-  return devPage(
-    "takuhon dev \u2014 error",
-    `<h1>takuhon dev</h1>
-<p>The profile could not be rendered:</p>
-<pre>${escapeHtml(message)}</pre>
-<p>Fix the file and reload.</p>`
-  );
-}
-function renderNotFoundPage(route, routes) {
-  const links = routes.map((r) => `<li><a href="${escapeHtml(r)}">${escapeHtml(r)}</a></li>`).join("");
-  return devPage(
-    "takuhon dev \u2014 404",
-    `<h1>404</h1>
-<p>No page for <code>${escapeHtml(route)}</code>.</p>
-<p>Available pages:</p>
-<ul>${links}</ul>`
-  );
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { code: 2, stdout: "", stderr: `takuhon: '${path}' is not valid JSON: ${detail}
+` };
+  }
+  const result = validate2(data);
+  if (!result.ok) {
+    const lines = result.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
+    return {
+      code: 1,
+      stdout: "",
+      stderr: `takuhon: '${path}' is not a valid takuhon profile; refusing to build:
+${lines.join("\n")}
+`
+    };
+  }
+  const filtered = applyPublicPrivacyFilter2(normalize2(result.data));
+  const written = [];
+  try {
+    for (const page of generateSite(filtered, { baseUrl })) {
+      const outFile = join3(output, page.file);
+      mkdirSync2(dirname2(outFile), { recursive: true });
+      writeFileAtomic(outFile, page.html);
+      written.push(outFile);
+    }
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { code: 2, stdout: "", stderr: `takuhon: failed to write the site: ${detail}
+` };
+  }
+  const summary = written.map((w) => `  ${w}`).join("\n");
+  return {
+    code: 0,
+    stdout: `built ${written.length} page${written.length === 1 ? "" : "s"} from ${path}:
+${summary}
+`,
+    stderr: ""
+  };
 }
 
 // src/export-command.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { resolve } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve2 } from "path";
 import { exportTakuhon, validate as validate3 } from "@takuhon/core";
-var DEFAULT_PATH3 = "takuhon.json";
-var USAGE3 = `Usage: takuhon export [path] [--output <file>]
+var DEFAULT_PATH4 = "takuhon.json";
+var USAGE4 = `Usage: takuhon export [path] [--output <file>]
 
 Serialise a takuhon.json into its transport form and print it to stdout, or
 write it to a file with --output. With no path, exports ./takuhon.json in the
@@ -850,9 +1166,9 @@ Exit codes: 0 = exported, 1 = source is not a valid profile,
 `;
 function runExport(args = []) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE3, stderr: "" };
+    return { code: 0, stdout: USAGE4, stderr: "" };
   }
-  const parsed = parseArgs3(args);
+  const parsed = parseArgs4(args);
   if ("error" in parsed) {
     return {
       code: 2,
@@ -864,7 +1180,7 @@ Run \`takuhon export --help\` for usage.
   }
   return exportFile(parsed);
 }
-function parseArgs3(args) {
+function parseArgs4(args) {
   let path;
   let output;
   for (let i = 0; i < args.length; i++) {
@@ -899,11 +1215,11 @@ function parseArgs3(args) {
     }
     path = arg;
   }
-  return { path: path ?? DEFAULT_PATH3, output };
+  return { path: path ?? DEFAULT_PATH4, output };
 }
 function exportFile(parsed) {
   const { path, output } = parsed;
-  if (output !== void 0 && resolve(output) === resolve(path)) {
+  if (output !== void 0 && resolve2(output) === resolve2(path)) {
     return {
       code: 2,
       stdout: "",
@@ -914,7 +1230,7 @@ Omit --output to print to stdout, or choose a different file.
   }
   let raw;
   try {
-    raw = readFileSync3(path, "utf8");
+    raw = readFileSync5(path, "utf8");
   } catch {
     return {
       code: 2,
@@ -959,7 +1275,7 @@ ${lines.join("\n")}
 }
 
 // src/import-command.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import {
   ImportError,
   MigrationError,
@@ -967,8 +1283,8 @@ import {
   importTakuhon,
   migrateTakuhon
 } from "@takuhon/core";
-var DEFAULT_PATH4 = "takuhon.json";
-var USAGE4 = `Usage: takuhon import <file> [path]
+var DEFAULT_PATH5 = "takuhon.json";
+var USAGE5 = `Usage: takuhon import <file> [path]
 
 Load a previously exported profile from <file> into a local takuhon.json,
 migrating it to the current schema version if needed. With no path, writes
@@ -982,9 +1298,9 @@ version), 2 = bad arguments / file missing / unreadable / not JSON / write faile
 `;
 function runImport(args = [], deps = {}) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE4, stderr: "" };
+    return { code: 0, stdout: USAGE5, stderr: "" };
   }
-  const parsed = parseArgs4(args);
+  const parsed = parseArgs5(args);
   if ("error" in parsed) {
     return {
       code: 2,
@@ -997,7 +1313,7 @@ Run \`takuhon import --help\` for usage.
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   return importFile(parsed, now);
 }
-function parseArgs4(args) {
+function parseArgs5(args) {
   const positionals = [];
   for (const arg of args) {
     if (arg.startsWith("-")) {
@@ -1011,13 +1327,13 @@ function parseArgs4(args) {
   if (positionals.length > 2) {
     return { error: "takuhon: `import` takes at most an input <file> and a target path." };
   }
-  return { file: positionals[0], path: positionals[1] ?? DEFAULT_PATH4 };
+  return { file: positionals[0], path: positionals[1] ?? DEFAULT_PATH5 };
 }
 function importFile(parsed, now) {
   const { file, path } = parsed;
   let raw;
   try {
-    raw = readFileSync4(file, "utf8");
+    raw = readFileSync6(file, "utf8");
   } catch {
     return { code: 2, stdout: "", stderr: `takuhon: cannot read '${file}'.
 ` };
@@ -1082,9 +1398,9 @@ ${lines2.join("\n")}` : ".";
   }
   let currentRaw;
   try {
-    currentRaw = readFileSync4(path, "utf8");
+    currentRaw = readFileSync6(path, "utf8");
   } catch (error) {
-    if (!isNotFound(error)) {
+    if (!isNotFound3(error)) {
       return { code: 2, stdout: "", stderr: `takuhon: cannot read current profile '${path}'.
 ` };
     }
@@ -1123,13 +1439,13 @@ ${lines2.join("\n")}` : ".";
   return { code: 0, stdout: `${lines.join("\n")}
 `, stderr: "" };
 }
-function isNotFound(error) {
+function isNotFound3(error) {
   return typeof error === "object" && error !== null && error.code === "ENOENT";
 }
 
 // src/migrate-command.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve3 } from "path";
 import {
   MigrationError as MigrationError2,
   SCHEMA_VERSION as SCHEMA_VERSION2,
@@ -1137,8 +1453,8 @@ import {
   migrateTakuhon as migrateTakuhon2,
   validate as validate4
 } from "@takuhon/core";
-var DEFAULT_PATH5 = "takuhon.json";
-var USAGE5 = `Usage: takuhon migrate [path] [--to <version>] [--out <file>] [--dry-run]
+var DEFAULT_PATH6 = "takuhon.json";
+var USAGE6 = `Usage: takuhon migrate [path] [--to <version>] [--out <file>] [--dry-run]
 
 Forward-migrate a takuhon.json to a newer schema version. The source version
 is read from the file's own schemaVersion. With no path, migrates
@@ -1160,9 +1476,9 @@ Exit codes: 0 = migrated / already current / dry-run, 1 = cannot migrate,
 `;
 function runMigrate(args = [], deps = {}) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE5, stderr: "" };
+    return { code: 0, stdout: USAGE6, stderr: "" };
   }
-  const parsed = parseArgs5(args);
+  const parsed = parseArgs6(args);
   if ("error" in parsed) {
     return {
       code: 2,
@@ -1175,7 +1491,7 @@ Run \`takuhon migrate --help\` for usage.
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   return migrateFile(parsed, now);
 }
-function parseArgs5(args) {
+function parseArgs6(args) {
   let path;
   let to;
   let out;
@@ -1218,13 +1534,13 @@ function parseArgs5(args) {
       error: `takuhon: unsupported --to version "${target}". Supported: ${SUPPORTED_SCHEMA_VERSIONS.join(", ")}.`
     };
   }
-  return { path: path ?? DEFAULT_PATH5, to: target, out, dryRun };
+  return { path: path ?? DEFAULT_PATH6, to: target, out, dryRun };
 }
 function migrateFile(parsed, now) {
   const { path, to: target, out, dryRun } = parsed;
   let raw;
   try {
-    raw = readFileSync5(path, "utf8");
+    raw = readFileSync7(path, "utf8");
   } catch {
     return {
       code: 2,
@@ -1259,7 +1575,7 @@ function migrateFile(parsed, now) {
     };
   }
   const writeTarget = out ?? path;
-  const inPlace = resolve2(writeTarget) === resolve2(path);
+  const inPlace = resolve3(writeTarget) === resolve3(path);
   let migrated;
   try {
     migrated = migrateTakuhon2(data, target);
@@ -1338,10 +1654,10 @@ ${lines2.join("\n")}
 }
 
 // src/restore-command.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { validate as validate5 } from "@takuhon/core";
-var DEFAULT_PATH6 = "takuhon.json";
-var USAGE6 = `Usage: takuhon restore --from <backup> [path] [--yes]
+var DEFAULT_PATH7 = "takuhon.json";
+var USAGE7 = `Usage: takuhon restore --from <backup> [path] [--yes]
 
 Overwrite a profile with a previously saved backup. With no path, restores
 ./takuhon.json in the current working directory.
@@ -1358,9 +1674,9 @@ Exit codes: 0 = restored / aborted, 1 = backup failed validation,
 `;
 async function runRestore(args = [], deps = {}) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE6, stderr: "" };
+    return { code: 0, stdout: USAGE7, stderr: "" };
   }
-  const parsed = parseArgs6(args);
+  const parsed = parseArgs7(args);
   if ("error" in parsed) {
     return {
       code: 2,
@@ -1373,7 +1689,7 @@ Run \`takuhon restore --help\` for usage.
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   return restoreFile(parsed, now, deps.confirm);
 }
-function parseArgs6(args) {
+function parseArgs7(args) {
   let from;
   let path;
   let yes = false;
@@ -1407,13 +1723,13 @@ function parseArgs6(args) {
   if (from === void 0 || from.length === 0) {
     return { error: "takuhon: `restore` requires `--from <backup>`." };
   }
-  return { from, path: path ?? DEFAULT_PATH6, yes };
+  return { from, path: path ?? DEFAULT_PATH7, yes };
 }
 async function restoreFile(parsed, now, confirm) {
   const { from, path, yes } = parsed;
   let backupRaw;
   try {
-    backupRaw = readFileSync6(from, "utf8");
+    backupRaw = readFileSync8(from, "utf8");
   } catch {
     return { code: 2, stdout: "", stderr: `takuhon: cannot read backup '${from}'.
 ` };
@@ -1443,9 +1759,9 @@ ${lines2.join("\n")}
   }
   let currentRaw;
   try {
-    currentRaw = readFileSync6(path, "utf8");
+    currentRaw = readFileSync8(path, "utf8");
   } catch (error) {
-    if (!isNotFound2(error)) {
+    if (!isNotFound4(error)) {
       return { code: 2, stdout: "", stderr: `takuhon: cannot read current profile '${path}'.
 ` };
     }
@@ -1508,17 +1824,17 @@ function confirmationMessage(path, from, data, currentRaw, preRestorePath) {
 ${preNote}
 Continue? [y/N]`;
 }
-function isNotFound2(error) {
+function isNotFound4(error) {
   return typeof error === "object" && error !== null && error.code === "ENOENT";
 }
 
 // src/sync-command.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { validate as validate6 } from "@takuhon/core";
-var DEFAULT_PATH7 = "takuhon.json";
+var DEFAULT_PATH8 = "takuhon.json";
 var ADMIN_PROFILE_PATH = "/api/admin/profile";
 var TOKEN_ENV = "TAKUHON_ADMIN_TOKEN";
-var USAGE7 = `Usage: takuhon sync [path] --url <base-url> [--if-match <etag>] [--dry-run]
+var USAGE8 = `Usage: takuhon sync [path] --url <base-url> [--if-match <etag>] [--dry-run]
 
 Push a local takuhon.json to a deployed takuhon instance by calling its admin
 write endpoint (PUT <base-url>/api/admin/profile). With no path, syncs
@@ -1544,9 +1860,9 @@ unset / auth failure / network error / other non-success response.
 `;
 async function runSync(args = [], deps = {}) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE7, stderr: "" };
+    return { code: 0, stdout: USAGE8, stderr: "" };
   }
-  const parsed = parseArgs7(args);
+  const parsed = parseArgs8(args);
   if ("error" in parsed) {
     return {
       code: 2,
@@ -1558,7 +1874,7 @@ Run \`takuhon sync --help\` for usage.
   }
   return syncProfile(parsed, deps);
 }
-function parseArgs7(args) {
+function parseArgs8(args) {
   let path;
   let url;
   let ifMatch;
@@ -1604,7 +1920,7 @@ function parseArgs7(args) {
   }
   const base = parseOrigin(url);
   if ("error" in base) return base;
-  return { path: path ?? DEFAULT_PATH7, url: base.origin, ifMatch, dryRun };
+  return { path: path ?? DEFAULT_PATH8, url: base.origin, ifMatch, dryRun };
 }
 function parseOrigin(value) {
   let parsed;
@@ -1637,7 +1953,7 @@ async function syncProfile(parsed, deps) {
   const { path, url, ifMatch, dryRun } = parsed;
   let raw;
   try {
-    raw = readFileSync7(path, "utf8");
+    raw = readFileSync9(path, "utf8");
   } catch {
     return { code: 2, stdout: "", stderr: `takuhon: cannot read '${path}'.
 ` };
@@ -1774,10 +2090,10 @@ async function readProblem(res) {
 }
 
 // src/validate-command.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { validate as validate7 } from "@takuhon/core";
-var DEFAULT_PATH8 = "takuhon.json";
-var USAGE8 = `Usage: takuhon validate [path]
+var DEFAULT_PATH9 = "takuhon.json";
+var USAGE9 = `Usage: takuhon validate [path]
 
 Validate a takuhon.json against the takuhon schema. With no path, validates
 ./takuhon.json in the current working directory.
@@ -1786,7 +2102,7 @@ Exit codes: 0 = valid, 1 = invalid, 2 = file missing / unreadable / not JSON.
 `;
 function runValidate(args = []) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE8, stderr: "" };
+    return { code: 0, stdout: USAGE9, stderr: "" };
   }
   if (args.length > 1) {
     return {
@@ -1798,10 +2114,10 @@ function runValidate(args = []) {
   return validateFile(args[0]);
 }
 function validateFile(pathArg) {
-  const target = pathArg ?? DEFAULT_PATH8;
+  const target = pathArg ?? DEFAULT_PATH9;
   let raw;
   try {
-    raw = readFileSync8(target, "utf8");
+    raw = readFileSync10(target, "utf8");
   } catch {
     return {
       code: 2,
@@ -1843,7 +2159,7 @@ ${lines.join("\n")}
 }
 
 // src/index.ts
-var pkg = JSON.parse(readFileSync9(new URL("../package.json", import.meta.url), "utf8"));
+var pkg = JSON.parse(readFileSync11(new URL("../package.json", import.meta.url), "utf8"));
 var VERSION = pkg.version;
 var HELP = `takuhon ${VERSION}
 
@@ -1869,6 +2185,10 @@ Commands:
   takuhon dev [path] [--port <n>]      Serve a takuhon.json as a local static preview,
                                        re-rendered on each request (default port: 4321).
                                        --base-url <url> adds canonical/hreflang links.
+  takuhon admin [path] [--port <n>]    Run a local admin server: edit the profile through
+                                       the form UI at /admin (writes takuhon.json, backs up
+                                       first) with a preview at / (default port: 4322). Binds
+                                       127.0.0.1; prints a per-run token to paste into the form.
   takuhon sync [path] --url <url>      Push a takuhon.json to a deployment's admin API
                                        (PUT <url>/api/admin/profile). Reads the admin token
                                        from TAKUHON_ADMIN_TOKEN. --if-match <etag> opts into
@@ -1904,6 +2224,9 @@ async function main(argv) {
   if (first === "dev") {
     return runDev(argv.slice(1));
   }
+  if (first === "admin") {
+    return runAdmin(argv.slice(1));
+  }
   if (first === "import") {
     return emit(runImport(argv.slice(1)));
   }