@uniweb/build 0.64.1 → 0.65.0

package/src/site/record-file.js

@@ -0,0 +1,35 @@
+/**
+ * ⛔ A RECORD'S NAME IS ITS FILE'S NAME — and a file holds one record.
+ *
+ * [Diego, 2026-09-27] — *"`slug` is a concept that is WRONG. We do not build slugs from this."* A
+ * record's name is its name as an entry in its folder (`$name`): the file's name, whole, with no
+ * key inside the file to override it. And a file holds ONE record, so that name is always its own.
+ * ⛔ Until then a record file's top-level `slug:` renamed the record, and a YAML or JSON file
+ * holding a list was one record per entry, each named by its own `slug`.
+ *
+ * Refused where a record file is read — by the build (`query-processor.js`) and by a push
+ * (`uwx/entity-source.js`) alike — naming the file and what to do. A BibTeX file still holds its
+ * entries, each named by its cite key: that is the format's own name for an entry, not a key a
+ * record carries. A `slug` INSIDE a section is that section's field, the author's data like any
+ * other; only the record's own level is refused.
+ */
+
+/**
+ * @param {*} data - a record file's content: a markdown file's frontmatter, a YAML or JSON file's
+ * @param {string} where - the file, for the message
+ * @param {string} name - the file's name without its extension — the record's name
+ */
+export function refuseNotOneRecord(data, where, name) {
+  if (Array.isArray(data)) {
+    throw new Error(
+      `[uniweb] ${where} holds a list of records. A file holds one record, named by the file — ` +
+        `write each entry to a file of its own (\`<name>.yml\`, \`<name>.json\`), named as the record is.`
+    )
+  }
+  if (data && typeof data === 'object' && Object.prototype.hasOwnProperty.call(data, 'slug')) {
+    throw new Error(
+      `[uniweb] ${where}: \`slug:\` names nothing — a record's name is its file's name ("${name}"). ` +
+        `Remove the key; to give the record another name, rename the file.`
+    )
+  }
+}

package/src/site/records-config.js

@@ -352,3 +352,24 @@ export function resolveFolder(entries, pool, { dir = RECORDS_DIR } = {}) {
 
   return { nodes: [...branches, ...top], placements, errors, warnings }
 }
+
+/**
+ * The records of a folder tree in FOLDER-TREE ORDER — depth-first, each folder's records and
+ * folders in the order they sit, a folder's records where the folder sits. It is the order a
+ * question with no `sort` answers in, on both lanes (ruled 2026-09-27 [Diego]): the static lane
+ * reads the tree `resolveFolder` builds, which is the tree a push places in a backend's folder.
+ *
+ * @param {Array} nodes - a folder tree: `{ kind: 'ref', $entityId }` and `{ kind: 'branch', $children }`
+ * @returns {string[]} the records' ids, in folder-tree order
+ */
+export function folderTreeOrder(nodes) {
+  const out = []
+  const walk = (list) => {
+    for (const node of list || []) {
+      if (node?.kind === 'ref') out.push(node.$entityId)
+      else if (node?.kind === 'branch') walk(node.$children)
+    }
+  }
+  walk(nodes)
+  return out
+}

package/src/site/registered-foundation.js

@@ -11,8 +11,9 @@
  * trip, never a wrong answer: the next push or pull reads it again. That is what makes `.uniweb/`
  * (gitignored, per copy) the right home for it.
  *
- * The reply is kept whole, as the backend answered it — its `schema` is the foundation schema a
- * build would emit, less its data schemas, which travel as Models.
+ * Only its `schema` is kept — the foundation schema a build would emit, less its data schemas, which
+ * travel as Models. ⛔ The reply carries more than a project reads, a serve location among it; a serve
+ * location is decided at publish and read from the response that carries it, never kept here.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'

package/src/uwx/backfill.js

@@ -21,10 +21,12 @@
 // reaches the file on a pull (`records-project.js`), which restores asset paths first.
 //
 // Single-record YAML/JSON/markdown files are rendered/back-filled in place.
