mikser-io-layouts 11.2.1 → 11.4.0

package/.github/workflows/publish.yml

@@ -23,6 +23,15 @@ on:
 jobs:
   publish:
     runs-on: ubuntu-latest
+    # A hung test must not cost six hours.
+    #
+    # Without this the job runs to GitHub's own limit, reporting nothing:
+    # a flaky teardown in one suite sat on `npm test` for seventeen
+    # minutes before anyone looked, and would have sat there all day.
+    # The longest suite in the family is a couple of minutes including
+    # install, so fifteen is generous and still fails while someone is
+    # still watching.
+    timeout-minutes: 15
     permissions:
       contents: read
       # The whole mechanism. Without it npm has nothing to verify.

package/README.md

@@ -126,6 +126,33 @@ destination: '/cards/{{entity.name}}.html'
 ---
 ```
 
+### `match:` — a layout claiming its own entities
+
+A layout can declare the pattern that selects it, instead of the config
+naming it from the other side. These two are the same rule:
+
+```js
+layouts({ match: { '@/blog/*': 'post-card' } })
+```
+
+```yaml
+# layouts/post-card.html.hbs
+---
+match: '@/blog/*'          # or a list: ['@/blog/*', '@/news/*']
+---
+```
+
+They are **peers**, not alternatives — an entity matched by a config pattern
+and by a layout's own pattern gets both layouts, exactly as two config
+patterns would. A document's own `meta.layout` still wins over both, and
+auto-layout still only runs when nothing matched at all.
+
+Patterns follow the same rule everywhere: `matchEntity` globs `entity.name`
+only for a pattern starting `@/`; anything else globs `entity.id`, which
+carries the `/<collection>/` prefix and the extension. A pattern that selects
+nothing is reported once per run on a full cycle, naming the layout that
+declared it.
+
 ```yaml
 # Pull from meta
 ---

package/lib/matching.js

