erudit 4.3.2 → 4.3.3

package/app/app.vue

@@ -2,6 +2,7 @@
 initFavicon();
 initOgImage();
 initOgSiteName();
+initWebSiteJsonLd();
 initAnalytics();
 initScrollUpWatcher();
 

package/app/components/main/MainTopicPartPage.vue

@@ -24,7 +24,7 @@ const phrase = await usePhrases(
   'summary_seo_description',
   'practice_seo_description',
 );
-const lastChangedDate = useLastChanged(() => mainContent.contentRelativePath);
+const lastChangedDate = useLastChanged(() => mainContent.lastmod);
 
 await useContentSeo({
   title: mainContent.title,
@@ -47,6 +47,8 @@ await useContentSeo({
           : undefined,
   seo: mainContent.seo,
   snippets: mainContent.snippets,
+  breadcrumbs: mainContent.breadcrumbs,
+  lastmod: mainContent.lastmod,
 });
 </script>
 

package/app/composables/analytics.ts

@@ -73,17 +73,24 @@ function yandexAnalytics(analytics: YandexAnalytics) {
 (function(m,e,t,r,i,k,a){
     m[i]=m[i]||function(){(m[i].a=m[i].a||[]).push(arguments)};
     m[i].l=1*new Date();
-    k=e.createElement(t),a=e.getElementsByTagName(t)[0],
-    k.async=1,k.src=r,a.parentNode.insertBefore(k,a)
-})(window, document, "script", "https://mc.yandex.ru/metrika/tag.js", "ym");
+    for (var j = 0; j < document.scripts.length; j++) {if (document.scripts[j].src === r) { return; }}
+    k=e.createElement(t),a=e.getElementsByTagName(t)[0],k.async=1,k.src=r,a.parentNode.insertBefore(k,a)
+})(window, document,'script','https://mc.yandex.ru/metrika/tag.js?id=${analytics.metricsId}', 'ym');
 
-ym(${analytics.metricsId}, "init", {
+ym(
+  ${analytics.metricsId},
+  'init',
+  {
+    ssr:true,
+    webvisor:true,
     clickmap:true,
-    trackLinks:true,
+    referrer: document.referrer,
+    url: location.href,
     accurateTrackBounce:true,
-    webvisor:true
-});
-                    `.trim(),
+    trackLinks:true
+  }
+);
+`.trim(),
         },
       ],
     });

package/app/composables/favicon.ts

@@ -1,9 +1,9 @@
 import { isTopicPart, type TopicPart } from '@erudit-js/core/content/topic';
 import { isContentType, type ContentType } from '@erudit-js/core/content/type';
 
-const fallbackFaviconHref = eruditPublic('favicons/default.svg');
+const FALLBACK_FAVICON_EXT = '.svg';
 
