@apleasantview/eleventy-plugin-baseline 0.1.0-next.40 → 0.1.0-next.41

package/index.js

@@ -3,36 +3,40 @@ import { createRequire } from 'node:module';
 
 import { HtmlBasePlugin } from '@11ty/eleventy';
 import { eleventyImageOnRequestDuringServePlugin } from '@11ty/eleventy-img';
+import markdownItAttrs from 'markdown-it-attrs';
 
-import { createLogger } from './core/logging.js';
+import { createLogger, printBannerOnce } from './core/logging/index.js';
+import { isLegacyShape, normalizeLegacyShape } from './core/back-compat/options.js';
+import { settingsSchema } from './core/schema.js';
+import { deriveBaselineState } from './core/state.js';
+import { runPrepass, PREPASS_SENTINEL } from './core/content-graph/index.js';
+import { registerVirtualDir } from './core/virtual-dir.js';
 import { createContentMapStore } from './core/content-map-store.js';
 import { createTranslationMapStore } from './core/translation-map-store.js';
 import { createSlugIndex } from './core/slug-index.js';
-import { registerVirtualDir } from './core/virtual-dir.js';
-import { registerPageContext } from './core/page-context.js';
-import { wikilinks } from './core/wikilinks.js';
-import { settingsSchema } from './core/schema.js';
-
-import { registerGlobals } from './core/global-functions/index.js';
-import { markdownFilter, relatedPostsFilter, isStringFilter } from './core/filters/index.js';
-import { imageShortcode } from './core/shortcodes/index.js';
+import { registerPageContext } from './core/page-context/index.js';
+import { autoHeadingIds, safeUse, wikilinks } from './core/markdown/index.js';
+import { slugify } from './core/utils/slugify.js';
 import { assetsCore, headCore, multilangCore, navigatorCore, sitemapCore } from './modules.js';
+import {
+	registerGlobals,
+	markdownFilter,
+	relatedPostsFilter,
+	isStringFilter,
+	imageShortcode
+} from './core/surface/index.js';
 
 const __require = createRequire(import.meta.url);
 const { name, version } = __require('./package.json');
+const eleventyVersion = process.env.ELEVENTY_VERSION;
+// const absoluteRoot = process.env.ELEVENTY_ROOT; -> Safekeeping.
 
 const mode = process.env.ELEVENTY_ENV;
+// eslint-disable-next-line no-unused-vars
 const isDev = mode === 'development';
+// eslint-disable-next-line no-unused-vars
 const isProd = mode === 'production';
 
-const LEGACY_OPTION_KEYS = [
-	'verbose',
-	'enableNavigatorTemplate',
-	'enableSitemapTemplate',
-	'assetsESBuild',
-	'multilingual'
-];
-
 // Whitelist of reserved global data keys used internally across the plugin.
 // Positive side effect is they all get listed in order and merge data to the same key.
 // Also prevents name collision with filters.
@@ -44,37 +48,19 @@ const INTERNAL_KEYS = [
 	'_navigator',
 	'_sitemap',
 	'_snapshot',
-	'_pageContext'
+	'eleventyComputed._pageContext',
+	'eleventyComputed._node',
+	'eleventyComputed._edges',
+	'eleventyComputed._backlinks',
+	'eleventyComputed._outgoing'
 ];
 
-/**
- * Detect legacy single-object plugin invocation.
- *
- * The original plugin API accepted a single merged configuration object.
- * This helper detects that shape and enables safe normalization into
- * the current (settings, options) contract.
- *
- * NOTE: arguments.length is required because default parameters mask arity.
- */
-function looksLikeLegacyOptions(firstArg, argsLength) {
-	if (argsLength >= 2) return false;
-	if (!firstArg || typeof firstArg !== 'object') return false;
-	return LEGACY_OPTION_KEYS.some((key) => key in firstArg);
-}
+// Base logger outputs regardless of options.
+const baseLog = createLogger(null, { verbose: true });
 
