poops 1.2.3 → 1.3.0

package/lib/markups.js

@@ -1,12 +1,14 @@
-import { pathExists, pathIsDirectory, readDataFile, mkDir, buildTime } from './utils/helpers.js'
-import { replaceOutExtensions, getRelativePathPrefix, getPageUrl, getPageUrlRelativeToOutput, parseFrontMatter, clearFrontMatterCache, wordcount } from './markup/helpers.js'
+import { pathExists, pathIsDirectory, readDataFile, mkDir, buildTime, toPosix } from './utils/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,23 +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
-    this.dataFiles = []
 
-    // 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')
@@ -71,12 +104,7 @@ export default class Markups {
       }
     }
 
-    const data = moduleConfig.data || moduleConfig.options.data
-    this.loadDataFiles(data)
-
-    if (!moduleConfig.out) {
-      moduleConfig.out = this.markupOut
-    }
+    this.loadDataFiles(this.dataConfig)
   }
 
   loadDataFiles(files) {
@@ -90,36 +118,79 @@ 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(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))
+          resolved.push(path.relative(path.resolve(process.cwd(), dataDir), f))
         }
       } else {
         resolved.push(file)
       }
     }
 
-    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 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)
       } 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)
+    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.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.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
+    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 = 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) })
+    }
+  }
+
   generateMarkupGlobPattern(excludes) {
     let markupDefaultExcludes = ['node_modules', '.git', '.svn', '.hg']
 
@@ -170,12 +241,72 @@ export default class Markups {
     return { result, frontMatter }
   }
 
+  getMarkupFiles(markupIn) {
+    // glob patterns must use `/` — on Windows `\` is an escape character
+    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 = [
-      ...globSync(path.join(markupIn, this.generateMarkupGlobPattern(this.includePaths))),
-      ...globSync(path.join(markupIn, `*.+(${this.engine.markupExtensions})`))
-    ]
+    const markupFiles = this.getMarkupFiles(markupIn)
     const compilePromises = []
     const indexableExtensions = this.engine.indexableExtensions
 
@@ -183,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)
@@ -199,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))
@@ -209,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) {
@@ -249,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)
@@ -257,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)) {
@@ -287,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 {
@@ -301,13 +432,26 @@ 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()
+      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)
       }
     }
 
-    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 })
@@ -319,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)
@@ -352,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/postcss.js

@@ -1,14 +1,13 @@
-import { transform } from 'esbuild'
 import fs from 'node:fs'
 import {
   pathExists,
   mkPath,
-  insertMinSuffix,
   buildStyleOutputFilePath,
   fillBannerTemplate,
   buildTime,
   fileSize
 } from './utils/helpers.js'
+import minifyToFile from './utils/minify.js'
 import log from './utils/log.js'
 
 let postcss
@@ -65,10 +64,13 @@ export default class PostCSS {
 
     this.config.postcss = Array.isArray(this.config.postcss) ? this.config.postcss : [this.config.postcss]
     for (const entry of this.config.postcss) {
-      if (entry.in && entry.out && pathExists(entry.in)) {
-        mkPath(entry.out)
-        await this.compileEntry(entry.in, entry.out, entry.options)
+      if (!entry.in || !entry.out) continue
+      if (!pathExists(entry.in)) {
+        log({ tag: 'postcss', error: true, text: 'Entry does not exist:', link: entry.in })
+        continue
       }
+      mkPath(entry.out)
+      await this.compileEntry(entry.in, entry.out, entry.options)
     }
   }
 
@@ -98,30 +100,14 @@ export default class PostCSS {
     const end = performance.now()
     if (!options.justMinified) log({ tag: 'postcss', text: 'Compiled:', link: outfilePath, size: fileSize(outfilePath), time: buildTime(start, end) })
 
-    const minPath = insertMinSuffix(outfilePath)
-    if (options.minify) {
-      try {
-        const minStart = !options.justMinified ? performance.now() : start
-
-        const minified = await transform(css, {
-          loader: 'css',
-          minify: true
-        })
-
-        if (this.banner) minified.code = this.banner + '\n' + minified.code
-        fs.writeFileSync(minPath, minified.code)
-        const minEnd = performance.now()
-        log({ tag: 'postcss', text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(minStart, minEnd) })
-      } catch (err) {
-        log({ tag: 'postcss', error: true, text: 'Failed compiling:', link: minPath })
-        console.error(err)
-      }
-
-      if (options.justMinified) {
-        fs.unlinkSync(outfilePath)
-      }
-    } else {
-      if (pathExists(minPath)) fs.unlinkSync(minPath)
-    }
+    await minifyToFile({
+      outfilePath,
+      loader: 'css',
+      code: css,
+      banner: this.banner,
+      tag: 'postcss',
+      options,
+      startTime: options.justMinified ? start : undefined
+    })
   }
 }

