@asciidoctor/core 4.0.0-alpha.6 → 4.0.1

package/build/node/index.cjs

@@ -5,7 +5,7 @@ const node_fs = require('node:fs');
 const path = require('node:path');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-var version = "4.0.0-alpha.6";
+var version = "4.0.1";
 const packageJson = {
 	version: version};
 
@@ -1752,14 +1752,23 @@ Logger.BasicFormatter = class {
 
 Logger.AutoFormattingMessage = {
   /**
-   * Attach auto-formatting to any plain object carrying { text, source_location }.
-   * @param {{text: string, source_location?: string}} obj
+   * Attach auto-formatting to any plain object carrying
+   * { text, source_location, include_location }.
+   *
+   * The location(s) are rendered only by inspect()/toString() (used when a
+   * stderr Logger formats the line); the structured `source_location` /
+   * `include_location` remain on the object so a MemoryLogger can record them
+   * on the resulting LogMessage without duplicating them inside `text`.
+   * @param {{text: string, source_location?: any, include_location?: any}} obj
    * @returns {typeof obj} The same object with inspect() and toString() added.
    */
   attach(obj) {
     obj.inspect = function () {
       const sloc = this.source_location;
-      return sloc ? `${sloc}: ${this.text}` : this.text
+      const iloc = this.include_location;
+      let text = sloc ? `${sloc}: ${this.text}` : this.text;
+      if (iloc) text += ` (${iloc})`;
+      return text
     };
     obj.toString = obj.inspect;
     return obj
@@ -1770,27 +1779,45 @@ Logger.AutoFormattingMessage = {
 
 /** Wrapper stored by MemoryLogger; provides getSeverity/getText/getSourceLocation. */
 class LogMessage {
+  /**
+   * @param {string} severity - Severity label, e.g. 'ERROR'.
+   * @param {string|{text: string, source_location?: import('./reader.js').Cursor}|null} message
+   */
   constructor(severity, message) {
     this.message = message;
+    /** @type {string} */
     this.severity = severity; // string label, e.g. 'ERROR'
     // AutoFormattingMessage objects carry { text, source_location }
     if (message !== null && typeof message === 'object' && 'text' in message) {
-      this._text = message.text;
-      this._sourceLocation = message.source_location ?? null;
+      /** @type {string} */
+      this.text = message.text;
+      /** @type {import('./reader.js').Cursor|null} */
+      this.sourceLocation = message.source_location ?? null;
     } else {
-      this._text = message != null ? String(message) : '';
-      this._sourceLocation = null;
+      this.text = message != null ? String(message) : '';
+      this.sourceLocation = null;
     }
   }
 
+  /**
+   * @returns {string} The severity label, e.g. 'ERROR'.
+   */
   getSeverity() {
     return this.severity
   }
+
+  /**
+   * @returns {string} The message text.
+   */
   getText() {
-    return this._text
+    return this.text
   }
+
+  /**
+   * @returns {import('./reader.js').Cursor|undefined} The source location, if any.
+   */
   getSourceLocation() {
-    return this._sourceLocation ?? undefined
+    return this.sourceLocation ?? undefined
   }
 }
 
@@ -1803,6 +1830,7 @@ class MemoryLogger {
     // matching Ruby's MemoryLogger (level: UNKNOWN). The add() method stores all
     // messages unconditionally — level is only used by the isDebug() guard.
     this.level = Severity.UNKNOWN;
+    /** @type {LogMessage[]} */
     this.messages = [];
   }
 
@@ -1810,6 +1838,9 @@ class MemoryLogger {
     return new MemoryLogger()
   }
 
+  /**
+   * @returns {LogMessage[]} The log messages recorded so far, in order.
+   */
   getMessages() {
     return this.messages
   }
@@ -6275,7 +6306,7 @@ function resolveBrowserIncludePath(reader, target, attrlist) {
     // ── Rule 2: target is an absolute URL (http:// / https:// / …) ───────────
   } else if (isUriish(pTarget)) {
     const descends = pathResolver.descendsFrom(pTarget, baseDir);
-    if (descends === false && !doc.getAttribute('allow-uri-read')) {
+    if (descends === false && !doc.hasAttribute('allow-uri-read')) {
       return reader.replaceNextLine(_linkReplacement(reader, target, attrlist))
     }
     incPath = relpath = pTarget;
@@ -6309,7 +6340,7 @@ function resolveBrowserIncludePath(reader, target, attrlist) {
   } else {
     // Nested include: context dir is an absolute URL.
     const ctxDescends = pathResolver.descendsFrom(ctxDir, baseDir);
-    if (ctxDescends !== false || doc.getAttribute('allow-uri-read')) {
+    if (ctxDescends !== false || doc.hasAttribute('allow-uri-read')) {
       incPath = `${ctxDir}/${pTarget}`;
       relpath = ctxDescends !== false ? incPath.slice(ctxDescends) : pTarget;
     } else {
@@ -6973,22 +7004,34 @@ class Reader {
   }
 
   /** @param {string} msg @param {{ sourceLocation?: any, includeLocation?: any }} [opts] */
-  _logWarn(msg, { sourceLocation, includeLocation } = {}) {
-    let text = sourceLocation ? `${sourceLocation.lineInfo}: ${msg}` : msg;
-    if (includeLocation) text += ` (${includeLocation.lineInfo})`;
-    this.logger.warn(text);
+  _logWarn(msg, opts = {}) {
+    this.logger.warn(this._messageWithContext(msg, opts));
   }
   _logError(msg, opts = {}) {
-    let text = opts.sourceLocation
-      ? `${opts.sourceLocation.lineInfo}: ${msg}`
-      : msg;
-    if (opts.includeLocation) text += ` (${opts.includeLocation.lineInfo})`;
-    this.logger.error(text);
+    this.logger.error(this._messageWithContext(msg, opts));
   }
   /** @param {string} msg @param {{ sourceLocation?: any }} [opts] */
-  _logInfo(msg, { sourceLocation } = {}) {
-    const text = sourceLocation ? `${sourceLocation.lineInfo}: ${msg}` : msg;
-    this.logger.info(text);
+  _logInfo(msg, opts = {}) {
+    this.logger.info(this._messageWithContext(msg, opts));
+  }
+
+  /**
+   * Build an auto-formatting message that keeps the cursor as a structured
+   * source_location (rather than baking it into the text). When displayed by a
+   * stderr Logger the location is rendered as a "<path>: line <N>: " prefix, but
+   * a MemoryLogger records it separately on the LogMessage so consumers can call
+   * getSourceLocation(). Mirrors Ruby's Logging#message_with_context.
+   * @param {string} msg
+   * @param {{ sourceLocation?: any, includeLocation?: any }} [opts]
+   * @internal
+   */
+  _messageWithContext(msg, { sourceLocation, includeLocation } = {}) {
+    if (!sourceLocation && !includeLocation) return msg
+    return Logger.AutoFormattingMessage.attach({
+      text: msg,
+      source_location: sourceLocation ?? null,
+      include_location: includeLocation ?? null,
+    })
   }
 }
 
@@ -7746,7 +7789,7 @@ class PreprocessorReader extends Reader {
     }
 
     if (isUriish(target) || typeof this._dir !== 'string') {
-      if (!doc.getAttribute('allow-uri-read')) {
+      if (!doc.hasAttribute('allow-uri-read')) {
         this._logWarn(
           `cannot include contents of URI: ${target} (allow-uri-read attribute not enabled)`,
           { sourceLocation: this.cursor }
@@ -10356,7 +10399,12 @@ class Parser {
             }
           }
 (intro ?? section).blocks.push(newBlock);
-          for (const key of Object.keys(attributes)) delete attributes[key];
+          // Reset the shared attributes object for the next block. Use Reflect.ownKeys
+          // (not Object.keys) so the Symbol-keyed attribute entries (ATTR_ENTRIES_KEY)
+          // are cleared too; otherwise the array of AttributeEntry objects leaks and
+          // accumulates across blocks, causing reassigned attributes (e.g. a body-level
+          // `:name:` redefined later) to all resolve to the final value at playback time.
+          for (const key of Reflect.ownKeys(attributes)) delete attributes[key];
         }
       }
 
@@ -11203,7 +11251,13 @@ class Parser {
       }
     }
 
-    if (Object.keys(attributes).length > 0) block.updateAttributes(attributes);
+    // Reflect.ownKeys (not Object.keys) so a block carrying only Symbol-keyed
+    // attribute entries (ATTR_ENTRIES_KEY) — e.g. an `:attr:` entry immediately
+    // preceding a list or table — still receives them, matching Ruby's
+    // `attributes.empty?` where the `:attribute_entries` key is counted. Without this
+    // the entries are dropped and the attribute is not played back for that block.
+    if (Reflect.ownKeys(attributes).length > 0)
+      block.updateAttributes(attributes);
     block.commitSubs();
 
     if (block.hasSub('callouts')) {
@@ -13473,6 +13527,7 @@ function _uniform(str, chr, len) {
  * DSL interface for include processors.
  *
  * @typedef {DocumentProcessorDslInterface & {
+ *   handles(fn: (target: string) => boolean): void;
  *   handles(fn: (doc: Document, target: string) => boolean): void;
  * }} IncludeProcessorDslInterface
  */
@@ -13523,7 +13578,7 @@ function _uniform(str, chr, len) {
  *   - Called with a single Function argument → stores it as the process block.
  *   - Called with non-Function arguments   → invokes the stored process block.
  *
- * The this context inside a stored process function is bound to the processor
+ * The `this` context inside a stored process function is bound to the processor
  * instance at definition time.
  */
 const ProcessorDsl = {
@@ -13697,6 +13752,35 @@ const SyntaxProcessorDsl = {
 const IncludeProcessorDsl = {
   ...DocumentProcessorDsl,
 
+  /**
+   * @overload
+   * @param {(target: string) => boolean} fn - Predicate that receives only the include target.
+   * @returns {void}
+   */
+  /**
+   * @overload
+   * @param {(doc: Document, target: string) => boolean} fn - Predicate that receives the document and the include target.
+   * @returns {void}
+   */
+  /**
+   * @overload
+   * @param {Document} doc - The document being parsed.
+   * @param {string} target - The include target.
+   * @returns {boolean}
+   */
+  /**
+   * Register a function that decides whether this include processor handles a given target,
+   * or invoke the registered handler.
+   *
+   * **Setter form** — register a predicate. The callback may accept either just the target
+   * string (arity 1) or both the document and the target string (arity 2).
+   *
+   * **Invoker form** — call the registered predicate with `(doc, target)` and return its
+   * result, or return `true` if no predicate has been registered.
+   *
+   * @param {...*} args
+   * @returns {boolean | void}
+   */
   handles(...args) {
     if (args.length === 1 && typeof args[0] === 'function') {
       const fn = args[0];
@@ -14464,6 +14548,8 @@ class ProcessorExtension extends Extension {
     super(kind, instance, instance.config);
     this.processMethod =
       processMethod || ((...args) => instance.process(...args));
+    /** @internal */
+    this._direct = false;
   }
 }
 
@@ -14491,10 +14577,24 @@ const SYNTAX_PROCESSOR_CLASSES = {
  * Registry holds the extensions which have been registered and activated, has
  * methods for registering or defining a processor and looks up extensions
  * stored in the registry during parsing.
+ *
+ * A registry can be reused across multiple conversions. Extensions registered
+ * via a group block (passed to {@link Extensions.create} or
+ * {@link Extensions.register}) are re-executed on every activation. Extensions
+ * registered directly on the registry instance (e.g. `registry.preprocessor(fn)`)
+ * are preserved across activations.
+ *
+ * @example
+ * const registry = Extensions.create('my-ext', function () {
+ *   this.preprocessor(function () { ... })
+ * })
+ * // registry can be passed to multiple conversions safely
  */
 class Registry {
   constructor(groups = {}) {
     this.groups = groups;
+    /** @internal */
+    this._activating = false;
     this._reset();
   }
 
@@ -14511,18 +14611,26 @@ class Registry {
       ...Object.values(Extensions.groups()),
       ...Object.values(this.groups),
     ];
-    for (const group of extGroups) {
-      if (typeof group === 'function') {
-        // Check if it is a class (constructor) with an activate prototype method.
-        if (group.prototype && typeof group.prototype.activate === 'function') {
-          new group().activate(this);
-        } else {
-          // Plain function — call in the context of this registry (like instance_exec).
-          group.length === 0 ? group.call(this) : group(this);
+    this._activating = true;
+    try {
+      for (const group of extGroups) {
+        if (typeof group === 'function') {
+          // Check if it is a class (constructor) with an activate prototype method.
+          if (
+            group.prototype &&
+            typeof group.prototype.activate === 'function'
+          ) {
+            new group().activate(this);
+          } else {
+            // Plain function — call in the context of this registry (like instance_exec).
+            group.length === 0 ? group.call(this) : group(this);
+          }
+        } else if (group && typeof group.activate === 'function') {
+          group.activate(this);
         }
-      } else if (group && typeof group.activate === 'function') {
-        group.activate(this);
       }
+    } finally {
+      this._activating = false;
     }
     return this
   }
@@ -15098,6 +15206,7 @@ class Registry {
     }
 
     const extension = new ProcessorExtension(kind, processorInstance);
+    extension._direct = !this._activating;
     extension.config.position === '>>'
       ? store.unshift(extension)
       : store.push(extension);
@@ -15169,27 +15278,44 @@ class Registry {
     }
 
     store[name] = new ProcessorExtension(kind, processorInstance);
+    store[name]._direct = !this._activating;
     return store[name]
   }
 
   /** @internal */
   _reset() {
+    // Keep extensions registered directly (outside a group); only clear group-registered ones.
+    // Extensions tagged with _direct=true survive across activations.
+    const keepArr = (arr) => {
+      const kept = arr?.filter((e) => e._direct) ?? [];
+      return kept.length ? kept : null
+    };
+    const keepMap = (map) => {
+      if (!map) return null
+      const kept = Object.create(null);
+      for (const [k, v] of Object.entries(map)) if (v._direct) kept[k] = v;
+      return Object.keys(kept).length ? kept : null
+    };
     /** @internal */
-    this._preprocessor_extensions = null;
+    this._preprocessor_extensions = keepArr(this._preprocessor_extensions);
     /** @internal */
-    this._tree_processor_extensions = null;
+    this._tree_processor_extensions = keepArr(this._tree_processor_extensions);
     /** @internal */
-    this._postprocessor_extensions = null;
+    this._postprocessor_extensions = keepArr(this._postprocessor_extensions);
     /** @internal */
-    this._include_processor_extensions = null;
+    this._include_processor_extensions = keepArr(
+      this._include_processor_extensions
+    );
     /** @internal */
-    this._docinfo_processor_extensions = null;
+    this._docinfo_processor_extensions = keepArr(
+      this._docinfo_processor_extensions
+    );
     /** @internal */
-    this._block_extensions = null;
+    this._block_extensions = keepMap(this._block_extensions);
     /** @internal */
-    this._block_macro_extensions = null;
+    this._block_macro_extensions = keepMap(this._block_macro_extensions);
     /** @internal */
-    this._inline_macro_extensions = null;
+    this._inline_macro_extensions = keepMap(this._inline_macro_extensions);
     this.document = null;
   }
 
@@ -15272,6 +15398,13 @@ const Extensions = {
   /**
    * Create a new Registry, optionally pre-populated with a named block.
    *
+   * When a `block` is provided it is stored as a group and re-executed on every
+   * activation, making the registry safe to reuse across multiple conversions.
+   * Without a `block`, any extensions registered directly on the returned registry
+   * (e.g. `registry.preprocessor(fn)`) are stored in transient state that is
+   * cleared on every activation — those registrations will be lost from the second
+   * conversion onwards. Prefer the block form when the registry may be reused.
+   *
    * @param {string|null} [name=null] - Optional name for the group; auto-generated if omitted.
    * @param {Function|null} [block=null] - Optional function to register as the group.
    * @returns {Registry}
@@ -16152,8 +16285,16 @@ class Document extends AbstractBlock {
     }
 
     // Pre-compute all async text values (titles, list item text, cell text, reftexts)
-    // so that synchronous getters work correctly during conversion.
+    // so that synchronous getters work correctly during conversion. _resolveAllTexts
+    // replays attribute entries in document order (mirroring conversion) so body-level
+    // attribute (re)assignments are in scope; snapshot and restore the document
+    // attributes so the downstream steps and conversion still start from the restored
+    // (header) state, matching Ruby's restore_attributes-before-convert invariant.
+    const attributesSnapshot = { ...this.attributes };
     await this._resolveAllTexts(this);
+    for (const key of Reflect.ownKeys(this.attributes))
+      delete this.attributes[key];
+    Object.assign(this.attributes, attributesSnapshot);
     // Reset the footnote counter so that body-content footnotes (processed during conversion)
     // start numbering from 1, reproducing Ruby's "out of sequence" quirk: title footnotes are
     // numbered during parsing via apply_title_subs, then the counter restarts for body content.
@@ -17227,6 +17368,12 @@ class Document extends AbstractBlock {
    * Handles titles (AbstractBlock), list item text, table cell text, and reftexts.
    */
   async _resolveAllTexts(block) {
+    // Replay this block's attribute entries (in document order, since the walk is
+    // depth-first pre-order like conversion) so that body-level attribute assignments
+    // and reassignments are in scope when the block's — and its descendants' and later
+    // siblings' — title / list item / table cell / reftext values are substituted.
+    // Mirrors AbstractBlock#convert, which calls playbackAttributes before converting.
+    this.playbackAttributes(block.attributes);
     // The header section lives outside document.blocks; pre-compute its title here so
     // that doc.doctitle() returns the fully-substituted title (with replacements applied,
     // e.g. ' → &#8217;) rather than the header-subs-only fallback.
@@ -17955,7 +18102,7 @@ const Substitutors = {
    *
    * @param {string|string[]} text - The text to process; must not be null.
    * @param {string[]} [subs=NORMAL_SUBS] - The substitutions to perform.
-   * @returns {string|string[]} Text with substitutions applied.
+   * @returns {Promise<string|string[]>} Text with substitutions applied.
    */
   async applySubs(text, subs = NORMAL_SUBS) {
     const isEmpty = Array.isArray(text) ? text.length === 0 : text.length === 0;
@@ -18069,7 +18216,7 @@ const Substitutors = {
    * Substitute quoted text (emphasis, strong, monospaced, etc.)
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subQuotes(text) {
     const compat = this.document.compatMode;
@@ -18241,7 +18388,7 @@ const Substitutors = {
    * Substitute inline macros (links, images, etc.)
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subMacros(text) {
     const foundSquareBracket = text.includes('[');
@@ -19136,7 +19283,7 @@ const Substitutors = {
    * Substitute post replacements (hard line breaks).
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subPostReplacements(text) {
     if (
@@ -19174,7 +19321,7 @@ const Substitutors = {
    *
    * @param {string} source
    * @param {boolean} processCallouts
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subSource(source, processCallouts) {
     return processCallouts
@@ -19186,7 +19333,7 @@ const Substitutors = {
    * Substitute callout source references.
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async subCallouts(text) {
     const calloutRx = this.hasAttribute('line-comment')
@@ -19215,7 +19362,7 @@ const Substitutors = {
    *
    * @param {string} source
    * @param {boolean} processCallouts
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async highlightSource(source, processCallouts) {
     const syntaxHl = this.document.syntaxHighlighter;
@@ -19561,7 +19708,7 @@ const Substitutors = {
    * Restore passthrough text by reinserting into placeholder positions.
    *
    * @param {string} text
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async restorePassthroughs(text) {
     if (!text.includes(PASS_START)) return text
@@ -19753,7 +19900,7 @@ const Substitutors = {
    * @param {string} attrlist
    * @param {string[]} [posattrs=[]]
    * @param {Object} [opts={}]
-   * @returns {Object}
+   * @returns {Promise<Object>}
    */
   async parseAttributes(attrlist, posattrs = [], opts = {}) {
     if (!attrlist || attrlist.length === 0) return {}
@@ -25250,6 +25397,7 @@ exports.Inline = Inline;
 exports.InlineMacroProcessor = InlineMacroProcessor;
 exports.List = List;
 exports.ListItem = ListItem;
+exports.LogMessage = LogMessage;
 exports.Logger = Logger;
 exports.LoggerManager = LoggerManager;
 exports.MemoryHttpCache = MemoryHttpCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asciidoctor/core",
-  "version": "4.0.0-alpha.6",
+  "version": "4.0.1",
   "description": "Asciidoctor.js: AsciiDoc in JavaScript powered by Asciidoctor",
   "type": "module",
   "main": "build/node/index.cjs",
@@ -66,7 +66,7 @@
   },
   "homepage": "https://github.com/asciidoctor/asciidoctor.js",
   "volta": {
-    "node": "24.16.0"
+    "node": "24.18.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.13",

package/src/browser/reader.js

@@ -92,7 +92,7 @@ export function resolveBrowserIncludePath(reader, target, attrlist) {
     // ── Rule 2: target is an absolute URL (http:// / https:// / …) ───────────
   } else if (isUriish(pTarget)) {
     const descends = pathResolver.descendsFrom(pTarget, baseDir)
-    if (descends === false && !doc.getAttribute('allow-uri-read')) {
+    if (descends === false && !doc.hasAttribute('allow-uri-read')) {
       return reader.replaceNextLine(_linkReplacement(reader, target, attrlist))
     }
     incPath = relpath = pTarget
@@ -126,7 +126,7 @@ export function resolveBrowserIncludePath(reader, target, attrlist) {
   } else {
     // Nested include: context dir is an absolute URL.
     const ctxDescends = pathResolver.descendsFrom(ctxDir, baseDir)
-    if (ctxDescends !== false || doc.getAttribute('allow-uri-read')) {
+    if (ctxDescends !== false || doc.hasAttribute('allow-uri-read')) {
       incPath = `${ctxDir}/${pTarget}`
       relpath = ctxDescends !== false ? incPath.slice(ctxDescends) : pTarget
     } else {

package/src/browser.js

@@ -9,7 +9,13 @@ import {
   ImageReference,
   RevisionInfo,
 } from './document.js'
-import { Logger, LoggerManager, MemoryLogger, NullLogger } from './logging.js'
+import {
+  Logger,
+  LoggerManager,
+  LogMessage,
+  MemoryLogger,
+  NullLogger,
+} from './logging.js'
 import { HttpCache, MemoryHttpCache, HttpCacheManager } from './http_cache.js'
 import { SafeMode, ContentModel } from './constants.js'
 import { Timings } from './timings.js'
@@ -110,6 +116,7 @@ export {
   Reader,
   SyntaxHighlighterBase,
   LoggerManager,
+  LogMessage,
   MemoryLogger,
   NullLogger,
   HttpCache,

package/src/document.js

@@ -587,8 +587,16 @@ export class Document extends AbstractBlock {
     }
 
     // Pre-compute all async text values (titles, list item text, cell text, reftexts)
-    // so that synchronous getters work correctly during conversion.
+    // so that synchronous getters work correctly during conversion. _resolveAllTexts
+    // replays attribute entries in document order (mirroring conversion) so body-level
+    // attribute (re)assignments are in scope; snapshot and restore the document
+    // attributes so the downstream steps and conversion still start from the restored
+    // (header) state, matching Ruby's restore_attributes-before-convert invariant.
+    const attributesSnapshot = { ...this.attributes }
     await this._resolveAllTexts(this)
+    for (const key of Reflect.ownKeys(this.attributes))
+      delete this.attributes[key]
+    Object.assign(this.attributes, attributesSnapshot)
     // Reset the footnote counter so that body-content footnotes (processed during conversion)
     // start numbering from 1, reproducing Ruby's "out of sequence" quirk: title footnotes are
     // numbered during parsing via apply_title_subs, then the counter restarts for body content.
@@ -1662,6 +1670,12 @@ export class Document extends AbstractBlock {
    * Handles titles (AbstractBlock), list item text, table cell text, and reftexts.
    */
   async _resolveAllTexts(block) {
+    // Replay this block's attribute entries (in document order, since the walk is
+    // depth-first pre-order like conversion) so that body-level attribute assignments
+    // and reassignments are in scope when the block's — and its descendants' and later
+    // siblings' — title / list item / table cell / reftext values are substituted.
+    // Mirrors AbstractBlock#convert, which calls playbackAttributes before converting.
+    this.playbackAttributes(block.attributes)
     // The header section lives outside document.blocks; pre-compute its title here so
     // that doc.doctitle() returns the fully-substituted title (with replacements applied,
     // e.g. ' → ’) rather than the header-subs-only fallback.