crawlforge-mcp-server 6.22.2 → 6.23.0

package/src/tools/scrape/_mainContent.js

@@ -44,6 +44,7 @@
 import { JSDOM } from 'jsdom';
 import { Readability } from '@mozilla/readability';
 import { load } from 'cheerio';
+import { normalizeCodeBlocks } from '../../utils/htmlToMarkdown.js';
 
 // How much of a table's text is compared against the article to decide whether
 // Readability already kept it. Long enough to be unique to that table.
@@ -177,6 +178,68 @@ export function unwrapMediaWikiHeadings(document) {
   }
 }
 
+// Readability's `byline` regex. The first element matching it (or carrying
+// rel="author" / itemprop="author") under 100 characters is taken as the
+// article's byline and deleted from the content.
+const BYLINE = /byline|author|dateline|writtenby|p-author/i;
+
+// A list page repeats one item markup: 10 `div.quote`, 20 `li.product`. Items
+// shorter than this are menu entries or tag-cloud links, not content.
+const MIN_LIST_ITEMS = 5;
+const MIN_ITEM_CHARS = 40;
+
+/**
+ * The repeated items of a list page in a DOM document: the children of one
+ * parent that share a tag and class, when there are at least MIN_LIST_ITEMS
+ * of them with MIN_ITEM_CHARS of text each.
+ * @param {Document} document
+ * @returns {Element[]}
+ */
+function repeatedItems(document) {
+  const items = [];
+  for (const parent of Array.from(document.querySelectorAll('body, body *'))) {
+    const groups = new Map();
+    for (const child of Array.from(parent.children)) {
+      const className = (child.getAttribute('class') || '').trim();
+      if (!className) continue;
+      const key = `${child.tagName} ${className}`;
+      groups.set(key, [...(groups.get(key) || []), child]);
+    }
+    for (const group of groups.values()) {
+      if (group.length < MIN_LIST_ITEMS) continue;
+      const substantial = group.filter((el) => normalizeWhitespace(el.textContent || '').length >= MIN_ITEM_CHARS);
+      if (substantial.length >= MIN_LIST_ITEMS) items.push(...substantial);
+    }
+  }
+  return items;
+}
+
+/**
+ * Stop Readability taking an author line inside a list item as the page's
+ * byline. It deletes the first byline-like element it meets, so on
+ * quotes.toscrape.com the first quote lost its author ("…our thinking.” by
+ * (about)") from every main-content read (live sweep, 2026-10-20). A byline
+ * belongs to an article, not to one entry of a list, so the attributes that
+ * mark one are stripped from nodes inside repeated items.
+ *
+ * @param {Document} document - mutated in place
+ */
+export function keepListItemBylines(document) {
+  for (const item of repeatedItems(document)) {
+    for (const el of Array.from(item.querySelectorAll('*'))) {
+      if (el.getAttribute('rel') === 'author') el.removeAttribute('rel');
+      if ((el.getAttribute('itemprop') || '').includes('author')) el.removeAttribute('itemprop');
+      if (BYLINE.test(el.id || '')) el.removeAttribute('id');
+      const className = el.getAttribute('class');
+      if (className && BYLINE.test(className)) {
+        const kept = className.split(/\s+/).filter((token) => token && !BYLINE.test(token));
+        if (kept.length > 0) el.setAttribute('class', kept.join(' '));
+        else el.removeAttribute('class');
+      }
+    }
+  }
+}
+
 /**
  * Readability's own data-table test (`_markDataTables`): 10+ rows or more than
  * 4 columns means the table carries data rather than layout, counting
@@ -309,9 +372,11 @@ export function extractMainContent(html, url) {
   if (tooLargeForReadability(html)) return { html: null, title: '', tablesRecovered: 0, tooLarge: true };
   let article;
   try {
-    const dom = new JSDOM(html, { url });
+    // Readability strips classes, so code-block languages move to data attributes first.
+    const dom = new JSDOM(normalizeCodeBlocks(html), { url });
     sanitizeAccidentalClasses(dom.window.document);
     unwrapMediaWikiHeadings(dom.window.document);
+    keepListItemBylines(dom.window.document);
     article = new Readability(dom.window.document).parse();
   } catch {
     return { html: null, title: '', tablesRecovered: 0 };
@@ -356,8 +421,8 @@ export function keepPageHeading(mainHtml, $) {
 }
 
 // Below both of these, Readability's article is a fragment of the page, not
-// its main content.
-export const THIN_MAIN_CONTENT = { maxChars: 1500, maxShare: 0.35 };
+// its main content. On a list page the bar is a share of `listMaxShare`.
+export const THIN_MAIN_CONTENT = { maxChars: 1500, maxShare: 0.35, listMaxShare: 0.6 };
 
 function visibleTextLength(html) {
   const $ = load(html);
@@ -379,10 +444,36 @@ function visibleTextLength(html) {
  */
 export function isThinMainContent(mainHtml, pageHtml) {
   const kept = visibleTextLength(mainHtml || '');
-  if (kept >= THIN_MAIN_CONTENT.maxChars) return null;
   const visible = visibleTextLength(pageHtml || '');
-  if (visible === 0 || kept / visible >= THIN_MAIN_CONTENT.maxShare) return null;
-  return { kept, visible };
+  if (visible === 0) return null;
+  const share = kept / visible;
+  if (kept < THIN_MAIN_CONTENT.maxChars && share < THIN_MAIN_CONTENT.maxShare) return { kept, visible };
+  // A list page's items are its content, and Readability scores them one
+  // block at a time: scrape_with_actions' text lost 3 of quotes.toscrape.com's
+  // 10 quotes (live sweep, 2026-10-20). Keeping much less than the page has
+  // there means items were pruned, not chrome.
+  if (share < THIN_MAIN_CONTENT.listMaxShare && isListPage(pageHtml)) return { kept, visible };
+  return null;
+}
+
+/**
+ * True when `html` repeats one item markup MIN_LIST_ITEMS+ times with
+ * MIN_ITEM_CHARS of text each — repeatedItems' test, on a cheerio parse.
+ * @param {string} html
+ */
+function isListPage(html) {
+  const $ = load(html);
+  return $('body, body *').toArray().some((parent) => {
+    const groups = new Map();
+    for (const child of $(parent).children().toArray()) {
+      const className = ($(child).attr('class') || '').trim();
+      if (!className) continue;
+      const key = `${child.name} ${className}`;
+      groups.set(key, [...(groups.get(key) || []), child]);
+    }
+    return Array.from(groups.values()).some((group) => group.length >= MIN_LIST_ITEMS &&
+      group.filter((el) => normalizeWhitespace($(el).text()).length >= MIN_ITEM_CHARS).length >= MIN_LIST_ITEMS);
+  });
 }
 
 export default extractMainContent;