-const faviconMimeByExt: Record<string, string> = {
+const mimeByExt: Record<string, string> = {
   '.svg': 'image/svg+xml',
   '.png': 'image/png',
   '.ico': 'image/x-icon',
@@ -14,24 +14,28 @@ const faviconMimeByExt: Record<string, string> = {
   '.bmp': 'image/bmp',
 };
 
-function getFaviconMimeType(href: string): string | undefined {
-  const pathPart = href.split(/[?#]/)[0] ?? '';
-  const dot = pathPart.lastIndexOf('.');
-  if (dot === -1) return undefined;
-  const ext = pathPart.slice(dot).toLowerCase();
-  return faviconMimeByExt[ext];
+function extFromConfigHref(key: string): string {
+  const href =
+    (ERUDIT.config.favicon as Record<string, string> | undefined)?.[key] ||
+    ERUDIT.config.favicon?.default;
+  if (!href) return FALLBACK_FAVICON_EXT;
+  const path = href.split(/[?#]/)[0] ?? '';
+  const dot = path.lastIndexOf('.');
+  return dot === -1 ? '' : path.slice(dot).toLowerCase();
 }
 
-export const useFaviconHref = () => {
-  return useState<string>('favicon-href', () => fallbackFaviconHref);
-};
+function mimeFromConfigHref(key: string): string | undefined {
+  return mimeByExt[extFromConfigHref(key)];
+}
+
+export const useFaviconKey = () =>
+  useState<string>('favicon-key', () => 'default');
 
 export function useFavicon() {
-  const faviconHref = useFaviconHref();
+  const faviconKey = useFaviconKey();
 
   function showDefaultFavicon() {
-    const defaultFaviconHref = ERUDIT.config.favicon?.default;
-    faviconHref.value = defaultFaviconHref || fallbackFaviconHref;
+    faviconKey.value = 'default';
   }
 
   function showContentFavicon(
@@ -40,15 +44,13 @@ export function useFavicon() {
       | { type: 'topic'; part: TopicPart },
   ) {
     if (args.type === 'topic') {
-      const topicPartHref = ERUDIT.config.favicon?.[args.part];
-      if (topicPartHref) {
-        faviconHref.value = topicPartHref;
+      if (ERUDIT.config.favicon?.[args.part]) {
+        faviconKey.value = args.part;
         return;
       }
     } else {
-      const typeHref = ERUDIT.config.favicon?.[args.type];
-      if (typeHref) {
-        faviconHref.value = typeHref;
+      if (ERUDIT.config.favicon?.[args.type]) {
+        faviconKey.value = args.type;
         return;
       }
     }
@@ -64,22 +66,43 @@ export function useFavicon() {
 
 export function initFavicon() {
   const withBaseUrl = useBaseUrl();
-  const faviconHref = useFaviconHref();
+  const faviconKey = useFaviconKey();
   const { showDefaultFavicon, showContentFavicon } = useFavicon();
   showDefaultFavicon();
 
   useHead({
     link: [
       computed(() => {
-        const href = withBaseUrl(faviconHref.value);
-        const type = getFaviconMimeType(faviconHref.value);
+        const key = faviconKey.value;
+        const ext = extFromConfigHref(key);
+        const mime = mimeFromConfigHref(key);
         return {
           key: 'favicon',
           rel: 'icon',
-          href,
-          ...(type && { type }),
+          href: withBaseUrl(`/favicon/${key}/source${ext}`),
+          ...(mime && { type: mime }),
         };
       }),
+      computed(() => ({
+        key: 'favicon-png-48',
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '48x48',
+        href: withBaseUrl(`/favicon/${faviconKey.value}/48.png`),
+      })),
+      computed(() => ({
+        key: 'favicon-png-32',
+        rel: 'icon',
+        type: 'image/png',
+        sizes: '32x32',
+        href: withBaseUrl(`/favicon/${faviconKey.value}/32.png`),
+      })),
+      computed(() => ({
+        key: 'apple-touch-icon',
+        rel: 'apple-touch-icon',
+        sizes: '180x180',
+        href: withBaseUrl(`/favicon/${faviconKey.value}/180.png`),
+      })),
     ],
   });
 

package/app/composables/jsonLd.ts

@@ -0,0 +1,101 @@
+import type { Breadcrumbs } from '../../shared/types/breadcrumbs';
+
+export function useJsonLd(key: string, data: Record<string, unknown>) {
+  useHead({
+    script: [
+      {
+        key,
+        type: 'application/ld+json',
+        innerHTML: JSON.stringify(data),
+      },
+    ],
+  });
+}
+
+export function initWebSiteJsonLd() {
+  const siteTitle =
+    ERUDIT.config.seo?.siteTitle || ERUDIT.config.asideMajor?.siteInfo?.title;
+
+  if (!siteTitle) {
+    return;
+  }
+
+  const runtimeConfig = useRuntimeConfig();
+  const siteUrl = runtimeConfig.public.siteUrl as string;
+
+  if (!siteUrl) {
+    return;
+  }
+
+  useJsonLd('jsonld-website', {
+    '@context': 'https://schema.org',
+    '@type': 'WebSite',
+    name: siteTitle,
+    url: siteUrl,
+  });
+}
+
+export function useContentBreadcrumbsJsonLd(breadcrumbs?: Breadcrumbs) {
+  if (!breadcrumbs || breadcrumbs.length === 0) {
+    return;
+  }
+
+  const withSiteUrl = useSiteUrl();
+
+  useJsonLd('jsonld-breadcrumbs', {
+    '@context': 'https://schema.org',
+    '@type': 'BreadcrumbList',
+    itemListElement: breadcrumbs.map((item, index) => ({
+      '@type': 'ListItem',
+      position: index + 1,
+      name: formatText(item.title),
+      item: withSiteUrl(item.link),
+    })),
+  });
+}
+
+export function useContentArticleJsonLd(args: {
+  title: string;
+  description?: string;
+  urlPath: string;
+  contentType: string;
+  lastmod?: string;
+}) {
+  const withSiteUrl = useSiteUrl();
+
+  const siteTitle =
+    ERUDIT.config.seo?.siteTitle || ERUDIT.config.asideMajor?.siteInfo?.title;
+
+  const schemaType =
+    args.contentType === 'book'
+      ? 'Book'
+      : args.contentType === 'group'
+        ? 'Course'
+        : 'Article';
+
+  const data: Record<string, unknown> = {
+    '@context': 'https://schema.org',
+    '@type': schemaType,
+    ...(schemaType === 'Article'
+      ? { headline: formatText(args.title) }
+      : { name: formatText(args.title) }),
+    url: withSiteUrl(args.urlPath),
+  };
+
+  if (args.description) {
+    data.description = formatText(args.description);
+  }
+
+  if (args.lastmod) {
+    data.dateModified = args.lastmod;
+  }
+
+  if (siteTitle) {
+    data.isPartOf = {
+      '@type': 'WebSite',
+      name: siteTitle,
+    };
+  }
+
+  useJsonLd('jsonld-content', data);
+}

package/app/composables/lastmod.ts

@@ -0,0 +1,6 @@
+export function useLastChanged(lastmod: MaybeRefOrGetter<string | undefined>) {
+  return computed(() => {
+    const val = toValue(lastmod);
+    return val ? new Date(val) : undefined;
+  });
+}

package/app/composables/og.ts

@@ -1,6 +1,8 @@
 import type { ContentSeo } from '@erudit-js/core/content/seo';
 import { toSeoSnippet } from '@erudit-js/prose';
 
+import type { Breadcrumbs } from '../../shared/types/breadcrumbs';
+
 export function initOgSiteName() {
   const siteTitle =
     ERUDIT.config.seo?.siteTitle || ERUDIT.config.asideMajor?.siteInfo?.title;
@@ -91,6 +93,8 @@ export async function useContentSeo(args: {
   description?: string;
   seo?: ContentSeo;
   snippets?: ElementSnippet[];
+  breadcrumbs?: Breadcrumbs;
+  lastmod?: string;
 }) {
   const canUseBookTitle = ERUDIT.config.seo?.useBookSiteTitle;
 
@@ -142,6 +146,23 @@ export async function useContentSeo(args: {
     });
   }
 
+  //
+  // JSON-LD structured data
+  //
+
+  useContentBreadcrumbsJsonLd(args.breadcrumbs);
+
+  useContentArticleJsonLd({
+    title: args.seo?.title || args.title,
+    description: args.seo?.description || args.description,
+    urlPath: canonicalPath,
+    contentType:
+      args.contentTypePath.type === 'topic'
+        ? 'article'
+        : args.contentTypePath.type,
+    lastmod: args.lastmod,
+  });
+
   //
   // SEO snippets
   //

package/app/pages/book/[...bookId].vue

@@ -19,7 +19,7 @@ if (ERUDIT.config.contributors?.enabled) {
 }
 
 const phrase = await usePhrases('begin_learning');
-const lastChangedDate = useLastChanged(() => mainContent.contentRelativePath);
+const lastChangedDate = useLastChanged(() => mainContent.lastmod);
 
 await useContentSeo({
   title: mainContent.title,
@@ -29,6 +29,8 @@ await useContentSeo({
     contentId: mainContent.shortId,
   },
   seo: mainContent.seo,
+  breadcrumbs: mainContent.breadcrumbs,
+  lastmod: mainContent.lastmod,
 });
 </script>
 

package/app/pages/group/[...groupId].vue

@@ -19,7 +19,7 @@ if (ERUDIT.config.contributors?.enabled) {
 }
 
 const phrase = await usePhrases('group', 'begin_learning');
-const lastChangedDate = useLastChanged(() => mainContent.contentRelativePath);
+const lastChangedDate = useLastChanged(() => mainContent.lastmod);
 
 await useContentSeo({
   title: mainContent.title,
@@ -31,6 +31,8 @@ await useContentSeo({
     contentId: mainContent.shortId,
   },
   seo: mainContent.seo,
+  breadcrumbs: mainContent.breadcrumbs,
+  lastmod: mainContent.lastmod,
 });
 </script>
 

package/app/pages/page/[...pageId].vue

@@ -17,7 +17,7 @@ async function proseMounted() {
   );
 }
 
-const lastChangedDate = useLastChanged(() => mainContent.contentRelativePath);
+const lastChangedDate = useLastChanged(() => mainContent.lastmod);
 
 await useContentSeo({
   title: mainContent.title,
@@ -29,6 +29,8 @@ await useContentSeo({
   },
   seo: mainContent.seo,
   snippets: mainContent.snippets,
+  breadcrumbs: mainContent.breadcrumbs,
+  lastmod: mainContent.lastmod,
 });
 </script>
 

package/app/plugins/prerender.server.ts

@@ -26,6 +26,7 @@ export default defineNuxtPlugin({
       '/api/prerender/quotes',
       '/api/prerender/news',
       '/api/prerender/ogImages',
+      '/api/prerender/favicons',
     ];
 
     for (const provider of routeProviders) {

package/modules/erudit/setup/runtimeConfig.ts

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs';
 import type { Nuxt } from '@nuxt/schema';
 import { sn } from 'unslash';
+import { findPath } from 'nuxt/kit';
 import type { EruditConfig } from '@erudit-js/core/eruditConfig/config';
 import { isDevLikeMode } from '@erudit-js/core/mode';
 
@@ -31,6 +32,7 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
     elements: eruditConfig.elements || [],
     countElements: eruditConfig.countElements || [],
     indexPage: eruditConfig.indexPage,
+    lastmod: await resolveLastmodConfig(eruditConfig),
   }) satisfies EruditRuntimeConfig;
 
   //
@@ -46,9 +48,6 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
         repository:
           eruditConfig.debug?.fakeApi?.repository ??
           (nuxt.options.dev || isDevLikeMode(ERUDIT_MODE)),
-        lastChanged:
-          eruditConfig.debug?.fakeApi?.lastChanged ??
-          (nuxt.options.dev || isDevLikeMode(ERUDIT_MODE)),
       },
       analytics: eruditConfig.debug?.analytics,
     },
@@ -106,3 +105,40 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
     nuxtAugmentations: eruditConfig.nuxtAugmentations,
   };
 }
+
+async function resolveLastmodConfig(
+  eruditConfig: EruditConfig,
+): Promise<EruditRuntimeConfig['lastmod']> {
+  const lastmod = eruditConfig.lastmod;
+
+  if (!lastmod || lastmod.enabled === false) {
+    return undefined;
+  }
+
+  if (lastmod.type === 'git') {
+    return { type: 'git' };
+  }
+
+  if (lastmod.type === 'custom') {
+    if (!lastmod.scriptPath) {
+      throw new Error(
+        'Lastmod config with type "custom" requires a "scriptPath"!',
+      );
+    }
+
+    const absPath = await findPath(lastmod.scriptPath, {
+      cwd: PROJECT_PATH,
+      extensions: ['.ts', '.js'],
+    });
+
+    if (!absPath) {
+      throw new Error(
+        `Failed to resolve lastmod provider path "${lastmod.scriptPath}"!`,
+      );
+    }
+
+    return { type: 'custom', scriptPath: absPath };
+  }
+
+  return undefined;
+}

package/nuxt.config.ts

@@ -53,7 +53,7 @@ export default defineNuxtConfig({
     rollupConfig: {
       // Prevent inlining some packages
       external(source) {
-        const ignore = ['jiti', 'tsprose', '@resvg/resvg-js'];
+        const ignore = ['jiti', 'tsprose', '@resvg/resvg-js', 'sharp'];
 
         for (const ignoreItem of ignore) {
           if (source.includes(ignoreItem)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erudit",
-  "version": "4.3.2",
+  "version": "4.3.3",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,12 +24,11 @@
     }
   },
   "dependencies": {
-    "@erudit-js/cli": "4.3.2",
-    "@erudit-js/core": "4.3.2",
-    "@erudit-js/prose": "4.3.2",
-    "unslash": "^2.0.0",
+    "@erudit-js/cli": "4.3.3",
+    "@erudit-js/core": "4.3.3",
+    "@erudit-js/prose": "4.3.3",
     "@floating-ui/vue": "^1.1.11",
-    "tsprose": "^1.0.1",
+    "@resvg/resvg-js": "^2.6.2",
     "@tailwindcss/vite": "^4.2.1",
     "better-sqlite3": "^12.8.0",
     "chokidar": "^5.0.0",
@@ -40,16 +39,18 @@
     "flexsearch": "^0.8.212",
     "glob": "^13.0.6",
     "image-size": "^2.0.2",
-    "@resvg/resvg-js": "^2.6.2",
-    "satori": "^0.25.0",
     "jiti": "^2.6.1",
     "nuxt": "4.4.2",
     "nuxt-my-icons": "1.2.2",
     "perfect-debounce": "^2.1.0",
+    "satori": "^0.25.0",
+    "sharp": "^0.34.5",
     "tailwindcss": "^4.2.1",
+    "ts-xor": "^1.3.0",
+    "tsprose": "^1.0.1",
+    "unslash": "^2.0.0",
     "vue": "latest",
-    "vue-router": "latest",
-    "ts-xor": "^1.3.0"
+    "vue-router": "latest"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13"

package/server/api/main/content/[...contentTypePath].ts

@@ -20,6 +20,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
     ['topic', 'page'].includes(contentTypePath.type),
   );
   const seo = await ERUDIT.repository.content.seo(fullId);
+  const lastmod = await ERUDIT.repository.content.lastmod(fullId);
 
   const bookNode = ERUDIT.contentNav.getBookFor(fullId);
   const bookTitle = bookNode
@@ -37,6 +38,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
     bookTitle,
     breadcrumbs: await ERUDIT.repository.content.breadcrumbs(fullId),
     seo,
+    lastmod,
   };
 
   if (description) {

package/server/api/prerender/favicons.ts

@@ -0,0 +1,31 @@
+import { loadFaviconSource } from '#layers/erudit/server/erudit/favicon/loadSource';
+import {
+  FAVICON_KEYS,
+  FAVICON_SIZES,
+  getFaviconHref,
+  extFromHref,
+} from '#layers/erudit/server/erudit/favicon/shared';
+
+export default defineEventHandler(async () => {
+  const routes: string[] = [];
+
+  for (const key of FAVICON_KEYS) {
+    const href = getFaviconHref(key);
+    if (!href) continue;
+
+    const source = await loadFaviconSource(href);
+    if (!source) continue;
+
+    const ext = extFromHref(href);
+    if (ext) {
+      routes.push(`/favicon/${key}/source${ext}`);
+    }
+
+    for (const size of FAVICON_SIZES) {
+      if (source.width !== undefined && source.width < size) continue;
+      routes.push(`/favicon/${key}/${size}.png`);
+    }
+  }
+
+  return routes;
+});

package/server/erudit/build.ts

@@ -9,6 +9,7 @@ import { buildSponsors } from './sponsors/build';
 import { buildCameos } from './cameos/build';
 import { buildContentNav } from './content/nav/build';
 import { requestFullContentResolve, resolveContent } from './content/resolve';
+import { buildContentLastmod } from './content/lastmod';
 import { buildGlobalContent } from './content/global/build';
 import { buildNews } from './news/build';
 import { triggerReload } from './reloadSignal';
@@ -29,6 +30,7 @@ export async function buildServerErudit() {
       await buildContentNav();
       await buildGlobalContent();
       await resolveContent();
+      await buildContentLastmod();
       ERUDIT.log.success(styleText('green', 'Build Complete!'));
     } catch (buildError) {
       requestFullContentResolve();

package/server/erudit/content/lastmod.ts

@@ -0,0 +1,206 @@
+import { spawnSync } from 'node:child_process';
+import { eq } from 'drizzle-orm';
+import type { LastmodProvider } from '@erudit-js/core/eruditConfig/lastmod';
+
+export async function buildContentLastmod() {
+  const lastmodConfig = ERUDIT.config.lastmod;
+
+  if (!lastmodConfig) {
+    return;
+  }
+
+  ERUDIT.log.debug.start('Collecting lastmod dates...');
+
+  let collected = false;
+
+  if (lastmodConfig.type === 'git') {
+    collected = await collectGitLastmod();
+  } else if (lastmodConfig.type === 'custom' && lastmodConfig.scriptPath) {
+    collected = await collectCustomLastmod(lastmodConfig.scriptPath);
+  }
+
+  if (collected) {
+    ERUDIT.log.success('Lastmod dates collected!');
+  }
+}
+
+function getGitContentPrefix(): string | undefined {
+  const projectRoot = ERUDIT.paths.project();
+
+  const result = spawnSync('git', ['rev-parse', '--show-prefix'], {
+    cwd: projectRoot,
+    encoding: 'utf-8',
+  });
+
+  if (result.status !== 0) return undefined;
+
+  // gitPrefix is e.g. "playground/" or "" (if project is at repo root)
+  return result.stdout.trim() + 'content/';
+}
+
+async function collectGitLastmod(): Promise<boolean> {
+  const projectRoot = ERUDIT.paths.project();
+  const contentPrefix = getGitContentPrefix();
+
+  if (!contentPrefix) {
+    ERUDIT.log.warn(
+      'Failed to detect git prefix — lastmod dates will be unavailable. ' +
+        'Is this a git repository?',
+    );
+    return false;
+  }
+
+  const result = spawnSync(
+    'git',
+    ['log', '--format=format:%cI', '--name-only', '--', contentPrefix],
+    {
+      cwd: projectRoot,
+      encoding: 'utf-8',
+      maxBuffer: 50 * 1024 * 1024,
+    },
+  );
+
+  if (result.status !== 0) {
+    ERUDIT.log.warn(
+      'Failed to run git log — lastmod dates will be unavailable. ' +
+        'Is this a git repository?',
+    );
+    return false;
+  }
+
+  const stdout = result.stdout;
+
+  if (!stdout.trim()) {
+    return false;
+  }
+
+  // Parse git log output: blocks separated by double newlines
+  // Each block: first line = ISO date, remaining lines = file paths
+  const dateMap = new Map<string, string>();
+  const blocks = stdout.split('\n\n');
+
+  for (const block of blocks) {
+    const lines = block.split('\n').filter(Boolean);
+    if (lines.length < 2) continue;
+
+    const date = lines[0]!;
+    for (let i = 1; i < lines.length; i++) {
+      const filePath = lines[i]!;
+      if (!filePath.startsWith(contentPrefix)) continue;
+
+      // Strip the prefix to get the content-relative path
+      // e.g. "playground/content/1-test/page.tsx" → "1-test"
+      const relPath = filePath.slice(contentPrefix.length);
+      const lastSlash = relPath.lastIndexOf('/');
+      const contentRelPath =
+        lastSlash > 0 ? relPath.slice(0, lastSlash) : relPath;
+
+      // Keep only the first (most recent) date per path
+      if (!dateMap.has(contentRelPath)) {
+        dateMap.set(contentRelPath, date);
+      }
+    }
+  }
+
+  // Detect shallow clone: if all dates are identical, warn
+  if (dateMap.size > 1) {
+    const dates = new Set(dateMap.values());
+    if (dates.size === 1) {
+      ERUDIT.log.warn(
+        'All git lastmod dates are identical — this likely means a shallow clone. ' +
+          'Use "fetch-depth: 0" in GitHub Actions checkout for accurate dates.',
+      );
+    }
+  }
+
+  // Build a map keyed by fullId from the contentRelPath-keyed dateMap
+  const ownDates = new Map<string, string>();
+  for (const [, navNode] of ERUDIT.contentNav.id2Node) {
+    const date = dateMap.get(navNode.contentRelPath);
+    if (date) {
+      ownDates.set(navNode.fullId, date);
+    }
+  }
+
+  await propagateAndSave(ownDates);
+  return true;
+}
+
+async function collectCustomLastmod(absPath: string): Promise<boolean> {
+  let provider: LastmodProvider;
+
+  try {
+    const module = await ERUDIT.import(absPath);
+    provider = (module as any).default;
+  } catch (error) {
+    ERUDIT.log.warn(
+      `Failed to import lastmod provider from "${absPath}":\n${error}`,
+    );
+    return false;
+  }
+
+  if (typeof provider !== 'function') {
+    ERUDIT.log.warn(
+      `Lastmod provider at "${absPath}" does not have a default-exported function!`,
+    );
+    return false;
+  }
+
+  // Collect dates from custom provider
+  const customDates = new Map<string, string>();
+
+  for (const [, navNode] of ERUDIT.contentNav.id2Node) {
+    try {
+      const date = await provider({
+        fullId: navNode.fullId,
+        mode: ERUDIT.mode,
+        projectPath: ERUDIT.paths.project(),
+      });
+      if (date instanceof Date && !isNaN(date.getTime())) {
+        customDates.set(navNode.fullId, date.toISOString());
+      }
+    } catch (error) {
+      ERUDIT.log.warn(
+        `Lastmod provider error for "${navNode.fullId}": ${error}`,
+      );
+    }
+  }
+
+  await propagateAndSave(customDates);
+  return true;
+}
+
+/**
+ * Propagate dates upward through the nav tree (parents inherit the most
+ * recent date from their children) and write resolved dates to the DB.
+ */
+async function propagateAndSave(ownDates: Map<string, string>) {
+  // Process deepest nodes first so child dates are finalized before parents
+  const sortedNodes = Array.from(ERUDIT.contentNav.id2Node.values()).sort(
+    (a, b) => b.fullId.split('/').length - a.fullId.split('/').length,
+  );
+
+  const resolvedDates = new Map<string, string>();
+
+  for (const navNode of sortedNodes) {
+    let bestDate = ownDates.get(navNode.fullId);
+
+    for (const child of navNode.children ?? []) {
+      const childDate = resolvedDates.get(child.fullId);
+      if (childDate && (!bestDate || childDate > bestDate)) {
+        bestDate = childDate;
+      }
+    }
+
+    if (bestDate) {
+      resolvedDates.set(navNode.fullId, bestDate);
+    }
+  }
+
+  for (const [fullId, date] of resolvedDates) {
+    await ERUDIT.db
+      .update(ERUDIT.db.schema.content)
+      .set({ lastmod: date })
+      .where(eq(ERUDIT.db.schema.content.fullId, fullId));
+  }
+}

package/server/erudit/content/repository/lastmod.ts

@@ -0,0 +1,12 @@
+import { eq } from 'drizzle-orm';
+
+export async function getContentLastmod(
+  fullId: string,
+): Promise<string | undefined> {
+  const result = await ERUDIT.db.query.content.findFirst({
+    columns: { lastmod: true },
+    where: eq(ERUDIT.db.schema.content.fullId, fullId),
+  });
+
+  return result?.lastmod ?? undefined;
+}

package/server/erudit/db/schema/content.ts

@@ -15,4 +15,5 @@ export const content = sqliteTable('content', {
   decorationExtension: text(),
   externals: text({ mode: 'json' }).$type<ContentExternalItem[]>(),
   seo: text({ mode: 'json' }).$type<ContentSeo>(),
+  lastmod: text(),
 });

package/server/erudit/favicon/convertToPng.ts

@@ -0,0 +1,48 @@
+import sharp from 'sharp';
+import { Resvg } from '@resvg/resvg-js';
+import type { FaviconSource } from './loadSource';
+
+const cache = new Map<string, Buffer>();
+
+export async function convertFaviconToPng(
+  faviconKey: string,
+  source: FaviconSource,
+  size: number,
+): Promise<Buffer> {
+  const cacheKey = `${faviconKey}:${size}`;
+  const cached = cache.get(cacheKey);
+  if (cached) return cached;
+
+  const png =
+    source.mime === 'image/svg+xml'
+      ? await svgToPng(source.buffer, size)
+      : await rasterToPng(source.buffer, size);
+
+  cache.set(cacheKey, png);
+  return png;
+}
+
+async function svgToPng(svgBuffer: Buffer, size: number): Promise<Buffer> {
+  const resvg = new Resvg(svgBuffer.toString('utf-8'), {
+    fitTo: { mode: 'width', value: size },
+  });
+  const rendered = Buffer.from(resvg.render().asPng());
+
+  return sharp(rendered)
+    .resize(size, size, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toBuffer();
+}
+
+async function rasterToPng(buffer: Buffer, size: number): Promise<Buffer> {
+  return sharp(buffer)
+    .resize(size, size, {
+      fit: 'contain',
+      background: { r: 0, g: 0, b: 0, alpha: 0 },
+    })
+    .png()
+    .toBuffer();
+}

package/server/erudit/favicon/loadSource.ts

@@ -0,0 +1,139 @@
+import { readFile } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
+import { imageSize } from 'image-size';
+import { mimeFromExt } from './shared';
+
+export interface FaviconSource {
+  buffer: Buffer;
+  mime: string;
+  /** Undefined for SVG (treated as infinitely scalable) */
+  width?: number;
+  height?: number;
+}
+
+function mimeFromBuffer(buffer: Buffer): string | undefined {
+  if (buffer.length < 12) return undefined;
+
+  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff)
+    return 'image/jpeg';
+
+  if (
+    buffer[0] === 0x89 &&
+    buffer[1] === 0x50 &&
+    buffer[2] === 0x4e &&
+    buffer[3] === 0x47
+  )
+    return 'image/png';
+
+  if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46)
+    return 'image/gif';
+
+  if (
+    buffer[0] === 0x52 &&
+    buffer[1] === 0x49 &&
+    buffer[2] === 0x46 &&
+    buffer[3] === 0x46 &&
+    buffer[8] === 0x57 &&
+    buffer[9] === 0x45 &&
+    buffer[10] === 0x42 &&
+    buffer[11] === 0x50
+  )
+    return 'image/webp';
+
+  if (buffer[0] === 0x42 && buffer[1] === 0x4d) return 'image/bmp';
+
+  if (
+    buffer[0] === 0x00 &&
+    buffer[1] === 0x00 &&
+    buffer[2] === 0x01 &&
+    buffer[3] === 0x00
+  )
+    return 'image/x-icon';
+
+  const head = buffer.subarray(0, 512).toString('utf-8').trim();
+  if (head.startsWith('<svg') || head.startsWith('<?xml'))
+    return 'image/svg+xml';
+
+  return undefined;
+}
+
+function resolveMime(
+  buffer: Buffer,
+  href: string,
+  serverMime?: string,
+): string {
+  return (
+    mimeFromBuffer(buffer) ||
+    mimeFromExt(href) ||
+    (serverMime?.startsWith('image/') ? serverMime : undefined) ||
+    'application/octet-stream'
+  );
+}
+
+function detectDimensions(
+  buffer: Buffer,
+  mime: string,
+): { width?: number; height?: number } {
+  if (mime === 'image/svg+xml') return {};
+
+  try {
+    const size = imageSize(buffer);
+    return { width: size.width, height: size.height };
+  } catch {
+    return {};
+  }
+}
+
+function buildSource(buffer: Buffer, mime: string): FaviconSource {
+  return { buffer, mime, ...detectDimensions(buffer, mime) };
+}
+
+const cache = new Map<string, FaviconSource | null>();
+
+export async function loadFaviconSource(
+  href: string,
+): Promise<FaviconSource | undefined> {
+  if (cache.has(href)) return cache.get(href) ?? undefined;
+
+  const source = await doLoad(href);
+  cache.set(href, source ?? null);
+  return source;
+}
+
+async function doLoad(href: string): Promise<FaviconSource | undefined> {
+  if (href.startsWith('http://') || href.startsWith('https://'))
+    return loadFromUrl(href);
+
+  return loadFromFilesystem(href);
+}
+
+async function loadFromUrl(url: string): Promise<FaviconSource | undefined> {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) return undefined;
+
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const serverMime = (response.headers.get('content-type') || '')
+      .split(';')[0]
+      ?.trim();
+    return buildSource(buffer, resolveMime(buffer, url, serverMime));
+  } catch {
+    return undefined;
+  }
+}
+
+async function loadFromFilesystem(
+  href: string,
+): Promise<FaviconSource | undefined> {
+  const cleanPath = href.replace(/^\.\//, '');
+  const localPath = isAbsolute(cleanPath)
+    ? cleanPath
+    : ERUDIT.paths.project(cleanPath);
+
+  try {
+    const buffer = await readFile(localPath);
+    return buildSource(buffer, resolveMime(buffer, href));
+  } catch {
+    return undefined;
+  }
+}

package/server/erudit/favicon/shared.ts

@@ -0,0 +1,48 @@
+export const FAVICON_SIZES = [32, 48, 180] as const;
+export type FaviconSize = (typeof FAVICON_SIZES)[number];
+
+// Mirrors contentTypes (minus 'topic') + topicParts from @erudit-js/core
+export const FAVICON_KEYS = [
+  'default',
+  'book',
+  'group',
+  'page',
+  'article',
+  'summary',
+  'practice',
+] as const;
+export type FaviconKey = (typeof FAVICON_KEYS)[number];
+
+function fallbackFaviconPath(): string {
+  return ERUDIT.paths.erudit('public', 'favicons', 'default.svg');
+}
+
+export function getFaviconHref(key: string): string | undefined {
+  const href = (
+    ERUDIT.config.public.favicon as Record<string, string> | undefined
+  )?.[key];
+  if (href) return href;
+  if (key === 'default') return fallbackFaviconPath();
+  return undefined;
+}
+
+const mimeByExt: Record<string, string> = {
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.bmp': 'image/bmp',
+  '.ico': 'image/x-icon',
+};
+
+export function extFromHref(href: string): string {
+  const path = href.split(/[?#]/)[0] ?? '';
+  const dot = path.lastIndexOf('.');
+  return dot === -1 ? '' : path.slice(dot).toLowerCase();
+}
+
+export function mimeFromExt(href: string): string | undefined {
+  return mimeByExt[extFromHref(href)];
+}

package/server/erudit/repository.ts

@@ -37,6 +37,7 @@ import {
 import { getContentSeo } from './content/repository/seo';
 import { getContentElementSnippets } from './content/repository/elementSnippets';
 import { isContentHidden } from './content/repository/hidden';
+import { getContentLastmod } from './content/repository/lastmod';
 import { serverRawToProse } from './prose/repository/rawToProse';
 
 export const repository = {
@@ -77,6 +78,7 @@ export const repository = {
     updateSchemaCounts: updateContentSchemaCounts,
     contentContributions: getContentContributions,
     seo: getContentSeo,
+    lastmod: getContentLastmod,
   },
   prose: {
     fromRaw: serverRawToProse,

package/server/routes/favicon/[...path].ts

@@ -0,0 +1,89 @@
+import { loadFaviconSource } from '#layers/erudit/server/erudit/favicon/loadSource';
+import { convertFaviconToPng } from '#layers/erudit/server/erudit/favicon/convertToPng';
+import {
+  FAVICON_SIZES,
+  FAVICON_KEYS,
+  getFaviconHref,
+  type FaviconSize,
+  type FaviconKey,
+} from '#layers/erudit/server/erudit/favicon/shared';
+
+export default defineEventHandler(async (event) => {
+  const rawPath = event.context.params?.path;
+  if (!rawPath) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Invalid favicon path',
+    });
+  }
+
+  const slashIdx = rawPath.indexOf('/');
+  if (slashIdx === -1) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Invalid favicon path',
+    });
+  }
+
+  const key = rawPath.slice(0, slashIdx);
+  const file = rawPath.slice(slashIdx + 1);
+
+  if (!FAVICON_KEYS.includes(key as FaviconKey)) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: `Unknown favicon key: ${key}`,
+    });
+  }
+
+  const href = getFaviconHref(key);
+  if (!href) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: `No favicon configured for: ${key}`,
+    });
+  }
+
+  const source = await loadFaviconSource(href);
+  if (!source) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Failed to load favicon source',
+    });
+  }
+
+  // Source route: {key}/source.{ext}
+  if (file.startsWith('source.')) {
+    setHeader(event, 'Content-Type', source.mime);
+    setHeader(event, 'Cache-Control', 'public, max-age=86400, s-maxage=86400');
+    return source.buffer;
+  }
+
+  // PNG route: {key}/{size}.png
+  if (!file.endsWith('.png')) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: 'Invalid favicon path',
+    });
+  }
+
+  const size = Number(file.slice(0, -4)) as FaviconSize;
+
+  if (!FAVICON_SIZES.includes(size)) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: `Invalid favicon size: ${file}`,
+    });
+  }
+
+  if (source.width !== undefined && source.width < size) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: `Favicon source too small (${source.width}px) for size ${size}px`,
+    });
+  }
+
+  const png = await convertFaviconToPng(key, source, size);
+  setHeader(event, 'Content-Type', 'image/png');
+  setHeader(event, 'Cache-Control', 'public, max-age=86400, s-maxage=86400');
+  return png;
+});

