erudit 4.3.1 → 4.3.3-dev.1

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,25 @@ 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,
+    keyElements: args.snippets?.filter((snippet) => !!snippet.key),
+    breadcrumbs: args.breadcrumbs,
+  });
+
   //
   // 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.1",
+  "version": "4.3.3-dev.1",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,32 +24,33 @@
     }
   },
   "dependencies": {
-    "@erudit-js/cli": "4.3.1",
-    "@erudit-js/core": "4.3.1",
-    "@erudit-js/prose": "4.3.1",
-    "unslash": "^2.0.0",
+    "@erudit-js/cli": "4.3.3-dev.1",
+    "@erudit-js/core": "4.3.3-dev.1",
+    "@erudit-js/prose": "4.3.3-dev.1",
     "@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",
     "consola": "^3.4.2",
-    "drizzle-kit": "^0.31.9",
+    "drizzle-kit": "^0.31.10",
     "drizzle-orm": "^0.45.1",
     "esbuild": "^0.27.4",
     "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.26.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();
+}