@apleasantview/eleventy-plugin-baseline 0.1.0-next.33 → 0.1.0-next.39

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

@@ -0,0 +1,140 @@
+import { getWeight, ElementWeights } from '@rviscomi/capo.js';
+import { capoPosthtmlAdapter as adapter } from './capo-adapter.js';
+import { dedupeMeta, dedupeLink } from '../utils/dedupe.js';
+
+/**
+ * PostHTML head driver (driver)
+ *
+ * Default head renderer. Emits standard meta tags, layers user extras and
+ * hreflang alternates on top, dedupes, capo-sorts, and replaces the
+ * <baseline-head> placeholder with the result.
+ *
+ * Architecture layer:
+ *   module (driver inside head)
+ *
+ * System role:
+ *   The seam between head's pipeline and the renderer choice. Alternate
+ *   drivers can be substituted at the import site without changing the
+ *   cascade-time seed builder.
+ *
+ * Lifecycle:
+ *   transform-time → emit, dedupe, sort, mutate the PostHTML tree
+ *
+ * Why this exists:
+ *   Splitting the renderer from the seed builder lets head swap rendering
+ *   strategies (e.g. a future direct-DOM driver) without touching cascade
+ *   wiring or the page-context shape.
+ *
+ * Scope:
+ *   Owns node emission, dedupe orchestration, capo sort, and placeholder
+ *   replacement.
+ *   Does not own seed shape (page context), hreflang building
+ *   (head/utils/alternates.js), or capo's element weights (capo.js).
+ *
+ * Data flow:
+ *   seeds + alternates + options → emit → dedupe → capo-sort → PostHTML
+ *   tree mutation
+ *
+ * @param {Object} args
+ * @param {Object} args.seeds - Page context for the current page.
+ * @param {Array<Object>} args.alternates - hreflang link descriptors.
+ * @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 }) {
+	const defaults = emitMeta(seeds.meta, seeds.render, options);
+	const extras = emitExtras(seeds.head, alternates);
+
+	const deduped = dedupeAll([...defaults, ...extras]);
+	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)
+		}));
+		return tree;
+	};
+}
+
+function emitMeta(meta, render, options) {
+	const nodes = [];
+	nodes.push(mkMeta({ charset: 'UTF-8' }));
+	nodes.push(mkMeta({ name: 'viewport', content: 'width=device-width, initial-scale=1.0' }));
+	if (meta.title) nodes.push({ tag: 'title', content: [meta.title] });
+	if (meta.description) nodes.push(mkMeta({ name: 'description', content: meta.description }));
+	nodes.push(mkMeta({ name: 'robots', content: meta.robots }));
+	if (meta.canonical) nodes.push(mkLink({ rel: 'canonical', href: meta.canonical }));
+	if (options.showGenerator && render.generator) {
+		nodes.push(mkMeta({ name: 'generator', content: render.generator }));
+	}
+
+	return nodes;
+}
+
+function emitExtras(head, alternates = []) {
+	const nodes = [];
+	for (const m of asArray(head?.meta)) nodes.push(mkMeta(m));
+	for (const l of asArray(head?.link)) {
+		if (l?.rel === 'canonical') continue; // 🚨 remove duplication source
+		nodes.push(mkLink(l));
+	}
+	for (const s of asArray(head?.script)) nodes.push(mkScript(s));
+	for (const s of asArray(head?.style)) nodes.push(mkStyle(s));
+	for (const a of alternates) nodes.push(mkLink(a));
+
+	return nodes;
+}
+
+function dedupeAll(nodes) {
+	const metas = [];
+	const links = [];
+	const others = [];
+	for (const n of nodes) {
+		if (n.tag === 'meta') metas.push(n.attrs || {});
+		else if (n.tag === 'link') links.push(n.attrs || {});
+		else others.push(n);
+	}
+	const dedupedMetas = dedupeMeta(metas).map(mkMeta);
+	const dedupedLinks = dedupeLink(links).map(mkLink);
+
+	return [...dedupedMetas, ...dedupedLinks, ...others];
+}
+
+function capoSort(nodes) {
+	const weighted = nodes.map((node, i) => ({
+		node,
+		i,
+		weight: adapter.isElement(node) ? getWeight(node, adapter) : ElementWeights.OTHER
+	}));
+	weighted.sort((a, b) => b.weight - a.weight || a.i - b.i);
+
+	return weighted.map((w) => w.node);
+}
+
+function mkMeta(attrs) {
+	return { tag: 'meta', attrs };
+}
+function mkLink(attrs) {
+	return { tag: 'link', attrs };
+}
+function mkScript(entry) {
+	const { content, ...attrs } = entry || {};
+	return content !== undefined ? { tag: 'script', attrs, content: [content] } : { tag: 'script', attrs };
+}
+function mkStyle(entry) {
+	const { content, ...attrs } = entry || {};
+	return content !== undefined ? { tag: 'style', attrs, content: [content] } : { tag: 'style', attrs };
+}
+function asArray(v) {
+	return Array.isArray(v) ? v : [];
+}
+function interleaveEOL(nodes, eol) {
+	const out = [];
+	for (const n of nodes) out.push(n, eol);
+	return out;
+}

package/modules/head/index.js

@@ -0,0 +1,106 @@
+import { renderHead } from './drivers/posthtml-head-elements.js';
+import { buildAlternates } from './utils/alternates.js';
+import { optionsSchema } from './schema.js';
+
+// Internal constants — not user-facing.
+const PLACEHOLDER_TAG = 'baseline-head';
+const EOL = '\n';
+
+/**
+ * Head (module)
+ *
+ * Render-time <head> composer. Turns the normalised page context into a
+ * sorted, deduped element list and replaces <baseline-head> in the output.
+ *
+ * Architecture layer:
+ *   module
+ *
+ * System role:
+ *   Consumes the page context (built at cascade-time) and the translation
+ *   map (written at cascade-time) to produce the final <head> at
+ *   transform-time.
+ *
+ * Lifecycle:
+ *   cascade-time   → upstream page-context registry builds the per-page seeds
+ *   transform-time → PostHTML plugin reads seeds, emits nodes, capo-sorts,
+ *                    replaces <baseline-head>
+ *
+ * Why this exists:
+ *   Eleventy's htmlTransformer context exposes only page metadata, not the
+ *   full data cascade. Pre-built seeds in the page-context registry carry
+ *   every field the composer needs from cascade-time into transform-time.
+ *
+ * Scope:
+ *   Owns transform-time composition and placeholder replacement.
+ *   Pass 1 covers bucket 1 only: charset, viewport, title, description,
+ *   robots, canonical, optional generator, plus user extras from
+ *   settings.head and hreflang alternates. SEO and JSON-LD are later passes.
+ *   Does not own seed shape (page context) or driver internals.
+ *
+ * Data flow:
+ *   page context + translation-map store + settings.head → driver →
+ *   PostHTML tree mutation (replaces <baseline-head>)
+ *
+ * @param {import("@11ty/eleventy").UserConfig} eleventyConfig
+ * @param {Object} moduleContext
+ */
+export function headCore(eleventyConfig, moduleContext) {
+	const { state, runtime, log } = moduleContext;
+	const { settings, options } = state;
+
+	// Structural-only options check: log on mismatch, do not throw.
+	const parsed = optionsSchema.safeParse(options.head);
+	if (!parsed.success) {
+		for (const issue of parsed.error.issues) {
+			log.info('options:', `${issue.path.join('.')} — ${issue.message}`);
+		}
+	}
+
+	const pageContextRegistry = moduleContext.resolvePageContext;
+
+	// Resolved plugin options with defaults.
+	const headOptions = {
+		titleSeparator: options.head?.titleSeparator ?? ' – ',
+		showGenerator: options.head?.showGenerator ?? false
+	};
+
+	// Per-build stats (cleared on eleventy.after for watch-mode reruns).
+	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)
+		});
+		headStats.pages.clear();
+	});
+
+	// --- Transform-time: compose and inject. ---
+	log.info('Injecting heads to pages');
+	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);
+			return (tree) => tree;
+		}
+
+		const translationKey = seeds.page?.locale?.translationKey;
+
+		const alternates = translationKey
+			? buildAlternates(seeds.page?.locale?.translationKey, runtime.translationMap.get(), seeds.site?.url)
+			: [];
+
+		return renderHead({
+			seeds,
+			alternates,
+			options: headOptions,
+			placeholderTag: PLACEHOLDER_TAG,
+			eol: EOL,
+			log
+		});
+	});
+}

