poops 1.2.2 → 1.2.4

package/lib/markup/engines/liquid.js

@@ -3,7 +3,8 @@ import path from 'node:path'
 import { Liquid } from 'liquidjs'
 import { Marked } from 'marked'
 import { highlightRenderer, highlightCode } from '../highlight.js'
-import { discoverImageVariants, parseFrontMatter } from '../helpers.js'
+import { discoverImageVariants, parseFrontMatter, groupby, decodeTemplateEntities, buildImageTag } from '../helpers.js'
+import { getImageExif, listImages } from '../image-cache.js'
 import { slugify } from 'book-of-spells'
 import dayjs from 'dayjs'
 
@@ -75,6 +76,15 @@ export default class LiquidEngine {
       if (variants.length === 0) return ''
       return variants.map(v => `${v.path} ${v.width}w`).join(', ')
     })
+    engine.registerFilter('exif', (imagePath) => {
+      const outputDir = path.join(process.cwd(), markupOut)
+      return getImageExif(imagePath, outputDir)
+    })
+    engine.registerFilter('images', (dirPath) => {
+      const outputDir = path.join(process.cwd(), markupOut)
+      return listImages(dirPath, outputDir)
+    })
+    engine.registerFilter('groupby', (arr, key, datePart) => groupby(arr, key, datePart))
     engine.registerFilter('highlight', (code, lang) => {
       const highlighted = highlightCode(code, lang)
       const langClass = lang ? ` language-${lang}` : ''
@@ -92,13 +102,17 @@ export default class LiquidEngine {
     this.globals[key] = value
   }
 
+  removeGlobal(key) {
+    delete this.globals[key]
+  }
+
   async render(templateName, context) {
     let source
     const frontMatterResult = parseFrontMatter(templateName)
     source = frontMatterResult.content
 
     if (path.extname(templateName) === '.md') {
-      source = marked.parse(source)
+      source = decodeTemplateEntities(marked.parse(source))
     }
 
     const frontMatter = context.page || {}
@@ -188,32 +202,7 @@ function registerImageTag(engine, getOutputDir) {
       }
 
       const prefix = (yield ctx.get(['relativePathPrefix'])) || ''
-      const alt = kwargs.alt || ''
-      const loading = kwargs.loading || 'lazy'
-      const isSvg = imagePath.endsWith('.svg')
-      const attrs = [`alt="${alt}"`]
-
-      if (isSvg) {
-        attrs.unshift(`src="${prefix}${imagePath}"`)
-      } else {
-        const outputDir = getOutputDir()
-        const { src, variants } = discoverImageVariants(imagePath, outputDir)
-        const sizes = kwargs.sizes || '100vw'
-        attrs.unshift(`src="${prefix}${src}"`)
-        if (variants.length > 0) {
-          const srcsetVal = variants.map(v => `${prefix}${v.path} ${v.width}w`).join(', ')
-          attrs.push(`srcset="${srcsetVal}"`)
-          attrs.push(`sizes="${sizes}"`)
-        }
-      }
-
-      attrs.push(`loading="${loading}"`)
-      const skip = new Set(['alt', 'sizes', 'loading'])
-      for (const [key, val] of Object.entries(kwargs)) {
-        if (skip.has(key)) continue
-        attrs.push(`${key}="${val}"`)
-      }
-      return `<img ${attrs.join(' ')}>`
+      return buildImageTag(imagePath, prefix, kwargs, getOutputDir)
     }
   })
 }

package/lib/markup/engines/nunjucks.js

@@ -3,7 +3,9 @@ import { globSync } from 'glob'
 import { Marked } from 'marked'
 import nunjucks from 'nunjucks'
 import path from 'node:path'
-import { discoverImageVariants, parseFrontMatter } from '../helpers.js'
+import { discoverImageVariants, parseFrontMatter, groupby, decodeTemplateEntities, buildImageTag } from '../helpers.js'
+import { getImageExif, listImages } from '../image-cache.js'
+import { toPosix } from '../../utils/helpers.js'
 import { highlightRenderer, highlightCode } from '../highlight.js'
 import { slugify } from 'book-of-spells'
 import dayjs from 'dayjs'
