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

package/server/api/problemScript/[...problemScriptPath].ts

@@ -4,7 +4,22 @@ import { build, type Plugin } from 'esbuild';
 
 import { STATIC_ASSET_EXTENSIONS } from '#layers/erudit/server/erudit/prose/transform/extensions';
 import { createGlobalContent } from '@erudit-js/core/content/global';
-import { coreElements } from '#erudit/prose/global';
+import { eruditGlobalNames } from '#erudit/prose/global';
+import { autoImportNames } from '#erudit/autoImports';
+
+/**
+ * Pure function calls irrelevant to the problem script runtime.
+ * Their entire call expressions (including all arguments) are replaced with
+ * `undefined` before bundling so esbuild never follows transitive imports
+ * inside their arguments (e.g. heavy checker handlers importing `mathjs`).
+ */
+const WIPE_OUT_FUNCTIONS: string[] = [
+  'defineProblemChecker',
+  'defineContributor',
+  'defineTopic',
+  'defineBook',
+  'definePage',
+];
 
 export default defineEventHandler<Promise<string>>(async (event) => {
   // <filepathToScriptFile>.js
@@ -25,7 +40,7 @@ export default defineEventHandler<Promise<string>>(async (event) => {
       $CONTRIBUTOR: '{}',
     },
     jsx: 'automatic',
-    plugins: [jsxRuntimePlugin, proseGlobalsPlugin, staticFilesPlugin],
+    plugins: [jsxRuntimePlugin, sourceTransformPlugin, staticFilesPlugin],
     alias: {
       '#project': ERUDIT.paths.project() + '/',
       '#content': ERUDIT.paths.project('content') + '/',
@@ -34,6 +49,11 @@ export default defineEventHandler<Promise<string>>(async (event) => {
 
   let code = buildResult.outputFiles[0]!.text;
 
+  // Post-build: strip redundant ERUDIT_GLOBAL declarations emitted by esbuild,
+  // normalize JSX identifiers, and prepend a selective destructuring preamble
+  // with only the global names actually used in the bundle.
+  code = normalizeEruditGlobals(code);
+
   // Transform $CONTENT patterns to link objects
   code = code.replace(/\$CONTENT(\.[a-zA-Z_$][\w$]*)+/g, (match) => {
     const path = match
@@ -63,65 +83,192 @@ const jsxRuntimePlugin: Plugin = {
     }));
 
     build.onLoad({ filter: /.*/, namespace: 'jsx-runtime-shim' }, () => ({
+      // Export both the canonical and underscore-prefixed names so that
+      // pre-built modules importing `jsx as _jsx` also resolve correctly.
       contents: `
-                export const jsx = globalThis.jsx;
-                export const jsxs = globalThis.jsxs;
-                export const Fragment = globalThis.Fragment;
+                export const jsx = globalThis.ERUDIT_GLOBAL.jsx;
+                export const jsxs = globalThis.ERUDIT_GLOBAL.jsxs;
+                export const Fragment = globalThis.ERUDIT_GLOBAL.Fragment;
+                export const _jsx = globalThis.ERUDIT_GLOBAL.jsx;
+                export const _jsxs = globalThis.ERUDIT_GLOBAL.jsxs;
+                export const _Fragment = globalThis.ERUDIT_GLOBAL.Fragment;
             `,
       loader: 'js',
     }));
   },
 };
 
-// Collect all tag names that are registered in globalThis
-const proseTagNames = new Set<string>(
-  Object.values(coreElements).flatMap((el: any) =>
-    (el.tags ?? []).map((t: any) => String(t.tagName)),
-  ),
-);
-
-// Pre-transform: rewrite any import of a known globalThis tag name → const from globalThis.
-// Non-tag imports are left as real imports and bundled normally.
-// Applies recursively to every .ts/.tsx file esbuild processes (including utility files).
-const proseGlobalsPlugin: Plugin = {
-  name: 'prose-globals',
+// Maps underscore-prefixed JSX names (emitted by some bundlers/transpilers) to
+// the canonical globalThis key where the value actually lives.
+const JSX_UNDERSCORE_ALIASES: Record<string, string> = {
+  _jsx: 'jsx',
+  _jsxs: 'jsxs',
+  _Fragment: 'Fragment',
+};
+
+// Names that are available on globalThis.ERUDIT_GLOBAL and should not be bundled as real imports.
+function getGlobalNames(): Set<string> {
+  return new Set<string>([
+    ...eruditGlobalNames,
+    // Auto-imported names from erudit config
+    ...autoImportNames,
+    // Underscore-prefixed aliases for JSX
+    '_jsx',
+    '_jsxs',
+    '_Fragment',
+  ]);
+}
+
+/**
+ * Replace calls to functions listed in `WIPE_OUT_FUNCTIONS` with `undefined`.
+ * Uses balanced-parenthesis scanning so nested calls/objects inside arguments
+ * are handled correctly.
+ *
+ * Example:
+ *   export default defineProblemChecker(def, async (d, i) => { ... });
+ *   →  export default undefined;
+ */
+function wipeOutCalls(source: string): string {
+  const pattern = new RegExp(
+    '\\b(' + WIPE_OUT_FUNCTIONS.join('|') + ')\\s*\\(',
+  );
+
+  let result = '';
+  let remaining = source;
+
+  while (true) {
+    const m = pattern.exec(remaining);
+    if (!m) {
+      result += remaining;
+      break;
+    }
+
+    // Skip function/method declarations (e.g. `function defineProblemChecker(`)
+    const prefix = remaining.slice(Math.max(0, m.index - 20), m.index);
+    if (/\bfunction\s*$/.test(prefix)) {
+      result += remaining.slice(0, m.index + m[0].length);
+      remaining = remaining.slice(m.index + m[0].length);
+      continue;
+    }
+
+    // Append everything before the function name
+    result += remaining.slice(0, m.index);
+
+    // Find the opening paren position (right after the function name + optional whitespace)
+    const openParenIndex = m.index + m[0].length - 1;
+    let depth = 1;
+    let i = openParenIndex + 1;
+
+    // Scan forward to find the matching closing paren, skipping strings/templates
+    while (i < remaining.length && depth > 0) {
+      const ch = remaining[i]!;
+
+      if (ch === '(') {
+        depth++;
+      } else if (ch === ')') {
+        depth--;
+      } else if (ch === "'" || ch === '"' || ch === '`') {
+        // Skip string/template literal
+        const quote = ch;
+        i++;
+        while (i < remaining.length) {
+          const sc = remaining[i]!;
+          if (sc === '\\') {
+            i += 2; // skip escaped char
+            continue;
+          }
+          if (sc === quote) break;
+          i++;
+        }
+      } else if (ch === '/' && remaining[i + 1] === '/') {
+        // Skip single-line comment
+        while (i < remaining.length && remaining[i] !== '\n') i++;
+        continue;
+      } else if (ch === '/' && remaining[i + 1] === '*') {
+        // Skip block comment
+        i += 2;
+        while (i < remaining.length - 1) {
+          if (remaining[i] === '*' && remaining[i + 1] === '/') {
+            i += 2;
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+
+      i++;
+    }
+
+    // Replace the entire call expression with `undefined`
+    result += 'undefined';
+    remaining = remaining.slice(i);
+  }
+
+  return result;
+}
+
+/**
+ * Rewrite imports of known globalThis names (JSX runtime + prose tags) from
+ * real import statements to `const X = globalThis["X"]` lookups.
+ * Non-global imports are left as real imports and bundled normally.
+ */
+function rewriteGlobalImports(
+  source: string,
+  globalNames: Set<string>,
+): string {
+  return source.replace(
+    /^import\s+\{([^}]+)\}\s+from\s+(['"])([^'"]+)\2.*$/gm,
+    (_match, bindings: string, _quote: string, pkg: string) => {
+      const keepParts: string[] = [];
+      const shimLines: string[] = [];
+
+      for (const part of bindings
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)) {
+        // handle "ExportName as LocalName"
+        const m = part.match(/^(\w+)(?:\s+as\s+(\w+))?$/);
+        if (!m) {
+          keepParts.push(part);
+          continue;
+        }
+        const localName = m[2] ?? m[1]!;
+        if (globalNames.has(localName)) {
+          // Underscore-prefixed JSX names (_jsx, _jsxs, _Fragment) must resolve
+          // to the canonical globalThis key (jsx, jsxs, Fragment) because the
+          // runtime only registers the un-prefixed versions.
+          const globalKey = JSX_UNDERSCORE_ALIASES[localName] ?? localName;
+          shimLines.push(
+            `var ${localName} = globalThis.ERUDIT_GLOBAL[${JSON.stringify(globalKey)}];`,
+          );
+        } else {
+          keepParts.push(part);
+        }
+      }
+
+      const lines: string[] = [];
+      if (keepParts.length > 0)
+        lines.push(`import { ${keepParts.join(', ')} } from '${pkg}';`);
+      lines.push(...shimLines);
+      return lines.join('\n');
+    },
+  );
+}
+
+// Pre-transform: wipe out pure function calls irrelevant to problem scripts,
+// then rewrite imports of known globalThis tag names → const from globalThis.
+// Applies to every .ts/.tsx/.js/.jsx file esbuild processes (including utility files).
+
+const sourceTransformPlugin: Plugin = {
+  name: 'source-transform',
   setup(build) {
+    const globalNames = getGlobalNames();
     build.onLoad({ filter: /\.[jt]sx?$/ }, (args) => {
-      const source = readFileSync(args.path, 'utf8');
-
-      const transformed = source.replace(
-        /^import\s+\{([^}]+)\}\s+from\s+(['"])([^'"]+)\2.*$/gm,
-        (_match, bindings: string, _quote: string, pkg: string) => {
-          const keepParts: string[] = [];
-          const shimLines: string[] = [];
-
-          for (const part of bindings
-            .split(',')
-            .map((s) => s.trim())
-            .filter(Boolean)) {
-            // handle "ExportName as LocalName"
-            const m = part.match(/^(\w+)(?:\s+as\s+(\w+))?$/);
-            if (!m) {
-              keepParts.push(part);
-              continue;
-            }
-            const localName = m[2] ?? m[1]!;
-            if (proseTagNames.has(localName)) {
-              shimLines.push(
-                `const ${localName} = globalThis[${JSON.stringify(localName)}];`,
-              );
-            } else {
-              keepParts.push(part);
-            }
-          }
+      let source = readFileSync(args.path, 'utf8');
 
-          const lines: string[] = [];
-          if (keepParts.length > 0)
-            lines.push(`import { ${keepParts.join(', ')} } from '${pkg}';`);
-          lines.push(...shimLines);
-          return lines.join('\n');
-        },
-      );
+      source = wipeOutCalls(source);
+      source = rewriteGlobalImports(source, globalNames);
 
       const ext = (args.path.match(/[jt]sx?$/)?.[0] ?? 'js') as
         | 'js'
@@ -129,13 +276,59 @@ const proseGlobalsPlugin: Plugin = {
         | 'ts'
         | 'tsx';
       return {
-        contents: transformed,
+        contents: source,
         loader: ext,
       };
     });
   },
 };
 
+/**
+ * Post-build pass that:
+ * 1. Strips all `var X = globalThis.ERUDIT_GLOBAL[...]` declarations (from
+ *    rewriteGlobalImports and the jsxRuntimePlugin shim) and the shim comment.
+ * 2. Normalizes underscore-prefixed JSX call-site names (_jsx2 → jsx, etc.).
+ * 3. Detects which ERUDIT_GLOBAL names are actually referenced in the code.
+ * 4. Prepends a single destructuring preamble with only those names.
+ */
+function normalizeEruditGlobals(code: string): string {
+  // Strip the jsx-runtime-shim comment
+  code = code.replace(/^\/\/ jsx-runtime-shim:jsx-runtime-shim\n/gm, '');
+
+  // Strip ALL var declarations pulling from globalThis.ERUDIT_GLOBAL
+  //   var jsx = globalThis.ERUDIT_GLOBAL.jsx;
+  //   var P = globalThis.ERUDIT_GLOBAL["P"];
+  //   var _jsx2 = globalThis.ERUDIT_GLOBAL.jsx;
+  code = code.replace(
+    /^var \w+ = globalThis\.ERUDIT_GLOBAL(?:\.[a-zA-Z_$][\w$]*|\[["'][a-zA-Z_$][\w$]*["']\]);[ \t]*\n?/gm,
+    '',
+  );
+
+  // Normalize call-site names (_jsxs must precede _jsx to avoid partial match):
+  //   _jsxs2(…)  →  jsxs(…)
+  //   _jsx2(…)   →  jsx(…)
+  //   _Fragment2 →  Fragment
+  code = code.replace(/_jsxs\d*\b/g, 'jsxs');
+  code = code.replace(/_jsx\d*\b/g, 'jsx');
+  code = code.replace(/_Fragment\d*\b/g, 'Fragment');
+
+  // Detect which ERUDIT_GLOBAL names are actually used in the code
+  const allNames = getGlobalNames();
+  const usedNames = [...allNames]
+    .filter((n) => /^[a-zA-Z_$]\w*$/.test(n) && !n.startsWith('_'))
+    .filter((n) => new RegExp('\\b' + n + '\\b').test(code));
+
+  if (usedNames.length > 0) {
+    code =
+      'var { ' +
+      usedNames.join(', ') +
+      ' } = globalThis.ERUDIT_GLOBAL;\n' +
+      code;
+  }
+
+  return code;
+}
+
 const staticFilesPlugin: Plugin = {
   name: 'static-files',
   setup(build) {

package/server/erudit/build.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import chokidar from 'chokidar';
 import { debounce } from 'perfect-debounce';
 import { sn } from 'unslash';
@@ -11,6 +11,7 @@ import { buildContentNav } from './content/nav/build';
 import { requestFullContentResolve, resolveContent } from './content/resolve';
 import { buildGlobalContent } from './content/global/build';
 import { buildNews } from './news/build';
+import { triggerReload } from './reloadSignal';
 
 export type EruditServerChangedFiles = Set<string>;
 export type EruditServerBuildError = Error | undefined;
@@ -28,7 +29,7 @@ export async function buildServerErudit() {
       await buildContentNav();
       await buildGlobalContent();
       await resolveContent();
-      ERUDIT.log.success(chalk.green('Build Complete!'));
+      ERUDIT.log.success(styleText('green', 'Build Complete!'));
     } catch (buildError) {
       requestFullContentResolve();
 
@@ -73,11 +74,16 @@ export async function tryServerWatchProject() {
       const files = Array.from(ERUDIT.changedFiles);
       console.log();
       ERUDIT.log.warn(
-        `${chalk.yellow('Rebuilding due to file change(s):')}\n\n` +
-          files.map((p, i) => chalk.gray(`${i + 1} -`) + ` "${p}"`).join('\n'),
+        `${styleText('yellow', 'Rebuilding due to file change(s):')}\n\n` +
+          files
+            .map((p, i) => styleText('gray', `${i + 1} -`) + ` "${p}"`)
+            .join('\n'),
       );
       console.log();
       await buildServerErudit();
+      if (!ERUDIT.buildError) {
+        triggerReload();
+      }
       ERUDIT.changedFiles.clear();
     } finally {
       ERUDIT.changedFiles.clear();

package/server/erudit/content/global/build.ts

@@ -11,6 +11,11 @@ const contentRoot = () => ERUDIT.paths.project('content');
 
 export let builtLinkObject: Record<string, any> | null = null;
 
+/** All valid fully-qualified $CONTENT paths — content items, topic parts,
+ *  public uniques, and internal (underscore) uniques.
+ *  Used for server-side prose link validation. */
+export let builtValidPaths: Set<string> | null = null;
+
 export async function buildGlobalContent() {
   ERUDIT.log.debug.start('Building global content...');
 
@@ -22,8 +27,9 @@ export async function buildGlobalContent() {
     return;
   }
 
-  const linkObject = await buildLinkObject();
+  const { linkObject, validPaths } = await buildLinkObject();
   builtLinkObject = linkObject;
+  builtValidPaths = validPaths;
 
   const linkTypes = linkObjectToTypes(linkObject);
   writeFileSync(
@@ -120,6 +126,7 @@ ${body}
  */
 async function buildLinkObject() {
   const linkTree: any = {};
+  const validPaths = new Set<string>();
 
   await ERUDIT.contentNav.walk((navItem) => {
     // Navigate to the correct position in the tree based on the full path
@@ -161,6 +168,11 @@ ${jsdoc}
           navItem.contentRelPath,
         ),
       };
+
+      validPaths.add(navItem.fullId);
+      for (const name of getAllUniqueNames(moduleContent)) {
+        validPaths.add(`${navItem.fullId}/$${name}`);
+      }
     } else if (navItem.type === 'topic') {
       const pathToTopicFile = ERUDIT.paths.project(
         `content/${navItem.contentRelPath}/topic.ts`,
@@ -183,6 +195,8 @@ ${jsdoc}
                 `.trim(),
       };
 
+      validPaths.add(navItem.fullId);
+
       for (const part of topicParts) {
         try {
           const pathToFile = ERUDIT.paths.project(
@@ -210,6 +224,11 @@ ${jsdoc}
               navItem.contentRelPath,
             ),
           };
+
+          validPaths.add(`${navItem.fullId}/${part}`);
+          for (const name of getAllUniqueNames(partContent)) {
+            validPaths.add(`${navItem.fullId}/${part}/$${name}`);
+          }
         } catch {}
       }
     } else {
@@ -233,10 +252,12 @@ ${jsdoc}
  */
                 `.trim(),
       };
+
+      validPaths.add(navItem.fullId);
     }
   });
 
-  return linkTree;
+  return { linkObject: linkTree, validPaths };
 }
 
 function tryGetTitle(moduleContent: string) {
@@ -254,6 +275,25 @@ function jsdocLines(lines: any[]) {
     .join('\n');
 }
 
+/** Returns ALL unique names from a module — both public and internal. Used to
+ *  populate builtValidPaths for server-side prose link validation. */
+function getAllUniqueNames(moduleContent: string): string[] {
+  const uniquesMatch = moduleContent.match(/uniques:\s*\{([^}]*)\}/s);
+  if (!uniquesMatch) return [];
+
+  const names: string[] = [];
+  for (const line of uniquesMatch[1]!.split('\n')) {
+    if (line.trim().startsWith('//')) continue;
+
+    const pairMatch =
+      line.match(/\[['"](.*?)['"]\]:\s*(\w+)/) ||
+      line.match(/['"](.*?)['"]:\s*(\w+)/) ||
+      line.match(/(\w+):\s*(\w+)/);
+    if (pairMatch) names.push(pairMatch[1]!);
+  }
+  return names;
+}
+
 function tryGetUniquesObject(
   moduleContent: string,
   pathToFile: string,
@@ -278,7 +318,7 @@ function tryGetUniquesObject(
       continue;
     }
 
-    // Skip uniques starting with underscore
+    // Skip uniques starting with underscore (internal — excluded from $CONTENT types)
     if (line.trim().startsWith('_')) {
       continue;
     }

package/server/erudit/content/nav/build.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { globSync } from 'glob';
 import { existsSync, readdirSync } from 'node:fs';
 import { contentTypes, type ContentType } from '@erudit-js/core/content/type';
@@ -132,7 +132,7 @@ export async function buildContentNav() {
 
   const stats = ERUDIT.contentNav.id2Node.size
     ? getContentNavStats(ERUDIT.contentNav.id2Node)
-    : chalk.gray('empty');
+    : styleText('gray', 'empty');
 
   ERUDIT.log.success(
     isInitial
@@ -324,7 +324,7 @@ const duplicateIdValidator: ContentNavValidator = () => {
 Content navigation node short ID duplication!
 + ${seenShortIds.get(navNode.shortId)}
 + ${navNode.fullId}
-    -> ${chalk.yellow(navNode.shortId)}
+    -> ${styleText('yellow', navNode.shortId)}
                     `.trim(),
         );
         duplicateIds.push(navNode.fullId);
@@ -348,7 +348,7 @@ const subsetValidator: ContentNavValidator = () => {
         ERUDIT.log.warn(
           `
 Only groups and books can have children!
--> ${chalk.yellow(navNode.fullId)}
+-> ${styleText('yellow', navNode.fullId)}
                     `.trim(),
         );
         wrongSubsetIds.push(navNode.fullId);
@@ -368,7 +368,7 @@ const bookCantSkipValidator: ContentNavValidator = () => {
         ERUDIT.log.warn(
           `
 Books can not be skipped!
-    -> ${navNode.contentRelPath.split('/').slice(0, -1).join('/')}/${chalk.yellow(navNode.contentRelPath.split('/').pop())}
+    -> ${navNode.contentRelPath.split('/').slice(0, -1).join('/')}/${styleText('yellow', navNode.contentRelPath.split('/').pop()!)}
                     `.trim(),
         );
         wrongBookIds.push(navNode.fullId);

package/server/erudit/content/nav/front.ts

@@ -86,6 +86,7 @@ async function createFrontContentNavItem(
       return {
         type: 'topic',
         ...baseItem,
+        parts: await ERUDIT.repository.content.topicParts(navNode.fullId),
       };
     case 'page':
       return {

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

@@ -4,7 +4,7 @@ export async function getContentDependencies(fullId: string) {
   const hardDependencies: ContentHardDep[] = [];
 
   const dbHardDependencies = await ERUDIT.db.query.contentDeps.findMany({
-    columns: { toFullId: true, hard: true, reason: true },
+    columns: { toFullId: true, hard: true, reason: true, uniqueNames: true },
     where: and(
       or(
         eq(ERUDIT.db.schema.contentDeps.fromFullId, fullId),
@@ -21,13 +21,35 @@ export async function getContentDependencies(fullId: string) {
     return map;
   }, new Map<string, string>());
 
+  // Merge unique names across hard dep rows sharing the same toFullId
+  // (can happen when a topic and its children both hard-dep the same target).
+  const hardUniqueMap = new Map<string, Set<string>>();
+  for (const row of dbHardDependencies) {
+    if (!hardUniqueMap.has(row.toFullId)) {
+      hardUniqueMap.set(row.toFullId, new Set());
+    }
+    if (row.uniqueNames) {
+      for (const name of row.uniqueNames.split(',')) {
+        hardUniqueMap.get(row.toFullId)!.add(name);
+      }
+    }
+  }
+
   const hardToFullIds = ERUDIT.contentNav.orderIds(
     externalToFullIds(dbHardDependencies),
   );
 
   for (const toFullId of hardToFullIds) {
     const reason = fullId2Reason.get(toFullId)!;
-    const hardDep = await createContentDep('hard', toFullId, undefined, reason);
+    const uniquePairs = Array.from(hardUniqueMap.get(toFullId) ?? []).map(
+      (uniqueName) => ({ contentFullId: toFullId, uniqueName }),
+    );
+    const hardDep = await createContentDep(
+      'hard',
+      toFullId,
+      uniquePairs.length > 0 ? uniquePairs : undefined,
+      reason,
+    );
     if (hardDep) {
       hardDependencies.push(hardDep);
     }
@@ -166,7 +188,7 @@ async function createContentDep(
 async function createContentDep(
   type: 'hard',
   fullId: string,
-  uniquePairs: undefined,
+  uniquePairs: { contentFullId: string; uniqueName: string }[] | undefined,
   reason: string,
 ): Promise<ContentHardDep | undefined>;
 async function createContentDep(
@@ -189,12 +211,20 @@ async function createContentDep(
   ]);
 
   if (type === 'hard') {
+    const hardUniques =
+      uniquePairs && uniquePairs.length > 0
+        ? await resolveUniqueEntries(uniquePairs)
+        : undefined;
+
     return {
       type: 'hard',
       reason: reason!,
       contentType,
       title,
       link,
+      ...(hardUniques && hardUniques.length > 0
+        ? { uniques: hardUniques }
+        : {}),
     };
   }
 
@@ -230,7 +260,7 @@ async function resolveUniqueEntries(
   const results = await Promise.all(
     unique.map(async ({ contentFullId, uniqueName }) => {
       const dbUnique = await ERUDIT.db.query.contentUniques.findFirst({
-        columns: { title: true, prose: true },
+        columns: { title: true, prose: true, contentProseType: true },
         where: and(
           eq(ERUDIT.db.schema.contentUniques.contentFullId, contentFullId),
           eq(ERUDIT.db.schema.contentUniques.uniqueName, uniqueName),
@@ -239,15 +269,24 @@ async function resolveUniqueEntries(
 
       if (!dbUnique) return null;
 
-      const pageLink = await ERUDIT.repository.content.link(contentFullId);
+      const navNode = ERUDIT.contentNav.getNodeOrThrow(contentFullId);
       const schemaName = dbUnique.prose.schema.name;
 
       if (!schemaName) return null;
 
+      const link =
+        navNode.type === 'topic'
+          ? PAGES.topic(
+              dbUnique.contentProseType as any,
+              navNode.shortId,
+              dbUnique.prose.id,
+            )
+          : PAGES.page(navNode.shortId, dbUnique.prose.id);
+
       return {
         name: uniqueName,
         title: dbUnique.title ?? undefined,
-        link: `${pageLink}?element=${dbUnique.prose.id}`,
+        link,
         schemaName,
       } satisfies ContentDepUnique;
     }),

package/server/erudit/content/resolve/index.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { inArray, or } from 'drizzle-orm';
 import { contentPathToId } from '@erudit-js/core/content/path';
 
@@ -180,7 +180,7 @@ function renderChangedContentTree(ids: Set<string>): string {
   const walkTree = (node: Node, depth: number) => {
     if (node.name) {
       const indent = '  '.repeat(Math.max(0, depth - 1));
-      lines.push(`${indent}- ${chalk.cyan(node.name)}`);
+      lines.push(`${indent}- ${styleText('cyan', node.name)}`);
     }
 
     const children = Array.from(node.children.values()).sort((a, b) =>
@@ -199,7 +199,7 @@ function renderChangedContentTree(ids: Set<string>): string {
     walkTree(child, 1);
   });
 
-  const header = chalk.gray('Changed content:');
+  const header = styleText('gray', 'Changed content:');
   return [header, ...lines].join('\n');
 }