package/modules/head/schema.js

@@ -0,0 +1,42 @@
+import * as z from 'zod';
+
+// Structural schemas for head-core. Permissive on unknown keys, typed on
+// keys the driver reads. Non-throwing at the call site — safeParse only.
+
+// `options.head` slice: render-behaviour knobs.
+export const optionsSchema = z.looseObject({
+	titleSeparator: z.string().optional(),
+	showGenerator: z.boolean().optional()
+});
+
+// `settings.head` extras slot: additive link/script/meta/style arrays.
+export const settingsHeadSchema = z.looseObject({
+	link: z.array(z.looseObject({})).optional(),
+	script: z.array(z.looseObject({})).optional(),
+	meta: z.array(z.looseObject({})).optional(),
+	style: z.array(z.looseObject({})).optional()
+});
+
+// `settings.seo` site-default SEO scalars, page-overridable.
+export const settingsSeoSchema = z.looseObject({
+	ogImage: z.string().optional(),
+	twitterSite: z.string().optional()
+});
+
+// Page-level `seo:` block. Same scalar set as bare front matter, namespaced.
+// `seo.foo` wins over bare `foo`.
+export const pageSeoSchema = z.looseObject({
+	title: z.string().optional(),
+	description: z.string().optional(),
+	noindex: z.boolean().optional(),
+	canonical: z.string().optional(),
+	ogTitle: z.string().optional(),
+	ogDescription: z.string().optional(),
+	ogType: z.string().optional(),
+	ogImage: z.string().optional(),
+	twitterCard: z.string().optional(),
+	twitterSite: z.string().optional(),
+	twitterTitle: z.string().optional(),
+	twitterDescription: z.string().optional(),
+	twitterImage: z.string().optional()
+});

