diff --git a/Makefile.cbm b/Makefile.cbm
index 9e1a7ac94..cd5eb4124 100644
--- a/Makefile.cbm
+++ b/Makefile.cbm
@@ -380,6 +380,7 @@ EXTRACTION_SRCS = \
     $(CBM_DIR)/doclink_py.c \
     $(CBM_DIR)/doc_adr.c \
     $(CBM_DIR)/doc_pdf.c \
+    $(CBM_DIR)/doc_adoc.c \
     $(CBM_DIR)/pdf/pdf_obj.c \
     $(CBM_DIR)/pdf/pdf_font.c \
     $(CBM_DIR)/pdf/pdf_text.c \
@@ -510,6 +511,7 @@ PIPELINE_SRCS = \
     src/pipeline/doc_links_md.c \
     src/pipeline/doc_links_pdf.c \
     src/pipeline/doc_links_rst.c \
+    src/pipeline/doc_links_adoc.c \
     src/pipeline/doc_links_msbuild.c \
     src/pipeline/pass_route_nodes.c \
     src/pipeline/pass_enrichment.c \
@@ -772,7 +774,7 @@ TEST_DISCOVER_SRCS = \
 
 TEST_GRAPH_BUFFER_SRCS = tests/test_graph_buffer.c
 
-TEST_PIPELINE_SRCS = tests/test_registry.c tests/test_pipeline.c tests/test_pipeline_conventions.c tests/test_pipeline_frozen.c tests/test_importance.c tests/test_cross_repo.c tests/test_fqn.c tests/test_route_canon.c tests/test_path_alias.c tests/test_configlink.c tests/test_doclinks.c tests/test_doc_mentions.c tests/test_doc_links_md.c tests/test_doc_links_pdf.c tests/test_doc_links_rst.c tests/test_infrascan.c tests/test_worker_pool.c tests/test_parallel.c tests/test_index_resilience.c tests/test_index_format.c tests/test_call_reference_contract.c tests/repro/repro_call_scope_usages.c tests/repro/repro_call_argument_usages.c tests/repro/repro_reference_precision.c tests/repro/repro_lexical_binding_precision.c tests/repro/repro_call_argument_matrix_a.c tests/repro/repro_call_argument_matrix_b.c tests/repro/repro_call_node_behaviors.c tests/repro/repro_language_registry.c tests/repro/repro_call_node_manifest.c tests/repro/repro_lsp_ordered_signatures.c tests/repro/repro_lsp_ordered_local.c tests/repro/repro_ts_overload_return_chains.c tests/repro/repro_harness_cleanup.c tests/repro/repro_runner_filter.c
+TEST_PIPELINE_SRCS = tests/test_registry.c tests/test_pipeline.c tests/test_pipeline_conventions.c tests/test_pipeline_frozen.c tests/test_importance.c tests/test_cross_repo.c tests/test_fqn.c tests/test_route_canon.c tests/test_path_alias.c tests/test_configlink.c tests/test_doclinks.c tests/test_doc_mentions.c tests/test_doc_links_md.c tests/test_doc_links_pdf.c tests/test_doc_links_rst.c tests/test_doc_links_adoc.c tests/test_infrascan.c tests/test_worker_pool.c tests/test_parallel.c tests/test_index_resilience.c tests/test_index_format.c tests/test_call_reference_contract.c tests/repro/repro_call_scope_usages.c tests/repro/repro_call_argument_usages.c tests/repro/repro_reference_precision.c tests/repro/repro_lexical_binding_precision.c tests/repro/repro_call_argument_matrix_a.c tests/repro/repro_call_argument_matrix_b.c tests/repro/repro_call_node_behaviors.c tests/repro/repro_language_registry.c tests/repro/repro_call_node_manifest.c tests/repro/repro_lsp_ordered_signatures.c tests/repro/repro_lsp_ordered_local.c tests/repro/repro_ts_overload_return_chains.c tests/repro/repro_harness_cleanup.c tests/repro/repro_runner_filter.c
 
 TEST_WATCHER_SRCS = tests/test_watcher.c
 
diff --git a/internal/cbm/cbm.c b/internal/cbm/cbm.c
index c740953f6..b9e3237b2 100644
--- a/internal/cbm/cbm.c
+++ b/internal/cbm/cbm.c
@@ -2821,6 +2821,25 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C
         cbm_index_mark_done(rel_path);
         return result;
     }
+    /* AsciiDoc has no grammar either: its headings, includes, attribute
+     * references and monospace spans are read from the text (doc_adoc.c). */
+    if (language == CBM_LANG_ASCIIDOC) {
+        result->module_qn = cbm_fqn_module_source_lang(a, project, rel_path, language);
+        CBMExtractCtx adoc_ctx = {
+            .arena = a,
+            .scratch = scratch,
+            .result = result,
+            .source = source,
+            .source_len = source_len,
+            .language = language,
+            .project = project,
+            .rel_path = rel_path,
+            .module_qn = result->module_qn,
+        };
+        cbm_adoc_extract_document(&adoc_ctx);
+        cbm_index_mark_done(rel_path);
+        return result;
+    }
 
     // Get language spec
     const CBMLangSpec *spec = cbm_lang_spec(language);
diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.h
index 0cb9c323c..b1868baec 100644
--- a/internal/cbm/cbm.h
+++ b/internal/cbm/cbm.h
@@ -210,6 +210,7 @@ typedef enum {
     CBM_LANG_PLSQL,    // Oracle PL/SQL
     CBM_LANG_CHIALISP, // Chialisp (.clsp/.clib/.clinc — Chia smart-coin s-expression language)
     CBM_LANG_PDF,      // PDF documents: the text layer, read without a grammar (doc_pdf.c)
+    CBM_LANG_ASCIIDOC, // AsciiDoc documents, read without a grammar (doc_adoc.c)
     CBM_LANG_COUNT
 } CBMLanguage;
 