-/**
- * Normalize legacy plugin input into the current structured contract.
- *
- * - settings → site identity (content + SEO concerns)
- * - options  → runtime behavior flags
- */
-function splitLegacyOptions(legacy) {
-	const { defaultLanguage, languages, ...rest } = legacy;
-	return {
-		settings: { defaultLanguage, languages },
-		options: rest
-	};
-}
+printBannerOnce(baseLog, { version, eleventyVersion });
+
+let contentGraph = null;
 
 /**
  * Baseline (composition root)
@@ -118,36 +104,29 @@ function splitLegacyOptions(legacy) {
  */
 export default function baseline(settings = {}, options = {}) {
 	// --- Legacy compatibility layer ---
-	const argsLength = arguments.length;
-	const wasLegacy = looksLikeLegacyOptions(settings, argsLength);
-
-	if (wasLegacy) {
-		const split = splitLegacyOptions(settings);
-		settings = split.settings;
-		options = split.options;
-	}
-
-	// Base logger outputs regardless of options.
-	const baseLog = createLogger(null, { verbose: true });
-
-	// Scoped logging.
-	function scopedLog(name) {
-		return createLogger(name, { verbose: options.verbose });
-	}
-
-	if (wasLegacy) {
-		baseLog.info('DEPRECATED: single-object plugin arg. Use baseline(settings, options) instead.');
+	if (isLegacyShape(settings, arguments.length)) {
+		const normalized = normalizeLegacyShape(settings);
+		settings = normalized.settings;
+		options = normalized.options;
+		baseLog.info('Single-object plugin arg is deprecated. Use baseline(settings, options).');
 	}
 
 	// Validate configuration shape (non-fatal).
 	const parsed = settingsSchema.safeParse(settings);
 	if (!parsed.success) {
 		for (const issue of parsed.error.issues) {
-			baseLog.info('settings:', `${issue.path.join('.')} — ${issue.message}`);
+			baseLog.info('settings:', `${issue.path.join('.')}, ${issue.message}`);
 		}
 	}
 
-	baseLog.info('Eleventy Baseline', version);
+	// Resolve state once, above the closure. Pure; no eleventyConfig.
+	const state = deriveBaselineState(settings, options, { mode });
+	baseLog.info('Settings and options resolved, modules loaded');
+
+	// Scoped logging.
+	function scopedLog(name) {
+		return createLogger(name, { verbose: state.options.verbose });
+	}
 
 	/**
 	 * Eleventy plugin initializer.
@@ -160,26 +139,69 @@ export default function baseline(settings = {}, options = {}) {
 		try {
 			eleventyConfig.versionCheck('>=3.0');
 		} catch (e) {
-			baseLog.error('Eleventy version mismatch:', e.message);
+			baseLog.error('Eleventy version mismatch.', e.message);
+		}
+
+		// --- Pre-pass wiring ---
+		// One mechanic: the pre-pass runs at the start of every Eleventy
+		// build cycle via `eleventy.before`. Initial build, watch rebuild,
+		// production build — all the same path. Templates always render
+		// against a graph rebuilt from current source. The sentinel keeps
+		// the inner Eleventy from re-attaching the hook on re-entry.
+		if (process.env[PREPASS_SENTINEL] !== '1') {
+			const prepassLog = scopedLog('pre-pass');
+
+			// Origins HtmlBasePlugin may have rewritten internal hrefs to.
+			// Stripped during link extraction so backlinks key on path-only.
+			const knownOrigins = new Set(['http://localhost:8080']);
+			for (const candidate of [settings.url, process.env.URL]) {
+				if (!candidate) continue;
+				try {
+					knownOrigins.add(new URL(candidate).origin);
+				} catch {
+					prepassLog.info('No known origins, using localhost only');
+				}
+			}
+
+			eleventyConfig.on('eleventy.before', async () => {
+				contentGraph = await runPrepass(
+					eleventyConfig.directories?.input,
+					eleventyConfig.directories?.output,
+					scopedLog,
+					{ quietMode: true, knownOrigins }
+				);
+			});
 		}
 
 		INTERNAL_KEYS.forEach((key) => {
+			// We leave eleventyComputed callback kEys alone, the rest are reserved-empty.
+			if (
+				key === 'eleventyComputed._pageContext' ||
+				key === 'eleventyComputed._node' ||
+				key === 'eleventyComputed._edges' ||
+				key === 'eleventyComputed._backlinks' ||
+				key === 'eleventyComputed._outgoing'
+			)
+				return;
 			eleventyConfig.addGlobalData(key, {});
 		});
 
 		const env = {
-			name: 'Eleventy Baseline',
-			package: name,
 			version,
-			mode
+			name: 'Eleventy Baseline',
+			env: {
+				mode,
+				package: name
+			}
 		};
 
 		eleventyConfig.addGlobalData('_baseline', {
-			env
+			...env,
+			options: state.options
 		});
 
 		if (!settings.url) {
-			baseLog.warn('settings.url missing — canonical URLs will be relative');
+			baseLog.warn('settings.url missing, canonical URLs will be relative');
 		}
 
 		registerGlobals(eleventyConfig);
@@ -188,38 +210,12 @@ export default function baseline(settings = {}, options = {}) {
 			baseHref: process.env.URL || eleventyConfig.pathPrefix
 		});
 
-		// --- State layer (authoritative configuration) ---
+		// --- Feature exposure to templates ---
 		const hasImageTransformPlugin = eleventyConfig.hasPlugin('eleventyImageTransformPlugin');
 
-		const state = {
-			settings: {
-				title: settings.title,
-				tagline: settings.tagline,
-				url: settings.url,
-				noindex: settings.noindex ?? false,
-				defaultLanguage: settings.defaultLanguage,
-				languages: settings.languages,
-				head: settings.head
-			},
-
-			options: {
-				verbose: options.verbose ?? false,
-				multilang: options.multilingual ?? false,
-				sitemap: options.sitemap ?? options.enableSitemapTemplate ?? true,
-				navigator: options.navigator ?? options.enableNavigatorTemplate ?? isDev,
-				head: {
-					titleSeparator: options.head?.titleSeparator,
-					showGenerator: options.head?.showGenerator
-				},
-				assets: {
-					esbuild: options.assets?.esbuild ?? options.assetsESBuild ?? {}
-				}
-			}
-		};
-
 		eleventyConfig.addGlobalData('_baseline', {
 			features: {
-				...state.options,
+				...state.features,
 				hasImageTransformPlugin
 			}
 		});
@@ -234,6 +230,9 @@ export default function baseline(settings = {}, options = {}) {
 			outputDir: ''
 		});
 
+		const virtualDirLog = scopedLog('virtual-dir');
+		virtualDirLog.info('Virtual directories mounted');
+
 		const directories = {
 			input: eleventyConfig.directories?.input,
 			output: eleventyConfig.directories?.output,
@@ -277,6 +276,9 @@ export default function baseline(settings = {}, options = {}) {
 				get contentMap() {
 					return contentMapStore.get();
 				},
+				get contentGraph() {
+					return contentGraph;
+				},
 				translationMap: translationMapStore,
 				slugIndex
 			},
@@ -287,34 +289,68 @@ export default function baseline(settings = {}, options = {}) {
 		// Page context registry
 		const pageContextRegistry = registerPageContext(eleventyConfig, coreContext);
 
-		// Wikilinks: [[slug]] / [[slug | lang]] in body markdown.
+		// --- Content graph ---
+		// Cascade hookup for the content graph. Reads via the runtime getter so
+		// serve-mode rebuilds reassigning `contentGraph` are picked up.
+		function getNode(pageUrl) {
+			return coreContext.runtime.contentGraph?.nodes?.[pageUrl];
+		}
+
+		function getEdges() {
+			return coreContext.runtime.contentGraph?.edges ?? [];
+		}
+
+		eleventyConfig.addGlobalData('eleventyComputed._node', () => (data) => {
+			const pageUrl = data.page?.url;
+			if (!pageUrl) return undefined;
+
+			return getNode(pageUrl);
+		});
+
+		eleventyConfig.addGlobalData('eleventyComputed._backlinks', () => (data) => {
+			const edges = getEdges();
+
+			const pageUrl = data.page?.url;
+			if (!pageUrl) return [];
+
+			return edges.filter((edge) => edge.to === pageUrl);
+		});
+
+		eleventyConfig.addGlobalData('eleventyComputed._outgoing', () => (data) => {
+			const edges = getEdges();
+
+			const pageUrl = data.page?.url;
+			if (!pageUrl) return [];
+
+			return edges.filter((edge) => edge.from === pageUrl);
+		});
+
+		// --- Markdown engine ---
+		// Order matters: attrs first so manual ids are visible to auto-heading-ids'
+		// seed pass; wikilinks last since it parses inline tokens independently.
+		const mdLog = scopedLog('markdown');
 		eleventyConfig.amendLibrary('md', (md) => {
-			md.use(wikilinks, { slugIndex, pageContextRegistry, translationMapStore });
+			safeUse(md, 'curly_attributes', markdownItAttrs, undefined, mdLog);
+			safeUse(md, 'baseline_auto_heading_ids', autoHeadingIds, { slugify }, mdLog);
+			safeUse(md, 'baseline_wikilinks', wikilinks, { slugIndex, pageContextRegistry, translationMapStore }, mdLog);
 		});
 
+		// --- Snapshots ---
 		coreContext.snapshots = {
 			contentMap: () => contentMapStore.snapshot(),
 			pageContext: () => pageContextRegistry.snapshot()
 		};
 
-		// --- Module activation ---
-		const features = {
-			multilang: Boolean(state.options.multilang),
-			sitemap: Boolean(state.options.sitemap),
-			navigator: Boolean(state.options.navigator),
-			head: true,
-			assets: true
-		};
-
 		// --- Module registry ---
 		const moduleRegistry = [
-			{ when: features.multilang, name: 'multilang', plugin: multilangCore },
-			{ when: features.sitemap, name: 'sitemap', plugin: sitemapCore },
+			{ when: state.features.multilang, name: 'multilang', plugin: multilangCore },
+			{ when: state.features.sitemap, name: 'sitemap', plugin: sitemapCore },
 			{ name: 'navigator', plugin: navigatorCore },
-			{ when: features.head, name: 'head', plugin: headCore, consumes: { pageContext: true } },
-			{ when: features.assets, name: 'assets', plugin: assetsCore }
+			{ when: state.features.head, name: 'head', plugin: headCore, consumes: { pageContext: true } },
+			{ when: state.features.assets, name: 'assets', plugin: assetsCore }
 		];
 
+		const active = [];
 		for (const entry of moduleRegistry) {
 			const { when = true, name, plugin, consumes = {} } = entry;
 			if (!when) continue;
@@ -325,6 +361,7 @@ export default function baseline(settings = {}, options = {}) {
 			};
 
 			eleventyConfig.addPlugin(plugin, moduleContext);
+			active.push(name);
 		}
 
 		// --- Filters ---

package/modules/assets/index.js

@@ -49,7 +49,7 @@ export function assetsCore(eleventyConfig, moduleContext) {
 	const parsed = optionsSchema.safeParse(options.assets);
 	if (!parsed.success) {
 		for (const issue of parsed.error.issues) {
-			log.info('options:', `${issue.path.join('.')} — ${issue.message}`);
+			log.info('options:', `${issue.path.join('.')}, ${issue.message}`);
 		}
 	}
 
@@ -63,13 +63,15 @@ export function assetsCore(eleventyConfig, moduleContext) {
 	const watchGlob = TemplatePath.join(assetsDirectory, '**/*.{css,js,svg,png,jpeg,jpg,webp,gif,avif}');
 
 	if (!assetsDirectory) {
-		log.warn('eleventyConfig.directories.assets is unset; registerVirtualDir must run before this plugin.');
+		log.warn('directories.assets is unset, registerVirtualDir must run before this plugin');
 		return;
 	}
 
 	// Watch common asset formats so edits trigger reloads during --serve.
 	eleventyConfig.addWatchTarget(watchGlob);
 
+	log.info('Assets pipeline registered');
+
 	// --- JS (esbuild) ---
 	// Register js as a template format. Only index.js files under assets/js/
 	// are compiled; everything else (11tydata.js, non-entry scripts) is skipped

package/modules/assets/processors/esbuild-process.js

@@ -1,5 +1,5 @@
 import * as esbuild from 'esbuild';
-import { createLogger } from '../../../core/logging.js';
+import { createLogger } from '../../../core/logging/index.js';
 
 /**
  * esbuild processor (processor)
@@ -61,7 +61,7 @@ export default async function assetsESbuild(jsFilePath, options = {}) {
 		// Return raw JS; markup wrapping is handled by the plugin registration.
 		return result.outputFiles[0].text;
 	} catch (error) {
-		log.error('esbuild failed:', error);
+		log.error('esbuild failed.', error);
 		// Surface a safe JS comment so the caller can decide how to wrap it.
 		return '/* Error processing JS */';
 	}

package/modules/assets/processors/postcss-process.js

@@ -2,7 +2,7 @@ import fs from 'fs/promises';
 import postcss from 'postcss';
 import loadPostCSSConfig from 'postcss-load-config';
 import fallbackPostCSSConfig from '../configs/postcss.config.js';
-import { createLogger } from '../../../core/logging.js';
+import { createLogger } from '../../../core/logging/index.js';
 
 /**
  * PostCSS processor (processor)
@@ -79,7 +79,7 @@ export default async function assetsPostCSS(cssFilePath) {
 		// Return raw CSS; markup wrapping is handled in the plugin registration.
 		return result.css;
 	} catch (error) {
-		log.error('PostCSS failed:', error);
+		log.error('PostCSS failed.', error);
 		// Surface a safe CSS string so the caller can decide how to wrap it.
 		return '/* Error processing CSS */';
 	}

