muriel 1.0.2 → 1.0.3

package/examples/muriel-blog-maker/blog.js

@@ -2,9 +2,19 @@
 import { flow } from '../../index.js';
 import fs from 'node:fs';
 import path from 'node:path';
-import { readdir, readFile, mkdir, copyFile, writeFile } from 'node:fs/promises';
-import sharp from 'sharp';
-import { marked } from 'marked';
+
+import { setup, processedPosts } from './lib.js';
+
+import postScanner  from './transforms/post-scanner/index.js';
+import processCover from './transforms/process-cover/index.js';
+import processAudio from './transforms/process-audio/index.js';
+import processText  from './transforms/process-text/index.js';
+import copyFiles    from './transforms/copy-files/index.js';
+import verifyPost   from './transforms/verify-post/index.js';
+import collectPost  from './transforms/collect-post/index.js';
+import homepage     from './transforms/homepage/index.js';
+import pagerizer    from './transforms/pagerizer/index.js';
+import rssFeed      from './transforms/rss-feed/index.js';
 
 // ─────────────────────────────────────────────
 // Configuration
@@ -16,768 +26,14 @@ if (!profilePath) {
   process.exit(1);
 }
 
-// Load and parse profile
 const profileFullPath = path.resolve(process.cwd(), profilePath);
-const profileRaw = fs.readFileSync(profileFullPath, 'utf-8');
-const profile = JSON.parse(profileRaw);
-
-// Base directory is the parent of 'examples' (project root)
+const profile = JSON.parse(fs.readFileSync(profileFullPath, 'utf-8'));
 const baseDir = path.resolve(path.dirname(profileFullPath), '..');
 
