@uniweb/build 0.29.1 → 0.30.1

package/src/site/{collection-processor.js → query-processor.js}

@@ -1,7 +1,7 @@
 /**
  * Collection Processor
  *
- * Processes content collections from markdown and YAML files into JSON data.
+ * Materializes each named QUERY over the site's records into JSON data.
  * Collections are defined in site.yml and processed at build time.
  *
  * ⛔ A COLLECTION `.md` IS NOT A PAGE-SECTION `.md`. Same extension, unrelated
@@ -18,7 +18,7 @@
  * ⭐ And `.md` is the HYBRID case, not the general one. It exists for records
  * that are part data and part prose — a blog article. YAML and JSON records are
  * data only, have no body, and express nesting and arrays natively; they are the
- * plain case rather than the exception. Reasoning about collections from the
+ * plain case rather than the exception. Reasoning about records from the
  * markdown shape alone imports a body and a content field that most records
  * do not have.
  *
@@ -39,15 +39,14 @@
  * @module @uniweb/build/site/collection-processor
  *
  * @example
- * // site.yml
- * collections:
- *   articles:
- *     path: collections/articles
- *     sort: date desc
+ * // queries.yml
+ * articles:
+ *   schema: '@/article'
+ *   sort: date desc
  *
  * // Usage
- * const collections = await processCollections(siteDir, config.collections)
- * await writeCollectionFiles(siteDir, collections)
+ * const byQuery = await processQueries(siteDir, config.queries)
+ * await writeQueryFiles(siteDir, byQuery)
  */
 
 import { readFile, readdir, stat, writeFile, mkdir, copyFile, rm } from 'node:fs/promises'
@@ -56,8 +55,10 @@ import { existsSync } from 'node:fs'
 import yaml from 'js-yaml'
 import { parseBibtex } from '@citestyle/bibtex'
 import { DATA_DIR } from '@uniweb/core'
-import { applyFilter, applySort } from './data-fetcher.js'
+import { applyWhere, applyFilter, applySort } from './data-fetcher.js'
 import { resolveAssetPath, walkContentAssets, isLocalAssetPath } from './assets.js'
+import { readEntityPool, groupPoolBySchema, ENTITIES_DIR } from './entity-pool.js'
+import { readRecordsConfig, resolveFolder, FOLDER_MISSING } from './records-config.js'
 
 // Try to import content-reader for markdown parsing
 let markdownToProseMirror
