@takuhon/cli 0.7.0 → 0.8.1

package/dist/index.js

@@ -1,13 +1,1522 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { readFileSync as readFileSync8, 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/site.ts
+import { resolveLocale } from "@takuhon/core";
+
+// src/build-html.ts
+import { generateJsonLd } from "@takuhon/core";
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeJsonLd(json) {
+  return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+function safeUrl(url) {
+  const trimmed = url.trim();
+  const scheme = /^([a-zA-Z][a-zA-Z0-9+.-]*):/.exec(trimmed)?.[1]?.toLowerCase();
+  if (scheme === void 0) return trimmed;
+  return scheme === "http" || scheme === "https" || scheme === "mailto" ? trimmed : void 0;
+}
+var CSS = `:root{--fg:#1a1a1a;--muted:#666;--accent:#0b5fff;--line:#e5e5e5}
+*{box-sizing:border-box}
+body{margin:0;color:var(--fg);font:16px/1.6 system-ui,-apple-system,"Segoe UI",Roboto,sans-serif;background:#fff}
+main{max-width:42rem;margin:0 auto;padding:2rem 1.25rem}
+a{color:var(--accent)}
+h1{font-size:1.9rem;margin:.2rem 0}
+h2{font-size:1.15rem;margin:2rem 0 .75rem;padding-bottom:.3rem;border-bottom:1px solid var(--line)}
+h3{font-size:1rem;margin:0}
+header .avatar{width:96px;height:96px;border-radius:50%;object-fit:cover}
+.tagline{font-size:1.1rem;color:var(--muted);margin:.2rem 0}
+.location{color:var(--muted);margin:.2rem 0}
+.bio{margin:.75rem 0}
+ul{padding:0;margin:0;list-style:none}
+.entries>li{margin:0 0 1.1rem}
+.sub{margin:.1rem 0;font-weight:600}
+.meta{margin:.1rem 0;color:var(--muted);font-size:.9rem}
+.links{display:flex;flex-wrap:wrap;gap:.5rem 1rem;margin:.75rem 0}
+.skills,.tags{display:flex;flex-wrap:wrap;gap:.4rem}
+.skills>li,.tags>li{background:#f2f2f2;border-radius:1rem;padding:.15rem .6rem;font-size:.85rem}
+.rec{margin:0 0 1.1rem}
+.rec blockquote{margin:0;padding-left:.9rem;border-left:3px solid var(--line)}
+.rec figcaption{color:var(--muted);font-size:.9rem;margin-top:.3rem}
+nav.locales{display:flex;gap:.75rem;margin-bottom:1rem;font-size:.9rem}
+footer.powered{max-width:42rem;margin:0 auto;padding:1.5rem 1.25rem;color:var(--muted);font-size:.85rem}`;
+function dateRange(start, end, isCurrent) {
+  const left = start ?? "";
+  const right = isCurrent === true || end === null ? "Present" : end ?? "";
+  if (left && right) return `${left} \u2013 ${right}`;
+  return left || right;
+}
+function nonEmpty(values, separator) {
+  const joined = values.filter((v) => typeof v === "string" && v.length > 0).join(separator);
+  return joined.length > 0 ? joined : void 0;
+}
+function renderEntry(entry) {
+  const href = entry.url ? safeUrl(entry.url) : void 0;
+  const heading = href ? `<a href="${escapeHtml(href)}">${escapeHtml(entry.heading)}</a>` : escapeHtml(entry.heading);
+  const parts = [`<h3>${heading}</h3>`];
+  if (entry.sub) parts.push(`<p class="sub">${escapeHtml(entry.sub)}</p>`);
+  if (entry.dates) parts.push(`<p class="meta">${escapeHtml(entry.dates)}</p>`);
+  if (entry.body) parts.push(`<p>${escapeHtml(entry.body)}</p>`);
+  if (entry.tags && entry.tags.length > 0) {
+    parts.push(
+      `<ul class="tags">${entry.tags.map((t) => `<li>${escapeHtml(t)}</li>`).join("")}</ul>`
+    );
+  }
+  return `<li>${parts.join("")}</li>`;
+}
+function entryList(title, entries) {
+  if (entries.length === 0) return "";
+  return `<section><h2>${escapeHtml(title)}</h2><ul class="entries">${entries.map(renderEntry).join("")}</ul></section>`;
+}
+function renderHeader(p) {
+  const parts = [];
+  const avatarSrc = p.avatar?.url ? safeUrl(p.avatar.url) : void 0;
+  if (avatarSrc) {
+    parts.push(
+      `<img class="avatar" src="${escapeHtml(avatarSrc)}" alt="${escapeHtml(p.avatar?.alt ?? "")}">`
+    );
+  }
+  parts.push(`<h1>${escapeHtml(p.displayName)}</h1>`);
+  if (p.tagline) parts.push(`<p class="tagline">${escapeHtml(p.tagline)}</p>`);
+  if (p.location?.display) parts.push(`<p class="location">${escapeHtml(p.location.display)}</p>`);
+  if (p.bio) parts.push(`<p class="bio">${escapeHtml(p.bio)}</p>`);
+  return `<header>${parts.join("")}</header>`;
+}
+function renderLinks(links) {
+  if (links.length === 0) return "";
+  const items = links.map((l) => {
+    const text = escapeHtml(l.label ?? l.url);
+    const href = safeUrl(l.url);
+    return href ? `<li><a href="${escapeHtml(href)}">${text}</a></li>` : `<li>${text}</li>`;
+  }).join("");
+  return `<nav aria-label="Links"><ul class="links">${items}</ul></nav>`;
+}
+function renderSkills(skills) {
+  if (skills.length === 0) return "";
+  const items = skills.map((s) => `<li>${escapeHtml(s.label)}</li>`).join("");
+  return `<section><h2>Skills</h2><ul class="skills">${items}</ul></section>`;
+}
+function renderLanguages(languages) {
+  if (languages.length === 0) return "";
+  const items = languages.map((l) => `<li>${escapeHtml(`${l.displayName ?? l.language} \u2014 ${l.proficiency}`)}</li>`).join("");
+  return `<section><h2>Languages</h2><ul class="entries">${items}</ul></section>`;
+}
+function renderRecommendations(recs) {
+  if (recs.length === 0) return "";
+  const items = recs.map((r) => {
+    const authorHref = r.author.url ? safeUrl(r.author.url) : void 0;
+    const name = authorHref ? `<a href="${escapeHtml(authorHref)}">${escapeHtml(r.author.name)}</a>` : escapeHtml(r.author.name);
+    const caption = [name, r.author.headline ? escapeHtml(r.author.headline) : ""].filter(Boolean).join(", ");
+    const rel = r.relationship ? ` (${escapeHtml(r.relationship)})` : "";
+    return `<figure class="rec"><blockquote>${escapeHtml(r.body)}</blockquote><figcaption>\u2014 ${caption}${rel}</figcaption></figure>`;
+  }).join("");
+  return `<section><h2>Recommendations</h2>${items}</section>`;
+}
+function renderContact(contact) {
+  const items = [];
+  if (contact.email) {
+    items.push(
+      `<li><a href="mailto:${escapeHtml(contact.email)}">${escapeHtml(contact.email)}</a></li>`
+    );
+  }
+  const formHref = contact.formUrl ? safeUrl(contact.formUrl) : void 0;
+  if (formHref) {
+    items.push(`<li><a href="${escapeHtml(formHref)}">Contact form</a></li>`);
+  }
+  if (items.length === 0) return "";
+  return `<section><h2>Contact</h2><ul class="entries">${items.join("")}</ul></section>`;
+}
+function renderJsonLdScript(data) {
+  const payload = JSON.stringify(generateJsonLd(data));
+  return `<script type="application/ld+json">${escapeJsonLd(payload)}</script>`;
+}
+function renderLocaleNav(localeNav) {
+  const items = localeNav.map(
+    (l) => l.current ? `<span aria-current="true">${escapeHtml(l.locale)}</span>` : `<a href="${escapeHtml(l.href)}">${escapeHtml(l.locale)}</a>`
+  ).join("");
+  return `<nav class="locales" aria-label="Language">${items}</nav>`;
+}
+function renderProfileHtml(input) {
+  const d = input.localized;
+  const p = d.profile;
+  const description = p.tagline ?? p.bio ?? "";
+  const head = [
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    `<title>${escapeHtml(p.displayName)}</title>`,
+    description ? `<meta name="description" content="${escapeHtml(description.slice(0, 300))}">` : "",
+    input.canonicalUrl ? `<link rel="canonical" href="${escapeHtml(input.canonicalUrl)}">` : "",
+    ...input.alternates.map(
+      (a) => `<link rel="alternate" hreflang="${escapeHtml(a.hreflang)}" href="${escapeHtml(a.href)}">`
+    ),
+    input.jsonLd ? renderJsonLdScript(d) : "",
+    `<style>${CSS}</style>`
+  ].filter(Boolean).join("\n  ");
+  const body = [
+    input.localeNav.length > 1 ? renderLocaleNav(input.localeNav) : "",
+    renderHeader(p),
+    renderLinks(d.links),
+    entryList(
+      "Experience",
+      d.careers.map((c) => ({
+        heading: c.role,
+        sub: c.organization,
+        dates: dateRange(c.startDate, c.endDate, c.isCurrent),
+        body: c.description,
+        url: c.url
+      }))
+    ),
+    entryList(
+      "Projects",
+      d.projects.map((x) => ({
+        heading: x.title,
+        dates: dateRange(x.startDate, x.endDate),
+        body: x.description,
+        url: x.url,
+        tags: x.tags
+      }))
+    ),
+    renderSkills(d.skills),
+    entryList(
+      "Education",
+      d.education.map((e) => {
+        const degree = nonEmpty([e.degree, e.fieldOfStudy], ", ");
+        return {
+          heading: degree ?? e.institution,
+          sub: degree ? e.institution : void 0,
+          dates: dateRange(e.startDate, e.endDate, e.isCurrent),
+          body: e.description,
+          url: e.url
+        };
+      })
+    ),
+    entryList(
+      "Certifications",
+      d.certifications.map((c) => ({
+        heading: c.title,
+        sub: c.issuingOrganization,
+        dates: dateRange(c.issueDate, c.expirationDate),
+        url: c.url
+      }))
+    ),
+    entryList(
+      "Publications",
+      d.publications.map((x) => ({
+        heading: x.title,
+        sub: nonEmpty([x.publisher, x.coAuthors?.join(", ")], " \xB7 "),
+        dates: dateRange(x.date),
+        body: x.description,
+        url: x.url ?? (x.doi ? `https://doi.org/${x.doi}` : void 0)
+      }))
+    ),
+    entryList(
+      "Honors & awards",
+      d.honors.map((x) => ({
+        heading: x.title,
+        sub: x.issuer,
+        dates: dateRange(x.date),
+        body: x.description,
+        url: x.url
+      }))
+    ),
+    entryList(
+      "Memberships",
+      d.memberships.map((x) => ({
+        heading: x.role ?? x.organization,
+        sub: x.role ? x.organization : void 0,
+        dates: dateRange(x.startDate, x.endDate, x.isCurrent),
+        body: x.description,
+        url: x.url
+      }))
+    ),
+    entryList(
+      "Volunteering",
+      d.volunteering.map((x) => ({
+        heading: x.role,
+        sub: nonEmpty([x.organization, x.cause], " \xB7 "),
+        dates: dateRange(x.startDate, x.endDate, x.isCurrent),
+        body: x.description,
+        url: x.url
+      }))
+    ),
+    entryList(
+      "Courses",
+      d.courses.map((x) => ({
+        heading: x.title,
+        sub: x.provider,
+        dates: dateRange(x.completionDate),
+        body: x.description,
+        url: x.certificateUrl
+      }))
+    ),
+    entryList(
+      "Patents",
+      d.patents.map((x) => ({
+        heading: x.title,
+        sub: nonEmpty([x.patentNumber, x.office, x.status, x.coInventors?.join(", ")], " \xB7 "),
+        dates: dateRange(x.filingDate ?? x.grantDate),
+        body: x.description,
+        url: x.url
+      }))
+    ),
+    entryList(
+      "Test scores",
+      d.testScores.map((x) => ({
+        heading: `${x.title}: ${x.score}`,
+        dates: dateRange(x.date),
+        body: x.description,
+        url: x.url
+      }))
+    ),
+    renderLanguages(d.languages),
+    renderRecommendations(d.recommendations),
+    renderContact(d.contact)
+  ].filter(Boolean).join("\n");
+  const footer = d.settings.showPoweredBy === true ? '<footer class="powered">Powered by takuhon</footer>' : "";
+  return `<!DOCTYPE html>
+<html lang="${escapeHtml(d.resolvedLocale)}">
+<head>
+  ${head}
+</head>
+<body>
+<main>
+${body}
+</main>
+${footer ? `${footer}
+` : ""}</body>
+</html>
+`;
+}
+
+// src/site.ts
+function generateSite(profile, options = {}) {
+  const { baseUrl } = options;
+  const defaultLocale = profile.settings.defaultLocale;
+  const locales = [.../* @__PURE__ */ new Set([defaultLocale, ...profile.settings.availableLocales])];
+  const jsonLd = profile.settings.enableJsonLd !== false;
+  return locales.map((locale) => {
+    const localized = resolveLocale(profile, locale);
+    const isDefault = locale === defaultLocale;
+    const localeNav = locales.map((to) => ({
+      locale: to,
+      href: localeHref(locale, to, defaultLocale),
+      current: to === locale
+    }));
+    const canonicalUrl = baseUrl ? absoluteUrl(baseUrl, locale, defaultLocale) : void 0;
+    const alternates = baseUrl ? buildAlternates(baseUrl, locales, defaultLocale) : [];
+    const html = renderProfileHtml({ localized, canonicalUrl, alternates, localeNav, jsonLd });
+    return {
+      route: isDefault ? "/" : `/${locale}/`,
+      file: isDefault ? "index.html" : `${locale}/index.html`,
+      html
+    };
+  });
+}
+function absoluteUrl(baseUrl, locale, defaultLocale) {
+  return locale === defaultLocale ? `${baseUrl}/` : `${baseUrl}/${locale}/`;
+}
+function buildAlternates(baseUrl, locales, defaultLocale) {
+  const alternates = locales.map((locale) => ({
+    hreflang: locale,
+    href: absoluteUrl(baseUrl, locale, defaultLocale)
+  }));
+  alternates.push({
+    hreflang: "x-default",
+    href: absoluteUrl(baseUrl, defaultLocale, defaultLocale)
+  });
+  return alternates;
+}
+function localeHref(from, to, defaultLocale) {
+  const fromRoot = from === defaultLocale;
+  const toRoot = to === defaultLocale;
+  if (fromRoot) return toRoot ? "./" : `${to}/`;
+  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_PORT = 4321;
+var USAGE2 = `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
+is re-read and re-rendered on every request, so edit it and reload the browser
+to see changes. Stop with Ctrl-C.
+
+Options:
+  --port <n>       Port to listen on (default: ${DEFAULT_PORT}).
+  --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). An invalid
+takuhon.json is served as an error page so you can fix it and reload.
+
+Exit codes: 0 = served then stopped, 2 = bad arguments / file missing /
+unreadable / port in use.
+`;
+function loadSiteState(path, baseUrl) {
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch {
+    return { ok: false, status: 500, message: `cannot read '${path}'.` };
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    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);
+  if (!result.ok) {
+    const lines = result.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
+    return {
+      ok: false,
+      status: 500,
+      message: `'${path}' is not a valid takuhon profile:
+${lines.join("\n")}`
+    };
+  }
+  const filtered = applyPublicPrivacyFilter2(normalize2(result.data));
+  const pages = new Map(generateSite(filtered, { baseUrl }).map((p) => [p.route, p.html]));
+  return { ok: true, pages };
+}
+function resolveRoute(urlPath) {
+  let p = urlPath;
+  try {
+    p = decodeURIComponent(urlPath);
+  } catch {
+  }
+  p = p.replace(/\/index\.html$/, "/");
+  if (p === "" || p === "/") return "/";
+  if (!p.startsWith("/")) p = `/${p}`;
+  if (!p.endsWith("/")) p = `${p}/`;
+  return p;
+}
+function contentType(_route) {
+  return "text/html; charset=utf-8";
+}
+function handleRequest(method, urlPath, state) {
+  if (method !== "GET" && method !== "HEAD") {
+    return { status: 405, contentType: "text/plain; charset=utf-8", body: "Method Not Allowed\n" };
+  }
+  if (!state.ok) {
+    return {
+      status: state.status,
+      contentType: contentType("/"),
+      body: renderErrorPage(state.message)
+    };
+  }
+  const route = resolveRoute(urlPath);
+  const html = state.pages.get(route);
+  if (html === void 0) {
+    return {
+      status: 404,
+      contentType: contentType(route),
+      body: renderNotFoundPage(route, [...state.pages.keys()])
+    };
+  }
+  return { status: 200, contentType: contentType(route), body: html };
+}
+function createDevServer(opts) {
+  return createServer((req, res) => {
+    const method = req.method ?? "GET";
+    const state = loadSiteState(opts.path, opts.baseUrl);
+    const response = handleRequest(method, pathnameOf(req.url ?? "/"), state);
+    res.writeHead(response.status, { "Content-Type": response.contentType });
+    if (method === "HEAD") res.end();
+    else res.end(response.body);
+  });
+}
+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);
+    return 0;
+  }
+  const parsed = parseArgs2(args);
+  if ("error" in parsed) {
+    err(`${parsed.error}
+Run \`takuhon dev --help\` for usage.
+`);
+    return 2;
+  }
+  try {
+    readFileSync2(parsed.path, "utf8");
+  } catch {
+    err(
+      `takuhon: cannot read '${parsed.path}'. Pass a path, or run from a directory containing a takuhon.json.
+`
+    );
+    return 2;
+  }
+  const server = createDevServer({ path: parsed.path, baseUrl: parsed.baseUrl });
+  return await new Promise((resolve3) => {
+    let closing = false;
+    const shutdown = () => {
+      if (closing) return;
+      closing = true;
+      process.removeListener("SIGINT", shutdown);
+      process.removeListener("SIGTERM", shutdown);
+      server.close(() => resolve3(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}
+`);
+      }
+      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);
+    });
+  });
+}
+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=")) {
+      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 && !isHttpUrl2(baseUrl)) {
+    return { error: "takuhon: `--base-url` must be an absolute http(s) URL." };
+  }
+  return {
+    path: path ?? DEFAULT_PATH2,
+    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 isHttpUrl2(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/export-command.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve } from "path";
+import { exportTakuhon, validate as validate3 } from "@takuhon/core";
+var DEFAULT_PATH3 = "takuhon.json";
+var USAGE3 = `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
+current working directory.
+
+Options:
+  --output <file>  Write the export to <file> instead of stdout (atomic).
+
+Exit codes: 0 = exported, 1 = source is not a valid profile,
+2 = bad arguments / file missing / unreadable / not JSON / write failed.
+`;
+function runExport(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 export --help\` for usage.
+`
+    };
+  }
+  return exportFile(parsed);
+}
+function parseArgs3(args) {
+  let path;
+  let output;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--embed-assets") {
+      return {
+        error: "takuhon: --embed-assets is not supported yet; assets are remote and asset embedding is deferred."
+      };
+    }
+    if (arg === "--output") {
+      const value = args[i + 1];
+      if (value === void 0 || value === "" || value.startsWith("-")) {
+        return { error: "takuhon: `--output` requires a value." };
+      }
+      output = 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("-")) {
+      return { error: `takuhon: unknown option \`${arg}\` for \`export\`.` };
+    }
+    if (path !== void 0) {
+      return { error: "takuhon: `export` takes at most one path argument." };
+    }
+    path = arg;
+  }
+  return { path: path ?? DEFAULT_PATH3, output };
+}
+function exportFile(parsed) {
+  const { path, output } = parsed;
+  if (output !== void 0 && resolve(output) === resolve(path)) {
+    return {
+      code: 2,
+      stdout: "",
+      stderr: `takuhon: --output '${output}' is the source file; export writes a separate artifact.
+Omit --output to print to stdout, or choose a different file.
+`
+    };
+  }
+  let raw;
+  try {
+    raw = readFileSync3(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 = validate3(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 export:
+${lines.join("\n")}
+`
+    };
+  }
+  const content = `${JSON.stringify(exportTakuhon(data), null, 2)}
+`;
+  if (output === void 0) {
+    return { code: 0, stdout: content, stderr: "" };
+  }
+  try {
+    writeFileAtomic(output, content);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { code: 2, stdout: "", stderr: `takuhon: failed to write '${output}': ${detail}
+` };
+  }
+  return { code: 0, stdout: `exported ${path} -> ${output}
+`, stderr: "" };
+}
+
+// src/import-command.ts
+import { readFileSync as readFileSync4 } from "fs";
+import {
+  ImportError,
+  MigrationError,
+  SCHEMA_VERSION,
+  importTakuhon,
+  migrateTakuhon
+} from "@takuhon/core";
+var DEFAULT_PATH4 = "takuhon.json";
+var USAGE4 = `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
+./takuhon.json in the current working directory.
+
+The current profile (if any) is backed up to
+.takuhon-backups/pre-import-<timestamp>.json before being overwritten.
+
+Exit codes: 0 = imported, 1 = input cannot be imported (invalid / unsupported
+version), 2 = bad arguments / file missing / unreadable / not JSON / write failed.
+`;
+function runImport(args = [], deps = {}) {
+  if (args[0] === "--help" || args[0] === "-h") {
+    return { code: 0, stdout: USAGE4, stderr: "" };
+  }
+  const parsed = parseArgs4(args);
+  if ("error" in parsed) {
+    return {
+      code: 2,
+      stdout: "",
+      stderr: `${parsed.error}
+Run \`takuhon import --help\` for usage.
+`
+    };
+  }
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  return importFile(parsed, now);
+}
+function parseArgs4(args) {
+  const positionals = [];
+  for (const arg of args) {
+    if (arg.startsWith("-")) {
+      return { error: `takuhon: unknown option \`${arg}\` for \`import\`.` };
+    }
+    positionals.push(arg);
+  }
+  if (positionals.length === 0) {
+    return { error: "takuhon: `import` requires an input <file>." };
+  }
+  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 };
+}
+function importFile(parsed, now) {
+  const { file, path } = parsed;
+  let raw;
+  try {
+    raw = readFileSync4(file, "utf8");
+  } catch {
+    return { code: 2, stdout: "", stderr: `takuhon: cannot read '${file}'.
+` };
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { code: 2, stdout: "", stderr: `takuhon: '${file}' is not valid JSON: ${detail}
+` };
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: `takuhon: '${file}' is not a takuhon profile (expected a JSON object).
+`
+    };
+  }
+  const source = data.schemaVersion;
+  if (typeof source !== "string" || source.length === 0) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: `takuhon: '${file}' has no usable schemaVersion; cannot import.
+`
+    };
+  }
+  let candidate = data;
+  if (source !== SCHEMA_VERSION) {
+    try {
+      candidate = migrateTakuhon(data, SCHEMA_VERSION);
+    } catch (error) {
+      if (error instanceof MigrationError) {
+        return {
+          code: 1,
+          stdout: "",
+          stderr: `takuhon: cannot import '${file}': ${error.message}.
+`
+        };
+      }
+      throw error;
+    }
+  }
+  let imported;
+  try {
+    imported = importTakuhon(candidate);
+  } catch (error) {
+    if (error instanceof ImportError) {
+      const lines2 = (error.errors ?? []).map((e) => `  ${e.pointer || "/"}: ${e.message}`);
+      const detail = lines2.length > 0 ? `:
+${lines2.join("\n")}` : ".";
+      return {
+        code: 1,
+        stdout: "",
+        stderr: `takuhon: '${file}' is not a valid takuhon profile; refusing to import${detail}
+`
+      };
+    }
+    throw error;
+  }
+  let currentRaw;
+  try {
+    currentRaw = readFileSync4(path, "utf8");
+  } catch (error) {
+    if (!isNotFound(error)) {
+      return { code: 2, stdout: "", stderr: `takuhon: cannot read current profile '${path}'.
+` };
+    }
+  }
+  let savedPath;
+  if (currentRaw !== void 0) {
+    const stamp = now();
+    try {
+      savedPath = createBackup({
+        targetPath: path,
+        content: currentRaw,
+        name: (withMillis) => preImportName(stamp, withMillis)
+      });
+    } catch (error) {
+      const detail = error instanceof BackupError ? error.message : String(error);
+      return {
+        code: 2,
+        stdout: "",
+        stderr: `takuhon: refusing to import into '${path}' \u2014 pre-import backup failed: ${detail}
+`
+      };
+    }
+  }
+  try {
+    writeFileAtomic(path, `${JSON.stringify(imported, null, 2)}
+`);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { code: 2, stdout: "", stderr: `takuhon: failed to write '${path}': ${detail}
+` };
+  }
+  const lines = [`imported ${file} -> ${path} (schemaVersion ${imported.schemaVersion})`];
+  if (savedPath !== void 0) {
+    lines.push(`  previous profile saved to ${savedPath}`);
+  }
+  return { code: 0, stdout: `${lines.join("\n")}
+`, stderr: "" };
+}
+function isNotFound(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 {
+  MigrationError as MigrationError2,
+  SCHEMA_VERSION as SCHEMA_VERSION2,
+  SUPPORTED_SCHEMA_VERSIONS,
+  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]
+
+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
+./takuhon.json in the current working directory.
+
+Options:
+  --to <version>   Target schema version (default: ${SCHEMA_VERSION2}).
+                   One of: ${SUPPORTED_SCHEMA_VERSIONS.join(", ")}.
+  --out <file>     Write the result to <file> instead of in place. The source
+                   file is left unchanged and no backup is created.
+  --dry-run        Report the planned migration and backup path; write nothing.
+
+Before an in-place write the current file is backed up to .takuhon-backups/
+beside it. Migrations are forward-only; to move to an older schema, restore
+from a backup with \`takuhon restore\`.
+
+Exit codes: 0 = migrated / already current / dry-run, 1 = cannot migrate,
+2 = bad arguments / file missing / unreadable / not JSON.
+`;
+function runMigrate(args = [], deps = {}) {
+  if (args[0] === "--help" || args[0] === "-h") {
+    return { code: 0, stdout: USAGE5, stderr: "" };
+  }
+  const parsed = parseArgs5(args);
+  if ("error" in parsed) {
+    return {
+      code: 2,
+      stdout: "",
+      stderr: `${parsed.error}
+Run \`takuhon migrate --help\` for usage.
+`
+    };
+  }
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  return migrateFile(parsed, now);
+}
+function parseArgs5(args) {
+  let path;
+  let to;
+  let out;
+  let dryRun = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (arg === "--to" || arg === "--out") {
+      const value = args[i + 1];
+      if (value === void 0 || value.startsWith("-")) {
+        return { error: `takuhon: \`${arg}\` requires a value.` };
+      }
+      if (arg === "--to") to = value;
+      else out = value;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--to=")) {
+      to = arg.slice("--to=".length);
+      continue;
+    }
+    if (arg.startsWith("--out=")) {
+      out = arg.slice("--out=".length);
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      return { error: `takuhon: unknown option \`${arg}\` for \`migrate\`.` };
+    }
+    if (path !== void 0) {
+      return { error: "takuhon: `migrate` takes at most one path argument." };
+    }
+    path = arg;
+  }
+  const target = to ?? SCHEMA_VERSION2;
+  if (!SUPPORTED_SCHEMA_VERSIONS.includes(target)) {
+    return {
+      error: `takuhon: unsupported --to version "${target}". Supported: ${SUPPORTED_SCHEMA_VERSIONS.join(", ")}.`
+    };
+  }
+  return { path: path ?? DEFAULT_PATH5, to: target, out, dryRun };
+}
+function migrateFile(parsed, now) {
+  const { path, to: target, out, dryRun } = parsed;
+  let raw;
+  try {
+    raw = readFileSync5(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 source = data.schemaVersion;
+  if (typeof source !== "string" || source.length === 0) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: `takuhon: '${path}' has no usable schemaVersion; cannot determine what to migrate from.
+`
+    };
+  }
+  if (source === target) {
+    return {
+      code: 0,
+      stdout: `${path}: already at schemaVersion ${target}; nothing to do.
+`,
+      stderr: ""
+    };
+  }
+  const writeTarget = out ?? path;
+  const inPlace = resolve2(writeTarget) === resolve2(path);
+  let migrated;
+  try {
+    migrated = migrateTakuhon2(data, target);
+  } catch (error) {
+    if (error instanceof MigrationError2) {
+      return {
+        code: 1,
+        stdout: "",
+        stderr: `takuhon: cannot migrate '${path}': ${error.message}.
+Migrations are forward-only; to move to an older schema, restore from a backup with \`takuhon restore\`.
+`
+      };
+    }
+    throw error;
+  }
+  const revalidated = validate4(migrated);
+  if (!revalidated.ok) {
+    const lines2 = revalidated.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
+    return {
+      code: 1,
+      stdout: "",
+      stderr: `takuhon: migrated '${path}' to ${target} but the result failed validation:
+${lines2.join("\n")}
+`
+    };
+  }
+  const stamp = now();
+  if (dryRun) {
+    const lines2 = [`${path}: would migrate ${source} -> ${target}`, `  write: ${writeTarget}`];
+    if (inPlace) {
+      lines2.push(`  backup: ${backupDirFor(path)}/${migrateBackupName(source, stamp)}`);
+    } else {
+      lines2.push("  (source left unchanged; no backup created)");
+    }
+    return { code: 0, stdout: `${lines2.join("\n")}
+`, stderr: "" };
+  }
+  let backupPath;
+  if (inPlace) {
+    try {
+      backupPath = createBackup({
+        targetPath: path,
+        content: raw,
+        name: (withMillis) => migrateBackupName(source, stamp, withMillis)
+      });
+    } catch (error) {
+      const detail = error instanceof BackupError ? error.message : String(error);
+      return {
+        code: 2,
+        stdout: "",
+        stderr: `takuhon: refusing to migrate '${path}' \u2014 backup failed: ${detail}
+`
+      };
+    }
+  }
+  try {
+    writeFileAtomic(writeTarget, `${JSON.stringify(migrated, null, 2)}
+`);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      code: 2,
+      stdout: "",
+      stderr: `takuhon: failed to write '${writeTarget}': ${detail}
+`
+    };
+  }
+  const lines = [`migrated ${path}: ${source} -> ${target}`];
+  if (inPlace) {
+    lines.push(`  backup: ${backupPath}`);
+  } else {
+    lines.push(`  wrote: ${writeTarget} (source left unchanged; no backup created)`);
+  }
+  return { code: 0, stdout: `${lines.join("\n")}
+`, stderr: "" };
+}
+
+// src/restore-command.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { validate as validate5 } from "@takuhon/core";
+var DEFAULT_PATH6 = "takuhon.json";
+var USAGE6 = `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.
+
+Options:
+  --from <backup>  Backup file to restore from (required).
+  --yes, -y        Skip the confirmation prompt.
+
+The backup is schema-validated first, and the current profile is saved to
+.takuhon-backups/pre-restore-<timestamp>.json before being overwritten.
+
+Exit codes: 0 = restored / aborted, 1 = backup failed validation,
+2 = bad arguments / file missing / unreadable / not JSON / unconfirmed.
+`;
+async function runRestore(args = [], deps = {}) {
+  if (args[0] === "--help" || args[0] === "-h") {
+    return { code: 0, stdout: USAGE6, stderr: "" };
+  }
+  const parsed = parseArgs6(args);
+  if ("error" in parsed) {
+    return {
+      code: 2,
+      stdout: "",
+      stderr: `${parsed.error}
+Run \`takuhon restore --help\` for usage.
+`
+    };
+  }
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  return restoreFile(parsed, now, deps.confirm);
+}
+function parseArgs6(args) {
+  let from;
+  let path;
+  let yes = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--yes" || arg === "-y") {
+      yes = true;
+      continue;
+    }
+    if (arg === "--from") {
+      const value = args[i + 1];
+      if (value === void 0 || value.startsWith("-")) {
+        return { error: "takuhon: `--from` requires a value." };
+      }
+      from = value;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--from=")) {
+      from = arg.slice("--from=".length);
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      return { error: `takuhon: unknown option \`${arg}\` for \`restore\`.` };
+    }
+    if (path !== void 0) {
+      return { error: "takuhon: `restore` takes at most one path argument." };
+    }
+    path = arg;
+  }
+  if (from === void 0 || from.length === 0) {
+    return { error: "takuhon: `restore` requires `--from <backup>`." };
+  }
+  return { from, path: path ?? DEFAULT_PATH6, yes };
+}
+async function restoreFile(parsed, now, confirm) {
+  const { from, path, yes } = parsed;
+  let backupRaw;
+  try {
+    backupRaw = readFileSync6(from, "utf8");
+  } catch {
+    return { code: 2, stdout: "", stderr: `takuhon: cannot read backup '${from}'.
+` };
+  }
+  let backupData;
+  try {
+    backupData = JSON.parse(backupRaw);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return {
+      code: 2,
+      stdout: "",
+      stderr: `takuhon: backup '${from}' is not valid JSON: ${detail}
+`
+    };
+  }
+  const result = validate5(backupData);
+  if (!result.ok) {
+    const lines2 = result.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
+    return {
+      code: 1,
+      stdout: "",
+      stderr: `takuhon: backup '${from}' is not a valid takuhon profile; refusing to restore:
+${lines2.join("\n")}
+`
+    };
+  }
+  let currentRaw;
+  try {
+    currentRaw = readFileSync6(path, "utf8");
+  } catch (error) {
+    if (!isNotFound2(error)) {
+      return { code: 2, stdout: "", stderr: `takuhon: cannot read current profile '${path}'.
+` };
+    }
+  }
+  const stamp = now();
+  const preRestorePath = `${backupDirFor(path)}/${preRestoreName(stamp)}`;
+  if (!yes) {
+    if (!confirm) {
+      return {
+        code: 2,
+        stdout: "",
+        stderr: `takuhon: refusing to overwrite '${path}' without confirmation.
+Re-run interactively, or pass \`--yes\` to skip the prompt.
+`
+      };
+    }
+    const decided = await confirm(
+      confirmationMessage(path, from, result.data, currentRaw, preRestorePath)
+    );
+    if (!decided) {
+      return { code: 0, stdout: "Aborted; no changes made.\n", stderr: "" };
+    }
+  }
+  let savedPath;
+  if (currentRaw !== void 0) {
+    try {
+      savedPath = createBackup({
+        targetPath: path,
+        content: currentRaw,
+        name: (withMillis) => preRestoreName(stamp, withMillis)
+      });
+    } catch (error) {
+      const detail = error instanceof BackupError ? error.message : String(error);
+      return {
+        code: 2,
+        stdout: "",
+        stderr: `takuhon: refusing to restore '${path}' \u2014 pre-restore backup failed: ${detail}
+`
+      };
+    }
+  }
+  try {
+    writeFileAtomic(path, backupRaw);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return { code: 2, stdout: "", stderr: `takuhon: failed to write '${path}': ${detail}
+` };
+  }
+  const lines = [`restored ${path} from ${from}`];
+  if (savedPath !== void 0) {
+    lines.push(`  previous profile saved to ${savedPath}`);
+  }
+  return { code: 0, stdout: `${lines.join("\n")}
+`, stderr: "" };
+}
+function confirmationMessage(path, from, data, currentRaw, preRestorePath) {
+  const when = typeof data.meta.updatedAt === "string" ? ` (from ${data.meta.updatedAt})` : "";
+  const preNote = currentRaw !== void 0 ? `Your current profile will be saved as ${preRestorePath}.` : `(no existing profile at ${path} to preserve)`;
+  return `This will overwrite the profile at ${path} with the backup ${from}${when}.
+${preNote}
+Continue? [y/N]`;
+}
+function isNotFound2(error) {
+  return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
 
 // src/validate-command.ts
-import { readFileSync } from "fs";
-import { validate } from "@takuhon/core";
-var DEFAULT_PATH = "takuhon.json";
-var USAGE = `Usage: takuhon validate [path]
+import { readFileSync as readFileSync7 } from "fs";
+import { validate as validate6 } from "@takuhon/core";
+var DEFAULT_PATH7 = "takuhon.json";
+var USAGE7 = `Usage: takuhon validate [path]
 
 Validate a takuhon.json against the takuhon schema. With no path, validates
 ./takuhon.json in the current working directory.
@@ -16,7 +1525,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: USAGE, stderr: "" };
+    return { code: 0, stdout: USAGE7, stderr: "" };
   }
   if (args.length > 1) {
     return {
@@ -28,10 +1537,10 @@ function runValidate(args = []) {
   return validateFile(args[0]);
 }
 function validateFile(pathArg) {
-  const target = pathArg ?? DEFAULT_PATH;
+  const target = pathArg ?? DEFAULT_PATH7;
   let raw;
   try {
-    raw = readFileSync(target, "utf8");
+    raw = readFileSync7(target, "utf8");
   } catch {
     return {
       code: 2,
@@ -52,7 +1561,7 @@ function validateFile(pathArg) {
 `
     };
   }
-  const result = validate(data);
+  const result = validate6(data);
   if (result.ok) {
     return {
       code: 0,
@@ -73,7 +1582,7 @@ ${lines.join("\n")}
 }
 
 // src/index.ts
-var pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
+var pkg = JSON.parse(readFileSync8(new URL("../package.json", import.meta.url), "utf8"));
 var VERSION = pkg.version;
 var HELP = `takuhon ${VERSION}
 
@@ -84,18 +1593,32 @@ Usage:
   takuhon --help               Show this help
 
 Commands:
-  takuhon validate [path]      Validate a takuhon.json (default: ./takuhon.json)
+  takuhon validate [path]              Validate a takuhon.json (default: ./takuhon.json)
+  takuhon migrate [path] [--to <v>]    Forward-migrate a takuhon.json to a newer schema
+                                       version (default target: latest). Backs up first.
+                                       Add --out <file> to write elsewhere, --dry-run to preview.
+  takuhon restore --from <backup>      Restore a profile from a backup (prompts before
+                                       overwriting; pass --yes to skip).
+  takuhon export [path] [--output <f>] Serialise a takuhon.json to stdout (or --output file).
+  takuhon import <file> [path]         Import an exported profile into a takuhon.json,
+                                       migrating to the current schema version. Backs up first.
+  takuhon build [path] [--output <d>]  Render a takuhon.json into a static site (HTML +
+                                       JSON-LD, one page per locale). --base-url <url> adds
+                                       absolute canonical/hreflang links.
+  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.
 
 Scaffolding a new profile project:
   npx create-takuhon my-profile
   npx create-takuhon my-profile --license CC-BY-4.0
 
-Subcommands (dev / sync / export / migrate / restore) are planned
-for a future release. Track progress at:
+The sync subcommand is planned for a future release.
+Track progress at:
 
   https://github.com/takuhon-dev/takuhon
 `;
-function main(argv) {
+async function main(argv) {
   const first = argv[0];
   if (first === "--version" || first === "-v") {
     process.stdout.write(`${VERSION}
@@ -107,10 +1630,26 @@ function main(argv) {
     return 0;
   }
   if (first === "validate") {
-    const { code, stdout, stderr } = runValidate(argv.slice(1));
-    if (stdout) process.stdout.write(stdout);
-    if (stderr) process.stderr.write(stderr);
-    return code;
+    return emit(runValidate(argv.slice(1)));
+  }
+  if (first === "migrate") {
+    return emit(runMigrate(argv.slice(1)));
+  }
+  if (first === "export") {
+    return emit(runExport(argv.slice(1)));
+  }
+  if (first === "build") {
+    return emit(runBuild(argv.slice(1)));
+  }
+  if (first === "dev") {
+    return runDev(argv.slice(1));
+  }
+  if (first === "import") {
+    return emit(runImport(argv.slice(1)));
+  }
+  if (first === "restore") {
+    const confirm = stdin.isTTY ? promptConfirm : void 0;
+    return emit(await runRestore(argv.slice(1), { confirm }));
   }
   process.stderr.write(
     `takuhon: unknown command '${first}'
@@ -119,5 +1658,42 @@ Run \`takuhon --help\` for usage. For scaffolding a new project, use \`create-ta
   );
   return 2;
 }
-process.exit(main(process.argv.slice(2)));
+function emit(outcome) {
+  if (outcome.stdout) process.stdout.write(outcome.stdout);
+  if (outcome.stderr) process.stderr.write(outcome.stderr);
+  return outcome.code;
+}
+async function promptConfirm(message) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await rl.question(`${message} `);
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+async function run(argv = process.argv.slice(2)) {
+  try {
+    process.exit(await main(argv));
+  } catch (error) {
+    process.stderr.write(`takuhon: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exit(1);
+  }
+}
+function isEntrypoint() {
+  const entry = process.argv[1];
+  if (entry === void 0) return false;
+  try {
+    return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+if (isEntrypoint()) {
+  void run();
+}
+export {
+  run
+};
 //# sourceMappingURL=index.js.map