@unitninety/site-kit 1.6.2 → 1.6.3

package/src/elements/define.ts

@@ -80,7 +80,7 @@ export type ExpandCtx = {
   /** The Single's read value, already expanded by the caller. */
   single(key: string): unknown
   entry(collection: string, id: Id, depth: number): EntryRead
-  query(collection: string, query: unknown): { entries: EntryRead[]; total: number }
+  query(collection: string, query: unknown): { entries: EntryRead[]; total: number; matches?: Id[] }
   inverse(collection: string, field: string, id: Id): EntryRead[]
 }
 export type SeedCtx = {
@@ -101,7 +101,9 @@ export type LeafDecl = {
   required?: boolean
   /** Seed shape. */
   default?: unknown
-  /** Sub-paths a client may not change, e.g. `['to']` on a link. */
+  /** Sub-paths a client may not change, e.g. `['to']` on a link. `['$']` fixes the whole
+   * value (including an absent value) on retained fields and omits its editor. Initial
+   * document seeding and new repeated items may initialise their values. */
   lock?: string[]
   renamedFrom?: string
   options?: Record<string, unknown>
@@ -112,12 +114,29 @@ export type ZoneDecl = { container: 'u90/zone'; label?: string; allow: string[];
 export type FieldDecl = LeafDecl | GroupDecl | ListDecl | ZoneDecl
 export const isLeaf = (d: FieldDecl): d is LeafDecl => 'element' in d
 
-export type BlockDecl = { name: string; label: string; fields: Record<string, FieldDecl>; entry?: string; order?: string[] }
+export type BlockDecl = { name: string; label: string; fields: Record<string, FieldDecl>; entry?: string; order?: string[]; shared?: { single: string; field: string; previewFields?: string[] } }
+/** Pinned content shown before or after a collection entry's editable page sections. */
+export type CollectionAuthoringAnchor = { label: string; fields: string[] } | { label: string; single: string }
+export type CollectionAuthoringSections = {
+  /** The collection template's sole fixed block, whose entry is this collection. */
+  block: string
+  /** A direct zone field on the wrapper; other fields must be whole-value-locked leaves. */
+  field: string
+  before?: CollectionAuthoringAnchor[]
+  after?: CollectionAuthoringAnchor[]
+}
+export type CollectionAuthoring = {
+  /** Concise creation form; omitted collections keep title-only creation. */
+  create?: { fields: string[] }
+  /** Exposes the wrapper's zone as page sections, with optional pinned content. */
+  sections?: CollectionAuthoringSections
+}
 export type CollectionDecl = {
   name: string
   label: string
   fields: Record<string, FieldDecl>
   template?: ZoneDecl
+  authoring?: CollectionAuthoring
   defaultSort?: { field: string; dir: 'asc' | 'desc' } | 'manual'
   order?: string[]
 }

package/src/elements/jsonSchema.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod'
-import { isLeaf, type FieldDecl, type Schema } from './define'
+import { isLeaf, SLOT, type FieldDecl, type Schema } from './define'
 import { orderedEntries } from './order'
 import { ID_RE } from './path'
 import { getElement } from './registry'
@@ -29,8 +29,9 @@ export function toJSONSchema(decl: FieldDecl, schema?: Schema): JsonSchema {
   }
   const blocks = decl.allow.map((name) => {
     const block = schema?.blocks[name]
-    const fields = block ? (toJSONSchema({ container: 'u90/group', fields: block.fields, order: block.order }, schema).properties as object) : {}
-    return { type: 'object', properties: { _id: id, _block: { const: name }, ...fields }, required: ['_id', '_block'], additionalProperties: false }
+    const fields = block ? (toJSONSchema({ container: 'u90/group', fields: block.fields, order: block.order }, schema).properties as Record<string, JsonSchema>) : {}
+    if (block?.shared) fields[block.shared.field] = { oneOf: [{ type: 'null', description: 'Use the shared content.' }, fields[block.shared.field]] }
+    return { type: 'object', properties: { _id: id, _block: { const: name }, ...(!decl.fixed && name !== SLOT ? { _hidden: { type: 'boolean' } } : {}), ...fields }, required: ['_id', '_block'], additionalProperties: false }
   })
   return { type: 'array', items: { oneOf: blocks } }
 }

package/src/elements/leaves/query.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod'
 import { Id, defineElement, type ExpandCtx, type Ref } from '../define'
 import { ELEMENT_IDS, type ElementId } from '../ids'
+import { ReferencePreviewFields } from './relation'
 import { EntriesReadSchema, type EntriesRead } from './selection'
 
 export const FILTERABLE: readonly ElementId[] = ['u90/choice', 'u90/boolean', 'u90/relation', 'u90/date', 'u90/number']
@@ -9,6 +10,7 @@ const OPS = ['eq', 'neq', 'in', 'not-in', 'is-set'] as const
 
 export const QueryOptions = z.strictObject({
   to: z.string().min(1),
+  previewFields: ReferencePreviewFields,
   /** field → element of the target collection; filled in by validateSchema from the CollectionDecl. */
   targetFields: z.record(z.string(), z.enum(ELEMENT_IDS)).optional(),
 })
@@ -77,7 +79,10 @@ const stored = (o: O) =>
         ctx.addIssue({ code: 'custom', path: [k], message: 'Each entry may be listed once.', params: { code: 'duplicate' } })
     }
   })
