@jant/core 0.3.40 → 0.3.43

package/bin/commands/import-site.js

@@ -7,7 +7,7 @@ import {
   stat,
   writeFile,
 } from "node:fs/promises";
-import { resolve, join, relative, extname, dirname, basename } from "node:path";
+import { resolve, join, extname, dirname, basename } from "node:path";
 import { tmpdir } from "node:os";
 import { parseArgs } from "node:util";
 import { typeidUnboxed } from "typeid-js";
@@ -20,37 +20,38 @@ import {
 } from "../lib/site-media-parser.js";
 import { openNodeDatabase } from "../lib/node-database.js";
 import { loadNodeRuntime } from "../lib/load-node-runtime.js";
+import { parseFrontMatter as parseFrontMatterShared } from "../lib/hugo-markdown.js";
 
 /**
  * Parse front matter from a Markdown file.
- * Supports both YAML (---...---) and TOML (+++...+++) delimiters.
- * Returns { frontMatter, body }.
+ * Delegates to the shared hugo-markdown module.
  */
-async function parseFrontMatter(content) {
-  // Try YAML front matter (---...---)
-  const yamlMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (yamlMatch) {
-    const { parse } = await import("yaml");
-    const frontMatter = parse(yamlMatch[1]) || {};
-    return { frontMatter, body: yamlMatch[2] };
-  }
-
-  // Try TOML front matter (+++...+++)
-  const tomlMatch = content.match(/^\+\+\+\n([\s\S]*?)\n\+\+\+\n?([\s\S]*)$/);
-  if (tomlMatch) {
-    const { parse } = await import("smol-toml");
-    const frontMatter = parse(tomlMatch[1]);
-    return { frontMatter, body: tomlMatch[2] };
-  }
-
-  return { frontMatter: {}, body: content };
-}
+const parseFrontMatter = parseFrontMatterShared;
 
 async function parseToml(content) {
   const { parse } = await import("smol-toml");
   return parse(content);
 }
 
+/**
+ * Read custom.css from a Jant Hugo export. Prefers the root
+ * `static/custom.css` (user override) and falls back to
+ * `themes/jant/static/custom.css` (the default location Jant writes).
+ */
+async function readImportCustomCss(rootDir) {
+  const rootCss = await readFile(
+    join(rootDir, "static", "custom.css"),
+    "utf-8",
+  ).catch(() => null);
+  if (rootCss !== null) {
+    return rootCss;
+  }
+  return readFile(
+    join(rootDir, "themes", "jant", "static", "custom.css"),
+    "utf-8",
+  ).catch(() => "");
+}
+
 function resolveImportUrl(url, siteConfig) {
   if (typeof url !== "string" || url.trim() === "" || url.startsWith("data:")) {
     return url;
@@ -216,53 +217,6 @@ async function readMediaSpecAsset(media, field = "src") {
   });
 }
 