package/lib/reactor.js

@@ -1,14 +1,14 @@
-import { build, transform } from 'esbuild'
+import { build } from 'esbuild'
 import { deepMerge } from 'book-of-spells'
 import {
   pathExists,
   mkPath,
-  insertMinSuffix,
   pathContainsPathSegment,
   fillBannerTemplate,
   buildTime,
   fileSize
 } from './utils/helpers.js'
+import minifyToFile from './utils/minify.js'
 import fs from 'node:fs'
 import path from 'node:path'
 import { createRequire } from 'node:module'
@@ -29,9 +29,12 @@ export default class Reactor {
     this.rendered = {}
 
     for (const entry of this.config.reactor) {
-      if (entry.component && entry.inject && pathExists(entry.component)) {
-        await this.compileEntry(entry)
+      if (!entry.component || !entry.inject) continue
+      if (!pathExists(entry.component)) {
+        log({ tag: 'reactor', error: true, text: 'Component does not exist:', link: entry.component })
+        continue
       }
+      await this.compileEntry(entry)
     }
 
     this.renderedChanged = JSON.stringify(this.rendered) !== JSON.stringify(prevRendered)
@@ -83,6 +86,9 @@ export const html = renderToString(React.createElement(Component));
     }
 
     // --- Step 2: Bundle the client entry for the browser ---
+    if (client && out && !pathExists(client)) {
+      log({ tag: 'reactor', error: true, text: 'Entry does not exist:', link: client })
+    }
     if (client && out && pathExists(client)) {
       mkPath(out)
 
@@ -129,31 +135,7 @@ export const html = renderToString(React.createElement(Component));
       if (!options.justMinified) log({ tag: 'reactor', text: 'Compiled:', link: out, size: fileSize(out), time: buildTime(esbuildStart, esbuildEnd) })
       if (options.sourcemap) log({ tag: 'reactor', text: 'Compiled:', link: `${out}.map` })
 
-      if (options.minify) {
-        const minPath = insertMinSuffix(out)
-        try {
-          const terserStart = performance.now()
-          const minifyResult = await transform(fs.readFileSync(out, 'utf-8'), {
-            minify: true,
-            loader: 'js'
-          })
-          const terserEnd = performance.now()
-
-          if (this.banner) minifyResult.code = this.banner + '\n' + minifyResult.code
-          fs.writeFileSync(minPath, minifyResult.code)
-          log({ tag: 'reactor', text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(terserStart, terserEnd) })
-        } catch (err) {
-          log({ tag: 'reactor', error: true, text: 'Failed compiling:', link: minPath })
-          console.error(err)
-        }
-
-        if (options.justMinified) {
-          fs.unlinkSync(out)
-        }
-      } else {
-        const minPath = insertMinSuffix(out)
-        if (pathExists(minPath)) fs.unlinkSync(minPath)
-      }
+      await minifyToFile({ outfilePath: out, loader: 'js', banner: this.banner, tag: 'reactor', options })
     }
   }
 

package/lib/scripts.js

@@ -1,16 +1,15 @@
-import { build, transform } from 'esbuild'
+import { build } from 'esbuild'
+import { globSync, hasMagic } from 'glob'
 import { deepMerge } from 'book-of-spells'
 import {
   pathExists,
   mkPath,
   pathForFile,
-  insertMinSuffix,
-  buildScriptOutputFilePath,
   fillBannerTemplate,
   buildTime,
   fileSize
 } from './utils/helpers.js'