@@ -43,9 +43,25 @@ export function createOnProcessed({
     // author cannot see.
     const matchTally = { evaluated: 0, hit: new Set(), reported: false }
 
+    // Patterns a LAYOUT declared for itself in its own front-matter, seen
+    // during the run. Recorded here rather than derived at report time
+    // because by then the cycle's resolved-layout reads are gone, and a
+    // layout deleted mid-run should not be reported as a dud pattern.
+    const declaredSeen = new Map()
+
+    // A pattern's identity for the tally. The same glob can legitimately
+    // appear in config and in a layout's front-matter; they are different
+    // rules and either can be the dead one.
+    const tallyKey = (pattern, layoutName) =>
+        layoutName ? `layout:${layoutName}:${pattern}` : `config:${pattern}`
+
     function reportUnmatchedPatterns(logger) {
         if (matchTally.reported) return
-        const patterns = Object.keys(options.match || {})
+        const patterns = [
+            ...Object.keys(options.match || {}).map(pattern =>
+                ({ pattern, layout: options.match[pattern], source: null })),
+            ...Array.from(declaredSeen.values()),
+        ]
         if (!patterns.length || !matchTally.evaluated) return
         // Only when the cycle evaluated everything. An incremental run
         // re-evaluates whatever changed, so a healthy pattern matches none of
@@ -56,8 +72,8 @@ export function createOnProcessed({
         if (!isFullCycle(runtime)) return
         matchTally.reported = true
 
-        for (const pattern of patterns) {
-            if (matchTally.hit.has(pattern)) continue
+        for (const { pattern, layout: layoutName, source } of patterns) {
+            if (matchTally.hit.has(tallyKey(pattern, source))) continue
             // Phrased as what was observed: an incremental cycle only
             // re-evaluates changed entities, so a pattern can legitimately
             // match nothing in a run of three. The count lets the reader
@@ -69,12 +85,17 @@ export function createOnProcessed({
             // So 'post' does NOT match a document named 'post'; '@/post' and
             // '/documents/post.md' both do.
             const onName = pattern.startsWith('@/')
+            // Where the pattern is written decides where the fix goes, and
+            // the two places look nothing alike. Without this the reader of
+            // a front-matter typo goes hunting through the config.
+            const declaredIn = source ? ` declared in layouts/${source}` : ''
             logger.warn(
-                { code: 'layout-pattern-no-match', pattern, layout: options.match[pattern],
+                { code: 'layout-pattern-no-match', pattern, layout: layoutName,
+                  declaredIn: source || 'layouts.match',
                   evaluated: matchTally.evaluated, matchedAgainst: onName ? 'name' : 'id' },
-                'Layout pattern %j (→ %j) matched none of the %d entities evaluated. ' +
+                'Layout pattern %j (→ %j)%s matched none of the %d entities evaluated. ' +
                 'It is matched against entity.%s%s.',
-                pattern, options.match[pattern], matchTally.evaluated,
+                pattern, layoutName, declaredIn, matchTally.evaluated,
                 onName ? 'name' : 'id',
                 onName ? '' : " — prefix a pattern with '@/' to match entity.name instead, " +
                              'since an id looks like /<collection>/<name>.<ext>')
@@ -104,6 +125,42 @@ export function createOnProcessed({
             return (await findEntity({ id: stateEntry.id })) || stateEntry
         }
 
+        // `match:` in a layout's own front-matter — the colocated twin of a
+        // `layouts({ match: … })` rule, and documented alongside
+        // `destination:` since before either worked. `destination` was
+        // implemented; this was not, and a layout carrying it matched
+        // nothing, logged nothing, and looked configured. Reported after it
+        // cost a consumer the longest detour of their session.
+        //
+        // Read through resolveLayout for the same reason destination is
+        // (lib/assembly.js): the state map holds the file as synced, before
+        // front-matter has been lifted into meta. The raw entry has no
+        // `meta.match` to find.
+        //
+        // Built once per cycle rather than per entity: one findEntity per
+        // layout over a 5-20 entry map is nothing, the same work repeated
+        // for every document in the catalog is not.
+        let declaredPatterns = null
+        async function layoutDeclaredPatterns() {
+            if (declaredPatterns) return declaredPatterns
+            declaredPatterns = []
+            for (const name of Object.keys(layouts)) {
+                const declared = (await resolveLayout(name))?.meta?.match
+                if (!declared) continue
+                for (const pattern of Array.isArray(declared) ? declared : [declared]) {
+                    if (typeof pattern !== 'string' || !pattern) {
+                        logger.warn(
+                            'Layout %j declares a non-string `match` (%j) — expected a glob, or an array of them.',
+                            name, pattern)
+                        continue
+                    }
+                    declaredPatterns.push({ pattern, layout: name, source: name })
+                    declaredSeen.set(tallyKey(pattern, name), { pattern, layout: name, source: name })
+                }
+            }
+            return declaredPatterns
+        }
+
         // Resolve the set of layouts that should render `entity` this
         // cycle. Returns an array — empty if none matched. Rules:
         //   1. meta.layout (string) and meta.layouts (array) can't both
@@ -153,7 +210,7 @@ export function createOnProcessed({
             matchTally.evaluated++
             for (const pattern in options.match || []) {
                 if (matchEntity(entity, pattern)) {
-                    matchTally.hit.add(pattern)
+                    matchTally.hit.add(tallyKey(pattern, null))
                     const name = options.match[pattern]
                     const layout = await resolveLayout(name)
                     if (layout && !matched.find(l => l.name === layout.name)) {
@@ -168,6 +225,22 @@ export function createOnProcessed({
                 }
             }
 
+            // Then the patterns each layout declared for itself. A peer of
+            // the config rules, not a fallback: both are "a pattern claimed
+            // this entity", and an entity legitimately matched by one of
+            // each gets both layouts, exactly as two config patterns would.
+            for (const { pattern, layout: name, source } of await layoutDeclaredPatterns()) {
+                if (!matchEntity(entity, pattern)) continue
+                matchTally.hit.add(tallyKey(pattern, source))
+                const layout = await resolveLayout(name)
+                if (layout && !matched.find(l => l.name === layout.name)) {
+                    // Distinguishable from a config pattern in `--explain`:
+                    // the same glob can be written in either place, and the
+                    // fix goes to a different file depending on which.
+                    matched.push({ ...layout, matchedBy: `${pattern} (layouts/${name})` })
+                }
+            }
+
             // Auto-layout: only as a fallback when no pattern matched.
             // The peel ladder is intentionally first-wins — it's a
             // most-specific-name search, not a multi-match.
@@ -203,12 +276,28 @@ export function createOnProcessed({
             switch (operation) {
                 case OPERATION.CREATE:
                 case OPERATION.UPDATE:
+                    let resolutionFailed = false
                     try {
                         entity.layouts = await resolveLayoutsForEntity(entity)
                     } catch (err) {
                         logger.error('Layout resolution for %s: %s', entity.id, err.message)
                         entity.layouts = []
+                        resolutionFailed = true
                     }
+
+                    // Whether the AUTHOR asked for a layout. Used further
+                    // down to tell an abandoned page from a typo.
+                    //
+                    // Captured here, before the mirror below writes
+                    // meta.layout for the pattern-matched and auto-layout
+                    // paths, so the field still answers one question. Read
+                    // after it, "the author named a layout" and "we recorded
+                    // the one we chose" are the same value. That is a
+                    // legibility choice, not a fix: the mirror only writes
+                    // when a layout was found, so the `layouts.length === 0`
+                    // term below already excludes every entity it touched.
+                    const declaredALayout = Boolean(
+                        entity.meta?.layout || entity.meta?.layouts?.length)
                     // Back-compat alias. Most existing downstream code
                     // reads `entity.layout`; keep it pointing at the
                     // first matched layout so it stays useful. The
@@ -275,6 +364,41 @@ export function createOnProcessed({
                         )
                     }
 
+                    // Tell the manifest this entity produces nothing, so the
+                    // snapshots it used to hold stop claiming files nobody
+                    // writes any more.
+                    //
+                    // Take `layout:` out of a document's front matter and the
+                    // page stayed on disk with a snapshot still vouching for
+                    // it — and because the file still matched the hash its own
+                    // render recorded, --audit-output read OK while the site
+                    // served a page the source no longer asked for. The
+                    // manifest cannot see this by itself: with no render task
+                    // there is nothing to compare against, and an asset whose
+                    // preset threw looks exactly the same from there. This
+                    // hook is where it IS knowable, so this is where it is
+                    // said.
+                    //
+                    // Only for an entity that declared nothing and matched
+                    // nothing. The two excluded cases are both errors, and
+                    // mikser keeps the last good output through an error
+                    // rather than taking the page down:
+                    //
+                    //   declared but unresolvable — `layout: page` with no
+                    //     `page` layout, already warned about by
+                    //     resolveLayout. Renaming a layout file would
+                    //     otherwise delete every page that names it, on the
+                    //     strength of a typo.
+                    //   resolution threw — meta.layout and meta.layouts both
+                    //     set, say. Nothing was decided, so nothing follows.
+                    //
+                    // Optional-called: the peer floor is core ^11.1.0 and
+                    // recordNoOutput is newer than that, so on an older
+                    // engine this is simply the behaviour that came before.
+                    if (entity.layouts.length === 0 && !declaredALayout && !resolutionFailed) {
+                        runtime.manifest?.recordNoOutput?.(entity.id)
+                    }
+
                     // meta.postprocessor (string) / meta.postprocessors
                     // (array) override is read at task-build time (in
                     // onBeforeRender) because the layout entity is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikser-io-layouts",
-  "version": "11.2.1",
+  "version": "11.4.0",
   "description": "SSG-flavor task-production policy for mikser-io. Multi-match layout assignment, per-layout destinations, postprocess chain attachment, layout inspection.",
   "main": "index.js",
   "type": "module",

package/test/unit.test.js

@@ -210,6 +210,193 @@ describe('layouts plugin', () => {
         })
     })
 
+    it('a layout matches through `match:` in its own front-matter', async () => {
+        // Documented in the README beside `destination:` and never
+        // implemented. A layout carrying it produced no render task, logged
+        // nothing, and looked correctly configured — reported as the longest
+        // single detour of a consumer's session.
+        //
+        // The catalog entity is what carries parsed front-matter; the state
+        // map holds the file as synced. Seeding both is what a real build
+        // does, and is why reading the state map alone found no `match`.
+        await withTempWorking(async (workingFolder) => {
+            const catalog = []
+            const h = createHarness({
+                entities: catalog,
+                options: { workingFolder, outputFolder: path.join(workingFolder, 'out'), force: true },
+            })
+            layouts({ autoLayouts: false })(h.core)
+            await h.runHook('loaded')
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'post-card.hbs' } })
+            catalog.push({
+                id: h.runtime.state.layouts.layouts['post-card'].id,
+                collection: 'layouts', name: 'post-card',
+                meta: { match: '@/blog/*' },
+            })
+
+            const doc = { id: '/documents/blog/welcome.md', collection: 'documents', name: 'blog/welcome', format: 'md', meta: {} }
+            h.journal.push({ id: 1, entity: doc, operation: 'create', context: {}, options: {}, output: null })
+            await h.runHook('processed', { aborted: false })
+
+            assert.deepEqual(doc.layouts.map(l => l.name), ['post-card'])
+            assert.match(doc.layouts[0].matchedBy, /layouts\/post-card/,
+                'explain must say the rule came from the layout, not the config')
+        })
+    })
+
+    it('a layout can declare several patterns', async () => {
+        await withTempWorking(async (workingFolder) => {
+            const catalog = []
+            const h = createHarness({
+                entities: catalog,
+                options: { workingFolder, outputFolder: path.join(workingFolder, 'out'), force: true },
+            })
+            layouts({ autoLayouts: false })(h.core)
+            await h.runHook('loaded')
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'card.hbs' } })
+            catalog.push({
+                id: h.runtime.state.layouts.layouts['card'].id,
+                collection: 'layouts', name: 'card',
+                meta: { match: ['@/blog/*', '@/news/*'] },
+            })
+
+            const news = { id: '/documents/news/launch.md', collection: 'documents', name: 'news/launch', format: 'md', meta: {} }
+            h.journal.push({ id: 1, entity: news, operation: 'create', context: {}, options: {}, output: null })
+            await h.runHook('processed', { aborted: false })
+
+            assert.deepEqual(news.layouts.map(l => l.name), ['card'])
+        })
+    })
+
+    it('a front-matter pattern that selected nothing warns, naming the layout', async () => {
+        // The silence is the whole finding: without this the author of a
+        // typo'd front-matter pattern gets a green build and empty pages.
+        // Naming the layout matters because the same glob can be written in
+        // the config, and the fix lives in a different file.
+        await withTempWorking(async (workingFolder) => {
+            const catalog = []
+            const h = createHarness({
+                entities: catalog,
+                options: { workingFolder, outputFolder: path.join(workingFolder, 'out'), force: true },
+            })
+            layouts({ autoLayouts: false })(h.core)
+            await h.runHook('loaded')
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'post-card.hbs' } })
+            catalog.push({
+                id: h.runtime.state.layouts.layouts['post-card'].id,
+                collection: 'layouts', name: 'post-card',
+                meta: { match: '@/blogg/*' },   // typo
+            })
+
+            const doc = { id: '/documents/blog/welcome.md', collection: 'documents', name: 'blog/welcome', format: 'md', meta: {} }
+            h.journal.push({ id: 1, entity: doc, operation: 'create', context: {}, options: {}, output: null })
+            await h.runHook('processed', { aborted: false })
+
+            const warnings = h.logs.filter(l =>
+                l.level === 'warn' && l.args.join(' ').includes('Layout pattern'))
+            assert.equal(warnings.length, 1, `expected one warning, got ${warnings.length}`)
+            const [fields, ...message] = warnings[0].args
+            assert.equal(fields.code, 'layout-pattern-no-match')
+            assert.equal(fields.pattern, '@/blogg/*')
+            assert.equal(fields.declaredIn, 'post-card', 'says which layout wrote the pattern')
+            assert.match(format(...message), /layouts\/post-card/,
+                'the sentence points at the file to edit')
+        })
+    })
+
+    it('reports the one dud front-matter pattern among working ones', async () => {
+        // The shape this actually takes in a project: several layouts each
+        // claiming their own section, one of them typo'd. A working pattern
+        // elsewhere must not absolve the dead one — that would make the
+        // warning useless in exactly the configuration it is for.
+        await withTempWorking(async (workingFolder) => {
+            const catalog = []
+            const h = createHarness({
+                entities: catalog,
+                options: { workingFolder, outputFolder: path.join(workingFolder, 'out'), force: true },
+            })
+            layouts({ autoLayouts: false })(h.core)
+            await h.runHook('loaded')
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'post-card.hbs' } })
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'news-card.hbs' } })
+            catalog.push({
+                id: h.runtime.state.layouts.layouts['post-card'].id,
+                collection: 'layouts', name: 'post-card',
+                meta: { match: '@/blog/*' },            // works
+            })
+            catalog.push({
+                id: h.runtime.state.layouts.layouts['news-card'].id,
+                collection: 'layouts', name: 'news-card',
+                meta: { match: '@/newss/*' },           // typo
+            })
+
+            const doc = { id: '/documents/blog/welcome.md', collection: 'documents', name: 'blog/welcome', format: 'md', meta: {} }
+            h.journal.push({ id: 1, entity: doc, operation: 'create', context: {}, options: {}, output: null })
+            await h.runHook('processed', { aborted: false })
+
+            assert.deepEqual(doc.layouts.map(l => l.name), ['post-card'], 'the good pattern still matched')
+            const warnings = h.logs.filter(l =>
+                l.level === 'warn' && l.args.join(' ').includes('Layout pattern'))
+            assert.equal(warnings.length, 1, `expected exactly one warning, got ${warnings.length}`)
+            assert.equal(warnings[0].args[0].declaredIn, 'news-card', 'names the dud, not the working one')
+        })
+    })
+
+    it('a front-matter pattern is a peer of a config pattern, not a fallback', async () => {
+        // Two rules claiming one entity give two layouts, exactly as two
+        // config patterns would. Making front-matter a fallback would mean
+        // adding a config rule silently switched a layout off.
+        await withTempWorking(async (workingFolder) => {
+            const catalog = []
+            const h = createHarness({
+                entities: catalog,
+                options: { workingFolder, outputFolder: path.join(workingFolder, 'out'), force: true },
+            })
+            layouts({ autoLayouts: false, match: { '@/blog/*': 'post' } })(h.core)
+            await h.runHook('loaded')
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'post.hbs' } })
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'post-card.hbs' } })
+            catalog.push({
+                id: h.runtime.state.layouts.layouts['post-card'].id,
+                collection: 'layouts', name: 'post-card',
+                meta: { match: '@/blog/*' },
+            })
+
+            const doc = { id: '/documents/blog/welcome.md', collection: 'documents', name: 'blog/welcome', format: 'md', meta: {} }
+            h.journal.push({ id: 1, entity: doc, operation: 'create', context: {}, options: {}, output: null })
+            await h.runHook('processed', { aborted: false })
+
+            assert.deepEqual(doc.layouts.map(l => l.name).sort(), ['post', 'post-card'])
+        })
+    })
+
+    it('an author-declared meta.layout still wins over a front-matter pattern', async () => {
+        // Precedence is unchanged: what the document asks for beats what a
+        // layout claims, the same way it beats a config pattern.
+        await withTempWorking(async (workingFolder) => {
+            const catalog = []
+            const h = createHarness({
+                entities: catalog,
+                options: { workingFolder, outputFolder: path.join(workingFolder, 'out'), force: true },
+            })
+            layouts({ autoLayouts: false })(h.core)
+            await h.runHook('loaded')
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'post.hbs' } })
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'post-card.hbs' } })
+            catalog.push({
+                id: h.runtime.state.layouts.layouts['post-card'].id,
+                collection: 'layouts', name: 'post-card',
+                meta: { match: '@/blog/*' },
+            })
+
+            const doc = { id: '/documents/blog/welcome.md', collection: 'documents', name: 'blog/welcome', format: 'md', meta: { layout: 'post' } }
+            h.journal.push({ id: 1, entity: doc, operation: 'create', context: {}, options: {}, output: null })
+            await h.runHook('processed', { aborted: false })
+
+            assert.deepEqual(doc.layouts.map(l => l.name), ['post'])
+        })
+    })
+
     it('stays silent about an unmatched pattern on an incremental cycle', async () => {
         // The inverse of the test above, and the reason the gate exists. An
         // incremental run re-evaluates only what changed, so a pattern that
@@ -728,6 +915,112 @@ describe('layouts plugin: multi-layouts (matching)', () => {
     })
 })
 