package/modules/head/utils/alternates.js

@@ -0,0 +1,11 @@
+export function buildAlternates(translationKey, translationsMap, siteUrl) {
+	if (!translationKey || !translationsMap) return [];
+	const variants = translationsMap[translationKey];
+	if (!variants) return [];
+	return Object.values(variants).flatMap((entry) => {
+		if (!entry?.url) return [];
+		const href = siteUrl ? new URL(entry.url, siteUrl).href : entry.url;
+		const link = { rel: 'alternate', hreflang: entry.lang, href };
+		return entry.isDefaultLang ? [link, { ...link, hreflang: 'x-default' }] : [link];
+	});
+}

package/modules/head/utils/dedupe.js

@@ -0,0 +1,47 @@
+/**
+ * Deduplicate meta tags. Last-wins by key (charset, name, property, http-equiv).
+ * Preserves insertion order after dedup.
+ * @param {Array<Object>} [arr=[]] - Array of meta tag objects.
+ * @returns {Array<Object>}
+ */
+function metaKey(meta) {
+	if (meta.charset) return 'charset';
+	if (meta.name) return `name:${meta.name}`;
+	if (meta.property) return `prop:${meta.property}`;
+	if (meta['http-equiv']) return `http:${meta['http-equiv']}`;
+	return null;
+}
+
+export const dedupeMeta = (arr = []) => {
+	const seen = new Set();
+	const out = [];
+
+	for (let i = arr.length - 1; i >= 0; i--) {
+		const key = metaKey(arr[i]);
+		if (!key || seen.has(key)) continue;
+		seen.add(key);
+		out.push(arr[i]);
+	}
+
+	return out.reverse();
+};
+
+/**
+ * Deduplicate link tags by rel+hreflang+href. Last-wins, preserves insertion order.
+ * @param {Array<Object>} [links=[]] - Array of link tag objects.
+ * @returns {Array<Object>}
+ */
+export const dedupeLink = (links = []) => {
+	const seen = new Set();
+	const out = [];
+
+	for (let i = links.length - 1; i >= 0; i--) {
+		const link = links[i];
+		const key = link.rel && link.href ? `rel:${link.rel}|hreflang:${link.hreflang ?? ''}|${link.href}` : null;
+		if (!key || seen.has(key)) continue;
+		seen.add(key);
+		out.push(link);
+	}
+
+	return out.reverse();
+};

