poops 1.2.4 → 1.4.0

package/lib/markup/indexer.js

@@ -152,7 +152,159 @@ export function generateSitemap(pageEntries, outputDir, siteUrl, config) {
   log({ tag: 'indexer', text: 'Generated sitemap:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
 }
 
+function humanizeSegment(seg) {
+  return seg
+    .replace(/[-_]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/\b\w/g, c => c.toUpperCase())
+}
+
+function navNodeTitle(entry) {
+  return entry.navTitle || entry.title
+}
+
+// Applies the `collections` option (true | false | ["name"] | "index") on top
+// of the base exclusions (nav:false, and isIndex pages which are collection
+// landing/pagination). "index" is the exception that re-admits each
+// collection's first landing page as a single leaf.
+function navFilterEntries(pageEntries, collectionsOpt) {
+  const mode = collectionsOpt === undefined ? true : collectionsOpt
+  const allowlist = Array.isArray(mode) ? new Set(mode) : null
+  const result = []
+
+  for (const e of pageEntries) {
+    if (e.nav === false) continue
+
+    if (e.isIndex) {
+      // collection landing (url === name, no slash) kept only in "index" mode;
+      // pagination pages (url has a slash) always dropped. Landing titles are
+      // the raw collection name ("blog"), so humanize for display.
+      if (mode === 'index' && !e.url.includes('/')) {
+        result.push({ ...e, title: humanizeSegment(e.title) })
+      }
+      continue
+    }
+
+    if (e.collection != null) {
+      if (mode === false || mode === 'index') continue
+      if (allowlist && !allowlist.has(e.collection)) continue
+    }
+    result.push(e)
+  }
+
+  return result
+}
+
+function insertNavNode(root, entry) {
+  let cursor = root
+  for (const seg of entry.url.split('/')) {
+    if (!cursor.children.has(seg)) {
+      cursor.children.set(seg, { segment: seg, children: new Map() })
+    }
+    cursor = cursor.children.get(seg)
+  }
+  cursor.hasPage = true
+  cursor.url = entry.url
+  cursor.title = navNodeTitle(entry)
+  if (entry.order != null) cursor.order = entry.order
+}
+
+function getNavNode(root, urlPath) {
+  let cursor = root
+  for (const seg of urlPath.split('/')) {
+    cursor = cursor.children.get(seg)
+    if (!cursor) return null
+  }
+  return cursor
+}
+
+function sortNavSiblings(nodes) {
+  nodes.sort((a, b) => {
+    const oa = a.order != null ? a.order : Infinity
+    const ob = b.order != null ? b.order : Infinity
+    if (oa !== ob) return oa - ob
+    return String(a.title).localeCompare(String(b.title))
+  })
+}
+
+// Post-order: children are serialized (and thus order-resolved) before the
+// parent, so a virtual parent can borrow its first child's order.
+function serializeNavNode(node) {
+  const children = [...node.children.values()].map(serializeNavNode)
+  sortNavSiblings(children)
+
+  const out = { title: node.title != null ? node.title : humanizeSegment(node.segment) }
+  if (node.url != null) out.url = node.url
+
+  let order = node.order
+  if (order == null && !node.hasPage && children.length) order = children[0].order
+  if (order != null) out.order = order
+
+  if (children.length) out.children = children
+  return out
+}
+
+export function buildNavTree(pageEntries, config = {}) {
+  const { collections, home, root } = config
+  let entries = navFilterEntries(pageEntries, collections)
+
+  if (root != null) {
+    const prefix = root + '/'
+    entries = entries.filter(e => e.url === root || e.url.startsWith(prefix))
+  } else if (home === false) {
+    entries = entries.filter(e => e.url !== '')
+  }
+
+  const tree = { children: new Map() }
+  let homeEntry = null
+  for (const entry of entries) {
+    // root index page (url '') can't be segment-split — it would corrupt the
+    // tree; handle it as a top-level leaf instead
+    if (entry.url === '') { homeEntry = entry; continue }
+    insertNavNode(tree, entry)
+  }
+
+  // root scoping: emit the section's children unwrapped to the top level, with
+  // the section's own index page (if any) pinned first as the overview link
+  if (root != null) {
+    const rootNode = getNavNode(tree, root)
+    if (!rootNode) return []
+    const top = [...rootNode.children.values()].map(serializeNavNode)
+    sortNavSiblings(top)
+    if (rootNode.hasPage) {
+      const overview = { title: rootNode.title, url: rootNode.url }
+      if (rootNode.order != null) overview.order = rootNode.order
+      top.unshift(overview)
+    }
+    return top
+  }
+
+  const top = [...tree.children.values()].map(serializeNavNode)
+  if (homeEntry) {
+    const node = { title: navNodeTitle(homeEntry), url: '' }
+    if (homeEntry.order != null) node.order = homeEntry.order
+    top.push(node)
+  }
+  sortNavSiblings(top)
+  return top
+}
+
+export function generateNav(pageEntries, outputDir, config) {
+  config = normalizeConfig(config)
+  if (!config) return
+
+  const tree = buildNavTree(pageEntries, config)
+
+  // 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(tree, null, 2))
+  log({ tag: 'indexer', text: 'Generated nav:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
+}
+
 export function generateIndexFiles(pageEntries, outputDir, siteUrl, config) {
   generateSearchIndex(pageEntries, outputDir, config.searchIndex)
   generateSitemap(pageEntries, outputDir, siteUrl, config.sitemap)
+  generateNav(pageEntries, outputDir, config.nav)
 }

package/lib/markup/renderer.js

@@ -0,0 +1,68 @@
+import { Marked } from 'marked'
+import { markedGithubEmoji } from 'marked-github-emoji'
+import { markedGithubAlerts } from 'marked-github-alerts'
+import { slugify } from 'book-of-spells'
+import { highlightRenderer, highlightCode } from './highlight.js'
+import { decodeTemplateEntities } from './helpers.js'
+
+const RAW_BLOCK_RE = /\{%-?\s*raw\s*-?%\}([\s\S]*?)\{%-?\s*endraw\s*-?%\}/g
+
+// Applies `outside` to the text between {% raw %} blocks and `inside` to each
+// block's inner content, re-emitting the delimiters untouched so the template
+// engine still sees them. The two places that would otherwise mangle raw
+// content route through this: fence highlighting and entity decoding.
+function mapRawSegments(str, outside, inside) {
+  RAW_BLOCK_RE.lastIndex = 0
+  let out = ''
+  let last = 0
+  for (const m of str.matchAll(RAW_BLOCK_RE)) {
+    out += outside(str.slice(last, m.index))
+    out += `{% raw %}${inside(m[1])}{% endraw %}`
+    last = m.index + m[0].length
+  }
+  return out + outside(str.slice(last))
+}
+
+// The marked renderer used across the markup engines: syntax highlighting
+// (from highlight.js) plus heading slug ids + permalink anchors.
+export const markdownRenderer = {
+  ...highlightRenderer,
+  // Fenced code goes through hljs, which wraps `{`/`%` in their own spans —
+  // splitting a {% raw %} tag so the template engine never sees it and
+  // evaluates the "raw" content (e.g. a {{ name }} in a config sample rendered
+  // as empty). Highlight around/inside each raw block instead, keeping the
+  // fence's language, and pass the delimiters through intact. Inline code
+  // never splits the delimiters, so it needs no special casing.
+  code(code, lang) {
+    const highlighted = mapRawSegments(code, (s) => s && highlightCode(s, lang), (s) => highlightCode(s, lang))
+    const langClass = lang ? ` language-${lang.replace(/[^\w-]/g, '')}` : ''
+    return `<pre><code class="hljs${langClass}">${highlighted}</code></pre>\n`
+  },
+  // Give every heading a slug id + a permalink anchor. The anchor is empty on
+  // purpose — themes reveal a "#" via `.heading-anchor::before`, so a site with
+  // no such CSS renders an invisible anchor instead of a stray "#".
+  // ponytail: no slug dedup — two identical headings on one page share an id;
+  // add a per-parse counter if that ever bites.
+  heading(text, level, raw) {
+    const id = slugify(raw || '')
+    if (!id) return `<h${level}>${text}</h${level}>\n`
+    return `<h${level} id="${id}">${text}<a class="heading-anchor" href="#${id}" aria-label="Permalink" aria-hidden="true"></a></h${level}>\n`
+  }
+}
+
+// One shared instance so both engines render markdown identically.
+export const marked = new Marked({ renderer: markdownRenderer })
+marked.use(markedGithubEmoji())
+marked.use(markedGithubAlerts({
+  alerts: {
+    info: { title: 'Info', icon: 'info' }
+  }
+}))
+
+// Renders a markdown page source for the template engines. Entity decoding
+// (which un-escapes inside {{ }} / {% %} so template args parse) must skip
+// raw blocks — their content is for display, so its entities have to survive
+// to the browser.
+export function renderMarkdown(source) {
+  return mapRawSegments(marked.parse(source), decodeTemplateEntities, (s) => s)
+}

package/lib/markups.js

@@ -1,12 +1,14 @@
 import { pathExists, pathIsDirectory, readDataFile, mkDir, buildTime, toPosix } from './utils/helpers.js'
-import { replaceOutExtensions, getRelativePathPrefix, getPageUrl, getPageUrlRelativeToOutput, parseFrontMatter, clearFrontMatterCache, wordcount } from './markup/helpers.js'
+import { replaceOutExtensions, getRelativePathPrefix, getPageUrlRelativeToOutput, parseFrontMatter, clearFrontMatterCache, wordcount } from './markup/helpers.js'
 import { collectionAutoDiscovery, getCollectionDataBasedOnConfig, buildCollectionPaginationData, generateCollectionPaginationPages } from './markup/collections.js'
-import { generateIndexFiles } from './markup/indexer.js'
+import { generateIndexFiles, buildNavTree } from './markup/indexer.js'
 import NunjucksEngine from './markup/engines/nunjucks.js'
 import LiquidEngine from './markup/engines/liquid.js'
 import fs from 'node:fs'
 import { globSync } from 'glob'
 import path from 'node:path'
+import { createRequire } from 'node:module'
+import { pathToFileURL } from 'node:url'
 import log from './utils/log.js'
 
 const ENGINES = {
@@ -22,8 +24,8 @@ export default class Markups {
     if (!moduleConfig || !moduleConfig.in) return
     if (!moduleConfig.options) moduleConfig.options = {}
 
-    // Determine engine
-    const engineName = moduleConfig.engine || moduleConfig.options.engine || 'nunjucks'
+    // Determine engine — resolved in init(), builtin name or importable module
+    this.engineName = moduleConfig.engine || moduleConfig.options.engine || 'nunjucks'
     this.logTag = 'markup'
 
     // Normalize config
@@ -35,22 +37,54 @@ export default class Markups {
     this.includePaths = moduleConfig.includePaths || moduleConfig.options.includePaths || []
     this.searchIndexConfig = moduleConfig.options.searchIndex || moduleConfig.searchIndex
     this.sitemapConfig = moduleConfig.options.sitemap || moduleConfig.sitemap
+    this.navConfig = moduleConfig.options.nav || moduleConfig.nav
     this.baseURL = moduleConfig.baseURL || moduleConfig.options.baseURL || null
 
-    // Instantiate engine
-    const EngineClass = ENGINES[engineName]
+    this.autoescape = moduleConfig.autoescape || moduleConfig.options.autoescape || false
+    this.dataConfig = moduleConfig.data || moduleConfig.options.data
+
+    if (!moduleConfig.out) {
+      moduleConfig.out = this.markupOut
+    }
+  }
+
+  // Engine instantiation is async because non-builtin engines are loaded via
+  // dynamic import. Idempotent; compile() calls it lazily, so a failed engine
+  // resolution logs once per compile and the module stays inert.
+  async init() {
+    if (!this.markupIn || this.engine) return
+
+    let EngineClass = ENGINES[this.engineName]
     if (!EngineClass) {
-      log({ tag: 'error', text: `Unknown markup engine: ${engineName}` })
+      try {
+        // Relative/absolute specifiers resolve against cwd (the user's
+        // project), bare specifiers against the module graph (node_modules)
+        const spec = /^[./]/.test(this.engineName) || path.isAbsolute(this.engineName)
+          ? pathToFileURL(path.resolve(process.cwd(), this.engineName)).href
+          : this.engineName
+        EngineClass = (await import(spec)).default
+      } catch {
+        // Bare specifier not reachable from poops's own module graph (e.g.
+        // poops installed via a file: link) — resolve from the user's project
+        try {
+          const projectRequire = createRequire(path.join(process.cwd(), 'package.json'))
+          EngineClass = (await import(pathToFileURL(projectRequire.resolve(this.engineName)).href)).default
+        } catch { /* handled below */ }
+      }
+    }
+
+    if (typeof EngineClass !== 'function') {
+      log({ tag: 'error', text: `Unknown markup engine: ${this.engineName}` })
       return
     }
 
-    const templatesDir = path.join(process.cwd(), this.markupIn)
+    const templatesDir = path.resolve(process.cwd(), this.markupIn)
     this.engine = new EngineClass(templatesDir, this.includePaths, {
-      autoescape: moduleConfig.autoescape || moduleConfig.options.autoescape || false
+      autoescape: this.autoescape
     })
 
     this.engine.registerFilters({ timeDateFormat: this.timeDateFormat, markupOut: this.markupOut })
-    this.engine.registerTags(() => path.join(process.cwd(), this.markupOut))
+    this.engine.registerTags(() => path.resolve(process.cwd(), this.markupOut))
 
     // Load global variables
     const pkgPath = path.join(process.cwd(), 'package.json')
@@ -70,12 +104,7 @@ export default class Markups {
       }
     }
 
-    this.dataConfig = moduleConfig.data || moduleConfig.options.data
     this.loadDataFiles(this.dataConfig)
-
-    if (!moduleConfig.out) {
-      moduleConfig.out = this.markupOut
-    }
   }
 
   loadDataFiles(files) {
@@ -89,11 +118,11 @@ export default class Markups {
     const dataDir = pathIsDirectory(this.markupIn) ? this.markupIn : path.dirname(this.markupIn)
     const resolved = []
     for (const file of files) {
-      const fullPath = path.join(process.cwd(), dataDir, file)
+      const fullPath = path.resolve(process.cwd(), dataDir, file)
       if (pathIsDirectory(fullPath)) {
         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))
+          resolved.push(path.relative(path.resolve(process.cwd(), dataDir), f))
         }
       } else {
         resolved.push(file)
@@ -103,7 +132,7 @@ export default class Markups {
     const loadedKeys = new Set()
     for (const dataFile of resolved) {
       try {
-        const data = readDataFile(path.join(process.cwd(), dataDir, dataFile))
+        const data = readDataFile(path.resolve(process.cwd(), dataDir, dataFile))
         const globalKeyName = path.basename(dataFile, path.extname(dataFile)).replace(/[.\-\s]/g, '_')
         this.engine.setGlobal(globalKeyName, data)
         loadedKeys.add(globalKeyName)
@@ -123,20 +152,29 @@ export default class Markups {
   }
 
   reloadDataFiles() {
-    this.loadDataFiles(this.dataConfig)
+    if (this.engine) this.loadDataFiles(this.dataConfig)
     return Promise.resolve()
   }
 
+  // Engines can override output extension mapping (e.g. a template format
+  // whose extension isn't in the default map); falls back to the shared helper
+  mapOutputPath(outputPath) {
+    if (this.engine && typeof this.engine.replaceOutExtensions === 'function') {
+      return this.engine.replaceOutExtensions(outputPath)
+    }
+    return replaceOutExtensions(outputPath)
+  }
+
   // 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 (!this.markupIn) return
+    const markupIn = path.resolve(process.cwd(), this.markupIn)
+    const rel = path.relative(markupIn, path.resolve(process.cwd(), sourcePath))
     if (rel.startsWith('..') || path.isAbsolute(rel)) return
 
-    const mapped = path.join(process.cwd(), this.markupOut, rel)
+    const mapped = path.resolve(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
@@ -146,7 +184,7 @@ export default class Markups {
       return
     }
 
-    const outFile = replaceOutExtensions(mapped)
+    const outFile = this.mapOutputPath(mapped)
     if (fs.existsSync(outFile) && !fs.statSync(outFile).isDirectory()) {
       fs.unlinkSync(outFile)
       log({ tag: this.logTag, text: 'Removed:', link: path.relative(process.cwd(), outFile) })
@@ -203,13 +241,72 @@ export default class Markups {
     return { result, frontMatter }
   }
 
-  async compileDirectory(markupIn, collectionData, pageEntries) {
-    const markupStart = performance.now()
+  getMarkupFiles(markupIn) {
     // glob patterns must use `/` — on Windows `\` is an escape character
-    const markupFiles = [
+    return [
       ...globSync(toPosix(path.join(markupIn, this.generateMarkupGlobPattern(this.includePaths)))),
       ...globSync(toPosix(path.join(markupIn, `*.+(${this.engine.markupExtensions})`)))
     ]
+  }
+
+  // True for collection index templates that compileDirectory skips —
+  // pagination renders them instead
+  isCollectionIndexOverride(relativePathParts, collectionData) {
+    return relativePathParts.length > 1 &&
+      collectionData[relativePathParts[0]] &&
+      relativePathParts[1].startsWith('index.') &&
+      this.engine.indexableExtensions.has(path.extname(relativePathParts[1])) &&
+      collectionData[relativePathParts[0]].items.length > 0
+  }
+
+  // Pre-pass: builds the nav tree from front matter alone (no rendering) and
+  // exposes it as the `nav` template global, so sidebars can render during the
+  // same compile instead of reading the previous build's nav.json.
+  // parseFrontMatter caches by mtime, so the compile pass re-reads nothing.
+  buildNavGlobal(markupIn, collectionData) {
+    if (!this.navConfig) return
+
+    const entries = []
+    for (const collectionName of Object.keys(collectionData)) {
+      entries.push({ url: collectionName, title: collectionName, isIndex: true })
+    }
+
+    const files = pathIsDirectory(markupIn) ? this.getMarkupFiles(markupIn) : [markupIn]
+    for (const file of files) {
+      if (!this.engine.indexableExtensions.has(path.extname(file))) continue
+      const relativePath = path.relative(markupIn, file)
+      const relativePathParts = relativePath.split(path.sep)
+      if (this.isCollectionIndexOverride(relativePathParts, collectionData)) continue
+
+      let frontMatter
+      try {
+        frontMatter = parseFrontMatter(file).frontMatter
+      } catch (err) {
+        continue
+      }
+      if (frontMatter.published === false) continue
+      if (!frontMatter.title) frontMatter.title = path.basename(file, path.extname(file))
+
+      const fileCollection = relativePathParts.length > 1 && collectionData[relativePathParts[0]]
+        ? relativePathParts[0]
+        : null
+      if (fileCollection && !frontMatter.collection) frontMatter.collection = fileCollection
+
+      const outPath = this.mapOutputPath(path.resolve(process.cwd(), this.markupOut, relativePath))
+      entries.push({
+        ...frontMatter,
+        url: getPageUrlRelativeToOutput(outPath, this.markupOut),
+        isIndex: false
+      })
+    }
+
+    const navOptions = typeof this.navConfig === 'object' ? this.navConfig : {}
+    this.engine.setGlobal('nav', buildNavTree(entries, navOptions))
+  }
+
+  async compileDirectory(markupIn, collectionData, pageEntries) {
+    const markupStart = performance.now()
+    const markupFiles = this.getMarkupFiles(markupIn)
     const compilePromises = []
     const indexableExtensions = this.engine.indexableExtensions
 
@@ -217,15 +314,14 @@ export default class Markups {
       const relativePath = path.relative(markupIn, file)
       const relativePathParts = relativePath.split(path.sep)
 
-      if (relativePathParts.length > 1 &&
-        collectionData[relativePathParts[0]] &&
-        relativePathParts[1].startsWith('index.') && indexableExtensions.has(path.extname(relativePathParts[1])) &&
-        collectionData[relativePathParts[0]].items.length > 0) {
+      if (this.isCollectionIndexOverride(relativePathParts, collectionData)) {
         continue
       }
 
-      let markupOut = path.join(process.cwd(), this.markupOut, relativePath)
-      const fromPath = path.join(process.cwd(), this.markupOut)
+      // Map before deriving dir/prefix: engines may relocate output (e.g.
+      // Shopify's templates/ flattening), and links must match the final path.
+      const markupOut = this.mapOutputPath(path.resolve(process.cwd(), this.markupOut, relativePath))
+      const fromPath = path.resolve(process.cwd(), this.markupOut)
       const markupOutDir = path.dirname(markupOut)
 
       mkDir(markupOutDir)
@@ -233,7 +329,9 @@ export default class Markups {
       const fileContext = {
         ...collectionData,
         relativePathPrefix: getRelativePathPrefix(markupOutDir, fromPath, this.baseURL),
-        _url: getPageUrl(markupOut)
+        // output-relative so page.url matches nav.json urls (getPageUrlRelativeToOutput),
+        // otherwise `item.url == page.url` sidebar/active checks never fire
+        _url: getPageUrlRelativeToOutput(markupOut, this.markupOut)
       }
 
       const shouldIndex = pageEntries && indexableExtensions.has(path.extname(file))
@@ -243,14 +341,12 @@ export default class Markups {
 
       const compilePromise = this.compileEntry(file, fileContext).then(({ result, frontMatter, skipped }) => {
         if (skipped) {
-          const outFile = replaceOutExtensions(markupOut)
-          if (fs.existsSync(outFile)) {
-            fs.unlinkSync(outFile)
-            log({ tag: this.logTag, text: 'Removed unpublished:', link: path.relative(process.cwd(), outFile) })
+          if (fs.existsSync(markupOut)) {
+            fs.unlinkSync(markupOut)
+            log({ tag: this.logTag, text: 'Removed unpublished:', link: path.relative(process.cwd(), markupOut) })
           }
           return
         }
-        markupOut = replaceOutExtensions(markupOut)
         fs.writeFileSync(markupOut, result)
 
         if (shouldIndex && frontMatter.published !== false) {
@@ -283,7 +379,7 @@ export default class Markups {
 
   async compileSingleFile(markupIn, collectionData, pageEntries) {
     const markupStart = performance.now()
-    let markupOut = path.join(process.cwd(), this.markupOut)
+    let markupOut = path.resolve(process.cwd(), this.markupOut)
     const markupOutDir = path.dirname(markupOut)
     const indexableExtensions = this.engine.indexableExtensions
     mkDir(markupOutDir)
@@ -291,14 +387,15 @@ export default class Markups {
     const fileContext = {
       ...collectionData,
       relativePathPrefix: getRelativePathPrefix(markupOutDir, null, this.baseURL),
-      _url: getPageUrl(markupOut)
+      // output-relative so page.url matches nav.json/index urls, same as compileDirectory
+      _url: getPageUrlRelativeToOutput(this.mapOutputPath(markupOut), this.markupOut)
     }
 
     const shouldIndex = pageEntries && indexableExtensions.has(path.extname(markupIn))
 
     try {
       const { result, frontMatter, skipped } = await this.compileEntry(markupIn, fileContext)
-      markupOut = replaceOutExtensions(markupOut)
+      markupOut = this.mapOutputPath(markupOut)
 
       if (skipped) {
         if (fs.existsSync(markupOut)) {
@@ -321,9 +418,9 @@ export default class Markups {
       }
 
       const markupEnd = performance.now()
-      log({ tag: this.logTag, text: 'Compiled:', link: path.relative(process.cwd(), path.join(process.cwd(), this.markupOut, path.basename(markupIn))), time: buildTime(markupStart, markupEnd) })
+      log({ tag: this.logTag, text: 'Compiled:', link: path.relative(process.cwd(), path.resolve(process.cwd(), this.markupOut, path.basename(markupIn))), time: buildTime(markupStart, markupEnd) })
     } catch (err) {
-      log({ tag: this.logTag, error: true, text: 'Failed compiling:', link: path.relative(process.cwd(), path.join(process.cwd(), this.markupOut, path.basename(markupIn))) })
+      log({ tag: this.logTag, error: true, text: 'Failed compiling:', link: path.relative(process.cwd(), path.resolve(process.cwd(), this.markupOut, path.basename(markupIn))) })
       console.error(err)
       throw err
     } finally {
@@ -335,6 +432,9 @@ export default class Markups {
     const moduleConfig = this.config.markup
     if (!moduleConfig || !moduleConfig.in) return
 
+    await this.init()
+    if (!this.engine) return
+
     if (this.config.reactorData) {
       // A removed reactor component must also drop its injected global,
       // same staleness rule as data files in loadDataFiles()
@@ -351,7 +451,7 @@ export default class Markups {
       }
     }
 
-    const markupIn = path.join(process.cwd(), this.markupIn)
+    const markupIn = path.resolve(process.cwd(), this.markupIn)
 
     if (!pathExists(markupIn)) {
       log({ tag: 'error', text: 'Markup path does not exist:', link: markupIn })
@@ -363,10 +463,15 @@ export default class Markups {
       ...getCollectionDataBasedOnConfig(this.markupIn, this.collectionsConfig)
     }
 
-    const shouldIndex = this.searchIndexConfig || this.sitemapConfig
+    const shouldIndex = this.searchIndexConfig || this.sitemapConfig || this.navConfig
     const pageEntries = shouldIndex ? [] : null
 
     buildCollectionPaginationData(collectionData)
+
+    // must precede any rendering (incl. pagination pages) so every template
+    // sees the current build's nav
+    this.buildNavGlobal(markupIn, collectionData)
+
     const collectionPromises = generateCollectionPaginationPages(collectionData, this.markupIn, this.markupOut, this.compileEntry.bind(this), this.baseURL)
 
     await Promise.all(collectionPromises)
@@ -396,7 +501,8 @@ export default class Markups {
     if (shouldIndex && pageEntries) {
       generateIndexFiles(pageEntries, this.markupOut, this.siteData.url, {
         searchIndex: this.searchIndexConfig,
-        sitemap: this.sitemapConfig
+        sitemap: this.sitemapConfig,
+        nav: this.navConfig
       })
     }
   }

package/lib/styles.js

@@ -1,7 +1,9 @@
 import fs from 'node:fs'
+import { globSync, hasMagic } from 'glob'
 import {
   pathExists,
   mkPath,
+  pathForFile,
   buildStyleOutputFilePath,
   fillBannerTemplate,
   buildTime,
@@ -25,12 +27,35 @@ export default class Styles {
     this.config.styles = Array.isArray(this.config.styles) ? this.config.styles : [this.config.styles]
     for (const styleEntry of this.config.styles) {
       if (!styleEntry.in || !styleEntry.out) continue
-      if (!pathExists(styleEntry.in)) {
-        log({ tag: 'style', error: true, text: 'Entry does not exist:', link: styleEntry.in })
-        continue
+      // `in` may be an array of entry points and/or globs — same resolution as scripts
+      const configured = Array.isArray(styleEntry.in) ? styleEntry.in : [styleEntry.in]
+      const entryPoints = []
+      let missing = false
+      for (const entry of configured) {
+        if (hasMagic(entry)) {
+          // Globs must use `/` even on Windows; sort for deterministic build order.
+          // Skip sass partials (_*.scss) — they are imports, not entry points.
+          const matches = globSync(entry, { posix: true }).filter(match => !path.basename(match).startsWith('_')).sort()
+          if (!matches.length) {
+            log({ tag: 'style', error: true, text: 'Entry does not exist:', link: entry })
+            missing = true
+          }
+          entryPoints.push(...matches)
+        } else if (!pathExists(entry)) {
+          log({ tag: 'style', error: true, text: 'Entry does not exist:', link: entry })
+          missing = true
+        } else {
+          entryPoints.push(entry)
+        }
+      }
+      if (missing) continue
+      if (entryPoints.length > 1 && pathForFile(styleEntry.out)) {
+        log({ tag: 'error', text: 'Cannot output multiple style files to a single file. Please specify an output directory path instead.' })
+        process.exit(1)
+      }
+      for (const entryPoint of entryPoints) {
+        await this.compileEntry(entryPoint, styleEntry.out, styleEntry.options)
       }
-      mkPath(styleEntry.out)
-      await this.compileEntry(styleEntry.in, styleEntry.out, styleEntry.options)
     }
   }
 
@@ -58,6 +83,7 @@ export default class Styles {
     }
 
     outfilePath = buildStyleOutputFilePath(infilePath, outfilePath)
+    mkPath(outfilePath) // resolved file path — mkPath on a dir out is a no-op
 
     const stylesStart = performance.now()
     let compiledSass