-function resolvePath(p) {
-  return path.resolve(baseDir, p.replace('{profile}', profile.profile));
-}
-
-// ─────────────────────────────────────────────
-// Producer: Scan posts directory
-// ─────────────────────────────────────────────
-
-function scanner(postsDir) {
-  return async send => {
-    const srcDir = resolvePath(postsDir);
-    console.log(`Scanning: ${srcDir}`);
-
-    const entries = await readdir(srcDir, { withFileTypes: true });
-    const postDirs = entries.filter(e => e.isDirectory()).map(e => e.name);
-
-    // Filter to valid posts (those with post.json)
-    const validPostDirs = [];
-    for (const postId of postDirs) {
-      const postDir = path.join(srcDir, postId);
-      const postJsonPath = path.join(postDir, 'post.json');
-      if (fs.existsSync(postJsonPath)) {
-        validPostDirs.push({ postId, postDir, postJsonPath });
-      } else {
-        console.log(`  Skipping ${postId}: no post.json`);
-      }
-    }
-
-    const totalPosts = validPostDirs.length;
-    console.log(`  Found ${totalPosts} posts`);
-
-    for (const { postId, postDir, postJsonPath } of validPostDirs) {
-      const postData = JSON.parse(await readFile(postJsonPath, 'utf-8'));
-
-      send({
-        postId,
-        postDir,
-        postData,
-        guid: postData.guid,
-        chapter: postData.chapter,
-        _totalPosts: totalPosts,
-        files: {
-          cover: postData.image ? path.join(postDir, 'cover.jpg') : null,
-          audio: postData.audio ? path.join(postDir, 'audio.mp3') : null,
-          text: path.join(postDir, 'text.md'),
-          filesDir: path.join(postDir, 'files')
-        }
-      });
-    }
-  };
-}
-
-// ─────────────────────────────────────────────
-// Transform: Process cover image → AVIF
-// ─────────────────────────────────────────────
-
-function processCover(config) {
-  const { width = 1024, height = 1024, quality = 80, effort = 4 } = config;
-
-  return async (send, packet) => {
-    const { files, guid, postId } = packet;
-
-    if (!files.cover || !fs.existsSync(files.cover)) {
-      console.log(`  [cover] ${postId}: No cover image`);
-      send({ ...packet, coverResult: { skipped: true } });
-      return;
-    }
-
-    const destPath = resolvePath(profile.cover.dest.replace('{guid}', guid));
-    await mkdir(path.dirname(destPath), { recursive: true });
-
-    try {
-      await sharp(files.cover)
-        .resize(width, height, { kernel: sharp.kernel.mitchell, fit: 'inside' })
-        .avif({ quality, effort })
-        .toFile(destPath);
-
-      const stats = fs.statSync(destPath);
-      console.log(`  [cover] ${postId}: ${(stats.size / 1024).toFixed(1)}KB → ${path.basename(destPath)}`);
-
-      send({
-        ...packet,
-        coverResult: {
-          success: true,
-          path: destPath,
-          url: profile.cover.url.replace('{guid}', guid),
-          size: stats.size
-        }
-      });
-    } catch (err) {
-      console.error(`  [cover] ${postId}: Error - ${err.message}`);
-      send({ ...packet, coverResult: { error: err.message } });
-    }
-  };
-}
-
-// ─────────────────────────────────────────────
-// Transform: Process audio → MP3 downsampling
-// ─────────────────────────────────────────────
-
-import { spawn } from 'node:child_process';
-import { once } from 'node:events';
-
-const mp3Presets = {
-  highQuality: (src, out) => [
-    '-hide_banner', '-loglevel', 'error', '-i', src,
-    '-c:a', 'libmp3lame', '-q:a', '5', '-ar', '48000',
-    '-af', 'aresample=resampler=soxr:precision=33:dither_method=triangular',
-    '-y', out
-  ],
-  quality: (src, out) => [
-    '-hide_banner', '-loglevel', 'error', '-i', src,
-    '-c:a', 'libmp3lame', '-q:a', '6', '-b:a', '192k', '-ar', '44100',
-    '-af', 'aresample=resampler=soxr:precision=28:dither_method=triangular',
-    '-y', out
-  ],
-  balanced: (src, out) => [
-    '-hide_banner', '-loglevel', 'error', '-i', src,
-    '-c:a', 'libmp3lame', '-q:a', '7', '-ar', '44100',
-    '-af', 'aresample=resampler=soxr:precision=24',
-    '-y', out
-  ],
-  speed: (src, out) => [
-    '-hide_banner', '-loglevel', 'error', '-i', src,
-    '-c:a', 'libmp3lame', '-q:a', '7', '-b:a', '128k', '-ar', '44100',
-    '-af', 'aresample=resampler=soxr:precision=20',
-    '-y', out
-  ],
-  fast: (src, out) => [
-    '-hide_banner', '-loglevel', 'error', '-i', src,
-    '-c:a', 'libmp3lame', '-q:a', '8', '-b:a', '96k', '-ar', '22050',
-    '-af', 'aresample=resampler=soxr',
-    '-y', out
-  ]
-};
-
-function processAudio(config) {
-  const preset = config.preset || 'balanced';
-
-  return async (send, packet) => {
-    const { files, guid, postId, postData } = packet;
-
-    if (!files.audio || !fs.existsSync(files.audio)) {
-      console.log(`  [audio] ${postId}: No audio file`);
-      send({ ...packet, audioResult: { skipped: true } });
-      return;
-    }
-
-    const destPath = resolvePath(
-      profile.audio.dest
-        .replace('{chapter}', postData.chapter || '0')
-        .replace('{id}', postData.id)
-    );
-    await mkdir(path.dirname(destPath), { recursive: true });
-
-    const presetFn = mp3Presets[preset];
-    if (!presetFn) {
-      console.error(`  [audio] ${postId}: Unknown preset "${preset}"`);
-      send({ ...packet, audioResult: { error: `Unknown preset: ${preset}` } });
-      return;
-    }
-
-    try {
-      const args = presetFn(files.audio, destPath);
-      const ffmpeg = spawn('ffmpeg', args);
-      let stderr = '';
-      ffmpeg.stderr.on('data', data => stderr += data.toString());
-
-      const [code] = await once(ffmpeg, 'close');
-
-      if (code !== 0) {
-        throw new Error(`FFmpeg exited with code ${code}: ${stderr}`);
-      }
-
-      const inputStats = fs.statSync(files.audio);
-      const outputStats = fs.statSync(destPath);
-      const reduction = ((1 - outputStats.size / inputStats.size) * 100).toFixed(1);
-
-      console.log(`  [audio] ${postId}: ${(inputStats.size / 1024 / 1024).toFixed(1)}MB → ${(outputStats.size / 1024 / 1024).toFixed(1)}MB (${reduction}% smaller)`);
-
-      send({
-        ...packet,
-        audioResult: {
-          success: true,
-          path: destPath,
-          url: profile.audio.url.replace('{id}', postData.id),
-          size: outputStats.size,
-          reduction: parseFloat(reduction)
-        }
-      });
-    } catch (err) {
-      console.error(`  [audio] ${postId}: Error - ${err.message}`);
-      send({ ...packet, audioResult: { error: err.message } });
-    }
-  };
-}
-
-// ─────────────────────────────────────────────
-// Transform: Process text → HTML
-// ─────────────────────────────────────────────
-
-function processText() {
-  // This runs after parallel branches join, so we have access to cover/audio results
-  return async (send, packet) => {
-    const { branches, guid, postId, postData } = packet;
-
-    // Extract results from joined branches
-    const coverBranch = branches?.find(b => b.coverResult);
-    const audioBranch = branches?.find(b => b.audioResult);
-    const filesBranch = branches?.find(b => b.files);
-
-    const files = filesBranch?.files || packet.files;
-
-    if (!fs.existsSync(files.text)) {
-      console.log(`  [text] ${postId}: No text.md`);
-      send({ ...packet, textResult: { skipped: true } });
-      return;
-    }
-
-    try {
-      const markdown = await readFile(files.text, 'utf-8');
-      const html = marked(markdown);
-
-      const destDir = resolvePath(`${profile.dest}/permalink/${guid}`);
-      await mkdir(destDir, { recursive: true });
-
-      const destPath = path.join(destDir, 'index.html');
-
-      // Get cover and audio URLs from branches
-      const coverUrl = coverBranch?.coverResult?.url;
-      const audioUrl = audioBranch?.audioResult?.url;
-
-      // Simple HTML template
-      const fullHtml = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${postData.title || postId}</title>
-  <style>
-    body { font-family: system-ui, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; line-height: 1.6; }
-    img { max-width: 100%; height: auto; }
-    audio { width: 100%; }
-  </style>
-</head>
-<body>
-  <article>
-    <h1>${postData.title || postId}</h1>
-    <time>${postData.date ? new Date(postData.date).toLocaleDateString() : ''}</time>
-    ${coverUrl ? `<img src="${coverUrl}" alt="Cover">` : ''}
-    ${audioUrl ? `<audio controls src="${audioUrl}"></audio>` : ''}
-    <div class="content">
-${html}
-    </div>
-  </article>
-</body>
-</html>`;
-
-      await writeFile(destPath, fullHtml);
-      console.log(`  [text] ${postId}: Generated index.html`);
-
-      send({
-        ...packet,
-        textResult: {
-          success: true,
-          path: destPath,
-          htmlLength: fullHtml.length
-        }
-      });
-    } catch (err) {
-      console.error(`  [text] ${postId}: Error - ${err.message}`);
-      send({ ...packet, textResult: { error: err.message } });
-    }
-  };
-}
-
-// ─────────────────────────────────────────────
-// Transform: Copy files directory
-// ─────────────────────────────────────────────
-
-function copyFiles() {
-  return async (send, packet) => {
-    const { files, guid, postId } = packet;
-
-    if (!fs.existsSync(files.filesDir)) {
-      send({ ...packet, filesResult: { skipped: true, reason: 'no files dir' } });
-      return;
-    }
-
-    try {
-      const entries = await readdir(files.filesDir, { withFileTypes: true });
-      const fileList = entries.filter(e => e.isFile());
-
-      if (fileList.length === 0) {
-        send({ ...packet, filesResult: { skipped: true, reason: 'empty' } });
-        return;
-      }
-
-      const destDir = resolvePath(`${profile.dest}/permalink/${guid}/files`);
-      await mkdir(destDir, { recursive: true });
-
-      let copiedCount = 0;
-      for (const file of fileList) {
-        const srcPath = path.join(files.filesDir, file.name);
-        const destPath = path.join(destDir, file.name);
-        await copyFile(srcPath, destPath);
-        copiedCount++;
-      }
-
-      console.log(`  [files] ${postId}: Copied ${copiedCount} file(s)`);
-
-      send({
-        ...packet,
-        filesResult: {
-          success: true,
-          count: copiedCount,
-          destDir
-        }
-      });
-    } catch (err) {
-      console.error(`  [files] ${postId}: Error - ${err.message}`);
-      send({ ...packet, filesResult: { error: err.message } });
-    }
-  };
-}
-
-// ─────────────────────────────────────────────
-// Transform: Verify all branches completed
-// ─────────────────────────────────────────────
-
-function verify() {
-  return (send, packet) => {
-    const { branches, postId, textResult } = packet;
-
-    const coverBranch = branches?.find(b => b.coverResult);
-    const audioBranch = branches?.find(b => b.audioResult);
-    const filesBranch = branches?.find(b => b.filesResult);
-
-    const results = {
-      cover: coverBranch?.coverResult || { missing: true },
-      audio: audioBranch?.audioResult || { missing: true },
-      text: textResult || { missing: true },
-      files: filesBranch?.filesResult || { missing: true }
-    };
-
-    const errors = Object.entries(results)
-      .filter(([, r]) => r.error)
-      .map(([k, r]) => `${k}: ${r.error}`);
-
-    const valid = errors.length === 0;
-
-    if (!valid) {
-      console.log(`  [verify] ${postId}: FAILED - ${errors.join(', ')}`);
-    } else {
-      console.log(`  [verify] ${postId}: OK`);
-    }
-
-    send({
-      ...packet,
-      results,
-      valid,
-      errors
-    });
-  };
-}
-
-// ─────────────────────────────────────────────
-// Transform: Collect processed posts
-// ─────────────────────────────────────────────
-
-const processedPosts = [];
-
-function collector() {
-  return (send, packet) => {
-    const { branches, postData, postId, guid, valid, errors, textResult } = packet;
-
-    // Extract results from branches
-    const coverBranch = branches?.find(b => b.coverResult);
-    const audioBranch = branches?.find(b => b.audioResult);
-
-    processedPosts.push({
-      postId,
-      guid,
-      valid,
-      errors,
-      postData,
-      coverUrl: coverBranch?.coverResult?.url,
-      audioUrl: audioBranch?.audioResult?.url,
-      permalinkUrl: `/permalink/${guid}/`
-    });
-
-    send(packet);
-  };
-}
-
-// ─────────────────────────────────────────────
-// Pagerizer: Generate paginated archive pages
-// page-0.html = oldest, page-N.html = newest
-// ─────────────────────────────────────────────
-
-class Page {
-  constructor(posts, index, allChunks) {
-    this.posts = posts;
-    this.index = index;
-    this.allChunks = allChunks;
-    this.pagerRadius = 5;
-  }
-
-  get pageIndex() { return this.index; }
-  get totalPages() { return this.allChunks.length; }
-  get isFirstPage() { return this.index === 0; }
-  get isLastPage() { return this.index === this.totalPages - 1; }
-
-  get newerIndex() { return this.index + 1 > this.totalPages - 1 ? null : this.index + 1; }
-  get olderIndex() { return this.index - 1 < 0 ? null : this.index - 1; }
-
-  get fileName() { return this.toFileName(this.index); }
-  get newerFileName() { return this.newerIndex !== null ? this.toFileName(this.newerIndex) : 'index.html'; }
-  get olderFileName() { return this.olderIndex !== null ? this.toFileName(this.olderIndex) : null; }
-
-  toFileName(index) {
-    return `page-${index}.html`;
-  }
-
-  get pager() {
-    return Array.from(
-      { length: this.pagerRadius * 2 + 1 },
-      (_, i) => (this.pageIndex - this.pagerRadius + i + this.totalPages) % this.totalPages
-    ).map(index => ({
-      text: `${index + 1}`,
-      url: this.toFileName(index),
-      ariaCurrent: this.pageIndex === index
-    }));
-  }
-}
-
-function chunk(array, size) {
-  const chunks = [];
-  for (let i = 0; i < array.length; i += size) {
-    chunks.push(array.slice(i, i + size));
-  }
-  return chunks;
-}
-
-const pageStyles = `
-    * { box-sizing: border-box; }
-    body { font-family: system-ui, sans-serif; max-width: 1200px; margin: 0 auto; padding: 2rem; line-height: 1.6; background: #111; color: #eee; }
-    a { color: #6af; text-decoration: none; }
-    a:hover { text-decoration: underline; }
-    h1 { border-bottom: 1px solid #333; padding-bottom: 0.5rem; }
-    .posts { display: grid; grid-template-columns: repeat(auto-fill, minmax(280px, 1fr)); gap: 1.5rem; }
-    .post { background: #1a1a1a; border-radius: 8px; overflow: hidden; transition: transform 0.2s; }
-    .post:hover { transform: translateY(-4px); }
-    .post img { width: 100%; height: 180px; object-fit: cover; }
-    .post-content { padding: 1rem; }
-    .post h2 { margin: 0 0 0.5rem; font-size: 1.1rem; }
-    .post time { color: #888; font-size: 0.85rem; }
-    .pager { display: flex; justify-content: center; gap: 0.5rem; margin: 2rem 0; flex-wrap: wrap; }
-    .pager a, .pager span { padding: 0.5rem 1rem; background: #222; border-radius: 4px; }
-    .pager span[aria-current="true"] { background: #6af; color: #000; }
-    nav.nav { display: flex; justify-content: space-between; margin-bottom: 1rem; }
-`;
-
-function renderPostCard(post) {
-  return `    <article class="post">
-      ${post.coverUrl ? `<a href="${post.permalinkUrl}"><img src="${post.coverUrl}" alt="" loading="lazy"></a>` : ''}
-      <div class="post-content">
-        <h2><a href="${post.permalinkUrl}">${post.postData.title || post.postId}</a></h2>
-        <time>${post.postData.date ? new Date(post.postData.date).toLocaleDateString() : ''}</time>
-      </div>
-    </article>`;
-}
-
-// ─────────────────────────────────────────────
-// Homepage: index.html with latest posts
-// ─────────────────────────────────────────────
-
-async function generateHomepage(posts, totalPages, config) {
-  const { pp = 12 } = config;
-  const destDir = resolvePath(profile.pagerizer.dest);
-  await mkdir(destDir, { recursive: true });
-
-  // Get latest posts (already sorted newest first)
-  const latestPosts = posts.slice(0, pp);
-
-  // Pager links to archive pages (centered on highest page with wrap)
-  // Shows: [wrapped pages descending] [main pages descending]
-  const pagerRadius = 5;
-  const centerPage = totalPages;
-  const allHomePages = Array.from(
-    { length: pagerRadius * 2 + 1 },
-    (_, i) => {
-      let pageNum = ((centerPage - pagerRadius + i - 1 + totalPages) % totalPages) + 1;
-      return {
-        text: `${pageNum}`,
-        url: `page-${pageNum}.html`,
-        pageNum
-      };
-    }
-  );
-
-  const lowBound = centerPage - pagerRadius;
-  const highBound = centerPage + pagerRadius;
-  const wrappedHome = allHomePages.filter(p => p.pageNum < lowBound || p.pageNum > highBound);
-  const mainHome = allHomePages.filter(p => p.pageNum >= lowBound && p.pageNum <= highBound);
-
-  const homePager = [
-    ...wrappedHome.sort((a, b) => b.pageNum - a.pageNum),
-    ...mainHome.sort((a, b) => b.pageNum - a.pageNum)
-  ];
-
-  const html = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${profile.title}</title>
-  <link rel="alternate" type="application/rss+xml" title="${profile.title} Feed" href="/feed.xml">
-  <style>${pageStyles}</style>
-</head>
-<body>
-  <header>
-    <h1>${profile.title}</h1>
-  </header>
-
-  <main class="posts">
-${latestPosts.map(renderPostCard).join('\n')}
-  </main>
-
-  <nav class="pager">
-    <a href="page-${totalPages}.html">Browse Archive</a>
-${homePager.map(p => `    <a href="${p.url}">${p.text}</a>`).join('\n')}
-  </nav>
-
-  <footer>
-    <p><a href="/feed.xml">RSS Feed</a></p>
-  </footer>
-</body>
-</html>`;
-
-  const filePath = path.join(destDir, 'index.html');
-  await writeFile(filePath, html);
-  console.log(`  [homepage] Generated index.html with ${latestPosts.length} latest posts`);
-  return { posts: latestPosts.length };
-}
+setup(baseDir, profile);
 
 // ─────────────────────────────────────────────
-// Pagerizer: Generate archive pages
-// Page N (highest) = newest posts (full 24)
-// Page 1 (lowest) = oldest posts (remainder)
-// ─────────────────────────────────────────────
-
-async function generatePaginatedPages(posts, config) {
-  const { pp = 24 } = config;
-  const destDir = resolvePath(profile.pagerizer.dest);
-  await mkdir(destDir, { recursive: true });
-
-  // Sort posts by date (newest first)
-  const sortedPosts = [...posts].sort((a, b) =>
-    new Date(b.postData.date) - new Date(a.postData.date)
-  );
-
-  // Chunk newest first: chunk[0] = newest 24, chunk[N] = oldest (remainder)
-  const chunks = chunk(sortedPosts, pp);
-  if (chunks.length === 0) chunks.push([]);
-
-  const totalPages = chunks.length;
-
-  for (let i = 0; i < chunks.length; i++) {
-    // Page number: chunk 0 = Page N (highest), chunk N-1 = Page 1 (lowest)
-    const pageNumber = totalPages - i;
-    const chunkPosts = chunks[i];
-
-    // Navigation indices (in chunk space)
-    const olderChunkIndex = i + 1 < chunks.length ? i + 1 : null;
-    const newerChunkIndex = i - 1 >= 0 ? i - 1 : null;
-
-    const olderPageNumber = olderChunkIndex !== null ? totalPages - olderChunkIndex : null;
-    const newerPageNumber = newerChunkIndex !== null ? totalPages - newerChunkIndex : null;
-
-    // Generate pager centered on current page with circular wrap
-    // Shows: [wrapped pages descending] [main pages descending]
-    // e.g., page 91: [5][4][3][2][1] [91][90][89][88][87][86]
-    const pagerRadius = 5;
-    const allPages = Array.from(
-      { length: pagerRadius * 2 + 1 },
-      (_, i) => {
-        let pn = ((pageNumber - pagerRadius + i - 1 + totalPages) % totalPages) + 1;
-        return {
-          text: `${pn}`,
-          url: `page-${pn}.html`,
-          ariaCurrent: pn === pageNumber,
-          pageNum: pn
-        };
-      }
-    );
-
-    // Split into wrapped (far from current) and main (near current)
-    const lowBound = pageNumber - pagerRadius;
-    const highBound = pageNumber + pagerRadius;
-    const wrapped = allPages.filter(p => p.pageNum < lowBound || p.pageNum > highBound);
-    const main = allPages.filter(p => p.pageNum >= lowBound && p.pageNum <= highBound);
-
-    // Wrapped pages descending, then main pages descending
-    const pager = [
-      ...wrapped.sort((a, b) => b.pageNum - a.pageNum),
-      ...main.sort((a, b) => b.pageNum - a.pageNum)
-    ];
-
-    const html = `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>${profile.title} - Page ${pageNumber}</title>
-  <link rel="alternate" type="application/rss+xml" title="${profile.title} Feed" href="/feed.xml">
-  <style>${pageStyles}</style>
-</head>
-<body>
-  <header>
-    <h1>${profile.title}</h1>
-  </header>
-
-  <nav class="nav">
-    ${newerPageNumber ? `<a href="page-${newerPageNumber}.html">&larr; Back</a>` : '<a href="index.html">&larr; Home</a>'}
-    <span>Page ${pageNumber} of ${totalPages}</span>
-    ${olderPageNumber ? `<a href="page-${olderPageNumber}.html">Next &rarr;</a>` : '<span></span>'}
-  </nav>
-
-  <main class="posts">
-${chunkPosts.map(renderPostCard).join('\n')}
-  </main>
-
-  <nav class="pager">
-    <a href="index.html">Home</a>
-${pager.map(p => p.ariaCurrent
-  ? `    <span aria-current="true">${p.text}</span>`
-  : `    <a href="${p.url}">${p.text}</a>`
-).join('\n')}
-  </nav>
-
-  <footer>
-    <p><a href="/feed.xml">RSS Feed</a></p>
-  </footer>
-</body>
-</html>`;
-
-    const filePath = path.join(destDir, `page-${pageNumber}.html`);
-    await writeFile(filePath, html);
-  }
-
-  console.log(`  [pagerizer] Generated ${chunks.length} archive page(s)`);
-  return { pages: chunks.length, postsPerPage: pp };
-}
-
-// ─────────────────────────────────────────────
-// Feed: Generate RSS feed.xml
-// ─────────────────────────────────────────────
-
-function escapeXml(str) {
-  if (!str) return '';
-  return str
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&apos;');
-}
-
-async function generateFeed(posts) {
-  const destPath = resolvePath(profile.feed.dest);
-  await mkdir(path.dirname(destPath), { recursive: true });
-
-  // Sort posts by date (newest first)
-  const sortedPosts = [...posts].sort((a, b) =>
-    new Date(b.postData.date) - new Date(a.postData.date)
-  );
-
-  const buildDate = new Date().toUTCString();
-
-  const xml = `<?xml version="1.0" encoding="UTF-8"?>
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
-  <channel>
-    <title>${escapeXml(profile.title)}</title>
-    <link>https://catpea.com/</link>
-    <description>${escapeXml(profile.title)} - Latest Posts</description>
-    <language>en-us</language>
-    <lastBuildDate>${buildDate}</lastBuildDate>
-    <atom:link href="https://catpea.com/feed.xml" rel="self" type="application/rss+xml"/>
-${sortedPosts.slice(0, 50).map(post => `    <item>
-      <title>${escapeXml(post.postData.title || post.postId)}</title>
-      <link>https://catpea.com/permalink/${post.guid}/</link>
-      <guid isPermaLink="true">https://catpea.com/permalink/${post.guid}/</guid>
-      <pubDate>${new Date(post.postData.date).toUTCString()}</pubDate>
-      ${post.postData.description ? `<description>${escapeXml(post.postData.description)}</description>` : ''}
-      ${post.coverUrl ? `<enclosure url="https://catpea.com${post.coverUrl}" type="image/avif"/>` : ''}
-    </item>`).join('\n')}
-  </channel>
-</rss>`;
-
-  await writeFile(destPath, xml);
-  console.log(`  [feed] Generated feed.xml with ${Math.min(sortedPosts.length, 50)} items`);
-  return { items: Math.min(sortedPosts.length, 50) };
-}
-
-// ─────────────────────────────────────────────
-// Finalize transform (homepage + pagerizer + feed)
-// ─────────────────────────────────────────────
-
-function finalize(config) {
-  const { homePP = 12, pagerPP = 24 } = config;
-  let expectedTotal = null;
-  const collected = [];
-
-  return async (send, packet) => {
-    // Track total from scanner
-    if (packet._totalPosts !== undefined) {
-      expectedTotal = packet._totalPosts;
-    }
-
-    collected.push(packet);
-
-    // Check if we've collected all posts
-    if (expectedTotal !== null && collected.length >= expectedTotal) {
-      // Get valid posts sorted newest first for homepage
-      const validPosts = processedPosts.filter(p => p.valid);
-      const sortedNewestFirst = [...validPosts].sort((a, b) =>
-        new Date(b.postData.date) - new Date(a.postData.date)
-      );
-
-      // Generate archive pages (returns page count)
-      const pagerResult = await generatePaginatedPages(validPosts, { pp: pagerPP });
-
-      // Generate homepage with link to archive
-      await generateHomepage(sortedNewestFirst, pagerResult.pages, { pp: homePP });
-
-      // Generate RSS feed
-      await generateFeed(sortedNewestFirst);
-
-      send({
-        _complete: true,
-        pagerized: true,
-        homepageGenerated: true,
-        feedGenerated: true,
-        totalPages: pagerResult.pages
-      });
-    } else {
-      send({ ...packet, _complete: false });
-    }
-  };
-}
-
-// ─────────────────────────────────────────────
-// Build the filtergraph
+// Filtergraph
 // ─────────────────────────────────────────────
 
 console.log(`\nMuriel Blog Builder`);
@@ -785,28 +41,30 @@ console.log(`Profile: ${profile.profile}`);
 console.log(`Title: ${profile.title}`);
 console.log(`─────────────────────────────────────────────\n`);
 
-const blog = flow(
-  [
-    [scanner(profile.src), 'post'],
+const blog = flow([
 
-    ['post', [
-      processCover(profile.cover),
-      processAudio(profile.audio),
-      copyFiles()
-    ], processText(), verify(), collector(), 'done'],
+  [postScanner(profile.src), 'post'],
 
-    ['done', finalize({ homePP: 12, pagerPP: 24 }), 'finished']
+  ['post',
+    [processCover(profile.cover), processAudio(profile.audio), copyFiles()],
+    processText(),
+    verifyPost(),
+    collectPost(),
+  'done'],
 
-  ],
-  {
-    context: { profile }
-  }
-);
+  ['done',
+    [homepage({ pp: 12 }), pagerizer({ pp: 24 }), rssFeed()],
+  'finished'],
+
+], { context: { profile } });
+
+// ─────────────────────────────────────────────
+// Completion
+// ─────────────────────────────────────────────
 
-// Listen for completion on the 'finished' pipe
 blog.on('finished', packet => {
-  // Only handle the final completion packet
-  if (!packet._complete) return;
+  const allComplete = packet.branches?.every(b => b._complete);
+  if (!allComplete) return;
 
   console.log(`\n─────────────────────────────────────────────`);
   console.log(`Summary: ${processedPosts.length} posts processed`);