package/src/tools/search/adapters/dataforseoSearch.js

@@ -155,7 +155,10 @@ export class DataForSEOSearchAdapter {
         device,
         depth,
         organicCount: items.length,
-        seResultsCount: result0?.se_results_count ?? null,
+        // Google's "About N results" total. Mobile SERPs (and many desktop
+        // ones) show no total, and DataForSEO then reports 0; a 0 beside
+        // organic results is unknown, not zero.
+        seResultsCount: result0?.se_results_count === 0 && items.length > 0 ? null : result0?.se_results_count ?? null,
         checkUrl: result0?.check_url ?? null, // Google URL to eyeball the real SERP
         cost: data.cost ?? task0.cost ?? null, // USD charged by DataForSEO for this call
       },

package/src/tools/search/searchWeb.js

@@ -84,6 +84,8 @@ const SearchWebSchema = z.object({
 // never costs an extra backend search.
 const DEDUPE_OVERFETCH = 4;
 const GOOGLE_MAX_RESULTS_PER_REQUEST = 10;
+// Deepest SearXNG page _executeViaSearxng reads to reach an offset.
+const SEARXNG_MAX_PAGES = 5;
 
 /**
  * Index, in the provider's page, of the first item this response does not
@@ -348,7 +350,9 @@ export class SearchWebTool {
       // Where the next page starts. Deduplication backfills this page from
       // the over-fetched margin, so the next page begins after the first
       // provider item NOT shown here, not at offset + limit (which repeated
-      // the backfilled items on the next page).
+      // the backfilled items on the next page). So next_offset is offset +
+      // the provider items this page consumed, duplicates included: 5 results
+      // with next_offset 6 means one of items 0..5 was a duplicate.
       const nextOffset = localizedParams.offset + firstUnshownIndex(
         processedResults,
         localizedParams.limit,
@@ -469,17 +473,38 @@ export class SearchWebTool {
    * @returns {Promise<Object>} Standard search_web response object
    */
   async _executeViaSearxng(validated) {
-    // page is 1-based; offset is 0-based items, so map via limit
-    const page = Math.floor(validated.offset / validated.limit) + 1;
-
-    const adapterResult = await searchViaSearxng({
-      query: validated.query,
-      // SearXNG returns a whole page per request, so the dedup margin is free.
-      limit: validated.limit + DEDUPE_OVERFETCH,
-      page,
-      safeSearch: validated.safe_search,
-      language: validated.lang
-    });
+    // SearXNG is addressed by page, and its page size is set by the instance
+    // and its engines, not by `limit`. So `offset` counts items in SearXNG's
+    // result stream: read pages 1, 2, ... until the window
+    // [offset, offset + limit + margin) is covered, a page adds no new URL
+    // (end of results, or an instance that repeats a page), or the page cap.
+    const wanted = validated.offset + validated.limit + DEDUPE_OVERFETCH;
+    const stream = [];
+    const seen = new Set();
+    let firstPage = null;
+    for (let page = 1; page <= SEARXNG_MAX_PAGES && stream.length < wanted; page++) {
+      let pageResult;
+      try {
+        pageResult = await searchViaSearxng({
+          query: validated.query,
+          limit: Number.MAX_SAFE_INTEGER, // keep the whole page
+          page,
+          safeSearch: validated.safe_search,
+          language: validated.lang
+        });
+      } catch (error) {
+        if (page === 1) throw error;
+        break; // a later page failing ends the stream; keep what was read
+      }
+      firstPage ??= pageResult;
+      const fresh = (pageResult.items || []).filter(item => !seen.has(item.link) && seen.add(item.link));
+      if (fresh.length === 0) break;
+      stream.push(...fresh);
+    }
+    const adapterResult = {
+      ...firstPage,
+      items: stream.slice(validated.offset, wanted)
+    };
 
     // Run through shared post-processing (deduplication, ranking)
     let processedResults = await this.processResults(adapterResult);
@@ -503,6 +528,14 @@ export class SearchWebTool {
       };
     }
 
+    // Same rule as execute(): the next page starts at the first stream item
+    // this page does not show, so duplicates removed here are not re-read.
+    const nextOffset = validated.offset + firstUnshownIndex(
+      processedResults,
+      validated.limit,
+      adapterResult.items.length
+    );
+
     // Drop the over-fetched margin (see execute()).
     if (processedResults.length > validated.limit) {
       processedResults = processedResults.slice(0, validated.limit);
@@ -541,9 +574,7 @@ export class SearchWebTool {
       search_time: adapterResult.searchInformation?.searchTime || 0,
       offset: validated.offset,
       limit: validated.limit,
-      // SearXNG is paged (offset maps to page floor(offset/limit)+1), so the
-      // next page starts at the next multiple of limit.
-      next_offset: page * validated.limit,
+      next_offset: nextOffset,
       cached: false,
       provider: {
         name: 'searxng',

package/src/tools/search/serpRank.js

@@ -179,7 +179,7 @@ export class SerpRankTool {
       device: meta.device,
       depthScanned: meta.depth,
       organicResults: meta.organicCount,
-      seResultsCount: meta.seResultsCount,
+      seResultsCount: meta.seResultsCount ?? undefined, // omitted when unknown (see the adapter)
       checkUrl: meta.checkUrl, // link to view the real SERP
       cost: meta.cost, // USD charged by DataForSEO for this lookup
       checkedAt: new Date().toISOString(),

package/src/tools/tracking/trackChanges/index.js

@@ -304,6 +304,7 @@ export class TrackChangesTool extends EventEmitter {
       details: comparisonResult.details,
       metrics: comparisonResult.metrics,
       recommendations: comparisonResult.recommendations,
+      ...(comparisonResult.ignoredOptions ? { ignoredOptions: comparisonResult.ignoredOptions } : {}),
       ...(comparisonResult.warnings || fetchWarnings.length
         ? { warnings: [...(comparisonResult.warnings || []), ...fetchWarnings] }
         : {}),

package/src/tools/tracking/trackChanges/schema.js

@@ -41,7 +41,7 @@ export const TRACK_CHANGES_INPUT_SHAPE = {
     // filled in here is indistinguishable from a value the caller passed, so
     // it overrode the template (R24 2.7). ChangeTracker applies these same
     // defaults when the baseline is created.
-    granularity: z.enum(['page', 'section', 'element', 'text']).optional().describe("Default: section"),
+    granularity: z.enum(['page', 'section', 'element', 'text']).optional().describe("Default: section. Fixed when the baseline is created: a compare always diffs at the baseline's granularity (as with customSelectors and excludeSelectors), and one that asks for a different value gets ignoredOptions:[{option, requested, applied}] plus a warnings entry. Recreate the baseline to change it"),
     trackText: z.boolean().optional().describe("Default: true"),
     trackStructure: z.boolean().optional().describe("Default: true"),
     trackAttributes: z.boolean().default(false),
@@ -49,6 +49,7 @@ export const TRACK_CHANGES_INPUT_SHAPE = {
     trackLinks: z.boolean().optional().describe("Default: true"),
     ignoreWhitespace: z.boolean().optional().describe("Default: true"),
     ignoreCase: z.boolean().optional().describe("Default: false"),
+    includeMarkupChanges: z.boolean().optional().describe("Also return details.markupChanges, a diff of the raw HTML (tags, classes, attributes). details.textChanges always diffs the visible text only. Default: false"),
     customSelectors: z.array(z.string()).optional(),
     excludeSelectors: z.array(z.string()).optional().default([
       'script', 'style', 'noscript', '.advertisement', '.ad', '#comments'

package/src/utils/htmlToMarkdown.js

@@ -52,6 +52,63 @@ export function promoteCornerHeaderCells(html) {
   }
 }
 
+const SKIP_LANGUAGES = new Set(['default', 'none']);
+
+/**
+ * Find a code block's language in the markup that names it: `data-language`,
+ * a `language-x`/`lang-x` class, MDN's `brush: x` class, a Sphinx
+ * `highlight-x` wrapper, or MDN's `.example-header .language-name` label.
+ * @param {import('cheerio').Cheerio<any>} pre
+ * @returns {string}
+ */
+function codeLanguage(pre) {
+  const code = pre.children('code').first();
+  const fromData = pre.attr('data-language') || code.attr('data-language');
+  if (fromData) return fromData;
+  for (const cls of [code.attr('class'), pre.attr('class')]) {
+    const m = /(?:^|\s)(?:language|lang)-([\w+#.-]+)/.exec(cls || '') || /brush:\s*([\w+#.-]+)/.exec(cls || '');
+    if (m) return m[1];
+  }
+  const wrapper = pre.closest('[class*="highlight-"]');
+  const m = /(?:^|\s)highlight-([\w+#.-]+)/.exec(wrapper.attr('class') || '');
+  if (m && !SKIP_LANGUAGES.has(m[1])) return m[1];
+  return pre.closest('.code-example').find('.example-header .language-name').first().text().trim();
+}
+
+/**
+ * Sphinx (docs.python.org) highlights code as `<pre>` full of `<span>`s with
+ * no `<code>`, so Turndown treated it as prose and escaped it (`\# comment`,
+ * `spam \= 1`); MDN puts a "js" language label and copy button in a header
+ * before each `<pre>`, which came out as a stray `js` line (live sweep
+ * 2026-10-20, 2.2). Rewrite every `<pre>` as `<pre><code>` holding its plain
+ * text with the language in `data-language` (Readability strips classes but
+ * keeps data attributes), and drop MDN's example headers. Run it before
+ * Readability as well as here, while the classes that name the language exist.
+ * @param {string} html
+ * @returns {string}
+ */
+export function normalizeCodeBlocks(html) {
+  if (!/<pre[\s>]/i.test(html)) return html;
+  try {
+    const $ = load(html);
+    $('pre').each((_, el) => {
+      const pre = $(el);
+      const language = codeLanguage(pre);
+      pre.find('br').replaceWith('\n');
+      const code = $('<code></code>').text(pre.text());
+      if (language) {
+        pre.attr('data-language', language);
+        code.attr('data-language', language);
+      }
+      pre.empty().append(code);
+    });
+    $('.code-example > .example-header').remove();
+    return $.html();
+  } catch {
+    return html;
+  }
+}
+
 const ROW_CONTAINER = /^(table|thead|tbody|tfoot)$/;
 
 /**
@@ -152,6 +209,25 @@ function getTurndown() {
       replacement: content => (content.trim() ? content.trim() + '\n' : '')
     });
 
+    // Every <pre> is a fenced block of its plain text, never escaped prose;
+    // the language comes from normalizeCodeBlocks' data-language.
+    _td.addRule('codeBlock', {
+      filter: 'pre',
+      replacement: (_content, node) => {
+        const text = node.textContent.replace(/\n$/, '');
+        if (!text.trim()) return '';
+        const code = node.firstChild && node.firstChild.nodeName === 'CODE' ? node.firstChild : null;
+        const language =
+          node.getAttribute('data-language') ||
+          (code && (code.getAttribute('data-language') ||
+            (/(?:^|\s)language-(\S+)/.exec(code.getAttribute('class') || '') || [])[1])) ||
+          '';
+        const longestRun = Math.max(0, ...(text.match(/`+/g) || []).map(r => r.length));
+        const fence = '`'.repeat(Math.max(3, longestRun + 1));
+        return '\n\n' + fence + language + '\n' + text + '\n' + fence + '\n\n';
+      }
+    });
+
     // Remove boilerplate elements before converting
     _td.remove(['script', 'style', 'nav', 'footer', 'aside', 'noscript']);
   }
@@ -178,7 +254,7 @@ export function htmlToMarkdown(html, options = {}) {
     const visible = options.keepHiddenContent
       ? rows
       : stripHiddenHtml(rows, { css: options.css });
-    return getTurndown().turndown(promoteCornerHeaderCells(visible)).trim();
+    return getTurndown().turndown(promoteCornerHeaderCells(normalizeCodeBlocks(visible))).trim();
   } catch {
     // Fallback: strip tags, return plain text
     return html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();

package/src/utils/localFilePolicy.js

@@ -0,0 +1,65 @@
+/**
+ * Which local files process_document may read (sourceType 'file' / 'pdf_file').
+ *
+ * A prompt-injected page can talk an agent into reading any path it names, so
+ * a local read is held to two rules, both checked on the path's realpath (a
+ * symlink is judged by where it points):
+ *  - the extension must be one of the document types the tool reads
+ *    (pdf, docx, txt, md, html/htm);
+ *  - no path segment may start with "." (~/.ssh, ~/.aws, ~/.config,
+ *    ~/.crawlforge, ...).
+ *
+ * CRAWLFORGE_ALLOWED_DIRS (a path.delimiter-separated list of directories)
+ * narrows reads to those directories instead: when set, a path is allowed only
+ * if its realpath sits inside one of them, and inside them the dot-segment rule
+ * does not apply. The extension rule always applies.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export const ALLOWED_EXTENSIONS = ['.pdf', '.docx', '.txt', '.md', '.html', '.htm'];
+
+async function realpathOr(p) {
+  try {
+    return await fs.realpath(p);
+  } catch {
+    return p; // a missing path is judged as given; the read itself reports it
+  }
+}
+
+/**
+ * Resolves `source` and refuses it when the policy above does not allow it.
+ * @param {string} source the path the caller passed
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {Promise<string>} the realpath to read
+ */
+export async function assertLocalFileAllowed(source, env = process.env) {
+  const real = await realpathOr(path.resolve(source));
+
+  const dirs = (env.CRAWLFORGE_ALLOWED_DIRS || '').split(path.delimiter).filter((d) => d.trim());
+  if (dirs.length > 0) {
+    const roots = await Promise.all(dirs.map((dir) => realpathOr(path.resolve(dir.trim()))));
+    if (!roots.some((root) => real.startsWith(root.endsWith(path.sep) ? root : root + path.sep))) {
+      throw new Error(
+        `Local file refused: '${source}' is outside CRAWLFORGE_ALLOWED_DIRS (${dirs.join(path.delimiter)}). ` +
+          'Add its directory to CRAWLFORGE_ALLOWED_DIRS to allow it.'
+      );
+    }
+  } else if (real.split(path.sep).some((segment) => segment.startsWith('.'))) {
+    throw new Error(
+      `Local file refused: '${source}' resolves to a path inside a dot-directory (${real}), ` +
+        'which process_document does not read (they hold credentials and config such as ~/.ssh and ~/.crawlforge). ' +
+        'To allow it, list its directory in CRAWLFORGE_ALLOWED_DIRS.'
+    );
+  }
+
+  const ext = path.extname(real).toLowerCase();
+  if (!ALLOWED_EXTENSIONS.includes(ext)) {
+    throw new Error(
+      `Local file refused: '${source}' resolves to a ${ext ? `'${ext}'` : 'extensionless'} file, and ` +
+        `process_document only reads ${ALLOWED_EXTENSIONS.join(', ')} files from disk.`
+    );
+  }
+
+  return real;
+}

package/src/utils/provenance.js

@@ -91,6 +91,20 @@ const VERSION_PREFIX = /^v(?=\d)/i;
 const MARKUP_BETWEEN_DIGITS = /(\d)(?:(?:\s*<[^>]{0,120}>)+\s*)([\d.,])/g;
 const MAX_WELD_PASSES = 3;
 
+/**
+ * Whether `sep` can be a digit-grouping separator in `t`: Western 3-digit
+ * groups ("1,234,567") or Indian lakh grouping ("12,34,567").
+ *
+ * @param {string} t
+ * @param {string} sep - "." or ","
+ * @returns {boolean}
+ */
+function isGrouped(t, sep) {
+  const s = sep === '.' ? '\\.' : sep;
+  return new RegExp(`^-?\\d{1,3}(?:${s}\\d{3})+$`).test(t)
+    || new RegExp(`^-?\\d{1,2}(?:${s}\\d{2})*${s}\\d{3}$`).test(t);
+}
+
 /**
  * Every numeric reading of one token, canonicalised.
  *
@@ -114,7 +128,9 @@ function readings(token) {
     raw.push(t.split(grouping).join('').replace(decimal, '.'));
   } else if (hasDot || hasComma) {
     const sep = hasDot ? '.' : ',';
-    raw.push(t.split(sep).join(''));                                  // grouping reading
+    // A grouping reading only when the groups are real thousands groups, so
+    // "12.34" is never read as 1234 (nor 1234 found in a page's "12.34").
+    if (isGrouped(t, sep)) raw.push(t.split(sep).join(''));           // grouping reading
     if (t.split(sep).length === 2) raw.push(t.replace(sep, '.'));     // decimal reading
   } else {
     raw.push(t);
@@ -250,6 +266,79 @@ function embeddedVersionReadings(value) {
   });
 }
 
+/** An ISO calendar date, the form a model is asked to convert dates into. */
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+/** Lowercase, strip accents and fold NBSPs, so "Mär" and "mar" compare equal. */
+const foldText = (s) => s.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase();
+
+/**
+ * Month name -> month number (1-12), long and short forms, from Intl for the
+ * languages a page is most often written in. A name two languages assign to
+ * different months would be ambiguous and is dropped.
+ */
+const MONTHS = (() => {
+  const map = new Map();
+  const clash = new Set();
+  for (const locale of ['en', 'fr', 'de', 'es', 'it', 'pt', 'nl']) {
+    for (const month of ['long', 'short']) {
+      const fmt = new Intl.DateTimeFormat(locale, { month, timeZone: 'UTC' });
+      for (let m = 1; m <= 12; m++) {
+        const name = foldText(fmt.format(new Date(Date.UTC(2026, m - 1, 15)))).replace(/\.$/, '');
+        if (map.has(name) && map.get(name) !== m) clash.add(name);
+        map.set(name, m);
+      }
+    }
+  }
+  map.set('sept', 9); // "Sept 14" in English
+  for (const name of clash) map.delete(name);
+  return map;
+})();
+
+/** "2026-10-14" when y/m/d is a real calendar date, else null. */
+function isoDate(y, m, d) {
+  const date = new Date(Date.UTC(y, m - 1, d));
+  if (date.getUTCFullYear() !== y || date.getUTCMonth() !== m - 1 || date.getUTCDate() !== d) return null;
+  return `${y}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`;
+}
+
+/** "14 octobre 2026", "14. März 2026", "1er octobre 2026", "14 de octubre de 2026". */
+const DAY_MONTH_YEAR = /(?<![\p{L}\d])(\d{1,2})(?:er|st|nd|rd|th|\.)?\s*(?:de\s+)?(\p{L}{3,})\.?,?\s+(?:de\s+)?(\d{4})(?!\d)/gu;
+/** "October 14, 2026", "Oct 14th 2026". */
+const MONTH_DAY_YEAR = /(?<![\p{L}\d])(\p{L}{3,})\.?\s+(\d{1,2})(?:st|nd|rd|th)?,?\s+(\d{4})(?!\d)/gu;
+/** "14.10.2026", "14/10/2026", "10/14/2026" — day/month order read both ways. */
+const NUMERIC_DATE = /(?<!\d)(\d{1,2})[./-](\d{1,2})[./-](\d{4})(?!\d)/g;
+
+/**
+ * Every calendar date the source writes in words or as d/m/y digits, as ISO
+ * strings. Only real dates are admitted, and day, month and year must come
+ * from one expression, so a date is never assembled from scattered numbers.
+ *
+ * @param {string} source
+ * @returns {Set<string>}
+ */
+function datesInSource(source) {
+  const found = new Set();
+  const add = (y, m, d) => {
+    const iso = isoDate(Number(y), Number(m), Number(d));
+    if (iso) found.add(iso);
+  };
+  for (const variant of sourceVariants(source)) {
+    const text = foldText(variant);
+    for (const [, d, name, y] of text.matchAll(DAY_MONTH_YEAR)) {
+      if (MONTHS.has(name)) add(y, MONTHS.get(name), d);
+    }
+    for (const [, name, d, y] of text.matchAll(MONTH_DAY_YEAR)) {
+      if (MONTHS.has(name)) add(y, MONTHS.get(name), d);
+    }
+    for (const [, a, b, y] of text.matchAll(NUMERIC_DATE)) {
+      add(y, b, a);
+      add(y, a, b);
+    }
+  }
+  return found;
+}
+
 /**
  * Replace every numeric value that is not present in the source with null.
  *
@@ -278,6 +367,7 @@ export function verifyNumericProvenance(data, source) {
   // Built lazily: most extractions are all numbers and never need it, and
   // lowercasing a multi-megabyte page is not free.
   let haystacks = null;
+  let dates = null;
   const inSource = (spellings) => {
     if (haystacks === null) haystacks = literalHaystacks(source);
     return spellings.some((s) => haystacks.some((h) => h.includes(s)));
@@ -313,6 +403,17 @@ export function verifyNumericProvenance(data, source) {
         verified++;
         return node;
       }
+      // An ISO date the model converted from "14 octobre 2026" is not on the
+      // page literally; it is when the page's own dates are read. A date that
+      // cannot exist ("2027-03-00") never matches.
+      const iso = typeof node === 'string' && node.trim().match(ISO_DATE);
+      if (iso) {
+        if (dates === null) dates = datesInSource(source);
+        if (dates.has(isoDate(Number(iso[1]), Number(iso[2]), Number(iso[3])))) {
+          verified++;
+          return node;
+        }
+      }
       unverified.push({ path: path || '(root)', value: node, reason: 'not_found_in_source' });
       return null;
     }

package/src/utils/ssrfGuard.js

@@ -10,7 +10,7 @@
  *
  * Two levels:
  *  - Stage 1 (default): blocks connections to loopback, link-local /
- *    cloud-metadata (169.254.0.0/16, incl. 169.254.169.254), and 0.0.0.0.
+ *    cloud-metadata (169.254.0.0/16, incl. 169.254.169.254), 0.0.0.0 and `::`.
  *    These are never legitimate public-scrape targets, so impact is ~zero.
  *  - Stage 2 (SSRF_STRICT=true): full private-range enforcement (RFC1918, ULA,
  *    multicast, CGNAT, etc.) via the existing SSRFProtection range logic.
@@ -42,7 +42,8 @@ import { withFetchCause } from './fetchError.js';
 const _ssrf = new SSRFProtection();
 
 // Narrow Stage-1 ranges: things no legitimate public scrape ever targets.
-const STAGE1_RANGES = ['127.0.0.0/8', '169.254.0.0/16', '0.0.0.0/8', '::1/128', 'fe80::/10'];
+// `::` (the unspecified address) connects to the local host, like 0.0.0.0.
+const STAGE1_RANGES = ['127.0.0.0/8', '169.254.0.0/16', '0.0.0.0/8', '::/128', '::1/128', 'fe80::/10'];
 
 // Literal cloud-metadata / service-discovery hostnames blocked even before DNS.
 const METADATA_HOSTS = new Set(['metadata.google.internal', 'metadata.azure.com', 'metadata']);
@@ -179,7 +180,7 @@ function preflightHostCheck(u, sec) {
  * connects to exactly what we checked (rebinding-safe). Allowlisted hostnames
  * are resolved normally, with no address filtering.
  */
-function ssrfLookup(hostname, opts, callback) {
+export function ssrfLookup(hostname, opts, callback) {
   const sec = config.security?.ssrfProtection;
   if (isAllowlisted(hostname.toLowerCase(), sec?.allowedDomains)) {
     return dns.lookup(hostname, opts, callback);

package/src/utils/ssrfProtection.js

@@ -29,7 +29,10 @@ const SSRF_CONFIG = {
     '0.0.0.0/8',       // This network
     '100.64.0.0/10',   // Carrier-grade NAT
     '198.18.0.0/15',   // Benchmark testing
+    '::/128',          // IPv6 unspecified (connects to the local host)
     '::1/128',         // IPv6 localhost
+    '::/96',           // IPv4-compatible IPv6 (deprecated)
+    '64:ff9b::/96',    // NAT64 (embeds an IPv4 address)
     'fc00::/7',        // IPv6 private network
     'fe80::/10',       // IPv6 link-local
     'ff00::/8',        // IPv6 multicast