package/modules/multilang/index.js

@@ -0,0 +1,149 @@
+import { I18nPlugin } from '@11ty/eleventy';
+import { DeepCopy } from '@11ty/eleventy-utils';
+import { normalizeLanguages } from '../../core/utils/helpers.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';
+
+/**
+ * Multilang (module)
+ *
+ * Language infrastructure. Normalises language config, builds translation
+ * relationships, attaches per-page locale data, and exposes cross-language
+ * lookup filters. Active only when options.multilingual is true and both
+ * defaultLanguage and at least one languages entry are set; otherwise the
+ * module exits early.
+ *
+ * Architecture layer:
+ *   module
+ *
+ * System role:
+ *   Wraps Eleventy's I18nPlugin and feeds the translation-map store that
+ *   head reads at transform-time. Sitemap reuses the same normalised
+ *   language map.
+ *
+ * Lifecycle:
+ *   build-time   → normalise languages, attach I18nPlugin, register filters
+ *                  and computed page.locale
+ *   cascade-time → translationsMap and translations collections build the
+ *                  per-translationKey map and write it to the store
+ *
+ * Why this exists:
+ *   I18nPlugin handles locale-aware routing but not translation
+ *   relationships. Head needs a transform-time-readable hreflang map; the
+ *   collection populates it once and the store carries it across the
+ *   lifecycle boundary.
+ *
+ * Scope:
+ *   Owns language normalisation, page.locale computation, the translations
+ *   and translationsMap collections, and the i18n filters
+ *   (i18nTranslationsFor, i18nTranslationIn, i18nDefaultTranslation).
+ *   Does not own URL routing (I18nPlugin) or hreflang rendering (head).
+ *
+ * Data flow:
+ *   settings.languages + page.lang/translationKey → normalisation +
+ *   I18nPlugin → collections + computed page.locale + translation-map
+ *   store → head, sitemap
+ *
+ * @param {import("@11ty/eleventy/src/UserConfig.js").default} eleventyConfig
+ * @param {Object} moduleContext
+ */
+export function multilangCore(eleventyConfig, moduleContext) {
+	const { state, runtime, log } = moduleContext;
+	const { settings, options } = state;
+
+	// --- Language normalization ---
+	// Accept languages as array or object; normalize to object map.
+	// Drives collection building, locale data, and sitemap-core language config.
+	const normalizeLanguageCode = (lang) => (lang || '').toLowerCase().trim();
+	const defaultLanguage = normalizeLanguageCode(settings.defaultLanguage);
+	const languages = normalizeLanguages(settings, log);
+	const hasLanguages = languages && Object.keys(languages).length > 0;
+
+	const isMultilingual = options.multilang === true && defaultLanguage && hasLanguages;
+
+	if (!isMultilingual) {
+		log.info('inactive: requires options.multilingual + settings.defaultLanguage + languages');
+		return;
+	}
+
+	// Register Eleventy's built-in I18nPlugin for locale-aware URL resolution.
+	eleventyConfig.addPlugin(I18nPlugin, {
+		defaultLanguage: defaultLanguage,
+		errorMode: 'allow-fallback'
+	});
+
+	// Computed locale data: every page gets a page.locale object with its
+	// resolved lang, translationKey, and whether it's the default language.
+	eleventyConfig.addGlobalData('eleventyComputed.page.locale', () => {
+		return (data) => {
+			const translationKey = data.translationKey;
+			const lang = normalizeLanguageCode(data.lang || data.language || defaultLanguage);
+			const isDefaultLang = lang === defaultLanguage;
+
+			return {
+				translationKey,
+				lang,
+				isDefaultLang
+			};
+		};
+	});
+
+	// Build a set of allowed language codes for validation during collection building.
+	const allowedLanguages = new Set(Object.keys(languages).map(normalizeLanguageCode));
+
+	// Build both the map (keyed by translationKey → lang) and the flat list.
+	// Shared logic for both collections — called once per collection registration.
+	const buildTranslations = (collection) => {
+		const map = {};
+		const list = [];
+
+		for (const page of collection.getAll()) {
+			const translationKey = page.data.translationKey;
+			if (!translationKey) continue;
+
+			const lang = page.data.lang || page.data.language || defaultLanguage;
+			if (!lang) continue;
+
+			if (allowedLanguages.size && !allowedLanguages.has(lang)) {
+				log.info(`Unknown lang "${lang}" in ${page.inputPath}`);
+				continue;
+			}
+
+			const locale = { locale: { translationKey, lang, isDefaultLang: lang === defaultLanguage } };
+			const safeCopy = DeepCopy(page, locale);
+			list.push(safeCopy);
+
+			if (!map[translationKey]) map[translationKey] = {};
+			map[translationKey][lang] = {
+				title: page.data.title,
+				url: page.url,
+				lang,
+				isDefaultLang: lang === defaultLanguage,
+				data: page.data
+			};
+		}
+
+		return { map, list };
+	};
+
+	// --- Collections ---
+
+	// Map form: translationsMap[translationKey][lang] → page metadata.
+	eleventyConfig.addCollection('translationsMap', (collection) => {
+		const map = buildTranslations(collection).map;
+		runtime.translationMap.set(map);
+		return map;
+	});
+
+	// Flat list: all translatable pages with locale data attached.
+	eleventyConfig.addCollection('translations', (collection) => {
+		return buildTranslations(collection).list;
+	});
+
+	// --- Filters ---
+	// Relational helpers for cross-language lookups in templates.
+	eleventyConfig.addFilter('i18nTranslationsFor', i18nTranslationsFor);
+	eleventyConfig.addFilter('i18nTranslationIn', i18nTranslationIn);
+	eleventyConfig.addFilter('i18nDefaultTranslation', i18nDefaultTranslation);
+}

