@uniweb/build 0.60.0 → 0.62.0

package/src/uwx/registry-package.js

@@ -26,7 +26,7 @@
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { toDataSchemaDeclaration } from './data-schema.js'
+import { toDataSchemaDeclaration, SHORTHAND_SECTION } from './data-schema.js'
 import { checkFoundationName, splitFoundationName } from '../foundation-name.js'
 
 const FOUNDATION_SCHEMA = '@uniweb/foundation-schema'
@@ -231,8 +231,8 @@ function makeOptionsResolver(dataSchemas, scoped) {
 }
 
 function itemBearingSectionName(normalized, ref) {
-  // fields-form → the synthesized single section (named by the ref's short segment)
-  if (normalized.fields) return String(ref).split('/').pop()
+  // fields-form → the shorthand's one section, always named `brief`
+  if (normalized.fields) return SHORTHAND_SECTION
   // sections-form → the first item-bearing (single/multi) section
   for (const [name, sec] of Object.entries(normalized.sections || {})) {
     const kind = sec.kind || 'single'

package/src/uwx/sync-package.js

@@ -33,6 +33,18 @@ const SITE_ENTITY_KEY = 'site-content'
 
 const cacheKey = (entity) => `${entity.model} ${entity.id}`
 
+// The folder's placements without the records a push leaves out — `{ kind: 'ref' }` leaves
+// naming them by `$entityId`, inside any branch.
+function withoutRecords(nodes, ids) {
+  if (!ids.size) return nodes
+  const out = []
+  for (const node of nodes || []) {
+    if (node?.kind === 'branch') out.push({ ...node, $children: withoutRecords(node.$children, ids) })
+    else if (!ids.has(node?.$entityId)) out.push(node)
+  }
+  return out
+}
+
 // Attach the push gate's optimistic-concurrency token to an entity, keyed by the
 // BACKEND uuid in its document body (`$uuid`). A never-synced entity has no
 // `$uuid` and therefore no base — correctly unconditional, since there is no
@@ -253,7 +265,11 @@ function rewriteEntityAssets(node, map, ids, noStamp = null) {
  *   records: { buffer, entityCount, index, models }|null,
  *   hashes: Object<string,string>, warnings: string[], refusals: string[],
  *   skipped: number, schemaless: Array<{name: string, model: string}>,
- *   localAssets: string[], applied: object }>}
+ *   localAssets: string[], applied: object,
+ *   waiting: Array<{id: string, model: string, slug: string, held: boolean, pending: object[]}> }>}
+ *   `waiting` lists the records whose references name a record this backend has not
+ *   minted yet — sent without them, or held back. A caller that sends pushes again
+ *   once this push has been applied (`records.js::encodeReference`).
  *   `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
@@ -300,10 +316,43 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
   })
   const warnings = [...col.warnings, ...(col.folder?.warnings ?? [])]
 
+  // ⭐ RECORDS WAITING FOR A REFERENCE (`records.js::encodeReference`). A record whose
+  // reference names a record this backend has not minted yet cannot name it on the wire,
+  // so this push sends what it can and the next pass completes it (the CLI's
+  // `pushInPasses`):
+  //   · new, and nothing it waits for is required → sent now without those references,
+  //     so after one pass every record exists, whatever refers to what;
+  //   · new, and a required reference waits → HELD and placed nowhere: it cannot be
+  //     created without it;
+  //   · already on this backend → HELD, left as it is there: sent without a reference it
+  //     has, it would lose that reference until the next pass.
+  // A held record is not sent and keeps the hash last banked for it, so the next pass
+  // sees it as changed.
+  const held = new Set()
+  const unplaced = new Set()
+  for (const e of col.entities) {
+    if (!e.pending?.length) continue
+    if (e.uuid) held.add(e.id)
+    else if (e.pending.some((p) => p.required)) {
+      held.add(e.id)
+      unplaced.add(e.id)
+    }
+  }
+  const waiting = col.entities
+    .filter((e) => e.pending?.length)
+    .map((e) => ({ id: e.id, model: e.model, slug: e.slug, held: held.has(e.id), pending: e.pending }))
+  const placedEntities = []
+  const placedIndex = []
+  col.entities.forEach((e, i) => {
+    if (unplaced.has(e.id)) return
+    placedEntities.push(e)
+    placedIndex.push(col.index[i])
+  })
+
   // The folder rides over the FULL record set (before filtering) so its references
   // are complete — new records by `$ref`, already-minted ones by `entry: <uuid>`.
   const folder = buildFolderEntity({
-    recordEntities: col.entities,
+    recordEntities: placedEntities,
     ...(sourceLocale ? { sourceLocale } : {}),
     // ⭐ Every record in the directory, at the top of the folder or in the
     // sub-folder `folder.yml` places it in — and NOTHING when there is no folder to
@@ -311,7 +360,7 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
     // non-empty tree: a `folder.yml` whose folders hold only records that resolved
     // no schema is a tree of empty branches, and sending it would replace the
     // backend's folder with them (measured on the `dynamic` template, 2026-09-21).
-    folderNodes: col.sendFolder === true ? (col.folder?.nodes ?? []) : [],
+    folderNodes: col.sendFolder === true ? withoutRecords(col.folder?.nodes ?? [], unplaced) : [],
     // ⛔ Whether the file side HAS a folder to state (`records.js::sendsFolder`) —
     // not whether it holds anything. A site with no records directory sends none
     // and leaves the backend's alone; an empty directory sends an empty folder,
@@ -469,7 +518,17 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
   // changed() has side effects (hashes/skipped), so evaluate every entity exactly
   // once, in a stable order: folder, then each record.
   const folderChanged = folder ? changed(folder) : false
-  const recordChanged = col.entities.map((e, i) => ({ entity: e, index: col.index[i], changed: changed(e) }))
+  // A held record keeps its last banked hash — it was not sent (see `held` above).
+  const keepBanked = (entity) => {
+    const key = cacheKey(entity)
+    if (priorHashes[key] !== undefined) hashes[key] = priorHashes[key]
+    return false
+  }
+  const recordChanged = placedEntities.map((e, i) => ({
+    entity: e,
+    index: placedIndex[i],
+    changed: held.has(e.id) ? keepBanked(e) : changed(e),
+  }))
   const changedRecords = recordChanged.filter((r) => r.changed)
 
   let records = null
@@ -523,6 +582,9 @@ export async function emitSyncPackages(siteRoot, opts = {}) {
 
   return {
     siteContent, records, siteContentUuid, hashes, warnings, skipped,
+    // Records waiting for a reference's record — see `held` above. Non-empty ⇒ the caller
+    // pushes again once this push has been applied.
+    waiting,
     refusals: col.refusals || [],
     schemaless: col.schemaless, localAssets, applied,
     // { stamped, unknown } when identity was applied; null when the caller passed

package/src/uwx/uuid.js

@@ -42,3 +42,10 @@ export function mintUuidV7() {
     hex.slice(20)
   )
 }
+
+const UUID_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+/** Is this a uuid (any version), as the exchange writes one? */
+export function isUuid(value) {
+  return typeof value === 'string' && UUID_SHAPE.test(value)
+}

package/src/validate-data.js

@@ -31,7 +31,8 @@ import { YAML_OPTIONS } from './utils/yaml-schema.js'
 import { queryNameFromUrl, declaredKeys, fillDeclaredKeys, fetchLevels, pageRouteQuery } from '@uniweb/core'
 import { parentRouteOf } from '@uniweb/core/route-match'
 
-import { validateItem, isStaticallyCheckable, validateBound, flatRecordFields } from '@uniweb/schemas/conform'
+import { validateItem, validateRecordFile, validateBound, contentBodyField, rootListSection, referencesOf } from '@uniweb/schemas/conform'
+import { isUuid } from './uwx/uuid.js'
 import { validateAndNormalizeSchema, buildDataSchemaMap } from './resolve-data-schema.js'
 
 // The pure checker, re-exported so `@uniweb/build/validate` stays the one import
@@ -41,7 +42,6 @@ export { validateItem, isStaticallyCheckable } from '@uniweb/schemas/conform'
 import { buildSchema } from './schema.js'
 import { resolveRecordsDir, readEntityPool, groupPoolBySchema } from './site/entity-pool.js'
 import { readEntityFile } from './uwx/entity-source.js'
-import { isContentBodyField } from './uwx/data-schema.js'
 import { toFetchList } from './site/data-fetcher.js'
 import { resolveFoundationSrcPath } from './utils/foundation-source-root.js'
 import { collectSiteContent } from './site/content-collector.js'
@@ -75,7 +75,7 @@ import { processQueries } from './site/query-processor.js'
  *
  * @typedef {Object} Report
  * @property {Array<Object>} violations - Each: { file, schema, item, field, rule, message, users }.
- * @property {Array<Object>} deferred - Inputs not statically checkable: { route, section, key, reason, ref?, url? }.
+ * @property {Array<Object>} deferred - Inputs not checked: data not in the project (an external query), or an inline schema on a binding — { route, section, key, reason, ref?, url? }.
  * @property {Array<Object>} setupErrors - Read failures: { file, message, users }.
  * @property {{ records: number, schemas: number, violations: number, deferred: number }} summary
  */
@@ -197,13 +197,10 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
         const schema = dataSchemas[ref]
         if (!schema) continue // build guarantees refs resolve; defensive skip
 
-        // ⭐ A sections-form schema is checked like any other now (`isStaticallyCheckable`,
-        // 2026-09-24) — a record can be flat or written by section. What is left out is a
-        // schema whose ROOT IS A LIST: it describes a whole value, not one record.
-        if (!isStaticallyCheckable(schema)) {
-          deferred.push({ route: page.route, section: type, key, reason: 'its root is a list, not a record', ref })
-          continue
-        }
+        // ⭐ Every schema is checked (2026-09-24): a sections-form one per record, flat or
+        // written by section, and one whose ROOT IS A LIST as the list the key receives
+        // (pass 2). A list root was deferred here until then, though the query's records
+        // are exactly that list.
 
         const pairKey = `${input.path} ${ref}`
         let entry = work.get(pairKey)
@@ -220,7 +217,7 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
   const violations = []
   const schemasSeen = new Set()
   let recordCount = 0
-  // (schema, slug) of every record this pass checked, so pass 5 checks the rest.
+  // (schema, slug) of every record this pass checked, so pass 4 checks the rest.
   const checkedRecords = new Set()
 
   for (const entry of work.values()) {
@@ -232,6 +229,19 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
 
     schemasSeen.add(entry.ref)
     const items = Array.isArray(records) ? records : [records]
+
+    // A schema whose ROOT IS A LIST describes the whole value the key receives, and the
+    // query's records ARE that list — so they are checked once, as the list. Any other
+    // schema describes one record, checked per record.
+    if (rootListSection(entry.schema)) {
+      recordCount += items.length
+      const base = { file: entry.path, schema: entry.ref, users: entry.users }
+      for (const finding of validateBound(entry.schema, items)) {
+        violations.push(listViolation(finding, (idx) => itemLabel(items[idx], idx), base))
+      }
+      continue
+    }
+
     items.forEach((item, idx) => {
       recordCount++
       if (item && typeof item.slug === 'string') checkedRecords.add(recordKey(entry.ref, item.slug))
@@ -247,21 +257,21 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
     })
   }
 
-  // Pass 3 — concept blocks, which join to a schema by CONVENTION rather than
-  // by a foundation binding. Additive and silent unless a schema resolves.
-  const concepts = await validateConceptBlocks(site)
-  violations.push(...concepts.violations)
-  for (const ref of concepts.schemas) schemasSeen.add(ref)
-  recordCount += concepts.checked
+  // ⛔ No pass checks a ```md:<tag> CONCEPT BLOCK — removed 2026-09-24 [Diego]. Its
+  // structure is recovered from the markdown by the semantic parser, so a schema has
+  // nothing to add: the pass matched `md:<tag>` to `@std/<tag>` and checked the parsed
+  // items, which either could not produce a finding (a schema in the item vocabulary)
+  // or produced ones no author could satisfy (`name` on `md:person` — markdown has no
+  // `name`). It was advisory while findings only warned; they now fail the run.
 