-const expand = (v: QueryStored, o: O, ctx: ExpandCtx): EntriesRead => ({ ...ctx.query(o.to, v), ...(ctx.draft ? { $path: ctx.at, $pins: (v.pin ?? []).map(String) } : {}) })
+const expand = (v: QueryStored, o: O, ctx: ExpandCtx): EntriesRead => {
+  const { matches, ...read } = ctx.query(o.to, v)
+  return { ...read, ...(ctx.draft ? { $path: ctx.at, $pins: (v.pin ?? []).map(String), ...(matches ? { $query: { matches, where: v.where ?? [], sort: v.sort ?? null, limit: v.limit ?? null } } : {}) } : {}) }
+}
 
 export const query = defineElement({
   id: 'u90/query',

package/src/elements/leaves/relation.ts

@@ -11,9 +11,12 @@ export const uniqueIds = (ids: unknown[], ctx: z.RefinementCtx) => {
     ctx.addIssue({ code: 'custom', message: 'Each entry may be referenced once.', params: { code: 'duplicate' } })
 }
 
+export const ReferencePreviewFields = z.array(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/)).min(1).max(20).refine(fields => new Set(fields).size === fields.length, 'Preview fields must be unique').optional()
+
 export const RelationOptions = z
   .strictObject({
     to: z.string().min(1),
+    previewFields: ReferencePreviewFields,
     cardinality: z.enum(['many-to-one', 'one-to-one', 'many-to-many', 'one-to-many']),
     inverseOf: z.string().min(1).optional(),
     depth: z.int().min(0).max(3).default(1),

package/src/elements/leaves/selection.ts

@@ -1,12 +1,13 @@
 import { z, type ZodType } from 'zod'
 import { EntryReadSchema, Id, defineElement, requiredIssue, type EntryRead, type ExpandCtx, type Ref } from '../define'
-import { EntryRef, resolveEntryRef, uniqueIds } from './relation'
+import { EntryRef, ReferencePreviewFields, resolveEntryRef, uniqueIds } from './relation'
 
-export const SelectionOptions = z.strictObject({ to: z.string().min(1), many: z.boolean().default(false), max: z.int().positive().optional(), depth: z.int().min(0).max(3).default(1) })
+export const SelectionOptions = z.strictObject({ to: z.string().min(1), many: z.boolean().default(false), max: z.int().positive().optional(), depth: z.int().min(0).max(3).default(1), previewFields: ReferencePreviewFields })
 type O = z.infer<typeof SelectionOptions>
 /** How a selection and a query read: the entries in order, how many there are, and `$path` in draft. */
-export type EntriesRead = { entries: EntryRead[]; total: number; $path?: string; $pins?: string[] }
-export const EntriesReadSchema = z.object({ entries: z.array(EntryReadSchema), total: z.number(), $path: z.string().optional(), $pins: z.array(z.string()).optional() })
+export type QueryBaseline = { matches: (string | number)[]; where: unknown[]; sort: unknown; limit: number | null }
+export type EntriesRead = { entries: EntryRead[]; total: number; $path?: string; $pins?: string[]; $query?: QueryBaseline }
+export const EntriesReadSchema = z.object({ entries: z.array(EntryReadSchema), total: z.number(), $path: z.string().optional(), $pins: z.array(z.string()).optional(), $query: z.object({ matches: z.array(Id), where: z.array(z.unknown()), sort: z.unknown(), limit: z.number().nullable() }).optional() })
 
 const stored = (o: O) => (o.many ? (o.max ? z.array(Id).max(o.max) : z.array(Id)).superRefine(uniqueIds) : Id.nullable())
 type SeedValue = z.infer<typeof EntryRef> | z.infer<typeof EntryRef>[] | null

package/src/elements/ops/expand.ts

@@ -11,7 +11,7 @@ export type Resolved = {
   /** Singles already expanded to their read values by the caller. */
   singles?: Map<string, unknown>
   entries?: Map<string, EntryRecord>
-  queries?: Map<string, { ids: Id[]; total: number }>
+  queries?: Map<string, { ids: Id[]; total: number; matches?: Id[] }>
   inverses?: Map<string, Id[]>
 }
 export const entryKey = (collection: string, id: Id) => `${collection}:${id}`
@@ -40,7 +40,7 @@ export function makeCtx(schema: Schema, r: Resolved, at: string, draft: boolean,
     },
     query: (collection, q) => {
       const hit = r.queries?.get(queryKey(collection, q))
-      return hit ? { entries: hit.ids.map((id) => ctx.entry(collection, id, 1)), total: hit.total } : { entries: [], total: 0 }
+      return hit ? { entries: hit.ids.map((id) => ctx.entry(collection, id, 1)), total: hit.total, ...(draft && hit.matches ? { matches: hit.matches } : {}) } : { entries: [], total: 0 }
     },
     inverse: (collection, field, id) => (r.inverses?.get(inverseKey(collection, field, id)) ?? []).map((x) => ctx.entry(collection, x, 1)),
   }
@@ -61,8 +61,9 @@ export function expandField(schema: Schema, decl: FieldDecl, value: unknown, ctx
     if (decl.container === 'u90/list') return isLeaf(decl.item) ? inner : { _id: c.key, ...(ctx.draft ? { $path: path.child(ctx.at, c.key) } : {}), ...(inner as object) }
     const item = items[i]
     const block = record(item) ? String(item._block) : ''
-    if (block === SLOT || !Object.hasOwn(schema.blocks, block)) return { _id: c.key, _block: block }
-    return { _id: c.key, _block: block, ...(ctx.draft ? { $path: path.child(ctx.at, c.key) } : {}), ...(inner as object) }
+    const metadata = record(item) && typeof item._hidden === 'boolean' ? { _hidden: item._hidden } : {}
+    if (block === SLOT || !Object.hasOwn(schema.blocks, block)) return { _id: c.key, _block: block, ...metadata }
+    return { _id: c.key, _block: block, ...metadata, ...(ctx.draft ? { $path: path.child(ctx.at, c.key) } : {}), ...(inner as object) }
   })
 }
 

