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

package/core/utils/add-trailing-slash.js

@@ -0,0 +1,11 @@
+/**
+ * Helper function to add trailing slash to a path
+ * @param {string} path
+ * @returns {string}
+ */
+export function addTrailingSlash(path) {
+	if (path.slice(-1) === '/') {
+		return path;
+	}
+	return path + '/';
+}

package/core/utils/ensure-dot-slash-dir.js

@@ -0,0 +1,13 @@
+import { TemplatePath } from '@11ty/eleventy-utils';
+
+/**
+ * Normalise a directory path to a `./`-prefixed form, defaulting empty/missing
+ * input to the current directory. Thin wrapper over
+ * `TemplatePath.addLeadingDotSlash` that bakes in the empty-string fallback.
+ *
+ * @param {string | undefined} dir
+ * @returns {string}
+ */
+export function ensureDotSlashDir(dir) {
+	return TemplatePath.addLeadingDotSlash(dir || './');
+}

package/core/utils/normalize-language-map.js

@@ -0,0 +1,37 @@
+/**
+ * Normalize the `settings.languages` config into an object map with
+ * lowercased, trimmed keys.
+ *
+ * Accepts an array of language codes or an object keyed by language code;
+ * either form ends up with `[normalizedKey]: entry`. Returns undefined if
+ * the input is invalid or empty.
+ *
+ * Lives in `core/utils/` (not `core/locale/`) because the array-vs-object
+ * shape coercion is config-shape adapting, not locale handling. The
+ * lowercasing of keys is the only locale-shaped part.
+ *
+ * @param {Object} settings - Options object containing languages.
+ * @param {import('../logging/index.js').BaselineLogger} [logger] - Logger for dropped-entry notice.
+ * @returns {Record<string, Object>|undefined} Normalized language map, or undefined.
+ */
+export function normalizeLanguageMap(settings, logger) {
+	const normalizedLanguages = Array.isArray(settings.languages)
+		? Object.fromEntries(
+				settings.languages
+					.filter((lang) => typeof lang === 'string' && lang.trim())
+					.map((lang) => [lang.toLowerCase().trim(), {}])
+			)
+		: settings.languages && typeof settings.languages === 'object'
+			? Object.fromEntries(
+					Object.entries(settings.languages).map(([k, v]) => [k.toLowerCase().trim(), v])
+				)
+			: undefined;
+
+	if (logger && Array.isArray(settings.languages)) {
+		const normalizedCount = normalizedLanguages ? Object.keys(normalizedLanguages).length : 0;
+		if (normalizedCount !== settings.languages.length) {
+			logger.info('Some languages entries were invalid and were dropped.');
+		}
+	}
+	return normalizedLanguages;
+}

package/core/utils/resolve-field.js

@@ -0,0 +1,9 @@
+/**
+ * Resolve a field with a page → site → fallback precedence chain.
+ *
+ * @param {{ pageValue?: any, siteValue?: any, fallbackValue?: any, isHome?: boolean }} args
+ * @returns {any}
+ */
+export function resolveField({ pageValue, siteValue, fallbackValue }) {
+	return pageValue ?? siteValue ?? fallbackValue;
+}

package/core/utils/resolve-subdir.js

@@ -0,0 +1,20 @@
+import { TemplatePath } from '@11ty/eleventy-utils';
+import { addTrailingSlash } from './add-trailing-slash.js';
+
+/**
+ * Resolve a subdirectory under input and output.
+ * Joins inputDir/outputDir with rawDir, normalises, and adds trailing slashes.
+ * @param {string} inputDir - The input directory (e.g., "./src/").
+ * @param {string} outputDir - The output directory (e.g., "./dist/").
+ * @param {string} rawDir - Raw subdirectory value (e.g., "assets", "static").
+ * @returns {{input: string, output: string}}
+ */
+export function resolveSubdir(inputDir, outputDir, rawDir) {
+	const joinedInput = TemplatePath.join(inputDir, rawDir || '');
+	const joinedOutput = TemplatePath.join(outputDir, rawDir || '');
+
+	return {
+		input: addTrailingSlash(TemplatePath.standardizeFilePath(joinedInput)),
+		output: addTrailingSlash(TemplatePath.standardizeFilePath(joinedOutput))
+	};
+}

package/core/utils/slugify.js

@@ -0,0 +1,15 @@
+import slugifyLib from 'slugify';
+
+/**
+ * Slugify a string into a wikilink-friendly key.
+ * Lowercases, strips diacritics, replaces non-alphanumerics with hyphens,
+ * trims leading/trailing hyphens. Returns undefined for empty input.
+ *
+ * @param {string|null|undefined} input
+ * @returns {string|undefined}
+ */
+export function slugify(input) {
+	if (input == null) return;
+	const slug = slugifyLib(String(input), { lower: true, strict: true, trim: true });
+	return slug || undefined;
+}

package/core/utils/title-case-slug.js

@@ -0,0 +1,15 @@
+/**
+ * Title-case a URL slug for display: "core-reference" → "Core Reference".
+ * The rough inverse of {@link slugify}: splits on hyphens/underscores and
+ * capitalises each word.
+ *
+ * @param {string} slug
+ * @returns {string}
+ */
+export function titleCaseSlug(slug) {
+	return String(slug)
+		.split(/[-_]/)
+		.filter(Boolean)
+		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+		.join(' ');
+}

package/core/utils/unique-by.js