package/modules/navigator/index.js

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import debug from './utils/debug.js';
+import { optionsSchema } from './schema.js';
+
+const __filename = fileURLToPath(import.meta.url);
+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.
+ *
+ * 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.
+ *
+ * Lifecycle:
+ *   build-time   → register Nunjucks globals, debug 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.
+ *
+ * Scope:
+ *   Owns the `_runtime` and `_ctx` Nunjucks globals, 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).
+ *
+ * Data flow:
+ *   snapshots (contentMap, pageContext) + this.ctx → globals + computed
+ *   `_snapshot` + virtual page → developer
+ *
+ * Note: `_snapshot.contentMap` is null on the navigator template itself
+ * because it renders before `eleventy.contentMap` fires. Read `_snapshot`
+ * from any ordinary page for a populated contentMap.
+ *
+ * @param {import("@11ty/eleventy").UserConfig} eleventyConfig
+ * @param {Object} moduleContext
+ * @param {Object} moduleContext.state - Resolved plugin state.
+ * @param {Object} moduleContext.snapshots - Thunks: { contentMap, pageContext }.
+ */
+export function navigatorCore(eleventyConfig, moduleContext) {
+	const { state, 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}`);
+		}
+	}
+
+	// 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 inspectorDepth = navigatorOpts.inspectorDepth ?? 4;
+
+	eleventyConfig.addGlobalData('eleventyComputed._snapshot', () => {
+		return () => ({
+			contentMap: snapshots.contentMap(),
+			pageContext: snapshots.pageContext()
+		});
+	});
+
+	/**
+	 * Nunjucks Global: _runtime
+	 *
+	 * Exposes internal Nunjucks runtime state:
+	 * - env  → environment instance
+	 * - ctx  → current render context
+	 * - globals → registered global values
+	 */
+	eleventyConfig.addNunjucksGlobal('_runtime', function () {
+		return {
+			env: this.env,
+			ctx: this.ctx,
+			globals: this.env?.globals
+		};
+	});
+
+	/**
+	 * Nunjucks Global: _ctx
+	 *
+	 * Direct reference to the template execution context.
+	 * Useful for debugging data shape at render time.
+	 */
+	eleventyConfig.addNunjucksGlobal('_ctx', function () {
+		return this.ctx;
+	});
+
+	/**
+	 * Virtual Debug Template
+	 *
+	 * Registers a synthetic Eleventy page that dumps runtime context.
+	 * This is only enabled when explicitly configured via options.
+	 */
+	if (renderTemplate) {
+		const templatePath = path.join(__dirname, './templates/navigator-core.html');
+		const virtualTemplateContent = fs.readFileSync(templatePath, 'utf-8');
+
+		eleventyConfig.addTemplate('navigator-core.html', virtualTemplateContent, {
+			permalink: '/navigator-core.html',
+			title: 'Navigator Core',
+			description: 'Eleventy + Baseline internals',
+			layout: null,
+			eleventyExcludeFromCollections: true,
+			_internal: false,
+
+			// Debug control surface
+			inspectorDepth
+		});
+
+		log.info('Navigator template registered at /navigator-core.html');
+	}
+
+	/**
+	 * Debug Filters
+	 *
+	 * Lightweight helpers for inspecting values in templates.
+	 * These are intentionally prefixed to avoid collisions.
+	 */
+	eleventyConfig.addFilter('_inspect', debug.inspect);
+	eleventyConfig.addFilter('_json', debug.json);
+	eleventyConfig.addFilter('_keys', debug.keys);
+}

package/modules/navigator/schema.js

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+
+// Structural schema for the `options.navigator` slice. Accepts boolean
+// shorthand or object form; permissive on unknown keys, typed on the keys
+// the module reads. Non-throwing at the call site.
+
+export const optionsSchema = z.union([
+	z.boolean(),
+	z.looseObject({
+		template: z.boolean().optional(),
+		inspectorDepth: z.number().int().min(0).optional()
+	})
+]).optional();

package/modules/{navigator-core → navigator}/templates/navigator-core.html

@@ -4,7 +4,7 @@ permalink: /navigator-core.html
 ---
 
 <!DOCTYPE html>
-<html lang="{{ lang | default(site.defaultLanguage) }}">
+<html lang="{{ lang | default(settings.defaultLanguage) }}">
 
 <head>
 	<baseline-head></baseline-head>
@@ -28,9 +28,9 @@ permalink: /navigator-core.html
 	</a>
 	<header>
 		<div class="_navigator__wrapper">
-			<h1>{{ site.title }} Navigator</h1>
+			<h1>{{ settings.title }} Navigator</h1>
 			<div>
-				<p>{{ site.tagline }}</p>
+				<p>{{ settings.tagline }}</p>
 			</div>
 		</div>
 	</header>
@@ -38,7 +38,13 @@ permalink: /navigator-core.html
 		<div class="_navigator__wrapper">
 			<p><a id="go-back" href=""><span style="vertical-align: text-bottom;">&#8592;</span>&nbsp;Go back</a></p>
 			<h2><u>Navigator</u></h2>
-			{% for key, value in _navigator() %}
+			<details>
+				<summary><strong>Page Context</strong></summary>
+				<pre>
+					{{- _snapshot.pageContext | _inspect({ depth: null }) -}}
+				</pre>
+			</details>
+			{% for key, value in _runtime() %}
 			<details>
 				<summary><strong>{{ key }}</strong></summary>
 				{% if value | isString %}