package/src/elements/ops/seed.ts

@@ -4,6 +4,7 @@ import { zodIssues } from '../leaf'
 import { path } from '../path'
 import { CURRENT_CONTRACT, getElement } from '../registry'
 import { record } from '../containers/group'
+import { blockFields } from '../containers/zone'
 import { orderedEntries } from '../order'
 
 export class SeedError extends Error {
@@ -19,6 +20,16 @@ const collector = () => {
   return { failures, fail }
 }
 
+/** Shared admission rules: visibility belongs only to block instances in non-fixed zones. */
+const visibilityIssues = (item: unknown, zone?: ZoneDecl): { code: string; message: string }[] => {
+  if (!record(item) || !Object.hasOwn(item, '_hidden')) return []
+  const issues: { code: string; message: string }[] = []
+  if (typeof item._hidden !== 'boolean') issues.push({ code: 'invalid_type', message: 'Block visibility must be a boolean.' })
+  if (!zone || item._block === SLOT) issues.push({ code: 'invalid-visibility', message: 'Only zone blocks can have visibility metadata.' })
+  else if (zone.fixed) issues.push({ code: 'fixed-visibility', message: 'Fixed blocks cannot have visibility metadata.' })
+  return issues
+}
+
 /** One declared field's stored value, from an explicit seed value or its declared default. */
 async function seedField(schema: Schema, decl: FieldDecl, v: unknown, ctx: SeedCtx, here: string, fail: Fail): Promise<unknown> {
   if (isLeaf(decl)) {
@@ -32,6 +43,7 @@ async function seedField(schema: Schema, decl: FieldDecl, v: unknown, ctx: SeedC
   }
   if (decl.container === 'u90/group') {
     const src = record(v) ? v : {}
+    visibilityIssues(src).forEach(i => fail(path.child(here, '_hidden'), i.message))
     const out: Record<string, unknown> = {}
     for (const [name, f] of orderedEntries(decl.fields, decl.order)) out[name] = await seedField(schema, f, src[name], ctx, path.child(here, name), fail)
     return out
@@ -50,18 +62,20 @@ async function seedField(schema: Schema, decl: FieldDecl, v: unknown, ctx: SeedC
 }
 async function seedListItem(schema: Schema, decl: ListDecl, item: unknown, ctx: SeedCtx, here: string, fail: Fail): Promise<Record<string, unknown>> {
   const _id = ctx.newId()
+  if (isLeaf(decl.item)) visibilityIssues(item).forEach(i => fail(path.child(here, _id, '_hidden'), i.message))
   const inner = await seedField(schema, decl.item, item, ctx, path.child(here, _id), fail)
   return isLeaf(decl.item) ? { _id, _value: inner } : { _id, ...(inner as object) }
 }
 async function seedZoneItem(schema: Schema, decl: ZoneDecl, item: unknown, ctx: SeedCtx, here: string, fail: Fail): Promise<Record<string, unknown> | null> {
   const _id = ctx.newId()
   const block = record(item) && typeof item._block === 'string' ? item._block : ''
+  visibilityIssues(item, decl).forEach(i => fail(path.child(here, _id, '_hidden'), i.message))
   if (block === SLOT) return { _id, _block: SLOT }
   const declared = Object.hasOwn(schema.blocks, block) ? schema.blocks[block] : undefined
   if (!declared) { fail(path.child(here, _id), `No block named "${block}".`); return null }
   if (!decl.allow.includes(block)) fail(path.child(here, _id), `"${block}" is not allowed here.`)
-  const { _block: _b, ...rest } = item as Record<string, unknown>
-  return { _id, _block: block, ...((await seedField(schema, { container: 'u90/group', fields: declared.fields, order: declared.order }, rest, ctx, path.child(here, _id), fail)) as object) }
+  const { _block: _b, _hidden, ...rest } = item as Record<string, unknown>
+  return { _id, _block: block, ...(typeof _hidden === 'boolean' ? { _hidden } : {}), ...((await seedField(schema, blockFields(declared, rest), rest, ctx, path.child(here, _id), fail)) as object) }
 }
 
 /** Declared defaults, or an explicit seed value, to stored JSON. Every failing path is collected before throwing. */
@@ -152,21 +166,26 @@ export function seedIssues(schema: Schema, docDecl: DocumentDecl, value: unknown
     }
     if (decl.container === 'u90/group') {
       if (!record(v)) return add(here, 'invalid_type', 'Expected an object of fields.')
-      for (const k of Object.keys(v)) if (!Object.hasOwn(decl.fields, k)) add(path.child(here, k), 'unknown-field', `No field named "${k}".`)
+      visibilityIssues(v).forEach(i => add(path.child(here, '_hidden'), i.code, i.message))
+      for (const k of Object.keys(v)) if (k !== '_hidden' && !Object.hasOwn(decl.fields, k)) add(path.child(here, k), 'unknown-field', `No field named "${k}".`)
       for (const [name, f] of orderedEntries(decl.fields, decl.order)) field(f, v[name], path.child(here, name))
       return
     }
     if (!Array.isArray(v)) return add(here, 'invalid_type', decl.container === 'u90/list' ? 'Expected a list.' : 'Expected a list of blocks.')
-    if (decl.container === 'u90/list') return v.forEach((item, i) => field(decl.item, item, path.child(here, i)))
+    if (decl.container === 'u90/list') return v.forEach((item, i) => {
+      if (isLeaf(decl.item)) visibilityIssues(item).forEach(issue => add(path.child(here, i, '_hidden'), issue.code, issue.message))
+      field(decl.item, item, path.child(here, i))
+    })
     v.forEach((item, i) => {
       const itemAt = path.child(here, i)
       const block = record(item) && typeof item._block === 'string' ? item._block : ''
+      visibilityIssues(item, decl).forEach(issue => add(path.child(itemAt, '_hidden'), issue.code, issue.message))
       if (block === SLOT) return
       const declared = Object.hasOwn(schema.blocks, block) ? schema.blocks[block] : undefined
       if (!declared) return add(itemAt, 'unknown-block', `No block named "${block}".`)
       if (!decl.allow.includes(block)) add(itemAt, 'not-allowed', `"${block}" is not allowed here.`)
-      const { _block: _b, ...rest } = item as Record<string, unknown>
-      field({ container: 'u90/group', fields: declared.fields, order: declared.order }, rest, itemAt)
+      const { _block: _b, _hidden: _h, ...rest } = item as Record<string, unknown>
+      field(blockFields(declared, rest), rest, itemAt)
     })
   }
   if (docDecl.kind === 'entry') {

package/src/elements/ops/validate.ts

@@ -1,3 +1,4 @@
+import { canonicalJson } from '../../site/wire'
 import { SLOT, type DocumentDecl, type Issue, type LeafIssue, type Mode, type Schema } from '../define'
 import { hasStoredShape, validateLeaf } from '../leaf'
 import { path } from '../path'
@@ -15,14 +16,39 @@ export function validate(schema: Schema, docDecl: DocumentDecl, doc: unknown, at
   const issues: Issue[] = []
   const push = (base: string, i: LeafIssue) => issues.push({ path: path.child(base, ...i.path), code: i.code, message: i.message, severity: i.severity ?? 'error' })
   const ids = new Map<string, string>()
+  const blockPaths = new Set<string>()
+  const hiddenPaths: string[] = []
   const layoutRoot = docDecl.kind === 'layout' ? path.child(at, 'blocks') : null
   const root = (p: string, code: string, message: string): Issue[] => [{ path: p, code, message, severity: 'error' }]
   if (!record(doc)) return root(at, 'invalid_type', 'A stored document is an object.')
   if (docDecl.kind === 'entry' && !Object.hasOwn(schema.collections, docDecl.collection)) return root(at, 'unknown-collection', `No collection named "${docDecl.collection}".`)
   if (docDecl.kind === 'single' && !Object.hasOwn(schema.singles, docDecl.key)) return root(at, 'unknown-single', `No Single named "${docDecl.key}".`)
   if (docDecl.kind === 'entry' && doc.fields !== undefined && !record(doc.fields)) return root(path.child(at, 'fields'), 'invalid_type', 'An entry stores its fields as an object.')
+  // Walking the old declaration also records absent fields. A new repeated item's path is
+  // absent from this map, so its defaults can initialise without unlocking retained fields.
+  const wholeLockedBefore = new Map<string, unknown>()
+  if (opts.previous !== undefined) walkDocument(schema, docDecl, opts.previous, {
+    leaf: ({ decl, value, at: here }) => { if (decl.lock?.includes('$')) wholeLockedBefore.set(here, value) },
+  }, at)
   walkDocument(schema, docDecl, doc, {
     enter: ({ container, decl, value, at: here }) => {
+      if (container.id === 'u90/zone' && Array.isArray(value)) {
+        for (const item of value) if (record(item)) {
+          const itemPath = path.child(here, String(item._id))
+          blockPaths.add(itemPath)
+          if (Object.hasOwn(item, '_hidden')) {
+            if (typeof item._hidden !== 'boolean') push(itemPath, { path: ['_hidden'], code: 'invalid_type', message: 'Block visibility must be a boolean.' })
+            if ('fixed' in decl && decl.fixed) push(itemPath, { path: ['_hidden'], code: 'fixed-visibility', message: 'Fixed blocks cannot have visibility metadata.' })
+            if (item._block === SLOT) push(itemPath, { path: ['_hidden'], code: 'invalid-visibility', message: 'SLOT cannot have visibility metadata.' })
+            if (item._hidden === true) hiddenPaths.push(itemPath)
+          }
+        }
+      }
+      if (record(value) && Object.hasOwn(value, '_hidden') && !blockPaths.has(here))
+        push(here, { path: ['_hidden'], code: 'invalid-visibility', message: 'Only zone blocks can have visibility metadata.' })
+      if (container.id === 'u90/list' && Array.isArray(value))
+        for (const item of value) if (record(item) && Object.hasOwn(item, '_hidden'))
+          push(path.child(here, String(item._id)), { path: ['_hidden'], code: 'invalid-visibility', message: 'List items cannot have visibility metadata.' })
       container.enter(decl, value, schema).forEach((i) => push(here, i))
       if (container.id === 'u90/zone' && slots(value) !== (here === layoutRoot ? 1 : 0))
         push(here, { path: [], code: 'slot', message: here === layoutRoot ? 'A layout holds exactly one SLOT.' : 'Only a layout may hold a SLOT.' })
@@ -34,8 +60,11 @@ export function validate(schema: Schema, docDecl: DocumentDecl, doc: unknown, at
           }
     },
     leaf: ({ entry, decl, value, at: here }) => {
-      validateLeaf(entry, decl, value, opts.mode).forEach((i) => push(here, i))
-      if (decl.lock?.length && opts.previous !== undefined) {
+      validateLeaf(entry, decl, value, hiddenPaths.some(p => here.startsWith(`${p}/`)) ? 'draft' : opts.mode).forEach((i) => push(here, i))
+      if (decl.lock?.includes('$') && wholeLockedBefore.has(here)) {
+        if (canonicalJson(wholeLockedBefore.get(here)) !== canonicalJson(value))
+          push(here, { path: [], code: 'locked', message: 'This field is set by the site and cannot be changed here.' })
+      } else if (decl.lock?.length && !decl.lock.includes('$') && opts.previous !== undefined) {
         const pointer = path.toPointer(opts.previous, here)
         const before = pointer === null ? undefined : valueAtPointer(opts.previous, pointer)
         if (before !== undefined)

package/src/legacy/cli.mjs

@@ -2,7 +2,7 @@
 import { readFile, writeFile } from 'node:fs/promises'
 
 /**
- * `npx --yes @unitninety/u90@1.0.1 pair <code>` — the one command an operator hands over. The u90 tool
+ * `npx --yes @unitninety/u90@1.0.3 pair <code>` — the one command an operator hands over. The u90 tool
  * runs this file for `u90 pair`. The command is scoped and pinned because an unscoped name, run in a
  * repository with no local bin, fetches whatever package npm holds under that name.
  *
@@ -115,7 +115,7 @@ const run = async () => {
   const args = process.argv.slice(2)
 
   if (args[0] !== 'pair' || !args[1]) {
-    fail('Usage: npx --yes @unitninety/u90@1.0.1 pair <code> --site https://example.com [--platform https://cms…]')
+    fail('Usage: npx --yes @unitninety/u90@1.0.3 pair <code> --site https://example.com [--platform https://cms…]')
   }
 
   const code = args[1]

package/src/legacy/content.ts

@@ -360,7 +360,7 @@ export const createContentClient = ({
             : !platformUrl
               ? 'PLATFORM_URL is unset'
               : 'PAYLOAD_API_KEY is unset'
-        }. Every page will render its committed fallback copy, and every collection route will 404. Set it in the site's environment — \`npx --yes @unitninety/u90@1.0.1 pair\` writes both.`,
+        }. Every page will render its committed fallback copy, and every collection route will 404. Set it in the site's environment — \`npx --yes @unitninety/u90@1.0.3 pair\` writes both.`,
       )
     }
     return true

package/src/seo/robots.ts

@@ -3,12 +3,12 @@ import type { SiteReply } from '../site/wire'
 import { siteUrlFor } from './metadata'
 
 /**
- * `robots.txt`: every crawler is allowed, and the sitemap named, unless the platform's
- * `allowIndexing` is off, when everything is disallowed and no sitemap is named. A `/site` read that
- * failed (`site` null) allows crawling, so a platform hiccup never takes a site out of search. With
- * no origin there is no absolute sitemap URL to name.
+ * Public pages remain crawlable even with indexing off: crawlers must fetch them to see
+ * metadata's noindex. Only indexable sites advertise a sitemap. Private previews are
+ * protected separately by the preview access gate and its X-Robots-Tag headers.
+ * A failed site read retains normal discovery rather than changing search policy.
  */
-export const robotsFor = ({ origin, site }: { origin: string | undefined; site: SiteReply | null }): MetadataRoute.Robots =>
-  site?.allowIndexing === false
-    ? { rules: { userAgent: '*', disallow: '/' } }
-    : { rules: { userAgent: '*', allow: '/' }, ...(origin ? { sitemap: siteUrlFor(origin, '/sitemap.xml') } : {}) }
+export const robotsFor = ({ origin, site }: { origin: string | undefined; site: SiteReply | null }): MetadataRoute.Robots => ({
+  rules: { userAgent: '*', allow: '/' },
+  ...(site?.allowIndexing !== false && origin ? { sitemap: siteUrlFor(origin, '/sitemap.xml') } : {}),
+})

package/src/seo/seeds.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod'
+import type { SiteManifest } from '../site/types'
+
+/** Portable SEO contains authored settings, never database IDs or Search Console credentials. */
+const text = z.string().max(10000).nullable().optional()
+const webUrl = z.string().max(400).refine(value => {
+  if (!value || /^\/(?!\/)\S*$/.test(value)) return true
+  try { const u = new URL(value); return ['http:', 'https:'].includes(u.protocol) && !u.username && !u.password } catch { return false }
+}, 'Expected an http or https URL, or a path on this site.').nullable().optional()
+const image = z.strictObject({ source: z.string().min(1).max(2048) }).nullable().optional()
+export const DocumentSeoSeedSchema = z.strictObject({
+  title: z.string().max(400).nullable().optional(), description: z.string().max(400).nullable().optional(), ogTitle: z.string().max(400).nullable().optional(), ogDescription: z.string().max(400).nullable().optional(),
+  ogImage: image, canonical: webUrl, noindex: z.boolean().optional(),
+})
+export const SiteSeoSeedSchema = z.strictObject({
+  allowIndexing: z.boolean().nullable().optional(), siteName: text, titleTemplate: text,
+  description: text, locale: text, ogImage: image, twitterHandle: text,
+  twitterCard: z.enum(['summary', 'summary_large_image']).optional(),
+  googleVerification: text, bingVerification: text,
+  organisation: z.strictObject({
+    legalName: text, logo: image, phone: text, email: text, address: text, legacyOpeningHours: text,
+    sameAs: z.array(z.string().max(2048)).max(100).optional(),
+    openingHours: z.array(z.strictObject({
+      day: z.enum(['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']),
+      closed: z.boolean(), opens: text, closes: text,
+    })).max(7).optional(),
+  }).nullable().optional(),
+})
+export const SeoSeedsSchema = z.strictObject({
+  site: SiteSeoSeedSchema.optional(),
+  pages: z.record(z.string(), DocumentSeoSeedSchema).optional(),
+  entries: z.record(z.string(), z.record(z.string(), DocumentSeoSeedSchema)).optional(),
+})
+export type DocumentSeoSeed = z.infer<typeof DocumentSeoSeedSchema>
+export type SiteSeoSeed = z.infer<typeof SiteSeoSeedSchema>
+export type SeoSeeds = z.infer<typeof SeoSeedsSchema>
+
+/** SEO targets must exist and have a page; no silent loss into unrendered fields. */
+export function seoSeedIssues(seo: SeoSeeds | undefined, manifest: SiteManifest): { path: string; message: string }[] {
+  const issues: { path: string; message: string }[] = []
+  for (const key of Object.keys(seo?.pages ?? {}))
+    if (!Object.hasOwn(manifest.pages, key)) issues.push({ path: `seo/pages/${key}`, message: 'SEO names a page the manifest does not declare.' })
+  for (const [collection, entries] of Object.entries(seo?.entries ?? {})) {
+    if (!manifest.collections[collection]?.route) issues.push({ path: `seo/entries/${collection}`, message: 'SEO needs a collection with its own page route.' })
+    for (const slug of Object.keys(entries))
+      if (!manifest.entries[collection]?.some(e => e.slug === slug)) issues.push({ path: `seo/entries/${collection}/${slug}`, message: 'SEO names an entry the manifest does not declare.' })
+  }
+  return issues
+}
+
+/** All portable image sources, with their diagnostic paths, for packaging and seeding. */
+export function seoSeedAssets(seo: SeoSeeds | undefined): { source: string; path: string }[] {
+  const out: { source: string; path: string }[] = []
+  const add = (value: { source: string } | null | undefined, path: string) => { if (value) out.push({ source: value.source, path }) }
+  add(seo?.site?.ogImage, 'seo/site/ogImage')
+  add(seo?.site?.organisation?.logo, 'seo/site/organisation/logo')
+  for (const [key, doc] of Object.entries(seo?.pages ?? {})) add(doc.ogImage, `seo/pages/${key}/ogImage`)
+  for (const [collection, entries] of Object.entries(seo?.entries ?? {}))
+    for (const [slug, doc] of Object.entries(entries)) add(doc.ogImage, `seo/entries/${collection}/${slug}/ogImage`)
+  return out
+}

package/src/server/render.tsx

@@ -5,18 +5,18 @@ import type { LanguageLinks } from '../languages/routing'
 import { LanguageProvider } from '../switcher/LanguageSwitcher'
 import { DraftBlocks } from '../bridge/DraftBlocks'
 
-type BlockItem = { _id: string; _block: string; $path?: string } & Record<string, unknown>
+type BlockItem = { _id: string; _block: string; _hidden?: boolean; $path?: string } & Record<string, unknown>
 /** What a block declared with `entry:` receives, when the document being rendered is an entry page. */
 type EntryProp = { id: string; slug?: string; route?: string; fields?: Record<string, unknown> }
 
 export function createRender(site: Site) {
   const Blocks = ({ value, slot, entry }: { value: unknown; slot?: ReactNode; entry?: EntryProp }): ReactElement => {
-    const items = (Array.isArray(value) ? value : []) as BlockItem[]
+    const items = ((Array.isArray(value) ? value : []) as BlockItem[]).filter(item => item._hidden !== true)
     const renderedItems = items.map((item) => {
       if (item._block === 'SLOT') return createElement(Fragment, { key: item._id }, slot)
       const def = Object.hasOwn(site.blocks, item._block) ? site.blocks[item._block] : undefined
       if (!def) return item.$path ? createElement('div', { key: item._id, 'data-u90-block': item.$path, 'data-u90-missing': item._block }, `Block "${item._block}" was removed`) : null
-      const { _id, _block, $path, ...fields } = item
+      const { _id, _block, _hidden, $path, ...fields } = item
       // zones arrive rendered: replace each zone-typed field with <Blocks/>, threading `entry` through
       const props: Record<string, unknown> = { ...fields }
       for (const [name, decl] of Object.entries(def.fields)) if ('container' in (decl as object) && (decl as { container: string }).container === 'u90/zone') props[name] = createElement(Blocks, { value: fields[name], entry })

package/src/site/assemble.ts

@@ -48,7 +48,7 @@ const declOf = (site: Site, d: ReplyDocument): DocumentDecl | null => {
 export function assemble(site: Site, reply: Reply, opts: AssembleOptions): RouteRead {
   if (reply.status === 'missing') {
     if (opts.stale && opts.defaults && declaredCodePage(site, opts.target))
-      return { ...assemble(site, replyFrom(site, opts.defaults, opts.target, reply.manifest), { ...opts, stale: false, defaults: null }), unavailable: true }
+      return { ...assemble(site, replyFrom(site, opts.defaults, opts.target, reply.manifest, opts.draft), { ...opts, stale: false, defaults: null }), unavailable: true }
     return { status: 'missing', tags: reply.tags }
   }
   const d = reply.document

package/src/site/defineSite.ts

@@ -94,8 +94,8 @@ export function defineSite(input: { singles: Singles; collections: Record<string
   for (const [k, c] of Object.entries(input.collections)) if (c.route) claim(c.route, `collection ${k}`)
   for (const [k, t] of Object.entries(input.pageTypes)) claim(t.route, `page type ${k}`)
   const schema: Schema = {
-    blocks: Object.fromEntries([...blocks.values()].map((b) => [b.name, { name: b.name, label: b.label, fields: strip(b.fields), ...(b.entry ? { entry: b.entry.name } : {}), order: Object.keys(b.fields) } satisfies BlockDecl])),
-    collections: Object.fromEntries(Object.values(input.collections).map((c) => [c.name, { name: c.name, label: c.label, fields: strip(c.fields), ...(c.template ? { template: JSON.parse(JSON.stringify(c.template.zone)) } : {}), ...(c.defaultSort ? { defaultSort: c.defaultSort } : {}), order: Object.keys(c.fields) } satisfies CollectionDecl])),
+    blocks: Object.fromEntries([...blocks.values()].map((b) => [b.name, { name: b.name, label: b.label, fields: strip(b.fields), ...(b.shared ? { shared: b.shared } : {}), ...(b.entry ? { entry: b.entry.name } : {}), order: Object.keys(b.fields) } satisfies BlockDecl])),
+    collections: Object.fromEntries(Object.values(input.collections).map((c) => [c.name, { name: c.name, label: c.label, fields: strip(c.fields), ...(c.authoring ? { authoring: JSON.parse(JSON.stringify(c.authoring)) } : {}), ...(c.template ? { template: JSON.parse(JSON.stringify(c.template.zone)) } : {}), ...(c.defaultSort ? { defaultSort: c.defaultSort } : {}), order: Object.keys(c.fields) } satisfies CollectionDecl])),
     singles: Object.fromEntries(Object.values(input.singles).map((s) => [s.key, { key: s.key, field: JSON.parse(JSON.stringify(s.decl)) }])),
   }
   // Finding 1: seed entries were checked only when seeded, at the platform or in the defaults store.

package/src/site/documents.ts

@@ -6,12 +6,12 @@ export const humanise = (name: string) => name.replace(/([a-z])([A-Z])/g, '$1 $2
 
 export const defineSingles = <M extends Record<string, Decl<unknown>>>(map: M): { [K in keyof M]: SingleDef<M[K] extends Decl<infer R> ? R : never> } =>
   Object.fromEntries(Object.entries(map).map(([key, decl]) => [key, { key, decl }])) as never
-export const collection = <F extends Fields>(name: string, o: { label?: string; fields: F; route?: string; defaultSort?: CollectionDef['defaultSort']; entries?: EntrySeed[] }): CollectionDef<F> =>
-  ({ kind: 'collection', name, label: o.label ?? humanise(name), fields: o.fields, route: o.route, defaultSort: o.defaultSort, ...(o.entries ? { entries: o.entries } : {}) })
+export const collection = <F extends Fields>(name: string, o: { label?: string; fields: F; route?: string; defaultSort?: CollectionDef['defaultSort']; entries?: EntrySeed[]; authoring?: CollectionDef['authoring'] }): CollectionDef<F> =>
+  ({ kind: 'collection', name, label: o.label ?? humanise(name), fields: o.fields, route: o.route, defaultSort: o.defaultSort, ...(o.authoring ? { authoring: o.authoring } : {}), ...(o.entries ? { entries: o.entries } : {}) })
 export const withTemplate = <C extends CollectionDef>(c: C, zone: Decl<unknown>, o: { layout?: string } = {}): C =>
   ({ ...c, template: { zone: zone as ZoneDecl, layout: o.layout } })
-export const block = <F extends Fields, C extends CollectionDef | undefined = undefined>(name: string, o: { label?: string; fields: F; component: unknown; entry?: C }): BlockDef<F, C> =>
-  ({ kind: 'block', name, label: o.label ?? humanise(name), fields: o.fields, component: o.component, entry: o.entry })
+export const block = <F extends Fields, C extends CollectionDef | undefined = undefined>(name: string, o: { label?: string; fields: F; component: unknown; entry?: C; shared?: BlockDef['shared'] }): BlockDef<F, C> =>
+  ({ kind: 'block', name, label: o.label ?? humanise(name), fields: o.fields, component: o.component, entry: o.entry, ...(o.shared ? { shared: o.shared } : {}) })
 export const layout = (o: { default?: boolean; parent?: string }, entries: Array<BlockDef | typeof SLOT>): LayoutDef => ({ kind: 'layout', ...o, entries })
 export const page = (o: { route: string; layout?: string; blocks: Decl<unknown> }): PageDef => ({ kind: 'page', route: o.route, layout: o.layout, blocks: o.blocks as ZoneDecl })
 export const pageType = (o: { label: string; route: string; layout?: string; blocks: Decl<unknown> }): PageTypeDef => ({ kind: 'pageType', ...o, blocks: o.blocks as ZoneDecl })

package/src/site/fields.ts

@@ -25,14 +25,14 @@ export const number = (o: Common & { default?: number; integer?: boolean; min?:
 export const boolean = (o: Common & { default?: boolean } = {}) => leaf<BooleanRead>('u90/boolean', o, {})
 export const choice = (values: Array<string | { value: string; label: string }>, o: Common & { default?: string | string[]; multiple?: boolean } = {}) =>
   leaf<ChoiceReadValue>('u90/choice', o, { values: values.map((v) => (typeof v === 'string' ? { value: v, label: v[0].toUpperCase() + v.slice(1) } : v)), multiple: o.multiple })
-export const relation = (to: string, o: Common & { default?: unknown; many?: boolean; unique?: boolean; inverseOf?: string; depth?: number } = {}) =>
+export const relation = (to: string, o: Common & { default?: unknown; many?: boolean; unique?: boolean; inverseOf?: string; depth?: number; previewFields?: string[] } = {}) =>
   leaf<EntryRead | EntryRead[] | null>('u90/relation', o, {
-    to, inverseOf: o.inverseOf, depth: o.depth,
+    to, inverseOf: o.inverseOf, depth: o.depth, previewFields: o.previewFields,
     cardinality: o.inverseOf ? (o.many ? 'many-to-many' : o.unique ? 'one-to-one' : 'one-to-many') : o.many ? 'many-to-many' : o.unique ? 'one-to-one' : 'many-to-one',
   })
-export const selection = (to: string, o: Common & { default?: unknown; many?: boolean; max?: number; depth?: number } = {}) =>
-  leaf<EntriesRead>('u90/selection', o, { to, many: o.many, max: o.max, depth: o.depth })
-export const query = (to: string, o: Common & { default?: unknown } = {}) => leaf<EntriesRead>('u90/query', o, { to })
+export const selection = (to: string, o: Common & { default?: unknown; many?: boolean; max?: number; depth?: number; previewFields?: string[] } = {}) =>
+  leaf<EntriesRead>('u90/selection', o, { to, many: o.many, max: o.max, depth: o.depth, previewFields: o.previewFields })
+export const query = (to: string, o: Common & { default?: unknown; previewFields?: string[] } = {}) => leaf<EntriesRead>('u90/query', o, { to, previewFields: o.previewFields })
 export const single = <R>(s: SingleDef<R>, o: Common = {}): Decl<R> => leaf<R>('u90/single', o, { key: s.key })
 
 export const group = <F extends Fields>(fields: F, o: { label?: string } = {}): Decl<{ [K in keyof F]: Read<F[K]> }> & { readonly __group: true } =>