@@ -86,10 +87,10 @@ try {
  *
  * @example
  * // Simple form
- * parseCollectionConfig('articles', 'collections/articles')
+ * parseQueryConfig('articles', '@/article')
  *
  * // Extended form
- * parseCollectionConfig('articles', {
+ * parseQueryConfig('articles', {
  *   path: 'collections/articles',
  *   route: '/blog',
  *   sort: 'date desc',
@@ -97,13 +98,22 @@ try {
  *   limit: 100
  * })
  */
-function parseCollectionConfig(name, config) {
+function parseQueryConfig(name, config) {
+  // ⚠️ `queries.yml`'s TERSEST form is a bare key — `articles:` — which YAML
+  // parses as NULL. The resolver normalizes that away, so the build path never
+  // sees it; a caller reading raw config (as this function's own docstring
+  // shows) would have crashed on the shortest thing an author can write.
+  if (config === null || config === undefined) config = {}
   if (typeof config === 'string') {
+    // The string shorthand names the SCHEMA — `entities/{schema}/` supplies the
+    // records, so there is no directory for a query to name.
     return {
       name,
-      path: config,
+      schema: config,
+      url: null,
       route: null,
       sort: null,
+      where: null,
       filter: null,
       limit: 0,
       excerpt: { maxLength: 160 },
@@ -113,9 +123,16 @@ function parseCollectionConfig(name, config) {
 
   return {
     name,
-    path: config.path,
+    // The query's schema selects its records from the pool — `entities/{schema}/`
+    // declares the model, so the entities of a schema ARE the query's records.
+    schema: config.schema || null,
+    url: config.url || null,
     route: config.route || null,
     sort: config.sort || null,
+    // `where:` is the CANONICAL predicate; `filter:` is the deprecated string DSL
+    // it replaced. Both are carried and both are applied below, in the same order
+    // `data-fetcher.js::applyPostProcessing` uses — see the note there.
+    where: config.where || null,
     filter: config.filter || null,
     limit: config.limit || 0,
     excerpt: {
@@ -131,18 +148,18 @@ function parseCollectionConfig(name, config) {
     // singular detail there) or via the kit's useEntityDetail hook.
     deferred: Array.isArray(config.deferred) ? config.deferred.slice() : null,
     // `detailUrl:` names the per-record endpoint pattern for API-backed
-    // collections (where the build emits no per-record files because
+    // remote sources (where the build emits no per-record files because
     // there are no on-disk source files to materialize). Used by the
     // runtime's auto-detail injection and the useEntityDetail kit hook.
     // Pattern uses {slug} as the placeholder; substitution at runtime
     // pulls from the dynamic-route param (entity-store) or the record's
-    // slug field (useEntityDetail). Markdown-backed collections leave
+    // slug field (useEntityDetail). File-backed queries leave
     // this null and get the static-file default /data/<name>/<slug>.json.
     detailUrl: typeof config.detailUrl === 'string' ? config.detailUrl : null,
     // `queryable:` declares the queryable surface — which fields a
     // foundation can offer for filtering UI, with their type and
     // type-specific metadata (enum options, range bounds). Foundations
-    // read this metadata via the kit's useCollectionQueryable hook to
+    // read this metadata via the kit's useQueryable hook to
     // render filter controls and compose where-objects from user
     // interactions. The framework doesn't validate the shape here —
     // foundations get whatever the author wrote; documentation defines
@@ -170,7 +187,7 @@ function parseCollectionConfig(name, config) {
  * fields and moved the page from /blog/docs-sites to /blog/11_docs_sites. The
  * only trace was
  *
- *   [collection-processor] YAML parse error: bad indentation of a mapping entry (4:72)
+ *   [query-processor] YAML parse error: bad indentation of a mapping entry (4:72)
  *
  * on line 16 of 857 lines of build output, naming no file, nine lines above
  * "Processed articles: 6 items" — a success line that reads as everything
@@ -303,20 +320,26 @@ function isExternalUrl(src) {
 /**
  * Process assets in collection content
  * - Resolves relative paths to site-root-relative paths
- * - Copies co-located assets to public/collections/<collection>/
+ * - Copies co-located assets to public/records/<schema>/
  * - Updates paths in the content in place
  *
  * @param {Object} content - ProseMirror document
  * @param {string} itemPath - Path to the markdown file
  * @param {string} siteRoot - Site root directory
- * @param {string} collectionName - Name of the collection (e.g., 'articles')
+ * @param {string} queryName - Name of the collection (e.g., 'articles')
  * @returns {Promise<Object>} Asset manifest for this item
  */
-async function processCollectionAssets(content, itemPath, siteRoot, collectionName, basePath) {
+async function processRecordAssets(content, itemPath, siteRoot, poolDirs, basePath) {
   const assets = {}
   const itemDir = dirname(itemPath)
   const publicDir = join(siteRoot, 'public')
-  const targetDir = join(publicDir, 'collections', collectionName)
+  // ⭐ THE RECORD'S OWN HOME, keyed by its pool position — `public/records/<schema
+  // dirs>/`. It was `public/collections/<queryName>/`, which meant the SAME image
+  // was copied once per query that returned the record, under two URLs. Third
+  // instance of the same conflation (after the freeform locale tree and the
+  // translation manifest): an asset belongs to a record, and which query selects
+  // it is not a fact about it.
+  const targetDir = join(publicDir, 'records', poolDirs)
 
   // Walk content and collect asset paths
   const assetNodes = []
@@ -349,7 +372,7 @@ async function processCollectionAssets(content, itemPath, siteRoot, collectionNa
         await copyFile(result.resolved, targetPath)
 
         // Update path to site-root-relative
-        finalPath = `${basePath}collections/${collectionName}/${assetFilename}`
+        finalPath = `${basePath}records/${poolDirs}/${assetFilename}`
 
         assets[src] = {
           original: src,
@@ -384,7 +407,7 @@ async function processCollectionAssets(content, itemPath, siteRoot, collectionNa
         const posterTarget = join(targetDir, posterFilename)
         await mkdir(targetDir, { recursive: true })
         await copyFile(posterResult.resolved, posterTarget)
-        node.attrs.poster = `${basePath}collections/${collectionName}/${posterFilename}`
+        node.attrs.poster = `${basePath}records/${poolDirs}/${posterFilename}`
       }
     }
 
@@ -395,7 +418,7 @@ async function processCollectionAssets(content, itemPath, siteRoot, collectionNa
         const previewTarget = join(targetDir, previewFilename)
         await mkdir(targetDir, { recursive: true })
         await copyFile(previewResult.resolved, previewTarget)
-        node.attrs.preview = `${basePath}collections/${collectionName}/${previewFilename}`
+        node.attrs.preview = `${basePath}records/${poolDirs}/${previewFilename}`
       }
     }
   }
@@ -406,17 +429,17 @@ async function processCollectionAssets(content, itemPath, siteRoot, collectionNa
 /**
  * Process assets in a data item (YAML/JSON)
  * - Recursively walks the data object looking for local asset paths
- * - Copies co-located assets to public/collections/<collection>/
+ * - Copies co-located assets to public/records/<schema>/
  * - Rewrites paths to absolute URLs (with base path)
  *
  * @param {Object} data - Parsed data object (mutated in place)
  * @param {string} itemPath - Path to the data file
  * @param {string} siteRoot - Site root directory
- * @param {string} collectionName - Name of the collection
+ * @param {string} queryName - Name of the collection
  * @param {string} basePath - Site base path (e.g., '/' or '/docs/')
  */
-async function processDataItemAssets(data, itemPath, siteRoot, collectionName, basePath) {
-  const targetDir = join(siteRoot, 'public', 'collections', collectionName)
+async function processDataItemAssets(data, itemPath, siteRoot, poolDirs, basePath) {
+  const targetDir = join(siteRoot, 'public', 'records', poolDirs)
 
   async function walk(parent, key) {
     const val = parent[key]
@@ -427,7 +450,7 @@ async function processDataItemAssets(data, itemPath, siteRoot, collectionName, b
           const filename = basename(resolved)
           await mkdir(targetDir, { recursive: true })
           await copyFile(resolved, join(targetDir, filename))
-          parent[key] = `${basePath}collections/${collectionName}/${filename}`
+          parent[key] = `${basePath}records/${poolDirs}/${filename}`
         }
       } else if (val.startsWith('/')) {
         // Absolute site path — just prepend base
@@ -467,7 +490,7 @@ async function processDataItemAssets(data, itemPath, siteRoot, collectionName, b
  * @param {string} filename - YAML filename (.yml or .yaml)
  * @returns {Promise<Object|Array|null>} Processed item(s) or null if unpublished
  */
-async function processDataItem(dir, filename, siteRoot, collectionName, basePath) {
+async function processDataItem(dir, filename, siteRoot, poolDirs, basePath) {
   const filepath = join(dir, filename)
   const raw = await readFile(filepath, 'utf-8')
   const data = yaml.load(raw) || {}
@@ -476,7 +499,7 @@ async function processDataItem(dir, filename, siteRoot, collectionName, basePath
   if (Array.isArray(data)) {
     for (const item of data) {
       if (item && typeof item === 'object') {
-        await processDataItemAssets(item, filepath, siteRoot, collectionName, basePath)
+        await processDataItemAssets(item, filepath, siteRoot, poolDirs, basePath)
       }
     }
     return data
@@ -486,7 +509,7 @@ async function processDataItem(dir, filename, siteRoot, collectionName, basePath
   if (data.published === false) return null
   const slug = basename(filename, extname(filename))
   const item = { slug, ...data }
-  await processDataItemAssets(item, filepath, siteRoot, collectionName, basePath)
+  await processDataItemAssets(item, filepath, siteRoot, poolDirs, basePath)
   return item
 }
 
@@ -501,7 +524,7 @@ async function processDataItem(dir, filename, siteRoot, collectionName, basePath
  * @param {string} filename - JSON filename
  * @returns {Promise<Object|Array|null>} Processed item(s) or null if unpublished
  */
-async function processJsonItem(dir, filename, siteRoot, collectionName, basePath) {
+async function processJsonItem(dir, filename, siteRoot, poolDirs, basePath) {
   const filepath = join(dir, filename)
   const raw = await readFile(filepath, 'utf-8')
   const slug = basename(filename, '.json')
@@ -511,7 +534,7 @@ async function processJsonItem(dir, filename, siteRoot, collectionName, basePath
   if (Array.isArray(data)) {
     for (const item of data) {
       if (item && typeof item === 'object') {
-        await processDataItemAssets(item, filepath, siteRoot, collectionName, basePath)
+        await processDataItemAssets(item, filepath, siteRoot, poolDirs, basePath)
       }
     }
     return data
@@ -520,7 +543,7 @@ async function processJsonItem(dir, filename, siteRoot, collectionName, basePath
   // Object → single item
   if (data.published === false) return null
   const item = { slug, ...data }
-  await processDataItemAssets(item, filepath, siteRoot, collectionName, basePath)
+  await processDataItemAssets(item, filepath, siteRoot, poolDirs, basePath)
   return item
 }
 
@@ -556,7 +579,7 @@ async function processBibtexItem(dir, filename) {
  * @param {string} siteRoot - Site root directory for asset resolution
  * @returns {Promise<Object|null>} Processed item or null if unpublished
  */
-async function processContentItem(dir, filename, config, siteRoot, basePath) {
+async function processContentItem(dir, filename, config, siteRoot, basePath, poolDirs) {
   const filepath = join(dir, filename)
   const raw = await readFile(filepath, 'utf-8')
   const slug = basename(filename, extname(filename))
@@ -574,13 +597,13 @@ async function processContentItem(dir, filename, config, siteRoot, basePath) {
 
   // Process assets (resolve paths, copy co-located files)
   // This modifies content in place, updating paths to site-root-relative
-  await processCollectionAssets(content, filepath, siteRoot, config.name, basePath)
+  await processRecordAssets(content, filepath, siteRoot, poolDirs, basePath)
 
   // Extract excerpt
   const excerpt = extractExcerpt(frontmatter, content, config.excerpt)
 
   // Extract first image (frontmatter takes precedence)
-  // Note: paths in content have already been updated by processCollectionAssets
+  // Note: paths in content have already been updated by processRecordAssets
   const image = frontmatter.image || extractFirstImage(content)
 
   return {
@@ -631,7 +654,7 @@ async function collectSourceFiles(dir, rel = '') {
  * whichever sorts last wins the route and the per-record file. That is a real
  * ambiguity only the author can resolve, so it is reported rather than repaired.
  */
-function warnDuplicateSlugs(items, collectionName) {
+function warnDuplicateSlugs(items, queryName) {
   const seen = new Map()
   for (const item of items) {
     if (!item || item.slug === undefined) continue
@@ -639,7 +662,7 @@ function warnDuplicateSlugs(items, collectionName) {
     const where = item.path ? `${item.path}/` : ''
     if (seen.has(slug)) {
       console.warn(
-        `[collection-processor] Collection "${collectionName}" has more than one record with ` +
+        `[query-processor] Query "${queryName}" has more than one record with ` +
           `slug "${slug}" (${seen.get(slug)}${slug}, ${where}${slug}). Its detail route and ` +
           `per-record file resolve to only one of them — give them distinct slugs.`
       )
@@ -656,41 +679,49 @@ function warnDuplicateSlugs(items, collectionName) {
  * @param {Object} config - Parsed collection config
  * @returns {Promise<Array>} Array of processed items
  */
-async function collectItems(siteDir, config, collectionsBase, basePath) {
-  const base = collectionsBase || siteDir
-  const collectionDir = resolve(base, config.path)
-
-  // Check if collection directory exists
-  if (!existsSync(collectionDir)) {
-    console.warn(`[collection-processor] Collection folder not found: ${config.path}`)
-    return []
-  }
-
-  const itemFiles = await collectSourceFiles(collectionDir)
-
-  // Process all collection files (markdown → content items, YAML/JSON → data
-  // items, BibTeX → CSL-JSON bibliography items).
+async function collectItems(siteDir, config, entitiesDir, basePath) {
+  // ⭐ THE QUERY NAMES A SCHEMA AND THE POOL FOLLOWS — the same resolution the
+  // sync lane makes, from the same reader, so the two lanes cannot disagree
+  // about which files are a query's records. They used to: this one recursed
+  // into a collection directory and sync did not.
+  const pooled = config.poolEntities || []
+  if (pooled.length === 0) return []
+
+  const dirOf = (e) => resolve(siteDir, entitiesDir || ENTITIES_DIR, ...e.dirs)
+
+  // Process all entity files (markdown → content items, YAML/JSON → data items,
+  // BibTeX → CSL-JSON bibliography items).
   let items = await Promise.all(
-    itemFiles.map(file => {
-      if (file.endsWith('.bib')) {
-        return processBibtexItem(collectionDir, file)
+    pooled.map((e) => {
+      const dir = dirOf(e)
+      const file = `${e.slug}${e.ext}`
+      if (e.ext === '.bib') {
+        return processBibtexItem(dir, file)
       }
-      if (file.endsWith('.json')) {
-        return processJsonItem(collectionDir, file, siteDir, config.name, basePath)
+      if (e.ext === '.json') {
+        return processJsonItem(dir, file, siteDir, e.dirs.join('/'), basePath)
       }
-      if (file.endsWith('.yml') || file.endsWith('.yaml')) {
-        return processDataItem(collectionDir, file, siteDir, config.name, basePath)
+      if (e.ext === '.yml' || e.ext === '.yaml') {
+        return processDataItem(dir, file, siteDir, e.dirs.join('/'), basePath)
       }
-      return processContentItem(collectionDir, file, config, siteDir, basePath)
+      return processContentItem(dir, file, config, siteDir, basePath, e.dirs.join('/'))
     })
   )
 
-  // Stamp each record's position inside the collection BEFORE flattening, while
-  // a result is still aligned with the file it came from. A file's own array
-  // entries (array-form YAML/JSON, every .bib entry) all share its directory.
+  // ⭐ `path` IS THE PLACEMENT `records.yml` GAVE THE RECORD, and it is the whole
+  // reason folders exist: `where: { path: { under: 'archive' } }` is how a query
+  // asks for a slice. Structure is query scope, not navigation.
+  //
+  // ⛔ THIS WAS HARDCODED TO `''` FOR A WHILE, AND THE COMMENT SAID "until the
+  // folder producer lands". It landed, and this was not revisited — so every
+  // folder slice matched NOTHING on the delivery lane, silently, which is the one
+  // failure mode the whole design is built to prevent. Measured before the fix: a
+  // two-record site with an `archive` folder returned `[]` for its own slice.
+  //
+  // ⚠️ It stays a SCALAR. `matchUnder` in `core/src/where.js` is string-only, so
+  // an array would match nothing — one placement per entity is the ruling.
   items = items.map((result, i) => {
-    const dir = dirname(itemFiles[i])
-    const path = dir === '.' ? '' : dir
+    const path = pooled[i] ? (config.placements?.get(pooled[i].id)?.path ?? '') : ''
     if (Array.isArray(result)) return result.map((item) => item && { ...item, path })
     return result && { ...result, path }
   })
@@ -713,7 +744,21 @@ async function collectItems(siteDir, config, collectionsBase, basePath) {
     }))
   }
 
-  // Apply custom filter
+  // ⛔ ORDER MATCHES `data-fetcher.js::applyPostProcessing` — where, filter, sort,
+  // limit. Two lanes evaluate the same declaration (this one materializes a query
+  // to `/data/<name>.json`; that one runs a page-level `fetch:`), so a difference
+  // in order is a difference in RESULT for any query that both narrows and limits.
+  //
+  // ⚠️ `where` was missing here entirely until 2026-08-29: `parseQueryConfig`
+  // read `filter` and never `where`, so the CANONICAL predicate was parsed, put on
+  // the sync wire, stored — and never applied, while the DEPRECATED one it replaced
+  // worked. An author following current guidance got silence and shipped unfiltered
+  // data. Pinned by `tests/collection-query-terms.test.js`.
+  if (config.where) {
+    items = applyWhere(items, config.where)
+  }
+
+  // Apply the legacy filter expression (deprecated)
   if (config.filter) {
     items = applyFilter(items, config.filter)
   }
@@ -735,28 +780,68 @@ async function collectItems(siteDir, config, collectionsBase, basePath) {
  * Process all content collections defined in site.yml
  *
  * @param {string} siteDir - Site root directory
- * @param {Object} collectionsConfig - Collections config from site.yml
+ * @param {Object} queriesConfig - the resolved QUERY declarations
+ * @param {string} [entitiesDir] - pool directory override (`site.yml::paths.entities`)
  * @returns {Promise<Object>} Map of collection name to items array
  *
  * @example
- * const collections = await processCollections('/path/to/site', {
+ * const collections = await processQueries('/path/to/site', {
  *   articles: { path: 'collections/articles', sort: 'date desc' },
  *   products: 'collections/products'
  * })
  * // { articles: [...], products: [...] }
  */
-export async function processCollections(siteDir, collectionsConfig, collectionsBase, basePath = '/') {
-  if (!collectionsConfig || typeof collectionsConfig !== 'object') {
+export async function processQueries(siteDir, queriesConfig, entitiesDir, basePath = '/') {
+  if (!queriesConfig || typeof queriesConfig !== 'object') {
     return {}
   }
 
+  // ⭐ ONE POOL WALK FOR EVERY QUERY. Two queries over the same schema read one
+  // set of files; a query reads none of another schema's.
+  const pool = await readEntityPool(siteDir, { dir: entitiesDir })
+  if (pool.errors.length) {
+    for (const e of pool.errors) console.warn(`[query-processor] ${e}`)
+  }
+
+  // ⛔ `records.yml` DECIDES WHAT IS PUBLISHED ON THIS LANE TOO, and it did not
+  // until now. Only the sync lane honoured it, so removing a record from
+  // `records.yml` left it shipping in `/data/<name>.json` on every static host —
+  // an author unpublishes a draft and it stays public. Measured before the fix.
+  //
+  // ⚖️ MISSING IS NOT EMPTY HERE EITHER, but it means something different from
+  // what it means to sync. There is no server folder to leave alone, so a site
+  // with no `records.yml` is simply not managing publication, and its whole pool
+  // is delivered. (Making missing mean "publish nothing" would turn every site
+  // without the file into a silently empty one.)
+  const recordsCfg = await readRecordsConfig(siteDir)
+  if (recordsCfg.error) console.warn(`[query-processor] ${recordsCfg.error}`)
+  const managed = recordsCfg.state !== FOLDER_MISSING
+  const folder = managed ? resolveFolder(recordsCfg.entries, pool.entities) : null
+  if (folder) {
+    for (const e of folder.errors) console.error(`[query-processor] ${e}`)
+  }
+  const published = folder
+    ? pool.entities.filter((e) => folder.placements.has(e.id))
+    : pool.entities
+
+  const poolBySchema = groupPoolBySchema(published)
+
   const results = {}
 
-  for (const [name, config] of Object.entries(collectionsConfig)) {
-    const parsed = parseCollectionConfig(name, config)
-    const items = await collectItems(siteDir, parsed, collectionsBase, basePath)
+  for (const [name, config] of Object.entries(queriesConfig)) {
+    const parsed = parseQueryConfig(name, config)
+    parsed.poolEntities = parsed.schema ? poolBySchema.get(parsed.schema) || [] : []
+    parsed.placements = folder?.placements ?? null
+    if (parsed.poolEntities.length === 0 && !parsed.url) {
+      console.warn(
+        `[query-processor] Query "${name}" matches no records — nothing ` +
+          `published declares ${parsed.schema || '(no schema)'}. ` +
+          (managed ? 'Check records.yml lists them.' : 'Check entities/.')
+      )
+    }
+    const items = await collectItems(siteDir, parsed, entitiesDir, basePath)
     results[name] = items
-    console.log(`[collection-processor] Processed ${name}: ${items.length} items`)
+    console.log(`[query-processor] Processed ${name}: ${items.length} items`)
   }
 
   return results
@@ -802,7 +887,7 @@ async function pruneOrphanedRecords(dataDir, name, expected) {
   const contained = resolve(recordsDir)
   if (contained !== resolve(dataDir, name) || !contained.startsWith(resolve(dataDir) + sep)) {
     console.warn(
-      `[collection-processor] Refusing to prune "${name}" — it does not resolve ` +
+      `[query-processor] Refusing to prune "${name}" — it does not resolve ` +
       `inside ${dataDir}`
     )
     return []
@@ -826,22 +911,22 @@ async function pruneOrphanedRecords(dataDir, name, expected) {
  * @returns {Promise<void>}
  *
  * @example
- * await writeCollectionFiles('/path/to/site', {
+ * await writeQueryFiles('/path/to/site', {
  *   articles: [{ slug: 'hello', title: 'Hello World', ... }]
  * })
  * // Creates public/data/articles.json
  */
-export async function writeCollectionFiles(siteDir, collections, collectionsConfig = null) {
-  if (!collections || Object.keys(collections).length === 0) {
+export async function writeQueryFiles(siteDir, byQuery, queriesConfig = null) {
+  if (!byQuery || Object.keys(byQuery).length === 0) {
     return
   }
 
   const dataDir = join(siteDir, 'public', DATA_DIR)
   await mkdir(dataDir, { recursive: true })
 
-  for (const [name, items] of Object.entries(collections)) {
-    const rawConfig = collectionsConfig?.[name]
-    const parsed = rawConfig ? parseCollectionConfig(name, rawConfig) : null
+  for (const [name, items] of Object.entries(byQuery)) {
+    const rawConfig = queriesConfig?.[name]
+    const parsed = rawConfig ? parseQueryConfig(name, rawConfig) : null
     const deferred = parsed?.deferred
 
     if (deferred && deferred.length > 0) {
@@ -872,21 +957,21 @@ export async function writeCollectionFiles(siteDir, collections, collectionsConf
       const cascadePath = join(dataDir, `${name}.json`)
       await writeFile(cascadePath, JSON.stringify(stripped, null, 2))
       console.log(
-        `[collection-processor] Generated ${cascadePath} (${items.length} items, ` +
+        `[query-processor] Generated ${cascadePath} (${items.length} items, ` +
         `deferred: [${deferred.join(', ')}]) + ${perRecordCount} per-record files`
       )
       if (pruned.length > 0) {
         // A deletion is always worth naming. These files were public a moment
         // ago, so "which ones went" is the question an author will have.
         console.log(
-          `[collection-processor] Removed ${pruned.length} stale per-record ` +
+          `[query-processor] Removed ${pruned.length} stale per-record ` +
           `file(s) from ${recordsDir}: ${pruned.join(', ')}`
         )
       }
     } else {
       const filepath = join(dataDir, `${name}.json`)
       await writeFile(filepath, JSON.stringify(items, null, 2))
-      console.log(`[collection-processor] Generated ${filepath} (${items.length} items)`)
+      console.log(`[query-processor] Generated ${filepath} (${items.length} items)`)
 
       // This collection is not deferred, so it has no per-record files. If it
       // used to, the directory is still there and will never be written again
@@ -894,7 +979,7 @@ export async function writeCollectionFiles(siteDir, collections, collectionsConf
       const pruned = await pruneOrphanedRecords(dataDir, name, new Set())
       if (pruned.length > 0) {
         console.log(
-          `[collection-processor] Removed ${pruned.length} per-record file(s) ` +
+          `[query-processor] Removed ${pruned.length} per-record file(s) ` +
           `from ${join(dataDir, name)} — "${name}" no longer declares deferred:`
         )
       }
@@ -909,15 +994,15 @@ export async function writeCollectionFiles(siteDir, collections, collectionsConf
  * @param {Object} config - Collection config
  * @returns {Promise<Date|null>} Most recent modification time
  */
-export async function getCollectionLastModified(siteDir, config) {
-  const parsed = parseCollectionConfig('temp', config)
-  const collectionDir = join(siteDir, parsed.path)
+export async function getQueryLastModified(siteDir, config) {
+  const parsed = parseQueryConfig('temp', config)
+  const poolDir = join(siteDir, parsed.path)
 
-  if (!existsSync(collectionDir)) {
+  if (!existsSync(poolDir)) {
     return null
   }
 
-  const files = await readdir(collectionDir)
+  const files = await readdir(poolDir)
   const itemFiles = files.filter(f =>
     !f.startsWith('_') &&
     (f.endsWith('.md') || f.endsWith('.yml') || f.endsWith('.yaml') || f.endsWith('.json') || f.endsWith('.bib'))
@@ -926,7 +1011,7 @@ export async function getCollectionLastModified(siteDir, config) {
   let lastModified = null
 
   for (const file of itemFiles) {
-    const fileStat = await stat(join(collectionDir, file))
+    const fileStat = await stat(join(poolDir, file))
     if (!lastModified || fileStat.mtime > lastModified) {
       lastModified = fileStat.mtime
     }