-// Multi-record files — array-form YAML/JSON and BibTeX (many records in one
-// file) — are grouped by file and written once, one `$uuid` per record keyed by
-// slug/cite-key. Anything genuinely unwritable is reported as 'deferred', never
-// silently skipped.
+// A BibTeX file (many records in one file) is grouped by file and written once,
+// one `$uuid` per record keyed by cite key. Anything genuinely unwritable is
+// reported as 'deferred', never silently skipped.
+// ⛔ A YAML or JSON file holding a list is refused before a push since 2026-09-27
+// (`site/record-file.js`: one record per file), so no entry reaches
+// `backfillArrayFile` from a push any more; it stays exported.
 
 import { readFileSync, writeFileSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
@@ -450,9 +452,9 @@ export function backfillEntityUuids({ index, finalized }) {
       continue
     }
     if (entry.multiRecord) {
-      // Many records in one file → group by file, written once. BibTeX and
-      // array-form YAML/JSON both re-render canonically (sync owns the output);
-      // the per-file writer is chosen by format below.
+      // Many records in one file → group by file, written once. BibTeX re-renders
+      // canonically (sync owns the output); the per-file writer is chosen by format
+      // below. (A YAML/JSON list file is refused before a push — header.)
       const group = entry.format === 'bib' ? bibFiles : arrayFiles
       let m = group.get(entry.sourceFile)
       if (!m) {

package/src/uwx/data-schema.js

@@ -141,31 +141,15 @@ export function toDataSchemaDeclaration(normalized, { name, resolveName, resolve
   // ⛔ No `creatable_by`: retired 2026-09-23 — Models are open, and `@uniweb/schemas`
   // refuses the key. (It was emitted here when authored.)
 
-  // `linkable` — DERIVED AND AUTHORED, and the two compose in one direction only.
+  // `linkable` — AUTHORED ONLY (2026-09-27 [Diego]). A model is linkable unless it says
+  // `linkable: false` (omitted ⇒ true), with or without a brief: only `linkable: false`
+  // keeps its entries out of references and out of a site's folder. A reference to a
+  // model with no brief carries no card, and that is not a reason to refuse one.
   //
-  // A brief-less model has no card to hydrate as an `entity_ref` target, so it
-  // cannot be linkable whatever it says; a model with a brief is linkable by
-  // default (omit ⇒ true). ⇒ **The derivation is a ceiling and the authored value
-  // may only lower it.** An author may say `linkable: false` on a model with a
-  // brief — a real choice, "do not let other models point at this" — and that is
-  // honoured.
-  //
-  // ⛔ The contradiction is refused rather than silently resolved: `linkable: true`
-  // on a brief-less model asks for something that cannot exist, and quietly
-  // ignoring it is how an author comes to believe a ref target works. Naming it
-  // costs one line and the message says which half to change.
-  if (!brief) {
-    if (normalized.linkable === true) {
-      throw new Error(
-        `Data schema '${name}': 'linkable: true' needs a brief section — a model with no brief ` +
-          `has no card to hydrate when another model references it. Mark a section 'brief: true', ` +
-          `or drop 'linkable'.`
-      )
-    }
-    decl.linkable = false
-  } else if (normalized.linkable === false) {
-    decl.linkable = false
-  }
+  // ⛔ Until then a brief-less model was emitted `linkable: false` and `linkable: true`
+  // on one was refused, on the reasoning that a reference would have no card to show —
+  // which kept its records out of every site's folder.
+  if (normalized.linkable === false) decl.linkable = false
 
   decl.sections = sections
   return decl

package/src/uwx/entity-source.js

@@ -39,6 +39,7 @@ const SOURCE_EXTENSIONS = new Set(['.md', '.yml', '.yaml', '.json', '.bib'])
 // (below), and a bare `export … from` creates NO local binding — the same
 // trap `core/src/index.js` carries a note about. It fails at runtime, not at
 // import time, so the suite is what catches it.
+import { refuseNotOneRecord } from '../site/record-file.js'
 import { parseFrontmatter } from '../utils/frontmatter.js'
 export { parseFrontmatter }
 
@@ -58,8 +59,9 @@ function formatFor(ext) {
  * ⭐ THE FILE IS THE UNIT NOW. `records/{schema}/` supplies the model, so
  * nothing above this needs a directory scan to know what a file is — the pool
  * reader (`site/entity-pool.js`) already walked the tree and paired each file
- * with its schema. A single-record file yields one record; array-form YAML/JSON
- * and BibTeX yield several, each carrying its own slug.
+ * with its schema. A record file yields one record, named by the file; a BibTeX file
+ * yields its entries, each named by its cite key. ⛔ A list in a YAML or JSON file, and a
+ * `slug:` naming a record, are refused (`site/record-file.js`, 2026-09-27).
  *
  * @param {string} filepath - absolute path to one entity source file
  * @returns {Promise<Array<{ slug, format, data, body, sourceFile, multiRecord }>>}
@@ -76,8 +78,8 @@ async function readOneFile(filepath) {
 
   if (format === 'md') {
     const { frontmatter, body } = parseFrontmatter(raw, filepath)
-    const slug = frontmatter.slug || slugFromName
-    return [{ slug, format, data: frontmatter, body, sourceFile: filepath, multiRecord: false }]
+    refuseNotOneRecord(frontmatter, filepath, slugFromName)
+    return [{ slug: slugFromName, format, data: frontmatter, body, sourceFile: filepath, multiRecord: false }]
   }
 
   if (format === 'bib') {
@@ -89,23 +91,10 @@ async function readOneFile(filepath) {
       .map((e) => ({ slug: e.id, format, data: e, body: undefined, sourceFile: filepath, multiRecord: true }))
   }
 
-  // yaml / json
+  // yaml / json — one record, named by the file (`site/record-file.js`)
   const data = format === 'json' ? JSON.parse(raw) : yaml.load(raw, YAML_OPTIONS)
-  if (Array.isArray(data)) {
-    // Many records in one file — each carries its own slug. Write-back deferred.
-    return data
-      .filter((item) => item && typeof item === 'object')
-      .map((item) => ({
-        slug: item.slug,
-        format,
-        data: item,
-        body: undefined,
-        sourceFile: filepath,
-        multiRecord: true,
-      }))
-  }
+  refuseNotOneRecord(data, filepath, slugFromName)
   const mapping = data && typeof data === 'object' ? data : {}
-  const slug = mapping.slug || slugFromName
-  return [{ slug, format, data: mapping, body: undefined, sourceFile: filepath, multiRecord: false }]
+  return [{ slug: slugFromName, format, data: mapping, body: undefined, sourceFile: filepath, multiRecord: false }]
 }
 

package/src/uwx/queries-config.js

@@ -5,7 +5,6 @@ export {
   resolveQueriesConfig,
   queriesYmlPath,
   defaultSchema,
-  deferredFromSchema,
   foundationDataSchemas,
   foundationSchemaJson,
   QUERIES_YML_RELPATH,

package/src/uwx/record-layout.js

@@ -40,7 +40,7 @@ export function recordFileLayout(declaration) {
  * The schema's CONTENT body field — the one a `.md` record's markdown body fills: a
  * markup `text` field (`format: markdown|html`) or a `format: prosemirror` json field,
  * declared directly on a top-level single section — the brief or another, like
- * `@std/article`'s `article_body.content`. The first in declared order.
+ * `@std/article`'s `body.content`. The first in declared order.
  *
  * ⛔ Not the brief's alone. Until 2026-09-24 the pull and the per-locale body override
  * looked only in the brief, while the push looked in every single section, so a body

package/src/uwx/records-project.js

@@ -40,9 +40,8 @@ import { join, resolve, relative, dirname, extname, basename, sep } from 'node:p
 import yaml from 'js-yaml'
 import { YAML_OPTIONS } from '../utils/yaml-schema.js'
 import { parseFrontmatter } from './entity-source.js'
-import { writeRecordFile, writeQueriesConfig, writeRecordsConfig, YAML_DUMP_OPTS } from './project-writer.js'
-import { canonicalJson } from './same-content.js'
-import { defaultSchema, deferredFromSchema, foundationDataSchemas, foundationSchemaJson, QUERIES_YML_RELPATH } from './queries-config.js'
+import { writeRecordFile, writeQueriesConfig, writeRecordsConfig } from './project-writer.js'
+import { defaultSchema, foundationDataSchemas, foundationSchemaJson, QUERIES_YML_RELPATH } from './queries-config.js'
 import { dataKeyTypes } from './data-key-types.js'
 import { poolDirsForSchema, schemaForPoolDirs, resolveRecordsDir } from '../site/entity-pool.js'
 import { folderYmlPath } from '../site/records-config.js'
@@ -51,8 +50,6 @@ import { unresolveSelfScope, resolveSelfScope, ownSchemaNames, refuseOrgOption }
 import { parseCatalogRef } from '../site/foundation-ref.js'
 import { unwrapLocalized, renderEntityDocument } from './backfill.js'
 import { parseBibtex } from '@citestyle/bibtex'
-import { getSchema as getStandardSchema, isStandardSchema } from '@uniweb/schemas'
-import { validateAndNormalizeSchema } from '../resolve-data-schema.js'
 import { createTranslationCollector, writeLocaleTranslations, writeFreeformTranslations } from './locale-sync.js'
 import { buildFreeformRecordPath } from '../i18n/freeform.js'
 
@@ -101,23 +98,20 @@ export function findRecordFileByUuid(poolDir, uuid) {
   return null
 }
 
-// ⭐ A RECORD KEPT IN A LIST FILE — a JSON or YAML array, or a BibTeX file: several records in one —
-// is found by its entry's `$uuid`, which the push's back-fill writes into each entry. ⛔ Until
-// 2026-09-25 a pull looked in single-record files alone, wrote each such record again as a file of
-// its own beside the list, and the next push held it twice — measured on the `international`
-// template's `records/team/team.json`.
+// ⭐ A RECORD KEPT IN A BIBTEX FILE — several entries in one — is found by its entry's `$uuid`, so
+// a pull does not write it again as a file of its own beside the list. ⛔ Until 2026-09-27 a JSON or
+// YAML array was such a list too; a file holds one record now (`site/record-file.js`).
 export function findListEntryByUuid(poolDir, uuid) {
   if (!uuid || !existsSync(poolDir)) return null
   for (const name of readdirSync(poolDir)) {
     if (name.startsWith('_')) continue
     const ext = extname(name).toLowerCase()
-    const format = ext === '.bib' ? 'bib' : formatForExt(ext)
-    if (format !== 'json' && format !== 'yaml' && format !== 'bib') continue
+    if (ext !== '.bib') continue
+    const format = 'bib'
     const path = join(poolDir, name)
     let entries
     try {
-      const text = readFileSync(path, 'utf8')
-      entries = format === 'json' ? JSON.parse(text) : format === 'yaml' ? yaml.load(text, YAML_OPTIONS) : parseBibtex(text)
+      entries = parseBibtex(readFileSync(path, 'utf8'))
     } catch {
       continue
     }
@@ -128,25 +122,6 @@ export function findListEntryByUuid(poolDir, uuid) {
   return null
 }
 
-// A pulled record written back into its entry of a JSON or YAML list, every other entry untouched.
-// The entry keeps its `slug`, which names it where a single-record file's name would.
-function writeRecordIntoList({ list, document, declaration, sourceLocale, collector, freeformRelPath, refName, context = null }) {
-  const text = readFileSync(list.path, 'utf8')
-  const entries = list.format === 'json' ? JSON.parse(text) : yaml.load(text, YAML_OPTIONS)
-  const rendered = renderEntityDocument({ document, declaration, format: list.format, sourceLocale, collector, freeformRelPath, refName, context })
-  const { $uuid, ...fields } = list.format === 'json' ? JSON.parse(rendered) : yaml.load(rendered, YAML_OPTIONS)
-  const slug = entries[list.index]?.slug
-  const entry = { ...($uuid ? { $uuid } : {}), ...(slug !== undefined ? { slug } : {}), ...fields }
-  // ⭐ An entry the pull did not change leaves the file as the author wrote it — its key order, its
-  // spacing, and a YAML file's comments. ⛔ Until 2026-09-26 the file was compared as text and re-dumped.
-  if (canonicalJson(entries[list.index]) === canonicalJson(entry)) return 'unchanged'
-  const next = entries.map((e, i) => (i === list.index ? entry : e))
-  const out = list.format === 'json' ? JSON.stringify(next, null, 2) + '\n' : yaml.dump(next, YAML_DUMP_OPTS)
-  if (out === text) return 'unchanged'
-  writeFileSync(list.path, out)
-  return 'updated'
-}
-
 // The format to give a NEW record file in a collection: match the collection's
 // existing single-record files, else markdown when the schema has a content body field
 // (so the body has a home), else YAML.
@@ -327,40 +302,12 @@ const DECL_WIRE_CONSUMED = new Set([
   'typed_by_data_key',
 ])
 
-// A standard schema (`@std/<name>`), normalized as the build resolves one — known with no foundation
-// on disk. ⛔ Until 2026-09-26 a clone, which has none, could not tell a derived `deferred:` from an
-// authored one and wrote it into the author's queries (`international`'s `articles`, over `@std/article`).
-function standardDataSchema(ref) {
-  const m = typeof ref === 'string' ? /^@std\/([^/]+)$/.exec(ref) : null
-  if (!m || !isStandardSchema(m[1])) return null
-  try {
-    return validateAndNormalizeSchema(getStandardSchema(m[1]), ref)
-  } catch {
-    return null
-  }
-}
-
-// Is this wire `deferred` exactly what the schema's brief would have derived? Compared
-// as an ORDER-INSENSITIVE set: the deriver walks the schema's sections, and a round trip
-// through YAML and the store is not obliged to preserve that order. Comparing as a list
-// would classify a reordered-but-identical value as authored, and persist it.
-function isDerivedDeferred(d, dataSchemas, pulledModel = null) {
-  if (!Array.isArray(d.deferred)) return false
-  // A clone has no foundation to read a schema from: it judges by the Model the pull read from the
-  // backend (`pulledModel`), and a standard schema is known in any case (`standardDataSchema`).
-  const derived = deferredFromSchema(dataSchemas?.[d.schema] ?? pulledModel ?? standardDataSchema(d.schema))
-  if (!derived || derived.length !== d.deferred.length) return false
-  const a = new Set(derived)
-  return d.deferred.every((f) => a.has(f))
-}
-
-function declToFileShape(wire, dataSchemas = null, scope = null, own = null, keyTypes = null, authored = null, models = null, markedOnly = false) {
+function declToFileShape(wire, scope = null, own = null, keyTypes = null, authored = null, markedOnly = false) {
   // ⛔ UNDO THE PRODUCER'S QUALIFICATION FIRST, before anything compares against
   // `schema`. The push qualifies a foundation-relative `@/x` to `@scope/x`
   // (`site.js::queriesNested`), and both checks below are keyed by the author's
   // `@/x`: against `@scope/x` the query-name default would never match — writing an
-  // explicit schema the author never had — and the derived-`deferred` lookup would
-  // miss, persisting a derivation into their file (the 2026-08-29 defect).
+  // explicit schema the author never had.
   const d = scope && typeof wire.schema === 'string'
     ? { ...wire, schema: unresolveSelfScope(wire.schema, scope, own) }
     : wire
@@ -407,26 +354,8 @@ function declToFileShape(wire, dataSchemas = null, scope = null, own = null, key
   setIf(decl, 'where', d.where)
   setIf(decl, 'limit', d.limit)
   setIf(decl, 'excerpt', d.excerpt)
-  // ⛔ DO NOT WRITE A DERIVATION INTO THE AUTHOR'S FILE. `deferred:` is derived from
-  // the schema's brief when unstated (`collections-config.js::deriveDeferredFromSchemas`)
-  // — framework's own test opens with "derived from a collection's data schema, NOT
-  // written by hand". But the deriver mutates the declaration in place, so by the time
-  // it reaches the wire an emitted `deferred` is indistinguishable from an authored one.
-  //
-  // ⚠️ Measured 2026-08-29: one push + one pull turned an unstated `deferred:` into a
-  // hardcoded list in `collections.yml` — a DIFFERENT file, at HIGHER precedence than
-  // the `site.yml` the collection was declared in. The collection then stopped tracking
-  // its schema's brief permanently, and nothing reported it.
-  //
-  // ⭐ This is exactly what the `schema` line above already does: emit on push (the
-  // backend needs the effective value), drop on pull when it merely restates what would
-  // be derived, so a terse author file stays terse and keeps tracking its schema.
-  //
-  // ⚖️ Only an EQUAL value is dropped. An author who deliberately writes a narrower or
-  // wider `deferred:` than the brief implies has expressed intent, and that survives.
-  if (d.deferred !== undefined && !isDerivedDeferred(d, dataSchemas, models?.[wire.schema] ?? null)) {
-    decl.deferred = d.deferred
-  }
+  // ⛔ A stored `deferred` is not written back: `deferred:` is retired (2026-09-27) and the build
+  // refuses it — a list carries each record's brief. A store may still hold one from an older push.
   // ⛔ A stored `detail_url` is not written back: `detailUrl:` is retired (2026-09-13)
   // and the build refuses it — its case is `record.url` on an external query.
   setIf(decl, 'queryable', d.queryable)
@@ -511,18 +440,14 @@ function typedQueryFolders(siteRoot, recordsRoot, scope, own, keyTypes) {
   return out
 }
 
-export function declarationsToQueriesYml({ document, siteRoot, scope, models = null, ...rest }) {
+export function declarationsToQueriesYml({ document, siteRoot, scope, ...rest }) {
   refuseOrgOption(rest, 'declarationsToQueriesYml')
   const decls = Array.isArray(document?.queries) ? document.queries : []
   const report = {}
   if (decls.length === 0) return report
 
-  // The foundation's data schemas, loaded ONCE for the whole projection — they are what
-  // lets `declToFileShape` tell a derived `deferred:` from an authored one. Absent (no
-  // foundation on disk, unbuilt, unresolvable) the inverter simply never fires and every
-  // `deferred` is treated as authored: the pre-2026-08-29 behaviour, which is the safe
-  // direction to fail — persisting a value that did not need persisting loses nothing,
-  // where dropping an AUTHORED one would.
+  // The foundation's data schemas and section types, loaded ONCE for the whole projection — which
+  // of the scope's schemas are its own, and the types of its data keys.
   let siteYml = null
   try {
     siteYml = yaml.load(readFileSync(join(siteRoot, 'site.yml'), 'utf8'), YAML_OPTIONS) || null
@@ -542,7 +467,7 @@ export function declarationsToQueriesYml({ document, siteRoot, scope, models = n
 
   const queries = {}
   for (const d of decls) {
-    const { name, decl } = declToFileShape(d, dataSchemas, selfScope, own, keyTypes, authored, models, markedOnly)
+    const { name, decl } = declToFileShape(d, selfScope, own, keyTypes, authored, markedOnly)
     if (!name) continue
     queries[name] = decl
   }
@@ -796,12 +721,10 @@ export function recordsToProject({ folderDoc, recordDocs = [], siteRoot, opts =
     const context = { key: [relative(recordsRoot, dirname(existing?.path ?? filePath)).split(sep).join('/'), where.slug].filter(Boolean).join('/') }
     let status
     try {
-      if (existing?.list && existing.format === 'bib') {
+      if (existing?.list) {
         // Kept as the author has it: a pull does not re-render BibTeX (said once per file, below).
         keptBib.add(existing.path)
         status = 'unchanged'
-      } else if (existing?.list) {
-        status = writeRecordIntoList({ list: existing, document: toWrite, declaration, sourceLocale, collector, freeformRelPath, refName, context })
       } else {
         status = writeRecordFile({ filePath, document: toWrite, declaration, format, sourceLocale, collector, freeformRelPath, refName, context })
       }

package/src/uwx/records.js

@@ -255,7 +255,7 @@ export function recordsToEntities({
   }
   // The markdown body of a `.md` record is the value of the schema's CONTENT body field,
   // wherever a top-level single section declares it — the brief, or a body section like
-  // `article_body.content`. One field is the target; zero means a body has nowhere to go.
+  // `body.content`. One field is the target; zero means a body has nowhere to go.
   const { target: bodyTarget, count: bodyFields } = contentBodyTarget(declaration)
 
   const entities = []
@@ -269,25 +269,6 @@ export function recordsToEntities({
         `"${bodyTarget.section}.${bodyTarget.key}"`
     )
   }
-  // ⛔ A SITE'S FOLDER PLACES ONLY A RECORD SOMETHING CAN REFERENCE. A folder entry is a
-  // reference, and a Model with no brief is not linkable (`toDataSchemaDeclaration`), so a
-  // backend refuses to place its records — measured 2026-09-25 as a `409 … linkable: false`,
-  // and by design (backend, 2026-09-26). Refused here, once for the schema, before anything
-  // is sent — and saying why, which the backend's refusal names only by its design doc.
-  if (declaration.linkable === false) {
-    const slugs = (records || []).map((r) => r?.slug).filter(Boolean)
-    if (slugs.length) {
-      const named = slugs.slice(0, 3).join(', ') + (slugs.length > 3 ? ` and ${slugs.length - 3} more` : '')
-      refusals.push(
-        `${label}: ${declaration.name} has no brief, so a site's folder cannot place its records ` +
-          `(${named}) — a folder entry is a reference, and only a record of a schema with a brief ` +
-          'can be one. Give the schema a brief (`brief: true` on one of its sections), or keep this ' +
-          'data out of records/.'
-      )
-    }
-    return { entities, warnings, refusals }
-  }
-
   for (const record of records || []) {
     const slug = record.slug
     if (!slug) {
@@ -415,12 +396,6 @@ function readFlat(layout, record, enc) {
   for (const [key, value] of Object.entries(record)) {
     if (!RECORD_KEYS.has(key)) values[key] = value
   }
-  // The record's handle fills a `slug` field the section declares, as the flat form
-  // always has (`@std/article`'s brief has one). Written by section, the field is
-  // written under its section like any other.
-  if (record.slug !== undefined && Object.hasOwn(def.fields || {}, 'slug') && values.slug === undefined) {
-    values.slug = record.slug
-  }
   return { [name]: encodeRecord(def.fields, values, enc, '', null) }
 }
 

package/src/uwx/site-project.js

@@ -1129,12 +1129,9 @@ function projectLayout(layoutSections, layoutBaseDir, report, prune, ctx) {
  * @param {string|null} [params.scope] - the scope the push qualified a query's
  *        `@/x` schema with, so it is written back as `@/x` — see
  *        `declarationsToQueriesYml`, whose default it overrides.
- * @param {Object<string,object>|null} [params.models] - the Models the site's queries name, as the
- *        pull read them from the backend, keyed by the ref on the wire — what a clone, with no
- *        foundation on disk, judges a query's derived `deferred:` by.
  * @returns {{ config: object, collections: object, locales: object, pages: string[], sections: string[], layout: string[], deleted: string[], renamed: object[] }}
  */
-export function siteContentDocumentToProject({ document, siteRoot, backend = null, sourceLocale = LOCALIZED_FIELD_ASSUMPTION.defaultSourceLocale, prune = false, keepAuthoredFoundation = false, scope, models = null }) {
+export function siteContentDocumentToProject({ document, siteRoot, backend = null, sourceLocale = LOCALIZED_FIELD_ASSUMPTION.defaultSourceLocale, prune = false, keepAuthoredFoundation = false, scope }) {
   const report = { config: null, collections: null, locales: null, assets: null, pages: [], sections: [], layout: [], deleted: [], renamed: [] }
 
   // Collects target-locale translations of localized scalars as they're projected;
@@ -1157,7 +1154,7 @@ export function siteContentDocumentToProject({ document, siteRoot, backend = nul
   )
 
   report.config = siteInfoToConfig({ document, siteRoot, backend, sourceLocale, collector, keepAuthoredFoundation, deferLanguages: true })
-  report.queries = declarationsToQueriesYml({ document, siteRoot, scope, models })
+  report.queries = declarationsToQueriesYml({ document, siteRoot, scope })
 
   // The uuid identity index (gitignored `.uniweb/`): read the prior map to anchor
   // rename detection, build a fresh one as we project, then persist it. Items not

package/src/uwx/site.js

@@ -939,7 +939,7 @@ export function isSiteRelativeExtensionUrl(decl) {
  *
  * The backend destructures exactly two — `name` and `schema` — and projects none of
  * this Section into a published payload, so the rest read as dead weight. ⛔ THEY ARE
- * OURS, AND THAT IS REASON ENOUGH: `excerpt`, `deferred`, `detailUrl` and `queryable`
+ * OURS, AND THAT IS REASON ENOUGH: `excerpt` and `queryable`
  * are read across FRAMEWORK's own runtime, build and kit — `useQueryable`
  * is a public hook a foundation calls to render a filter UI. They drive the file
  * lane, where they work. "The backend does not read it" was never an argument that
@@ -989,7 +989,6 @@ const DECL_EMITTED_ABOVE = new Set([
   'where',
   'limit',
   'excerpt',
-  'deferred',
   'queryable',
   // Derived by the rule above, never taken from a file.
   'typed_by_data_key',
@@ -1021,7 +1020,9 @@ const DECL_NOT_ON_WIRE = new Set([
   'route',
   // Legacy predicate, translated to the canonical `where` upstream. No legacy
   // fields on the wire.
-  'filter'
+  'filter',
+  // ⛔ RETIRED 2026-09-27 — the build refuses it (`refuseQueryDeclaration`), so it is never sent.
+  'deferred',
 ])
 
 /** An external query's source, as it rides in the `queries` Section's `source`. */
@@ -1066,7 +1067,6 @@ function queriesNested(declarations, uuids = null, scope = null, keyTyped = null
     setIf(data, 'where', d.where)
     setIf(data, 'limit', d.limit)
     setIf(data, 'excerpt', d.excerpt)
-    setIf(data, 'deferred', d.deferred)
     setIf(data, 'queryable', d.queryable)
     // ⛔ EMIT WHAT WE DO NOT MODEL. The decl's field set is the BACKEND's Model
     // (this document mirrors `@uniweb/site-content` — see the lane header), and
@@ -1290,8 +1290,8 @@ function settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translation
   // codes included: sync carries the full working set and only *publish* filters,
   // which preserves a locale's publish intent across a remove + re-add in `languages:`.
   // ⭐ A site that declares no `languages:` has the languages its translation files make — the build's
-  // rule (`i18n/locales.js`) — and sends that list (`languages`, below), as it sends a derived
-  // `deferred:`: a host may serve a site in the languages it declares and no others, and the site's
+  // rule (`i18n/locales.js`) — and sends that list (`languages`, below): a host may serve a site in
+  // the languages it declares and no others, and the site's
   // localized URLs with them. The pull does not write it back where the files already say it
   // (`siteContentDocumentToProject`). ⛔ Until 2026-09-26 only a declared list was sent, so the
   // `international` template, which declares none, sent no language but its source.

package/src/validate-data.js

@@ -258,7 +258,8 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
 
     items.forEach((item, idx) => {
       recordCount++
-      if (item && typeof item.slug === 'string') checkedRecords.add(recordKey(entry.ref, item.slug))
+      // A delivered record is named by `$name` — the handle its file's pool entry is keyed by.
+      if (item && typeof item.$name === 'string') checkedRecords.add(recordKey(entry.ref, item.$name))
       for (const finding of validateItem(entry.schema, item)) {
         violations.push({
           file: entry.path,
@@ -620,7 +621,7 @@ function toShippedShape(value) {
 
 function itemLabel(item, idx) {
   if (item && typeof item === 'object') {
-    if (typeof item.slug === 'string' && item.slug) return item.slug
+    if (typeof item.$name === 'string' && item.$name) return item.$name
     if (typeof item.id === 'string' && item.id) return item.id
   }
   return String(idx)