@uniweb/build 0.59.1 → 0.61.0

package/src/uwx/records.js

@@ -2,7 +2,7 @@
 // referenced BY NAME, on the entity-content SYNC lane.
 //
 // Each record becomes a section-keyed `$`-document (docs/reference/entity-content.md):
-// `$id` (the producer-local handle), `$model` (the Model by name), and
+// `$id` (the producer-local handle), `$schema` (its data schema, by scoped name), and
 // each SINGLE section keyed by its name — the brief plus any sibling singles, not
 // the brief alone. The backend MINTS `$uuid` on first sync and
 // returns it in the finalized response; the verb back-fills it into the source
@@ -75,7 +75,7 @@ const SKIP_KEYS = new Set([
   'slug',
   '$id',
   '$uuid',
-  '$model',
+  '$schema',
   '$owner',
   '$unit',
   '$meta',
@@ -85,7 +85,7 @@ const SKIP_KEYS = new Set([
   'draft',
 ])
 
-// Recursively drop IDENTITY `$`-sigil keys (`$uuid`/`$id`/`$model`/… — never
+// Recursively drop IDENTITY `$`-sigil keys (`$uuid`/`$id`/`$schema`/… — never
 // field data; the sigil-exclusivity invariant guarantees this) at every level,
 // so a back-filled `$uuid` doesn't change the hash. Two are exceptions, because
 // they are content rather than identity:
@@ -103,7 +103,7 @@ function stripSigils(value) {
     // encoding rather than the reference made the folder's hash unreproducible.
     //
     // `refLeaf` (uwx/folder.js) emits `$ref: <the record's $id>` — the pool position
-    // `<dirs>/<slug>` — while the record is brand-new, and `entry: { model, entity:
+    // `<dirs>/<slug>` — while the record is brand-new, and `entry: { schema, entity:
     // <uuid> }` once it has been minted.
     // Both denote the same record. A push hashes the folder BEFORE submitting, then
     // back-fills the minted `$uuid` into every record's source file — so the very
@@ -205,8 +205,10 @@ function encodeFieldValue(value, field, sourceLocale, translations) {
  * @param {string} [params.sourceLocale]   - locale for localized-field wrap
  * @param {object} [params.translations]   - `{ locale: { hash: tgt } }` for wrapping
  *        localized scalar fields per-locale (from loadLocaleTranslations)
- * @returns {{ entities: object[], warnings: string[] }} each entity is
- *   `{ id, uuid, model, file, document }` — `document` is the section-keyed body.
+ * @returns {{ entities: object[], warnings: string[], refusals: string[] }} each
+ *   entity is `{ id, uuid, model, file, document }` — `document` is the section-keyed
+ *   body. `refusals` names the records that cannot be sent as written, one line
+ *   each; a caller that sends must not send while any is present.
  */
 export function recordsToEntities({
   label,
@@ -259,6 +261,14 @@ export function recordsToEntities({
       if (!fieldByKey.has(key)) fieldByKey.set(key, field)
     }
   }
+  // Every section by name, single or list — to recognize a record written BY SECTION
+  // (`details: { title: … }`), the shape docs/reference/entity-content.md gives a
+  // sections-form record. This mapper reads a record's fields from the top of its
+  // file, so such a record is refused below rather than sent without them.
+  const sectionNames = new Set(sectionEntries.map(([name]) => name))
+  const listSections = new Set(
+    sectionEntries.filter(([, s]) => s && s.multiple === true).map(([name]) => name)
+  )
 
   // The markdown body of a `.md` record is the value of the Model's CONTENT body
   // field — a markup `text` field (raw source string) or a `format: prosemirror`
@@ -276,6 +286,8 @@ export function recordsToEntities({
 
   const entities = []
   const warnings = []
+  // Records that cannot be sent as written — see the ⛔ at the end of the loop.
+  const refusals = []
   if (contentMatches.length > 1) {
     warnings.push(
       `${label}: ${declaration.name} has more than one content ` +
@@ -299,7 +311,7 @@ export function recordsToEntities({
     // only the fallback for a record that did not arrive that way.
     //
     // The qualification is a CONSTRAINT, not a style: the sync response is keyed per
-    // (`$model`, `$id`), so a bare slug would collide whenever two schema folders
+    // (`$schema`, `$id`), so a bare slug would collide whenever two schema folders
     // resolving to one Model reuse one (see the duplicate check). ⇒ Do not describe this
     // value as "the slug" — the folder leaf's `name` is the bare segment, and
     // conflating the two has already misdirected a naming decision.
@@ -326,31 +338,74 @@ export function recordsToEntities({
       }
       if (Object.keys(data).length) sectionData[secName] = data
     }
-    // Warn for author keys not on ANY record section. A real unknown key means the
-    // frontmatter doesn't match the collection's data schema — that SHOULD warn
-    // (only identity/transport keys in SKIP_KEYS are silent).
+    // Author keys on no record section (only identity/transport keys in SKIP_KEYS are
+    // exempt). A key naming a SECTION is not unknown: the record is written by
+    // section, refused below.
+    const bySection = []
+    const undeclared = []
     for (const key of Object.keys(record)) {
       if (SKIP_KEYS.has(key) || fieldByKey.has(key)) continue
-      warnings.push(
-        `${label}/${slug}: field "${key}" is not on ` +
-          `${declaration.name} — not synced`
+      if (sectionNames.has(key)) bySection.push(key)
+      else undeclared.push(key)
+    }
+
+    // ⛔ A RECORD THE BACKEND WOULD REFUSE — OR WOULD STORE EMPTY — IS REFUSED HERE,
+    // before anything is sent. Two cases are visible from here, and the second is only
+    // checked when the first does not already explain it:
+    //   - a record written by section, whose sections' contents this mapper cannot
+    //     send (it reads fields from the top of the file). Sent, it arrives with an
+    //     empty brief: refused when the brief has a `required` field, and otherwise
+    //     STORED EMPTY, in silence — so this stays whatever the backend does with a
+    //     refusal;
+    //   - a `required` field the send would lack — the brief is always sent, another
+    //     single section only when the record fills it. The backend refuses it too,
+    //     but names the field, not the file.
+    // Measured 2026-09-23: a record written by section went up with an empty brief and
+    // the lane was refused — and the refused lane left the folder's entries and
+    // entities with no data behind, so every later push of the site's records was
+    // refused. The backend's push has been one transaction since 2026-09-24; a refusal
+    // now writes nothing.
+    // ⛔ And what a push cannot carry is refused too, because it is lost twice over: the
+    // backend never receives it, and the next pull writes the file without it — an
+    // undeclared key (`tags:` beside a schema with no `tags`), or a markdown body where
+    // the schema has no field to hold it. Both were warnings until 2026-09-24
+    // ("not synced"), and a pull then deleted the value from the author's file.
+    if (undeclared.length) {
+      const one = undeclared.length === 1
+      refusals.push(
+        `${label}/${slug}: ${quoted(undeclared)} ${one ? 'is not a field' : 'are not fields'} of ` +
+          `${declaration.name} — a push cannot carry ${one ? 'it' : 'them'}, and the next pull would ` +
+          `drop ${one ? 'it' : 'them'} from the file. Declare ${one ? 'it' : 'them'} in the schema, ` +
+          `or remove ${one ? 'it' : 'them'}.`
       )
     }
     if (hasBody && !bodyTarget) {
-      warnings.push(
-        `${label}/${slug}: markdown body present but ` +
-          `${declaration.name} has no content body field — body not synced`
+      refusals.push(
+        `${label}/${slug}: the file has a markdown body, and ${declaration.name} has no field for ` +
+          'it (a `markdown` or `richtext` field) — a push cannot carry it. Add one to the schema, ' +
+          'or move the text into a field.'
       )
     }
+    if (bySection.length) {
+      refusals.push(sectionShapeRefusal(`${label}/${slug}`, bySection, listSections, declaration.name))
+    } else {
+      const missing = missingRequired(recordSections, sectionData, briefName)
+      if (missing.length) {
+        refusals.push(
+          `${label}/${slug}: ${declaration.name} requires ${listOf(missing)}, and this record ` +
+            `has no value for ${missing.length === 1 ? 'it' : 'them'}.`
+        )
+      }
+    }
 
-    // The `$`-document, in canonical key order: `$uuid?`, `$id`, `$model`, `$disabled?`,
+    // The `$`-document, in canonical key order: `$uuid?`, `$id`, `$schema`, `$disabled?`,
     // then each populated section in declared order (the brief always present as the
     // card). `$owner`/`$unit`/`$meta` are omitted — the backend binds owner + unit on
     // its side.
     const document = {}
     if (uuid) document.$uuid = uuid
     document.$id = id
-    document.$model = declaration.name
+    document.$schema = declaration.name
     // ⭐ A DRAFT IS SENT AS A DISABLED ENTITY: it stays in the folder and is never
     // publicly delivered. Only `true` travels. An absent key means enabled [Diego,
     // 2026-09-21], so a record whose `draft: true` is removed is sent without the key
@@ -373,7 +428,51 @@ export function recordsToEntities({
       document,
     })
   }
-  return { entities, warnings }
+  return { entities, warnings, refusals }
+}
+
+// "a", "a and b", "a, b and c" — items are already formatted.
+function listOf(items) {
+  if (items.length <= 1) return items.join('')
+  return `${items.slice(0, -1).join(', ')} and ${items[items.length - 1]}`
+}
+
+const quoted = (keys) => listOf(keys.map((k) => `"${k}"`))
+
+// Why a record written by section cannot be sent, and what to do about each kind of
+// section it names: a single section's fields can move to the top of the file; a
+// list section has no file form a push can send.
+function sectionShapeRefusal(where, keys, listSections, modelName) {
+  const singles = keys.filter((k) => !listSections.has(k))
+  const lists = keys.filter((k) => listSections.has(k))
+  const one = keys.length === 1
+  let message =
+    `${where}: ${quoted(keys)} ${one ? 'is a section' : 'are sections'} of ${modelName}, and a ` +
+    `push reads a record's fields from the top of its file — what ${one ? 'it holds' : 'they hold'} ` +
+    'would not be sent.'
+  if (singles.length) message += ` Move the fields of ${quoted(singles)} up a level.`
+  if (lists.length) {
+    message +=
+      ` ${quoted(lists)} ${lists.length === 1 ? 'holds' : 'hold'} a list, which a push cannot ` +
+      'send from a file yet.'
+  }
+  return message
+}
+
+// The `required` fields a record's send would lack. The brief is always sent; another
+// single section only when the record fills it, so an empty one is not checked. A
+// field counts as present when the send carries a value for it (`null` is none).
+function missingRequired(recordSections, sectionData, briefName) {
+  const missing = []
+  for (const [secName, sec] of recordSections) {
+    const data = sectionData[secName]
+    if (secName !== briefName && !data) continue
+    for (const [key, field] of Object.entries(sec.fields || {})) {
+      if (field?.required !== true || data?.[key] != null) continue
+      missing.push(secName === briefName ? `"${key}"` : `"${key}" (section "${secName}")`)
+    }
+  }
+  return missing
 }
 
 // Post-pass: override a collection record's localized CONTENT body with a per-locale
@@ -544,7 +643,7 @@ function resolveDeclaration(schema, modelName) {
  * (e.g. site-content) into one sync package. First sync sends no `$uuid` (the
  * backend mints); re-sync round-trips the back-filled `$uuid`. Throws on an
  * unresolvable EXPLICIT Model, an invalid `records/folder.yml`, or a duplicate
- * ($model, $id) within the submission.
+ * ($schema, $id) within the submission.
  *
  * @param {string} siteRoot - directory containing site.yml
  * @param {object} [opts]
@@ -558,8 +657,9 @@ function resolveDeclaration(schema, modelName) {
  *        Defaults to the site's foundation's (`siteSelfScope`); a caller that has it
  *        already passes it, so one emit reads it once.
  * @returns {Promise<{ entities: object[], index: object[], warnings: string[],
- *   schemaless: Array<{name: string, model: string}>, colConfig: object,
- *   folder: object, recordsDirExists: boolean }>}
+ *   refusals: string[], schemaless: Array<{name: string, model: string}>,
+ *   colConfig: object, folder: object, recordsDirExists: boolean }>}
+ *   `refusals` — records that cannot be sent as written (`recordsToEntities`).
  *   `schemaless` lists the QUERIES whose schema resolved to nothing (the
  *   convention-default soft-skip) — their records are not pushed as entities, and
  *   the composite deploy delivers those queries statically instead.
@@ -597,6 +697,7 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
     throw new Error(`uwx/records: ${recordsCfg.file} is invalid —\n  ${folder.errors.join('\n  ')}`)
   }
   const warnings = [...pool.errors, ...folder.warnings]
+  const refusals = []
 
   const colConfig = opts.queriesConfig || (await resolveQueriesConfig(siteRoot))
   const queries = siteQueries(colConfig.declarations)
@@ -606,6 +707,7 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
       entities: [],
       index: [],
       warnings,
+      refusals,
       schemaless: [],
       colConfig,
       folder: { ...folder, nodes: [] },
@@ -657,7 +759,7 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
   // ⭐ Resolving BEFORE `declarationFor` is what keeps this to one line of behaviour:
   // `resolveDeclaration` already matches a fully-qualified name against the
   // foundation's `@/`-keyed `dataSchemas`, so a resolved name looks up correctly and
-  // `declaration.name` — the value that becomes `$model` — is the resolved one.
+  // `declaration.name` — the value that becomes `$schema` — is the resolved one.
   //
   // ⛔ The rule lives in `./self-scope.js`, shared with the `queries` Section
   // (`site.js::queriesNested`): a query's `schema` must name exactly the Model
@@ -740,7 +842,7 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
   const producedBy = new Map()
   // Schemas (as written) whose Model resolved to nothing — soft-skipped.
   const unresolved = new Set()
-  // The sync response is keyed per ($model, $id), so the pair must be unique
+  // The sync response is keyed per ($schema, $id), so the pair must be unique
   // within one submission.
   const seen = new Set()
 
@@ -821,14 +923,14 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
       const dupKey = `${e.model} ${e.id}`
       if (seen.has(dupKey)) {
         throw new Error(
-          `uwx/records: duplicate ($model, $id) in one sync — "${e.id}" of ` +
+          `uwx/records: duplicate ($schema, $id) in one sync — "${e.id}" of ` +
             `${e.model} comes from more than one record. Each record in a schema ` +
             'folder needs its own slug; make the slugs unique.'
         )
       }
       seen.add(dupKey)
       // The verb back-fills the minted `$uuid` into this source file, matched
-      // back from the finalized response by ($model, $id).
+      // back from the finalized response by ($schema, $id).
       const src = sourceBySlug.get(e.slug)
       index.push({
         id: e.id,
@@ -843,16 +945,13 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
         ownId: ownIds.get(e.slug) ?? null,
         format: src ? src.format : null,
         multiRecord: src ? src.multiRecord : false,
-        // The Model declaration, so the back-fill can render the finalized
-        // document → authoring shape (variant A): unwrap localized fields, route
-        // the content body field to the md body, drop the brief record `$uuid`.
-        declaration,
         // Sent disabled, so the back-fill can check that the backend kept it that way.
         draft: e.document.$disabled === true,
       })
     }
     entities.push(...mappedOut.entities)
     warnings.push(...mappedOut.warnings)
+    refusals.push(...mappedOut.refusals)
   }
 
   // Queries whose schema resolved to nothing — not pushed as entities. The composite
@@ -903,6 +1002,7 @@ export async function buildRecordEntities(siteRoot, opts = {}) {
     entities,
     index,
     warnings,
+    refusals,
     schemaless,
     colConfig,
     folder: { ...folder, nodes },
@@ -968,11 +1068,11 @@ export function filterChanged(entities, index, { priorHashes = {}, sendAll = fal
  * @param {object} [opts] - buildRecordEntities opts, plus `priorHashes`,
  *        `sendAll`, `exporter`, `exportedAt`.
  * @returns {Promise<{ buffer: Buffer|null, models: string[], entityCount: number,
- *        warnings: string[], index: object[], hashes: Object<string,string>,
- *        skipped: number }>}
+ *        warnings: string[], refusals: string[], index: object[],
+ *        hashes: Object<string,string>, skipped: number }>}
  */
 export async function emitRecordSyncPackage(siteRoot, opts = {}) {
-  const { entities, index, warnings, recordsDirExists } = await buildRecordEntities(siteRoot, opts)
+  const { entities, index, warnings, refusals, recordsDirExists } = await buildRecordEntities(siteRoot, opts)
   if (entities.length === 0) {
     throw new Error(
       'uwx/records: no records to export — ' +
@@ -989,7 +1089,7 @@ export async function emitRecordSyncPackage(siteRoot, opts = {}) {
 
   const sentModels = [...new Set(sendEntities.map((e) => e.model))]
   if (sendEntities.length === 0) {
-    return { buffer: null, models: sentModels, entityCount: 0, warnings, index: [], hashes, skipped }
+    return { buffer: null, models: sentModels, entityCount: 0, warnings, refusals, index: [], hashes, skipped }
   }
 
   const buffer = emitEntitySyncPackage({
@@ -1000,5 +1100,5 @@ export async function emitRecordSyncPackage(siteRoot, opts = {}) {
     exportedAt: opts.exportedAt,
   })
 
-  return { buffer, models: sentModels, entityCount: sendEntities.length, warnings, index: sendIndex, hashes, skipped }
+  return { buffer, models: sentModels, entityCount: sendEntities.length, warnings, refusals, index: sendIndex, hashes, skipped }
 }

package/src/uwx/self-scope.js

@@ -9,7 +9,7 @@
 //
 // ⭐ ONE RULE FOR EVERY PATH THAT SHIPS A REF FROM ONE PUBLISH, and its inverse:
 //
-//   - a record's `$model`             `records.js::buildRecordEntities`
+//   - a record's `$schema`            `records.js::buildRecordEntities`
 //   - a query's `schema`              `site.js::queriesNested` (the `queries` Section)
 //   - the author's spelling, on pull  `records-project.js` (placement and declarations)
 //

package/src/uwx/site.js

@@ -850,7 +850,7 @@ export function isSiteRelativeExtensionUrl(decl) {
  * @param {Object<string,string>} [uuids] `name` → backend `$uuid`, from a push
  *        response or a pull. Absent on a first sync, where minting is correct.
  * @param {string} [org] the publish org. A foundation-relative `schema` (`@/x`)
- *        is qualified with it (`./self-scope.js`), exactly as the records' `$model`
+ *        is qualified with it (`./self-scope.js`), exactly as the records' `$schema`
  *        is — see the note at the `schema` line below.
  */
 // ⛔ KEYS THAT MUST NOT REACH THE WIRE. Everything else on an authored declaration
@@ -930,7 +930,7 @@ function queriesNested(declarations, uuids = null, scope = null) {
     // the runtime fetches it from (never the records service).
     const source = d.path ? { path: d.path } : d.url !== undefined ? externalSource(d) : d.source
     setIf(data, 'source', source)
-    // ⛔ QUALIFIED, WITH THE SAME RULE AND THE SAME SCOPE AS THE RECORDS' `$model`
+    // ⛔ QUALIFIED, WITH THE SAME RULE AND THE SAME SCOPE AS THE RECORDS' `$schema`
     // (`records.js::buildRecordEntities`) — the site's foundation's. A consumer
     // answers a query by matching this name against the Models its records were
     // stored under, so a verbatim `@/member` beside records stored as `@acme/member`
@@ -1242,7 +1242,7 @@ function settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translation
  *        `siteSelfScope`; pass the scope the records are emitted with. With none
  *        known, `@/x` ships as written.
  * @returns {Promise<object>} the section-keyed `$`-document:
- *        `{ $uuid?, $id, $model, info, settings?, pages, layout_sections, extensions,
+ *        `{ $uuid?, $id, $schema, info, settings?, pages, layout_sections, extensions,
  *        queries, services?, secrets? }`
  */
 export async function siteProjectToDocument(siteRoot, opts = {}) {
@@ -1518,7 +1518,7 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
   // config (the records themselves are separate entities; this is just the config).
   const colConfig = await resolveQueriesConfig(siteRoot, { siteYml })
 
-  // `$uuid?` then `$id` `$model`, then sections in Model-declared order.
+  // `$uuid?` then `$id` `$schema`, then sections in Model-declared order.
   const doc = {}
   // ⭐ From `sync.json`, keyed by the backend this document is being produced FOR.
   // It was `site.yml::$uuid` — one scalar with no way to say which backend minted it.
@@ -1529,7 +1529,7 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
     (opts.backend ? readBackendState(siteRoot, opts.backend).site?.uuid : undefined)
   if (entityUuid) doc.$uuid = entityUuid
   doc.$id = SITE_ENTITY_KEY // one site-content entity per project (stable handle)
-  doc.$model = SITE_MODEL_NAME
+  doc.$schema = SITE_MODEL_NAME
   doc.info = info
   // Emitted only when the file declares something — see `settingsNested`.
   const settings = settingsNested(siteYml, { headHtml, themeYml, sourceLocale, translations })
@@ -1594,7 +1594,7 @@ export async function emitSiteSyncPackage(siteRoot, opts = {}) {
     entities: [
       {
         id: document.$id,
-        model: document.$model,
+        model: document.$schema,
         file: 'entities/site-content.json',
         document,
       },

package/src/uwx/sync-package.js

@@ -71,7 +71,7 @@ function emitLane(entities, exporter, exportedAt, extraModels = []) {
   return { buffer, entityCount: entities.length, models }
 }
 
-// Collect the Models referenced by the folder's `ref` leaves (`entry.model`), walking
+// Collect the Models referenced by the folder's `ref` leaves (`entry.schema`), walking
 // the contents/$children tree. The folder is built from the FULL record set, so it
 // references every record's Model — including records the send-only-changed filter
 // drops from THIS package (a re-push where the folder changed but the records didn't).
@@ -79,7 +79,7 @@ function emitLane(entities, exporter, exportedAt, extraModels = []) {
 // ride even when their record entities don't.
 function collectReferencedModels(node, acc) {
   if (!node || typeof node !== 'object') return acc
-  if (node.entry && typeof node.entry.model === 'string') acc.add(node.entry.model)
+  if (node.entry && typeof node.entry.schema === 'string') acc.add(node.entry.schema)
   for (const key of ['$children', 'contents']) {
     if (Array.isArray(node[key])) for (const child of node[key]) collectReferencedModels(child, acc)
   }
@@ -251,9 +251,13 @@ function rewriteEntityAssets(node, map, ids, noStamp = null) {
  * @returns {Promise<{
  *   siteContent: { buffer, entityCount, index, models }|null,
  *   records: { buffer, entityCount, index, models }|null,
- *   hashes: Object<string,string>, warnings: string[], skipped: number,
- *   schemaless: Array<{name: string, model: string}>, localAssets: string[],
- *   applied: object }>}
+ *   hashes: Object<string,string>, warnings: string[], refusals: string[],
+ *   skipped: number, schemaless: Array<{name: string, model: string}>,
+ *   localAssets: string[], applied: object }>}
+ *   `refusals` names the records that cannot be sent as written, one line each
+ *   (`records.js::recordsToEntities`). A caller that submits must not submit while
+ *   any is present: the backend would refuse the records lane — or, for a record
+ *   written by section whose brief requires nothing, store it empty.
  *   `schemaless` lists queries that resolved no data schema (soft-skipped from
  *   the sync) — the composite deploy delivers these statically via the data ball.
  *   `localAssets` lists the site-root local media refs (`/images/x.png`) the deploy
@@ -277,7 +281,7 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
   const exportedAt = opts.exportedAt
   refuseOrgOption(opts, 'emitSyncPackages')
   // ⭐ ONE SCOPE FOR THE WHOLE EMIT — the site's foundation's, the one `register`
-  // stored its Models under — so a record's `$model` and a query's `schema` are
+  // stored its Models under — so a record's `$schema` and a query's `schema` are
   // qualified alike. Read once here and handed to both. ⛔ It was the org that owns
   // the SITE until 2026-09-22 (`self-scope.js`).
   const scope =
@@ -446,7 +450,7 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
   const localAssets = [...localAssetSet]
 
   const siteEntity = siteDoc
-    ? { id: siteDoc.$id, model: siteDoc.$model, file: 'entities/site-content.json', document: siteDoc }
+    ? { id: siteDoc.$id, model: siteDoc.$schema, file: 'entities/site-content.json', document: siteDoc }
     : null
 
   // One hash map over every entity (both lanes) — the sync-cache the caller persists.
@@ -519,6 +523,7 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
 
   return {
     siteContent, records, siteContentUuid, hashes, warnings, skipped,
+    refusals: col.refusals || [],
     schemaless: col.schemaless, localAssets, applied,
     // { stamped, unknown } when identity was applied; null when the caller passed
     // no map. `unknown > 0` with `stamped === 0` on a site that has been pushed