poops 1.9.8 → 2.0.0

package/lib/markup/indexer.js

@@ -34,10 +34,28 @@ const DEFAULTS = {
 
 const INTERNAL_FIELDS = new Set(['content', 'isIndex', 'layout', 'published', '_src'])
 
-function normalizeConfig(config) {
+// Warned once per feature per process: llms is normalized twice (index + full),
+// and a watch session would otherwise repeat the line on every rebuild.
+const deprecationWarned = new Set()
+
+function warnRenamedOutput(feature) {
+  if (deprecationWarned.has(feature)) return
+  deprecationWarned.add(feature)
+  log({ tag: 'indexer', warn: true, text: `Deprecated: "${feature}.output" is now "${feature}.out" — still read, will stop working in 3.0.` })
+}
+
+// `out` is the output key everywhere else in a poops config, so it is the one
+// here too. 1.x spelled it `output` in these sub-features; that still works,
+// warns, and goes away in 3.0.
+function normalizeConfig(config, feature) {
   if (!config) return null
-  if (typeof config === 'string') return { output: config, ...DEFAULTS }
-  return { ...DEFAULTS, ...config }
+  if (typeof config === 'string') return { out: config, ...DEFAULTS }
+  const normalized = { ...DEFAULTS, ...config }
+  if (normalized.out === undefined && normalized.output !== undefined) {
+    warnRenamedOutput(feature)
+    normalized.out = normalized.output
+  }
+  return normalized
 }
 
 // A page front-matter `robots: noindex` (or `none`) opts it out of the
@@ -120,7 +138,7 @@ export function _getKeywordCache() {
 }
 
 export function generateSearchIndex(pageEntries, outputDir, config) {
-  config = normalizeConfig(config)
+  config = normalizeConfig(config, 'markup.options.searchIndex')
   if (!config) return
 
   // Any option that changes extraction output invalidates the whole cache
@@ -159,14 +177,14 @@ export function generateSearchIndex(pageEntries, outputDir, 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)
+  const outputPath = path.resolve(process.cwd(), outputDir, config.out)
   fs.mkdirSync(path.dirname(outputPath), { recursive: true })
   fs.writeFileSync(outputPath, JSON.stringify(entries, null, 2))
   log({ tag: 'indexer', text: 'Generated search index:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
 }
 
 export function generateSitemap(pageEntries, outputDir, siteUrl, config) {
-  config = normalizeConfig(config)
+  config = normalizeConfig(config, 'markup.options.sitemap')
   if (!config) return
 
   const baseUrl = siteUrl ? siteUrl.replace(/\/+$/, '') : ''
@@ -190,7 +208,7 @@ export function generateSitemap(pageEntries, outputDir, siteUrl, 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)
+  const outputPath = path.resolve(process.cwd(), outputDir, config.out)
   fs.mkdirSync(path.dirname(outputPath), { recursive: true })
   fs.writeFileSync(outputPath, xml)
   log({ tag: 'indexer', text: 'Generated sitemap:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
@@ -204,7 +222,7 @@ export function generateSitemap(pageEntries, outputDir, siteUrl, config) {
 // resolved from site data by the caller. Mirrors generateSitemap's page set —
 // isIndex (collection landing/pagination) pages are skipped.
 export function generateLlmsTxt(pageEntries, outputDir, siteUrl, config) {
-  config = normalizeConfig(config)
+  config = normalizeConfig(config, 'markup.options.llms')
   if (!config) return
 
   const baseUrl = siteUrl ? siteUrl.replace(/\/+$/, '') : ''
@@ -273,7 +291,7 @@ export function generateLlmsTxt(pageEntries, outputDir, siteUrl, config) {
     }
   }
 
-  const outputPath = path.resolve(process.cwd(), outputDir, config.output)
+  const outputPath = path.resolve(process.cwd(), outputDir, config.out)
   fs.writeFileSync(outputPath, out)
   log({ tag: 'indexer', text: 'Generated llms.txt:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
 }
@@ -287,14 +305,14 @@ export function generateLlmsTxt(pageEntries, outputDir, siteUrl, config) {
 // ponytail: raw markdown, so unrendered {% %} tags / shortcodes in a body leak
 // through verbatim. Upgrade path if that bites: render + HTML→markdown the body.
 export function generateLlmsFull(pageEntries, outputDir, siteUrl, config) {
-  config = normalizeConfig(config)
+  config = normalizeConfig(config, 'markup.options.llms')
   if (!config || !config.full) return
   // Default filename pairs with the index: llms.txt → llms-full.txt, ai.txt →
   // ai-full.txt (suffix the index's `output`, dir/ext preserved). A string
   // `full` overrides the path outright.
   let output = config.full
   if (typeof output !== 'string') {
-    const p = path.parse(config.output || 'llms.txt')
+    const p = path.parse(config.out || 'llms.txt')
     output = path.join(p.dir, `${p.name}-full${p.ext}`)
   }
 
@@ -349,7 +367,7 @@ export function generateLlmsFull(pageEntries, outputDir, siteUrl, config) {
 // sitemap's filename, threaded in by generateIndexFiles.
 // ponytail: single user-agent group; add per-agent groups if a real need shows up.
 export function generateRobotsTxt(outputDir, siteUrl, config, sitemapOutput) {
-  config = normalizeConfig(config)
+  config = normalizeConfig(config, 'markup.options.robots')
   if (!config) return
 
   const arr = (v) => v == null ? [] : (Array.isArray(v) ? v : [v])
@@ -372,7 +390,7 @@ export function generateRobotsTxt(outputDir, siteUrl, config, sitemapOutput) {
   }
   if (sitemapUrl) lines.push('', `Sitemap: ${sitemapUrl}`)
 
-  const outputPath = path.resolve(process.cwd(), outputDir, config.output)
+  const outputPath = path.resolve(process.cwd(), outputDir, config.out)
   fs.mkdirSync(path.dirname(outputPath), { recursive: true })
   fs.writeFileSync(outputPath, lines.join('\n') + '\n')
   log({ tag: 'indexer', text: 'Generated robots.txt:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
@@ -509,14 +527,14 @@ export function buildNavTree(pageEntries, config = {}) {
 }
 
 export function generateNav(pageEntries, outputDir, config) {
-  config = normalizeConfig(config)
+  config = normalizeConfig(config, 'markup.options.nav')
   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)
+  const outputPath = path.resolve(process.cwd(), outputDir, config.out)
   fs.mkdirSync(path.dirname(outputPath), { recursive: true })
   fs.writeFileSync(outputPath, JSON.stringify(tree, null, 2))
   log({ tag: 'indexer', text: 'Generated nav:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
@@ -541,10 +559,10 @@ function feedAuthorName(author) {
 
 // Normalizes the `feed` option into concrete per-collection specs. Accepts:
 //   true | "feed.xml"           → RSS for every collection
-//   { output, type, limit, … }  → those options for every collection
+//   { out, type, limit, … }     → those options for every collection
 //   { collection, … }           → one named collection
 //   [ {…}, {…} ]                → an explicit list
-// `output` containing a slash is a full path under the output dir; a bare
+// `out` containing a slash is a full path under the output dir; a bare
 // filename is placed in the collection's own folder (default "feed.xml").
 function resolveFeedSpecs(config, collectionNames, site) {
   if (!config) return []
@@ -552,15 +570,20 @@ function resolveFeedSpecs(config, collectionNames, site) {
   const specs = []
   for (let item of raw) {
     if (item === true) item = {}
-    else if (typeof item === 'string') item = { output: item }
+    else if (typeof item === 'string') item = { out: item }
     if (!item || typeof item !== 'object') continue
 
+    if (item.out === undefined && item.output !== undefined) {
+      warnRenamedOutput('markup.options.feed')
+      item = { ...item, out: item.output }
+    }
+
     const targets = item.collection ? [item.collection] : collectionNames
     for (const name of targets) {
-      const outName = item.output || 'feed.xml'
+      const outName = item.out || 'feed.xml'
       specs.push({
         collection: name,
-        output: outName.includes('/') ? outName : `${name}/${outName}`,
+        out: outName.includes('/') ? outName : `${name}/${outName}`,
         type: item.type === 'atom' ? 'atom' : 'rss',
         limit: Number(item.limit) > 0 ? Number(item.limit) : 20,
         title: item.title || (site.title ? `${humanize(name)} | ${site.title}` : humanize(name)),
@@ -685,10 +708,10 @@ export function generateFeeds(pageEntries, outputDir, siteUrl, config, site = {}
       .sort((a, b) => new Date(b.date || 0) - new Date(a.date || 0))
       .slice(0, spec.limit)
 
-    const ctx = { selfUrl: abs(spec.output), channelLink: abs(spec.collection), abs }
+    const ctx = { selfUrl: abs(spec.out), channelLink: abs(spec.collection), abs }
     const xml = spec.type === 'atom' ? buildAtomFeed(spec, items, ctx) : buildRssFeed(spec, items, ctx)
 
-    const outputPath = path.resolve(process.cwd(), outputDir, spec.output)
+    const outputPath = path.resolve(process.cwd(), outputDir, spec.out)
     fs.mkdirSync(path.dirname(outputPath), { recursive: true })
     fs.writeFileSync(outputPath, xml)
     log({ tag: 'indexer', text: 'Generated feed:', link: path.relative(process.cwd(), outputPath), size: fileSize(outputPath) })
@@ -701,7 +724,7 @@ export function generateIndexFiles(pageEntries, outputDir, siteUrl, config) {
   generateLlmsTxt(pageEntries, outputDir, siteUrl, config.llms)
   generateLlmsFull(pageEntries, outputDir, siteUrl, config.llms)
   const sitemapOutput = config.sitemap
-    ? (typeof config.sitemap === 'string' ? config.sitemap : config.sitemap.output)
+    ? (typeof config.sitemap === 'string' ? config.sitemap : (config.sitemap.out ?? config.sitemap.output))
     : null
   generateRobotsTxt(outputDir, siteUrl, config.robots, sitemapOutput)
   generateNav(pageEntries, outputDir, config.nav)

package/lib/markups.js

@@ -25,32 +25,53 @@ export default class Markups {
     if (!moduleConfig.options) moduleConfig.options = {}
 
     // Determine engine — resolved in init(), builtin name or importable module
-    this.engineName = moduleConfig.engine || moduleConfig.options.engine || 'nunjucks'
+    this.engineName = this.option('engine') || 'nunjucks'
     this.logTag = 'markup'
 
     // Normalize config
     this.markupIn = moduleConfig.in
     this.markupOut = moduleConfig.out || process.cwd()
-    this.siteData = moduleConfig.site || moduleConfig.options.site || {}
-    this.timeDateFormat = moduleConfig.options.timeDateFormat || moduleConfig.timeDateFormat
-    this.collectionsConfig = moduleConfig.options.collections || moduleConfig.collections
-    this.includePaths = moduleConfig.includePaths || moduleConfig.options.includePaths || []
-    this.searchIndexConfig = moduleConfig.options.searchIndex || moduleConfig.searchIndex
-    this.sitemapConfig = moduleConfig.options.sitemap || moduleConfig.sitemap
-    this.llmsConfig = moduleConfig.options.llms || moduleConfig.llms
-    this.robotsConfig = moduleConfig.options.robots || moduleConfig.robots
-    this.feedConfig = moduleConfig.options.feed || moduleConfig.feed
-    this.navConfig = moduleConfig.options.nav || moduleConfig.nav
-    this.baseURL = moduleConfig.baseURL || moduleConfig.options.baseURL || null
-
-    this.autoescape = moduleConfig.autoescape || moduleConfig.options.autoescape || false
-    this.dataConfig = moduleConfig.data || moduleConfig.options.data
+    this.siteData = this.option('site') || {}
+    this.dateFormat = this.option('dateFormat') ?? this.deprecatedOption('timeDateFormat', 'dateFormat')
+    this.collectionsConfig = this.option('collections')
+    this.includePaths = this.option('includePaths') || []
+    this.searchIndexConfig = this.option('searchIndex')
+    this.sitemapConfig = this.option('sitemap')
+    this.llmsConfig = this.option('llms')
+    this.robotsConfig = this.option('robots')
+    this.feedConfig = this.option('feed')
+    this.navConfig = this.option('nav')
+    this.baseURL = this.option('baseURL') || null
+
+    this.autoescape = this.option('autoescape') || false
+    this.dataConfig = this.option('data')
 
     if (!moduleConfig.out) {
       moduleConfig.out = this.markupOut
     }
   }
 
+  // `markup.options` is the canonical home for every markup setting except the
+  // `in`/`out` entry itself — the same { in, out, options } shape scripts and
+  // styles entries have. 1.x read most of these at the `markup.` level too;
+  // that still works, warns once per key, and goes away in 3.0.
+  option(key) {
+    const moduleConfig = this.config.markup
+    if (moduleConfig.options[key] !== undefined) return moduleConfig.options[key]
+    if (moduleConfig[key] === undefined) return undefined
+    log({ tag: 'markup', warn: true, text: `Deprecated: "markup.${key}" moved into "markup.options.${key}" in 2.0 — still read, will stop working in 3.0.` })
+    return moduleConfig[key]
+  }
+
+  // A key that was renamed in 2.0. Reads the old name (wherever it sits) and
+  // says what to call it now.
+  deprecatedOption(key, replacement) {
+    const value = this.option(key)
+    if (value === undefined) return undefined
+    log({ tag: 'markup', warn: true, text: `Deprecated: "${key}" is now "${replacement}" — still read, will stop working in 3.0.` })
+    return value
+  }
+
   // 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.
@@ -86,7 +107,7 @@ export default class Markups {
       autoescape: this.autoescape
     })
 
-    this.engine.registerFilters({ timeDateFormat: this.timeDateFormat, markupOut: this.markupOut })
+    this.engine.registerFilters({ dateFormat: this.dateFormat, markupOut: this.markupOut })
     this.engine.registerTags(() => path.resolve(process.cwd(), this.markupOut))
 
     // Load global variables
@@ -97,10 +118,6 @@ export default class Markups {
 
     this.engine.setGlobal('site', this.siteData)
 
-    if (this.config.livereload_port) {
-      this.engine.setGlobal('livereload_port', this.config.livereload_port)
-    }
-
     if (this.config.reactorData) {
       for (const [name, html] of Object.entries(this.config.reactorData)) {
         this.engine.setGlobal(name, html)
@@ -114,7 +131,7 @@ export default class Markups {
   // title/description from site data so generateLlmsTxt gets ready values.
   resolveLlmsConfig() {
     if (!this.llmsConfig) return undefined
-    const base = typeof this.llmsConfig === 'string' ? { output: this.llmsConfig } : { ...this.llmsConfig }
+    const base = typeof this.llmsConfig === 'string' ? { out: this.llmsConfig } : { ...this.llmsConfig }
     base.title = base.title || this.siteData.title
     base.description = base.description || this.siteData.description
     return base

package/lib/reactor.js

@@ -6,7 +6,8 @@ import {
   pathContainsPathSegment,
   fillBannerTemplate,
   buildTime,
-  fileSize
+  fileSize,
+  DEFAULT_TARGET
 } from './utils/helpers.js'
 import minifyToFile from './utils/minify.js'
 import fs from 'node:fs'
@@ -100,7 +101,7 @@ export const html = renderToString(React.createElement(Component));
         sourcemap: false,
         minify: false,
         format: 'iife',
-        target: 'es2019',
+        target: DEFAULT_TARGET,
         nodePaths: this.config.includePaths
       }
 

package/lib/scripts.js

@@ -15,7 +15,8 @@ import {
   fillOutTemplateEntry,
   fillBannerTemplate,
   buildTime,
-  fileSize
+  fileSize,
+  DEFAULT_TARGET
 } from './utils/helpers.js'
 import path from 'node:path'
 import minifyToFile from './utils/minify.js'
@@ -93,7 +94,7 @@ export default class Scripts {
       sourcemap: false,
       minify: false,
       format: 'iife',
-      target: 'es2019',
+      target: DEFAULT_TARGET,
       nodePaths: this.config.includePaths // Resolve `includePaths`
     }
 

package/lib/server.js

@@ -37,6 +37,80 @@ const MIME_TYPES = {
   '.webmanifest': 'application/manifest+json; charset=utf-8'
 }
 
+// The reload channel. One endpoint on the static server, so a poops dev
+// session is one port total.
+export const RELOAD_PATH = '/__poops_reload'
+
+// Injected into every served HTML page while livereload is on, so nothing has
+// to be embedded in your templates. EventSource reconnects on its own, which
+// is the whole reason this is SSE and not a socket: restart poops and the open
+// tabs re-attach without a keepalive protocol of our own.
+// CSS paths arrive as build-output paths ('dist/css/site.css') while the page
+// links a URL ('/css/site.css'), so a stylesheet matches when the emitted path
+// ends with the link's pathname — the same suffix match livereload did, and it
+// survives any `serve.base`. Re-setting href with a cache-busting query swaps
+// the stylesheet in place; the page never reloads and scroll/state survive.
+// A css event that matches no link on the page falls back to a full reload:
+// the build wrote a stylesheet this page does not link (or links under another
+// name), and silently doing nothing would look like a dead watcher.
+const RELOAD_CLIENT = `<script>
+(function () {
+  var es = new EventSource('${RELOAD_PATH}')
+  es.addEventListener('reload', function () { location.reload() })
+  es.addEventListener('css', function (e) {
+    var paths = JSON.parse(e.data)
+    var links = document.querySelectorAll('link[rel="stylesheet"][href]')
+    var swapped = 0
+    for (var i = 0; i < links.length; i++) {
+      var pathname = new URL(links[i].href, location.href).pathname
+      for (var j = 0; j < paths.length; j++) {
+        if (paths[j].endsWith(pathname)) {
+          links[i].href = pathname + '?poops=' + Date.now()
+          swapped++
+          break
+        }
+      }
+    }
+    if (!swapped) location.reload()
+  })
+})()
+</script>
+`
+
+export function injectReloadClient(html) {
+  return /<\/body>/i.test(html)
+    ? html.replace(/<\/body>/i, RELOAD_CLIENT + '</body>')
+    : html + RELOAD_CLIENT
+}
+
+// Holds the open EventSource responses and fans build events out to them.
+// Kept separate from the request handler so the watch loop can own one hub and
+// hand it to the server, and so it can be driven directly in tests.
+export function createReloadHub() {
+  const clients = new Set()
+
+  return {
+    clients,
+
+    handle(req, res) {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive'
+      })
+      // Reconnect fast after a poops restart — the browser default is 3s
+      res.write('retry: 1000\n\n')
+      clients.add(res)
+      req.on('close', () => clients.delete(res))
+    },
+
+    send(event, data) {
+      const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
+      for (const res of clients) res.write(payload)
+    }
+  }
+}
+
 // Parse a single-range `Range: bytes=start-end` header against a file size.
 // Returns { start, end } (inclusive), null when absent/ignorable (multipart,
 // malformed — RFC says serve the full file then), or 'unsatisfiable' for a
@@ -62,7 +136,7 @@ export function parseRange(header, size) {
   return { start, end }
 }
 
-export function createStaticHandler(base) {
+export function createStaticHandler(base, reloadHub) {
   // Drop any trailing separator — `serve.base: "/"` resolves to `<cwd>/`, and the
   // containment check below would then compare against `<cwd>//` and reject everything
   base = path.resolve(base)
@@ -81,6 +155,7 @@ export function createStaticHandler(base) {
       return res.end('Not Found')
     }
     if (!/<base[\s>]/i.test(html)) html = html.replace(/<head([^>]*)>/i, '<head$1><base href="/">')
+    if (reloadHub) html = injectReloadClient(html)
     res.end(html)
   }
 
@@ -100,6 +175,8 @@ export function createStaticHandler(base) {
       return res.end('Bad Request')
     }
 
+    if (reloadHub && pathname === RELOAD_PATH) return reloadHub.handle(req, res)
+
     // Contain resolution inside `base` — rejects `..` traversal and null bytes
     if (pathname.includes('\0')) return notFound(res)
     let filePath = path.normalize(path.join(base, pathname))
@@ -133,7 +210,24 @@ export function createStaticHandler(base) {
       }
     }
 
-    res.setHeader('Content-Type', MIME_TYPES[path.extname(filePath).toLowerCase()] || 'application/octet-stream')
+    const ext = path.extname(filePath).toLowerCase()
+    res.setHeader('Content-Type', MIME_TYPES[ext] || 'application/octet-stream')
+
+    // HTML gets the reload client appended, so it's built in memory rather than
+    // streamed — the length changes, and a Range over a page nobody seeks in
+    // isn't worth keeping consistent with the injection.
+    if (reloadHub && ext === '.html') {
+      let html
+      try {
+        html = injectReloadClient(fs.readFileSync(filePath, 'utf8'))
+      } catch {
+        return notFound(res)
+      }
+      res.statusCode = 200
+      res.setHeader('Content-Length', Buffer.byteLength(html))
+      return res.end(req.method === 'HEAD' ? undefined : html)
+    }
+
     res.setHeader('Accept-Ranges', 'bytes')
 
     const range = parseRange(req.headers.range, stat.size)

package/lib/styles.js

@@ -11,6 +11,7 @@ import {
   entryBase,
   hasOutTemplate,
   fillOutTemplate,
+  insertMinSuffix,
   fillBannerTemplate,
   buildTime,
   fileSize
@@ -127,7 +128,9 @@ export default class Styles {
     const mapsrc = options.sourcemap ? `\n/*# sourceMappingURL=${path.basename(outfilePath)}.map */` : ''
     if (this.banner) compiledSass.css = this.banner + '\n' + compiledSass.css
     fs.writeFileSync(outfilePath, compiledSass.css + mapsrc)
-    this.outputs.push(outfilePath) // after the write — a failed compile has nothing to reload
+    // after the write — a failed compile has nothing to reload. `justMinified`
+    // deletes this file below, so only the .min path is worth reporting then.
+    if (!options.justMinified) this.outputs.push(outfilePath)
     const stylesEnd = performance.now()
     if (!options.justMinified) log({ tag: 'style', text: 'Compiled:', link: outfilePath, size: fileSize(outfilePath), time: buildTime(stylesStart, stylesEnd) })
 
@@ -146,5 +149,11 @@ export default class Styles {
       options,
       startTime: options.justMinified ? stylesStart : undefined
     })
+
+    // Pages link whichever spelling they were written against, and with
+    // `minify` on that is usually the .min file. Reporting only the plain one
+    // meant the reload client could find no matching stylesheet and fell back
+    // to reloading the whole page on every style edit.
+    if (options.minify) this.outputs.push(insertMinSuffix(outfilePath))
   }
 }

package/lib/utils/helpers.js

@@ -4,6 +4,12 @@ import path from 'node:path'
 import yaml from 'yaml'
 import { convertGlobToRegex } from 'book-of-spells'
 
+// The esbuild target scripts and reactor bundles compile to when an entry
+// doesn't set its own. ES2020 is where optional chaining and nullish
+// coalescing live — the syntax people write today, which an older target
+// would lower into helpers for browsers that have supported it since 2020.
+export const DEFAULT_TARGET = 'es2020'
+
 export function toPosix(filePath) {
   return path.sep === '/' ? filePath : filePath.split(path.sep).join('/')
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poops",
   "description": "Straightforward, no-bullshit bundler for the web.",
-  "version": "1.9.8",
+  "version": "2.0.0",
   "license": "MIT",
   "type": "module",
   "main": "poops.js",
@@ -51,18 +51,17 @@
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "dependencies": {
     "argoyle": "^1.0.0",
-    "book-of-spells": "^1.3.0",
-    "chokidar": "^3.5.3",
+    "book-of-spells": "^1.4.0",
+    "chokidar": "^5.0.0",
     "dayjs": "^1.11.19",
-    "esbuild": "^0.25.0",
+    "esbuild": "^0.28.1",
     "glob": "^13.0.6",
     "highlight.js": "^11.11.1",
     "liquidjs": "^10.24.0",
-    "livereload": "^0.9.3",
     "marked": "^18.0.6",
     "marked-github-alerts": "^1.0.1",
     "marked-github-emoji": "^1.0.2",
@@ -79,15 +78,17 @@
     "@tailwindcss/postcss": "^4.2.1",
     "eslint": "^9.39.3",
     "jest": "^30.2.0",
-    "neostandard": "^0.12.2",
+    "neostandard": "^0.13.0",
     "poops-docs-theme": "^1.0.0",
-    "postcss": "^8.5.8",
+    "postcss": "^8.5.25",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "sulphuris": "^2.0.0",
+    "sulphuris": "^4.0.0",
     "tailwindcss": "^4.2.1"
   },
   "overrides": {
-    "minimatch": ">=10.2.1"
+    "nunjucks": {
+      "chokidar": "$chokidar"
+    }
   }
 }