-/**
- * Parse reply markers from post body.
- * Returns array of { attrs, body } segments where the first is the root.
- */
-function splitReplies(body) {
-  const markerRegex = /<!-- jant:reply (.*?) -->/g;
-
-  // Split body by markers, keeping the marker data
-  const markers = [];
-  let match;
-  while ((match = markerRegex.exec(body)) !== null) {
-    // Parse key="value" pairs from the marker
-    const attrs = {};
-    const attrRegex = /(\w+)="([^"]*)"/g;
-    let attrMatch;
-    while ((attrMatch = attrRegex.exec(match[1])) !== null) {
-      attrs[attrMatch[1]] = attrMatch[2];
-    }
-    markers.push({
-      index: match.index,
-      endIndex: match.index + match[0].length,
-      attrs,
-    });
-  }
-
-  if (markers.length === 0) {
-    return [{ attrs: null, body: body.trim() }];
-  }
-
-  const segments = [];
-
-  // Root segment: everything before the first marker
-  segments.push({ attrs: null, body: body.slice(0, markers[0].index).trim() });
-
-  // Reply segments: between consecutive markers
-  for (let i = 0; i < markers.length; i++) {
-    const start = markers[i].endIndex;
-    const end = i + 1 < markers.length ? markers[i + 1].index : body.length;
-    segments.push({
-      attrs: markers[i].attrs,
-      body: body.slice(start, end).trim(),
-    });
-  }
-
-  return segments;
-}
-
 function normalizeImportPathKey(value) {
   if (typeof value !== "string") {
     return null;
@@ -284,30 +238,35 @@ function normalizeImportAliasPath(value) {
   return pathKey ? `/${pathKey}` : null;
 }
 
-function collectReplySlugPaths(replySegments) {
-  const replySlugPaths = new Set();
-
-  for (const replySegment of replySegments) {
-    const replySlugPath = normalizeImportAliasPath(replySegment?.attrs?.slug);
-    if (replySlugPath) {
-      replySlugPaths.add(replySlugPath);
-    }
-  }
-
-  return replySlugPaths;
-}
-
-function getExportedRootAliases(frontMatter) {
-  const aliases = frontMatter?.extra?.jant?.root_aliases;
-  return Array.isArray(aliases) ? aliases : [];
-}
-
-function getRootAliasPathsForImport(aliases, postSlug, replySlugPaths) {
+/**
+ * Resolve the historical root slugs that should become custom-URL aliases
+ * pointing at the current root post. Hugo's `aliases:` on a root also
+ * contains every reply slug; we strip those (reply slugs are claimed by
+ * their own bundles) and keep only entries that aren't the root itself.
+ *
+ * `root_aliases:` is the authoritative record of the root's own historical
+ * slugs (the exporter writes it for round-trip), so when present we prefer
+ * it. Otherwise we fall back to `aliases:` minus reply slugs.
+ */
+function getRootAliasPathsForImport(
+  aliases,
+  rootAliases,
+  postSlug,
+  replySlugPaths,
+) {
   const rootSlugPath = normalizeImportAliasPath(postSlug);
   const aliasPaths = [];
   const seen = new Set();
 
-  for (const alias of Array.isArray(aliases) ? aliases : []) {
+  // Prefer the explicit `root_aliases:` list when the exporter wrote it.
+  const source =
+    Array.isArray(rootAliases) && rootAliases.length > 0
+      ? rootAliases
+      : Array.isArray(aliases)
+        ? aliases
+        : [];
+
+  for (const alias of source) {
     const aliasPath = normalizeImportAliasPath(alias);
     if (!aliasPath) {
       continue;
@@ -316,9 +275,9 @@ function getRootAliasPathsForImport(aliases, postSlug, replySlugPaths) {
       continue;
     }
     if (replySlugPaths.has(aliasPath)) {
-      throw new Error(
-        `Exported root alias "${aliasPath}" conflicts with a reply slug`,
-      );
+      // Reply slugs live in their own bundles — never route their URL back
+      // to the root as a custom alias.
+      continue;
     }
     if (seen.has(aliasPath)) {
       continue;
@@ -474,6 +433,85 @@ function normalizeImportedBodySegment(markdown) {
   };
 }
 
+function isAbsoluteUrl(value) {
+  return typeof value === "string" && /^https?:\/\//i.test(value);
+}
+
+/**
+ * Resolve a `media:` entry's `src` or `poster` reference to a local disk
+ * path when the export bundled the bytes under `static/`. Absolute URLs
+ * (remote-linked media) skip the disk lookup — the uploader fetches them
+ * directly.
+ */
+async function resolveJantMediaDiskPath(ref, sourceRootDir) {
+  if (typeof ref !== "string" || !ref.trim()) return null;
+  if (isAbsoluteUrl(ref)) return null;
+  const normalized = ref.startsWith("/") ? ref.slice(1) : ref;
+  const fullPath = join(sourceRootDir, "static", normalized);
+  const fileStat = await stat(fullPath).catch(() => null);
+  return fileStat?.isFile() ? fullPath : null;
+}
+
+/**
+ * Build a media spec for upload from a flat `media:` front-matter entry.
+ *
+ * The entry's `src` is either a site-relative path
+ * (`/media/{id}.webp` — bytes live under `static/` in the exported site)
+ * or an absolute public URL (the exporter linked to an existing
+ * R2/S3/local-proxy host rather than re-bundling the bytes). Poster
+ * frames follow the same rule. The import uploader already knows how
+ * to handle both forms via `readImportAsset`.
+ */
+async function mediaSpecFromJantMedia(entry, sourceRootDir) {
+  if (!entry || typeof entry.src !== "string" || !entry.src.trim()) {
+    return null;
+  }
+
+  const srcFilePath = await resolveJantMediaDiskPath(entry.src, sourceRootDir);
+  if (!srcFilePath && !isAbsoluteUrl(entry.src)) {
+    // Relative src but file not on disk — can't upload.
+    return null;
+  }
+
+  const poster =
+    typeof entry.poster === "string" && entry.poster.trim()
+      ? entry.poster
+      : null;
+  const posterFilePath = poster
+    ? await resolveJantMediaDiskPath(poster, sourceRootDir)
+    : null;
+
+  const originalName =
+    typeof entry.original_name === "string" && entry.original_name.trim()
+      ? entry.original_name
+      : srcFilePath
+        ? basename(srcFilePath)
+        : undefined;
+
+  return {
+    kind: typeof entry.kind === "string" ? entry.kind : undefined,
+    src: entry.src,
+    srcFilePath,
+    poster,
+    posterFilePath,
+    mimeType:
+      typeof entry.mime_type === "string" ? entry.mime_type : undefined,
+    originalName,
+    size: typeof entry.size === "number" ? entry.size : undefined,
+    width: typeof entry.width === "number" ? entry.width : undefined,
+    height: typeof entry.height === "number" ? entry.height : undefined,
+    alt: typeof entry.alt === "string" ? entry.alt : undefined,
+    position:
+      typeof entry.position === "string" ? entry.position : undefined,
+    blurhash:
+      typeof entry.blurhash === "string" ? entry.blurhash : undefined,
+    waveform:
+      typeof entry.waveform === "string" ? entry.waveform : undefined,
+    summary: typeof entry.summary === "string" ? entry.summary : undefined,
+    chars: typeof entry.chars === "number" ? entry.chars : undefined,
+  };
+}
+
 async function normalizeMediaSpec(spec, siteConfig, sourceRootDir) {
   if (!spec || typeof spec.src !== "string" || spec.src.trim() === "") {
     return null;
@@ -488,20 +526,19 @@ async function normalizeMediaSpec(spec, siteConfig, sourceRootDir) {
   return {
     kind: spec.kind,
     src,
-    srcFilePath: await resolveImportLocalAssetPath(
-      spec.src,
-      siteConfig,
-      sourceRootDir,
-    ),
+    srcFilePath:
+      spec.srcFilePath ??
+      (await resolveImportLocalAssetPath(spec.src, siteConfig, sourceRootDir)),
     poster,
     posterFilePath:
-      typeof spec.poster === "string"
+      spec.posterFilePath ??
+      (typeof spec.poster === "string"
         ? await resolveImportLocalAssetPath(
             spec.poster,
             siteConfig,
             sourceRootDir,
           )
-        : null,
+        : null),
     mimeType: spec.mimeType || undefined,
     originalName: spec.originalName || undefined,
     size: typeof spec.size === "number" ? spec.size : undefined,
@@ -516,22 +553,86 @@ async function normalizeMediaSpec(spec, siteConfig, sourceRootDir) {
   };
 }
 
-function normalizeTextAttachmentSpec(spec) {
+/**
+ * Coerce a `<figure data-jant-node="attachment" data-jant-kind="text">` meta
+ * block into the shape `createTextAttachment` wants on import.
+ *
+ * Two source shapes are supported:
+ *
+ * 1. Inline (legacy exports): the meta JSON carries the markdown itself under
+ *    `contentFormat: "markdown"` + `content: "..."`. Used before text
+ *    attachments got their own public URL.
+ * 2. Reference (current exports): the meta JSON only carries `kind: "text"`
+ *    + `src: <url>` pointing at the `.md` artifact. We fetch that URL
+ *    (falling back to `--pull-media` local disk via
+ *    `resolveImportLocalAssetPath`, same as images) and use the bytes as
+ *    the markdown body.
+ *
+ * Returns `null` when the spec isn't a text attachment or we can't get
+ * usable content (unreachable URL, empty body, etc.) — caller drops the
+ * attachment rather than creating an empty one.
+ */
+async function normalizeTextAttachmentSpec(spec, siteConfig, sourceRootDir) {
+  if (!spec || spec.kind !== "text") {
+    return null;
+  }
+
+  const summary =
+    typeof spec.summary === "string" ? spec.summary : undefined;
+
+  // Legacy inline content path — no network fetch needed.
   if (
-    !spec ||
-    spec.kind !== "text" ||
-    spec.contentFormat !== "markdown" ||
-    typeof spec.content !== "string" ||
-    spec.content.trim() === ""
+    spec.contentFormat === "markdown" &&
+    typeof spec.content === "string" &&
+    spec.content.trim() !== ""
   ) {
+    return {
+      type: "text",
+      contentFormat: "markdown",
+      content: spec.content,
+      summary,
+    };
+  }
+
+  // Reference path — fetch the markdown from the stored `src` URL.
+  if (typeof spec.src !== "string" || spec.src.trim() === "") {
+    return null;
+  }
+
+  const sourceUrl = resolveImportUrl(spec.src, siteConfig);
+  if (typeof sourceUrl !== "string" || sourceUrl.trim() === "") {
+    return null;
+  }
+
+  const asset = await readImportAsset({
+    sourceUrl,
+    sourceFilePath: await resolveImportLocalAssetPath(
+      spec.src,
+      siteConfig,
+      sourceRootDir,
+    ),
+  });
+
+  if (!asset) {
+    return null;
+  }
+
+  let markdown;
+  try {
+    markdown = new TextDecoder("utf-8", { fatal: false }).decode(asset.bytes);
+  } catch {
+    return null;
+  }
+
+  if (markdown.trim() === "") {
     return null;
   }
 
   return {
     type: "text",
     contentFormat: "markdown",
-    content: spec.content,
-    summary: typeof spec.summary === "string" ? spec.summary : undefined,
+    content: markdown,
+    summary,
   };
 }
 
@@ -557,7 +658,11 @@ async function buildImportedAttachments(
   let uploaded = 0;
 
   for (const spec of attachmentSpecs) {
-    const textAttachment = normalizeTextAttachmentSpec(spec);
+    const textAttachment = await normalizeTextAttachmentSpec(
+      spec,
+      siteConfig,
+      sourceRootDir,
+    );
     if (textAttachment) {
       attachments.push(textAttachment);
       continue;
@@ -600,7 +705,16 @@ async function uploadMediaList(mediaSpecs, target, siteConfig, sourceRootDir) {
     if (!normalized || normalized.src.startsWith("data:")) continue;
     const result = await target.uploadMedia(normalized);
     if (!result) continue;
-    urlMap.set(normalized.src, result.url);
+    // Key the rewrite map by the *original* URL as it appears in the body
+    // (e.g. `/media/...`). `normalized.src` has been resolved against
+    // `siteConfig.base_url` and becomes absolute, which would never match
+    // `node.url` from the markdown AST during `rewriteMediaReferences`.
+    if (typeof spec.src === "string" && spec.src.trim() !== "") {
+      urlMap.set(spec.src, result.url);
+    }
+    if (normalized.src !== spec.src) {
+      urlMap.set(normalized.src, result.url);
+    }
     mediaIds.push(result.id);
     uploaded += 1;
   }
@@ -608,14 +722,190 @@ async function uploadMediaList(mediaSpecs, target, siteConfig, sourceRootDir) {
   return { urlMap, mediaIds, uploaded };
 }
 
+/**
+ * Upload each media spec referenced by a bundle's front matter. Accepts
+ * both site-relative entries (bytes on disk under `static/`, via
+ * `srcFilePath`) and absolute-URL entries (remote-linked media — the
+ * uploader fetches the URL). Returns a `urlMap` (for rewriting in-body
+ * references) and an ordered `mediaIds` list for post attachment.
+ */
+async function uploadBundleResources(resourceSpecs, target) {
+  const urlMap = new Map();
+  const mediaIds = [];
+  let uploaded = 0;
+
+  for (const spec of resourceSpecs) {
+    if (!spec) continue;
+    if (!spec.srcFilePath && !isAbsoluteUrl(spec.src)) continue;
+    const result = await target.uploadMedia(spec);
+    if (!result) continue;
+    urlMap.set(spec.src, result.url);
+    mediaIds.push(result.id);
+    uploaded += 1;
+  }
+
+  return { urlMap, mediaIds, uploaded };
+}
+
+function coerceBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return normalized === "true" || normalized === "1" || normalized === "yes";
+  }
+  return false;
+}
+
+/**
+ * Build a unified "site config" object from Hugo's split config files.
+ *
+ * Hugo writes two sources of truth:
+ *   - `hugo.toml`: baseURL, title, languageCode, theme params
+ *   - `data/jant.toml`: everything Jant owns — nav items, branding modes,
+ *     home_default_view, site_footer, avatar urls, display preferences,
+ *     and the ordered collections directory under `[[directory]]`.
+ *
+ * This merger normalizes them into a single shape that downstream helpers
+ * (`buildSettingsUpdatesFromConfig`, `normalizeImportedNavItems`,
+ * `normalizeImportedCollectionDirectory`, `buildSiteAvatarImport`) already
+ * know how to read. The shape is intentionally a superset — nothing
+ * depends on `hugo.toml`-only vs `data/jant.toml`-only fields, so extra
+ * keys are harmless if they leak through.
+ */
+async function loadSiteConfig(rootDir) {
+  const hugoTomlText = await readFile(
+    join(rootDir, "hugo.toml"),
+    "utf-8",
+  ).catch(() => null);
+  const jantDataText = await readFile(
+    join(rootDir, "data", "jant.toml"),
+    "utf-8",
+  ).catch(() => null);
+
+  if (!hugoTomlText && !jantDataText) {
+    return null;
+  }
+
+  const hugoToml = hugoTomlText ? await parseToml(hugoTomlText) : {};
+  const jantData = jantDataText ? await parseToml(jantDataText) : {};
+
+  const params = hugoToml.params ?? {};
+
+  const title =
+    (typeof hugoToml.title === "string" && hugoToml.title) ||
+    (typeof jantData.site_name === "string" ? jantData.site_name : "");
+  const description =
+    (typeof params.description === "string" && params.description) ||
+    (typeof jantData.site_description === "string"
+      ? jantData.site_description
+      : "");
+  const baseUrl =
+    typeof hugoToml.baseURL === "string"
+      ? hugoToml.baseURL
+      : typeof hugoToml.baseurl === "string"
+        ? hugoToml.baseurl
+        : "";
+  const language =
+    (typeof hugoToml.languageCode === "string" && hugoToml.languageCode) ||
+    (typeof hugoToml.defaultContentLanguage === "string" &&
+      hugoToml.defaultContentLanguage) ||
+    (typeof jantData.site_language === "string"
+      ? jantData.site_language
+      : "en");
+
+  const directoryItems = Array.isArray(jantData.directory)
+    ? jantData.directory
+    : [];
+  const directoryExported = Array.isArray(jantData.directory);
+
+  return {
+    // Public base URL (used for resolving relative media URLs).
+    base_url: baseUrl,
+    title,
+    description,
+    default_language: language,
+    extra: {
+      jant: {
+        theme_id:
+          (typeof params.theme_id === "string" && params.theme_id) ||
+          (typeof jantData.theme_id === "string" ? jantData.theme_id : ""),
+        default_theme_id:
+          (typeof params.default_theme_id === "string" &&
+            params.default_theme_id) ||
+          (typeof jantData.default_theme_id === "string"
+            ? jantData.default_theme_id
+            : ""),
+        font_theme_id:
+          (typeof params.font_theme_id === "string" && params.font_theme_id) ||
+          (typeof jantData.font_theme_id === "string"
+            ? jantData.font_theme_id
+            : ""),
+        theme_mode:
+          (typeof params.theme_mode === "string" && params.theme_mode) ||
+          (typeof jantData.theme_mode === "string" ? jantData.theme_mode : ""),
+        home_default_view:
+          (typeof params.home_default_view === "string" &&
+            params.home_default_view) ||
+          (typeof jantData.home_default_view === "string"
+            ? jantData.home_default_view
+            : ""),
+        show_jant_branding_on_home: coerceBoolean(
+          params.show_jant_branding_on_home ??
+            jantData.show_jant_branding_on_home,
+        ),
+        show_header_avatar: coerceBoolean(
+          params.show_header_avatar ?? jantData.show_header_avatar,
+        ),
+        noindex: coerceBoolean(params.noindex ?? jantData.noindex),
+        site_footer_markdown:
+          typeof jantData.site_footer_markdown === "string"
+            ? jantData.site_footer_markdown
+            : "",
+        site_avatar_mode:
+          typeof jantData.site_avatar_mode === "string"
+            ? jantData.site_avatar_mode
+            : "none",
+        site_avatar_url:
+          typeof jantData.site_avatar_url === "string"
+            ? jantData.site_avatar_url
+            : typeof params.site_avatar_url === "string"
+              ? params.site_avatar_url
+              : "",
+        favicon_mode:
+          typeof jantData.favicon_mode === "string"
+            ? jantData.favicon_mode
+            : "default",
+        favicon_url:
+          typeof jantData.favicon_path === "string"
+            ? jantData.favicon_path
+            : "/favicon.ico",
+        apple_touch_mode:
+          typeof jantData.apple_touch_mode === "string"
+            ? jantData.apple_touch_mode
+            : "default",
+        apple_touch_icon_url:
+          typeof jantData.apple_touch_icon_path === "string"
+            ? jantData.apple_touch_icon_path
+            : "/apple-touch-icon.png",
+        nav: Array.isArray(jantData.nav) ? jantData.nav : [],
+        nav_exported: Array.isArray(jantData.nav),
+        collections_directory: directoryItems,
+        collections_directory_exported: directoryExported,
+      },
+      jant_export: {
+        format:
+          typeof jantData.format === "string" ? jantData.format : "jant-site",
+      },
+    },
+  };
+}
+
 function buildSettingsUpdatesFromConfig(siteConfig, customCss = "") {
   const jant = siteConfig?.extra?.jant || {};
   const themeId = String(jant.theme_id || "");
   const defaultThemeId = String(jant.default_theme_id || "");
   const fontThemeId = String(jant.font_theme_id || "");
   const themeMode = String(jant.theme_mode || "");
-  const headerNavMaxVisible = Number(jant.header_nav_max_visible);
-
   return {
     SITE_NAME: String(siteConfig?.title || ""),
     SITE_DESCRIPTION: String(siteConfig?.description || ""),
@@ -623,10 +913,6 @@ function buildSettingsUpdatesFromConfig(siteConfig, customCss = "") {
     SITE_FOOTER: String(jant.site_footer_markdown || ""),
     HOME_DEFAULT_VIEW:
       String(jant.home_default_view || "") === "featured" ? "featured" : "",
-    HEADER_NAV_MAX_VISIBLE:
-      Number.isFinite(headerNavMaxVisible) && headerNavMaxVisible !== 2
-        ? String(headerNavMaxVisible)
-        : "",
     SHOW_JANT_BRANDING_ON_HOME: jant.show_jant_branding_on_home ? "true" : "",
     NOINDEX: jant.noindex ? "true" : "",
     SHOW_HEADER_AVATAR: jant.show_header_avatar ? "true" : "",
@@ -637,6 +923,32 @@ function buildSettingsUpdatesFromConfig(siteConfig, customCss = "") {
   };
 }
 
+/**
+ * Internal config keys that the site importer restores via the dedicated
+ * `/api/settings/import` route. Must stay in sync with
+ * `importableInternalSettingKeys` in `src/lib/api-settings.ts`.
+ */
+const IMPORTABLE_INTERNAL_SETTING_KEYS = new Set([
+  "THEME",
+  "FONT_THEME",
+  "THEME_MODE",
+  "CUSTOM_CSS",
+  "SHOW_HEADER_AVATAR",
+]);
+
+function splitSettingsUpdatesForImport(updates) {
+  const editable = {};
+  const internal = {};
+  for (const [key, value] of Object.entries(updates)) {
+    if (IMPORTABLE_INTERNAL_SETTING_KEYS.has(key)) {
+      internal[key] = value;
+    } else {
+      editable[key] = value;
+    }
+  }
+  return { editable, internal };
+}
+
 function normalizeImportedNavItems(siteConfig) {
   const jant = siteConfig?.extra?.jant || {};
   const navItems = jant.nav;
@@ -669,6 +981,58 @@ function normalizeImportedNavItems(siteConfig) {
   };
 }
 
+function normalizeImportedCollectionDirectory(siteConfig) {
+  const jant = siteConfig?.extra?.jant || {};
+  const directoryItems = jant.collections_directory;
+  if (!Array.isArray(directoryItems)) {
+    return {
+      exported: Boolean(jant.collections_directory_exported),
+      items: [],
+    };
+  }
+
+  return {
+    exported: true,
+    items: directoryItems
+      .map((item) => {
+        if (!item || typeof item !== "object") return null;
+
+        if (
+          item.type === "collection" &&
+          typeof item.slug === "string" &&
+          item.slug.trim()
+        ) {
+          return {
+            type: "collection",
+            slug: item.slug.trim(),
+          };
+        }
+
+        if (item.type === "divider") {
+          return {
+            type: "divider",
+            label: typeof item.label === "string" ? item.label : null,
+          };
+        }
+
+        if (
+          item.type === "link" &&
+          typeof item.label === "string" &&
+          typeof item.url === "string"
+        ) {
+          return {
+            type: "link",
+            label: item.label,
+            url: item.url,
+          };
+        }
+
+        return null;
+      })
+      .filter(Boolean),
+  };
+}
+
 async function buildSiteAvatarImport(siteConfig, sourceRootDir) {
   const exportInfo = siteConfig?.extra?.jant_export || {};
   if (exportInfo.format !== "jant-site") {
@@ -744,6 +1108,117 @@ async function buildSiteAvatarImport(siteConfig, sourceRootDir) {
   };
 }
 
+async function reorderCollectionDirectoryItems(target, orderedIds) {
+  const dedupedIds = [];
+  const seenIds = new Set();
+  for (const id of orderedIds) {
+    if (typeof id !== "string" || !id || seenIds.has(id)) continue;
+    seenIds.add(id);
+    dedupedIds.push(id);
+  }
+
+  let moves = 0;
+
+  for (let index = 0; index < dedupedIds.length; index += 1) {
+    const itemId = dedupedIds[index];
+    const currentItems = await target.listCollectionDirectoryItems();
+    const currentIds = currentItems.map((item) => item.id);
+    const currentIndex = currentIds.indexOf(itemId);
+    if (currentIndex === -1) continue;
+
+    if (index === 0) {
+      if (currentIndex === 0) continue;
+      const beforeId = currentIds.find((id) => id !== itemId) ?? null;
+      await target.moveCollectionDirectoryItem(itemId, null, beforeId);
+      moves += 1;
+      continue;
+    }
+
+    const afterId = dedupedIds[index - 1];
+    const afterIndex = currentIds.indexOf(afterId);
+    if (afterIndex === -1) continue;
+    if (currentIds[afterIndex + 1] === itemId) continue;
+
+    const beforeId =
+      currentIds.slice(afterIndex + 1).find((id) => id !== itemId) ?? null;
+    await target.moveCollectionDirectoryItem(itemId, afterId, beforeId);
+    moves += 1;
+  }
+
+  return moves;
+}
+
+async function syncImportedCollectionDirectory(
+  target,
+  importedDirectory,
+  collectionSlugToId,
+) {
+  if (!importedDirectory.exported) {
+    return { created: 0, deleted: 0, moved: 0 };
+  }
+
+  let deleted = 0;
+  const existingItems = await target.listCollectionDirectoryItems();
+  for (const item of existingItems) {
+    if (item.type === "collection") continue;
+    const removed = await target.deleteCollectionDirectoryItem(item.id);
+    if (removed !== false) {
+      deleted += 1;
+    }
+  }
+
+  let currentItems = await target.listCollectionDirectoryItems();
+  const collectionItemIds = new Map(
+    currentItems
+      .filter((item) => item.type === "collection" && item.collectionId)
+      .map((item) => [item.collectionId, item.id]),
+  );
+
+  const desiredIds = [];
+  const seenCollectionIds = new Set();
+  let created = 0;
+
+  for (const item of importedDirectory.items) {
+    if (item.type === "collection") {
+      const collectionId = collectionSlugToId.get(item.slug);
+      if (!collectionId || seenCollectionIds.has(collectionId)) {
+        continue;
+      }
+      seenCollectionIds.add(collectionId);
+      const directoryItemId = collectionItemIds.get(collectionId);
+      if (directoryItemId) {
+        desiredIds.push(directoryItemId);
+      }
+      continue;
+    }
+
+    const createdItem = await target.createCollectionDirectoryItem(
+      item.type === "divider"
+        ? {
+            type: "divider",
+            ...(item.label !== null ? { label: item.label } : {}),
+          }
+        : {
+            type: "link",
+            label: item.label,
+            url: item.url,
+          },
+    );
+    desiredIds.push(createdItem.id);
+    created += 1;
+  }
+
+  currentItems = await target.listCollectionDirectoryItems();
+  const currentIds = currentItems.map((item) => item.id);
+  const desiredIdSet = new Set(desiredIds);
+  const moved = await reorderCollectionDirectoryItems(target, [
+    ...desiredIds,
+    ...currentIds.filter((id) => !desiredIdSet.has(id)),
+  ]);
+
+  return { created, deleted, moved };
+}
+
 function buildIncompleteSetupError(targetLabel) {
   return [
     `${targetLabel} has not completed setup.`,
@@ -859,6 +1334,9 @@ function createRemoteTarget(apiUrl, token) {
     async updateSettings(updates) {
       return apiCall("PUT", "/api/settings", apiUrl, token, updates);
     },
+    async updateImportSettings(updates) {
+      return apiCall("PUT", "/api/settings/import", apiUrl, token, updates);
+    },
     async listNavItems() {
       const result = await apiCall("GET", "/api/nav-items", apiUrl, token);
       return result.navItems || [];
@@ -945,9 +1423,39 @@ function createRemoteTarget(apiUrl, token) {
       const existing = await apiCall("GET", "/api/collections", apiUrl, token);
       return existing.collections || [];
     },
+    async listCollectionDirectoryItems() {
+      const existing = await apiCall("GET", "/api/collections", apiUrl, token);
+      return existing.directoryItems || [];
+    },
     async createCollection(data) {
       return apiCall("POST", "/api/collections", apiUrl, token, data);
     },
+    async createCollectionDirectoryItem(data) {
+      return apiCall(
+        "POST",
+        "/api/collections/directory-items",
+        apiUrl,
+        token,
+        data,
+      );
+    },
+    async moveCollectionDirectoryItem(id, after, before) {
+      return apiCall(
+        "PUT",
+        `/api/collections/directory-items/${id}/move`,
+        apiUrl,
+        token,
+        { after, before },
+      );
+    },
+    async deleteCollectionDirectoryItem(id) {
+      return apiCall(
+        "DELETE",
+        `/api/collections/directory-items/${id}`,
+        apiUrl,
+        token,
+      );
+    },
     async createPost(data) {
       return apiCall(
         "POST",
@@ -1002,6 +1510,10 @@ async function createLocalTarget(env = process.env) {
       await runtime.services.settings.setMany(updates);
       return { settings: updates };
     },
+    async updateImportSettings(updates) {
+      await runtime.services.settings.setMany(updates);
+      return { success: true };
+    },
     async listNavItems() {
       return runtime.services.navItems.list();
     },
@@ -1081,9 +1593,21 @@ async function createLocalTarget(env = process.env) {
     async listCollections() {
       return runtime.services.collections.list();
     },
+    async listCollectionDirectoryItems() {
+      return runtime.services.collections.listDirectoryItems();
+    },
     async createCollection(data) {
       return runtime.services.collections.create(data);
     },
+    async createCollectionDirectoryItem(data) {
+      return runtime.services.collections.createDirectoryItem(data);
+    },
+    async moveCollectionDirectoryItem(id, after, before) {
+      return runtime.services.collections.moveDirectoryItem(id, after, before);
+    },
+    async deleteCollectionDirectoryItem(id) {
+      return runtime.services.collections.deleteDirectoryItem(id);
+    },
     async createPost(data) {
       const { attachments, ...postData } = data;
       return runtime.services.posts.createWithAttachments(
@@ -1181,9 +1705,24 @@ async function createLocalTarget(env = process.env) {
 }
 
 /**
- * Recursively walk a directory's content/ folder and collect post/collection files.
+ * Walk `content/` and classify each `_index.md` / `index.md` bundle by its
+ * front-matter `type`. Returns ordered root-post bundles (with child reply
+ * bundles attached) and stand-alone collection landing pages.
+ *
+ * Algorithm:
+ *   1. Recurse into `content/` collecting every directory that has either
+ *      `_index.md` (branch bundle / section) or `index.md` (leaf bundle).
+ *   2. For each `_index.md`, read front matter. `type: "post"` (or a
+ *      missing `type` with post-shaped keys) → root bundle. `type:
+ *      "collection"` → collection landing page. Other known section types
+ *      (`home`, `featured`, `archive`, `collections`) are recorded and
+ *      skipped for post import.
+ *   3. For each root bundle, enumerate immediate child directories; any
+ *      child dir containing `index.md` becomes a reply leaf bundle.
+ *   4. Reply bundles are sorted by `frontMatter.date` ascending (fallback:
+ *      directory name) so thread order is deterministic.
  */
-async function walkContent(rootDir, postFiles, collectionFiles) {
+async function walkHugoContent(rootDir) {
   const contentDir = join(rootDir, "content");
   const contentStat = await stat(contentDir).catch(() => null);
   if (!contentStat?.isDirectory()) {
@@ -1191,33 +1730,249 @@ async function walkContent(rootDir, postFiles, collectionFiles) {
     process.exit(1);
   }
 
+  // Map of absolute dir → { frontMatter, body, kind, slug, dir, children[] }
+  const dirs = new Map();
+
+  async function readBundle(dir, fileName) {
+    const filePath = join(dir, fileName);
+    const content = await readFile(filePath, "utf-8").catch(() => null);
+    if (content === null) return null;
+    const { frontMatter, body } = await parseFrontMatter(content);
+    return { frontMatter, body };
+  }
+
   async function walk(dir) {
-    const entries = await readdir(dir, { withFileTypes: true });
+    const entries = await readdir(dir, { withFileTypes: true }).catch(
+      () => null,
+    );
+    if (!entries) return;
+
+    const hasIndex = entries.some(
+      (entry) => entry.isFile() && entry.name === "_index.md",
+    );
+    const hasLeaf = entries.some(
+      (entry) => entry.isFile() && entry.name === "index.md",
+    );
+
+    if (hasIndex) {
+      const parsed = await readBundle(dir, "_index.md");
+      if (parsed) {
+        const type =
+          typeof parsed.frontMatter.type === "string"
+            ? parsed.frontMatter.type
+            : null;
+        const slug =
+          typeof parsed.frontMatter.slug === "string"
+            ? parsed.frontMatter.slug
+            : basename(dir);
+        dirs.set(dir, {
+          kind: type || "post",
+          slug,
+          dir,
+          frontMatter: parsed.frontMatter,
+          body: parsed.body,
+          file: "_index.md",
+          children: [],
+        });
+      }
+    } else if (hasLeaf) {
+      const parsed = await readBundle(dir, "index.md");
+      if (parsed) {
+        const slug =
+          typeof parsed.frontMatter.slug === "string"
+            ? parsed.frontMatter.slug
+            : basename(dir);
+        dirs.set(dir, {
+          kind: "leaf",
+          slug,
+          dir,
+          frontMatter: parsed.frontMatter,
+          body: parsed.body,
+          file: "index.md",
+          children: [],
+        });
+      }
+    }
+
     for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
-        await walk(fullPath);
-      } else if (entry.name === "index.md" || entry.name === "_index.md") {
-        const relPath = relative(rootDir, fullPath).replace(/\\/g, "/");
-        const content = await readFile(fullPath, "utf-8");
-        if (
-          (relPath.startsWith("content/jant-collections/") ||
-            relPath.startsWith("content/c/")) &&
-          relPath.endsWith("/_index.md")
-        ) {
-          collectionFiles.push({ path: relPath, content });
-        } else if (
-          relPath.startsWith("content/") &&
-          relPath.endsWith("/index.md") &&
-          relPath !== "content/_index.md"
-        ) {
-          postFiles.push({ path: relPath, content });
-        }
+        await walk(join(dir, entry.name));
       }
     }
   }
 
   await walk(contentDir);
+
+  // Attach leaf children to their parent root bundles.
+  const rootBundles = [];
+  const collectionBundles = [];
+
+  for (const record of dirs.values()) {
+    if (record.kind === "leaf") {
+      const parentDir = dirname(record.dir);
+      const parent = dirs.get(parentDir);
+      if (parent && (parent.kind === "post" || parent.kind === null)) {
+        parent.children.push(record);
+      }
+      continue;
+    }
+    if (record.kind === "collection") {
+      collectionBundles.push(record);
+      continue;
+    }
+    if (record.kind === "post") {
+      rootBundles.push(record);
+      continue;
+    }
+    // home / featured / archive / collections / anything else — skip.
+  }
+
+  // Sort replies within each root by `date` asc (fallback: directory name).
+  for (const root of rootBundles) {
+    root.children.sort((a, b) => {
+      const aDate =
+        typeof a.frontMatter.date === "string"
+          ? Date.parse(a.frontMatter.date)
+          : NaN;
+      const bDate =
+        typeof b.frontMatter.date === "string"
+          ? Date.parse(b.frontMatter.date)
+          : NaN;
+      if (Number.isFinite(aDate) && Number.isFinite(bDate) && aDate !== bDate) {
+        return aDate - bDate;
+      }
+      if (Number.isFinite(aDate) && !Number.isFinite(bDate)) return -1;
+      if (!Number.isFinite(aDate) && Number.isFinite(bDate)) return 1;
+      return basename(a.dir).localeCompare(basename(b.dir));
+    });
+  }
+
+  return { rootBundles, collectionBundles };
+}
+
+/**
+ * Resolve the collection memberships listed in a bundle's top-level
+ * `collections:` front-matter array into `{collectionId, createdAt,
+ * position, pinnedAt}` records the post-create APIs expect.
+ *
+ * Drops entries whose slug doesn't map to a known collection — the
+ * importer prints no warning (collections without slugs are already
+ * filtered by the exporter).
+ */
+function resolveCollectionMemberships(frontMatter, collectionSlugToId) {
+  const collections = Array.isArray(frontMatter.collections)
+    ? frontMatter.collections
+    : [];
+  const entries = [];
+  const ids = [];
+  for (const raw of collections) {
+    if (!raw || typeof raw.slug !== "string") continue;
+    const id = collectionSlugToId.get(raw.slug);
+    if (!id) continue;
+    const entry = { collectionId: id };
+    if (typeof raw.collected_at === "string" && raw.collected_at) {
+      entry.createdAt = Math.floor(
+        new Date(raw.collected_at).getTime() / 1000,
+      );
+    }
+    if (typeof raw.position === "number") {
+      entry.position = raw.position;
+    }
+    if (typeof raw.pinned_at === "string" && raw.pinned_at) {
+      entry.pinnedAt = Math.floor(new Date(raw.pinned_at).getTime() / 1000);
+    }
+    entries.push(entry);
+    ids.push(id);
+  }
+  return { entries, ids };
+}
+
+/**
+ * Build the payload for `target.createPost()` from a parsed bundle. Works
+ * for both root bundles (`forReply: false`) and reply leaf bundles — the
+ * front-matter shape is identical aside from `build:` and the parent link.
+ */
+function buildPostPayloadFromBundle(bundle, options) {
+  const { frontMatter } = bundle;
+  const format =
+    typeof frontMatter.format === "string" ? frontMatter.format : "note";
+  const slug =
+    typeof frontMatter.slug === "string" ? frontMatter.slug : undefined;
+  const status =
+    frontMatter.status === "draft" || frontMatter.status === "published"
+      ? frontMatter.status
+      : frontMatter.draft
+        ? "draft"
+        : "published";
+  // Accept every canonical visibility value (see `VISIBILITIES` in
+  // `src/types/constants.ts`). Anything else — or missing — falls back to
+  // the service default (`public`).
+  const visibility =
+    frontMatter.visibility === "public" ||
+    frontMatter.visibility === "latest_hidden" ||
+    frontMatter.visibility === "private"
+      ? frontMatter.visibility
+      : undefined;
+  const { entries: collectionEntries, ids: collectionIds } = options.memberships;
+
+  const data = {
+    format,
+    title:
+      format === "quote"
+        ? typeof frontMatter.source_name === "string"
+          ? frontMatter.source_name
+          : undefined
+        : typeof frontMatter.title === "string"
+          ? frontMatter.title
+          : undefined,
+    bodyMarkdown: options.bodyMarkdown || undefined,
+    slug,
+    status,
+    visibility,
+    collectionIds:
+      collectionEntries.length === 0 && collectionIds.length > 0
+        ? collectionIds
+        : undefined,
+    collectionEntries:
+      collectionEntries.length > 0 ? collectionEntries : undefined,
+    attachments:
+      options.attachments.length > 0 ? options.attachments : undefined,
+    publishedAt:
+      status === "published" && typeof frontMatter.date === "string"
+        ? Math.floor(new Date(frontMatter.date).getTime() / 1000)
+        : undefined,
+    featuredAt:
+      typeof frontMatter.featured_at === "string" && frontMatter.featured_at
+        ? Math.floor(new Date(frontMatter.featured_at).getTime() / 1000)
+        : undefined,
+    pinnedAt:
+      typeof frontMatter.pinned_at === "string" && frontMatter.pinned_at
+        ? Math.floor(new Date(frontMatter.pinned_at).getTime() / 1000)
+        : undefined,
+    rating:
+      typeof frontMatter.rating === "number" ? frontMatter.rating : undefined,
+  };
+
+  if (options.replyToId) {
+    data.replyToId = options.replyToId;
+  }
+
+  if (format === "link" && typeof frontMatter.link_url === "string") {
+    data.url = frontMatter.link_url;
+  }
+  if (format === "quote") {
+    if (typeof frontMatter.quote_text === "string") {
+      data.quoteText = frontMatter.quote_text;
+    }
+    if (
+      typeof frontMatter.source_url === "string" &&
+      frontMatter.source_url.trim()
+    ) {
+      data.url = frontMatter.source_url;
+    }
+  }
+
+  return data;
 }
 
 export const __test__ = {
@@ -1227,16 +1982,23 @@ export const __test__ = {
   normalizeTextAttachmentSpec,
   extractAttachmentBlocks,
   buildImportedAttachments,
+  uploadMediaList,
   buildSettingsUpdatesFromConfig,
   normalizeImportedNavItems,
+  normalizeImportedCollectionDirectory,
   buildSiteAvatarImport,
-  collectReplySlugPaths,
-  getExportedRootAliases,
+  reorderCollectionDirectoryItems,
+  syncImportedCollectionDirectory,
   getRootAliasPathsForImport,
   toRemotePostPayload,
   buildIncompleteSetupError,
   detectRemoteSetupStatus,
   getIncompleteSetupError,
+  loadSiteConfig,
+  walkHugoContent,
+  mediaSpecFromJantMedia,
+  resolveCollectionMemberships,
+  buildPostPayloadFromBundle,
 };
 
 export async function run(argv) {
@@ -1255,7 +2017,7 @@ export async function run(argv) {
   if (values.help) {
     console.log("Usage: jant site import [--url <url>] [options]");
     console.log("");
-    console.log("Import a Zola export directory or ZIP into a Jant instance.");
+    console.log("Import a Hugo export directory or ZIP into a Jant instance.");
     console.log("");
     console.log("Modes:");
     console.log(
@@ -1320,26 +2082,10 @@ export async function run(argv) {
     process.exit(1);
   }
 
-  const postFiles = [];
-  const collectionFiles = [];
-  let siteConfig = null;
-  let customCss = "";
   let sourceRootDir = inputPath;
   let tempSourceRootDir = null;
 
-  if (inputStat.isDirectory()) {
-    console.log(`Reading directory ${inputPath}...`);
-    await walkContent(sourceRootDir, postFiles, collectionFiles);
-    const configPath = join(sourceRootDir, "config.toml");
-    const configContent = await readFile(configPath, "utf-8").catch(() => null);
-    if (configContent) {
-      siteConfig = await parseToml(configContent);
-    }
-    customCss = await readFile(
-      join(sourceRootDir, "static", "custom.css"),
-      "utf-8",
-    ).catch(() => "");
-  } else {
+  if (inputStat.isFile()) {
     console.log(`Reading ZIP ${inputPath}...`);
     const zipData = await readFile(inputPath);
     const { unzipSync } = await import("fflate");
@@ -1351,23 +2097,26 @@ export async function run(argv) {
       await mkdir(dirname(fullPath), { recursive: true });
       await writeFile(fullPath, data);
     }
-
-    await walkContent(sourceRootDir, postFiles, collectionFiles);
-    const configPath = join(sourceRootDir, "config.toml");
-    const configContent = await readFile(configPath, "utf-8").catch(() => null);
-    if (configContent) {
-      siteConfig = await parseToml(configContent);
-    }
-    customCss = await readFile(
-      join(sourceRootDir, "static", "custom.css"),
-      "utf-8",
-    ).catch(() => "");
+  } else {
+    console.log(`Reading directory ${inputPath}...`);
   }
 
+  const { rootBundles, collectionBundles } =
+    await walkHugoContent(sourceRootDir);
+  const siteConfig = await loadSiteConfig(sourceRootDir);
+  const customCss = await readImportCustomCss(sourceRootDir);
+
   try {
+    const replyCount = rootBundles.reduce(
+      (sum, root) => sum + root.children.length,
+      0,
+    );
     console.log(
-      `Found ${postFiles.length} posts and ${collectionFiles.length} collections`,
+      `Found ${rootBundles.length} posts (+${replyCount} replies) and ${collectionBundles.length} collections`,
     );
+    const importedCollectionDirectory = siteConfig
+      ? normalizeImportedCollectionDirectory(siteConfig)
+      : { exported: false, items: [] };
 
     if (target) {
       const setupError = await getIncompleteSetupError(
@@ -1408,8 +2157,10 @@ export async function run(argv) {
           }
         }
       } else {
+        const { editable, internal } =
+          splitSettingsUpdatesForImport(settingsUpdates);
         try {
-          const result = await target.updateSettings(settingsUpdates);
+          const result = await target.updateSettings(editable);
           if (result?.rejectedKeys?.length) {
             console.warn(
               `Warning: Some site settings were rejected: ${result.rejectedKeys.join(", ")}`,
@@ -1422,6 +2173,22 @@ export async function run(argv) {
           process.exit(1);
         }
 
+        if (Object.keys(internal).length > 0) {
+          try {
+            const result = await target.updateImportSettings(internal);
+            if (result?.rejectedKeys?.length) {
+              console.warn(
+                `Warning: Some internal site settings were rejected: ${result.rejectedKeys.join(", ")}`,
+              );
+            }
+          } catch (err) {
+            console.error(
+              `Error applying exported internal site settings: ${err.message}`,
+            );
+            process.exit(1);
+          }
+        }
+
         if (importedNav.exported) {
           try {
             const existingNavItems = await target.listNavItems();
@@ -1443,8 +2210,13 @@ export async function run(argv) {
               avatarImport.mode === "set" ? avatarImport : null,
             );
           } catch (err) {
-            console.error(`Error importing site avatar: ${err.message}`);
-            process.exit(1);
+            // Non-fatal: continue the rest of the import even if the avatar
+            // source asset is unreachable (e.g. unreadable file, stale URL).
+            // The rest of the site data is far more valuable than losing the
+            // entire import over a single image.
+            console.warn(
+              `Warning: Could not import site avatar — continuing without it. (${err.message})`,
+            );
           }
         }
       }
@@ -1465,12 +2237,8 @@ export async function run(argv) {
       }
     }
 
-    for (const { path, content } of collectionFiles) {
-      const { frontMatter } = await parseFrontMatter(content);
-      const slug = path
-        .replace("content/jant-collections/", "")
-        .replace("content/c/", "")
-        .replace("/_index.md", "");
+    for (const bundle of collectionBundles) {
+      const slug = bundle.slug;
 
       if (collectionSlugToId.has(slug)) {
         console.error(
@@ -1481,83 +2249,117 @@ export async function run(argv) {
 
       if (dryRun) {
         console.log(
-          `[dry-run] Would create collection: ${frontMatter.title || slug}`,
+          `[dry-run] Would create collection: ${bundle.frontMatter.title || slug}`,
         );
         collectionSlugToId.set(slug, `dry-run-${slug}`);
         continue;
       }
 
       try {
-        const collectionExtra = frontMatter.extra || {};
         const result = await target.createCollection({
-          title: frontMatter.title || slug,
+          title: bundle.frontMatter.title || slug,
           slug,
-          description: frontMatter.description || null,
+          description:
+            typeof bundle.frontMatter.summary_text === "string"
+              ? bundle.frontMatter.summary_text
+              : undefined,
           sortOrder:
-            collectionExtra.sort_order ||
-            collectionExtra.sortOrder ||
-            undefined,
+            typeof bundle.frontMatter.sort_order === "string"
+              ? bundle.frontMatter.sort_order
+              : undefined,
         });
         collectionSlugToId.set(slug, result.id);
-        console.log(`Created collection: ${frontMatter.title || slug}`);
+        console.log(`Created collection: ${bundle.frontMatter.title || slug}`);
       } catch (err) {
         console.error(`Error creating collection "${slug}": ${err.message}`);
         process.exit(1);
       }
     }
 
-    // 4. Process posts
+    if (importedCollectionDirectory.exported) {
+      if (dryRun) {
+        console.log(
+          `[dry-run] Would restore collection directory with ${importedCollectionDirectory.items.length} items`,
+        );
+      } else {
+        try {
+          await syncImportedCollectionDirectory(
+            target,
+            importedCollectionDirectory,
+            collectionSlugToId,
+          );
+        } catch (err) {
+          console.error(
+            `Error restoring collections directory: ${err.message}`,
+          );
+          process.exit(1);
+        }
+      }
+    }
+
+    // 4. Process posts — root bundle first, then each reply leaf, then aliases.
     let postsCreated = 0;
     let repliesCreated = 0;
     let mediaUploaded = 0;
     let aliasesCreated = 0;
 
-    for (const { path, content } of postFiles) {
-      const { frontMatter, body } = await parseFrontMatter(content);
-
-      const segments = splitReplies(body);
-      const rootSegment = segments[0];
-      const replySegments = segments.slice(1);
-      const replySlugPaths = collectReplySlugPaths(replySegments);
-
-      // Resolve collection IDs from taxonomy slugs
-      const collectionIds = [];
-      const taxonomyCollections =
-        frontMatter.taxonomies?.c || frontMatter.taxonomies?.collections || [];
-      for (const colSlug of taxonomyCollections) {
-        const id = collectionSlugToId.get(colSlug);
-        if (id) collectionIds.push(id);
-      }
-
-      const extra = frontMatter.extra || {};
-      const format = extra.format || "note";
-      const postSlug =
-        frontMatter.slug != null ? String(frontMatter.slug) : undefined;
-      const postStatus =
-        extra.status === "draft" || extra.status === "published"
-          ? extra.status
-          : frontMatter.draft
-            ? "draft"
-            : "published";
-      const postVisibility =
-        extra.visibility === "unlisted" || extra.visibility === "private"
-          ? extra.visibility
-          : undefined;
+    for (const rootBundle of rootBundles) {
+      const { frontMatter: rootFm } = rootBundle;
+      const postSlug = rootBundle.slug;
+      const format =
+        typeof rootFm.format === "string" ? rootFm.format : "note";
       const postLabel =
-        (format === "quote" ? extra.source_name : frontMatter.title) ||
+        (format === "quote"
+          ? typeof rootFm.source_name === "string"
+            ? rootFm.source_name
+            : null
+          : typeof rootFm.title === "string"
+            ? rootFm.title
+            : null) ||
         postSlug ||
         "(untitled)";
 
-      if (!dryRun && postSlug) {
+      if (!dryRun) {
         await assertImportSlugAvailable(target, postSlug, postLabel, "post");
       }
 
-      // Process images in root body
-      let rootBody = rootSegment?.body || "";
-      const normalizedRootBody = normalizeImportedBodySegment(rootBody);
-      rootBody = normalizedRootBody.markdown;
+      // Normalize body + extract embedded attachment blocks.
+      const normalizedRoot = normalizeImportedBodySegment(rootBundle.body);
+      let rootBody = normalizedRoot.markdown;
       let importedAttachments = [];
 
+      // Upload media declared in flat `media:` front matter. Each entry's
+      // `src` is either a site-relative path (bytes under `static/`) or an
+      // absolute URL (media still served by the original provider).
+      // Text attachments (`kind: "text"`) live under the same `media:` key
+      // but must be imported via `normalizeTextAttachmentSpec` so the body
+      // is decoded and stored as a text attachment rather than uploaded as
+      // a generic media file.
+      const rootResourceSpecs = [];
+      const rootTextAttachmentEntries = [];
+      if (Array.isArray(rootFm.media)) {
+        for (const entry of rootFm.media) {
+          if (entry && typeof entry === "object" && entry.kind === "text") {
+            rootTextAttachmentEntries.push(entry);
+            continue;
+          }
+          const spec = await mediaSpecFromJantMedia(entry, sourceRootDir);
+          if (spec) rootResourceSpecs.push(spec);
+        }
+      }
+
+      const rootResourceIds = [];
+      if (!skipMedia && !dryRun && rootResourceSpecs.length > 0) {
+        const result = await uploadBundleResources(rootResourceSpecs, target);
+        mediaUploaded += result.uploaded;
+        if (result.urlMap.size > 0) {
+          rootBody = rewriteMediaReferences(rootBody, result.urlMap);
+        }
+        rootResourceIds.push(...result.mediaIds);
+      }
+
+      // Fallback: rewrite any leftover in-body image URLs (covers hand-
+      // authored Hugo content where the exporter didn't declare resources).
       if (!skipMedia && !dryRun) {
         const imageMedia = findImageUrls(rootBody).map((src) => ({ src }));
         const uploadResult = await uploadMediaList(
@@ -1567,14 +2369,14 @@ export async function run(argv) {
           sourceRootDir,
         );
         mediaUploaded += uploadResult.uploaded;
-
         if (uploadResult.urlMap.size > 0) {
           rootBody = rewriteMediaReferences(rootBody, uploadResult.urlMap);
         }
       }
+
       if (!dryRun) {
         const attachmentResult = await buildImportedAttachments(
-          normalizedRootBody.attachments,
+          normalizedRoot.attachments,
           target,
           siteConfig,
           sourceRootDir,
@@ -1584,91 +2386,129 @@ export async function run(argv) {
         mediaUploaded += attachmentResult.uploaded;
       }
 
-      const postData = {
-        format,
-        title:
-          format === "quote"
-            ? typeof extra.source_name === "string"
-              ? extra.source_name
-              : undefined
-            : frontMatter.title != null
-              ? String(frontMatter.title)
-              : undefined,
-        bodyMarkdown: rootBody || undefined,
-        slug: postSlug,
-        path: frontMatter.path != null ? String(frontMatter.path) : undefined,
-        status: postStatus,
-        visibility: postVisibility,
-        collectionIds: collectionIds.length > 0 ? collectionIds : undefined,
-        attachments:
-          importedAttachments.length > 0 ? importedAttachments : undefined,
-        publishedAt:
-          postStatus === "published" && frontMatter.date
-            ? Math.floor(new Date(frontMatter.date).getTime() / 1000)
-            : undefined,
-        pinned: extra.pinned || undefined,
-        featured: extra.featured || undefined,
-        rating: extra.rating || undefined,
-      };
-
-      if (format === "link" && extra.link_url) {
-        postData.url = extra.link_url;
+      // Also attach every uploaded root page-resource as a media attachment
+      // so the post record carries them even when none appear in body text.
+      for (const mediaId of rootResourceIds) {
+        importedAttachments.push({ type: "media", mediaId });
       }
-      if (format === "quote" && extra.quote_text) {
-        postData.quoteText = extra.quote_text;
-        if (typeof extra.source_url === "string" && extra.source_url.trim()) {
-          postData.url = extra.source_url;
+
+      // Build text attachments declared in the flat `media:` front matter.
+      // These reference a `.md` artifact that holds the full body; the
+      // normalizer fetches the bytes (local disk first, then remote URL)
+      // and decodes them.
+      if (!skipMedia && !dryRun) {
+        for (const textEntry of rootTextAttachmentEntries) {
+          const textAttachment = await normalizeTextAttachmentSpec(
+            textEntry,
+            siteConfig,
+            sourceRootDir,
+          );
+          if (textAttachment) importedAttachments.push(textAttachment);
         }
       }
 
+      const memberships = resolveCollectionMemberships(
+        rootFm,
+        collectionSlugToId,
+      );
+      const postData = buildPostPayloadFromBundle(rootBundle, {
+        bodyMarkdown: rootBody,
+        attachments: importedAttachments,
+        memberships,
+        replyToId: null,
+      });
+
       if (dryRun) {
         console.log(`[dry-run] Would create post: ${postLabel} (${format})`);
-        if (replySegments.length > 0) {
-          console.log(`  [dry-run] With ${replySegments.length} replies`);
+        if (rootBundle.children.length > 0) {
+          console.log(
+            `  [dry-run] With ${rootBundle.children.length} replies`,
+          );
         }
         postsCreated++;
-        repliesCreated += replySegments.length;
+        repliesCreated += rootBundle.children.length;
         continue;
       }
 
-      const progress = `[${postsCreated + 1}/${postFiles.length}]`;
-
+      const progress = `[${postsCreated + 1}/${rootBundles.length}]`;
       let post;
       try {
         post = await target.createPost(postData);
         postsCreated++;
         const replyInfo =
-          replySegments.length > 0 ? ` (+${replySegments.length} replies)` : "";
+          rootBundle.children.length > 0
+            ? ` (+${rootBundle.children.length} replies)`
+            : "";
         console.log(`${progress} Created: ${postLabel}${replyInfo}`);
       } catch (err) {
         console.error(`Error creating post "${postLabel}": ${err.message}`);
         process.exit(1);
       }
 
-      // Create replies before aliases so reply slugs can claim their own paths.
+      // Create replies before aliases so reply slugs can claim their paths.
       if (!post) continue;
-      for (const replySegment of replySegments) {
-        const replyAttrs = replySegment.attrs || {};
-        const replySlug = replyAttrs.slug || undefined;
+      const replySlugPaths = new Set();
+      // Jant threads are linear: each reply must point at the current end of
+      // the thread, not at the root. Track the tail as we go so the Nth
+      // reply chains after the (N−1)th.
+      let threadTailId = post.id;
+      for (const replyBundle of rootBundle.children) {
+        const replyFm = replyBundle.frontMatter;
+        const replySlug = replyBundle.slug;
+        const replyFormat =
+          typeof replyFm.format === "string" ? replyFm.format : "note";
         const replyLabel =
-          replyAttrs.source_name ||
-          replyAttrs.title ||
+          (replyFormat === "quote"
+            ? typeof replyFm.source_name === "string"
+              ? replyFm.source_name
+              : null
+            : typeof replyFm.title === "string"
+              ? replyFm.title
+              : null) ||
           replySlug ||
           "(untitled reply)";
-        if (!dryRun && replySlug) {
-          await assertImportSlugAvailable(
+
+        const replySlugPath = normalizeImportAliasPath(replySlug);
+        if (replySlugPath) replySlugPaths.add(replySlugPath);
+
+        await assertImportSlugAvailable(
+          target,
+          replySlug,
+          `${replyLabel} in ${postLabel}`,
+          "reply",
+        );
+
+        const normalizedReply = normalizeImportedBodySegment(replyBundle.body);
+        let replyBody = normalizedReply.markdown;
+        let replyAttachments = [];
+
+        const replyResourceSpecs = [];
+        const replyTextAttachmentEntries = [];
+        if (Array.isArray(replyFm.media)) {
+          for (const entry of replyFm.media) {
+            if (entry && typeof entry === "object" && entry.kind === "text") {
+              replyTextAttachmentEntries.push(entry);
+              continue;
+            }
+            const spec = await mediaSpecFromJantMedia(entry, sourceRootDir);
+            if (spec) replyResourceSpecs.push(spec);
+          }
+        }
+
+        const replyResourceIds = [];
+        if (!skipMedia && replyResourceSpecs.length > 0) {
+          const result = await uploadBundleResources(
+            replyResourceSpecs,
             target,
-            replySlug,
-            `${replyLabel} in ${postLabel}`,
-            "reply",
           );
+          mediaUploaded += result.uploaded;
+          if (result.urlMap.size > 0) {
+            replyBody = rewriteMediaReferences(replyBody, result.urlMap);
+          }
+          replyResourceIds.push(...result.mediaIds);
         }
-        let replyBody = replySegment.body || "";
-        const normalizedReplyBody = normalizeImportedBodySegment(replyBody);
-        replyBody = normalizedReplyBody.markdown;
-        let replyAttachments = [];
 
-        if (!skipMedia && !dryRun) {
+        if (!skipMedia) {
           const imageMedia = findImageUrls(replyBody).map((src) => ({ src }));
           const uploadResult = await uploadMediaList(
             imageMedia,
@@ -1677,87 +2517,72 @@ export async function run(argv) {
             sourceRootDir,
           );
           mediaUploaded += uploadResult.uploaded;
-
           if (uploadResult.urlMap.size > 0) {
             replyBody = rewriteMediaReferences(replyBody, uploadResult.urlMap);
           }
         }
-        if (!dryRun) {
-          const attachmentResult = await buildImportedAttachments(
-            normalizedReplyBody.attachments,
-            target,
-            siteConfig,
-            sourceRootDir,
-            { skipUploads: skipMedia },
-          );
-          replyAttachments = attachmentResult.attachments;
-          mediaUploaded += attachmentResult.uploaded;
-        }
 
-        const replyFormat = replyAttrs.format || "note";
-        const replyStatus =
-          replyAttrs.status === "draft" || replyAttrs.status === "published"
-            ? replyAttrs.status
-            : "published";
-        const replyVisibility =
-          replyAttrs.visibility === "unlisted" ||
-          replyAttrs.visibility === "private"
-            ? replyAttrs.visibility
-            : undefined;
-        const replyData = {
-          format: replyFormat,
-          status: replyStatus,
-          title:
-            replyFormat === "quote"
-              ? replyAttrs.source_name || undefined
-              : replyAttrs.title || undefined,
-          bodyMarkdown: replyBody || undefined,
-          replyToId: post.id,
-          slug: replySlug,
-          visibility: replyVisibility,
-          attachments:
-            replyAttachments.length > 0 ? replyAttachments : undefined,
-          publishedAt: replyAttrs.date
-            ? Math.floor(new Date(replyAttrs.date).getTime() / 1000)
-            : undefined,
-          rating: replyAttrs.rating ? Number(replyAttrs.rating) : undefined,
-        };
-
-        if (replyFormat === "link" && replyAttrs.url) {
-          replyData.url = replyAttrs.url;
+        const attachmentResult = await buildImportedAttachments(
+          normalizedReply.attachments,
+          target,
+          siteConfig,
+          sourceRootDir,
+          { skipUploads: skipMedia },
+        );
+        replyAttachments = attachmentResult.attachments;
+        mediaUploaded += attachmentResult.uploaded;
+        for (const mediaId of replyResourceIds) {
+          replyAttachments.push({ type: "media", mediaId });
         }
-        if (replyFormat === "quote" && replyAttrs.quote_text) {
-          replyData.quoteText = decodeURIComponent(replyAttrs.quote_text);
-          if (replyAttrs.source_url) {
-            replyData.url = replyAttrs.source_url;
+
+        if (!skipMedia) {
+          for (const textEntry of replyTextAttachmentEntries) {
+            const textAttachment = await normalizeTextAttachmentSpec(
+              textEntry,
+              siteConfig,
+              sourceRootDir,
+            );
+            if (textAttachment) replyAttachments.push(textAttachment);
           }
         }
 
+        const replyMemberships = resolveCollectionMemberships(
+          replyFm,
+          collectionSlugToId,
+        );
+        const replyData = buildPostPayloadFromBundle(replyBundle, {
+          bodyMarkdown: replyBody,
+          attachments: replyAttachments,
+          memberships: replyMemberships,
+          replyToId: threadTailId,
+        });
+
         try {
-          await target.createPost(replyData);
+          const createdReply = await target.createPost(replyData);
           repliesCreated++;
+          if (createdReply?.id) {
+            threadTailId = createdReply.id;
+          }
         } catch (err) {
           console.error(`  Error creating reply: ${err.message}`);
           process.exit(1);
         }
       }
 
-      // Create exported root aliases after replies. Reply slugs are handled by
-      // the thread markers; only true root aliases round-trip back into Jant.
+      // Create exported root aliases after replies. Historical root slugs
+      // round-trip via `root_aliases:`; reply slugs are handled by their
+      // own bundles so we strip them from the alias list.
       const rootTargetSlug = postSlug || post.slug;
-      let aliasPaths;
-      try {
-        aliasPaths = getRootAliasPathsForImport(
-          getExportedRootAliases(frontMatter),
-          rootTargetSlug,
-          replySlugPaths,
-        );
-      } catch (err) {
-        console.error(
-          `Error importing aliases for "${postLabel}": ${err.message}`,
-        );
-        process.exit(1);
-      }
+      const aliases = Array.isArray(rootFm.aliases) ? rootFm.aliases : [];
+      const rootAliases = Array.isArray(rootFm.root_aliases)
+        ? rootFm.root_aliases
+        : [];
+      const aliasPaths = getRootAliasPathsForImport(
+        aliases,
+        rootAliases,
+        rootTargetSlug,
+        replySlugPaths,
+      );
       for (const aliasPath of aliasPaths) {
         try {
           await target.createAlias(aliasPath, rootTargetSlug);
@@ -1791,3 +2616,4 @@ export async function run(argv) {
     }
   }
 }
+