@apleasantview/eleventy-plugin-baseline 0.1.0-next.39 → 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,38 @@
 import * as esbuild from 'esbuild';
-import { createLogger } from '../../../core/logging.js';
+import { createLogger } from '../../../core/logging/index.js';
+
+/**
+ * esbuild processor (processor)
+ *
+ * Bundles a single JS entrypoint with esbuild and returns the text. Used
+ * both by the `js` template format compile guard and by the
+ * `inlineESbuild` filter in the assets module.
+ *
+ * Architecture layer:
+ *   module
+ *
+ * System role:
+ *   Stateless bundler called by `modules/assets/index.js`. The compile
+ *   guard decides which files reach this processor; this file owns the
+ *   esbuild call itself.
+ *
+ * Lifecycle:
+ *   build-time → invoked per matching entrypoint during template compile,
+ *                or per-call from the inline filter
+ *
+ * Why this exists:
+ *   Eleventy treats every `.js` file as a template. A dedicated processor
+ *   keeps esbuild configuration out of the template format wiring and lets
+ *   the inline filter reuse the same defaults.
+ *
+ * Scope:
+ *   Owns esbuild option defaults and the bundle call. Does not own the
+ *   compile guard, the watch target, or markup wrapping; the assets
+ *   module owns those.
+ *
+ * Data flow:
+ *   entrypoint path + options → esbuild.build → bundled JS text
+ */
 
 const log = createLogger('assets-esbuild');
 const defaultOptions = { minify: true, target: 'es2020' };
@@ -28,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,41 @@ 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)
+ *
+ * Processes a single CSS entrypoint through PostCSS and returns the text.
+ * Used both by the `css` template format compile guard and by the
+ * `inlinePostCSS` filter in the assets module.
+ *
+ * Architecture layer:
+ *   module
+ *
+ * System role:
+ *   Stateless processor called by `modules/assets/index.js`. Resolves the
+ *   user's PostCSS config from the project root, falling back to the
+ *   bundled Baseline config when none is found. Cached for the lifetime
+ *   of the process.
+ *
+ * Lifecycle:
+ *   build-time → invoked per matching entrypoint during template compile,
+ *                or per-call from the inline filter
+ *
+ * Why this exists:
+ *   Eleventy has no PostCSS hook of its own. A dedicated processor lets
+ *   user configs win when present and keeps the bundled fallback out of
+ *   the consumer's `node_modules` resolution path.
+ *
+ * Scope:
+ *   Owns config resolution, caching, and the PostCSS call. Does not own
+ *   the compile guard, the watch target, or markup wrapping; the assets
+ *   module owns those.
+ *
+ * Data flow:
+ *   entrypoint path → PostCSS pipeline → processed CSS text
+ */
 
 const log = createLogger('assets-postcss');
 
@@ -45,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/capo-adapter.js

@@ -1,9 +1,31 @@
 /**
- * capo.js adapter for PostHTML AST nodes.
+ * Capo PostHTML adapter (driver)
  *
- * Implements the HTMLAdapter interface capo.js v2 uses to compute element
- * weights (src/adapters/adapter.js in @rviscomi/capo.js). Only getWeight is
- * consumed downstream; the rest are shimmed to satisfy the shape.
+ * Implements the `HTMLAdapter` interface capo.js v2 expects, against
+ * PostHTML's `{ tag, attrs, content }` node shape. Only `getWeight` is
+ * exercised downstream; the rest are shimmed to satisfy the contract.
+ *
+ * Architecture layer:
+ *   module
+ *
+ * System role:
+ *   Translation shim between the head driver's PostHTML tree and the
+ *   capo.js sort. Used by `posthtml-head-elements.js` when ordering the
+ *   composed `<head>` element list.
+ *
+ * Lifecycle:
+ *   transform-time → invoked per node while capo.js scores element weights
+ *
+ * Why this exists:
+ *   capo.js is DOM-shaped; PostHTML is not. Without an adapter the driver
+ *   would have to walk the tree twice or hand-roll element weighting.
+ *
+ * Scope:
+ *   Owns attribute lookup, tag name resolution, and text extraction over
+ *   PostHTML nodes. Does not own weighting logic; capo.js owns that.
+ *
+ * Data flow:
+ *   PostHTML node → adapter accessor → capo.js getWeight
  *
  * A PostHTML element node looks like `{ tag, attrs, content }` where attrs
  * is either undefined or a plain object. Boolean attributes appear with an

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

@@ -10,7 +10,7 @@ import { dedupeMeta, dedupeLink } from '../utils/dedupe.js';
  * <baseline-head> placeholder with the result.
  *
  * Architecture layer:
- *   module (driver inside head)
+ *   module
  *
  * System role:
  *   The seam between head's pipeline and the renderer choice. Alternate
@@ -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,