@333eco/corpus 2.4.0 → 2.4.2

package/README.md

@@ -83,6 +83,18 @@ verbatim. **A zero result was recording the matcher's limits while being read as
 ⭐ On a zero result the response now names **which terms appear in no document at all**
 (`absent_terms`), so a dead end says something instead of nothing.
 
+⭐ **Diacritics are optional.** `metta` finds what `mettā` finds, and `Tonle Sap` reaches the
+text that writes `Tonlé Sap` — before 2.4.1 a plain-ASCII query found 6 documents where the
+marked one found 20. ⛔ **Fold to match, serve verbatim:** the fold touches only what is
+compared, and every excerpt carries the corpus's own spelling, because a Pāli or Sanskrit
+spelling is a tradition marker rather than a typo. Only Latin combining diacritics are folded;
+Khmer and Burmese vowel signs are marks too, and are left exactly as written.
+
+⭐ **Every result says it is an excerpt.** The text ends with a line naming how many of the
+matches it shows and the `read_documents` call that reads those documents in full. It sits in
+the result rather than only in the server's instructions, because a result reaches the model in
+every client, at the moment it decides whether to keep reading.
+
 ### Reading a whole shelf
 
 ⭐ **Search answers from excerpts, and a model answers from what it opened.** A frontier
@@ -101,8 +113,15 @@ corpus already fits one — but a way to read the shelf.
 - **Paged by size.** `max_bytes` defaults to 90,000 (under the 25,000-token point at which
   Claude Code moves a tool result into a file) and may go to 400,000. **A document is never
   split** — half a document verifies nothing — so one larger than the page arrives alone and
-  says `over_budget`. Follow `next_cursor`; a cursor from a different corpus version is refused
-  rather than serving page 2 of another corpus.
+  says so in its `[PAGE]` line. That last block names the cursor for the next page; a cursor from a
+  different corpus version is refused rather than serving page 2 of another corpus.
+- **`list_documents` says how to read what it listed:** `read_with` carries the same filters as
+  `read_documents` arguments.
+
+⚠️ **The server can point; it cannot make a model read.** Its instructions say *for a broad
+question, read the relevant shelf in full* — deliberately conditional, because a whole shelf read
+to answer a one-fact question is slower, costlier and often worse. Clients differ in whether they
+show server instructions at all, which is why the pointers also live in the results.
 
 ⭐ **Every document ends with an `[END OF DOCUMENT — <slug> · <n> words]` line**, by every
 route. The server never cuts a document, but a client may, and a cut document reads as a
@@ -176,15 +195,23 @@ hands every consumer an obligation nobody can discharge, so **the build fails**
 rather than serving it — the same reasoning as the licence gate: a property, not a
 rule someone has to remember.
 
-**Results are structured.** Every tool returns `structuredContent` — the typed
-object — and uses `content` for the human form: the document text with its
-provenance header for `get_document`, readable excerpts for `search_corpus`, a
-compact serialisation for the rest. ⛔ **Nothing is sent twice.** The spec's
-back-compat advice is to serialise the JSON into `content` as well; measured, that
-doubles every response (1.76×–2.00×), so this server splits by role instead —
-`content` is read, `structuredContent` is validated, and the two carry different
-things. `outputSchema` is deliberately not declared yet: a schema binds the server
-on every future change, and the envelope is still moving.
+**Documents come as text; everything else is structured.** `get_document` and
+`read_documents` return **`content` only** — each document behind its provenance header
+and ending at its `[END OF DOCUMENT]` line. The other tools return `structuredContent`
+(the typed object) plus a readable or compact `content`, and anything a reader needs —
+search's `reading` line included — is in the structured part.
+
+⛔⛔ **Why the document tools carry no `structuredContent` (2.4.2).** From 2.0.0 to 2.4.1
+they split by role: text in `content`, the envelope *without the body* in
+`structuredContent`. A Claude client shown a result that carries `structuredContent` hands its
+model **only that part** — so for eleven days **no document text reached any Claude-based
+reader**, while every check here passed, because every check read the server's output
+directly rather than through a client. The MCP spec assumes the two parts carry the same
+information; a server that splits them is at the mercy of whichever part a client picks. The
+document is the payload and its provenance already rides in the header, so the document tools
+now send the text and nothing else — and `check-parity` fails if either ever carries
+`structuredContent` again. `outputSchema` is deliberately not declared: a schema binds the server
+on every future change.
 
 **Text is returned verbatim and is never summarised.** Not a stylistic
 preference — a summary cannot be hash-verified, so summarising at the server

