erudit 4.2.0-dev.1 → 4.3.0-dev.1

package/app/plugins/appSetup/index.ts

@@ -13,7 +13,10 @@ export default defineNuxtPlugin({
   hooks: {
     'app:mounted': async () => {
       const { registerProseGlobals } = await import('#erudit/prose/global');
-      registerProseGlobals();
+      await registerProseGlobals();
+
+      const { registerAutoImportGlobals } = await import('#erudit/autoImports');
+      await registerAutoImportGlobals();
 
       await setupHtmlBranding();
       await setupWelcomeMessage();

package/app/plugins/devReload.client.ts

@@ -0,0 +1,13 @@
+import { isDevLikeMode } from '@erudit-js/core/mode';
+
+export default defineNuxtPlugin({
+  name: 'erudit-dev-reload',
+  setup() {
+    const runtimeConfig = useRuntimeConfig().public;
+    const mode = runtimeConfig.eruditMode as any;
+    if (!isDevLikeMode(mode) || !runtimeConfig.eruditReload) return;
+
+    const es = new EventSource('/_reload');
+    es.onmessage = () => window.location.reload();
+  },
+});

package/app/router.options.ts

@@ -2,9 +2,23 @@ import type { RouterOptions } from 'vue-router';
 
 export default {
   scrollBehavior(_to, _from, savedPosition) {
-    if (!savedPosition && !_to.query.element) {
-      return { top: 0 };
+    if (savedPosition) {
+      return savedPosition;
     }
-    return savedPosition;
+    // On a hard reload, _from is START_LOCATION (matched is empty).
+    // Return false so the browser's native scroll restoration (history.scrollRestoration = 'auto')
+    // can restore the position without Vue Router fighting it with { top: 0 }.
+    if (!_from || _from.matched.length === 0) {
+      return false;
+    }
+    if (_to.query.element) {
+      return false;
+    }
+    // Only scroll to top when the page path actually changes,
+    // not for query-param-only replacements (e.g. ?q= from search input).
+    if (_to.path === _from.path) {
+      return false;
+    }
+    return { top: 0 };
   },
 } as RouterOptions;

package/app/styles/main.css

@@ -27,7 +27,7 @@
   --text-main-2xl: calc(1.5 * var(--text-main));
 
   --default-transition-timing-function: cubic-bezier(0, 0, 0.5, 1);
-  --default-transition-duration: calc(200ms * var(--duration-multiplier));
+  --default-transition-duration: calc(180ms * var(--duration-multiplier));
 
   --spacing-normal: calc(4 * var(--spacing));
   --spacing-big: calc(2 * var(--spacing-normal));
@@ -42,7 +42,7 @@
 
   --h-min-aside-item: 60px;
 
-  --color-brand: light-dark(#00b886, #00dcb5);
+  --color-brand: light-dark(#00a545, #129adc);
   --color-bg-root: light-dark(#ebebeb, #141414);
   --color-bg-aside: light-dark(#f7f7f7, #1b1b1b);
   --color-bg-main: light-dark(#ffffff, #212121);

package/modules/erudit/dependencies.ts

@@ -0,0 +1,16 @@
+import type { Nuxt } from 'nuxt/schema';
+import type { EruditDependencies } from '@erudit-js/core/dependencies';
+
+export function addDependencies(
+  nuxt: Nuxt,
+  dependencies: EruditDependencies | undefined,
+) {
+  const transpile = (nuxt.options.build.transpile ||= []);
+  const optimizeDeps = nuxt.options.vite.optimizeDeps || {};
+  const optimizeDepsInclude = (optimizeDeps.include ||= []);
+
+  for (const [name, options] of Object.entries(dependencies ?? {})) {
+    if (options?.transpile) transpile.push(name);
+    if (options?.optimize) optimizeDepsInclude.push(name);
+  }
+}

package/modules/erudit/index.ts

@@ -16,6 +16,9 @@ import {
   registerServerGlobals,
 } from './setup/globals';
 import { setupProseElements } from './setup/elements/setup';
+import { setupProblemChecks } from './setup/problemChecks/setup';
+import { setupAutoImports } from './setup/autoImports';
+import { addDependencies } from './dependencies';
 
 export default defineNuxtModule({
   meta: { name: 'Erudit', configKey: 'erudit', version },
@@ -27,12 +30,16 @@ export default defineNuxtModule({
     await registerServerGlobals();
     await registerGlobalContentTypes();
 
-    const { eruditRuntimeConfig, nuxtAugmentations } =
+    const { eruditConfig, eruditRuntimeConfig, nuxtAugmentations } =
       await setupEruditRuntimeConfig(nuxt);
     await setupWatchers(nuxt);
     await setupEruditFullRestart(nuxt);
     await setupEruditPublicAssets(nuxt);
     await setupProseElements(nuxt, eruditRuntimeConfig);
+    await setupProblemChecks(nuxt, eruditConfig);
+    await setupAutoImports(nuxt, eruditConfig);
+
+    addDependencies(nuxt, eruditConfig.dependencies);
 
     if (nuxtAugmentations) {
       for (const augment of nuxtAugmentations) {

package/modules/erudit/setup/autoImports.ts

@@ -0,0 +1,143 @@
+import { writeFileSync } from 'node:fs';
+import type { Nuxt } from 'nuxt/schema';
+import { addTemplate, findPath } from 'nuxt/kit';
+import { sn } from 'unslash';
+import type { EruditConfig } from '@erudit-js/core/eruditConfig/config';
+
+import { PROJECT_PATH } from '../env';
+import { moduleLogger } from '../logger';
+import { printGrayNamesTable } from './namesTable';
+
+interface ResolvedAutoImport {
+  /** Config path as written by the user (e.g. './my-globals') */
+  configPath: string;
+  /** Absolute resolved path to the source file */
+  absPath: string;
+  /** #project/ relative path for TypeScript type declarations */
+  projectRelativePath: string;
+  /** Named export identifiers discovered from the file */
+  exportNames: string[];
+}
+
+export async function setupAutoImports(nuxt: Nuxt, eruditConfig: EruditConfig) {
+  const autoImportPaths = eruditConfig.autoImports ?? [];
+
+  if (autoImportPaths.length === 0) {
+    createEmptyTemplate(nuxt);
+    return;
+  }
+
+  const resolved: ResolvedAutoImport[] = [];
+
+  for (const configPath of autoImportPaths) {
+    const absPath = await findPath(configPath, {
+      cwd: PROJECT_PATH,
+      extensions: ['.ts', '.js'],
+    });
+
+    if (!absPath) {
+      throw new Error(`[autoImports] Failed to resolve path "${configPath}"!`);
+    }
+
+    // Discover named exports by dynamically importing the file
+    const mod = await import(absPath);
+    const exportNames = Object.keys(mod).filter((key) => key !== 'default');
+
+    if (exportNames.length === 0) {
+      moduleLogger.warn(
+        `[autoImports] File "${configPath}" has no named exports — skipping.`,
+      );
+      continue;
+    }
+
+    // Compute #project/ relative path for TypeScript type declarations
+    const normalizedAbsPath = absPath.replace(/\\/g, '/');
+    const normalizedProjectPath = PROJECT_PATH.replace(/\\/g, '/');
+    const projectRelativePath = normalizedAbsPath
+      .replace(normalizedProjectPath + '/', '')
+      .replace(/\.(ts|js)$/, '');
+
+    resolved.push({
+      configPath,
+      absPath: normalizedAbsPath,
+      projectRelativePath,
+      exportNames,
+    });
+  }
+
+  const allExportNames = resolved.flatMap((r) => r.exportNames);
+
+  createTemplate(nuxt, resolved, allExportNames);
+  createTypeDeclarations(resolved);
+
+  moduleLogger.success(
+    `Registered ${allExportNames.length} auto-import(s) from ${resolved.length} file(s)!`,
+  );
+
+  printGrayNamesTable(allExportNames);
+}
+
+function createEmptyTemplate(nuxt: Nuxt) {
+  addTemplate({
+    write: true,
+    filename: '#erudit/autoImports.ts',
+    getContents: () =>
+      `export const autoImportNames = new Set<string>();\nexport function registerAutoImportGlobals() { (globalThis as any).ERUDIT_GLOBAL = (globalThis as any).ERUDIT_GLOBAL || {}; }\n`,
+  });
+
+  const alias = (nuxt.options.alias ||= {});
+  alias['#erudit/autoImports'] =
+    nuxt.options.buildDir + '/#erudit/autoImports.ts';
+}
+
+function createTemplate(
+  nuxt: Nuxt,
+  resolved: ResolvedAutoImport[],
+  allExportNames: string[],
+) {
+  const importStatements = resolved
+    .map((r) => {
+      const names = r.exportNames.join(', ');
+      const importPath = r.absPath.replace(/\.(ts|js)$/, '');
+      return `import { ${names} } from '${importPath}';`;
+    })
+    .join('\n');
+
+  const template =
+    `
+${importStatements}
+
+export const autoImportNames = new Set<string>(${JSON.stringify(allExportNames)});
+
+export function registerAutoImportGlobals() {
+  (globalThis as any).ERUDIT_GLOBAL = (globalThis as any).ERUDIT_GLOBAL || {};
+  Object.assign((globalThis as any).ERUDIT_GLOBAL, {
+    ${allExportNames.join(',\n    ')}
+  });
+}
+`.trim() + '\n';
+
+  addTemplate({
+    write: true,
+    filename: '#erudit/autoImports.ts',
+    getContents: () => template,
+  });
+
+  const alias = (nuxt.options.alias ||= {});
+  alias['#erudit/autoImports'] =
+    nuxt.options.buildDir + '/#erudit/autoImports.ts';
+}
+
+function createTypeDeclarations(resolved: ResolvedAutoImport[]) {
+  let dts = 'export {}\n\ndeclare global {\n';
+
+  for (const r of resolved) {
+    for (const name of r.exportNames) {
+      dts += `    const ${name}: typeof import('#project/${r.projectRelativePath}')['${name}']\n`;
+    }
+  }
+
+  dts += '}\n';
+
+  writeFileSync(sn(PROJECT_PATH, '.erudit/types/autoImports.d.ts'), dts);
+}

package/modules/erudit/setup/elements/globalTemplate.ts

@@ -53,17 +53,25 @@ export const elementsGlobals = {
     .join(',\n    ')}
 }
 
+export const eruditGlobalNames = new Set<string>([
+  ...Object.values(coreElements).flatMap((el: any) => (el.tags ?? []).map((t: any) => String(t.tagName))),
+  ...Object.keys(elementsGlobals),
+  'jsx', 'jsxs', 'Fragment', 'defineProblemScript',
+]);
+
 export function registerProseGlobals() {
+  (globalThis as any).ERUDIT_GLOBAL = (globalThis as any).ERUDIT_GLOBAL || {};
+
   for (const coreElement of Object.values(coreElements)) {
     const tags = coreElement.tags || [];
     for (const tag of tags) {
-      Object.assign(globalThis, {
+      Object.assign((globalThis as any).ERUDIT_GLOBAL, {
         [tag.tagName]: tag,
       });
     }
   }
 
-  Object.assign(globalThis, {
+  Object.assign((globalThis as any).ERUDIT_GLOBAL, {
     // Make jsx runtime globally available (for prose generation in isolated modules like problem scripts)
     jsx,
     jsxs,

package/modules/erudit/setup/elements/setup.ts

@@ -1,4 +1,3 @@
-import chalk from 'chalk';
 import type { Nuxt } from 'nuxt/schema';
 import { findPath } from 'nuxt/kit';
 
@@ -6,12 +5,13 @@ import type { ProseCoreElement } from '@erudit-js/prose';
 
 import type { EruditRuntimeConfig } from '../../../../shared/types/runtimeConfig';
 import { moduleLogger } from '../../logger';
+import { printGrayNamesTable } from '../namesTable';
 import type { ElementData } from './shared';
-import { createTagsTable } from './tagsTable';
 import { createElementGlobalTypes } from './elementGlobalTypes';
 import { createGlobalTemplate } from './globalTemplate';
 import { createAppTemplate } from './appTemplate';
 import { PROJECT_PATH } from '../../env';
+import { addDependencies } from '../../dependencies';
 
 const BUILTIN_ELEMENT_PATHS = [
   '@erudit-js/prose/elements/callout',
@@ -131,16 +131,7 @@ export async function setupProseElements(
         }
       }
 
-      const transpile = (nuxt.options.build.transpile ||= []);
-      const optimizeDeps = nuxt.options.vite.optimizeDeps || {};
-      const optimizeDepsInclude = (optimizeDeps.include ||= []);
-
-      for (const [name, options] of Object.entries(
-        coreElement.dependencies ?? {},
-      )) {
-        if (options?.transpile) transpile.push(name);
-        if (options?.optimize) optimizeDepsInclude.push(name);
-      }
+      addDependencies(nuxt, coreElement.dependencies);
     }
 
     elementsData.push(elementData);
@@ -160,6 +151,9 @@ Registered ${elementsNumber} prose elements: ${schemasNumber} schema(s) and ${ta
         `.trim(),
   );
 
-  const tagsTable = createTagsTable(elementsData);
-  console.log(chalk.gray(tagsTable));
+  const tagNames = elementsData.flatMap((data) =>
+    data.coreElements.flatMap((coreElement) => Object.keys(coreElement.tags)),
+  );
+
+  printGrayNamesTable(tagNames.map((t) => `<${t}>`));
 }

package/modules/erudit/setup/elements/tagsTable.ts

@@ -1,28 +1,12 @@
 import type { ElementData } from './shared';
+import { createNamesTable } from '../namesTable';
 
 export function createTagsTable(elementsData: ElementData[], columns = 4) {
   const tagNames = elementsData.flatMap((data) =>
     data.coreElements.flatMap((coreElement) => Object.keys(coreElement.tags)),
   );
 
-  if (tagNames.length === 0) return '';
-
-  const cols = Math.max(1, columns);
   const formatted = tagNames.map((t) => `<${t}>`);
-  const maxLen = Math.max(...formatted.map((s) => s.length));
-  const colWidth = maxLen + 2; // padding between columns
-
-  const rows = Math.ceil(formatted.length / cols);
-  const lines: string[] = [];
-
-  for (let r = 0; r < rows; r++) {
-    const start = r * cols;
-    const rowItems = formatted.slice(start, start + cols);
-    const padded = rowItems.map((s) => s.padEnd(colWidth, ' '));
-    lines.push(padded.join('').replace(/\s+$/u, '')); // trim trailing spaces on the row
-  }
-
-  const tagTable = lines.join('\n');
 
-  return tagTable;
+  return createNamesTable(formatted, columns);
 }

package/modules/erudit/setup/fullRestart.ts

@@ -1,6 +1,6 @@
 import type { Nuxt } from '@nuxt/schema';
 import { debounce } from 'perfect-debounce';
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { sn } from 'unslash';
 
 import { ERUDIT_PACKAGE_WATCHER, ERUDIT_PROJECT_WATCHER } from '../watcher';
@@ -15,8 +15,10 @@ export async function setupEruditFullRestart(nuxt: Nuxt) {
     changedPaths.clear();
 
     moduleLogger.warn(
-      `${chalk.yellow('Full restart due to critical file change(s):')}\n\n` +
-        files.map((p, i) => chalk.gray(`${i + 1} -`) + ` "${p}"`).join('\n'),
+      `${styleText('yellow', 'Full restart due to critical file change(s):')}\n\n` +
+        files
+          .map((p, i) => styleText('gray', `${i + 1} -`) + ` "${p}"`)
+          .join('\n'),
     );
 
     await nuxt.callHook('close', nuxt);

package/modules/erudit/setup/namesTable.ts

@@ -0,0 +1,33 @@
+import { styleText } from 'node:util';
+
+export function createNamesTable(names: string[], columns = 4) {
+  if (names.length === 0) return '';
+
+  const cols = Math.max(1, columns);
+  const maxLen = Math.max(...names.map((s) => s.length));
+  const colWidth = maxLen + 2;
+
+  const rows = Math.ceil(names.length / cols);
+  const lines: string[] = [];
+
+  for (let r = 0; r < rows; r++) {
+    const start = r * cols;
+    const rowItems = names.slice(start, start + cols);
+    const padded = rowItems.map((s) => s.padEnd(colWidth, ' '));
+    lines.push(padded.join('').replace(/\s+$/u, ''));
+  }
+
+  return lines.join('\n');
+}
+
+export function printGrayNamesTable(names: string[], columns = 4) {
+  const table = createNamesTable(names, columns);
+  if (!table) return;
+
+  console.log(
+    table
+      .split('\n')
+      .map((line) => styleText('gray', line))
+      .join('\n'),
+  );
+}

package/modules/erudit/setup/problemChecks/setup.ts

@@ -0,0 +1,60 @@
+import type { Nuxt } from 'nuxt/schema';
+import { findPath } from 'nuxt/kit';
+import type { EruditConfig } from '@erudit-js/core/eruditConfig/config';
+import type { ProblemChecker } from '@erudit-js/core/problemCheck';
+
+import type { ResolvedProblemCheck } from './shared';
+import { PROJECT_PATH } from '../../env';
+import { moduleLogger } from '../../logger';
+import { printGrayNamesTable } from '../namesTable';
+import { createTemplate } from './template';
+
+export async function setupProblemChecks(
+  nuxt: Nuxt,
+  eruditConfig: EruditConfig,
+) {
+  const resolvedProblemChecks: ResolvedProblemCheck[] = [];
+  const seenProblemChecks = new Set<string>();
+
+  for (const strProblemCheck of eruditConfig.problemChecks ?? []) {
+    const absPath = await findPath(strProblemCheck, {
+      cwd: PROJECT_PATH,
+      extensions: ['.ts', '.js'],
+    });
+
+    if (!absPath) {
+      throw new Error(
+        `Failed to resolve path for problem check "${strProblemCheck}"!`,
+      );
+    }
+
+    const defaultExport = (await import(absPath)).default as ProblemChecker;
+    const name = defaultExport?.name;
+
+    if (!name) {
+      throw new Error(
+        `Problem check at "${strProblemCheck}" does not have a name!`,
+      );
+    }
+
+    if (seenProblemChecks.has(name)) {
+      throw new Error(`Duplicate problem check name "${name}" found!`);
+    }
+
+    seenProblemChecks.add(name);
+    resolvedProblemChecks.push({
+      name,
+      absPath,
+    });
+  }
+
+  createTemplate(nuxt, resolvedProblemChecks);
+
+  if (resolvedProblemChecks.length > 0) {
+    moduleLogger.success(
+      `Registered ${resolvedProblemChecks.length} problem check(s)!`,
+    );
+
+    printGrayNamesTable(resolvedProblemChecks.map((c) => c.name));
+  }
+}

package/modules/erudit/setup/problemChecks/shared.ts

@@ -0,0 +1,4 @@
+export interface ResolvedProblemCheck {
+  name: string;
+  absPath: string;
+}

package/modules/erudit/setup/problemChecks/template.ts

@@ -0,0 +1,33 @@
+import type { Nuxt } from 'nuxt/schema';
+import { addTemplate } from 'nuxt/kit';
+
+import type { ResolvedProblemCheck } from './shared';
+
+export function createTemplate(
+  nuxt: Nuxt,
+  problemChecks: ResolvedProblemCheck[],
+) {
+  const template = `
+import type { ProblemCheckers } from '@erudit-js/core/problemCheck';
+
+${problemChecks
+  .map(
+    (check) =>
+      `import ${check.name} from '${check.absPath.replace(/\.(ts|js)$/, '')}';`,
+  )
+  .join('\n')}
+
+export const problemCheckers: ProblemCheckers = {
+  ${problemChecks.map((check) => `${check.name},`).join('\n  ')}
+}
+  `.trim();
+
+  addTemplate({
+    write: true,
+    filename: '#erudit/checks.ts',
+    getContents: () => template,
+  });
+
+  const alias = (nuxt.options.alias ||= {});
+  alias['#erudit/checks'] = nuxt.options.buildDir + '/#erudit/checks.ts';
+}

package/modules/erudit/setup/runtimeConfig.ts

@@ -2,8 +2,9 @@ import { existsSync } from 'node:fs';
 import type { Nuxt } from '@nuxt/schema';
 import { sn } from 'unslash';
 import type { EruditConfig } from '@erudit-js/core/eruditConfig/config';
+import { isDevLikeMode } from '@erudit-js/core/mode';
 
-import { PROJECT_PATH } from '../env.js';
+import { ERUDIT_MODE, PROJECT_PATH } from '../env.js';
 import { moduleLogger } from '../logger.js';
 import type {
   EruditPublicRuntimeConfig,
@@ -26,25 +27,28 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
   // Erudit Runtime Config
   //
 
-  nuxt.options.runtimeConfig.erudit = {
+  nuxt.options.runtimeConfig.erudit = (<EruditRuntimeConfig>{
     elements: eruditConfig.elements || [],
     countElements: eruditConfig.countElements || [],
     indexPage: eruditConfig.indexPage,
-  } satisfies EruditRuntimeConfig;
+  }) satisfies EruditRuntimeConfig;
 
   //
   // Erudit Public Runtime Config
   //
 
-  nuxt.options.runtimeConfig.public.erudit = {
+  nuxt.options.runtimeConfig.public.erudit = (<EruditPublicRuntimeConfig>{
     debug: {
       ads: eruditConfig.debug?.ads ?? false,
       log: eruditConfig.debug?.log ?? false,
       slowTransition: eruditConfig.debug?.slowTransition ?? false,
       fakeApi: {
-        repository: eruditConfig.debug?.fakeApi?.repository ?? nuxt.options.dev,
+        repository:
+          eruditConfig.debug?.fakeApi?.repository ??
+          (nuxt.options.dev || isDevLikeMode(ERUDIT_MODE)),
         lastChanged:
-          eruditConfig.debug?.fakeApi?.lastChanged ?? nuxt.options.dev,
+          eruditConfig.debug?.fakeApi?.lastChanged ??
+          (nuxt.options.dev || isDevLikeMode(ERUDIT_MODE)),
       },
       analytics: eruditConfig.debug?.analytics,
     },
@@ -85,7 +89,7 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
     sponsors: eruditConfig.sponsors,
     ads: eruditConfig.ads,
     analytics: eruditConfig.analytics,
-  } satisfies EruditPublicRuntimeConfig;
+  }) satisfies EruditPublicRuntimeConfig;
 
   //
   // Other
@@ -94,6 +98,7 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
   nuxt.options.runtimeConfig.public.buildTime = Date.now();
 
   return {
+    eruditConfig,
     eruditRuntimeConfig: nuxt.options.runtimeConfig
       .erudit as EruditRuntimeConfig,
     eruditPublicRuntimeConfig: nuxt.options.runtimeConfig.public

package/nuxt.config.ts

@@ -3,11 +3,6 @@ import { sn } from 'unslash';
 
 import { BASE_URL, ERUDIT_COMMAND, PROJECT_PATH } from './modules/erudit/env';
 
-/**
- * This is context-unaware or "static" Nuxt configuration.
- * The only thing that works here are aliases.
- * If you need to use context (e.g. paths to package/project or Erudit project config), use `./modules/erudit/setup/nuxtConfig.ts` file.
- */
 export default defineNuxtConfig({
   compatibilityDate: '2026-01-01',
   devtools: { enabled: true },
@@ -18,6 +13,11 @@ export default defineNuxtConfig({
     iconsDir: '#layers/erudit/app/assets/icons',
   },
   plugins: ['#layers/erudit/app/plugins/appSetup'],
+  typescript: {
+    nodeTsConfig: {
+      include: [sn(PROJECT_PATH, 'packages/erudit/modules/erudit/**/*.ts')],
+    },
+  },
   runtimeConfig: {
     eruditPath: '',
     projectPath: '',
@@ -25,6 +25,7 @@ export default defineNuxtConfig({
     public: {
       eruditVersion: '',
       eruditMode: '',
+      eruditReload: true,
       siteUrl: '',
     },
   },
@@ -93,7 +94,14 @@ export default defineNuxtConfig({
       },
     ],
     optimizeDeps: {
-      noDiscovery: true,
+      include: [
+        '@vue/devtools-core',
+        '@vue/devtools-kit',
+        '@floating-ui/vue',
+        'unslash',
+        'tsprose',
+        'tsprose/jsx-runtime',
+      ],
     },
     server: {
       fs: { strict: false },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erudit",
-  "version": "4.2.0-dev.1",
+  "version": "4.3.0-dev.1",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,15 +24,14 @@
     }
   },
   "dependencies": {
-    "@erudit-js/cli": "4.2.0-dev.1",
-    "@erudit-js/core": "4.2.0-dev.1",
-    "@erudit-js/prose": "4.2.0-dev.1",
+    "@erudit-js/cli": "4.3.0-dev.1",
+    "@erudit-js/core": "4.3.0-dev.1",
+    "@erudit-js/prose": "4.3.0-dev.1",
     "unslash": "^2.0.0",
     "@floating-ui/vue": "^1.1.10",
-    "tsprose": "^1.0.0",
+    "tsprose": "^1.0.1",
     "@tailwindcss/vite": "^4.2.0",
     "better-sqlite3": "^12.6.2",
-    "chalk": "^5.6.2",
     "chokidar": "^5.0.0",
     "consola": "^3.4.2",
     "drizzle-kit": "^0.31.9",