-  // Pass 4 — tagged data blocks, which join by the component's OWN binding.
+  // Pass 3 — tagged data blocks, which join by the component's OWN binding.
   const blocks = validateTaggedDataBlocks(site, foundation, dataSchemas)
   violations.push(...blocks.violations)
   deferred.push(...blocks.deferred)
   for (const ref of blocks.schemas) schemasSeen.add(ref)
   recordCount += blocks.checked
 
-  // Pass 5 — every record file no section's binding reached, against the data schema
+  // Pass 4 — every record file no section's binding reached, against the data schema
   // its folder names. ⭐ The set a push sends: every file in the records directory is
   // a record and every record is pushed, whether or not a section reads it — and
   // until 2026-09-24 one that no section read was never checked here.
@@ -286,13 +296,30 @@ export async function validateDataInputs({ siteRoot, foundationPath }) {
 
 const recordKey = (ref, slug) => `${ref}\u0000${slug}`
 
+// A finding from checking a whole list (`validateBound`) names its element by index —
+// `[3].label` — so the element is named the way a per-record finding names its record,
+// by `label(3)`, and the path is left relative to it.
+function listViolation(finding, label, base) {
+  const m = /^\[(\d+)\]\.?/.exec(finding.field || '')
+  if (!m) return { ...base, item: 'the list', ...finding }
+  const idx = Number(m[1])
+  return { ...base, item: label(idx), ...finding, field: finding.field.slice(m[0].length) || finding.field }
+}
+
 /**
  * Check the records in the records directory that pass 2 did not, each against the
  * data schema its folder names (`records/member/` → `@/member`).
  *
- * A record is read the way a push reads it (`uwx/entity-source.js`), and a markdown
- * record's body is the value of its schema's content body field unless its
- * frontmatter sets one — which is what a push sends it as (`uwx/records.js`).
+ * A record is checked as its FILE holds it (`validateRecordFile`) — read the way a push
+ * reads it (`uwx/entity-source.js`), a markdown body in its schema's content body field
+ * unless the file sets that field, which is what a push sends it as (`uwx/records.js`).
+ * So a finding names the path an author edits (`article.title`), and a field written in
+ * the retired flat form is reported under the rule `section`. Pass 2 checks the records
+ * a section receives, in the shape it receives them (`validateItem`).
+ *
+ * Every record's references are checked here too, whichever pass checked the rest: one
+ * that names no record of its schema is reported under the rule `ref`, since a push
+ * cannot send it.
  *
  * A folder whose schema resolves to nothing is left out in silence: its records are
  * schema-less, delivered as files, and the push says so itself.
@@ -302,9 +329,14 @@ const recordKey = (ref, slug) => `${ref}\u0000${slug}`
 async function validateRecordFiles(siteRoot, { srcDir, dataSchemas, paths, checked }) {
   const out = { violations: [], setupErrors: [], schemas: new Set(), checked: 0 }
   const pool = await readEntityPool(siteRoot, { dir: resolveRecordsDir(siteRoot, paths).rel })
+  // Every record is read first: a reference names a record of another schema by its
+  // name — its file's, or its `slug:` — or by the id its file carries.
+  const read = []
+  const names = new Map() // schema (as its folder names it) → the names and ids of its records
   for (const [ref, entities] of groupPoolBySchema(pool.entities)) {
     const schema = await schemaForRecords(ref, { srcDir, dataSchemas })
-    if (!schema || !isStaticallyCheckable(schema)) continue
+    const known = names.get(ref) ?? new Set()
+    names.set(ref, known)
     for (const pooled of entities) {
       let records
       try {
@@ -314,13 +346,39 @@ async function validateRecordFiles(siteRoot, { srcDir, dataSchemas, paths, check
         continue
       }
       for (const r of records) {
-        if (!r.slug || checked.has(recordKey(ref, r.slug))) continue
+        if (r.slug) known.add(String(r.slug))
+        if (typeof r.data?.$uuid === 'string') known.add(r.data.$uuid)
+      }
+      // An entity of a list-rooted schema too: it holds the list under its section's key.
+      // ⛔ Until 2026-09-24 such a folder was skipped here without a word.
+      if (schema) read.push({ ref, schema, pooled, records })
+    }
+  }
+  for (const { ref, schema, pooled, records } of read) {
+    for (const r of records) {
+      if (!r.slug) continue
+      const record = withBody(schema, r)
+      if (!checked.has(recordKey(ref, r.slug))) {
         out.checked++
         out.schemas.add(ref)
-        for (const finding of validateItem(schema, withBody(schema, r))) {
+        for (const finding of validateRecordFile(schema, record)) {
           out.violations.push({ file: pooled.relPath, schema: ref, item: r.slug, users: [], ...finding })
         }
       }
+      // ⭐ A reference must name a record — a push refuses one that does not. A uuid is
+      // left alone: it may be a record the backend holds and this project does not.
+      for (const { path, ref: target, value } of referencesOf(schema, record)) {
+        if (typeof value !== 'string' || isUuid(value) || names.get(target)?.has(value)) continue
+        out.violations.push({
+          file: pooled.relPath,
+          schema: ref,
+          item: r.slug,
+          users: [],
+          field: path,
+          rule: 'ref',
+          message: `names "${value}", and no record of ${target} is called that`,
+        })
+      }
     }
   }
   return out
@@ -337,138 +395,21 @@ async function schemaForRecords(ref, { srcDir, dataSchemas }) {
   }
 }
 
-// A record as a push sends it: a markdown body fills the schema's content body field
-// when the frontmatter does not set it.
+// A record as its file holds it, with a markdown body in the schema's content body field
+// — under its section, in a file written by section — when the file does not set it.
 function withBody(schema, r) {
   const record = { ...(r.data || {}) }
   if (typeof r.body !== 'string' || r.body.trim() === '') return record
-  const key = Object.entries(flatRecordFields(schema) || {}).find(([, f]) => isContentBodyField(f))?.[0]
-  if (key && record[key] === undefined) record[key] = r.body
-  return record
-}
-
-/**
- * Check each ```md:<tag> concept block against `@std/<tag>`, when that schema
- * exists.
- *
- * THREE PROPERTIES MAKE THIS SAFE, and all three have to hold:
- *
- * 1. It adds NO REGISTRY. The resolution is mechanical — `md:faq` → `@std/faq`,
- *    the same `@std` → `@uniweb/schemas` mapping every other ref uses. What the
- *    framework gains is a naming convention; no code branches on the value of a
- *    tag, and nothing here knows which concepts exist. A hardcoded list of
- *    concept names is the thing this whole design exists to avoid, and it would
- *    arrive through this door if the check needed to know what `faq` means.
- *
- * 2. It never touches SHAPE. A concept block's shape comes from its fence,
- *    unconditionally. This runs after the parse and changes nothing: a block
- *    with no resolvable schema still parses, still delivers items, still
- *    renders. The schema is a check, never a gate.
- *
- * 3. It never fails at RENDER. Findings only — this whole module is a pre-live
- *    dev/CI gate and the runtime stays tolerant.
- *
- * ⛔ A standard schema for a concept MUST be authored in the ITEM vocabulary —
- * `title`, `paragraphs`, and the rest of the parsed shape — because that is what
- * a concept block always produces. An `@std/faq` written as `{ question, answer }`
- * could only be checked with a per-concept field mapping, which is the forbidden
- * registry arriving by the back door. Author the schema to match the parse, or
- * do not ship the schema.
- *
- * ⛔ AND FOR A PROSE CONCEPT, NO FACET CAN FIRE AT ALL — so do not write an
- * `@std` schema for one. Measured 2026-07-30:
- *
- *   - `required` is inert. The item vocabulary is TOTAL — `flattenGroup` fills
- *     every field it declares, so a titleless item has `title: ''` rather than
- *     no title, and `required` fires only on absent or null. "The author
- *     actually wrote a question" is not expressible.
- *   - `type` cannot fail either. Inside a concept block `title` is always a
- *     string (never an array — `alwaysItems` suppresses the same-level merge
- *     that would make one) and `paragraphs` is always an array of strings.
- *   - which leaves `enum` / `format`, and neither has a natural application to
- *     a question or an answer. The test suite had to invent `format: 'url'` on
- *     a question to make anything fire — that is the tell, not a fixture quirk.
- *
- * The mechanism still earns its place, but it is waiting for a different shape:
- * a concept that carries a tagged DATA BLOCK. Verified that one reaches the item
- * — ```` ```md:steps ```` holding a ```` ```yaml:meta ```` gives
- * `items[0].data.meta` — and there `required` fires when an author omits the
- * block, `enum` constrains a status, `format` constrains a duration. That is the
- * trigger to write a schema. Until then the frontend holds the concept names and
- * their shapes, which is where they belong: its extension encodes the shape
- * executably, and a `standard/faq.js` in `@uniweb/schemas` whose only consumer is
- * that app would be this framework stating which concepts exist — the registry
- * this design forbids, spelled as a filename instead of a switch.
- *
- * Note on resolution: this deliberately does NOT go through `resolveSchemaRef`,
- * which resolves a package from a FOUNDATION's node_modules and throws when a
- * ref is unknown. Neither fits — a concept block needs no foundation (so this
- * works on a link-mode site whose foundation is a registry ref with nothing
- * local), and an unresolved tag must be silent rather than an error. So the
- * package is resolved from this build's own graph, where it is an
- * optionalDependency, exactly as `i18n/records.js` resolves it.
- *
- * @param {Object} site - collected site content (`{ pages }`)
- * @returns {Promise<{ violations: Array, schemas: Set<string>, checked: number }>}
- */
-export async function validateConceptBlocks(site) {
-  const empty = { violations: [], schemas: new Set(), checked: 0 }
-
-  const parse = await loadSemanticParser()
-  if (!parse) return empty // no parser available — nothing to derive items from
-
-  const standards = await loadStandardSchemas()
-  if (!standards) return empty // @uniweb/schemas absent — nothing to check against
-
-  const violations = []
-  const schemasSeen = new Set()
-  let checked = 0
-
-  for (const page of site.pages || []) {
-    walkSections(page.sections || [], (section) => {
-      const doc = section.content
-      if (doc?.type !== 'doc') return
-
-      for (const node of conceptBlockNodes(doc)) {
-        const tag = node.attrs?.tag
-        if (!tag) continue
-
-        const raw = standards(tag)
-        if (!raw) continue // no `@std/<tag>` — say nothing, by design
-
-        let schema
-        try {
-          schema = validateAndNormalizeSchema(raw, `@std/${tag}`)
-        } catch {
-          continue // a malformed standard schema is that package's problem
-        }
-        if (!isStaticallyCheckable(schema)) continue
-
-        schemasSeen.add(`@std/${tag}`)
-        const { items } = parse({ type: 'doc', content: node.content || [] }, { alwaysItems: true })
-
-        items.forEach((item, idx) => {
-          checked++
-          for (const finding of validateItem(schema, item)) {
-            violations.push({
-              file: `${page.route || '/'} › ${section.type || 'section'} › md:${tag}`,
-              schema: `@std/${tag}`,
-              item: `item ${idx + 1}`,
-              users: [{ route: page.route, section: section.type, key: tag }],
-              ...finding,
-            })
-          }
-        })
-      }
-    })
+  const target = contentBodyField(schema)
+  if (!target) return record
+  if (!target.fileSection) {
+    if (record[target.key] === undefined) record[target.key] = r.body
+    return record
   }
-
-  return { violations, schemas: schemasSeen, checked }
-}
-
-/** Every concept block in a doc, including any nested inside a container. */
-function conceptBlockNodes(doc) {
-  return nodesOfType(doc, 'concept_block')
+  const held = record[target.fileSection]
+  if (held != null && (typeof held !== 'object' || Array.isArray(held))) return record
+  if (held?.[target.key] === undefined) record[target.fileSection] = { ...(held || {}), [target.key]: r.body }
+  return record
 }
 
 function nodesOfType(doc, type) {
@@ -495,11 +436,9 @@ function nodesOfType(doc, type) {
  * tagged block fills was never applied to anything. `@std/form` existed for
  * exactly this and had never run outside its own contract test.
  *
- * Unlike concept blocks (pass 3), the join here is NOT by convention. A concept
- * block resolves `md:faq` → `@std/faq` mechanically, which is why that pass must
- * stay silent when no such schema exists. This one uses the binding the component
- * actually declared, so there is no naming rule and no registry — a tag nobody
- * bound is simply not governed, and says nothing.
+ * The join is the binding the component actually declared, so there is no naming
+ * rule and no registry — a tag nobody bound is simply not governed, and says
+ * nothing.
  *
  * The value needs no parsing: a tagged fence lands as a `dataBlock` node with its
  * parsed value already on `attrs.data`, and a body that FAILED to parse never
@@ -562,28 +501,6 @@ export function validateTaggedDataBlocks(site, foundation, dataSchemas) {
   return { violations, schemas, checked, deferred }
 }
 
-/** `parseContent`, or null when the parser is not installed. */
-async function loadSemanticParser() {
-  try {
-    const mod = await import('@uniweb/semantic-parser')
-    return typeof mod.parseContent === 'function' ? mod.parseContent : null
-  } catch {
-    return null
-  }
-}
-
-/** A `(name) => schema | undefined` lookup over `@std`, or null when absent. */
-async function loadStandardSchemas() {
-  try {
-    const mod = await import('@uniweb/schemas')
-    if (typeof mod.getSchema === 'function') return (name) => mod.getSchema(name)
-    const table = mod.schemas ?? mod.default
-    return table ? (name) => table[name] : null
-  } catch {
-    return null
-  }
-}
-
 /**
  * The data inputs reaching a section, deduped by key — the fetches of its levels, most
  * specific first; when two levels share a key, the nearer one wins. What each input fills