uniweb 0.33.1 → 0.34.1

package/src/commands/build.js

@@ -592,7 +592,7 @@ function resolveFoundationDir(projectDir, siteConfig) {
  *
  * The `buildLocalizedContent` step is the same call bundle mode makes
  * post-vite, so multi-locale sites get identical per-locale outputs in
- * either mode. Collection translation (`buildLocalizedCollections`)
+ * either mode. Collection translation (`buildLocalizedRecords`)
  * also runs here so deploy ships translated collection JSONs.
  *
  * Bug surfaced + fixed by routing deploy through this path: the bundle
@@ -652,28 +652,28 @@ async function buildSiteLink(projectDir, options = {}) {
       // Collection translations — optional; don't fail the build if
       // missing. Bundle mode does the same.
       try {
-        const { buildLocalizedCollections } = await import('@uniweb/build/i18n')
-        const collectionOutputs = await buildLocalizedCollections(projectDir, {
+        const { buildLocalizedRecords } = await import('@uniweb/build/i18n')
+        const recordOutputs = await buildLocalizedRecords(projectDir, {
           locales: i18nConfig.locales,
           outputDir: distDir,
-          collectionsLocalesDir: join(
+          recordLocalesDir: join(
             projectDir,
             i18nConfig.localesDir,
-            'collections'
+            'records'
           )
         })
-        const collectionCount = Object.values(collectionOutputs).reduce(
+        const recordCount = Object.values(recordOutputs).reduce(
           (sum, localeOutputs) => sum + Object.keys(localeOutputs).length,
           0
         )
-        if (collectionCount > 0) {
+        if (recordCount > 0) {
           success(
-            `Translated collections for ${Object.keys(collectionOutputs).length} locale(s)`
+            `Translated records for ${Object.keys(recordOutputs).length} locale(s)`
           )
         }
       } catch (err) {
         if (process.env.UNIWEB_DEBUG)
-          console.error('Collection translation:', err.message)
+          console.error('Record translation:', err.message)
       }
     } catch (err) {
       error(`i18n build failed: ${err.message}`)
@@ -772,33 +772,33 @@ async function buildSite(projectDir, options = {}) {
 
       // Translate collections if they exist
       try {
-        const { buildLocalizedCollections } = await import('@uniweb/build/i18n')
+        const { buildLocalizedRecords } = await import('@uniweb/build/i18n')
 
-        const collectionOutputs = await buildLocalizedCollections(projectDir, {
+        const recordOutputs = await buildLocalizedRecords(projectDir, {
           locales: i18nConfig.locales,
           outputDir: join(projectDir, 'dist'),
-          collectionsLocalesDir: join(
+          recordLocalesDir: join(
             projectDir,
             i18nConfig.localesDir,
-            'collections'
+            'records'
           )
         })
 
         // Count collections translated
-        const collectionCount = Object.values(collectionOutputs).reduce(
+        const recordCount = Object.values(recordOutputs).reduce(
           (sum, localeOutputs) => sum + Object.keys(localeOutputs).length,
           0
         )
 
-        if (collectionCount > 0) {
+        if (recordCount > 0) {
           success(
-            `Translated collections for ${Object.keys(collectionOutputs).length} locale(s)`
+            `Translated records for ${Object.keys(recordOutputs).length} locale(s)`
           )
         }
       } catch (err) {
         // Collection translation is optional, don't fail build
         if (process.env.UNIWEB_DEBUG) {
-          console.error('Collection translation:', err.message)
+          console.error('Record translation:', err.message)
         }
       }
     } catch (err) {

package/src/commands/clone.js

@@ -24,7 +24,7 @@
  *      seed;
  *   4. install, then delegate the projection to the project-local `uniweb pull` (which
  *      resolves the now-installed project-local `@uniweb/build`; clone forwards
- *      `--no-collections` to it when set).
+ *      `--no-records` to it when set).
  *
  * Sites are private — authenticate with `uniweb login` first; the session carries
  * identity + the backend origin. There is no `--foundation` flag: the site carries
@@ -37,7 +37,7 @@
  *                                        the current workspace when run inside one)
  *   uniweb clone <uuid> --path sites     Place under sites/ (segregated layout)
  *   uniweb clone <uuid> --project docs   Co-located docs/site
- *   uniweb clone <uuid> --no-collections Pull pages only; skip collection records
+ *   uniweb clone <uuid> --no-records Pull pages only; skip records
  *
  * Backend: via BackendClient (the site-content pull lane). Origin from
  *   --registry  >  UNIWEB_REGISTER_URL  >  the local default (internal dev overrides;
@@ -176,7 +176,7 @@ export async function clone(args = [], deps = {}) {
   if (!siteUuid) {
     error('Missing site uuid.')
     log(
-      `\nUsage: ${getCliPrefix()} clone <site-uuid> [name|.] [--path <dir>] [--project <name>] [--no-collections]`
+      `\nUsage: ${getCliPrefix()} clone <site-uuid> [name|.] [--path <dir>] [--project <name>] [--no-records]`
     )
     log(
       `${colors.dim}Sites are private — run \`uniweb login\` first.${colors.reset}`
@@ -184,8 +184,8 @@ export async function clone(args = [], deps = {}) {
     return { exitCode: 2 }
   }
 
-  const noCollections =
-    args.includes('--no-collections') || args.includes('--content-only')
+  const noRecords =
+    args.includes('--no-records') || args.includes('--content-only')
   const pathFlag = flagValue(args, '--path')
   const projectFlag = flagValue(args, '--project')
   const tokenFlag = flagValue(args, '--token')
@@ -386,7 +386,7 @@ export async function clone(args = [], deps = {}) {
   // bytes on disk, not of what the scaffolder first wrote.
   recordWritten(
     siteDir,
-    ['site.yml', 'theme.yml', 'head.html', 'collections.yml']
+    ['site.yml', 'theme.yml', 'head.html', 'queries.yml', 'records.yml']
       .map((f) => join(siteDir, f))
       .filter((p) => existsSync(p))
   )
@@ -394,7 +394,7 @@ export async function clone(args = [], deps = {}) {
   const pullExtra = []
   if (explicitBackend) pullExtra.push('--backend', explicitBackend)
   if (tokenFlag) pullExtra.push('--token', tokenFlag)
-  if (noCollections) pullExtra.push('--no-collections')
+  if (noRecords) pullExtra.push('--no-records')
 
   if (deps.skipPull) {
     note('Skipping pull (test mode).')

package/src/commands/content.js

@@ -162,8 +162,7 @@ async function contentExport(args) {
     if (entity.layout_sections?.length)
       counts.layout_sections = entity.layout_sections.length
     if (entity.extensions?.length) counts.extensions = entity.extensions.length
-    if (entity.collections?.length)
-      counts.collections = entity.collections.length
+    if (entity.queries?.length) counts.queries = entity.queries.length
   }
 
   console.log('')
@@ -198,6 +197,6 @@ async function contentExport(args) {
     )
   }
   console.log('')
-  say.warn('v0 scope: media bytes, collection records, and @-nested section')
+  say.warn('v0 scope: media bytes, records, and @-nested section')
   say.dim('hierarchy are not yet carried (documented).')
 }

package/src/commands/doctor.js

@@ -153,8 +153,8 @@ function loadSiteYml(dir) {
 /**
  * Diagnose the compiled-collection output directory.
  *
- * `public/<DATA_DIR>/` holds what the build compiles from `collections/`, and
- * nothing else — `collections/` is the only supported way to provide
+ * `public/<DATA_DIR>/` holds what the build compiles from `entities/`, and
+ * nothing else — `entities/` + `records.yml` is the only supported way to provide
  * structured data. Two consequences, both checked here:
  *
  * 1. **The mapping is a bijection.** Every entry should be backed by a
@@ -548,9 +548,33 @@ export async function checkFormSubmitTarget({ sitePath, siteName, siteYml, issue
   )
 }
 
+/** The bare map in `queries.yml`, or `{}` when there is none. */
+function readQueriesYml(sitePath) {
+  try {
+    const doc = yaml.load(readFileSync(join(sitePath, 'queries.yml'), 'utf8'))
+    return doc && typeof doc === 'object' && !Array.isArray(doc) ? doc : {}
+  } catch {
+    return {}
+  }
+}
+
 function checkGeneratedDataDir({ sitePath, siteName, siteYml, issues, shouldFix, fixed }) {
   const dataDir = join(sitePath, 'public', DATA_DIR)
-  const declared = new Set(Object.keys(siteYml.collections || {}))
+  // ⚠️ THE QUERIES, not the pool. `public/<DATA_DIR>/x.json` is a query's
+  // MATERIALIZATION — one file per named query — so the bijection is with the
+  // declared queries, never with the schema folders under `entities/`.
+  //
+  // ⛔ BOTH HOMES, or this reports every compiled file as an orphan. A site that
+  // keeps its queries in `queries.yml` has none in `site.yml`, and reading one
+  // file would turn the whole check into a false positive — the loudest possible
+  // failure for a check whose job is to find stale output.
+  //
+  // Read directly rather than through `resolveQueriesConfig`: this pass is
+  // synchronous, and it needs the NAMES rather than resolved declarations.
+  const declared = new Set([
+    ...Object.keys(siteYml.queries || {}),
+    ...Object.keys(readQueriesYml(sitePath))
+  ])
 
   if (existsSync(dataDir)) {
     // A collection `x` owns `x.json` (the cascade) and `x/` (per-record files
@@ -565,16 +589,16 @@ function checkGeneratedDataDir({ sitePath, siteName, siteYml, issues, shouldFix,
       .map((entry) => (entry.isDirectory() ? `${entry.name}/` : entry.name))
 
     if (orphans.length > 0) {
-      const id = 'orphaned-collection-output'
+      const id = 'orphaned-query-output'
       issues.push({
         id,
         type: 'warning',
         site: siteName,
-        message: `${orphans.length} entr${orphans.length === 1 ? 'y' : 'ies'} in public/${DATA_DIR}/ with no declared collection`
+        message: `${orphans.length} entr${orphans.length === 1 ? 'y' : 'ies'} in public/${DATA_DIR}/ with no declared query`
       })
       warn(`[${id}] Stale output in public/${DATA_DIR}/: ${orphans.join(', ')}`)
       log(
-        `    No collection in site.yml produces ${orphans.length === 1 ? 'it' : 'these'}. ` +
+        `    No query produces ${orphans.length === 1 ? 'it' : 'these'}. ` +
         `${orphans.length === 1 ? 'It is' : 'They are'} still served and deployed.`
       )
       if (shouldFix(id)) {
@@ -614,7 +638,7 @@ function checkGeneratedDataDir({ sitePath, siteName, siteYml, issues, shouldFix,
       const body = existing === null ? '' : existing.replace(/\n*$/, '\n')
       writeFileSync(
         gitignorePath,
-        `${body}\n# Compiled collections — generated from collections/\n${rule}\n`
+        `${body}\n# Compiled query results — generated from entities/ + queries.yml\n${rule}\n`
       )
       fixed(`added ${rule} to ${gitignorePath}`)
       if (existsSync(dataDir)) {
@@ -891,9 +915,9 @@ export async function doctor(args = []) {
     }
 
     // `public/<DATA_DIR>/` is the build's output directory and nothing else —
-    // `collections/` is the only supported way to provide structured data. That
-    // makes the mapping a bijection: every entry there should be backed by a
-    // declared collection, so anything else is stale, and identifiable.
+    // `entities/` + `records.yml` is the only supported way to provide structured
+    // data. That makes the mapping a bijection: every entry there should be backed
+    // by a declared QUERY, so anything else is stale, and identifiable.
     //
     // It matters because the directory is written into the source tree rather
     // than dist/, so what lands there persists and gets deployed. A collection

package/src/commands/i18n.js

@@ -242,13 +242,13 @@ async function loadSiteConfig(siteRoot) {
 async function runExtract(siteRoot, config, args) {
   const verbose = args.includes('--verbose') || args.includes('-v')
   const dryRun = args.includes('--dry-run')
-  const collectionsOnly =
-    args.includes('--collections-only') || args.includes('--collections')
-  const noCollections = args.includes('--no-collections')
+  const recordsOnly =
+    args.includes('--records-only') || args.includes('--records')
+  const noRecords = args.includes('--no-records')
   // --with-collections is now a no-op (collections are included by default)
 
-  // Extract page content (unless --collections-only)
-  if (!collectionsOnly) {
+  // Extract page content (unless --records-only)
+  if (!recordsOnly) {
     log(
       `\n${colors.cyan}Extracting translatable content${dryRun ? ' (dry run)' : ''}...${colors.reset}\n`
     )
@@ -309,43 +309,43 @@ async function runExtract(siteRoot, config, args) {
     }
   }
 
-  // Extract collection content (by default, skip with --no-collections)
-  if (!noCollections) {
+  // Extract collection content (by default, skip with --no-records)
+  if (!noRecords) {
     log(
-      `\n${colors.cyan}Extracting collection content${dryRun ? ' (dry run)' : ''}...${colors.reset}\n`
+      `\n${colors.cyan}Extracting record content${dryRun ? ' (dry run)' : ''}...${colors.reset}\n`
     )
 
     // Check if collections exist
     const dataDir = join(siteRoot, 'public', DATA_DIR)
     if (!existsSync(dataDir)) {
-      if (collectionsOnly) {
-        error('No collections found. Create collection data in public/data/.')
+      if (recordsOnly) {
+        error('No records found. Add entities under entities/ and list them in records.yml.')
         process.exit(1)
       }
-      log(`${colors.dim}No collections found in public/data/.${colors.reset}`)
+      log(`${colors.dim}No records found in public/data/.${colors.reset}`)
       return
     }
 
     try {
-      const { extractCollectionManifest, formatSyncReport } =
+      const { extractRecordManifest, formatSyncReport } =
         await import('@uniweb/build/i18n')
 
-      const collectionsManifestPath = join(
+      const recordManifestPath = join(
         siteRoot,
         config.localesDir,
-        'collections',
+        'records',
         'manifest.json'
       )
-      const isUpdate = existsSync(collectionsManifestPath)
+      const isUpdate = existsSync(recordManifestPath)
 
-      const { manifest, report } = await extractCollectionManifest(siteRoot, {
+      const { manifest, report } = await extractRecordManifest(siteRoot, {
         localesDir: config.localesDir,
         dryRun
       })
 
       const unitCount = Object.keys(manifest.units).length
       if (unitCount > 0) {
-        success(`Extracted ${unitCount} translatable strings from collections`)
+        success(`Extracted ${unitCount} translatable strings from records`)
 
         if (report && isUpdate) {
           log('')
@@ -356,18 +356,18 @@ async function runExtract(siteRoot, config, args) {
           log(`\n${colors.dim}Dry run — no files were modified.${colors.reset}`)
         } else {
           log(
-            `\nManifest written to: ${colors.dim}${config.localesDir}/collections/manifest.json${colors.reset}`
+            `\nManifest written to: ${colors.dim}${config.localesDir}/records/manifest.json${colors.reset}`
           )
         }
       } else {
         log(
-          `${colors.dim}No translatable content found in collections.${colors.reset}`
+          `${colors.dim}No translatable content found in records.${colors.reset}`
         )
       }
     } catch (err) {
-      error(`Collection extraction failed: ${err.message}`)
+      error(`Record extraction failed: ${err.message}`)
       if (verbose) console.error(err)
-      if (collectionsOnly) process.exit(1)
+      if (recordsOnly) process.exit(1)
     }
   }
 }
@@ -652,7 +652,7 @@ async function runStatusFreeform(siteRoot, config, locale, options = {}) {
       const allPaths = [
         ...discovered.pages,
         ...discovered.pageIds,
-        ...discovered.collections
+        ...discovered.records
       ]
 
       // Check staleness
@@ -988,11 +988,11 @@ async function runAudit(siteRoot, config, args) {
  * Usage:
  *   uniweb i18n init-freeform es pages/about hero
  *   uniweb i18n init-freeform es page-ids/installation intro
- *   uniweb i18n init-freeform es collections/articles getting-started
+ *   uniweb i18n init-freeform es entities/article getting-started
  */
 async function runInitFreeform(siteRoot, config, args) {
   const locale = args[0]
-  const pathType = args[1] // pages/about, page-ids/installation, collections/articles
+  const pathType = args[1] // pages/about, page-ids/installation, entities/article
   const sectionId = args[2] // hero, intro, getting-started
 
   if (!locale || !pathType || !sectionId) {
@@ -1001,7 +1001,7 @@ async function runInitFreeform(siteRoot, config, args) {
     log('  uniweb i18n init-freeform es pages/about hero')
     log('  uniweb i18n init-freeform es page-ids/installation intro')
     log(
-      `  uniweb i18n init-freeform es collections/articles getting-started${colors.reset}`
+      `  uniweb i18n init-freeform es entities/article getting-started${colors.reset}`
     )
     process.exit(1)
   }
@@ -1057,15 +1057,29 @@ async function runInitFreeform(siteRoot, config, args) {
           if (sourceContent) break
         }
       }
-    } else if (pathType.startsWith('collections/')) {
-      // Find item in collection data
-      const collectionName = pathType.replace('collections/', '')
-      const dataPath = join(
-        siteRoot,
-        'public',
-        'data',
-        `${collectionName}.json`
-      )
+    } else if (pathType.startsWith('entities/')) {
+      // ⛔ ADDRESSED BY THE RECORD, matching where the loader reads. The freeform
+      // tree is `entities/<schema dirs>/<slug>.md`; this used to take
+      // `collections/<query>` and write a path nothing read — the loader moved
+      // and this did not.
+      //
+      // The record's CONTENT still lives in a query's materialization, so the
+      // query that covers this schema is resolved rather than named.
+      const poolDirs = pathType.replace('entities/', '')
+      const { resolveQueriesConfig, poolDirsForSchema } = await import('@uniweb/build/uwx')
+      let queryName = null
+      try {
+        const { declarations } = await resolveQueriesConfig(siteRoot)
+        for (const [name, decl] of Object.entries(declarations || {})) {
+          const dirs = decl.schema ? poolDirsForSchema(decl.schema) : null
+          if (dirs && dirs.join('/') === poolDirs) { queryName = name; break }
+        }
+      } catch {
+        /* no resolvable config — fall through to the not-found message below */
+      }
+      const dataPath = queryName
+        ? join(siteRoot, 'public', 'data', `${queryName}.json`)
+        : join(siteRoot, 'public', 'data', '__none__.json')
 
       if (existsSync(dataPath)) {
         const dataRaw = await readFile(dataPath, 'utf-8')
@@ -1607,8 +1621,8 @@ ${colors.bright}Options:${colors.reset}
   --freeform           (status/prune) Include free-form translation status
   --json               (status) Output as JSON for translation tools
   --by-page            (status --missing) Group missing strings by page
-  --collections-only   (extract/status/audit) Process only collections
-  --no-collections     (extract/status/audit) Skip collections (pages only)
+  --records-only   (extract/status/audit) Process only records
+  --no-records     (extract/status/audit) Skip records (pages only)
   --all-stale          (update-hash) Update all stale translations at once
 
 ${colors.bright}Configuration:${colors.reset}
@@ -1638,14 +1652,14 @@ ${colors.bright}File Structure:${colors.reset}
         .manifest.json       Staleness tracking
         pages/about/hero.md  Translated content for /about page, hero section
         page-ids/install/intro.md  Translated content by page ID
-        collections/articles/getting-started.md
+        entities/article/getting-started.md
 
 ${colors.bright}Examples:${colors.reset}
   ${colors.dim}# Hash-based workflow${colors.reset}
   uniweb i18n extract                     # Extract all translatable strings
   uniweb i18n extract --dry-run           # Preview without writing
   uniweb i18n extract --verbose           # Show extracted strings
-  uniweb i18n extract --no-collections    # Pages only (skip collections)
+  uniweb i18n extract --no-records    # Pages only (skip records)
   uniweb i18n generate es fr              # Create starter files for Spanish and French
   uniweb i18n generate --empty            # Create files with empty values (for translators)
   uniweb i18n generate --force            # Overwrite existing locale files
@@ -1658,7 +1672,7 @@ ${colors.bright}Examples:${colors.reset}
   ${colors.dim}# Free-form workflow (complete section replacement)${colors.reset}
   uniweb i18n init-freeform es pages/about hero
   uniweb i18n init-freeform es page-ids/installation intro
-  uniweb i18n init-freeform es collections/articles getting-started
+  uniweb i18n init-freeform es entities/article getting-started
   uniweb i18n status --freeform    # Show free-form translation status
   uniweb i18n update-hash es --all-stale  # Update hashes after review
   uniweb i18n move pages/docs/setup pages/getting-started

package/src/commands/publish.js

@@ -70,6 +70,7 @@ import {
   readSiteIdentity
 } from '../utils/site-identity.js'
 import { isNonInteractive, confirm } from '../utils/interactive.js'
+import { guardEmptyRecords } from '../utils/records-guard.js'
 import { headProvenance } from '../utils/git.js'
 import {
   makeModelResolver,
@@ -93,7 +94,7 @@ import {
   readPaymentRefusal,
   reportPaymentRefusal
 } from '../backend/payment-handoff.js'
-import { reportSchemalessCollections } from '../utils/schemaless-report.js'
+import { reportSchemalessQueries } from '../utils/schemaless-report.js'
 import { uploadSiteData } from '../utils/site-data-upload.js'
 
 const c = {
@@ -113,7 +114,20 @@ const say = {
   dim: (m) => console.log(`  ${c.dim}${m}${c.reset}`)
 }
 
-// Origin-relative serve path → clickable absolute URL (self-serve default).
+// Origin-relative serve path → clickable absolute URL.
+//
+// ⭐ THE TWO SHAPES ARE A CONTRACT, NOT AN INCONSISTENCY — ratified 2026-08-29 and
+// documented in the backend's `wire-layer.md` rather than merely observed. A publish
+// returns an ABSOLUTE url when Cloudflare hosts the site (another origin entirely)
+// and an ORIGIN-RELATIVE path when the backend serves it itself, where its own
+// external origin is not reliably self-reportable from behind an ALB.
+//
+// ⇒ So this branch is implementing the contract, not defending against drift. I
+// reported the two shapes as a violation of "finished values only" in collab
+// framework-backend-812b; the backend checked, found the adjacent ruling that
+// explains the relative arm, and ratified both. Do not "fix" it by demanding one
+// shape — the caller's own origin is the missing half on the relative arm, and we
+// are the caller.
 function absolutizeServeUrl(origin, url) {
   if (!url || typeof url !== 'string') return null
   if (/^https?:\/\//.test(url)) return url
@@ -234,15 +248,17 @@ export async function publish(args = []) {
   }
   const asOrg = org.asOrg
 
-  // Capability handshake (cached). Publish ends in a go-live, so the publish
-  // lane must be offered.
-  const config = await client.discover()
-  if (config?.delivery && config.delivery.publish === false) {
-    say.err(
-      `Backend at ${client.origin} does not offer the publish lane (delivery.publish=false).`
-    )
-    return { exitCode: 1 }
-  }
+  // ⛔ There is no capability gate here any more, deliberately.
+  //
+  // This used to read `delivery.publish` from the discovery document and refuse when it
+  // was false. It could never fire: the backend sent a literal true for every deployment,
+  // so the gate compared a constant against false. The key is now gone on both sides
+  // (2026-08-30). Restoring a reader for it would re-create a check that cannot fail
+  // while implying a capability that was never negotiable.
+  //
+  // Discovery is not consulted on this path at all. The one leaf the CLI still reads
+  // (`delivery.siteSubscriptionRequired`) is read after the site create, where a
+  // credential is already in hand.
 
   // ⛔ NOTHING about a runtime is sent from here. `site.yml::runtime` was a
   // vestigial prop and is no longer read [Diego, 2026-08-22]; `?runtime=` is no
@@ -436,6 +452,14 @@ export async function publish(args = []) {
   // Non-local @std/registry Model schemas resolve through the backend (same as push).
   const resolveModel = makeModelResolver({ client, offline: false })
 
+  // ⛔ AN EMPTY `records.yml` REMOVES. It is the one path where an ordinary act is
+  // destructive — a placeholder file, created meaning to fill it in — so the count
+  // is reported and confirmed before anything is sent.
+  {
+    const guard = await guardEmptyRecords({ siteDir, args, warn: say.warn, note: say.dim })
+    if (!guard.ok) return { exitCode: 1 }
+  }
+
   // 3. Partition collections by schema presence (a first emit reads `schemaless`
   //    — collections with no data schema, delivered statically via the ball).
   let probe
@@ -456,7 +480,7 @@ export async function publish(args = []) {
   // A product decision the author is usually making unknowingly — say it at warn
   // level, not dim among everything else. See the helper for what the old
   // message got wrong.
-  reportSchemalessCollections(probe.schemaless, say)
+  reportSchemalessQueries(probe.schemaless, say)
   const localAssets = probe.localAssets || []
 
   // 3a. A clone with no `$uuid` is bound to no backend site, so every cached map
@@ -579,7 +603,7 @@ export async function publish(args = []) {
   //     `client.discover()` is the mechanism if that changes — `DISCOVERY_DEFAULTS`
   //     makes an absent key non-breaking by construction.
   if (ball) {
-    say.info('Uploading collection data…')
+    say.info('Uploading schema-less record data…')
     try {
       const r = await uploadSiteData({
         apiBase: client.origin,
@@ -595,9 +619,9 @@ export async function publish(args = []) {
         for (const f of r.failed) say.dim(`  ${f.path} (HTTP ${f.status})`)
         return { exitCode: 1 }
       }
-      say.dim(`Collection data : ${r.uploaded.length} file(s) [${r.mode}]`)
+      say.dim(`Record data     : ${r.uploaded.length} file(s) [${r.mode}]`)
     } catch (err) {
-      say.err(`Collection data upload failed: ${err.message}`)
+      say.err(`Record data upload failed: ${err.message}`)
       return { exitCode: 1 }
     }
   }