package/server/routes/sitemap.xml.ts

@@ -2,7 +2,14 @@ import { sn } from 'unslash';
 
 export default defineEventHandler(async (event) => {
   const urls = new Set<string>();
-  urls.add(PAGES.index);
+  const urlLastmod = new Map<string, string>();
+
+  function addUrl(url: string, lastmod?: string) {
+    urls.add(url);
+    if (lastmod) urlLastmod.set(url, lastmod);
+  }
+
+  addUrl(PAGES.index);
 
   //
   // Contributors
@@ -34,7 +41,7 @@ export default defineEventHandler(async (event) => {
 
   {
     const dbContentItems = await ERUDIT.db.query.content.findMany({
-      columns: { fullId: true },
+      columns: { fullId: true, lastmod: true },
     });
 
     for (const dbContentItem of dbContentItems) {
@@ -45,14 +52,15 @@ export default defineEventHandler(async (event) => {
       }
 
       const contentNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
+      const lastmod = dbContentItem.lastmod ?? undefined;
 
       if (contentNode.type === 'topic') {
         const parts = await ERUDIT.repository.content.topicParts(fullId);
         for (const part of parts) {
-          urls.add(PAGES.topic(part, contentNode.shortId));
+          addUrl(PAGES.topic(part, contentNode.shortId), lastmod);
         }
       } else {
-        urls.add(PAGES[contentNode.type](fullId));
+        addUrl(PAGES[contentNode.type](fullId), lastmod);
       }
 
       const elementSnippets =
@@ -60,7 +68,7 @@ export default defineEventHandler(async (event) => {
 
       for (const snippet of elementSnippets || []) {
         if (snippet.seo) {
-          urls.add(snippet.link);
+          addUrl(snippet.link, lastmod);
         }
       }
     }
@@ -75,11 +83,12 @@ export default defineEventHandler(async (event) => {
   const xml = `<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 ${Array.from(urls)
-  .map(
-    (url) => `    <url>
-        <loc>${sn(runtimeConfig.public.siteUrl, url)}</loc>
-    </url>`,
-  )
+  .map((url) => {
+    const lastmod = urlLastmod.get(url);
+    return `    <url>
+        <loc>${sn(runtimeConfig.public.siteUrl, url)}</loc>${lastmod ? `\n        <lastmod>${lastmod}</lastmod>` : ''}
+    </url>`;
+  })
   .join('\n')}
 </urlset>`.trim();
 

package/shared/types/mainContent.ts

@@ -27,6 +27,7 @@ export interface MainContentBase {
   connections?: ContentConnections;
   contributions?: ContentContribution[];
   seo?: ContentSeo;
+  lastmod?: string;
 }
 
 export interface MainContentChildrenItem {

package/shared/types/runtimeConfig.ts

@@ -13,6 +13,10 @@ export interface EruditRuntimeConfig {
   elements: string[];
   countElements: (string | string[])[];
   indexPage?: EruditIndexPage;
+  lastmod?: {
+    type: 'git' | 'custom';
+    scriptPath?: string;
+  };
 }
 
 export interface EruditPublicRuntimeConfig {
@@ -27,7 +31,6 @@ export interface EruditPublicRuntimeConfig {
     ads: boolean;
     fakeApi: {
       repository: boolean;
-      lastChanged: boolean | string;
     };
     analytics?: boolean;
   };

package/app/composables/lastChanged.ts

@@ -1,61 +0,0 @@
-type LastChangedSource =
-  | { type: 'date'; value: string }
-  | { type: 'github'; url: string; path: string };
-
-function useLastChangedSource(
-  contentRelativePath: MaybeRefOrGetter<string | undefined>,
-) {
-  return computed((): LastChangedSource | undefined => {
-    const path = toValue(contentRelativePath);
-    if (!path) return undefined;
-
-    const debug = ERUDIT.config.debug.fakeApi.lastChanged;
-    if (debug === true) return { type: 'date', value: '2024-01-15T12:00:00Z' };
-    if (typeof debug === 'string') return { type: 'date', value: debug };
-
-    const repo = ERUDIT.config.repository;
-    if (!repo || repo.type !== 'github') return undefined;
-    const parts = repo.name.split('/');
-    if (parts.length !== 2) return undefined;
-    const [owner, repoName] = parts;
-
-    return {
-      type: 'github',
-      url: `https://api.github.com/repos/${owner}/${repoName}/commits`,
-      path: `content/${path}`,
-    };
-  });
-}
-
-export function useLastChanged(
-  contentRelativePath: MaybeRefOrGetter<string | undefined>,
-) {
-  const source = useLastChangedSource(contentRelativePath);
-  const date = ref<Date | undefined>(undefined);
-
-  onMounted(async () => {
-    const s = source.value;
-    if (!s) return;
-
-    if (s.type === 'date') {
-      date.value = new Date(s.value);
-      return;
-    }
-
-    if (s.type === 'github') {
-      try {
-        const data = await $fetch<any[]>(s.url, {
-          query: { path: s.path, per_page: 1 },
-          responseType: 'json',
-        });
-        if (Array.isArray(data) && data[0]?.commit?.committer?.date) {
-          date.value = new Date(data[0].commit.committer.date);
-        }
-      } catch {
-        // silently ignore API errors
-      }
-    }
-  });
-
-  return date;
-}