erudit 4.2.0 → 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,73 +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',
     }));
   },
 };
 
-// Names that are available on globalThis and should not be bundled as real imports
-const globalNames = new Set<string>([
-  // JSX runtime
-  'jsx',
-  '_jsx',
-  'jsxs',
-  '_jsxs',
-  'Fragment',
-  '_Fragment',
-  // Prose tag names registered in globalThis
-  ...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 (globalNames.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'
@@ -137,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/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 }
+        : {}),
     };
   }
 

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');
 }
 

package/server/erudit/content/resolve/utils/contentError.ts

@@ -1,10 +1,10 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import type { ContentNavNode } from '../../nav/types';
 
 export function logContentError(contentNode: ContentNavNode) {
   ERUDIT.log.error(
     `Error parsing ${contentNode.type} ${ERUDIT.log.stress(
       contentNode.fullId,
-    )}!\nLocation: ${chalk.red(ERUDIT.paths.project(`content/${contentNode.contentRelPath}`))}`,
+    )}!\nLocation: ${styleText('red', ERUDIT.paths.project(`content/${contentNode.contentRelPath}`))}`,
   );
 }

package/server/erudit/content/resolve/utils/insertContentResolved.ts

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 import { sql } from 'drizzle-orm';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
 import { builtValidPaths } from '../../global/build';
@@ -80,7 +80,24 @@ async function insertContentDeps(
     await ERUDIT.db
       .insert(ERUDIT.db.schema.contentDeps)
       .values(contentDeps)
-      .onConflictDoNothing();
+      .onConflictDoUpdate({
+        target: [
+          ERUDIT.db.schema.contentDeps.fromFullId,
+          ERUDIT.db.schema.contentDeps.toFullId,
+        ],
+        set: {
+          // Merge unique names from the auto dep into the existing row
+          // (which may already be a hard dep that has no uniqueNames yet).
+          // Only uniqueNames is updated — hard/reason are left untouched.
+          uniqueNames: sql`CASE
+            WHEN ${ERUDIT.db.schema.contentDeps.uniqueNames} IS NULL
+              THEN excluded.uniqueNames
+            WHEN excluded.uniqueNames IS NULL
+              THEN ${ERUDIT.db.schema.contentDeps.uniqueNames}
+            ELSE ${ERUDIT.db.schema.contentDeps.uniqueNames} || ',' || excluded.uniqueNames
+          END`,
+        },
+      });
   }
 }
 
@@ -93,7 +110,7 @@ function filterTargetMap(
   const brokenLinkMessage = (message: string, metas: ContentLinkUsage[]) => {
     let output = `${message} in ${ERUDIT.log.stress(contentFullId)}:\n`;
     for (const { type, label } of metas) {
-      output += `  ${chalk.gray('➔')}  <${type}>${label}</${type}>\n`;
+      output += `  ${styleText('gray', '➔')}  <${type}>${label}</${type}>\n`;
     }
     return output;
   };
@@ -104,7 +121,7 @@ function filterTargetMap(
     if (storageKey.startsWith('<link:unknown>/')) {
       ERUDIT.log.warn(
         brokenLinkMessage(
-          `Unknown link ${chalk.red(storageKey.replace('<link:unknown>/', ''))}`,
+          `Unknown link ${styleText('red', storageKey.replace('<link:unknown>/', ''))}`,
           metas,
         ),
       );
@@ -136,7 +153,7 @@ function filterTargetMap(
       } catch {
         ERUDIT.log.warn(
           brokenLinkMessage(
-            `Failed to resolve content link ${chalk.red(storageKey.replace('<link:global>/', ''))}`,
+            `Failed to resolve content link ${styleText('red', storageKey.replace('<link:global>/', ''))}`,
             metas,
           ),
         );

package/server/erudit/global.ts

@@ -11,6 +11,7 @@ import type { EruditServerPaths } from './path';
 import type { EruditServerRepository } from './repository';
 
 import { registerProseGlobals } from '#erudit/prose/global';
+import { registerAutoImportGlobals } from '#erudit/autoImports';
 
 export const ERUDIT: {
   buildError: EruditServerBuildError;
@@ -27,7 +28,9 @@ export const ERUDIT: {
   import: EruditServerImporter;
 } = {} as any;
 
-Object.assign(globalThis, {
+(globalThis as any).ERUDIT_GLOBAL = (globalThis as any).ERUDIT_GLOBAL || {};
+
+Object.assign((globalThis as any).ERUDIT_GLOBAL, {
   defineContributor,
   defineSponsor,
   defineCameo,
@@ -40,3 +43,4 @@ Object.assign(globalThis, {
 });
 
 registerProseGlobals();
+registerAutoImportGlobals();