package/modules/head/drivers/posthtml-head-elements.js

@@ -41,10 +41,9 @@ import { dedupeMeta, dedupeLink } from '../utils/dedupe.js';
  * @param {Object} args.options - Head options (titleSeparator, showGenerator).
  * @param {string} args.placeholderTag - Placeholder element to replace.
  * @param {string} args.eol - End-of-line separator interleaved between nodes.
- * @param {Object} args.log - Scoped logger.
  * @returns {(tree: Object) => Object} PostHTML plugin function.
  */
-export function renderHead({ seeds, alternates, options, placeholderTag, eol, log }) {
+export function renderHead({ seeds, alternates, options, placeholderTag, eol }) {
 	const defaults = emitMeta(seeds.meta, seeds.render, options);
 	const extras = emitExtras(seeds.head, alternates);
 
@@ -52,7 +51,6 @@ export function renderHead({ seeds, alternates, options, placeholderTag, eol, lo
 	const sorted = capoSort(deduped);
 
 	return function rendererPlugin(tree) {
-		// log.info('injecting head for', seeds.page.inputPath || seeds.page.url);
 		tree.match({ tag: placeholderTag }, () => ({
 			tag: 'head',
 			content: interleaveEOL(sorted, eol)

package/modules/head/index.js

@@ -2,6 +2,8 @@ import { renderHead } from './drivers/posthtml-head-elements.js';
 import { buildAlternates } from './utils/alternates.js';
 import { optionsSchema } from './schema.js';
 
+import chalk from 'kleur';
+
 // Internal constants — not user-facing.
 const PLACEHOLDER_TAG = 'baseline-head';
 const EOL = '\n';
@@ -52,7 +54,7 @@ export function headCore(eleventyConfig, moduleContext) {
 	const parsed = optionsSchema.safeParse(options.head);
 	if (!parsed.success) {
 		for (const issue of parsed.error.issues) {
-			log.info('options:', `${issue.path.join('.')} — ${issue.message}`);
+			log.info('options:', `${issue.path.join('.')}, ${issue.message}`);
 		}
 	}
 
@@ -68,23 +70,19 @@ export function headCore(eleventyConfig, moduleContext) {
 	const headStats = { pages: new Set() };
 
 	eleventyConfig.on('eleventy.after', () => {
-		log.info({
-			message: 'Head injection summary',
-			totalPages: headStats.pages.size,
-			sample: Array.from(headStats.pages).slice(0, 10)
-		});
+		log.info(chalk.green(`Head injected into ${headStats.pages.size} pages`));
 		headStats.pages.clear();
 	});
 
 	// --- Transform-time: compose and inject. ---
-	log.info('Injecting heads to pages');
+	log.info('Injecting heads');
 	eleventyConfig.htmlTransformer.addPosthtmlPlugin('html', function (context) {
 		headStats.pages.add(context?.page?.inputPath || context?.outputPath);
 
 		const key = context?.page?.url ?? context?.page?.inputPath;
 		const seeds = pageContextRegistry?.getByKey(key);
 		if (!seeds) {
-			log.warn('no head seeds for', context?.page?.inputPath || context?.outputPath);
+			log.warn('No head seeds for', context?.page?.inputPath || context?.outputPath);
 			return (tree) => tree;
 		}
 
@@ -99,8 +97,7 @@ export function headCore(eleventyConfig, moduleContext) {
 			alternates,
 			options: headOptions,
 			placeholderTag: PLACEHOLDER_TAG,
-			eol: EOL,
-			log
+			eol: EOL
 		});
 	});
 }

package/modules/multilang/index.js

@@ -1,6 +1,6 @@
 import { I18nPlugin } from '@11ty/eleventy';
 import { DeepCopy } from '@11ty/eleventy-utils';
-import { normalizeLanguages } from '../../core/utils/helpers.js';
+import { normalizeLanguages } from '../../core/utils/normalize-languages.js';
 import i18nTranslationsFor from './filters/i18n-translations-for.js';
 import i18nTranslationIn from './filters/i18n-translation-in.js';
 import i18nDefaultTranslation from './filters/i18n-default-translation.js';
@@ -63,10 +63,12 @@ export function multilangCore(eleventyConfig, moduleContext) {
 	const isMultilingual = options.multilang === true && defaultLanguage && hasLanguages;
 
 	if (!isMultilingual) {
-		log.info('inactive: requires options.multilingual + settings.defaultLanguage + languages');
+		log.info('Multilang inactive, needs options.multilang, settings.defaultLanguage, and languages');
 		return;
 	}
 
+	log.info(`Multilang active: ${Object.keys(languages).join('/')} (default: ${defaultLanguage})`);
+
 	// Register Eleventy's built-in I18nPlugin for locale-aware URL resolution.
 	eleventyConfig.addPlugin(I18nPlugin, {
 		defaultLanguage: defaultLanguage,

package/modules/navigator/index.js

@@ -10,39 +10,42 @@ const __dirname = path.dirname(__filename);
 /**
  * Navigator (module)
  *
- * Debug surface. Exposes Eleventy and Baseline runtime state to templates so
- * developers can inspect data shape, scope contents, and lifecycle output
- * without leaving the page.
+ * Two roles, one module: the public read surface for plugin-produced
+ * cross-page data (the content graph and its enriched backlinks), and the
+ * debug surface for inspecting Eleventy and Baseline runtime state.
  *
  * Architecture layer:
  *   module
  *
  * System role:
- *   Read-only window into the runtime substrate. Pulls snapshots from the
- *   page-context registry and content-map store via the module context;
- *   does not write back.
+ *   Read-only window over the runtime substrate. Surfaces the content graph
+ *   for templates that need cross-page reads, and snapshots from the
+ *   page-context registry and content-map store for debugging. Writes
+ *   nothing back.
  *
  * Lifecycle:
- *   build-time   → register Nunjucks globals, debug filters, and the
- *                  optional virtual debug page
+ *   build-time   → register `_navigator` ({ nodes, edges, backlinks }),
+ *                  debug globals, filters, and the optional virtual debug page
  *   cascade-time → eleventyComputed `_snapshot` resolves contentMap and
  *                  pageContext on each page
  *
  * Why this exists:
- *   Render-time inspection of cascade state has no built-in surface.
- *   Centralising globals and filters under a debug-only module keeps the
- *   inspection vocabulary stable and out of feature modules.
+ *   Templates need an addressable cross-page surface for graph reads, and
+ *   render-time inspection of cascade state has no built-in equivalent.
+ *   One module owns both vocabularies so feature modules stay narrow.
  *
  * Scope:
- *   Owns the `_runtime` and `_ctx` Nunjucks globals, computed `_snapshot`,
+ *   Owns the `_navigator` global (`{ nodes, edges, backlinks }`, the public
+ *   read surface), the debug globals `_runtime` and `_ctx`, computed `_snapshot`,
  *   debug filters (`_inspect`, `_json`, `_keys`), and the optional virtual
  *   page at /navigator-core.html.
- *   Does not own the data it surfaces (page-context registry, content-map
- *   store).
+ *   Does not own the data it surfaces (content graph, page-context registry,
+ *   content-map store).
  *
  * Data flow:
- *   snapshots (contentMap, pageContext) + this.ctx → globals + computed
- *   `_snapshot` + virtual page → developer
+ *   runtime.contentGraph + snapshots + this.ctx → `_navigator` + debug
+ *   globals + computed `_snapshot` + virtual page → templates and
+ *   developers
  *
  * Note: `_snapshot.contentMap` is null on the navigator template itself
  * because it renders before `eleventy.contentMap` fires. Read `_snapshot`
@@ -51,23 +54,25 @@ const __dirname = path.dirname(__filename);
  * @param {import("@11ty/eleventy").UserConfig} eleventyConfig
  * @param {Object} moduleContext
  * @param {Object} moduleContext.state - Resolved plugin state.
+ * @param {Object} moduleContext.runtime - Lazy access layer; reads contentGraph.
  * @param {Object} moduleContext.snapshots - Thunks: { contentMap, pageContext }.
  */
 export function navigatorCore(eleventyConfig, moduleContext) {
-	const { state, snapshots, log, env } = moduleContext;
+	const { state, runtime, snapshots, log, env } = moduleContext;
 	const { settings, options } = state;
 
 	// Structural-only options check: log on mismatch, do not throw.
 	const parsed = optionsSchema.safeParse(options.navigator);
 	if (!parsed.success) {
 		for (const issue of parsed.error.issues) {
-			log.info('options:', `${issue.path.join('.')} — ${issue.message}`);
+			log.info('options:', `${issue.path.join('.')}, ${issue.message}`);
 		}
 	}
 
 	// Boolean shorthand activates the virtual page; object form lets users tune.
 	const navigatorOpts = options.navigator && typeof options.navigator === 'object' ? options.navigator : {};
-	const renderTemplate = env.mode === 'development' ?? navigatorOpts.template ?? Boolean(options.navigator);
+	const renderTemplate =
+		navigatorOpts.template ?? (typeof options.navigator === 'boolean' ? options.navigator : env.mode === 'development');
 	const inspectorDepth = navigatorOpts.inspectorDepth ?? 4;
 
 	eleventyConfig.addGlobalData('eleventyComputed._snapshot', () => {
@@ -77,6 +82,14 @@ export function navigatorCore(eleventyConfig, moduleContext) {
 		});
 	});
 
+	// Public read surface for plugin-produced cross-page data. Templates can
+	// paginate over `_navigator.backlinks` or read `_navigator.graph` directly.
+	eleventyConfig.addGlobalData('_navigator', () => ({
+		nodes: runtime.contentGraph?.nodes ?? {},
+		edges: runtime.contentGraph?.edges ?? {},
+		backlinks: runtime.contentGraph?.backlinks ?? {}
+	}));
+
 	/**
 	 * Nunjucks Global: _runtime
 	 *
@@ -125,7 +138,7 @@ export function navigatorCore(eleventyConfig, moduleContext) {
 			inspectorDepth
 		});
 
-		log.info('Navigator template registered at /navigator-core.html');
+		log.info('Navigator mounted at /navigator-core.html');
 	}
 
 	/**

package/modules/navigator/templates/navigator-core.html

@@ -41,7 +41,7 @@ permalink: /navigator-core.html
 			<details>
 				<summary><strong>Page Context</strong></summary>
 				<pre>
-					{{- _snapshot.pageContext | _inspect({ depth: null }) -}}
+					{{- _pageContext | _inspect({ depth: null }) -}}
 				</pre>
 			</details>
 			{% for key, value in _runtime() %}