+describe('layouts plugin: reporting that an entity renders nothing', () => {
+    // The manifest keeps a snapshot per (entity, destination) — its claim that
+    // the entity produced that file. An entity that STOPS producing output
+    // leaves the claim behind, and the page with it: still on disk, still
+    // matching the hash its own render recorded, so --audit-output reads OK
+    // while the site serves something the source no longer asks for.
+    //
+    // The manifest cannot see this alone. With no render task there is nothing
+    // to compare a claim against, and an asset whose preset threw looks
+    // identical from there — so guessing deletes the good derivative a failed
+    // preset exists to keep. This hook knows, so this hook says.
+    //
+    // What must NOT be reported is the whole difficulty. Both exclusions are
+    // errors, and mikser's rule through an error is that the last good output
+    // survives rather than the page coming down.
+    async function report(files, doc, options = {}) {
+        return withTempWorking(async (workingFolder) => {
+            const h = createHarness({
+                options: { workingFolder, outputFolder: path.join(workingFolder, 'out') },
+            })
+            const reported = []
+            h.runtime.manifest = { recordNoOutput: (id) => reported.push(id) }
+            layouts(options)(h.core)
+            await h.runHook('loaded')
+            for (const relativePath of files) {
+                await h.runSync('layouts', { action: 'create', context: { relativePath } })
+            }
+            h.journal.push({ id: 1, entity: doc, operation: 'create', context: {}, options: {}, output: null })
+            await h.runHook('processed', { aborted: false })
+            return { reported, doc, logs: h.logs }
+        })
+    }
+
+    const plainDoc = (meta) => ({
+        id: '/documents/blog/welcome.md',
+        collection: 'documents',
+        name: 'blog/welcome',
+        format: 'md',
+        meta,
+    })
+
+    it('reports an entity that declared nothing and matched nothing', async () => {
+        const { reported, doc } = await report(['post.hbs'], plainDoc({}))
+        assert.deepEqual(doc.layouts, [], 'precondition: nothing resolved')
+        assert.deepEqual(reported, ['/documents/blog/welcome.md'])
+    })
+
+    it('stays quiet when a declared layout merely cannot be found', async () => {
+        // A typo, or a layout file renamed. The entity still says which layout
+        // it wants, so this is an error to fix — not a page to withdraw.
+        // Reporting it would delete every page naming a layout the moment that
+        // layout's filename changed.
+        const { reported, doc, logs } = await report(['post.hbs'], plainDoc({ layout: 'pst' }))
+        assert.deepEqual(doc.layouts, [], 'precondition: nothing resolved')
+        assert.ok(logs.some(l => l.args.join(' ').includes('Layout not found')),
+            'precondition: it really did fail to resolve')
+        assert.deepEqual(reported, [])
+    })
+
+    it('stays quiet when resolution threw', async () => {
+        // meta.layout and meta.layouts both set. Nothing was decided, so
+        // nothing follows from it.
+        const { reported, doc } = await report(
+            ['post.hbs'], plainDoc({ layout: 'post', layouts: ['post'] }))
+        assert.deepEqual(doc.layouts, [], 'precondition: resolution failed')
+        assert.deepEqual(reported, [])
+    })
+
+    it('stays quiet when a layout did match', async () => {
+        const { reported, doc } = await report(['post.hbs'], plainDoc({ layout: 'post' }))
+        assert.equal(doc.layouts.length, 1, 'precondition: it resolved')
+        assert.deepEqual(reported, [])
+    })
+
+    it('stays quiet when a CONFIG PATTERN matched and the author declared nothing', async () => {
+        // The case that pins down which question `declaredALayout` answers.
+        // The mirror block writes meta.layout for pattern-matched and
+        // auto-layout entities, so if it were read after that, "the author
+        // named a layout" and "we recorded the one we chose" would be the same
+        // field — and an entity that rendered perfectly well would be reported
+        // as producing nothing, taking its own fresh output off disk.
+        const { reported, doc } = await report(
+            ['post.hbs'], plainDoc({}), { match: { '@/blog/*': 'post' } })
+        assert.equal(doc.layouts.length, 1, 'precondition: the pattern matched')
+        assert.equal(doc.meta.layout, 'post', 'precondition: and the mirror recorded it')
+        assert.deepEqual(reported, [])
+    })
+
+    it('does not require the engine to offer recordNoOutput at all', async () => {
+        // The peer floor is core ^11.1.0 and recordNoOutput is newer, so an
+        // entity that renders nothing on an older engine has to be a quiet
+        // no-op rather than a crash mid-cycle.
+        await withTempWorking(async (workingFolder) => {
+            const h = createHarness({
+                options: { workingFolder, outputFolder: path.join(workingFolder, 'out') },
+            })
+            assert.equal(h.runtime.manifest, undefined, 'precondition: no manifest on the runtime')
+            layouts()(h.core)
+            await h.runHook('loaded')
+            await h.runSync('layouts', { action: 'create', context: { relativePath: 'post.hbs' } })
+            h.journal.push({ id: 1, entity: plainDoc({}), operation: 'create', context: {}, options: {}, output: null })
+            await h.runHook('processed', { aborted: false })
+        })
+    })
+})
+
 describe('layouts plugin: multi-layouts (collision)', () => {
     it('drops both render tasks when two layouts produce the same destination', async () => {
         await withTempWorking(async (workingFolder) => {