@@ -26,7 +28,7 @@ class RelativeLoader extends nunjucks.Loader {
       if (this.includePaths) {
         pattern = `{${this.includePaths.join(',')}}/${pattern}`
       }
-      fullPath = globSync(path.join(this.templatesDir, pattern))[0]
+      fullPath = globSync(toPosix(path.join(this.templatesDir, pattern)))[0]
     }
     if (!fs.existsSync(fullPath)) {
       log({ tag: 'markup', error: true, text: 'Template not found:', link: name })
@@ -46,7 +48,7 @@ class RelativeLoader extends nunjucks.Loader {
     }
 
     if (path.extname(fullPath) === '.md') {
-      source = marked.parse(source)
+      source = decodeTemplateEntities(marked.parse(source))
     }
 
     if (frontMatter.layout) {
@@ -108,6 +110,15 @@ export default class NunjucksEngine {
       if (variants.length === 0) return ''
       return variants.map(v => `${v.path} ${v.width}w`).join(', ')
     })
+    env.addFilter('exif', (imagePath) => {
+      const outputDir = path.join(process.cwd(), markupOut)
+      return getImageExif(imagePath, outputDir)
+    })
+    env.addFilter('images', (dirPath) => {
+      const outputDir = path.join(process.cwd(), markupOut)
+      return listImages(dirPath, outputDir)
+    })
+    env.addFilter('groupby', (arr, key, datePart) => groupby(arr, key, datePart))
     env.addFilter('highlight', (code, lang) => {
       const highlighted = highlightCode(code, lang)
       const langClass = lang ? ` language-${lang}` : ''
@@ -125,6 +136,10 @@ export default class NunjucksEngine {
     this.env.addGlobal(key, value)
   }
 
+  removeGlobal(key) {
+    delete this.env.globals[key]
+  }
+
   render(templateName, context) {
     return new Promise((resolve, reject) => {
       this.env.getTemplate(templateName).render(context, (error, result) => {
@@ -152,7 +167,7 @@ export default class NunjucksEngine {
 
 // --- Nunjucks Extensions ---
 
-class GoogleFontsExtension {
+export class GoogleFontsExtension {
   constructor() { this.tags = ['googleFonts'] }
 
   parse(parser, nodes) {
@@ -195,7 +210,7 @@ class GoogleFontsExtension {
   }
 }
 
-class ImageExtension {
+export class ImageExtension {
   constructor(getOutputDir) { this.tags = ['image']; this.getOutputDir = getOutputDir }
 
   parse(parser, nodes) {
@@ -207,38 +222,11 @@ class ImageExtension {
 
   run(context, imagePath, kwargs) {
     const prefix = context.lookup('relativePathPrefix') || ''
-    const alt = (kwargs && kwargs.alt) || ''
-    const loading = (kwargs && kwargs.loading) || 'lazy'
-    const isSvg = imagePath.endsWith('.svg')
-    const attrs = [`alt="${alt}"`]
-
-    if (isSvg) {
-      attrs.unshift(`src="${prefix}${imagePath}"`)
-    } else {
-      const outputDir = this.getOutputDir()
-      const { src, variants } = discoverImageVariants(imagePath, outputDir)
-      const sizes = (kwargs && kwargs.sizes) || '100vw'
-      attrs.unshift(`src="${prefix}${src}"`)
-      if (variants.length > 0) {
-        const srcsetVal = variants.map(v => `${prefix}${v.path} ${v.width}w`).join(', ')
-        attrs.push(`srcset="${srcsetVal}"`)
-        attrs.push(`sizes="${sizes}"`)
-      }
-    }
-
-    attrs.push(`loading="${loading}"`)
-    if (kwargs) {
-      const skip = new Set(['alt', 'sizes', 'loading'])
-      for (const [key, val] of Object.entries(kwargs)) {
-        if (key.startsWith('__') || skip.has(key)) continue
-        attrs.push(`${key}="${val}"`)
-      }
-    }
-    return new nunjucks.runtime.SafeString(`<img ${attrs.join(' ')}>`)
+    return new nunjucks.runtime.SafeString(buildImageTag(imagePath, prefix, kwargs, this.getOutputDir))
   }
 }
 
-class HighlightExtension {
+export class HighlightExtension {
   constructor() { this.tags = ['highlight'] }
 
   parse(parser, nodes) {

package/lib/markup/helpers.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import yaml from 'yaml'
+import { toPosix } from '../utils/helpers.js'
+import { getImageEntry } from './image-cache.js'
 
 const frontMatterCache = new Map()
 
@@ -58,9 +60,139 @@ export function clearFrontMatterCache(filePath) {
   frontMatterCache.delete(filePath)
 }
 
+export function wordcount(text) {
+  if (!text) return 0
+  // eslint-disable-next-line no-useless-escape
+  const stripped = text.replace(/<[^>]*>/g, ' ').replace(/[#*_`~\[\]()>|{}\\-]/g, ' ')
+  const words = stripped.match(/\S+/g)
+  return words ? words.length : 0
+}
+
+// marked HTML-encodes quotes/brackets in template tags it treats as prose,
+// breaking string args like groupby("date"). Decode entities inside {{ }} / {% %}
+// after markdown, before the template engine parses. Decode &amp; last so
+// &amp;lt; doesn't double-decode into <.
+export function decodeTemplateEntities(html) {
+  return html.replace(/(\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\})/g, (tag) =>
+    tag
+      .replace(/&quot;/g, '"')
+      .replace(/&#39;/g, "'")
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>')
+      .replace(/&amp;/g, '&')
+  )
+}
+
+export function groupby(arr, key, datePart) {
+  if (!Array.isArray(arr)) return []
+
+  const map = new Map()
+  for (const item of arr) {
+    let value = item[key]
+    if (datePart && value) {
+      const date = new Date(value)
+      if (!isNaN(date)) {
+        switch (datePart) {
+          case 'year': value = date.getUTCFullYear(); break
+          case 'month': value = date.getUTCMonth() + 1; break
+          case 'day': value = date.getUTCDate(); break
+        }
+      }
+    }
+    const groupKey = value != null ? String(value) : ''
+    if (!map.has(groupKey)) map.set(groupKey, [])
+    map.get(groupKey).push(item)
+  }
+
+  return Array.from(map, ([key, items]) => ({ key, items }))
+}
+
 const FORMAT_PRIORITY = ['avif', 'webp']
 
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+// jpeg sources compile to .jpg variants — same format for grouping purposes
+function normalizeFormat(fmt) {
+  return fmt === 'jpeg' ? 'jpg' : fmt
+}
+
+// Pick best format for srcset (highest priority format that has variants)
+// and the middle-sized original-format variant as the src fallback.
+function pickSrcsetAndSrc(variants, originalExt) {
+  originalExt = normalizeFormat(originalExt)
+  variants.sort((a, b) => a.width - b.width)
+
+  const availableFormats = new Set(variants.map(v => normalizeFormat(v.format)))
+  let srcsetFormat = null
+  for (const fmt of FORMAT_PRIORITY) {
+    if (availableFormats.has(fmt)) {
+      srcsetFormat = fmt
+      break
+    }
+  }
+  if (!srcsetFormat && availableFormats.has(originalExt)) {
+    srcsetFormat = originalExt
+  }
+  if (!srcsetFormat && availableFormats.size > 0) {
+    srcsetFormat = [...availableFormats][0]
+  }
+
+  const srcsetVariants = srcsetFormat ? variants.filter(v => normalizeFormat(v.format) === srcsetFormat) : []
+
+  const originalVariants = variants.filter(v => normalizeFormat(v.format) === originalExt)
+  let srcVariant = null
+  if (originalVariants.length > 0) {
+    srcVariant = originalVariants[Math.floor((originalVariants.length - 1) / 2)]
+  } else if (srcsetVariants.length > 0) {
+    srcVariant = srcsetVariants[Math.floor((srcsetVariants.length - 1) / 2)]
+  }
+
+  return { srcVariant, srcsetVariants }
+}
+
+// Variant discovery from the poops-images compile cache: exact output paths
+// and dimensions, no directory scan. Only `{name}-{width}w.{ext}` outputs are
+// srcset material — named sizes (`-thumb-200w`) and preprocessed outputs
+// (`-blurred-...`) are crops or effects with their own aspect ratios.
+function discoverImageVariantsFromCache(imagePath, outputDir) {
+  const found = getImageEntry(imagePath, outputDir)
+  if (!found) return null
+
+  const { entry, prefixDir } = found
+  const parsed = path.parse(imagePath)
+  const originalExt = parsed.ext.replace('.', '')
+  const variantPattern = new RegExp(`^${escapeRegExp(parsed.name)}-(\\d+)w\\.([a-z0-9]+)$`)
+  const basePattern = new RegExp(`^${escapeRegExp(parsed.name)}\\.([a-z0-9]+)$`)
+
+  const variants = []
+  let base = null
+  for (const out of entry.outputs || []) {
+    const file = path.posix.basename(toPosix(out.path))
+    const sitePath = prefixDir ? toPosix(path.join(prefixDir, out.path)) : toPosix(out.path)
+    let match = file.match(variantPattern)
+    if (match) {
+      variants.push({ path: sitePath, width: parseInt(match[1], 10), height: out.height, format: match[2] })
+      continue
+    }
+    match = file.match(basePattern)
+    if (match && !base) {
+      base = { path: sitePath, width: out.width, height: out.height }
+    }
+  }
+
+  const { srcVariant, srcsetVariants } = pickSrcsetAndSrc(variants, originalExt)
+  // Base output fixes the src extension when the source was converted (heic → jpg)
+  const src = srcVariant || base || { path: imagePath }
+
+  return { src: src.path, variants: srcsetVariants, width: src.width, height: src.height }
+}
+
 export function discoverImageVariants(imagePath, outputDir) {
+  const fromCache = discoverImageVariantsFromCache(imagePath, outputDir)
+  if (fromCache) return fromCache
+
   const parsed = path.parse(imagePath)
   const dir = path.join(outputDir, parsed.dir)
   const baseName = parsed.name
@@ -81,44 +213,14 @@ export function discoverImageVariants(imagePath, outputDir) {
     const [, name, widthStr, format] = match
     if (name !== baseName) continue
     variants.push({
-      path: path.join(parsed.dir, file),
+      path: toPosix(path.join(parsed.dir, file)),
       width: parseInt(widthStr, 10),
       format
     })
   }
 
-  variants.sort((a, b) => a.width - b.width)
-
-  // Pick best format for srcset: highest priority format that has variants
-  const availableFormats = new Set(variants.map(v => v.format))
-  let srcsetFormat = null
-  for (const fmt of FORMAT_PRIORITY) {
-    if (availableFormats.has(fmt)) {
-      srcsetFormat = fmt
-      break
-    }
-  }
-  if (!srcsetFormat && availableFormats.has(originalExt)) {
-    srcsetFormat = originalExt
-  }
-  if (!srcsetFormat && availableFormats.size > 0) {
-    srcsetFormat = [...availableFormats][0]
-  }
-
-  const srcsetVariants = srcsetFormat ? variants.filter(v => v.format === srcsetFormat) : []
-
-  // Pick middle-sized variant in original format for src fallback
-  const originalVariants = variants.filter(v => v.format === originalExt)
-  let src = imagePath
-  if (originalVariants.length > 0) {
-    const mid = Math.floor((originalVariants.length - 1) / 2)
-    src = originalVariants[mid].path
-  } else if (srcsetVariants.length > 0) {
-    const mid = Math.floor((srcsetVariants.length - 1) / 2)
-    src = srcsetVariants[mid].path
-  }
-
-  return { src, variants: srcsetVariants }
+  const { srcVariant, srcsetVariants } = pickSrcsetAndSrc(variants, originalExt)
+  return { src: srcVariant ? srcVariant.path : imagePath, variants: srcsetVariants }
 }
 
 export function replaceOutExtensions(outputPath) {
@@ -153,8 +255,9 @@ export function getRelativePathPrefix(outputDir, fromDir, baseURL) {
     return baseURL.endsWith('/') ? baseURL : baseURL + '/'
   }
 
-  let relativeDir = path.relative(process.cwd(), outputDir)
-  const fromRelativeDir = fromDir ? path.relative(process.cwd(), fromDir) : ''
+  // getUpDirPrefix splits on `/`, so normalize away native separators
+  let relativeDir = toPosix(path.relative(process.cwd(), outputDir))
+  const fromRelativeDir = fromDir ? toPosix(path.relative(process.cwd(), fromDir)) : ''
 
   if (fromRelativeDir && relativeDir.startsWith(fromRelativeDir)) {
     relativeDir = relativeDir.replace(fromRelativeDir, '')
@@ -165,10 +268,50 @@ export function getRelativePathPrefix(outputDir, fromDir, baseURL) {
 
 export function getPageUrl(outputPath) {
   outputPath = replaceOutExtensions(outputPath)
-  return /index\.[a-z]+$/.test(path.basename(outputPath)) ? path.relative(process.cwd(), path.dirname(outputPath)) : path.relative(process.cwd(), outputPath)
+  return toPosix(/index\.[a-z]+$/.test(path.basename(outputPath)) ? path.relative(process.cwd(), path.dirname(outputPath)) : path.relative(process.cwd(), outputPath))
 }
 
 export function getPageUrlRelativeToOutput(outputPath, outputDir) {
   const pageUrl = getPageUrl(outputPath)
-  return path.relative(outputDir, pageUrl)
+  return toPosix(path.relative(outputDir, pageUrl))
+}
+
+export function escapeAttr(value) {
+  return String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;')
+}
+
+// Shared by the nunjucks and liquid `image` tags — attribute values may come
+// from front-matter/user data, so they are escaped here, once for both engines.
+export function buildImageTag(imagePath, prefix, kwargs, getOutputDir) {
+  const alt = (kwargs && kwargs.alt) || ''
+  const loading = (kwargs && kwargs.loading) || 'lazy'
+  const isSvg = imagePath.endsWith('.svg')
+  const attrs = [`alt="${escapeAttr(alt)}"`]
+
+  if (isSvg) {
+    attrs.unshift(`src="${escapeAttr(prefix + imagePath)}"`)
+  } else {
+    const { src, variants, width, height } = discoverImageVariants(imagePath, getOutputDir())
+    const sizes = (kwargs && kwargs.sizes) || '100vw'
+    attrs.unshift(`src="${escapeAttr(prefix + src)}"`)
+    if (width && height && !(kwargs && (kwargs.width || kwargs.height))) {
+      attrs.push(`width="${width}"`, `height="${height}"`)
+    }
+    if (variants.length > 0) {
+      const srcsetVal = variants.map(v => `${prefix}${v.path} ${v.width}w`).join(', ')
+      attrs.push(`srcset="${escapeAttr(srcsetVal)}"`)
+      attrs.push(`sizes="${escapeAttr(sizes)}"`)
+    }
+  }
+
+  attrs.push(`loading="${escapeAttr(loading)}"`)
+  if (kwargs) {
+    const skip = new Set(['alt', 'sizes', 'loading'])
+    for (const [key, val] of Object.entries(kwargs)) {
+      // `__keywords` is nunjucks' kwargs marker, never a real attribute
+      if (key.startsWith('__') || skip.has(key)) continue
+      attrs.push(`${key}="${escapeAttr(val)}"`)
+    }
+  }
+  return `<img ${attrs.join(' ')}>`
 }

package/lib/markup/image-cache.js

@@ -0,0 +1,114 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { toPosix } from '../utils/helpers.js'
+
+// Compile cache written by poops-images (https://github.com/stamat/poops-images)
+// next to the images it generates. Holds exact output paths, dimensions and EXIF.
+const CACHE_FILENAME = '.poops-images-cache.json'
+
+const cacheFileCache = new Map()
+
+function readCacheFile(cachePath) {
+  let stat
+  try {
+    stat = fs.statSync(cachePath)
+  } catch {
+    return null
+  }
+
+  const cached = cacheFileCache.get(cachePath)
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return cached.data
+  }
+
+  let data = null
+  try {
+    data = JSON.parse(fs.readFileSync(cachePath, 'utf8'))
+  } catch {
+    return null
+  }
+
+  cacheFileCache.set(cachePath, { mtimeMs: stat.mtimeMs, size: stat.size, data })
+  return data
+}
+
+export function clearImageCache() {
+  cacheFileCache.clear()
+}
+
+// Finds the poops-images cache entry for a site-relative image path.
+// Walks from the image's directory up to outputDir, since the cache file sits
+// at the root of the images output dir, which may be a subdirectory of the
+// site output (e.g. dist/images/.poops-images-cache.json).
+// Returns { entry, prefixDir } where prefixDir is the cache dir relative to
+// outputDir (output paths in the cache are relative to the cache dir), or null.
+export function getImageEntry(imagePath, outputDir) {
+  const root = path.resolve(outputDir)
+  let dir = path.resolve(root, path.dirname(imagePath))
+  if (!dir.startsWith(root)) return null
+
+  const target = toPosix(path.relative(root, path.resolve(root, imagePath)))
+  const targetNoExt = target.replace(/\.[^./]+$/, '')
+
+  while (true) {
+    const data = readCacheFile(path.join(dir, CACHE_FILENAME))
+    if (data && data.entries) {
+      const prefixDir = toPosix(path.relative(root, dir))
+      const rel = prefixDir ? target.slice(prefixDir.length + 1) : target
+      let entry = data.entries[rel]
+      if (!entry) {
+        // Output extension may differ from the source key (heic → jpg, jpeg → jpg)
+        const relNoExt = prefixDir ? targetNoExt.slice(prefixDir.length + 1) : targetNoExt
+        for (const [key, value] of Object.entries(data.entries)) {
+          if (key.replace(/\.[^./]+$/, '') === relNoExt) {
+            entry = value
+            break
+          }
+        }
+      }
+      if (entry) return { entry, prefixDir }
+    }
+    if (dir === root) return null
+    dir = path.dirname(dir)
+  }
+}
+
+export function getImageExif(imagePath, outputDir) {
+  const found = getImageEntry(imagePath, outputDir)
+  return (found && found.entry.exif) || null
+}
+
+// Lists all cache entries under a site-relative directory, gallery-ready:
+// site-relative paths, `date` flattened from EXIF (file mtime fallback) so
+// engine-native sort and the groupby filter work without touching nested exif.
+export function listImages(dirPath, outputDir) {
+  const root = path.resolve(outputDir)
+  const clean = toPosix(dirPath || '').replace(/^\/+|\/+$/g, '')
+  let dir = path.resolve(root, clean)
+  if (!dir.startsWith(root)) return []
+
+  while (true) {
+    const data = readCacheFile(path.join(dir, CACHE_FILENAME))
+    if (data && data.entries) {
+      const prefixDir = toPosix(path.relative(root, dir))
+      const scope = toPosix(path.relative(dir, path.resolve(root, clean)))
+      const sitePath = (p) => prefixDir ? toPosix(path.join(prefixDir, p)) : toPosix(p)
+
+      const images = []
+      for (const [key, entry] of Object.entries(data.entries)) {
+        if (scope && !key.startsWith(scope + '/')) continue
+        images.push({
+          path: sitePath(key),
+          width: entry.width,
+          height: entry.height,
+          date: (entry.exif && entry.exif.dateTime) || (entry.mtime ? new Date(entry.mtime).toISOString() : null),
+          exif: entry.exif || null,
+          outputs: (entry.outputs || []).map(o => ({ ...o, path: sitePath(o.path) }))
+        })
+      }
+      return images
+    }
+    if (dir === root) return []
+    dir = path.dirname(dir)
+  }
+}

package/lib/markup/indexer.js

@@ -116,7 +116,9 @@ export function generateSearchIndex(pageEntries, outputDir, config) {
 
   entries = applyGlobalFrequencyCeiling(entries, config.globalFrequencyCeiling)
 
-  const outputPath = path.join(process.cwd(), outputDir, config.output)
+  // resolve, not join: outputDir may be absolute (join would mangle it,
+  // e.g. cross-drive temp dirs on Windows)
+  const outputPath = path.resolve(process.cwd(), outputDir, config.output)
   fs.writeFileSync(outputPath, JSON.stringify(entries, null, 2))
   log({ tag: 'indexer', text: 'Generated search index:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
 }
@@ -143,7 +145,9 @@ export function generateSitemap(pageEntries, outputDir, siteUrl, config) {
 
   xml += '</urlset>\n'
 
-  const outputPath = path.join(process.cwd(), outputDir, config.output)
+  // resolve, not join: outputDir may be absolute (join would mangle it,
+  // e.g. cross-drive temp dirs on Windows)
+  const outputPath = path.resolve(process.cwd(), outputDir, config.output)
   fs.writeFileSync(outputPath, xml)
   log({ tag: 'indexer', text: 'Generated sitemap:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
 }