diff --git a/internal/cbm/doc_adoc.c b/internal/cbm/doc_adoc.c
new file mode 100644
index 000000000..bfe70b69a
--- /dev/null
+++ b/internal/cbm/doc_adoc.c
@@ -0,0 +1,944 @@
+/*
+ * doc_adoc.c — AsciiDoc documents in the graph (the extraction half;
+ * src/pipeline/doc_links_adoc.c resolves), and the Antora scope blob.
+ *
+ * AsciiDoc has no grammar here: like a PDF, the file is read directly. Each
+ * heading (`= Title` .. `====== Title`, or `#` .. `######`) outside a
+ * delimited block becomes a Section (name the title, the text up to the next
+ * heading as its docstring, its lines up to the next heading); text before
+ * the first heading belongs to the file. Delimited blocks (`----` listing,
+ * `....` literal, `////` comment, `++++` passthrough, `====` example, `****`
+ * sidebar, `____` quote, `|===` table, ``` fences) open and close on the same
+ * delimiter line (the field test's H8 rules).
+ *
+ * References become tokens whose `raw` is the reference as written, then
+ * TAB-separated fields:
+ *   include     include::target[attrs] (Asciidoctor's preprocessor directive:
+ *               read in every block but a comment block; `\include::` is
+ *               escaped): written, target with the page's attributes
+ *               substituted (references the page does not define stay as
+ *               `{name}` for the component's), tags (`tag=` / `tags=`),
+ *               lines (`lines=`)
+ *   attribute   an attribute reference `{name}` in the text: written, name,
+ *               the page's value as written and as the page expands it (both
+ *               "" when the page does not define it).
+ *               Antora components define their API links as attributes
+ *               (`{Assertions}` -> a javadoc page): the resolver reads them.
+ *   code_path,  a monospace span (`x`, ``x``, `+x+`) naming a path or a
+ *   code_name   qualified name (the Markdown code-span classifier); raw is
+ *               the span's text
+ * Page attributes (`:name: value`, `:name!:` / `:!name:` to unset) apply from
+ * their line on, in document order.
+ *
+ * The Antora scope (cbm_doclink_antora_scan_scope): an antora.yml's component
+ * name, its asciidoc attributes and its collector scans; an
+ * antora-playbook*.yml's asciidoc attributes. Read as text, never run.
+ */
+#include "doclink.h"
+
+#include "arena.h"
+#include "cbm.h"
+#include "helpers.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+    AD_HEAD_MAX = 6,      /* `======` */
+    AD_DELIM_MIN = 4,     /* `----` and its kin */
+    AD_TABLE_MIN = 3,     /* `|===` */
+    AD_FENCE_MIN = 3,     /* ``` */
+    AD_BODY_MAX = 500,    /* a section's docstring (Markdown's MAX_COMMENT_LEN) */
+    AD_SPAN_MAX = 150,    /* a span the classifier reads (MD_SPAN_MAX) */
+    AD_ATTRS_INIT = 16,   /* first capacity of the page attribute list */
+    AD_EXPAND_DEPTH = 10, /* nested attribute references expanded (H8) */
+    AD_FIELD_MAX = 512,   /* an attribute value or target longer than this is skipped */
+};
+
+typedef struct {
+    const char *s;
+    int len;
+} ad_line_t;
+
+typedef struct {
+    char *name;
+    char *value;
+} ad_attr_t;
+
+typedef struct {
+    int line; /* 0-based */
+    const char *title;
+    const char *qn;
+    bool shared_qn;
+} ad_head_t;
+
+typedef struct {
+    CBMExtractCtx *ctx;
+    CBMArena *scratch;
+    ad_line_t *L;
+    int n;
+    unsigned char *in_block; /* 1: inside a delimited block; 2: inside a comment block */
+    ad_head_t *heads;
+    int nheads;
+    ad_attr_t *attrs;
+    int nattrs;
+    int cap_attrs;
+    char *span_buf;
+    bool failed;
+} ad_doc_t;
+
+static bool ad_blank(char c) {
+    return c == ' ' || c == '\t' || c == '\r';
+}
+
+static bool ad_word(char c) {
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+}
+
+/* The line without trailing whitespace: its length. */
+static int ad_rlen(const ad_line_t *l) {
+    int n = l->len;
+    while (n > 0 && ad_blank(l->s[n - 1])) {
+        n--;
+    }
+    return n;
+}
+
+/* ADOC_DELIM_RE: the delimiter's length, or 0. */
+static int ad_delim(const ad_line_t *l) {
+    int n = ad_rlen(l);
+    if (n == 0) {
+        return 0;
+    }
+    const char *s = l->s;
+    if (s[0] == '|') {
+        int k = 1;
+        while (k < n && s[k] == '=') {
+            k++;
+        }
+        return (k == n && n - 1 >= AD_TABLE_MIN) ? n : 0;
+    }
+    if (!strchr("-.=*_+/`", s[0])) {
+        return 0;
+    }
+    for (int k = 1; k < n; k++) {
+        if (s[k] != s[0]) {
+            return 0;
+        }
+    }
+    int min = s[0] == '`' ? AD_FENCE_MIN : AD_DELIM_MIN;
+    return n >= min ? n : 0;
+}
+
+/* ADOC_HEAD_RE ^(={1,6}|#{1,6})\s+(\S.*?)\s*$: the level and the title span. */
+static int ad_heading(const ad_line_t *l, int *ta, int *tb) {
+    const char *s = l->s;
+    int n = ad_rlen(l);
+    if (n == 0 || (s[0] != '=' && s[0] != '#')) {
+        return 0;
+    }
+    int k = 0;
+    while (k < n && s[k] == s[0]) {
+        k++;
+    }
+    if (k > AD_HEAD_MAX || k >= n || !ad_blank(s[k])) {
+        return 0;
+    }
+    int a = k;
+    while (a < n && ad_blank(s[a])) {
+        a++;
+    }
+    if (a >= n) {
+        return 0;
+    }
+    *ta = a;
+    *tb = n;
+    return k;
+}
+
+static bool ad_lines(ad_doc_t *d, const char *src, int len) {
+    int count = 1;
+    for (int i = 0; i < len; i++) {
+        count += src[i] == '\n';
+    }
+    d->L = (ad_line_t *)cbm_arena_alloc(d->scratch, (size_t)count * sizeof(*d->L));
+    d->in_block = (unsigned char *)cbm_arena_alloc(d->scratch, (size_t)count);
+    if (!d->L || !d->in_block) {
+        return false;
+    }
+    memset(d->in_block, 0, (size_t)count);
+    int pos = 0;
+    for (int i = 0; i < count; i++) {
+        const char *nl = memchr(src + pos, '\n', (size_t)(len - pos));
+        int end = nl ? (int)(nl - src) : len;
+        d->L[i] = (ad_line_t){src + pos, end - pos};
+        pos = end + 1;
+    }
+    d->n = count;
+    return true;
+}
+
+/* Delimited blocks, then the headings outside them. */
+static void ad_structure(ad_doc_t *d) {
+    int open = -1;
+    for (int i = 0; i < d->n; i++) {
+        int dl = ad_delim(&d->L[i]);
+        if (open < 0) {
+            if (dl) {
+                open = i;
+                d->in_block[i] = d->L[i].s[0] == '/' ? 2 : 1;
+            }
+            continue;
+        }
+        const ad_line_t *o = &d->L[open];
+        d->in_block[i] = d->L[open].s[0] == '/' ? 2 : 1;
+        if (dl && dl == ad_rlen(o) && memcmp(d->L[i].s, o->s, (size_t)dl) == 0) {
+            open = -1;
+        }
+    }
+    d->heads = (ad_head_t *)cbm_arena_alloc(d->scratch, (size_t)d->n * sizeof(*d->heads));
+    if (!d->heads) {
+        d->failed = true;
+        return;
+    }
+    for (int i = 0; i < d->n; i++) {
+        int ta;
+        int tb;
+        if (d->in_block[i] || ad_heading(&d->L[i], &ta, &tb) == 0) {
+            continue;
+        }
+        char *title = cbm_arena_strndup(d->ctx->arena, d->L[i].s + ta, (size_t)(tb - ta));
+        if (!title) {
+            d->failed = true;
+            return;
+        }
+        d->heads[d->nheads++] = (ad_head_t){.line = i, .title = title};
+    }
+}
+
+/* qn_safe_segment (extract_defs.c): whitespace runs become '-'. */
+static const char *ad_qn_segment(CBMArena *a, const char *name) {
+    char *out = cbm_arena_strdup(a, name);
+    if (!out) {
+        return NULL;
+    }
+    size_t w = 0;
+    bool in_ws = false;
+    for (const char *p = name; *p; p++) {
+        if (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') {
+            in_ws = true;
+            continue;
+        }
+        if (in_ws && w > 0) {
+            out[w++] = '-';
+        }
+        in_ws = false;
+        out[w++] = *p;
+    }
+    out[w] = '\0';
+    return out;
+}
+
+/* The section's own text, whitespace collapsed, at most AD_BODY_MAX bytes and
+ * never a cut UTF-8 character. */
+static const char *ad_body(ad_doc_t *d, int from, int to) {
+    char *out = (char *)cbm_arena_alloc(d->ctx->arena, AD_BODY_MAX + 1);
+    if (!out) {
+        return NULL;
+    }
+    int w = 0;
+    for (int k = from; k < to && w < AD_BODY_MAX; k++) {
+        const char *s = d->L[k].s;
+        int len = d->L[k].len;
+        for (int i = 0; i < len && w < AD_BODY_MAX; i++) {
+            char c = s[i];
+            if (ad_blank(c)) {
+                if (w > 0 && out[w - 1] != ' ') {
+                    out[w++] = ' ';
+                }
+                continue;
+            }
+            out[w++] = c;
+        }
+        if (w > 0 && w < AD_BODY_MAX && out[w - 1] != ' ') {
+            out[w++] = ' ';
+        }
+    }
+    while (w > 0 && ((unsigned char)out[w - 1] & 0xC0) == 0x80) {
+        w--; /* never end inside a character */
+    }
+    if (w > 0 && ((unsigned char)out[w - 1] & 0xC0) == 0xC0) {
+        w--;
+    }
+    while (w > 0 && out[w - 1] == ' ') {
+        w--;
+    }
+    out[w] = '\0';
+    return w > 0 ? out : NULL;
+}
+
+static int ad_head_qn_cmp(const void *a, const void *b) {
+    const ad_head_t *x = *(const ad_head_t *const *)a;
+    const ad_head_t *y = *(const ad_head_t *const *)b;
+    return strcmp(x->qn, y->qn);
+}
+
+static void ad_sections(ad_doc_t *d) {
+    CBMExtractCtx *ctx = d->ctx;
+    CBMArena *a = ctx->arena;
+    for (int h = 0; h < d->nheads; h++) {
+        const char *seg = ad_qn_segment(a, d->heads[h].title);
+        d->heads[h].qn = seg ? cbm_fqn_compute(a, ctx->project, ctx->rel_path, seg) : NULL;
+        if (!d->heads[h].qn) {
+            d->failed = true;
+            return;
+        }
+    }
+    if (d->nheads > 1) {
+        ad_head_t **by = (ad_head_t **)cbm_arena_alloc(d->scratch, (size_t)d->nheads * sizeof(*by));
+        if (!by) {
+            d->failed = true;
+            return;
+        }
+        for (int h = 0; h < d->nheads; h++) {
+            by[h] = &d->heads[h];
+        }
+        qsort(by, (size_t)d->nheads, sizeof(*by), ad_head_qn_cmp);
+        for (int h = 1; h < d->nheads; h++) {
+            if (strcmp(by[h]->qn, by[h - 1]->qn) == 0) {
+                by[h]->shared_qn = true;
+                by[h - 1]->shared_qn = true;
+            }
+        }
+    }
+    for (int h = 0; h < d->nheads; h++) {
+        const ad_head_t *hd = &d->heads[h];
+        int end = h + 1 < d->nheads ? d->heads[h + 1].line : d->n;
+        int last = end - 1;
+        while (last > hd->line && ad_rlen(&d->L[last]) == 0) {
+            last--;
+        }
+        CBMDefinition def;
+        memset(&def, 0, sizeof(def));
+        def.name = hd->title;
+        def.qualified_name = hd->qn;
+        def.label = "Section";
+        def.file_path = ctx->rel_path;
+        def.start_line = (uint32_t)hd->line + 1;
+        def.end_line = (uint32_t)last + 1;
+        def.is_exported = true;
+        def.docstring = ad_body(d, hd->line + 1, end);
+        cbm_defs_push(&ctx->result->defs, a, def);
+    }
+}
+
+/* ── Page attributes ─────────────────────────────────────────────── */
+
+static ad_attr_t *ad_attr_find(ad_doc_t *d, const char *name, size_t n) {
+    for (int i = 0; i < d->nattrs; i++) {
+        if (strlen(d->attrs[i].name) == n && memcmp(d->attrs[i].name, name, n) == 0) {
+            return &d->attrs[i];
+        }
+    }
+    return NULL;
+}
+
+/* ATTR_ENTRY_RE ^:(!?)([\w][\w\-]*)(!?):(?:\s+(.*?))?\s*$ -- true when the
+ * line is an attribute entry (set or unset). */
+static bool ad_attr_entry(ad_doc_t *d, const ad_line_t *l) {
+    const char *s = l->s;
+    int n = ad_rlen(l);
+    if (n < 3 || s[0] != ':') {
+        return false;
+    }
+    int k = 1;
+    bool unset = false;
+    if (s[k] == '!') {
+        unset = true;
+        k++;
+    }
+    int na = k;
+    if (k >= n || !ad_word(s[k])) {
+        return false;
+    }
+    while (k < n && (ad_word(s[k]) || s[k] == '-')) {
+        k++;
+    }
+    int nb = k;
+    if (k < n && s[k] == '!') {
+        unset = true;
+        k++;
+    }
+    if (k >= n || s[k] != ':') {
+        return false;
+    }
+    k++;
+    if (k < n && !ad_blank(s[k])) {
+        return false;
+    }
+    while (k < n && ad_blank(s[k])) {
+        k++;
+    }
+    ad_attr_t *a = ad_attr_find(d, s + na, (size_t)(nb - na));
+    if (unset) {
+        if (a) {
+            *a = d->attrs[--d->nattrs];
+        }
+        return true;
+    }
+    char *value = cbm_arena_strndup(d->scratch, s + k, (size_t)(n - k));
+    if (!value) {
+        d->failed = true;
+        return true;
+    }
+    if (a) {
+        a->value = value;
+        return true;
+    }
+    if (d->nattrs >= d->cap_attrs) {
+        int ncap = d->cap_attrs ? d->cap_attrs * 2 : AD_ATTRS_INIT;
+        ad_attr_t *grown = (ad_attr_t *)cbm_arena_alloc(d->scratch, (size_t)ncap * sizeof(*grown));
+        if (!grown) {
+            d->failed = true;
+            return true;
+        }
+        if (d->nattrs) {
+            memcpy(grown, d->attrs, (size_t)d->nattrs * sizeof(*grown));
+        }
+        d->attrs = grown;
+        d->cap_attrs = ncap;
+    }
+    char *name = cbm_arena_strndup(d->scratch, s + na, (size_t)(nb - na));
+    if (!name) {
+        d->failed = true;
+        return true;
+    }
+    d->attrs[d->nattrs++] = (ad_attr_t){name, value};
+    return true;
+}
+
+/* A `{name}` reference at s[i] (not escaped `\{`): the name's span. */
+static bool ad_attr_ref(const char *s, int n, int i, int *a, int *b) {
+    if (s[i] != '{' || (i > 0 && s[i - 1] == '\\') || i + 2 >= n || !ad_word(s[i + 1])) {
+        return false;
+    }
+    int k = i + 1;
+    while (k < n && (ad_word(s[k]) || s[k] == '-')) {
+        k++;
+    }
+    if (k >= n || s[k] != '}') {
+        return false;
+    }
+    *a = i + 1;
+    *b = k;
+    return true;
+}
+
+/* The text with the page's attribute references substituted, pass after pass
+ * (a value may reference others; at most AD_EXPAND_DEPTH passes, as H8's
+ * depth); references the page does not define stay as written. NULL when it
+ * grows past AD_FIELD_MAX or memory ran out. */
+static char *ad_expand(ad_doc_t *d, const char *s, int n) {
+    char cur[AD_FIELD_MAX + 1];
+    char out[AD_FIELD_MAX + 1];
+    if (n > AD_FIELD_MAX) {
+        return NULL;
+    }
+    memcpy(cur, s, (size_t)n);
+    int cl = n;
+    for (int pass = 0; pass < AD_EXPAND_DEPTH; pass++) {
+        int w = 0;
+        bool changed = false;
+        for (int i = 0; i < cl; i++) {
+            int a;
+            int b;
+            const ad_attr_t *at = NULL;
+            if (ad_attr_ref(cur, cl, i, &a, &b)) {
+                at = ad_attr_find(d, cur + a, (size_t)(b - a));
+            }
+            if (at) {
+                int vl = (int)strlen(at->value);
+                if (w + vl > AD_FIELD_MAX) {
+                    return NULL;
+                }
+                memcpy(out + w, at->value, (size_t)vl);
+                w += vl;
+                i = b;
+                changed = true;
+                continue;
+            }
+            if (w + 1 > AD_FIELD_MAX) {
+                return NULL;
+            }
+            out[w++] = cur[i];
+        }
+        if (w > 0) {
+            memcpy(cur, out, (size_t)w);
+        }
+        cl = w;
+        if (!changed) {
+            break;
+        }
+    }
+    return cbm_arena_strndup(d->scratch, cur, (size_t)cl);
+}
+
+/* ── Tokens ──────────────────────────────────────────────────────── */
+
+static void ad_push(ad_doc_t *d, int line, int syntax, const char *raw) {
+    if (!raw) {
+        d->failed = true;
+        return;
+    }
+    CBMExtractCtx *ctx = d->ctx;
+    int lo = 0;
+    int hi = d->nheads;
+    while (lo < hi) {
+        int mid = lo + ((hi - lo) / 2);
+        if (d->heads[mid].line <= line) {
+            lo = mid + 1;
+        } else {
+            hi = mid;
+        }
+    }
+    const ad_head_t *sec = lo > 0 ? &d->heads[lo - 1] : NULL;
+    if (sec && sec->shared_qn) {
+        sec = NULL;
+    }
+    CBMDocLink link = {
+        .source_qn = sec ? sec->qn : (ctx->module_qn ? ctx->module_qn : ""),
+        .raw = raw,
+        .line = (uint32_t)line + 1,
+        .def_line = sec ? (uint32_t)sec->line + 1 : 1,
+        .syntax = (uint16_t)syntax,
+        .flags = sec ? 0 : CBM_DOCLINK_FLAG_FILE,
+    };
+    cbm_doclinks_push(&ctx->result->doc_links, ctx->arena, link);
+}
+
+/* A value of the include's attribute list (`tag=x`, `tags="a;b"`, `lines=1..5`). */
+static void ad_attrlist_value(const char *al, int n, const char *key, char *out, size_t cap) {
+    out[0] = '\0';
+    size_t kl = strlen(key);
+    for (int i = 0; i + (int)kl < n; i++) {
+        if ((i > 0 && ad_word(al[i - 1])) || memcmp(al + i, key, kl) != 0) {
+            continue;
+        }
+        int k = i + (int)kl;
+        while (k < n && ad_blank(al[k])) {
+            k++;
+        }
+        if (k >= n || al[k] != '=') {
+            continue;
+        }
+        k++;
+        while (k < n && ad_blank(al[k])) {
+            k++;
+        }
+        int a = k;
+        int b;
+        if (k < n && al[k] == '"') {
+            a = k + 1;
+            const char *q = memchr(al + a, '"', (size_t)(n - a));
+            b = q ? (int)(q - al) : n;
+        } else {
+            b = a;
+            while (b < n && al[b] != ',') {
+                b++;
+            }
+        }
+        while (b > a && ad_blank(al[b - 1])) {
+            b--;
+        }
+        snprintf(out, cap, "%.*s", b - a, al + a);
+        return;
+    }
+}
+
+/* INCLUDE_RE ^(\\?)include::([^\[\s][^\[]*)\[(.*)\]\s*$ */
+static void ad_include(ad_doc_t *d, int i) {
+    const ad_line_t *l = &d->L[i];
+    const char *s = l->s;
+    int n = ad_rlen(l);
+    static const char kw[] = "include::";
+    int kl = (int)strlen(kw);
+    if (n < kl + 2 || memcmp(s, kw, (size_t)kl) != 0 || s[kl] == '[' || ad_blank(s[kl]) ||
+        s[n - 1] != ']') {
+        return;
+    }
+    const char *open = memchr(s + kl, '[', (size_t)(n - kl));
+    if (!open) {
+        return;
+    }
+    int ta = kl;
+    int tb = (int)(open - s);
+    int aa = tb + 1;
+    int ab = n - 1;
+    char *target = ad_expand(d, s + ta, tb - ta);
+    if (!target || strchr(target, '\t')) {
+        return;
+    }
+    char tags[AD_FIELD_MAX];
+    char tag1[AD_FIELD_MAX];
+    char lines[AD_FIELD_MAX];
+    ad_attrlist_value(s + aa, ab - aa, "tags", tags, sizeof(tags));
+    ad_attrlist_value(s + aa, ab - aa, "tag", tag1, sizeof(tag1));
+    ad_attrlist_value(s + aa, ab - aa, "lines", lines, sizeof(lines));
+    char *written = cbm_arena_strndup(d->ctx->arena, s, (size_t)n);
+    ad_push(d, i, CBM_DOCLINK_ADOC_INCLUDE,
+            written ? cbm_arena_sprintf(d->ctx->arena, "%s\t%s\t%s\t%s", written, target,
+                                        tags[0] ? tags : tag1, lines)
+                    : NULL);
+}
+
+/* Built-in attributes: characters and document settings, never a link. */
+static bool ad_builtin(const char *s, size_t n) {
+    static const char *const names[] = {"nbsp",       "sp",
+                                        "empty",      "blank",
+                                        "zwsp",       "wj",
+                                        "apos",       "quot",
+                                        "lsquo",      "rsquo",
+                                        "ldquo",      "rdquo",
+                                        "deg",        "plus",
+                                        "brvbar",     "vbar",
+                                        "amp",        "lt",
+                                        "gt",         "startsb",
+                                        "endsb",      "caret",
+                                        "asterisk",   "tilde",
+                                        "backslash",  "backtick",
+                                        "two-colons", "two-semicolons",
+                                        "cpp",        "cxx",
+                                        "pp",         "docname",
+                                        "docdir",     "docfile",
+                                        "doctitle",   "toc",
+                                        "version",    "revnumber",
+                                        "revdate",    "author",
+                                        "email",      "page-component-version",
+                                        NULL};
+    for (int i = 0; names[i]; i++) {
+        if (strlen(names[i]) == n && memcmp(names[i], s, n) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void ad_attr_refs(ad_doc_t *d, int i) {
+    const ad_line_t *l = &d->L[i];
+    const char *s = l->s;
+    int n = l->len;
+    for (int k = 0; k < n; k++) {
+        int a;
+        int b;
+        if (!ad_attr_ref(s, n, k, &a, &b) || ad_builtin(s + a, (size_t)(b - a))) {
+            continue;
+        }
+        const ad_attr_t *at = ad_attr_find(d, s + a, (size_t)(b - a));
+        char *value = at ? ad_expand(d, at->value, (int)strlen(at->value)) : NULL;
+        if (at && (!value || strchr(value, '\t') || strchr(at->value, '\t'))) {
+            k = b;
+            continue;
+        }
+        ad_push(d, i, CBM_DOCLINK_ADOC_ATTRIBUTE,
+                cbm_arena_sprintf(d->ctx->arena, "{%.*s}\t%.*s\t%s\t%s", b - a, s + a, b - a, s + a,
+                                  at ? at->value : "", value ? value : ""));
+        k = b;
+    }
+}
+
+/* Monospace spans of a prose line: `x` and ``x``, a `+x+` passthrough's inner
+ * text; each a code_path / code_name when the classifier names one. */
+static void ad_spans(ad_doc_t *d, int i) {
+    const ad_line_t *l = &d->L[i];
+    const char *s = l->s;
+    int n = l->len;
+    int k = 0;
+    while (k < n) {
+        if (s[k] != '`') {
+            k++;
+            continue;
+        }
+        int run = 1;
+        while (k + run < n && s[k + run] == '`') {
+            run++;
+        }
+        if (run > 2) {
+            k += run;
+            continue;
+        }
+        int a = k + run;
+        int e = a;
+        while (e + run <= n && !(memcmp(s + e, run == 2 ? "``" : "`", (size_t)run) == 0)) {
+            e++;
+        }
+        if (e + run > n || e == a) {
+            k = a;
+            continue;
+        }
+        int b = e;
+        if (b - a >= 2 && s[a] == '+' && s[b - 1] == '+') {
+            a++;
+            b--;
+        }
+        CBMDocLinkMdPath p;
+        if (b > a && b - a <= AD_SPAN_MAX &&
+            cbm_doclink_md_classify_span(s + a, (size_t)(b - a), d->span_buf, AD_SPAN_MAX + 1,
+                                         &p)) {
+            ad_push(d, i,
+                    p.shape == CBM_DOCLINK_MD_QUALIFIED ? CBM_DOCLINK_ADOC_CODE_NAME
+                                                        : CBM_DOCLINK_ADOC_CODE_PATH,
+                    cbm_arena_strndup(d->ctx->arena, s + a, (size_t)(b - a)));
+        }
+        k = e + run;
+    }
+}
+
+static void ad_tokens(ad_doc_t *d) {
+    for (int i = 0; i < d->n && !d->failed; i++) {
+        if (d->in_block[i] == 2) {
+            continue; /* a comment block: nothing in it is read */
+        }
+        const ad_line_t *l = &d->L[i];
+        if (l->len >= 2 && l->s[0] == '/' && l->s[1] == '/' && !d->in_block[i]) {
+            continue; /* a line comment */
+        }
+        if (!d->in_block[i] && ad_attr_entry(d, l)) {
+            continue;
+        }
+        if (l->len > 0 && l->s[0] == 'i') {
+            ad_include(d, i);
+        }
+        ad_attr_refs(d, i);
+        if (!d->in_block[i]) {
+            ad_spans(d, i);
+        }
+    }
+}
+
+void cbm_adoc_extract_document(CBMExtractCtx *ctx) {
+    if (!ctx || !ctx->result || !ctx->source || ctx->source_len <= 0) {
+        return;
+    }
+    ad_doc_t d = {.ctx = ctx, .scratch = ctx->scratch ? ctx->scratch : ctx->arena};
+    d.span_buf = (char *)cbm_arena_alloc(d.scratch, (size_t)(AD_SPAN_MAX + 1) * 2);
+    if (!d.span_buf || !ad_lines(&d, ctx->source, ctx->source_len)) {
+        ctx->result->doc_links.failed = true;
+        return;
+    }
+    ad_structure(&d);
+    if (!d.failed) {
+        ad_sections(&d);
+    }
+    if (!d.failed) {
+        ad_tokens(&d);
+    }
+    if (d.failed) {
+        ctx->result->doc_links.failed = true;
+    }
+}
+
+/* ── The Antora scope (antora.yml, antora-playbook*.yml) ─────────── */
+
+typedef struct {
+    CBMArena *a;
+    char *buf;
+    size_t len;
+    size_t cap;
+    bool failed;
+} ad_sb_t;
+
+static void ad_put(ad_sb_t *sb, const char *s, size_t n) {
+    if (sb->failed) {
+        return;
+    }
+    if (sb->len + n + 1 > sb->cap) {
+        size_t ncap = sb->cap ? sb->cap : AD_FIELD_MAX;
+        while (ncap < sb->len + n + 1) {
+            ncap *= 2;
+        }
+        char *grown = (char *)cbm_arena_alloc(sb->a, ncap);
+        if (!grown) {
+            sb->failed = true;
+            return;
+        }
+        if (sb->len) {
+            memcpy(grown, sb->buf, sb->len);
+        }
+        sb->buf = grown;
+        sb->cap = ncap;
+    }
+    memcpy(sb->buf + sb->len, s, n);
+    sb->len += n;
+    sb->buf[sb->len] = '\0';
+}
+
+static void ad_rec(ad_sb_t *sb, const char *kind, const char *a, size_t an, const char *b,
+                   size_t bn) {
+    for (size_t i = 0; i < an; i++) {
+        if (a[i] == '\t' || a[i] == '\n') {
+            return;
+        }
+    }
+    for (size_t i = 0; b && i < bn; i++) {
+        if (b[i] == '\t' || b[i] == '\n') {
+            return;
+        }
+    }
+    ad_put(sb, kind, strlen(kind));
+    ad_put(sb, "\t", 1);
+    ad_put(sb, a, an);
+    if (b) {
+        ad_put(sb, "\t", 1);
+        ad_put(sb, b, bn);
+    }
+    ad_put(sb, "\n", 1);
+}
+
+static int ad_indent(const char *s, int n) {
+    int k = 0;
+    while (k < n && s[k] == ' ') {
+        k++;
+    }
+    return k;
+}
+
+/* `key: value` at s (after the indent): the key and value spans (value
+ * unquoted, comments not stripped: the field test's reading). */
+static bool ad_yaml_kv(const char *s, int n, int *ka, int *kb, int *va, int *vb) {
+    int k = 0;
+    if (k >= n || !(ad_word(s[k]))) {
+        return false;
+    }
+    while (k < n && (ad_word(s[k]) || s[k] == '-')) {
+        k++;
+    }
+    int e = k;
+    while (k < n && ad_blank(s[k])) {
+        k++;
+    }
+    if (k >= n || s[k] != ':') {
+        return false;
+    }
+    k++;
+    while (k < n && ad_blank(s[k])) {
+        k++;
+    }
+    *ka = 0;
+    *kb = e;
+    *va = k;
+    *vb = n; /* the caller's line has no trailing whitespace */
+    return true;
+}
+
+/* A value in matching quotes loses them. */
+static void ad_unquote(const char *s, int *va, int *vb) {
+    if (*vb - *va >= 2 && s[*va] == s[*vb - 1] && (s[*va] == '\'' || s[*va] == '"')) {
+        (*va)++;
+        (*vb)--;
+    }
+}
+
+/* H8 parse_antora_yml: `name:`, `asciidoc: attributes:` and
+ * `ext: collector: scan: - dir: / into:`. */
+static void ad_antora(const char *src, int len, bool component, ad_sb_t *sb) {
+    bool in_asciidoc = false;
+    bool in_attrs = false;
+    int attrs_ind = -1;
+    bool in_scan = false;
+    int pos = 0;
+    while (pos <= len) {
+        const char *nl = memchr(src + pos, '\n', (size_t)(len - pos));
+        int end = nl ? (int)(nl - src) : len;
+        const char *s = src + pos;
+        int n = end - pos;
+        while (n > 0 && ad_blank(s[n - 1])) {
+            n--;
+        }
+        int ind = ad_indent(s, n);
+        int ka;
+        int kb;
+        int va;
+        int vb;
+        bool kv = ad_yaml_kv(s + ind, n - ind, &ka, &kb, &va, &vb);
+        if (kv) {
+            ad_unquote(s + ind, &va, &vb);
+        }
+        if (ind == 0 && n > 0) {
+            in_asciidoc = kv && kb == (int)strlen("asciidoc") && memcmp(s, "asciidoc", 8) == 0;
+            in_attrs = false;
+            in_scan = false;
+            if (component && kv && kb == (int)strlen("name") && memcmp(s, "name", 4) == 0 &&
+                vb > va) {
+                ad_rec(sb, "N", s + va, (size_t)(vb - va), NULL, 0);
+            }
+        } else if (in_asciidoc && kv && va == vb && kb == (int)strlen("attributes") &&
+                   memcmp(s + ind, "attributes", 10) == 0) {
+            in_attrs = true;
+            attrs_ind = -1;
+        } else if (in_attrs && n > ind && s[ind] != '#') {
+            if (attrs_ind < 0) {
+                attrs_ind = ind;
+            }
+            if (ind < attrs_ind) {
+                in_attrs = false;
+            } else if (ind == attrs_ind && kv) {
+                ad_rec(sb, "A", s + ind, (size_t)kb, s + ind + va, (size_t)(vb - va));
+            }
+        }
+        if (component && kv && kb == (int)strlen("scan") && memcmp(s + ind, "scan", 4) == 0) {
+            in_scan = true;
+        } else if (component && in_scan) {
+            const char *t = s + ind;
+            int tn = n - ind;
+            if (tn > 1 && t[0] == '-' && ad_blank(t[1])) {
+                int sk = 1;
+                while (sk < tn && ad_blank(t[sk])) {
+                    sk++;
+                }
+                t += sk;
+                tn -= sk;
+            }
+            int a;
+            int b;
+            int c;
+            int e;
+            bool tkv = ad_yaml_kv(t, tn, &a, &b, &c, &e);
+            if (tkv) {
+                ad_unquote(t, &c, &e);
+            }
+            if (tkv && e > c) {
+                if (b == 3 && memcmp(t, "dir", 3) == 0) {
+                    ad_rec(sb, "D", t + c, (size_t)(e - c), NULL, 0);
+                } else if (b == 4 && memcmp(t, "into", 4) == 0) {
+                    ad_rec(sb, "I", t + c, (size_t)(e - c), NULL, 0);
+                }
+            }
+        }
+        pos = end + 1;
+    }
+}
+
+const char *cbm_doclink_antora_scan_scope(CBMExtractCtx *ctx) {
+    if (!ctx || !ctx->rel_path || !ctx->source || ctx->source_len <= 0) {
+        return NULL;
+    }
+    const char *base = strrchr(ctx->rel_path, '/');
+    base = base ? base + 1 : ctx->rel_path;
+    bool component = strcmp(base, "antora.yml") == 0;
+    bool playbook = strncmp(base, "antora-playbook", strlen("antora-playbook")) == 0;
+    if (!component && !playbook) {
+        return NULL;
+    }
+    ad_sb_t sb = {.a = ctx->arena};
+    ad_put(&sb, CBM_DOCLINK_ADOC_SCOPE_TAG "\n", strlen(CBM_DOCLINK_ADOC_SCOPE_TAG "\n"));
+    ad_put(&sb, component ? "C\n" : "P\n", 2);
+    ad_antora(ctx->source, ctx->source_len, component, &sb);
+    if (sb.failed) {
+        ctx->result->doc_links.failed = true;
+        return NULL;
+    }
+    return sb.buf;
+}
diff --git a/internal/cbm/doclink.c b/internal/cbm/doclink.c
index 1a3d06b3c..09ee36c25 100644
--- a/internal/cbm/doclink.c
+++ b/internal/cbm/doclink.c
@@ -175,6 +175,11 @@ static const doclink_lang_t DOCLINK_LANGS[] = {
     {.lang = CBM_LANG_PYTHON,
      .scan_scope = cbm_doclink_py_scan_scope,
      .scope_tag = CBM_DOCLINK_PY_SCOPE_TAG},
+    /* YAML: the Antora component and playbook settings the AsciiDoc resolver
+     * reads */
+    {.lang = CBM_LANG_YAML,
+     .scan_scope = cbm_doclink_antora_scan_scope,
+     .scope_tag = CBM_DOCLINK_ADOC_SCOPE_TAG},
 };
 
 static const doclink_lang_t *doclink_lang(CBMLanguage lang) {
diff --git a/internal/cbm/doclink.h b/internal/cbm/doclink.h
index 741b95aaa..e97aaf488 100644
--- a/internal/cbm/doclink.h
+++ b/internal/cbm/doclink.h
@@ -92,6 +92,11 @@
     X(CBM_DOCLINK_RST_KERNEL_DOC, CBM_LANG_RST, "kernel_doc", false, true, "MENTIONS")         \
     X(CBM_DOCLINK_RST_CODE_PATH, CBM_LANG_RST, "code_path", false, true, "MENTIONS")           \
     X(CBM_DOCLINK_RST_CODE_NAME, CBM_LANG_RST, "code_name", false, true, "MENTIONS")           \
+    /* asciidoc (doc_adoc.c): includes, Antora API attributes, monospace spans */              \
+    X(CBM_DOCLINK_ADOC_INCLUDE, CBM_LANG_ASCIIDOC, "include", false, true, "MENTIONS")         \
+    X(CBM_DOCLINK_ADOC_ATTRIBUTE, CBM_LANG_ASCIIDOC, "attribute", false, true, "MENTIONS")     \
+    X(CBM_DOCLINK_ADOC_CODE_PATH, CBM_LANG_ASCIIDOC, "code_path", false, true, "MENTIONS")     \
+    X(CBM_DOCLINK_ADOC_CODE_NAME, CBM_LANG_ASCIIDOC, "code_name", false, true, "MENTIONS")     \
     /* any language (CBM_LANG_COUNT): a URL is never an edge */                                \
     X(CBM_DOCLINK_HREF, CBM_LANG_COUNT, "href", true, false, "MENTIONS")
 
@@ -333,6 +338,22 @@ const char *cbm_doclink_py_scan_scope(CBMExtractCtx *ctx);
 /* The Python scope blob starts with this tag line. */
 #define CBM_DOCLINK_PY_SCOPE_TAG "py1"
 
+/* ── AsciiDoc (doc_adoc.c) ─────────────────────────────────────────── */
+
+/* AsciiDoc documents: a Section per heading and the references to code
+ * (include::, Antora API attributes, monospace spans) as doc-link tokens.
+ * Runs instead of a grammar for CBM_LANG_ASCIIDOC. */
+void cbm_adoc_extract_document(CBMExtractCtx *ctx);
+
+/* The scope blob of a YAML file, which the AsciiDoc resolver reads: an
+ * antora.yml's component name, asciidoc attributes and collector scans, an
+ * antora-playbook*.yml's attributes (read as text). NULL for every other
+ * file. */
+const char *cbm_doclink_antora_scan_scope(CBMExtractCtx *ctx);
+
+/* The Antora scope blob starts with this tag line. */
+#define CBM_DOCLINK_ADOC_SCOPE_TAG "ad1"
+
 /* PDF documents (doc_pdf.c): a Section per page (name "page N", the page's
  * text as docstring, property page) and the pages' structural code mentions
  * as doc-link tokens. Runs instead of a grammar for CBM_LANG_PDF. */
diff --git a/internal/cbm/lang_specs.c b/internal/cbm/lang_specs.c
index a37c3e52c..6672011d0 100644
--- a/internal/cbm/lang_specs.c
+++ b/internal/cbm/lang_specs.c
@@ -2718,6 +2718,9 @@ static const CBMLangSpec lang_specs[CBM_LANG_COUNT] = {
     // looked up, so this language never reaches cbm_lang_spec()/cbm_ts_language().
     // Left as a zero spec.
 
+    // CBM_LANG_ASCIIDOC — AsciiDoc documents. No grammar row, as PDF: extraction
+    // reads the file itself (cbm_adoc_extract_document, doc_adoc.c). Zero spec.
+
     // CBM_LANG_OBJECTSCRIPT_EXPORT — Studio Export XML. No grammar row: the
     // pipeline transcodes Export XML to UDL (iris_export_xml.c) and re-extracts
     // each class as CBM_LANG_OBJECTSCRIPT_UDL, so this language never reaches
diff --git a/src/discover/language.c b/src/discover/language.c
index c15a1d43d..b1cd7d938 100644
--- a/src/discover/language.c
+++ b/src/discover/language.c
@@ -619,6 +619,9 @@ static const ext_entry_t EXT_TABLE[] = {
     {".clib", CBM_LANG_CHIALISP},
     {".clinc", CBM_LANG_CHIALISP},
     {".pdf", CBM_LANG_PDF},
+    /* AsciiDoc; `.asc` is left out: it is as often an ASCII-armored signature */
+    {".adoc", CBM_LANG_ASCIIDOC},
+    {".asciidoc", CBM_LANG_ASCIIDOC},
 
     /* Slang */
     {".slang", CBM_LANG_SLANG},
@@ -831,6 +834,7 @@ static const char *LANG_NAMES[CBM_LANG_COUNT] = {
     [CBM_LANG_SCHEME] = "Scheme",
     [CBM_LANG_CHIALISP] = "Chialisp",
     [CBM_LANG_PDF] = "PDF",
+    [CBM_LANG_ASCIIDOC] = "AsciiDoc",
     [CBM_LANG_FENNEL] = "Fennel",
     [CBM_LANG_FISH] = "Fish",
     [CBM_LANG_AWK] = "AWK",
diff --git a/src/discover/userconfig.c b/src/discover/userconfig.c
index 7b1f3d2b5..a0d306008 100644
--- a/src/discover/userconfig.c
+++ b/src/discover/userconfig.c
@@ -161,6 +161,7 @@ static const lang_name_entry_t LANG_NAME_TABLE[] = {
     {"plsql", CBM_LANG_PLSQL},
     {"chialisp", CBM_LANG_CHIALISP},
     {"pdf", CBM_LANG_PDF},
+    {"asciidoc", CBM_LANG_ASCIIDOC},
     {"lean", CBM_LANG_LEAN},
     {"form", CBM_LANG_FORM},
     {"magma", CBM_LANG_MAGMA},
diff --git a/src/pipeline/doc_links.c b/src/pipeline/doc_links.c
index 71159220d..c5023658d 100644
--- a/src/pipeline/doc_links.c
+++ b/src/pipeline/doc_links.c
@@ -45,10 +45,8 @@ const char *cbm_doclink_reason_name(int reason) {
 /* One pointer per language with a resolver: the one line a language leg adds
  * to this file. */
 static const cbm_doclink_resolver_t *const DOCLINK_RESOLVERS[] = {
-    &cbm_doclink_cs_resolver,
-    &cbm_doclink_md_resolver,
-    &cbm_doclink_pdf_resolver,
-    &cbm_doclink_rst_resolver,
+    &cbm_doclink_cs_resolver,  &cbm_doclink_md_resolver,   &cbm_doclink_pdf_resolver,
+    &cbm_doclink_rst_resolver, &cbm_doclink_adoc_resolver,
 };
 
 enum { DOCLINK_RESOLVER_COUNT = sizeof(DOCLINK_RESOLVERS) / sizeof(DOCLINK_RESOLVERS[0]) };
@@ -93,7 +91,7 @@ static const cbm_doclink_resolver_t *resolver_of_scope(const char *scope) {
 /* ── Incremental scope rules ─────────────────────────────────────── */
 
 bool cbm_doclinks_binds_lines(CBMLanguage lang) {
-    return lang == CBM_LANG_MARKDOWN || lang == CBM_LANG_RST;
+    return lang == CBM_LANG_MARKDOWN || lang == CBM_LANG_RST || lang == CBM_LANG_ASCIIDOC;
 }
 
 bool cbm_doclinks_is_scope_input(const char *rel_path) {
diff --git a/src/pipeline/doc_links.h b/src/pipeline/doc_links.h
index ec1416f27..77a5dfb67 100644
--- a/src/pipeline/doc_links.h
+++ b/src/pipeline/doc_links.h
@@ -245,6 +245,9 @@ extern const cbm_doclink_resolver_t cbm_doclink_pdf_resolver;
 /* reStructuredText documents and the Python scope they read (doc_links_rst.c):
  * via "rst". */
 extern const cbm_doclink_resolver_t cbm_doclink_rst_resolver;
+/* AsciiDoc documents and the Antora YAML scope they read (doc_links_adoc.c):
+ * via "asciidoc". */
+extern const cbm_doclink_resolver_t cbm_doclink_adoc_resolver;
 
 /* Over a Markdown resolver index (cbm_doclink_md_resolver.build), for the
  * other document resolvers: the innermost code definition of `path` holding
@@ -253,6 +256,15 @@ extern const cbm_doclink_resolver_t cbm_doclink_rst_resolver;
 const cbm_gbuf_node_t *cbm_doclink_md_segment(const void *md_index, const char *path,
                                               uint32_t first, uint32_t last, const char *member);
 const cbm_gbuf_node_t *cbm_doclink_md_folder(const void *md_index, const char *path);
+/* The definition a region [first, last] of `path` (its text in `text`) binds,
+ * by the field test's rule (H8 bind_range): edge blank and comment lines
+ * trimmed; the innermost enclosing definition, unless it is a type (or there
+ * is none) and the definitions inside cover every other line of the region
+ * (an annotation right above one counts) -- then that one definition (the
+ * type for several). NULL: the file. */
+const cbm_gbuf_node_t *cbm_doclink_md_region(const void *md_index, const char *path,
+                                             const char *text, size_t text_len, uint32_t first,
+                                             uint32_t last);
 bool cbm_doclink_md_test_path(const char *path);
 
 #if defined(CBM_ENABLE_TEST_SEAMS) && CBM_ENABLE_TEST_SEAMS
@@ -278,7 +290,8 @@ void cbm_doclink_cs_test_unit_memo(bool on);
 #endif
 
 /* True for a document language whose references may bind the LINES of a file
- * (Markdown `file#L3-L9`, reST :lines:): a body edit of that file keeps its
+ * (Markdown `file#L3-L9`, reST :lines:, AsciiDoc tags and lines=): a body
+ * edit of that file keeps its
  * names but can move what those lines hold, so an incremental run
  * re-resolves such documents with the edited file. */
 bool cbm_doclinks_binds_lines(CBMLanguage lang);
diff --git a/src/pipeline/doc_links_adoc.c b/src/pipeline/doc_links_adoc.c
new file mode 100644
index 000000000..863462e41
--- /dev/null
+++ b/src/pipeline/doc_links_adoc.c
@@ -0,0 +1,919 @@
+/*
+ * doc_links_adoc.c — AsciiDoc references -> MENTIONS edges, via "asciidoc"
+ * (the resolving half of internal/cbm/doc_adoc.c), with the Antora rules the
+ * field test's harvester measured (H8: includes 97.6-100 % resolved, ~100 %
+ * precise; javadoc attributes 320/320).
+ *
+ * Antora: a component is the directory of an antora.yml; its pages live under
+ * <component>/modules/<module>/pages. Its attributes and collector scans, and
+ * a playbook's attributes, come from the YAML scope blobs (doc_adoc.c), so an
+ * incremental run resolves as a full one.
+ *
+ * include::target[...]: references the page left are expanded from the
+ * component's attributes, then the playbook's. A resource ID
+ * ([[version@]component:]module:]family$path) names
+ * <component>/modules/<module>/<family dir>/<path>, or a file a collector scan
+ * contributes there; any other target is relative to the including file. Its
+ * `lines=` bind the innermost definition holding them; its `tag=` / `tags=`
+ * regions -- the included file's own `tag::x[]` .. `end::x[]` comments, read
+ * from that indexed file -- likewise; a tag the file does not have binds the
+ * file (the document stays a dependent of that file, so it re-resolves when
+ * the file changes, on an incremental run as on a full one).
+ *
+ * {attribute} references whose value is an Antora javadoc link
+ * ({javadoc-root}/<module>/<package path>/<Type>.html[#member]) bind the
+ * Java or Kotlin type (or its member) that the repository's main sources
+ * declare under that package path.
+ *
+ * Monospace spans: the Markdown resolver's code-span rules (doc_links_md.c).
+ */
+#include "pipeline/doc_links.h"
+
+#include "discover/discover.h" /* cbm_language_for_filename */
+#include "doclink.h"
+#include "foundation/arena.h"
+#include "foundation/compat_fs.h"
+#include "foundation/constants.h"
+#include "foundation/mem_core.h"
+#include "graph_buffer/graph_buffer.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+    RA_PATH_CAP = 1024,
+    RA_FIELDS = 6,
+    RA_EXPAND_PASSES = 10,             /* nested attribute references (H8's depth) */
+    RA_TAG_FILE_MAX = 8 * 1024 * 1024, /* an included file read for its tags */
+    RA_TAGS = 16,                      /* tags of one include */
+    RA_TAG_LEN = 128,                  /* a tag name */
+    RA_INIT = 8,
+};
+
+typedef struct {
+    const char *key;
+    const char *value;
+} ra_attr_t;
+
+typedef struct {
+    const char *dir;
+    const char *into;
+} ra_scan_t;
+
+typedef struct {
+    const char *root; /* the antora.yml's directory ("" for the repository root) */
+    const char *name;
+    ra_attr_t *attrs;
+    int nattrs;
+    ra_scan_t *scans;
+    int nscans;
+} ra_comp_t;
+
+typedef struct {
+    const char *project;
+    const char *repo; /* the repository on disk: included files are read for their tags */
+    void *md;
+    const char **run_paths;
+    int run_count;
+    CBMArena arena;
+    ra_comp_t *comps;
+    int ncomps;
+    ra_attr_t *pattrs; /* playbook attributes, the first definition of a key wins */
+    int npattrs;
+} ra_index_t;
+
+static void ra_destroy(void *index);
+
+static const char *ra_base(const char *path) {
+    const char *s = strrchr(path, '/');
+    return s ? s + SKIP_ONE : path;
+}
+
+static bool ra_ends(const char *s, const char *suffix) {
+    size_t n = strlen(s);
+    size_t k = strlen(suffix);
+    return n >= k && strcmp(s + n - k, suffix) == 0;
+}
+
+static bool ra_grow(CBMArena *a, void **items, int count, int *cap, size_t size) {
+    if (count < *cap) {
+        return true;
+    }
+    int ncap = *cap ? *cap * PAIR_LEN : RA_INIT;
+    void *grown = cbm_arena_alloc(a, (size_t)ncap * size);
+    if (!grown) {
+        return false;
+    }
+    if (count > 0) {
+        memcpy(grown, *items, (size_t)count * size);
+    }
+    *items = grown;
+    *cap = ncap;
+    return true;
+}
+
+/* One YAML scope blob: a component (C) or a playbook (P). */
+static bool ra_read_scope(ra_index_t *x, const char *path, const char *scope, int *comp_cap,
+                          int *pattr_cap) {
+    char *copy = cbm_arena_strdup(&x->arena, scope);
+    if (!copy) {
+        return false;
+    }
+    char *save = NULL;
+    (void)strtok_r(copy, "\n", &save); /* the tag line */
+    char *line = strtok_r(NULL, "\n", &save);
+    if (!line || (strcmp(line, "C") != 0 && strcmp(line, "P") != 0)) {
+        return true;
+    }
+    bool component = line[0] == 'C';
+    ra_comp_t comp = {0};
+    int acap = 0;
+    int scap = 0;
+    if (component) {
+        const char *b = ra_base(path);
+        comp.root =
+            cbm_arena_strndup(&x->arena, path, b > path ? (size_t)(b - path - SKIP_ONE) : 0);
+        comp.name = "";
+        if (!comp.root) {
+            return false;
+        }
+    }
+    for (line = strtok_r(NULL, "\n", &save); line; line = strtok_r(NULL, "\n", &save)) {
+        char *tab = strchr(line, '\t');
+        if (!tab) {
+            continue;
+        }
+        *tab = '\0';
+        char *v = tab + SKIP_ONE;
+        if (strcmp(line, "N") == 0 && component) {
+            comp.name = v;
+        } else if (strcmp(line, "A") == 0) {
+            char *t2 = strchr(v, '\t');
+            if (!t2) {
+                continue;
+            }
+            *t2 = '\0';
+            ra_attr_t at = {v, t2 + SKIP_ONE};
+            if (component) {
+                if (!ra_grow(&x->arena, (void **)&comp.attrs, comp.nattrs, &acap, sizeof(at))) {
+                    return false;
+                }
+                comp.attrs[comp.nattrs++] = at;
+            } else {
+                bool seen = false;
+                for (int i = 0; i < x->npattrs; i++) {
+                    seen = seen || strcmp(x->pattrs[i].key, at.key) == 0;
+                }
+                if (!seen) {
+                    if (!ra_grow(&x->arena, (void **)&x->pattrs, x->npattrs, pattr_cap,
+                                 sizeof(at))) {
+                        return false;
+                    }
+                    x->pattrs[x->npattrs++] = at;
+                }
+            }
+        } else if (strcmp(line, "D") == 0 && component) {
+            if (!ra_grow(&x->arena, (void **)&comp.scans, comp.nscans, &scap, sizeof(ra_scan_t))) {
+                return false;
+            }
+            comp.scans[comp.nscans++] = (ra_scan_t){v, ""};
+        } else if (strcmp(line, "I") == 0 && component && comp.nscans > 0) {
+            comp.scans[comp.nscans - 1].into = v;
+        }
+    }
+    if (component) {
+        if (!ra_grow(&x->arena, (void **)&x->comps, x->ncomps, comp_cap, sizeof(comp))) {
+            return false;
+        }
+        x->comps[x->ncomps++] = comp;
+    }
+    return true;
+}
+
+static void *ra_build(const cbm_doclink_build_in_t *in) {
+    ra_index_t *x = (ra_index_t *)cbm_calloc(CBM_MEM_CLASS_OTHER, sizeof(*x));
+    if (!x) {
+        return NULL;
+    }
+    cbm_arena_init(&x->arena);
+    x->project = in->ctx ? in->ctx->project_name : NULL;
+    x->repo = in->ctx ? in->ctx->repo_path : NULL;
+    x->run_count = in->run_file_count;
+    x->run_paths = in->run_file_count > 0
+                       ? (const char **)cbm_calloc(CBM_MEM_CLASS_OTHER,
+                                                   (size_t)in->run_file_count * sizeof(char *))
+                       : NULL;
+    x->md = cbm_doclink_md_resolver.build(in);
+    if ((in->run_file_count > 0 && !x->run_paths) || !x->md || !x->project) {
+        ra_destroy(x);
+        return NULL;
+    }
+    int comp_cap = 0;
+    int pattr_cap = 0;
+    for (int i = 0; i < in->file_count; i++) {
+        const cbm_doclink_file_t *f = &in->files[i];
+        if (f->run_file >= 0 && f->run_file < x->run_count) {
+            x->run_paths[f->run_file] = f->rel_path; /* valid until destroy */
+        }
+        if (f->scope &&
+            strncmp(f->scope, CBM_DOCLINK_ADOC_SCOPE_TAG "\n",
+                    strlen(CBM_DOCLINK_ADOC_SCOPE_TAG "\n")) == 0 &&
+            !ra_read_scope(x, f->rel_path, f->scope, &comp_cap, &pattr_cap)) {
+            ra_destroy(x);
+            return NULL;
+        }
+    }
+    return x;
+}
+
+static void ra_destroy(void *index) {
+    ra_index_t *x = (ra_index_t *)index;
+    if (!x) {
+        return;
+    }
+    if (x->md) {
+        cbm_doclink_md_resolver.destroy(x->md);
+    }
+    cbm_arena_destroy(&x->arena);
+    cbm_free(CBM_MEM_CLASS_OTHER, x->run_paths);
+    cbm_free(CBM_MEM_CLASS_OTHER, x);
+}
+
+/* H8 component_of: the deepest component whose modules/ hold the document. */
+static const ra_comp_t *ra_component_of(const ra_index_t *x, const char *doc) {
+    const ra_comp_t *best = NULL;
+    for (int i = 0; i < x->ncomps; i++) {
+        const ra_comp_t *c = &x->comps[i];
+        char pref[RA_PATH_CAP];
+        snprintf(pref, sizeof(pref), "%s%smodules/", c->root, c->root[0] ? "/" : "");
+        if (strncmp(doc, pref, strlen(pref)) == 0 &&
+            (!best || strlen(c->root) > strlen(best->root))) {
+            best = c;
+        }
+    }
+    return best;
+}
+
+static const char *ra_attr(const ra_index_t *x, const ra_comp_t *c, const char *key, size_t n) {
+    for (int i = 0; c && i < c->nattrs; i++) {
+        if (strlen(c->attrs[i].key) == n && memcmp(c->attrs[i].key, key, n) == 0) {
+            return c->attrs[i].value;
+        }
+    }
+    for (int i = 0; i < x->npattrs; i++) {
+        if (strlen(x->pattrs[i].key) == n && memcmp(x->pattrs[i].key, key, n) == 0) {
+            return x->pattrs[i].value;
+        }
+    }
+    return NULL;
+}
+
+static bool ra_word(char c) {
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+}
+
+/* The text with the component's and the playbook's attribute references
+ * substituted, pass after pass. False when one stays undefined or it does
+ * not fit. */
+static bool ra_expand(const ra_index_t *x, const ra_comp_t *c, const char *s, char *out,
+                      size_t cap) {
+    char cur[RA_PATH_CAP];
+    char nxt[RA_PATH_CAP];
+    if (snprintf(cur, sizeof(cur), "%s", s) >= (int)sizeof(cur)) {
+        return false;
+    }
+    bool undefined = false;
+    for (int pass = 0; pass < RA_EXPAND_PASSES; pass++) {
+        size_t w = 0;
+        bool changed = false;
+        undefined = false;
+        for (size_t i = 0; cur[i]; i++) {
+            const char *v = NULL;
+            size_t e = i + SKIP_ONE;
+            if (cur[i] == '{' && (i == 0 || cur[i - SKIP_ONE] != '\\') && ra_word(cur[e])) {
+                while (cur[e] && (ra_word(cur[e]) || cur[e] == '-')) {
+                    e++;
+                }
+                if (cur[e] == '}') {
+                    v = ra_attr(x, c, cur + i + SKIP_ONE, e - i - SKIP_ONE);
+                    undefined = undefined || !v;
+                }
+            }
+            if (v) {
+                size_t vl = strlen(v);
+                if (w + vl >= sizeof(nxt)) {
+                    return false;
+                }
+                memcpy(nxt + w, v, vl);
+                w += vl;
+                i = e;
+                changed = true;
+                continue;
+            }
+            if (w + SKIP_ONE >= sizeof(nxt)) {
+                return false;
+            }
+            nxt[w++] = cur[i];
+        }
+        nxt[w] = '\0';
+        memcpy(cur, nxt, w + SKIP_ONE);
+        if (!changed) {
+            break;
+        }
+    }
+    if (undefined || snprintf(out, cap, "%s", cur) >= (int)cap) {
+        return false;
+    }
+    return true;
+}
+
+/* os.path.normpath(base/p); false when it leaves the repository. */
+static bool ra_norm(const char *base, const char *p, char *out, size_t cap) {
+    char tmp[RA_PATH_CAP * PAIR_LEN];
+    snprintf(tmp, sizeof(tmp), "%s%s%s", base, base[0] && p[0] ? "/" : "", p);
+    size_t w = 0;
+    out[0] = '\0';
+    for (char *s = tmp; *s;) {
+        char *e = strchr(s, '/');
+        size_t l = e ? (size_t)(e - s) : strlen(s);
+        if (l == PAIR_LEN && s[0] == '.' && s[1] == '.') {
+            if (w == 0) {
+                return false;
+            }
+            while (w > 0 && out[w - SKIP_ONE] != '/') {
+                w--;
+            }
+            if (w > 0) {
+                w--;
+            }
+            out[w] = '\0';
+        } else if (l > 0 && !(l == SKIP_ONE && s[0] == '.')) {
+            if (w + l + PAIR_LEN > cap) {
+                return false;
+            }
+            if (w > 0) {
+                out[w++] = '/';
+            }
+            memcpy(out + w, s, l);
+            w += l;
+            out[w] = '\0';
+        }
+        if (!e) {
+            break;
+        }
+        s = e + SKIP_ONE;
+    }
+    return true;
+}
+
+static void ra_unresolved(cbm_doclink_outcome_t *out, int reason) {
+    out->kind = CBM_DOCLINK_UNRESOLVED;
+    out->reason = reason;
+}
+
+static void ra_edge(cbm_doclink_outcome_t *out, const cbm_gbuf_node_t *n, uint32_t a, uint32_t b) {
+    out->kind = CBM_DOCLINK_EDGE;
+    out->target = n;
+    out->exact = true;
+    out->target_first = a;
+    out->target_last = b;
+}
+
+/* A path of a type the indexer does not read (a service file, an image): no
+ * reference to code, decided by its name as the Markdown resolver does -- never
+ * by the disk, which an incremental run does not watch for such files. */
+static bool ra_unindexable(const char *path) {
+    return cbm_language_for_filename(ra_base(path)) == CBM_LANG_COUNT;
+}
+
+/* A collector scan of build output (`./build/...`): what it contributes is
+ * generated, not a file of the repository (H8). */
+static bool ra_build_dir(const char *dir) {
+    while (dir[0] == '.' && dir[1] == '/') {
+        dir += PAIR_LEN;
+    }
+    return strcmp(dir, "build") == 0 || strncmp(dir, "build/", strlen("build/")) == 0 ||
+           strstr(dir, "/build/") != NULL;
+}
+
+static const char *const RA_FAMILIES[][2] = {{"example", "examples"},
+                                             {"partial", "partials"},
+                                             {"page", "pages"},
+                                             {"image", "images"},
+                                             {"attachment", "attachments"}};
+
+/* H8 resolve_target: an Antora resource ID or a path relative to the including
+ * file. Returns the repository path in `out`, or false with `out->kind` set. */
+static bool ra_target(const ra_index_t *x, const cbm_gbuf_t *graph, const char *doc,
+                      const ra_comp_t *comp, const char *target, char *path, size_t cap,
+                      cbm_doclink_outcome_t *out) {
+    out->kind = CBM_DOCLINK_LOCAL;
+    if (strstr(target, "://")) {
+        return false; /* a URL include */
+    }
+    const char *dollar = strchr(target, '$');
+    if (dollar && comp) {
+        char pre[RA_PATH_CAP];
+        snprintf(pre, sizeof(pre), "%.*s", (int)(dollar - target), target);
+        const char *at = strrchr(pre, '@');
+        char *segs = at ? pre + (at - pre) + SKIP_ONE : pre;
+        /* family is the last segment; module and component before it */
+        char *fam = strrchr(segs, ':');
+        const char *module = NULL;
+        if (fam) {
+            *fam = '\0';
+            fam++;
+            char *comp_sep = strchr(segs, ':');
+            if (comp_sep) {
+                *comp_sep = '\0';
+                if (strcmp(segs, comp->name) != 0) {
+                    return false; /* another component's resource */
+                }
+                module = comp_sep + SKIP_ONE;
+            } else {
+                module = segs;
+            }
+        } else {
+            fam = segs;
+        }
+        char doc_module[RA_PATH_CAP] = "ROOT";
+        if (!module) {
+            /* the including page's own module: modules/<module>/... */
+            const char *rel = doc + strlen(comp->root) + (comp->root[0] ? SKIP_ONE : 0);
+            if (strncmp(rel, "modules/", strlen("modules/")) == 0) {
+                const char *m = rel + strlen("modules/");
+                const char *slash = strchr(m, '/');
+                if (slash) {
+                    snprintf(doc_module, sizeof(doc_module), "%.*s", (int)(slash - m), m);
+                }
+            }
+            module = doc_module;
+        }
+        const char *famdir = NULL;
+        for (size_t i = 0; i < sizeof(RA_FAMILIES) / sizeof(RA_FAMILIES[0]); i++) {
+            if (strcmp(fam, RA_FAMILIES[i][0]) == 0) {
+                famdir = RA_FAMILIES[i][1];
+            }
+        }
+        if (!famdir) {
+            ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE);
+            return false;
+        }
+        char virt[RA_PATH_CAP];
+        snprintf(virt, sizeof(virt), "modules/%s/%s/%s", module, famdir, dollar + SKIP_ONE);
+        if (ra_norm(comp->root, virt, path, cap) &&
+            cbm_pipeline_file_node(graph, x->project, path)) {
+            return true;
+        }
+        /* a file a collector scan contributes into the component */
+        for (int i = 0; i < comp->nscans; i++) {
+            const char *into = comp->scans[i].into;
+            while (into[0] == '.' && into[1] == '/') {
+                into += PAIR_LEN;
+            }
+            size_t il = strlen(into);
+            while (il > 0 && into[il - SKIP_ONE] == '/') {
+                il--;
+            }
+            if (il == 0 || strncmp(virt, into, il) != 0 || virt[il] != '/') {
+                continue;
+            }
+            char sub[RA_PATH_CAP];
+            snprintf(sub, sizeof(sub), "%s/%s", comp->scans[i].dir, virt + il + SKIP_ONE);
+            if (ra_norm(comp->root, sub, path, cap) &&
+                cbm_pipeline_file_node(graph, x->project, path)) {
+                return true;
+            }
+            if (ra_build_dir(comp->scans[i].dir)) {
+                return false; /* build output (H8 generated): no file of the repository */
+            }
+        }
+        if (ra_unindexable(virt)) {
+            return false;
+        }
+        ra_unresolved(out, CBM_DOCLINK_REASON_MISSING);
+        return false;
+    }
+    char dir[RA_PATH_CAP];
+    const char *b = ra_base(doc);
+    snprintf(dir, sizeof(dir), "%.*s", b > doc ? (int)(b - doc - SKIP_ONE) : 0, doc);
+    if (!ra_norm(dir, target, path, cap)) {
+        return false; /* above the repository root */
+    }
+    if (cbm_pipeline_file_node(graph, x->project, path)) {
+        return true;
+    }
+    char parent[RA_PATH_CAP];
+    const char *pb = ra_base(path);
+    snprintf(parent, sizeof(parent), "%.*s", pb > path ? (int)(pb - path - SKIP_ONE) : 0, path);
+    if (!ra_unindexable(path) && parent[0] && cbm_doclink_md_folder(x->md, parent)) {
+        ra_unresolved(out, CBM_DOCLINK_REASON_MISSING);
+    }
+    return false;
+}
+
+/* Asciidoctor's TagDirectiveRx \b(?:tag|(e)nd)::(\S+?)\[\](?=$|[ \r]) over the
+ * file: the 1-based lines from the first region's first content line to the
+ * last region's last one (directive lines excluded). False when a tag has no
+ * region. */
+static bool ra_tag_span(const char *src, size_t n, const char *const *tags, int ntags,
+                        uint32_t *first, uint32_t *last) {
+    *first = 0;
+    *last = 0;
+    for (int t = 0; t < ntags; t++) {
+        size_t tl = strlen(tags[t]);
+        uint32_t line = 1;
+        uint32_t start = 0;
+        bool found = false;
+        size_t pos = 0;
+        while (pos < n) {
+            const char *nl = memchr(src + pos, '\n', n - pos);
+            size_t end = nl ? (size_t)(nl - src) : n;
+            for (size_t i = pos; i + PAIR_LEN < end; i++) {
+                bool is_end = false;
+                size_t k;
+                if (i + strlen("tag::") <= end && memcmp(src + i, "tag::", strlen("tag::")) == 0) {
+                    k = i + strlen("tag::");
+                } else if (i + strlen("end::") <= end &&
+                           memcmp(src + i, "end::", strlen("end::")) == 0) {
+                    k = i + strlen("end::");
+                    is_end = true;
+                } else {
+                    continue;
+                }
+                if (i > pos && ra_word(src[i - SKIP_ONE])) {
+                    continue; /* \b */
+                }
+                if (k + tl + PAIR_LEN > end || memcmp(src + k, tags[t], tl) != 0 ||
+                    src[k + tl] != '[' || src[k + tl + SKIP_ONE] != ']') {
+                    continue;
+                }
+                size_t after = k + tl + PAIR_LEN;
+                if (after != end && src[after] != ' ' && src[after] != '\r') {
+                    continue;
+                }
+                if (!is_end && start == 0) {
+                    start = line + SKIP_ONE;
+                } else if (is_end && start != 0) {
+                    if (start <= line - SKIP_ONE) {
+                        *first = (*first == 0 || start < *first) ? start : *first;
+                        *last = line - SKIP_ONE > *last ? line - SKIP_ONE : *last;
+                        found = true;
+                    }
+                    start = 0;
+                }
+                break;
+            }
+            line++;
+            pos = end + SKIP_ONE;
+        }
+        if (start != 0 && start <= line - SKIP_ONE) {
+            *first = (*first == 0 || start < *first) ? start : *first;
+            *last = line - SKIP_ONE > *last ? line - SKIP_ONE : *last;
+            found = true;
+        }
+        if (!found) {
+            return false;
+        }
+    }
+    return *first > 0;
+}
+
+/* The included file's text, read from the indexed file on disk (at most
+ * RA_TAG_FILE_MAX bytes): its tag regions and the lines of a region. NULL
+ * when it cannot be read; the caller frees it (cbm_free, OTHER). */
+static char *ra_read(const ra_index_t *x, const char *path, size_t *n) {
+    *n = 0;
+    if (!x->repo) {
+        return NULL;
+    }
+    char abs[RA_PATH_CAP * PAIR_LEN];
+    snprintf(abs, sizeof(abs), "%s/%s", x->repo, path);
+    FILE *f = cbm_fopen(abs, "rb");
+    if (!f) {
+        return NULL;
+    }
+    char *buf = (char *)cbm_alloc(CBM_MEM_CLASS_OTHER, RA_TAG_FILE_MAX);
+    *n = buf ? fread(buf, SKIP_ONE, RA_TAG_FILE_MAX, f) : 0;
+    (void)fclose(f);
+    return buf;
+}
+
+/* `lines=a..b;c;d..-1`: the span of all ranges (-1: the file's end). */
+static bool ra_lines(const char *v, uint32_t *first, uint32_t *last) {
+    *first = 0;
+    *last = 0;
+    const char *p = v;
+    while (*p) {
+        while (*p == ';' || *p == ',' || *p == ' ' || *p == '"') {
+            p++;
+        }
+        if (!*p) {
+            break;
+        }
+        if (*p < '0' || *p > '9') {
+            return false;
+        }
+        uint32_t a = (uint32_t)strtoul(p, (char **)&p, 10);
+        uint32_t b = a;
+        if (p[0] == '.' && p[1] == '.') {
+            p += PAIR_LEN;
+            if (p[0] == '-' && p[1] == '1') {
+                b = UINT32_MAX;
+                p += PAIR_LEN;
+            } else if (*p >= '0' && *p <= '9') {
+                b = (uint32_t)strtoul(p, (char **)&p, 10);
+            } else {
+                return false;
+            }
+        }
+        if (a == 0 || b < a) {
+            return false;
+        }
+        *first = (*first == 0 || a < *first) ? a : *first;
+        *last = b > *last ? b : *last;
+    }
+    return *first > 0;
+}
+
+typedef struct {
+    char buf[RA_PATH_CAP * PAIR_LEN];
+    char *f[RA_FIELDS];
+    int n;
+} ra_rec_t;
+
+static bool ra_record(const char *raw, ra_rec_t *r) {
+    if (snprintf(r->buf, sizeof(r->buf), "%s", raw) >= (int)sizeof(r->buf)) {
+        return false;
+    }
+    r->n = 0;
+    char *p = r->buf;
+    while (r->n < RA_FIELDS) {
+        r->f[r->n++] = p;
+        char *tab = strchr(p, '\t');
+        if (!tab) {
+            break;
+        }
+        *tab = '\0';
+        p = tab + SKIP_ONE;
+    }
+    for (int i = r->n; i < RA_FIELDS; i++) {
+        r->f[i] = "";
+    }
+    return true;
+}
+
+static void ra_include(const ra_index_t *x, const cbm_gbuf_t *graph, const char *doc,
+                       const ra_rec_t *r, cbm_doclink_outcome_t *out) {
+    const ra_comp_t *comp = ra_component_of(x, doc);
+    char target[RA_PATH_CAP];
+    if (strchr(r->f[1], '{')) {
+        if (!comp || !ra_expand(x, comp, r->f[1], target, sizeof(target))) {
+            ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE); /* an undefined attribute */
+            return;
+        }
+    } else {
+        snprintf(target, sizeof(target), "%s", r->f[1]);
+    }
+    char path[RA_PATH_CAP];
+    if (!ra_target(x, graph, doc, comp, target, path, sizeof(path), out)) {
+        return;
+    }
+    const cbm_gbuf_node_t *file = cbm_pipeline_file_node(graph, x->project, path);
+    if (!file) {
+        out->kind = CBM_DOCLINK_LOCAL;
+        return;
+    }
+    uint32_t first = 0;
+    uint32_t last = 0;
+    const char *tagv = r->f[2];
+    if (!tagv[0] && r->f[3][0] && !ra_lines(r->f[3], &first, &last)) {
+        ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE);
+        return;
+    }
+    size_t tn = 0;
+    char *text = (tagv[0] || first > 0) ? ra_read(x, path, &tn) : NULL;
+    if (tagv[0]) {
+        /* H8: negated and wildcard tags leave the positive ones; none left
+         * includes the whole file */
+        char tags[RA_TAGS][RA_TAG_LEN];
+        const char *tagp[RA_TAGS];
+        int nt = 0;
+        for (const char *p = tagv; *p && nt < RA_TAGS;) {
+            size_t l = strcspn(p, ";,");
+            if (l > 0 && l < RA_TAG_LEN && p[0] != '!' && !memchr(p, '*', l)) {
+                snprintf(tags[nt], RA_TAG_LEN, "%.*s", (int)l, p);
+                tagp[nt] = tags[nt];
+                nt++;
+            }
+            p += l + (p[l] ? SKIP_ONE : 0);
+        }
+        if (nt == 0 || !text || !ra_tag_span(text, tn, tagp, nt, &first, &last)) {
+            first = 0; /* wildcards only, or a tag the file lacks: the file */
+            last = 0;
+        }
+    }
+    if (first > 0) {
+        const cbm_gbuf_node_t *seg = text
+                                         ? cbm_doclink_md_region(x->md, path, text, tn, first, last)
+                                         : cbm_doclink_md_segment(x->md, path, first, last, NULL);
+        cbm_free(CBM_MEM_CLASS_OTHER, text);
+        ra_edge(out, seg ? seg : file, first, last == UINT32_MAX ? 0 : last);
+        return;
+    }
+    cbm_free(CBM_MEM_CLASS_OTHER, text);
+    ra_edge(out, file, 0, 0);
+}
+
+static bool ra_class_label(const char *label) {
+    static const char *const labels[] = {"Class", "Interface", "Enum", "Type", "Trait", NULL};
+    for (int i = 0; label && labels[i]; i++) {
+        if (strcmp(label, labels[i]) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool ra_member_label(const char *label) {
+    static const char *const labels[] = {"Method", "Field", "Variable", "Function", NULL};
+    for (int i = 0; label && labels[i]; i++) {
+        if (strcmp(label, labels[i]) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/* H8 javadoc: xref:attachment$api/<module>/<pkg path>/<Type>.html[#member]. */
+static void ra_javadoc(const ra_index_t *x, const cbm_gbuf_t *graph, const char *val,
+                       cbm_doclink_outcome_t *out) {
+    static const char key[] = "xref:attachment$api/";
+    const char *p = strstr(val, key);
+    if (!p) {
+        return;
+    }
+    p += strlen(key);
+    const char *slash = strchr(p, '/'); /* after the JPMS module */
+    if (!slash) {
+        return;
+    }
+    const char *path = slash + SKIP_ONE;
+    const char *html = strstr(path, ".html");
+    if (!html || memchr(path, '[', (size_t)(html - path))) {
+        return;
+    }
+    char rel[RA_PATH_CAP];
+    snprintf(rel, sizeof(rel), "%.*s", (int)(html - path), path);
+    const char *tname = ra_base(rel);
+    if (strcmp(tname, "package-summary") == 0 || strcmp(tname, "module-summary") == 0 ||
+        strcmp(rel, "index") == 0) {
+        return; /* a package or module page: no code node */
+    }
+    char anchor[RA_PATH_CAP] = "";
+    if (html[strlen(".html")] == '#') {
+        const char *a = html + strlen(".html") + SKIP_ONE;
+        size_t al = strcspn(a, "[(-");
+        snprintf(anchor, sizeof(anchor), "%.*s", (int)al, a);
+    }
+    char pkgdir[RA_PATH_CAP];
+    snprintf(pkgdir, sizeof(pkgdir), "%.*s", (int)(tname - rel), rel); /* "org/x/" */
+    char outer[RA_PATH_CAP];
+    snprintf(outer, sizeof(outer), "%.*s", (int)strcspn(tname, "."), tname);
+    const char *want = strrchr(tname, '.') ? strrchr(tname, '.') + SKIP_ONE : tname;
+    /* the source files declaring <pkg dir>/<Outer>.java|.kt, main sources first */
+    const cbm_gbuf_node_t **nodes = NULL;
+    int count = 0;
+    if (cbm_gbuf_find_by_name(graph, outer, &nodes, &count) != 0) {
+        return;
+    }
+    const char *files[2] = {NULL, NULL};
+    int nfiles = 0;
+    for (int pass = 0; pass < PAIR_LEN && nfiles == 0; pass++) {
+        bool main_only = pass == 0;
+        for (int i = 0; i < count; i++) {
+            const cbm_gbuf_node_t *n = nodes[i];
+            const char *fp = n->file_path;
+            if (!ra_class_label(n->label) || !fp) {
+                continue;
+            }
+            char tail[RA_PATH_CAP * PAIR_LEN];
+            bool java = ra_ends(fp, ".java");
+            snprintf(tail, sizeof(tail), "%s%s%s", pkgdir, outer, java ? ".java" : ".kt");
+            size_t fl = strlen(fp);
+            size_t tl = strlen(tail);
+            if (!(java || ra_ends(fp, ".kt")) || fl < tl || strcmp(fp + fl - tl, tail) != 0 ||
+                (fl > tl && fp[fl - tl - SKIP_ONE] != '/') ||
+                (main_only && !strstr(fp, "/src/main/"))) {
+                continue;
+            }
+            bool seen = false;
+            for (int k = 0; k < nfiles; k++) {
+                seen = seen || strcmp(files[k], fp) == 0;
+            }
+            if (!seen && nfiles < PAIR_LEN) {
+                files[nfiles++] = fp;
+            } else if (!seen) {
+                nfiles++;
+            }
+        }
+    }
+    if (nfiles == 0) {
+        ra_unresolved(out, CBM_DOCLINK_REASON_MISSING);
+        return;
+    }
+    if (nfiles > SKIP_ONE) {
+        ra_unresolved(out, CBM_DOCLINK_REASON_AMBIGUOUS);
+        return;
+    }
+    /* the type in that file (the first by line for a repeated name) */
+    const cbm_gbuf_node_t *type = NULL;
+    if (cbm_gbuf_find_by_name(graph, want, &nodes, &count) == 0) {
+        for (int i = 0; i < count; i++) {
+            const cbm_gbuf_node_t *n = nodes[i];
+            if (ra_class_label(n->label) && n->file_path && strcmp(n->file_path, files[0]) == 0 &&
+                (!type || n->start_line < type->start_line ||
+                 (n->start_line == type->start_line && n->id < type->id))) {
+                type = n;
+            }
+        }
+    }
+    if (!type) {
+        ra_unresolved(out, CBM_DOCLINK_REASON_GRAPH_GAP);
+        return;
+    }
+    const cbm_gbuf_node_t *member = NULL;
+    int members = 0;
+    if (anchor[0] && cbm_gbuf_find_by_name(graph, anchor, &nodes, &count) == 0) {
+        for (int i = 0; i < count; i++) {
+            const cbm_gbuf_node_t *n = nodes[i];
+            if (ra_member_label(n->label) && n->file_path && strcmp(n->file_path, files[0]) == 0 &&
+                n->start_line >= type->start_line && n->start_line <= type->end_line) {
+                member = n;
+                members++;
+            }
+        }
+    }
+    /* an overloaded member: the type that declares it */
+    ra_edge(out, members == SKIP_ONE ? member : type, 0, 0);
+}
+
+static void ra_attribute(const ra_index_t *x, const cbm_gbuf_t *graph, const char *doc,
+                         const ra_rec_t *r, cbm_doclink_outcome_t *out) {
+    const ra_comp_t *comp = ra_component_of(x, doc);
+    if (!comp) {
+        return; /* outside an Antora component: no API attributes (H8) */
+    }
+    const char *raw = r->f[2][0] ? r->f[2] : ra_attr(x, comp, r->f[1], strlen(r->f[1]));
+    if (!raw || !strstr(raw, "{javadoc-root}")) {
+        return;
+    }
+    char val[RA_PATH_CAP];
+    if (!ra_expand(x, comp, r->f[2][0] ? r->f[3] : raw, val, sizeof(val))) {
+        return;
+    }
+    ra_javadoc(x, graph, val, out);
+}
+
+static void ra_resolve(const void *index, void *state, int run_file, const CBMDocLink *link,
+                       const cbm_gbuf_t *graph, cbm_doclink_outcome_t *out) {
+    (void)state;
+    const ra_index_t *x = (const ra_index_t *)index;
+    out->kind = CBM_DOCLINK_LOCAL;
+    const char *doc = (run_file >= 0 && run_file < x->run_count) ? x->run_paths[run_file] : NULL;
+    if (!doc || !link->raw) {
+        ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE);
+        return;
+    }
+    if (link->syntax == CBM_DOCLINK_ADOC_CODE_PATH || link->syntax == CBM_DOCLINK_ADOC_CODE_NAME) {
+        CBMDocLink md = *link;
+        md.syntax = link->syntax == CBM_DOCLINK_ADOC_CODE_PATH ? CBM_DOCLINK_MD_CODE_PATH
+                                                               : CBM_DOCLINK_MD_CODE_NAME;
+        cbm_doclink_md_resolver.resolve(x->md, NULL, run_file, &md, graph, out);
+        return;
+    }
+    ra_rec_t *r = (ra_rec_t *)cbm_alloc(CBM_MEM_CLASS_OTHER, sizeof(*r));
+    if (!r || !ra_record(link->raw, r)) {
+        ra_unresolved(out, CBM_DOCLINK_REASON_UNPARSEABLE);
+        cbm_free(CBM_MEM_CLASS_OTHER, r);
+        return;
+    }
+    if (link->syntax == CBM_DOCLINK_ADOC_INCLUDE) {
+        ra_include(x, graph, doc, r, out);
+    } else if (link->syntax == CBM_DOCLINK_ADOC_ATTRIBUTE) {
+        ra_attribute(x, graph, doc, r, out);
+    }
+    cbm_free(CBM_MEM_CLASS_OTHER, r);
+}
+
+const cbm_doclink_resolver_t cbm_doclink_adoc_resolver = {
+    .langs = {CBM_LANG_ASCIIDOC, CBM_LANG_YAML},
+    .lang_count = 2,
+    .scope_tag = CBM_DOCLINK_ADOC_SCOPE_TAG,
+    .build = ra_build,
+    .destroy = ra_destroy,
+    .resolve = ra_resolve,
+    .via = "asciidoc",
+};
diff --git a/src/pipeline/doc_links_md.c b/src/pipeline/doc_links_md.c
index b2a76594e..667ea724a 100644
--- a/src/pipeline/doc_links_md.c
+++ b/src/pipeline/doc_links_md.c
@@ -50,6 +50,8 @@ enum {
     MDR_HEX_BASE = 16,
     MDR_PCT_LEN = 3,    /* `%XX` */
     MDR_ADR_DIGITS = 5, /* an ADR number has at most this many digits */
+    MDR_PRIO_FIELD = 3, /* H8's label priorities: types 0, Type 1, callables 2 */
+    MDR_PRIO_OTHER = 4,
 };
 
 /* Labels whose nodes are code a range or a member can name. */
@@ -108,8 +110,8 @@ static const char *mdr_base(const char *path) {
 static bool mdr_code_file(const char *path) {
     CBMLanguage lang = cbm_language_for_filename(mdr_base(path));
     return lang != CBM_LANG_COUNT && lang != CBM_LANG_MARKDOWN && lang != CBM_LANG_RST &&
-           lang != CBM_LANG_HTML && lang != CBM_LANG_CSS && lang != CBM_LANG_SCSS &&
-           !cbm_has_config_extension(path);
+           lang != CBM_LANG_ASCIIDOC && lang != CBM_LANG_PDF && lang != CBM_LANG_HTML &&
+           lang != CBM_LANG_CSS && lang != CBM_LANG_SCSS && !cbm_has_config_extension(path);
 }
 
 /* The stems of a package directory's index file. */
@@ -1205,6 +1207,228 @@ const cbm_gbuf_node_t *cbm_doclink_md_segment(const void *md_index, const char *
     return md_index ? mdr_segment((const mdr_index_t *)md_index, path, first, last, member) : NULL;
 }
 
+/* ── A region of a file's text (the field test's H8 bind_range) ─────── */
+
+/* A blank or comment-only line (H8 _skippable). */
+static bool mdr_skippable(const char *s, size_t n) {
+    size_t i = 0;
+    while (i < n && (s[i] == ' ' || s[i] == '\t' || s[i] == '\r')) {
+        i++;
+    }
+    if (i == n) {
+        return true;
+    }
+    const char *t = s + i;
+    size_t r = n - i;
+    if ((r >= PAIR_LEN && t[0] == '/' && (t[1] == '/' || t[1] == '*')) || t[0] == '*' ||
+        t[0] == ';' || t[0] == '%' || (r >= PAIR_LEN && t[0] == '\'' && t[1] == ' ') ||
+        (r >= PAIR_LEN && t[0] == '-' && t[1] == '-' && r > PAIR_LEN &&
+         (t[PAIR_LEN] == ' ' || t[PAIR_LEN] == '\t')) ||
+        (r >= strlen("<!--") && memcmp(t, "<!--", strlen("<!--")) == 0)) {
+        return true;
+    }
+    return t[0] == '#' && !(r >= PAIR_LEN && (t[1] == '[' || t[1] == '!'));
+}
+
+static bool mdr_annotation(const char *s, size_t n) {
+    size_t i = 0;
+    while (i < n && (s[i] == ' ' || s[i] == '\t')) {
+        i++;
+    }
+    return i < n && (s[i] == '@' || (i + SKIP_ONE < n && s[i] == '#' && s[i + SKIP_ONE] == '['));
+}
+
+static bool mdr_container(const char *label) {
+    static const char *const labels[] = {"Function", "Method", "Class", "Struct", "Interface",
+                                         "Enum",     "Type",   "Trait", "Record", NULL};
+    for (int i = 0; label && labels[i]; i++) {
+        if (strcmp(label, labels[i]) == 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static int mdr_label_prio(const char *label) {
+    if (!label) {
+        return MDR_PRIO_OTHER;
+    }
+    if (mdr_classlike(label) && strcmp(label, "Type") != 0) {
+        return 0;
+    }
+    if (strcmp(label, "Type") == 0) {
+        return SKIP_ONE;
+    }
+    if (strcmp(label, "Function") == 0 || strcmp(label, "Method") == 0) {
+        return PAIR_LEN;
+    }
+    return strcmp(label, "Field") == 0 ? MDR_PRIO_FIELD : MDR_PRIO_OTHER;
+}
+
+/* (s, -e, label priority, id): the order H8 picks maximal nodes in. */
+static int mdr_region_cmp(const void *a, const void *b) {
+    const cbm_gbuf_node_t *x = *(const cbm_gbuf_node_t *const *)a;
+    const cbm_gbuf_node_t *y = *(const cbm_gbuf_node_t *const *)b;
+    if (x->start_line != y->start_line) {
+        return x->start_line < y->start_line ? -1 : 1;
+    }
+    if (x->end_line != y->end_line) {
+        return x->end_line > y->end_line ? -1 : 1;
+    }
+    int px = mdr_label_prio(x->label);
+    int py = mdr_label_prio(y->label);
+    if (px != py) {
+        return px < py ? -1 : 1;
+    }
+    return (x->id > y->id) - (x->id < y->id);
+}
+
+/* Do the maximal nodes cover every line of [a, b] that is not blank or a
+ * comment (an annotation line counts when it sits right above a covered
+ * node, H8's exact-cover)? */
+static bool mdr_exact_cover(const cbm_gbuf_node_t *const *max, int nmax, const size_t *starts,
+                            const char *text, size_t text_len, uint32_t a, uint32_t b) {
+    for (uint32_t ln = a; ln <= b; ln++) {
+        bool covered = false;
+        for (int k = 0; k < nmax && !covered; k++) {
+            covered = (uint32_t)max[k]->start_line <= ln && (uint32_t)max[k]->end_line >= ln;
+        }
+        size_t s0 = starts[ln - SKIP_ONE];
+        size_t s1 = starts[ln] > s0 ? starts[ln] - SKIP_ONE : s0;
+        if (covered || s0 >= text_len || mdr_skippable(text + s0, s1 - s0)) {
+            continue;
+        }
+        if (!mdr_annotation(text + s0, s1 - s0)) {
+            return false;
+        }
+        /* annotations, blanks and comments down to a covered node's first line */
+        uint32_t nxt = ln + SKIP_ONE;
+        while (nxt <= b) {
+            size_t t0 = starts[nxt - SKIP_ONE];
+            size_t t1 = starts[nxt] > t0 ? starts[nxt] - SKIP_ONE : t0;
+            if (!mdr_skippable(text + t0, t1 - t0) && !mdr_annotation(text + t0, t1 - t0)) {
+                break;
+            }
+            nxt++;
+        }
+        bool starts_node = false;
+        for (int k = 0; k < nmax && !starts_node; k++) {
+            starts_node = (uint32_t)max[k]->start_line <= nxt && (uint32_t)max[k]->end_line >= nxt;
+        }
+        if (!starts_node) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const cbm_gbuf_node_t *cbm_doclink_md_region(const void *md_index, const char *path,
+                                             const char *text, size_t text_len, uint32_t first,
+                                             uint32_t last) {
+    const mdr_index_t *x = (const mdr_index_t *)md_index;
+    if (!x || !text || first == 0 || last < first) {
+        return NULL;
+    }
+    /* line starts: starts[k] is the offset of line k + 1; one past the end */
+    uint32_t nlines = SKIP_ONE;
+    for (size_t i = 0; i < text_len; i++) {
+        nlines += text[i] == '\n';
+    }
+    if (last > nlines) {
+        last = nlines;
+    }
+    if (first > last) {
+        return NULL;
+    }
+    size_t *starts =
+        (size_t *)cbm_alloc(CBM_MEM_CLASS_OTHER, ((size_t)nlines + SKIP_ONE) * sizeof(size_t));
+    if (!starts) {
+        return NULL;
+    }
+    uint32_t k = 0;
+    starts[k++] = 0;
+    for (size_t i = 0; i < text_len; i++) {
+        if (text[i] == '\n') {
+            starts[k++] = i + SKIP_ONE;
+        }
+    }
+    starts[k] = text_len + SKIP_ONE;
+    /* edge blank and comment lines trimmed */
+    uint32_t a = first;
+    uint32_t b = last;
+    while (a <= b && mdr_skippable(text + starts[a - SKIP_ONE],
+                                   starts[a] - SKIP_ONE - starts[a - SKIP_ONE])) {
+        a++;
+    }
+    while (b >= a && mdr_skippable(text + starts[b - SKIP_ONE],
+                                   starts[b] - SKIP_ONE - starts[b - SKIP_ONE])) {
+        b--;
+    }
+    if (a > b) {
+        a = first;
+        b = last;
+    }
+    int lo = 0;
+    int hi = 0;
+    mdr_file_defs(x, path, &lo, &hi);
+    const cbm_gbuf_node_t *enc = NULL;
+    for (int i = lo; i < hi; i++) {
+        const cbm_gbuf_node_t *n = x->defs[i].node;
+        if (!mdr_container(n->label) || n->start_line <= 0 || (uint32_t)n->start_line > a ||
+            (uint32_t)n->end_line < b) {
+            continue;
+        }
+        int span = n->end_line - n->start_line;
+        int best = enc ? enc->end_line - enc->start_line : 0;
+        if (!enc || span < best ||
+            (span == best && (n->start_line > enc->start_line ||
+                              (n->start_line == enc->start_line &&
+                               mdr_label_prio(n->label) < mdr_label_prio(enc->label))))) {
+            enc = n;
+        }
+    }
+    const cbm_gbuf_node_t **inside = (const cbm_gbuf_node_t **)cbm_alloc(
+        CBM_MEM_CLASS_OTHER, (size_t)(hi - lo + SKIP_ONE) * sizeof(*inside));
+    const cbm_gbuf_node_t *pick = NULL;
+    if (inside) {
+        int ni = 0;
+        for (int i = lo; i < hi; i++) {
+            const cbm_gbuf_node_t *n = x->defs[i].node;
+            if (n == enc || n->start_line <= 0 || (uint32_t)n->start_line < a ||
+                (uint32_t)n->end_line > b ||
+                (enc && (n->start_line < enc->start_line || n->end_line > enc->end_line))) {
+                continue;
+            }
+            inside[ni++] = n;
+        }
+        qsort(inside, (size_t)ni, sizeof(*inside), mdr_region_cmp);
+        int nmax = 0; /* maximal ones, compacted in place */
+        for (int i = 0; i < ni; i++) {
+            bool nested = false;
+            for (int m = 0; m < nmax && !nested; m++) {
+                nested = inside[m]->start_line <= inside[i]->start_line &&
+                         inside[i]->end_line <= inside[m]->end_line;
+            }
+            if (!nested) {
+                inside[nmax++] = inside[i];
+            }
+        }
+        bool type_enc = !enc || (mdr_classlike(enc->label));
+        bool exact =
+            nmax > 0 && type_enc && mdr_exact_cover(inside, nmax, starts, text, text_len, a, b);
+        if (exact && enc) {
+            pick = nmax == SKIP_ONE ? inside[0] : enc; /* several: the type holding them */
+        } else if (enc) {
+            pick = enc;
+        } else if (nmax == SKIP_ONE) {
+            pick = inside[0];
+        }
+        cbm_free(CBM_MEM_CLASS_OTHER, (void *)inside);
+    }
+    cbm_free(CBM_MEM_CLASS_OTHER, starts);
+    return pick;
+}
+
 const cbm_gbuf_node_t *cbm_doclink_md_folder(const void *md_index, const char *path) {
     return md_index && path ? mdr_folder((const mdr_index_t *)md_index, NULL, path) : NULL;
 }
diff --git a/tests/repro/repro_call_node_manifest.c b/tests/repro/repro_call_node_manifest.c
index fe6e3eda5..6d87ac716 100644
--- a/tests/repro/repro_call_node_manifest.c
+++ b/tests/repro/repro_call_node_manifest.c
@@ -549,9 +549,10 @@ TEST(repro_call_node_manifest_live_specs_contain_only_expected_primary_entries)
 
         /* The registry reproduction owns Nim's stale enum and the
          * intentionally grammar-free classifications: Studio Export's
-         * transform-only one and PDF's DOCUMENT one (doc_pdf.c). */
+         * transform-only one and the DOCUMENT ones of PDF and AsciiDoc
+         * (doc_pdf.c, doc_adoc.c). */
         if (language == CBM_LANG_NIM || language == CBM_LANG_OBJECTSCRIPT_EXPORT ||
-            language == CBM_LANG_PDF) {
+            language == CBM_LANG_PDF || language == CBM_LANG_ASCIIDOC) {
             continue;
         }
         if (!spec || spec->language != language) {
diff --git a/tests/repro/repro_language_registry.c b/tests/repro/repro_language_registry.c
index 67496eb7f..e99faaa91 100644
--- a/tests/repro/repro_language_registry.c
+++ b/tests/repro/repro_language_registry.c
@@ -218,6 +218,7 @@ static const LanguageCapabilityEntry LANGUAGE_CAPABILITIES[CBM_LANG_COUNT] = {
     CALL_WITHOUT_REFERENCE_VOCAB(PLSQL),
     CALL_WITHOUT_REFERENCE_VOCAB(CHIALISP),
     DOCUMENT(PDF),
+    DOCUMENT(ASCIIDOC),
 };
 
 #undef CALL_WITH_REFERENCE_VOCAB
@@ -311,7 +312,7 @@ TEST(repro_language_capability_ledger_covers_every_enum) {
     if (counts[CAP_CALL_WITH_REFERENCE_VOCAB] != 88 ||
         counts[CAP_CALL_WITHOUT_REFERENCE_VOCAB] != 27 || counts[CAP_NO_CALL] != 49 ||
         counts[CAP_TRANSFORM_ONLY] != 1 || counts[CAP_UNSUPPORTED] != 1 ||
-        counts[CAP_DOCUMENT] != 1) {
+        counts[CAP_DOCUMENT] != 2) {
         fprintf(stderr,
                 "  [language-registry] invariant=capability_partition call_ref_vocab=%d ref_gap=%d "
                 "no_call=%d transform_only=%d unsupported=%d document=%d\n",
@@ -330,7 +331,8 @@ TEST(repro_call_argument_matrices_equal_call_capability_ledger) {
         EXPECTED_MATRIX_A_ROWS = 68,
         EXPECTED_MATRIX_B_ROWS = 49,
         EXPECTED_CALL_CAPABLE_LANGUAGES = 115,
-        EXPECTED_NON_CALL_LANGUAGES = 52, /* 49 no-call + transform-only + unsupported + PDF */
+        EXPECTED_NON_CALL_LANGUAGES =
+            53, /* 49 no-call + transform-only + unsupported + PDF, AsciiDoc */
         EXPECTED_NON_CALL_DOMAIN_CONTROLS = 2,
     };
     CBMLanguage matrix_a_ids[CBM_LANG_COUNT];
diff --git a/tests/test_doc_links_adoc.c b/tests/test_doc_links_adoc.c
new file mode 100644
index 000000000..97cd5999e
--- /dev/null
+++ b/tests/test_doc_links_adoc.c
@@ -0,0 +1,287 @@
+/*
+ * test_doc_links_adoc.c — AsciiDoc documents -> Sections and MENTIONS edges
+ * (doc_adoc.c, doc_links_adoc.c).
+ *
+ * Headings and delimited blocks, the tokens (include with the page's
+ * attributes, attribute references, monospace spans), the Antora scope blob,
+ * and the resolver: resource IDs and collector scans, tag regions read from
+ * the included file, lines, javadoc attributes to types and members, the
+ * monospace spans through the Markdown rules, incremental == full.
+ */
+#include "../src/foundation/compat.h"
+#include "test_framework.h"
+#include "test_helpers.h"
+#include "test_doc_mentions_helpers.h"
+
+#include "cbm.h"
+#include "doclink.h"
+#include "pipeline/pipeline.h"
+#include "pipeline/pipeline_internal.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static const char *const ADOC_PAGE =
+    "= Writing Tests\n"                                                   /* 1 */
+    ":testDir: example$java\n"                                            /* 2 */
+    "\n"                                                                  /* 3 */
+    "Intro with {Assertions} and {nbsp}.\n"                               /* 4 */
+    "\n"                                                                  /* 5 */
+    "== First Test\n"                                                     /* 6 */
+    "\n"                                                                  /* 7 */
+    "[source,java]\n"                                                     /* 8 */
+    "----\n"                                                              /* 9 */
+    "include::{testDir}/example/FirstTests.java[tags=user_guide]\n"       /* 10 */
+    "== Not A Heading\n"                                                  /* 11 */
+    "----\n"                                                              /* 12 */
+    "\n"                                                                  /* 13 */
+    "////\n"                                                              /* 14 */
+    "include::example$java/Hidden.java[]\n"                               /* 15 */
+    "////\n"                                                              /* 16 */
+    "// include::example$java/Commented.java[]\n"                         /* 17 */
+    "\n"                                                                  /* 18 */
+    "=== Details\n"                                                       /* 19 */
+    "\n"                                                                  /* 20 */
+    "See `src/main/java/org/x/Assertions.java` and `org.x.Assertions`.\n" /* 21 */
+    "include::../../../../src/main/java/org/x/Calc.java[lines=4..6]\n"    /* 22 */
+    "include::{testDir}/example/WithImports.java[tag=all]\n";             /* 23 */
+
+static const CBMDefinition *adoc_def(const CBMFileResult *r, const char *name) {
+    for (int i = 0; i < r->defs.count; i++) {
+        const CBMDefinition *d = &r->defs.items[i];
+        if (d->label && strcmp(d->label, "Section") == 0 && d->name && strcmp(d->name, name) == 0) {
+            return d;
+        }
+    }
+    return NULL;
+}
+
+static bool adoc_raw_has(const CBMFileResult *r, const char *needle) {
+    for (int i = 0; i < r->doc_links.count; i++) {
+        if (strstr(r->doc_links.items[i].raw, needle)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+TEST(adoc_scan_structure) {
+    CBMFileResult *r =
+        dm_extract(ADOC_PAGE, CBM_LANG_ASCIIDOC, "docs/modules/ROOT/pages/writing.adoc");
+    ASSERT_NOT_NULL(r);
+    ASSERT_FALSE(r->doc_links.failed);
+    const CBMDefinition *top = adoc_def(r, "Writing Tests");
+    const CBMDefinition *first = adoc_def(r, "First Test");
+    const CBMDefinition *details = adoc_def(r, "Details");
+    ASSERT_NOT_NULL(top);
+    ASSERT_NOT_NULL(first);
+    ASSERT_NOT_NULL(details);
+    ASSERT_NULL(adoc_def(r, "Not A Heading")); /* inside a listing block */
+    ASSERT_EQ(first->start_line, 6);
+    ASSERT_EQ(first->end_line, 17);
+    ASSERT_STR_EQ(details->qualified_name, "p.docs.modules.ROOT.pages.writing.Details");
+    /* an include with the page's attribute substituted, its tags */
+    const CBMDocLink *inc =
+        dm_find_token(r, "include::{testDir}/example/FirstTests.java[tags=user_guide]\t"
+                         "example$java/example/FirstTests.java\tuser_guide\t");
+    ASSERT_NOT_NULL(inc);
+    ASSERT_EQ(inc->syntax, CBM_DOCLINK_ADOC_INCLUDE);
+    ASSERT_EQ(inc->line, 10);
+    ASSERT_STR_EQ(inc->source_qn, first->qualified_name);
+    ASSERT_NOT_NULL(dm_find_token(r,
+                                  "include::../../../../src/main/java/org/x/Calc.java[lines=4..6]"
+                                  "\t../../../../src/main/java/org/x/Calc.java\t\t4..6"));
+    /* nothing from a comment block or a line comment */
+    ASSERT_FALSE(adoc_raw_has(r, "Hidden.java"));
+    ASSERT_FALSE(adoc_raw_has(r, "Commented.java"));
+    /* attribute references: built-ins are none; the page's own carry its value */
+    ASSERT_NOT_NULL(dm_find_token(r, "{Assertions}\tAssertions\t\t"));
+    ASSERT_FALSE(adoc_raw_has(r, "{nbsp}"));
+    /* monospace spans */
+    ASSERT_EQ(dm_find_token(r, "src/main/java/org/x/Assertions.java")->syntax,
+              CBM_DOCLINK_ADOC_CODE_PATH);
+    ASSERT_EQ(dm_find_token(r, "org.x.Assertions")->syntax, CBM_DOCLINK_ADOC_CODE_NAME);
+    cbm_free_result(r);
+    PASS();
+}
+
+static const char *const ANTORA_YML =
+    "name: guide\n"
+    "version: true\n"
+    "ext:\n"
+    "  collector:\n"
+    "    scan:\n"
+    "    - dir: ./build/generated\n"
+    "      clean: true\n"
+    "    - dir: ./src/test\n"
+    "      into: modules/ROOT/examples\n"
+    "asciidoc:\n"
+    "  attributes:\n"
+    "    javadoc-root: \"xref:attachment$api\"\n"
+    "    # API\n"
+    "    Assertions: '{javadoc-root}/org.x/org/x/Assertions.html[Assertions]'\n"
+    "    assertEquals: '{javadoc-root}/org.x/org/x/Assertions.html#assertEquals(int,int)[x]'\n"
+    "    Missing: '{javadoc-root}/org.x/org/x/Gone.html[Gone]'\n";
+
+TEST(adoc_antora_scope_blob) {
+    CBMFileResult *r = dm_extract(ANTORA_YML, CBM_LANG_YAML, "docs/antora.yml");
+    ASSERT_NOT_NULL(r);
+    ASSERT_NOT_NULL(r->doc_scope);
+    ASSERT_STR_EQ(r->doc_scope,
+                  "ad1\n"
+                  "C\n"
+                  "N\tguide\n"
+                  "D\t./build/generated\n"
+                  "D\t./src/test\n"
+                  "I\tmodules/ROOT/examples\n"
+                  "A\tjavadoc-root\txref:attachment$api\n"
+                  "A\tAssertions\t{javadoc-root}/org.x/org/x/Assertions.html[Assertions]\n"
+                  "A\tassertEquals\t{javadoc-root}/org.x/org/x/Assertions.html#assertEquals(int,"
+                  "int)[x]\n"
+                  "A\tMissing\t{javadoc-root}/org.x/org/x/Gone.html[Gone]\n");
+    cbm_free_result(r);
+    r = dm_extract("site:\n  title: x\n", CBM_LANG_YAML, "config/other.yml");
+    ASSERT_NOT_NULL(r);
+    ASSERT_NULL(r->doc_scope);
+    cbm_free_result(r);
+    PASS();
+}
+
+static void adoc_write_repo(const char *repo, const char *first_tests) {
+    th_write_file(TH_PATH(repo, "docs/antora.yml"), ANTORA_YML);
+    th_write_file(TH_PATH(repo, "docs/modules/ROOT/pages/writing.adoc"), ADOC_PAGE);
+    th_write_file(TH_PATH(repo, "docs/src/test/java/example/FirstTests.java"), first_tests);
+    th_write_file(TH_PATH(repo, "src/main/java/org/x/Assertions.java"),
+                  "package org.x;\n"
+                  "\n"
+                  "public class Assertions {\n"
+                  "    public static void assertEquals(int a, int b) {}\n"
+                  "    public static void fail() {}\n"
+                  "}\n");
+    /* a tag region that takes the imports with the class: it binds the class */
+    th_write_file(TH_PATH(repo, "docs/src/test/java/example/WithImports.java"),
+                  "package example;\n"
+                  "\n"
+                  "// tag::all[]\n"
+                  "import java.util.List;\n"
+                  "\n"
+                  "class WithImports {\n"
+                  "    List<String> names() { return null; }\n"
+                  "}\n"
+                  "// end::all[]\n");
+    th_write_file(TH_PATH(repo, "src/main/java/org/x/Calc.java"),
+                  "package org.x;\n"
+                  "\n"
+                  "public class Calc {\n"
+                  "    public int add(int a, int b) {\n"
+                  "        return a + b;\n"
+                  "    }\n"
+                  "}\n");
+}
+
+static const char *const FIRST_TESTS = "package example;\n"         /* 1 */
+                                       "\n"                         /* 2 */
+                                       "class FirstTests {\n"       /* 3 */
+                                       "    void helper() {}\n"     /* 4 */
+                                       "\n"                         /* 5 */
+                                       "    // tag::user_guide[]\n" /* 6 */
+                                       "    void addition() {\n"    /* 7 */
+                                       "        helper();\n"        /* 8 */
+                                       "    }\n"                    /* 9 */
+                                       "    // end::user_guide[]\n" /* 10 */
+                                       "}\n";                       /* 11 */
+
+static bool adoc_edge(const char *db, const char *src, const char *tgt, const char *needle) {
+    char props[512];
+    int n = 0;
+    dm_edge(db, src, tgt, props, sizeof(props), &n);
+    return n == 1 && (!needle || strstr(props, needle));
+}
+
+TEST(adoc_links_pipeline) {
+    char tmp[256];
+    snprintf(tmp, sizeof(tmp), "/tmp/cbm_dladoc_XXXXXX");
+    ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
+    char repo[512];
+    char db[512];
+    snprintf(repo, sizeof(repo), "%s/repo", tmp);
+    snprintf(db, sizeof(db), "%s/g.db", tmp);
+    adoc_write_repo(repo, FIRST_TESTS);
+    ASSERT_EQ(dm_index(repo, db, NULL), 0);
+    const char *page = "docs.modules.ROOT.pages.writing";
+    char src[256];
+    /* a resource ID through a collector scan; the tag region's innermost method */
+    snprintf(src, sizeof(src), "%s.First-Test", page);
+    ASSERT_TRUE(adoc_edge(db, src, "example.FirstTests.addition",
+                          "{\"via\":\"asciidoc\",\"syntax\":\"include\",\"tier\":\"exact\""));
+    ASSERT_TRUE(adoc_edge(db, src, "example.FirstTests.addition", "\"target_lines\":[7,9]"));
+    /* a javadoc attribute (under the document title): the type it documents */
+    snprintf(src, sizeof(src), "%s.Writing-Tests", page);
+    ASSERT_TRUE(adoc_edge(db, src, "org.x.Assertions", "\"syntax\":\"attribute\""));
+    /* lines= and a relative include */
+    snprintf(src, sizeof(src), "%s.Details", page);
+    ASSERT_TRUE(adoc_edge(db, src, "org.x.Calc.add", "\"target_lines\":[4,6]"));
+    /* the region's imports are no definition: the one it holds whole binds */
+    ASSERT_TRUE(adoc_edge(db, src, "example.WithImports", "\"target_lines\":[4,8]"));
+    /* monospace spans through the Markdown rules */
+    ASSERT_TRUE(adoc_edge(db, src, "src.main.java.org.x.Assertions.java.__file__",
+                          "\"syntax\":\"code_path\""));
+    /* back navigation: the method knows the section that includes it */
+    ASSERT_EQ(dm_count(db, "SELECT COUNT(*) FROM edges e JOIN nodes s ON s.id=e.source_id JOIN "
+                           "nodes t ON t.id=e.target_id WHERE e.type='MENTIONS' AND "
+                           "t.name='addition' AND s.label='Section' AND s.name='First Test'"),
+              1);
+    th_cleanup(tmp);
+    PASS();
+}
+
+TEST(adoc_links_incremental) {
+    char tmp[256];
+    snprintf(tmp, sizeof(tmp), "/tmp/cbm_dladoc_inc_XXXXXX");
+    ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
+    char repo[512];
+    char db[512];
+    char full_db[512];
+    snprintf(repo, sizeof(repo), "%s/repo", tmp);
+    snprintf(db, sizeof(db), "%s/inc.db", tmp);
+    snprintf(full_db, sizeof(full_db), "%s/full.db", tmp);
+    adoc_write_repo(repo, FIRST_TESTS);
+    ASSERT_EQ(dm_index(repo, db, NULL), 0);
+    /* the tagged region moves to another method: the page follows it */
+    th_write_file(TH_PATH(repo, "docs/src/test/java/example/FirstTests.java"),
+                  "package example;\n"
+                  "\n"
+                  "class FirstTests {\n"
+                  "    // tag::user_guide[]\n"
+                  "    void helper() {}\n"
+                  "    // end::user_guide[]\n"
+                  "\n"
+                  "    void addition() {\n"
+                  "        helper();\n"
+                  "    }\n"
+                  "}\n");
+    ASSERT_EQ(dm_step(repo, db, full_db, "tag moved", CBM_INCREMENTAL_ROUTE_CLOSURE_REPAIR), 0);
+    /* a component attribute changes: every page re-resolves */
+    th_write_file(TH_PATH(repo, "docs/antora.yml"),
+                  "name: guide\n"
+                  "ext:\n"
+                  "  collector:\n"
+                  "    scan:\n"
+                  "    - dir: ./src/test\n"
+                  "      into: modules/ROOT/examples\n"
+                  "asciidoc:\n"
+                  "  attributes:\n"
+                  "    javadoc-root: \"xref:attachment$api\"\n"
+                  "    Assertions: '{javadoc-root}/org.x/org/x/Calc.html[Calc]'\n");
+    ASSERT_EQ(dm_step(repo, db, full_db, "attribute change", CBM_INCREMENTAL_ROUTE_FORCED_FULL), 0);
+    th_cleanup(tmp);
+    PASS();
+}
+
+SUITE(doc_links_adoc) {
+    RUN_TEST(adoc_scan_structure);
+    RUN_TEST(adoc_antora_scope_blob);
+    RUN_TEST(adoc_links_pipeline);
+    RUN_TEST(adoc_links_incremental);
+}
diff --git a/tests/test_main.c b/tests/test_main.c
index 542df5b48..145e96ef6 100644
--- a/tests/test_main.c
+++ b/tests/test_main.c
@@ -1824,6 +1824,7 @@ extern void suite_doc_mentions_msbuild(void);
 extern void suite_doc_links_md(void);
 extern void suite_doc_links_pdf(void);
 extern void suite_doc_links_rst(void);
+extern void suite_doc_links_adoc(void);
 extern void suite_infrascan(void);
 extern void suite_cli(void);
 extern void suite_agent_clients(void);
@@ -2294,6 +2295,7 @@ int main(int argc, char **argv) {
     RUN_SELECTED_SUITE(doc_links_md);
     RUN_SELECTED_SUITE(doc_links_pdf);
     RUN_SELECTED_SUITE(doc_links_rst);
+    RUN_SELECTED_SUITE(doc_links_adoc);
 
     /* Infrastructure scanning */
     RUN_SELECTED_SUITE(infrascan);