package/dist/corpus.json

@@ -1,5 +1,5 @@
 {
-  "package_version": "2.4.0",
+  "package_version": "2.4.2",
   "generated_from": [
     "H3/publications",
     "TH/publications",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@333eco/corpus",
-    "version": "2.4.0",
+    "version": "2.4.2",
     "description": "An MCP server for an open-licensed corpus, served with verifiable provenance — every document carries its sha256, DOI and OpenTimestamps proof so a consuming agent can check its own citation.",
     "license": "CC0-1.0",
     "author": "Thon Ly",

package/src/base-tools.mjs

@@ -27,9 +27,9 @@ export const BASE_TOOLS = [
         title: "Search the corpus",
         annotations: { ...READ_ONLY, title: "Search the corpus" },
         description:
-            "Full-text search across the open-licensed corpus. Returns matching documents with a provenance envelope " +
-            "and a short excerpt around each match — not the full text; call get_document for that. Every result can " +
-            "be independently verified via its sha256, DOI and OpenTimestamps proof.",
+            "Full-text search across the open-licensed corpus; diacritics are optional. Returns matching documents with " +
+            "a provenance envelope and a short excerpt around each match — not the full text; read_documents or " +
+            "get_document return that. Every result can be verified via its sha256, DOI and OpenTimestamps proof.",
         inputSchema: {
             type: "object",
             properties: {

package/src/read-tools.mjs

@@ -43,7 +43,7 @@ export const READ_TOOLS = [
         // facets are described once, on list_documents.
         description:
             "Whole documents, never summarised: those matching the list_documents filters, or the given slugs. " +
-            "One content block each. Paged: follow next_cursor.",
+            "One content block each; the last block names the cursor for the next page.",
         inputSchema: {
             type: "object",
             properties: {
@@ -65,9 +65,27 @@ export const READ_TOOLS = [
 
 export const READ_TOOL_NAMES = READ_TOOLS.map((t) => t.name);
 
+// ⚠️ CONDITIONAL ON PURPOSE (2.4.1). "Prefer read_documents" unqualified would send a model to
+// read a 260,000-token shelf to answer a one-fact question — slower, costlier and often worse.
+// ⛔ It names shelves by their facets (list_documents' own vocabulary), never by what the
+// documents say: describing the API, not the subject matter.
 export const READ_INSTRUCTIONS =
-    " Search returns excerpts; to answer broadly, read whole documents with read_documents. Every document ends " +
-    "with an [END OF DOCUMENT] line — if it is missing, the text was cut short.";
+    " For a broad question, read the relevant shelf in full: choose it with list_documents, read it with " +
+    "read_documents. Search returns excerpts, suited to finding one passage. Every document ends with an " +
+    "[END OF DOCUMENT] line; if it is missing, the text was cut short.";
+
+/**
+ * list_documents' pointer to reading what it just listed: the same filters, as arguments
+ * read_documents accepts. Only the facets actually given, so the pointer reads back exactly.
+ */
+export const readWith = (args, count) =>
+    count
+        ? {
+              tool: "read_documents",
+              arguments: Object.fromEntries(["genre", "category", "voice", "licence"].filter((k) => args?.[k]).map((k) => [k, args[k]])),
+              note: "Reads every document listed here in full, paged by size."
+          }
+        : null;
 
 // ⚠️ The cursor carries the INDEX VERSION as well as the offset. Pages are offsets
 // into a list, and a list read across a redeploy is two lists: without the version
@@ -92,9 +110,9 @@ const decodeCursor = (cursor, version) => {
 
 /**
  * read_documents. `ctx` is what differs between the surfaces:
- * { documents, bySlug, envelope, version }.
+ * { documents, bySlug, version }.
  */
-export const readDocuments = ({ documents, bySlug, envelope, version }, args) => {
+export const readDocuments = ({ documents, bySlug, version }, args) => {
     const hasFilter = ["genre", "category", "voice", "licence"].some((k) => args?.[k]);
     let matched;
     if (args?.slugs !== undefined) {
@@ -131,43 +149,34 @@ export const readDocuments = ({ documents, bySlug, envelope, version }, args) =>
     const next = nextOffset < matched.length ? encodeCursor(version, nextOffset) : undefined;
 
     if (!matched.length) {
-        return {
-            content: [{ type: "text", text: "no documents match these filters. Call list_documents to see the facets and their counts." }],
-            structuredContent: { matched: 0, returned: 0, offset: 0, page_bytes: 0, max_bytes: budget, documents: [] }
-        };
+        return { content: [{ type: "text", text: "no documents match these filters. Call list_documents to see the facets and their counts." }] };
     }
 
+    // ⛔⛔ TEXT ONLY — NO structuredContent (2.4.2, founder-ruled 2026-09-13). A Claude client shown a
+    // result that carries structuredContent hands its model ONLY that part; the envelope-without-body
+    // shape this tool shipped with in 2.4.0 therefore delivered no document to any Claude-based reader
+    // (§the-text-never-arrived). The document IS the payload, and the provenance already rides in each
+    // document's header, so the structured copy bought validation for programs at the price of the
+    // text for models. Everything a reader needs to keep going is in the [PAGE] line.
     const content = page.map((p) => ({ type: "text", text: p.text }));
-    // The one block that is not a document: what a reader of `content` alone needs in
-    // order to keep going, or to know it has everything.
+    const over = page.length === 1 && used > budget ? " This document is larger than max_bytes and was returned whole rather than split." : "";
     content.push({
         type: "text",
         text: next
-            ? `[PAGE — documents ${start + 1}–${nextOffset} of ${matched.length}. ${matched.length - nextOffset} more: call read_documents again with the same arguments and cursor "${next}".]`
-            : `[PAGE — documents ${start + 1}–${nextOffset} of ${matched.length}. That is every matching document.]`
+            ? `[PAGE — documents ${start + 1}–${nextOffset} of ${matched.length}.${over} ${matched.length - nextOffset} more: call read_documents again with the same arguments and cursor "${next}".]`
+            : `[PAGE — documents ${start + 1}–${nextOffset} of ${matched.length}.${over} That is every matching document.]`
     });
+    return { content };
+};
 
-    return {
-        content,
-        structuredContent: {
-            matched: matched.length,
-            returned: page.length,
-            offset: start,
-            page_bytes: used,
-            max_bytes: budget,
-            ...(page.length === 1 && used > budget ? { over_budget: "one document larger than max_bytes, returned whole rather than split" } : {}),
-            ...(next ? { next_cursor: next } : {}),
-            documents: page.map((p) => ({
-                ...envelope(p.d),
-                genre: p.d.genre,
-                category: p.d.category,
-                voice: p.d.voice,
-                bytes: p.d.bytes,
-                words: p.d.words,
-                text_in: "content, one block per document in this order, each prefixed by its provenance header"
-            }))
-        }
-    };
+/**
+ * get_document — shared by both surfaces since 2.4.2, TEXT ONLY for the same reason as read_documents:
+ * the envelope-without-body in structuredContent was the only part a Claude client showed its model.
+ */
+export const getDocument = ({ bySlug }, args) => {
+    const d = bySlug.get(String(args?.slug ?? ""));
+    if (!d) throw new Error(`no document with slug "${args?.slug}". Call list_documents to see what is available.`);
+    return { content: [{ type: "text", text: documentText(d) }] };
 };
 
 /**

package/src/search.mjs

@@ -1,8 +1,8 @@
 // How `search_corpus` decides a document matches.
 //
-// ⭐⭐ SHARED, AND IT HAS TO BE. The two surfaces keep their own `callTool` on
-// purpose — twenty lines each, diffable by eye. Matching is not that: it is
-// ranking, tokenising and window-finding, and if the stdio server and the worker
+// ⭐⭐ SHARED, AND IT HAS TO BE — matching and, since 2.4.1, the whole search_corpus
+// tool (see searchCorpus below). Matching is ranking, tokenising and window-finding, and
+// if the stdio server and the worker
 // ever disagreed about which documents answer a query, the corpus would have two
 // opinions about itself. That is the same failure `sync.mjs` exists to prevent,
 // arriving through the search path instead of the data path.
@@ -33,15 +33,49 @@
 // any document containing "b" and "heart" separately — precision traded away for
 // nothing, in the corpus where those marks matter most.
 
+import { structuredWithText } from "./results.mjs";
+
 const TOKEN = /[\p{L}\p{N}]+(?:['’-][\p{L}\p{N}]+)*/gu;
 
+// ⭐⭐ DIACRITICS ARE OPTIONAL IN A QUERY (2.4.1). A model types `metta`; the corpus writes
+// `mettā`. Without a fold that search found 6 documents against 20, and `Tonle Sap` found none
+// — a reader typing plain ASCII, which is most of them, silently missed most of the Pāli
+// material. ⛔ FOLD TO MATCH, SERVE VERBATIM: the spelling is a tradition marker (Pāli for a
+// Theravāda citation, Sanskrit for a Hindu one), so the fold touches only what is COMPARED —
+// every excerpt is cut from the original text.
+// ⚠️ LENGTH-PRESERVING, character by character, so a position in the folded text is the same
+// position in the original and the excerpt window lands where the match is. Only Latin
+// combining diacritics (U+0300–U+036F) are removed, and only where the base letter survives
+// as one character: Khmer and Burmese vowel signs are marks too, and stripping them would
+// make Khmer text match what it does not say.
+const LATIN_MARKS = /[\u0300-\u036f]/g;
+const foldChar = (c) => {
+    const f = c.normalize("NFD").replace(LATIN_MARKS, "");
+    return f.length === c.length ? f : c;
+};
+export const fold = (s) => String(s ?? "").replace(/[^\x00-\x7f]/gu, foldChar);
+
+// The folded, lowercased body, computed once per document text rather than on every search.
+// Keyed by the string itself: the corpus holds one string per document for the life of the
+// process, so the cache is bounded by the corpus.
+const HAY = new Map();
+const hayOf = (body) => {
+    let h = HAY.get(body);
+    if (h === undefined) {
+        h = fold(body.toLowerCase());
+        HAY.set(body, h);
+    }
+    return h;
+};
+const foldQuery = (query) => fold(String(query ?? "").normalize("NFC").toLowerCase());
+
 // Dropped only when something survives the dropping. These are words present in
 // essentially every document, so they never narrow the result set — but they do
 // wreck the tightest-window calculation, because an "and" is always close by.
 const STOP = new Set(["a", "an", "and", "as", "at", "be", "by", "for", "from", "in", "is", "it", "of", "on", "or", "the", "to", "with"]);
 
 export const terms = (query) => {
-    const all = String(query ?? "").toLowerCase().match(TOKEN) ?? [];
+    const all = foldQuery(query).match(TOKEN) ?? [];
     const kept = all.filter((t) => !STOP.has(t));
     return kept.length ? kept : all;
 };
@@ -138,8 +172,8 @@ const tightestWindow = (lists) => {
 // term match's excerpt may NOT contain the literal query, and a caller reading
 // an excerpt deserves to know which question it answered.
 export const match = (body, query, span = 320) => {
-    const hay = body.toLowerCase();
-    const phrase = String(query ?? "").toLowerCase().trim();
+    const hay = hayOf(body);
+    const phrase = foldQuery(query).trim();
 
     if (phrase) {
         const i = hay.indexOf(phrase);
@@ -175,6 +209,60 @@ export const rank = (hits, limit) =>
 export const absentTerms = (documents, query) => {
     const ts = [...new Set(terms(query))];
     if (ts.length === 0) return [];
-    const hays = documents.map((d) => d.text.toLowerCase());
+    const hays = documents.map((d) => hayOf(d.text));
     return ts.filter((t) => !hays.some((h) => h.includes(t)));
 };
+
+/* ---------------------------------------------------------- search_corpus ---
+   ⭐ THE WHOLE TOOL, SHARED (2.4.1). It lived twice, once in each surface's callTool, and
+   its guidance line was about to be written twice too — the shape in which the envelope
+   drifted. One function, imported by both. */
+
+// A search returns EXCERPTS, and a model that reads only excerpts answers from them. So the
+// text a model reads says so at the moment it decides what to do next — in the result, where
+// every client delivers it, rather than only in server instructions a client may drop.
+const readingLine = (results, matches) => {
+    const slugs = results.map((r) => r.slug);
+    return (
+        `[Showing ${results.length} of ${matches} matching document${matches === 1 ? "" : "s"}, as excerpts. ` +
+        `To answer from the full texts, call read_documents with slugs ${JSON.stringify(slugs)}` +
+        (matches > results.length ? `; raise limit to see more of the ${matches} matches` : "") +
+        ".]"
+    );
+};
+
+export const searchCorpus = ({ documents, envelope }, args) => {
+    const q = String(args?.query ?? "");
+    if (!q) throw new Error("query is required");
+    const pool = documents.filter((d) => !args?.genre || d.genre === args.genre);
+    const hits = pool.map((d) => ({ d, m: match(d.text, q) })).filter((h) => h.m !== null);
+    const results = rank(hits, Number(args?.limit ?? 10)).map((h) => ({
+        ...envelope(h.d),
+        genre: h.d.genre,
+        excerpt: h.m.excerpt,
+        // ⭐ HOW it matched, not just that it did: a "terms" excerpt need not
+        // contain the literal query, and a caller reading it should know
+        // which question the excerpt is answering.
+        match: h.m.mode
+    }));
+    // ⚠️ `matches` is the TOTAL found, not the number returned — it used to be
+    // capped at `limit`, which made "10 matches" and "at least 10 matches"
+    // indistinguishable. `returned` carries the capped count.
+    const absent = hits.length ? [] : absentTerms(pool, q);
+    const readable = results.length
+        ? results.map((h) => `${h.slug} — ${h.title}${h.match === "terms" ? "  [all terms, not the phrase]" : ""}\n  ${h.excerpt}`).join("\n\n") +
+          "\n\n" + readingLine(results, hits.length)
+        : absent.length
+          ? `no document matches "${q}". No document contains: ${absent.join(", ")}.`
+          : `no document matches "${q}" — every term appears somewhere, but no single document holds them all. Try fewer terms.`;
+    return structuredWithText(readable, {
+        query: q,
+        matches: hits.length,
+        returned: results.length,
+        // ⛔ 2.4.2: the reading line was in `content` only, and a Claude client shows its model only
+        // structuredContent — so the 2.4.1 nudge reached no Claude reader. It rides here too.
+        ...(results.length ? { reading: readingLine(results, hits.length) } : {}),
+        ...(absent.length ? { absent_terms: absent } : {}),
+        results: results
+    });
+};

package/src/server.mjs

@@ -35,14 +35,13 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";
 import { RESOURCE_TEMPLATES, listResources, readResource, completeArgument } from "./resources.mjs";
-import { structured, structuredWithText } from "./results.mjs";
-import { documentText } from "./resources.mjs";
+import { structured } from "./results.mjs";
 import { envelope } from "./envelope.mjs";
 import { PROMPTS, getPrompt } from "./prompts.mjs";
 import { BASE_TOOLS, withFacets } from "./base-tools.mjs";
-import { READ_TOOLS, READ_TOOL_NAMES, READ_INSTRUCTIONS, filterDocuments, readDocuments, completenessOf, manifestProblems } from "./read-tools.mjs";
+import { READ_TOOLS, READ_TOOL_NAMES, READ_INSTRUCTIONS, filterDocuments, readDocuments, getDocument, readWith, completenessOf, manifestProblems } from "./read-tools.mjs";
 import { PROGRAM_TOOLS, PROGRAM_TOOL_NAMES, PROGRAM_INSTRUCTIONS, callProgramTool } from "./program-tools.mjs";
-import { match, rank, absentTerms } from "./search.mjs";
+import { searchCorpus } from "./search.mjs";
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const INDEX = resolve(HERE, "..", "dist", "corpus.json");
@@ -121,77 +120,17 @@ const text = (value) => ({ content: [{ type: "text", text: typeof value === "str
 
 const callTool = (name, args) => {
     if (name === "search_corpus") {
-        const q = String(args?.query ?? "");
-        if (!q) throw new Error("query is required");
-        const pool = corpus.documents.filter((d) => !args?.genre || d.genre === args.genre);
-        const hits = pool.map((d) => ({ d, m: match(d.text, q) })).filter((h) => h.m !== null);
-        const results = rank(hits, Number(args?.limit ?? 10)).map((h) => ({
-            ...envelope(h.d),
-            genre: h.d.genre,
-            excerpt: h.m.excerpt,
-            // ⭐ HOW it matched, not just that it did: a "terms" excerpt need not
-            // contain the literal query, and a caller reading it should know
-            // which question the excerpt is answering.
-            match: h.m.mode
-        }));
-        // ⚠️ `matches` is the TOTAL found, not the number returned — it used to be
-        // capped at `limit`, which made "10 matches" and "at least 10 matches"
-        // indistinguishable. `returned` carries the capped count.
-        const absent = hits.length ? [] : absentTerms(pool, q);
-        const readable = results.length
-            ? results.map((h) => `${h.slug} — ${h.title}${h.match === "terms" ? "  [all terms, not the phrase]" : ""}\n  ${h.excerpt}`).join("\n\n")
-            : absent.length
-              ? `no document matches "${q}". No document contains: ${absent.join(", ")}.`
-              : `no document matches "${q}" — every term appears somewhere, but no single document holds them all. Try fewer terms.`;
-        return structuredWithText(readable, {
-            query: q,
-            matches: hits.length,
-            returned: results.length,
-            ...(absent.length ? { absent_terms: absent } : {}),
-            results: results
-        });
+        // Shared with the other surface (search.mjs): the answer, the excerpts and the
+        // reading line cannot differ between them.
+        return searchCorpus({ documents: corpus.documents, envelope }, args);
     }
 
     if (name === "get_document") {
-        const d = bySlug.get(String(args?.slug ?? ""));
-        if (!d) throw new Error(`no document with slug "${args?.slug}". Call list_documents to see what is available.`);
-        // ⭐ The document goes to `content` WITH ITS PROVENANCE HEADER — the same
-        // bytes resources/read returns, so the two doors into a document agree —
-        // and the envelope goes to `structuredContent` WITHOUT the body. Split by
-        // role; nothing is sent twice.
-        return structuredWithText(documentText(d), {
-            ...envelope(d),
-            genre: d.genre,
-            bytes: d.bytes,
-            words: d.words,
-            // ⚠️ category and voice were in list_documents and NOT here, so a
-            // caller who fetched ONE document could not see the facets it had
-            // just filtered on — the discovery call and the read call disagreed
-            // about what a document is. Both are cheap strings; the reason the
-            // body is excluded (it is in `content`, never sent twice) does not
-            // apply to them.
-            category: d.category,
-            voice: d.voice,
-            repo: d.repo,
-            path: d.path,
-            metadata_convention: d.metadata_convention,
-            // ⚠️ PRESENT ONLY WHERE THEY MEAN SOMETHING, and dropping them was a
-            // real bug: `editorial` is what tells a consumer that the inline
-            // [VERBATIM]/[SCAFFOLD] markers in `text` are a convention rather
-            // than noise, and `segments` is the same split structurally. The
-            // markers alone are the load-bearing half — they survive quotation —
-            // but shipping them with nothing that explains them made the
-            // convention look like an artefact of bad extraction.
-            ...(d.editorial ? { editorial: d.editorial } : {}),
-            ...(d.segments ? { segments: d.segments } : {}),
-            // ⚠️ Deliberately absent: the body is in `content`. Carrying it here
-            // too is the duplication this shape exists to avoid.
-            text_in: "content[0].text, prefixed by the provenance header and ending at its [END OF DOCUMENT] line"
-        });
+        // Shared (read-tools.mjs), and TEXT ONLY since 2.4.2 — see §the-text-never-arrived there.
+        return getDocument({ bySlug: bySlug }, args);
     }
-
     if (name === "read_documents") {
-        return readDocuments({ documents: corpus.documents, bySlug, envelope, version: String(corpus.package_version ?? "") }, args);
+        return readDocuments({ documents: corpus.documents, bySlug, version: String(corpus.package_version ?? "") }, args);
     }
 
     if (name === "list_documents") {
@@ -233,6 +172,8 @@ const callTool = (name, args) => {
             ...(corpus.voices ? { voices: corpus.voices } : {}),
             // A87: the manifest's counts and reasons beside the listing they account for.
             ...(corpus.manifest ? { completeness: completenessOf(corpus) } : {}),
+            // 2.4.1: what to call to read this listing in full — the same filters, as arguments.
+            ...(readWith(args, list.length) ? { read_with: readWith(args, list.length) } : {}),
             documents: list
         });
     }