@inditextech/docouture-asciidoc-extensions 1.1.0 → 1.2.0-SNAPSHOT.135.1

package/README.md

@@ -139,8 +139,8 @@ Antora's — treat them as a typing aid, not as proof that an API exists in 2.2.
 
 ## Reporting authoring mistakes
 
-Both site playbooks set `runtime.log.failure_level: warn`, so **a warning fails
-the build**. That is the right severity for an authoring error: an unknown label
+Scaffolded playbooks set `runtime.log.failure_level: error`, so **an error fails
+the build** and a warning does not. Log authoring mistakes as errors: an unknown label
 colour, a `[cards]` block with no cards, a tab set with no panels all render as
 something plausible but wrong, and shipping that is worse than not building.
 
@@ -148,10 +148,13 @@ Use `lib/warn.js` so every extension reports in the same shape — what the auth
 wrote, what is wrong, and what was expected:
 
 ```js
-warn(parent, 'label:mauve[]', 'unknown IDS Label variant "mauve"', VARIANTS)
+error(parent, 'label:mauve[]', 'unknown IDS Label variant "mauve"', VARIANTS)
 // → label:mauve[] — unknown IDS Label variant "mauve"; expected one of white, grey, …
 ```
 
+Output that is still correct but degraded ("only the first image is rendered")
+goes through `notice()` instead, which logs at `warn` and does not fail the build.
+
 ## Using this package in a site
 
 Two steps, both required. Doing only one fails silently.

package/lib/accordion.js

@@ -7,7 +7,7 @@
 const { chain, chainAll, precomputeSubtree } = require('./async-compat')
 const { escapeHtml, attr, stripTags } = require('./html')
 const uniqueId = require('./unique-id')
-const warn = require('./warn')
+const { error } = require('./warn')
 
 // Accordion grouping — GH-61 Part 2. Adds only what a native `[%collapsible]`
 // cannot express on its own: group semantics (`role=group`, an accessible