-import fs from 'node:fs'
+import minifyToFile from './utils/minify.js'
 import log from './utils/log.js'
 
 export default class Scripts {
@@ -24,10 +23,30 @@ export default class Scripts {
     this.config.scripts = Array.isArray(this.config.scripts) ? this.config.scripts : [this.config.scripts]
 
     for (const scriptEntry of this.config.scripts) {
-      if (scriptEntry.in && scriptEntry.out && pathExists(scriptEntry.in)) {
-        mkPath(scriptEntry.out)
-        await this.compileEntry(scriptEntry.in, scriptEntry.out, scriptEntry.options)
+      if (!scriptEntry.in || !scriptEntry.out) continue
+      // `in` may be an array of entry points — pathExists on an array throws
+      const configured = Array.isArray(scriptEntry.in) ? scriptEntry.in : [scriptEntry.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
+          const matches = globSync(entry, { posix: true }).sort()
+          if (!matches.length) {
+            log({ tag: 'script', error: true, text: 'Entry does not exist:', link: entry })
+            missing = true
+          }
+          entryPoints.push(...matches)
+        } else if (!pathExists(entry)) {
+          log({ tag: 'script', error: true, text: 'Entry does not exist:', link: entry })
+          missing = true
+        } else {
+          entryPoints.push(entry)
+        }
       }
+      if (missing) continue
+      mkPath(scriptEntry.out)
+      await this.compileEntry(entryPoints, scriptEntry.out, scriptEntry.options)
     }
   }
 
@@ -73,9 +92,16 @@ export default class Scripts {
 
     deepMerge(opts, optionsClone) // ability to pass other esbuild options `node_modules/esbuild/lib/main.d.ts`
 
+    // Multi-dir entry points nest output under their common ancestor (esbuild's
+    // outbase), so output paths can't be derived from basenames — read them
+    // from the metafile instead. Keys are relative to absWorkingDir.
+    opts.metafile = true
+    opts.absWorkingDir = process.cwd()
+
     const esbuildStart = performance.now()
+    let result
     try {
-      await build(opts)
+      result = await build(opts)
     } catch (err) {
       log({ tag, error: true, text: 'Failed compiling:', link: outfilePath })
       console.error(err)
@@ -83,36 +109,13 @@ export default class Scripts {
     }
     const esbuildEnd = performance.now()
 
-    for (const entry of infilePath) {
-      const newOutFilePath = buildScriptOutputFilePath(entry, outfilePath)
-      const minPath = insertMinSuffix(newOutFilePath)
+    for (const [newOutFilePath, output] of Object.entries(result.metafile.outputs)) {
+      if (!output.entryPoint) continue // sourcemaps, chunks
 
       if (!options.justMinified) log({ tag, text: 'Compiled:', link: newOutFilePath, size: fileSize(newOutFilePath), time: buildTime(esbuildStart, esbuildEnd) })
       if (options.sourcemap) log({ tag, text: 'Compiled:', link: `${newOutFilePath}.map` })
 
-      if (options.minify) {
-        try {
-          const terserStart = performance.now()
-          const minifyResult = await transform(fs.readFileSync(newOutFilePath, 'utf-8'), {
-            minify: true,
-            loader: 'js'
-          })
-          const terserEnd = performance.now()
-
-          if (this.banner) minifyResult.code = this.banner + '\n' + minifyResult.code
-          fs.writeFileSync(minPath, minifyResult.code)
-          log({ tag, text: 'Compiled:', link: minPath, size: fileSize(minPath), time: buildTime(terserStart, terserEnd) })
-        } catch (err) {
-          log({ tag, error: true, text: 'Failed compiling:', link: minPath })
-          console.error(err)
-        }
-
-        if (options.justMinified) {
-          fs.unlinkSync(newOutFilePath)
-        }
-      } else {
-        if (pathExists(minPath)) fs.unlinkSync(minPath)
-      }
+      await minifyToFile({ outfilePath: newOutFilePath, loader: 'js', banner: this.banner, tag, options })
     }
   }
 }