@@ -0,0 +1,25 @@
+/**
+ * Deduplicate an array by a key (string property name or selector function).
+ * Items without a derivable key are kept via their JSON-stringified shape.
+ *
+ * @template T
+ * @param {T[]} arr
+ * @param {string | ((item: T) => string | undefined)} keyFn
+ * @returns {T[]}
+ */
+export const uniqueBy = (arr, keyFn) =>
+	Object.values(
+		(arr ?? []).reduce((acc, item) => {
+			if (!item) return acc;
+
+			const id = typeof keyFn === 'function' ? keyFn(item) : item?.[keyFn];
+
+			if (!id) {
+				acc[JSON.stringify(item)] = item;
+				return acc;
+			}
+
+			acc[id] = item;
+			return acc;
+		}, {})
+	);

package/core/virtual-dir.js

@@ -1,8 +1,11 @@
-import { TemplatePath } from '@11ty/eleventy-utils';
-import { resolveSubdir } from './utils/helpers.js';
-import { createLogger } from './logging.js';
+import { ensureDotSlashDir } from './utils/ensure-dot-slash-dir.js';
+import { resolveSubdir } from './utils/resolve-subdir.js';
+import { createLogger } from './logging/index.js';
 import { getScope, addScopeListener, setEntry } from './registry.js';
 
+const SCOPE_NAME = 'core:virtual-dir';
+const LOG_NAME = 'virtual-dir';
+
 /**
  * Virtual directories (runtime substrate)
  *
@@ -40,8 +43,6 @@ import { getScope, addScopeListener, setEntry } from './registry.js';
  *   live { input, output } cache → consumers
  */
 
-const SCOPE_NAME = 'core:virtual-dir';
-
 /**
  * Register a virtual directory on eleventyConfig.directories.
  *
@@ -56,10 +57,10 @@ const SCOPE_NAME = 'core:virtual-dir';
  */
 export function registerVirtualDir(eleventyConfig, { key, outputDir } = {}) {
 	if (!key) {
-		throw new Error('registerVirtualDir: `name` is required');
+		throw new Error('[baseline/virtual-dir] `name` is required');
 	}
 
-	const log = createLogger(SCOPE_NAME);
+	const log = createLogger(LOG_NAME);
 	const scope = getScope(eleventyConfig, SCOPE_NAME);
 	const rawDir = eleventyConfig.dir?.[key] || key;
 	const rawOutputDir = outputDir ?? rawDir;
@@ -75,7 +76,7 @@ export function registerVirtualDir(eleventyConfig, { key, outputDir } = {}) {
 	// shared listener below refreshes when Eleventy emits its final directories.
 	const existing = Object.getOwnPropertyDescriptor(eleventyConfig.directories, key);
 	if (existing && existing.configurable === false) {
-		log.info(`directories[${key}] already defined; skipping`);
+		log.info(`directories.${key} already defined, skipping`);
 	} else {
 		Object.defineProperty(eleventyConfig.directories, key, {
 			get() {
@@ -101,8 +102,8 @@ export function registerVirtualDir(eleventyConfig, { key, outputDir } = {}) {
 }
 
 function syncCache(cache, dirs, rawDir, rawOutputDir) {
-	const inputDir = TemplatePath.addLeadingDotSlash(dirs.input || './');
-	const outputDir = TemplatePath.addLeadingDotSlash(dirs.output || './');
+	const inputDir = ensureDotSlashDir(dirs.input);
+	const outputDir = ensureDotSlashDir(dirs.output);
 
 	// resolveSubdir symmetrically resolves against input and output; call twice
 	// so input and output subdirs can differ (e.g. `public` copies to root).

package/index.js

@@ -3,36 +3,41 @@ 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 { registerSeoGraph } from './core/seo-graph/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 +49,20 @@ const INTERNAL_KEYS = [
 	'_navigator',
 	'_sitemap',
 	'_snapshot',
-	'_pageContext'
+	'eleventyComputed._pageContext',
+	'eleventyComputed._node',
+	'eleventyComputed._seoGraph',
+	'eleventyComputed._backlinks',
+	'eleventyComputed._outgoing',
+	'eleventyComputed._edges'
 ];
 
-/**
- * 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 +106,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 +141,70 @@ 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._seoGraph' ||
+				key === 'eleventyComputed._backlinks' ||
+				key === 'eleventyComputed._outgoing' ||
+				key === 'eleventyComputed._edges'
+			)
+				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 +213,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 +233,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 +279,9 @@ export default function baseline(settings = {}, options = {}) {
 				get contentMap() {
 					return contentMapStore.get();
 				},
+				get contentGraph() {
+					return contentGraph;
+				},
 				translationMap: translationMapStore,
 				slugIndex
 			},
@@ -284,47 +289,85 @@ export default function baseline(settings = {}, options = {}) {
 			helpers
 		};
 
-		// Page context registry
+		// Page context and SEO graph registries
 		const pageContextRegistry = registerPageContext(eleventyConfig, coreContext);
+		const seoGraphRegistry = registerSeoGraph(eleventyConfig, coreContext);
+
+		// --- 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 [];
 
-		// Wikilinks: [[slug]] / [[slug | lang]] in body markdown.
+			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
+			pageContext: () => pageContextRegistry.snapshot(),
+			seoGraph: () => seoGraphRegistry.snapshot()
 		};
 
 		// --- 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, seoGraph: 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;
 			const moduleContext = {
 				...coreContext,
 				log: scopedLog(name),
-				resolvePageContext: consumes.pageContext ? pageContextRegistry : null
+				resolvePageContext: consumes.pageContext ? pageContextRegistry : null,
+				resolveSeoGraph: consumes.seoGraph ? seoGraphRegistry : null
 			};
 
 			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 */';
 	}