@@ -170,12 +170,12 @@ function collapsibleChildren(wrapper) {
 function finish(parent, wrapper, attrs, self) {
   const children = collapsibleChildren(wrapper)
   if (!children.length) {
-    warn(parent, '[accordion]', 'an accordion group with no `[%collapsible]` items in it')
+    error(parent, '[accordion]', 'an accordion group with no `[%collapsible]` items in it')
   }
 
   const ariaLabel = ariaLabelFor(attrs, wrapper)
   if (!ariaLabel) {
-    warn(
+    error(
       parent,
       '[accordion]',
       'an accordion group has no `aria-label=` and no title; give it one — a `role=group` with no accessible name is a strongly-discouraged pattern for screen reader users'
@@ -194,7 +194,7 @@ function finish(parent, wrapper, attrs, self) {
       .map((html, index) => {
         if (!groupName) return html
         if (!DETAILS_OPEN_RX.test(html)) {
-          warn(
+          error(
             parent,
             '[accordion]',
             'child ' + (index + 1) + " didn't render as a <details>; single-open needs every item to be one"
@@ -226,9 +226,12 @@ function accordionBlock() {
     // See steps.js's own comment: a literal JS `null` "source" crashes Opal
     // (2.2) inside `Block#initialize`'s `.nil_or_empty?()` check.
     const wrapper = this.createBlock(parent, 'open', '', attrs)
-    // See label-macro.js's own comment on this same pattern.
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this
+    // No `self = this` needed: this callback is already an arrow
+    // function (see this.process(...) below), so `this` here is
+    // already the outer block processor's own `this` (Asciidoctor
+    // never rebinds it the way it does inside a plain `function`
+    // callback — see label-macro.js's own comment on that different
+    // case) — passed straight through to finish() below.
     // See async-compat.js's own header comment: parseContent is sync under
     // 2.2 (Opal, real Antora builds) and Promise-returning under 4.0 (the
     // ui-bundle preview harness) — chain() handles either without making
@@ -236,7 +239,7 @@ function accordionBlock() {
     // a `.Title` carrying inline markup (this block's own, or a child
     // `[%collapsible]`'s) arrive converted rather than raw.
     return chain(this.parseContent(wrapper, reader.getLines()), () =>
-      chain(precomputeSubtree(wrapper), () => finish(parent, wrapper, attrs, self))
+      chain(precomputeSubtree(wrapper), () => finish(parent, wrapper, attrs, this))
     )
   })
 }

package/lib/accordion.spec.js

@@ -99,6 +99,7 @@ Just a stray paragraph.
       .map((m) => m.getText())
       .join('\n')
     expect(messages).toContain('an accordion group with no `[%collapsible]` items in it')
+    expect(logger.getMessages().every((m) => m.getSeverity().toString() === 'ERROR')).toBe(true)
   })
 
   it('warns when a group has no aria-label and no title', async () => {

package/lib/card-grid.js

@@ -6,7 +6,7 @@
 
 const { chain, chainAll, precomputeSubtree } = require('./async-compat')
 const { escapeHtml } = require('./html')
-const warn = require('./warn')
+const { error, notice } = require('./warn')
 
 // Card grid — the ATD Card (Figma component set 2669:33855, states and types
 // at 2610:29000 for light and 2669:42541 for dark), rendered as IDS Card
@@ -85,7 +85,7 @@ const BREAKPOINTS = ['s', 'm', 'l']
 const DEFAULT_COLUMNS = '1 s:2 m:3'
 const MAX_COLUMNS = 4
 
-const COLUMN_RX = /^(?:([a-z]+):)?([0-9]+)$/
+const COLUMN_RX = /^(?:([a-z]+):)?(\d+)$/
 // A bare Lucide icon name (lucide.dev/icons/<name>), lowercase and
 // hyphen-separated — the shape `icons.yml` uses. Whether that icon is
 // actually MASKED is checked by ui-bundle's own `just icons-build`
@@ -120,17 +120,17 @@ function parseColumns(spec, parent) {
     if (!token) continue
     const match = COLUMN_RX.exec(token)
     if (!match) {
-      warn(parent, '[cards,columns="' + spec + '"]', 'cannot read the column "' + token + '"; expected `3` or `m:3`')
+      error(parent, '[cards,columns="' + spec + '"]', 'cannot read the column "' + token + '"; expected `3` or `m:3`')
       continue
     }
     const [, breakpoint, count] = match
     if (breakpoint && !BREAKPOINTS.includes(breakpoint)) {
-      warn(parent, '[cards,columns="' + spec + '"]', 'unknown breakpoint "' + breakpoint + '"', BREAKPOINTS)
+      error(parent, '[cards,columns="' + spec + '"]', 'unknown breakpoint "' + breakpoint + '"', BREAKPOINTS)
       continue
     }
     const columns = Number(count)
     if (columns < 1 || columns > MAX_COLUMNS) {
-      warn(
+      error(
         parent,
         '[cards,columns="' + spec + '"]',
         columns + ' columns is outside the supported range 1-' + MAX_COLUMNS
@@ -161,7 +161,7 @@ function renderHeader(icon, subheader, parent) {
     if (ICON_RX.test(icon)) {
       iconHtml = '<span class="docouture-card__icon dt-icon-mask--' + escapeHtml(icon) + '" aria-hidden="true"></span>'
     } else {
-      warn(
+      error(
         parent,
         '[card,icon="' + icon + '"]',
         'not an icon reference; expected a bare Lucide icon name, e.g. `store`'
@@ -221,13 +221,13 @@ function renderCard(block, type, parent) {
   // already safe.
   const title = block.getTitle()
   if (!title) {
-    warn(parent, '[card]', 'a card has no title; give it a `.Title` line carrying the link')
+    error(parent, '[card]', 'a card has no title; give it a `.Title` line carrying the link')
     return ''
   }
 
   const href = (HREF_RX.exec(title) || [])[1]
   if (!href) {
-    warn(
+    error(
       parent,
       '[card] ' + block.getAttribute('title'),
       'a card title carries no link; make it an `xref:` or a `link:`'
@@ -236,17 +236,17 @@ function renderCard(block, type, parent) {
 
   const { images, bodies } = cardParts(block)
   if (type === 'no-image' && images.length) {
-    warn(parent, '[card]', 'this card has an image but the block is `type=' + type + '`', TYPES.slice(1))
+    error(parent, '[card]', 'this card has an image but the block is `type=' + type + '`', TYPES.slice(1))
   }
   if (type !== 'no-image' && !images.length) {
-    warn(parent, '[card]', 'a `type=' + type + '` card needs an `image::` of its own')
+    error(parent, '[card]', 'a `type=' + type + '` card needs an `image::` of its own')
   }
   if (images.length > 1) {
-    warn(parent, '[card]', 'a card has ' + images.length + ' images; only the first is rendered')
+    notice(parent, '[card]', 'a card has ' + images.length + ' images; only the first is rendered')
   }
   for (const body of bodies) {
     if (body.getContext() !== 'paragraph') {
-      warn(parent, '[card]', 'a card body holds a ' + body.getContext() + ' block; only paragraphs are supported')
+      error(parent, '[card]', 'a card body holds a ' + body.getContext() + ' block; only paragraphs are supported')
     }
   }
 
@@ -275,17 +275,17 @@ function renderCard(block, type, parent) {
 function finish(parent, wrapper, attrs, self) {
   const type = attrs.type || DEFAULT_TYPE
   if (!TYPES.includes(type)) {
-    warn(parent, '[cards,type=' + attrs.type + ']', 'unknown card type "' + attrs.type + '"', TYPES)
+    error(parent, '[cards,type=' + attrs.type + ']', 'unknown card type "' + attrs.type + '"', TYPES)
   }
 
   const width = attrs.width || DEFAULT_WIDTH
   if (!WIDTHS.includes(width)) {
-    warn(parent, '[cards,width=' + attrs.width + ']', 'unknown width "' + attrs.width + '"', WIDTHS)
+    error(parent, '[cards,width=' + attrs.width + ']', 'unknown width "' + attrs.width + '"', WIDTHS)
   }
 
   const cards = wrapper.getBlocks().filter((block) => block.getStyle() === 'card')
   if (!cards.length) {
-    warn(parent, '[cards]', 'a cards block with no `[card]` in it')
+    error(parent, '[cards]', 'a cards block with no `[card]` in it')
   }
 
   const cardHtmls = cards.map((card) => renderCard(card, TYPES.includes(type) ? type : DEFAULT_TYPE, parent))
@@ -310,15 +310,18 @@ function cardsBlock() {
     // See steps.js's own comment: a literal JS `null` "source" crashes Opal
     // (2.2) inside `Block#initialize`'s `.nil_or_empty?()` check.
     const wrapper = this.createBlock(parent, 'open', '', attrs)
-    // See label-macro.js's own comment on this same pattern.
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this
+    // No `self = this` needed: this callback is already an arrow
+    // function (see this.process(...) below), so `this` here is
+    // already the outer block processor's own `this` (Asciidoctor
+    // never rebinds it the way it does inside a plain `function`
+    // callback — see label-macro.js's own comment on that different
+    // case) — passed straight through to finish() below.
     // See async-compat.js's own header comment: parseContent is sync under
     // 2.2 (Opal, real Antora builds) and Promise-returning under 4.0 (the
     // ui-bundle preview harness) — chain() handles either without making
     // this function `async` unconditionally.
     return chain(this.parseContent(wrapper, reader.getLines()), () =>
-      chain(precomputeSubtree(wrapper), () => finish(parent, wrapper, attrs, self))
+      chain(precomputeSubtree(wrapper), () => finish(parent, wrapper, attrs, this))
     )
   })
 }

package/lib/card-grid.spec.js

@@ -0,0 +1,70 @@
+// SPDX-FileCopyrightText: 2026 INDUSTRIA DE DISEÑO TEXTIL S.A. (INDITEX S.A.)
+//
+// SPDX-License-Identifier: Apache-2.0
+
+'use strict'
+
+import { describe, expect, it } from 'vitest'
+
+const asciidoctor = require('@asciidoctor/core')
+const registerCardGrid = require('./card-grid')
+
+/**
+ * @param {string} source
+ * @returns {Promise<{ html: string, messages: { severity: string, text: string }[] }>}
+ */
+async function run(source) {
+  const logger = asciidoctor.MemoryLogger.create()
+  asciidoctor.LoggerManager.setLogger(logger)
+  const registry = asciidoctor.Extensions.create()
+  registerCardGrid(registry)
+  const html = await asciidoctor.convert(source, { extension_registry: registry, safe: 'safe' })
+  const messages = logger.getMessages().map((m) => ({ severity: m.getSeverity().toString(), text: m.getText() }))
+  return { html: String(html), messages }
+}
+
+const errorsOf = (messages) => messages.filter((m) => m.severity === 'ERROR').map((m) => m.text)
+
+describe('cards block severities', () => {
+  it('errors on an unknown type, width and an empty block', async () => {
+    const { messages } = await run('[cards,type=bogus,width=huge]\n====\nJust text.\n====\n')
+    const text = errorsOf(messages).join('\n')
+    expect(text).toContain('unknown card type "bogus"')
+    expect(text).toContain('unknown width "huge"')
+    expect(text).toContain('a cards block with no `[card]` in it')
+  })
+
+  it('errors on unreadable columns, an unknown breakpoint and an out-of-range count', async () => {
+    const { messages } = await run('[cards,columns="x zz:3 m:99"]\n====\nJust text.\n====\n')
+    const text = errorsOf(messages).join('\n')
+    expect(text).toContain('cannot read the column "x"')
+    expect(text).toContain('unknown breakpoint "zz"')
+    expect(text).toContain('outside the supported range')
+  })
+
+  it('errors on a card without a title and on a title without a link', async () => {
+    const { messages } = await run(
+      '[cards,type=no-image]\n====\n[card]\nNo title here.\n\n[card]\n.Plain title\nBody.\n====\n'
+    )
+    const text = errorsOf(messages).join('\n')
+    expect(text).toContain('a card has no title')
+    expect(text).toContain('a card title carries no link')
+  })
+
+  it('errors when an image does not match the card type, or is missing', async () => {
+    const withImage = await run(
+      '[cards,type=no-image]\n====\n[card]\n.link:https://example.com[A]\n--\nimage::a.png[A]\n--\n====\n'
+    )
+    expect(errorsOf(withImage.messages).join('\n')).toContain('this card has an image but the block is `type=no-image`')
+    const missing = await run('[cards,type=image-square]\n====\n[card]\n.link:https://example.com[A]\nBody.\n====\n')
+    expect(errorsOf(missing.messages).join('\n')).toContain('needs an `image::` of its own')
+  })
+
+  it('notices extra images (warn, not error) and errors on a non-paragraph body', async () => {
+    const { messages } = await run(
+      '[cards,type=image-square]\n====\n[card]\n.link:https://example.com[A]\n--\nimage::a.png[A]\nimage::b.png[B]\n\n* a list\n--\n====\n'
+    )
+    expect(messages.some((m) => m.severity === 'WARN' && m.text.includes('only the first is rendered'))).toBe(true)
+    expect(errorsOf(messages).join('\n')).toContain('only paragraphs are supported')
+  })
+})

package/lib/cta.js

@@ -6,7 +6,7 @@
 
 const { chain, chainAll, precomputeSubtree } = require('./async-compat')
 const { escapeHtml, attr } = require('./html')
-const warn = require('./warn')
+const { error, notice } = require('./warn')
 
 // Call to action — a full-width band closing out a landing section, styled
 // after Fumadocs' "Free & Open Source" block on the Weave.js docs home
@@ -150,13 +150,13 @@ function splitImages(images, parent) {
   const dark = images.filter((image) => image.hasRole(DARK_ROLE))
   const light = images.filter((image) => !image.hasRole(DARK_ROLE))
   if (light.length > 1) {
-    warn(parent, '[cta]', 'a cta has ' + light.length + ' mark images; only the first is rendered')
+    notice(parent, '[cta]', 'a cta has ' + light.length + ' mark images; only the first is rendered')
   }
   if (dark.length > 1) {
-    warn(parent, '[cta]', 'a cta has ' + dark.length + ' `role=dark` mark images; only the first is rendered')
+    notice(parent, '[cta]', 'a cta has ' + dark.length + ' `role=dark` mark images; only the first is rendered')
   }
   if (dark.length && !light.length) {
-    warn(parent, '[cta]', 'a cta has a `role=dark` mark image but no mark for the light theme')
+    error(parent, '[cta]', 'a cta has a `role=dark` mark image but no mark for the light theme')
   }
   return { light: light[0], dark: dark[0] }
 }
@@ -198,7 +198,7 @@ function renderAction(converted, variant, role, parent) {
   if (!converted) return ''
   const match = CTA_RX.exec(converted)
   if (!match) {
-    warn(parent, '[.' + role + ']', 'a cta action carries no link; make it an `xref:` or a `link:`')
+    error(parent, '[.' + role + ']', 'a cta action carries no link; make it an `xref:` or a `link:`')
     return ''
   }
   const href = match[1] || ''
@@ -235,7 +235,7 @@ function renderAction(converted, variant, role, parent) {
 function finish(parent, wrapper, attrs, self) {
   const align = attrs.align || DEFAULT_ALIGN
   if (!ALIGNMENTS.includes(align)) {
-    warn(parent, '[cta,align=' + attrs.align + ']', 'unknown alignment "' + attrs.align + '"', ALIGNMENTS)
+    error(parent, '[cta,align=' + attrs.align + ']', 'unknown alignment "' + attrs.align + '"', ALIGNMENTS)
   }
 
   // A block-style attribute, so raw, so escaped — see the header comment on
@@ -245,20 +245,24 @@ function finish(parent, wrapper, attrs, self) {
 
   const { images, primaries, secondaries, bodies } = ctaParts(wrapper)
   if (!primaries.length) {
-    warn(parent, '[cta]', 'a cta has no `[.primary]` action')
+    error(parent, '[cta]', 'a cta has no `[.primary]` action')
   }
   if (primaries.length > 1) {
-    warn(parent, '[cta]', 'a cta has ' + primaries.length + ' `[.primary]` paragraphs; only the first is rendered')
+    notice(parent, '[cta]', 'a cta has ' + primaries.length + ' `[.primary]` paragraphs; only the first is rendered')
   }
   if (secondaries.length > 1) {
-    warn(parent, '[cta]', 'a cta has ' + secondaries.length + ' `[.secondary]` paragraphs; only the first is rendered')
+    notice(
+      parent,
+      '[cta]',
+      'a cta has ' + secondaries.length + ' `[.secondary]` paragraphs; only the first is rendered'
+    )
   }
   if (secondaries.length && !primaries.length) {
-    warn(parent, '[cta]', 'a cta has a `[.secondary]` action but no `[.primary]` one')
+    error(parent, '[cta]', 'a cta has a `[.secondary]` action but no `[.primary]` one')
   }
   for (const body of bodies) {
     if (body.getContext() !== 'paragraph') {
-      warn(parent, '[cta]', 'a cta body holds a ' + body.getContext() + ' block; only paragraphs are supported')
+      error(parent, '[cta]', 'a cta body holds a ' + body.getContext() + ' block; only paragraphs are supported')
     }
   }
   const { light, dark } = splitImages(images, parent)
@@ -314,16 +318,19 @@ function ctaBlock() {
     // See steps.js's own comment: a literal JS `null` "source" crashes Opal
     // (2.2) inside `Block#initialize`'s `.nil_or_empty?()` check.
     const wrapper = this.createBlock(parent, 'open', '', attrs)
-    // See label-macro.js's own comment on this same pattern.
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this
+    // No `self = this` needed: this callback is already an arrow
+    // function (see this.process(...) below), so `this` here is
+    // already the outer block processor's own `this` (Asciidoctor
+    // never rebinds it the way it does inside a plain `function`
+    // callback — see label-macro.js's own comment on that different
+    // case) — passed straight through to finish() below.
     // See async-compat.js's own header comment: parseContent is sync under
     // 2.2 (Opal, real Antora builds) and Promise-returning under 4.0 (the
     // ui-bundle preview harness) — chain() handles either without making
     // this function `async` unconditionally. precomputeSubtree is what makes
     // a `.Title` carrying inline markup arrive converted rather than raw.
     return chain(this.parseContent(wrapper, reader.getLines()), () =>
-      chain(precomputeSubtree(wrapper), () => finish(parent, wrapper, attrs, self))
+      chain(precomputeSubtree(wrapper), () => finish(parent, wrapper, attrs, this))
     )
   })
 }

package/lib/cta.spec.js

@@ -179,4 +179,63 @@ https://example.com[Go]
       .join('\n')
     expect(messages).toContain('a cta body holds a')
   })
+
+  it('logs a notice (warn, not error) when extra mark images are ignored', async () => {
+    const logger = asciidoctor.MemoryLogger.create()
+    await convert(
+      `[cta,title="T"]
+====
+image::a.svg[A]
+image::b.svg[B]
+
+[.primary]
+https://example.com[Go]
+====
+`,
+      { logger }
+    )
+    const msgs = logger.getMessages()
+    expect(msgs.length).toBeGreaterThan(0)
+    expect(msgs.every((m) => m.getSeverity().toString() === 'WARN')).toBe(true)
+  })
+
+  /** @param {string} source @returns {Promise<string[]>} severities logged */
+  async function severities(source) {
+    const logger = asciidoctor.MemoryLogger.create()
+    await convert(source, { logger })
+    return logger.getMessages().map((m) => m.getSeverity().toString())
+  }
+
+  it('errors on a dark-only mark and notices extra dark marks, extra primaries and secondaries', async () => {
+    const dark = await severities(`[cta,title="T"]
+====
+image::d.svg[role=dark]
+
+[.primary]
+https://example.com[Go]
+====
+`)
+    expect(dark).toContain('ERROR')
+    const extras = await severities(`[cta,title="T"]
+====
+image::a.svg[A]
+image::d1.svg[role=dark]
+image::d2.svg[role=dark]
+
+[.primary]
+https://example.com[One]
+
+[.primary]
+https://example.com[Two]
+
+[.secondary]
+https://example.com[S1]
+
+[.secondary]
+https://example.com[S2]
+====
+`)
+    expect(extras).toHaveLength(3)
+    expect(extras.every((x) => x === 'WARN')).toBe(true)
+  })
 })

package/lib/feature-tabs.js

@@ -7,7 +7,7 @@
 const { chain, chainAll, precomputeSubtree } = require('./async-compat')
 const { escapeHtml, attr } = require('./html')
 const uniqueId = require('./unique-id')
-const warn = require('./warn')
+const { error, notice } = require('./warn')
 
 // Feature tabs — the landing's "Key features" switcher (GH-22, Figma
 // 2696:54801 at l, 2696:92583 at m, 2696:94328 at s, 2696:95691 at xs).
@@ -167,13 +167,13 @@ function splitImages(images, parent) {
   const dark = images.filter((image) => image.hasRole(DARK_ROLE))
   const light = images.filter((image) => !image.hasRole(DARK_ROLE))
   if (light.length > 1) {
-    warn(parent, '[feature]', 'a slide has ' + light.length + ' images; only the first is rendered')
+    notice(parent, '[feature]', 'a slide has ' + light.length + ' images; only the first is rendered')
   }
   if (dark.length > 1) {
-    warn(parent, '[feature]', 'a slide has ' + dark.length + ' `role=dark` images; only the first is rendered')
+    notice(parent, '[feature]', 'a slide has ' + dark.length + ' `role=dark` images; only the first is rendered')
   }
   if (dark.length && !light.length) {
-    warn(parent, '[feature]', 'a slide has a `role=dark` image but no image for the light theme')
+    error(parent, '[feature]', 'a slide has a `role=dark` image but no image for the light theme')
   }
   return { light: light[0], dark: dark[0] }
 }
@@ -221,7 +221,7 @@ function renderCta(converted, parent) {
   if (!converted) return ''
   const match = CTA_RX.exec(converted)
   if (!match) {
-    warn(parent, '[.cta]', "a slide's call to action carries no link; make it an `xref:` or a `link:`")
+    error(parent, '[.cta]', "a slide's call to action carries no link; make it an `xref:` or a `link:`")
     return ''
   }
   const href = match[1] || ''
@@ -266,17 +266,17 @@ function renderFeature(block, index, parent) {
   // A block attribute, so raw, so escaped — the other half of that same rule.
   const label = block.getAttribute('label')
   if (!title && !label) {
-    warn(parent, '[feature]', 'a slide has no label; give it a `.Title` line or a `label=` attribute')
+    error(parent, '[feature]', 'a slide has no label; give it a `.Title` line or a `label=` attribute')
     return { tab: '', panel: '' }
   }
   const tabLabel = label ? escapeHtml(label) : title
 
   const { images, ctas, bodies } = featureParts(block)
   if (!images.length) {
-    warn(parent, '[feature] ' + (label || block.getAttribute('title')), 'a slide has no `image::` of its own')
+    error(parent, '[feature] ' + (label || block.getAttribute('title')), 'a slide has no `image::` of its own')
   }
   if (ctas.length > 1) {
-    warn(parent, '[feature]', 'a slide has ' + ctas.length + ' `[.cta]` paragraphs; only the first is rendered')
+    notice(parent, '[feature]', 'a slide has ' + ctas.length + ' `[.cta]` paragraphs; only the first is rendered')
   }
   const { light, dark } = splitImages(images, parent)
 
@@ -349,7 +349,7 @@ function renderFeature(block, index, parent) {
 function finish(parent, wrapper, attrs, self) {
   const features = wrapper.getBlocks().filter((block) => block.getStyle() === 'feature')
   if (!features.length) {
-    warn(parent, '[feature-tabs]', 'a feature-tabs block with no `[feature]` in it')
+    error(parent, '[feature-tabs]', 'a feature-tabs block with no `[feature]` in it')
   }
 
   const rendered = features.map((feature, index) => renderFeature(feature, index, parent))
@@ -381,16 +381,19 @@ function featureTabsBlock() {
     // See steps.js's own comment: a literal JS `null` "source" crashes Opal
     // (2.2) inside `Block#initialize`'s `.nil_or_empty?()` check.
     const wrapper = this.createBlock(parent, 'open', '', attrs)
-    // See label-macro.js's own comment on this same pattern.
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const self = this
+    // No `self = this` needed: this callback is already an arrow
+    // function (see this.process(...) below), so `this` here is
+    // already the outer block processor's own `this` (Asciidoctor
+    // never rebinds it the way it does inside a plain `function`
+    // callback — see label-macro.js's own comment on that different
+    // case) — passed straight through to finish() below.
     // See async-compat.js's own header comment: parseContent is sync under
     // 2.2 (Opal, real Antora builds) and Promise-returning under 4.0 (the
     // ui-bundle preview harness) — chain() handles either without making
     // this function `async` unconditionally. precomputeSubtree is what makes
     // a `.Title` carrying inline markup arrive converted rather than raw.
     return chain(this.parseContent(wrapper, reader.getLines()), () =>
-      chain(precomputeSubtree(wrapper), () => finish(parent, wrapper, attrs, self))
+      chain(precomputeSubtree(wrapper), () => finish(parent, wrapper, attrs, this))
     )
   })
 }

package/lib/feature-tabs.spec.js

@@ -175,4 +175,42 @@ Just a paragraph, no open block at all.
     expect(html).toContain('>Prose slide</a>')
     expect(html).toContain('Just a paragraph, no open block at all.')
   })
+
+  /** @param {string} source @returns {Promise<string[]>} severities logged */
+  async function severities(source) {
+    const logger = asciidoctor.MemoryLogger.create()
+    await convert(source, { logger })
+    return logger.getMessages().map((m) => m.getSeverity().toString())
+  }
+
+  it('errors on a dark-only slide image and notices extra images and ctas', async () => {
+    const dark = await severities(`[feature-tabs]
+====
+[feature,label="Dark only"]
+--
+image::d.png[role=dark]
+--
+====
+`)
+    expect(dark).toContain('ERROR')
+    const extras = await severities(`[feature-tabs]
+====
+[feature,label="Extras"]
+--
+image::a.png[A]
+image::b.png[B]
+image::d1.png[role=dark]
+image::d2.png[role=dark]
+
+[.cta]
+https://example.com[One]
+
+[.cta]
+https://example.com[Two]
+--
+====
+`)
+    expect(extras.length).toBeGreaterThanOrEqual(3)
+    expect(extras.every((x) => x === 'WARN')).toBe(true)
+  })
 })

package/lib/first-positional.js

@@ -12,6 +12,6 @@
 // Both are the attribute list's first positional entry.
 module.exports = function firstPositional(attrs) {
   if (attrs && Array.isArray(attrs.$positional)) return attrs.$positional[0]
-  if (attrs && Object.prototype.hasOwnProperty.call(attrs, '1')) return attrs['1']
+  if (attrs && Object.hasOwn(attrs, '1')) return attrs['1']
   return undefined
 }

package/lib/html.js

@@ -59,6 +59,16 @@ const ESCAPES = {
 
 const ESCAPE_RX = /[&<>"']/g
 
+// `value` is typed `unknown` below (see its own JSDoc) precisely because it
+// arrives however Asciidoctor handed it over — in real use always a string,
+// number or nullish (the `== null` guard below), never a plain object. This
+// is what makes stringifying it SAFE in practice — `String()` alone can't
+// prove that statically, and would silently produce `'[object Object]'` if
+// it were ever wrong, so this narrows first instead.
+function safeStringify(value) {
+  return typeof value === 'string' || typeof value === 'number' ? String(value) : JSON.stringify(value)
+}
+
 /**
  * Escapes a RAW authored string for interpolation into HTML.
  *
@@ -72,7 +82,7 @@ const ESCAPE_RX = /[&<>"']/g
  */
 function escapeHtml(value) {
   if (value == null) return ''
-  return String(value).replace(ESCAPE_RX, (char) => ESCAPES[/** @type {keyof typeof ESCAPES} */ (char)])
+  return safeStringify(value).replace(ESCAPE_RX, (char) => ESCAPES[/** @type {keyof typeof ESCAPES} */ (char)])
 }
 
 /**
@@ -112,13 +122,23 @@ const TAG_RX = /<[^>]*>/g
  * @param {string} html
  * @returns {string}
  */
+// Capped rather than unbounded: each pass removes at least one tag, so
+// nesting depth (not input length) bounds how many passes a real page ever
+// needs — legitimate content never comes close to this cap. Bounding it
+// anyway turns adversarially-deep nesting into a fixed, constant amount of
+// extra work, rather than relying on realistic content alone to keep this
+// fast.
+const MAX_STRIP_PASSES = 100
+
 function stripTags(html) {
   let previous
   let current = html
+  let passes = 0
   do {
     previous = current
     current = previous.replace(TAG_RX, '')
-  } while (current !== previous)
+    passes += 1
+  } while (current !== previous && passes < MAX_STRIP_PASSES)
   return current
 }