poops 1.2.3 → 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, groupby, decodeTemplateEntities } 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,14 @@ 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)
@@ -93,6 +102,10 @@ export default class LiquidEngine {
     this.globals[key] = value
   }
 
+  removeGlobal(key) {
+    delete this.globals[key]
+  }
+
   async render(templateName, context) {
     let source
     const frontMatterResult = parseFrontMatter(templateName)
@@ -189,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, groupby, decodeTemplateEntities } 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 })
@@ -108,6 +110,14 @@ 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)
@@ -126,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) => {
@@ -208,34 +222,7 @@ export 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))
   }
 }
 

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()
 
@@ -107,7 +109,90 @@ export function groupby(arr, key, datePart) {
 
 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
@@ -128,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) {
@@ -200,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, '')
@@ -212,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) })
 }

package/lib/markups.js

@@ -1,4 +1,4 @@
-import { pathExists, pathIsDirectory, readDataFile, mkDir, buildTime } from './utils/helpers.js'
+import { pathExists, pathIsDirectory, readDataFile, mkDir, buildTime, toPosix } from './utils/helpers.js'
 import { replaceOutExtensions, getRelativePathPrefix, getPageUrl, getPageUrlRelativeToOutput, parseFrontMatter, clearFrontMatterCache, wordcount } from './markup/helpers.js'
 import { collectionAutoDiscovery, getCollectionDataBasedOnConfig, buildCollectionPaginationData, generateCollectionPaginationPages } from './markup/collections.js'
 import { generateIndexFiles } from './markup/indexer.js'
@@ -36,7 +36,6 @@ export default class Markups {
     this.searchIndexConfig = moduleConfig.options.searchIndex || moduleConfig.searchIndex
     this.sitemapConfig = moduleConfig.options.sitemap || moduleConfig.sitemap
     this.baseURL = moduleConfig.baseURL || moduleConfig.options.baseURL || null
-    this.dataFiles = []
 
     // Instantiate engine
     const EngineClass = ENGINES[engineName]
@@ -71,8 +70,8 @@ export default class Markups {
       }
     }
 
-    const data = moduleConfig.data || moduleConfig.options.data
-    this.loadDataFiles(data)
+    this.dataConfig = moduleConfig.data || moduleConfig.options.data
+    this.loadDataFiles(this.dataConfig)
 
     if (!moduleConfig.out) {
       moduleConfig.out = this.markupOut
@@ -92,7 +91,7 @@ export default class Markups {
     for (const file of files) {
       const fullPath = path.join(process.cwd(), dataDir, file)
       if (pathIsDirectory(fullPath)) {
-        const dirFiles = globSync(path.join(fullPath, '**/*.+(json|yml|yaml)'))
+        const dirFiles = globSync(toPosix(path.join(fullPath, '**/*.+(json|yml|yaml)')))
         for (const f of dirFiles) {
           resolved.push(path.relative(path.join(process.cwd(), dataDir), f))
         }
@@ -101,25 +100,59 @@ export default class Markups {
       }
     }
 
-    if (!this.dataFiles.length) this.dataFiles = resolved
-
+    const loadedKeys = new Set()
     for (const dataFile of resolved) {
       try {
         const data = readDataFile(path.join(process.cwd(), dataDir, dataFile))
         const globalKeyName = path.basename(dataFile, path.extname(dataFile)).replace(/[.\-\s]/g, '_')
         this.engine.setGlobal(globalKeyName, data)
+        loadedKeys.add(globalKeyName)
       } catch (err) {
         log({ tag: 'error', text: 'Data file not found:', link: dataFile })
         continue
       }
     }
+
+    // A deleted data file must also drop its global, or stale data renders forever
+    if (this.dataGlobalKeys) {
+      for (const key of this.dataGlobalKeys) {
+        if (!loadedKeys.has(key)) this.engine.removeGlobal(key)
+      }
+    }
+    this.dataGlobalKeys = loadedKeys
   }
 
   reloadDataFiles() {
-    this.loadDataFiles(this.dataFiles)
+    this.loadDataFiles(this.dataConfig)
     return Promise.resolve()
   }
 
+  // Maps a deleted source path to its build output and removes it.
+  // compile() only globs existing sources, so it can never clean up
+  // after a deletion — this is the only place stale output gets removed.
+  removeOutput(sourcePath) {
+    if (!this.engine) return
+    const markupIn = path.join(process.cwd(), this.markupIn)
+    const rel = path.relative(markupIn, path.join(process.cwd(), sourcePath))
+    if (rel.startsWith('..') || path.isAbsolute(rel)) return
+
+    const mapped = path.join(process.cwd(), this.markupOut, rel)
+
+    // rel === '' with a directory output would be the whole out dir —
+    // never remove that, it also holds css/js from other modules
+    if (rel !== '' && fs.existsSync(mapped) && fs.statSync(mapped).isDirectory()) {
+      fs.rmSync(mapped, { recursive: true })
+      log({ tag: this.logTag, text: 'Removed:', link: path.relative(process.cwd(), mapped) })
+      return
+    }
+
+    const outFile = replaceOutExtensions(mapped)
+    if (fs.existsSync(outFile) && !fs.statSync(outFile).isDirectory()) {
+      fs.unlinkSync(outFile)
+      log({ tag: this.logTag, text: 'Removed:', link: path.relative(process.cwd(), outFile) })
+    }
+  }
+
   generateMarkupGlobPattern(excludes) {
     let markupDefaultExcludes = ['node_modules', '.git', '.svn', '.hg']
 
@@ -172,9 +205,10 @@ export default class Markups {
 
   async compileDirectory(markupIn, collectionData, pageEntries) {
     const markupStart = performance.now()
+    // glob patterns must use `/` — on Windows `\` is an escape character
     const markupFiles = [
-      ...globSync(path.join(markupIn, this.generateMarkupGlobPattern(this.includePaths))),
-      ...globSync(path.join(markupIn, `*.+(${this.engine.markupExtensions})`))
+      ...globSync(toPosix(path.join(markupIn, this.generateMarkupGlobPattern(this.includePaths)))),
+      ...globSync(toPosix(path.join(markupIn, `*.+(${this.engine.markupExtensions})`)))
     ]
     const compilePromises = []
     const indexableExtensions = this.engine.indexableExtensions
@@ -302,6 +336,16 @@ export default class Markups {
     if (!moduleConfig || !moduleConfig.in) return
 
     if (this.config.reactorData) {
+      // A removed reactor component must also drop its injected global,
+      // same staleness rule as data files in loadDataFiles()
+      const reactorKeys = new Set(Object.keys(this.config.reactorData))
+      if (this.reactorGlobalKeys) {
+        for (const key of this.reactorGlobalKeys) {
+          if (!reactorKeys.has(key)) this.engine.removeGlobal(key)
+        }
+      }
+      this.reactorGlobalKeys = reactorKeys
+
       for (const [name, html] of Object.entries(this.config.reactorData)) {
         this.engine.setGlobal(name, html)
       }