erudit 4.1.0 → 4.2.0-dev.1

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

@@ -22,9 +22,8 @@ export function createGlobalTemplate(nuxt: Nuxt, elementsData: ElementData[]) {
   }
 
   const template = `
-import { PROSE_REGISTRY } from '@jsprose/core';
-import { jsx, jsxs, Fragment } from '@jsprose/core/jsx-runtime';
-import type { EruditProseCoreElement } from '@erudit-js/prose';
+import { jsx, jsxs, Fragment } from 'tsprose/jsx-runtime';
+import type { ProseCoreElements } from '@erudit-js/prose';
 import { defineProblemScript } from '@erudit-js/prose/elements/problem/problemScript';
 
 ${Object.entries(cores)
@@ -41,32 +40,39 @@ ${Object.entries(globals)
   )
   .join('\n')}
 
-const coreElements: EruditProseCoreElement[] = [
-    ${Object.keys(cores).join(',\n    ')}
-].flatMap(element => (Array.isArray(element) ? element : [element]) as any);
+export const coreElements: ProseCoreElements = Object.fromEntries([
+  ${Object.keys(cores).join(',\n  ')}
+  ]
+  .flatMap((element: any) => (Array.isArray(element) ? element : [element]))
+  .map((element: any) => [element.schema.name, element])
+);
 
-const elementsGlobals = {
-    ${Object.keys(globals)
-      .map((key) => `...${key}`)
-      .join(',\n    ')}
+export const elementsGlobals = {
+  ${Object.keys(globals)
+    .map((key) => `...${key}`)
+    .join(',\n    ')}
 }
 
 export function registerProseGlobals() {
-    for (const element of coreElements) {
-        PROSE_REGISTRY.addItem(element.registryItem);
-        Object.assign(globalThis, element.registryItem.tags || {});
+  for (const coreElement of Object.values(coreElements)) {
+    const tags = coreElement.tags || [];
+    for (const tag of tags) {
+      Object.assign(globalThis, {
+        [tag.tagName]: tag,
+      });
     }
+  }
 
-    Object.assign(globalThis, {
-        // Make jsx runtime globally available (for prose generation in isolated modules like problem scripts)
-        jsx,
-        jsxs,
-        Fragment,
-        // Problem globals
-        defineProblemScript,
-        // Elements globals
-        ...elementsGlobals
-    });
+  Object.assign(globalThis, {
+    // Make jsx runtime globally available (for prose generation in isolated modules like problem scripts)
+    jsx,
+    jsxs,
+    Fragment,
+    // Problem globals
+    defineProblemScript,
+    // Elements globals
+    ...elementsGlobals
+  });
 }
     `.trim();
 

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

@@ -1,13 +1,14 @@
 import chalk from 'chalk';
 import type { Nuxt } from 'nuxt/schema';
 import { findPath } from 'nuxt/kit';
-import type { EruditProseCoreElement } from '@erudit-js/prose';
+
+import type { ProseCoreElement } from '@erudit-js/prose';
 
 import type { EruditRuntimeConfig } from '../../../../shared/types/runtimeConfig';
 import { moduleLogger } from '../../logger';
 import type { ElementData } from './shared';
 import { createTagsTable } from './tagsTable';
-import { createGlobalTypes } from './globalTypes';
+import { createElementGlobalTypes } from './elementGlobalTypes';
 import { createGlobalTemplate } from './globalTemplate';
 import { createAppTemplate } from './appTemplate';
 import { PROJECT_PATH } from '../../env';
@@ -60,7 +61,7 @@ export async function setupProseElements(
 
     const elementData: ElementData = {
       name: uniqueElementName,
-      registryItems: [],
+      coreElements: [],
       absDirectory: '',
       absCorePath: '',
       absAppPath: undefined,
@@ -91,7 +92,7 @@ export async function setupProseElements(
       elementData.absAppPath = appAbsPath;
     }
 
-    const coreDefault: EruditProseCoreElement | EruditProseCoreElement[] = (
+    const coreDefault: ProseCoreElement | ProseCoreElement[] = (
       await import(coreAbsPath)
     ).default;
 
@@ -100,7 +101,7 @@ export async function setupProseElements(
       : [coreDefault];
 
     for (const coreElement of coreElements) {
-      const schemaName = coreElement.registryItem.schema.name;
+      const schemaName = coreElement.schema.name;
 
       if (seenSchemas.has(schemaName)) {
         throw new Error(
@@ -109,23 +110,24 @@ export async function setupProseElements(
       }
 
       seenSchemas.add(schemaName);
-      elementData.registryItems.push({
+      elementData.coreElements.push({
         schemaName,
-        tagNames: [],
+        tags: {},
       });
 
-      if (coreElement.registryItem.tags) {
-        for (const tagName of Object.keys(coreElement.registryItem.tags)) {
-          if (seenTags.has(tagName)) {
+      if (coreElement.tags) {
+        for (let i = 0; i < coreElement.tags.length; i++) {
+          const tag = coreElement.tags[i]!;
+          if (seenTags.has(tag.tagName)) {
             throw new Error(
-              `Prose element tag name "<${tagName}>" is already registered by another element!`,
+              `Prose element tag name "<${tag.tagName}>" is already registered by another element!`,
             );
           }
 
-          seenTags.add(tagName);
-          elementData.registryItems[
-            elementData.registryItems.length - 1
-          ]!.tagNames.push(tagName);
+          seenTags.add(tag.tagName);
+          elementData.coreElements[elementData.coreElements.length - 1]!.tags[
+            tag.tagName
+          ] = i;
         }
       }
 
@@ -144,7 +146,7 @@ export async function setupProseElements(
     elementsData.push(elementData);
   }
 
-  createGlobalTypes(elementsData);
+  createElementGlobalTypes(elementsData);
   createGlobalTemplate(nuxt, elementsData);
   createAppTemplate(nuxt, elementsData);
 

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

@@ -1,8 +1,8 @@
 export interface ElementData {
   name: string;
-  registryItems: {
+  coreElements: {
     schemaName: string;
-    tagNames: string[];
+    tags: Record<string, number>;
   }[];
   absDirectory: string;
   absCorePath: string;

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

@@ -2,7 +2,7 @@ import type { ElementData } from './shared';
 
 export function createTagsTable(elementsData: ElementData[], columns = 4) {
   const tagNames = elementsData.flatMap((data) =>
-    data.registryItems.flatMap((item) => item.tagNames),
+    data.coreElements.flatMap((coreElement) => Object.keys(coreElement.tags)),
   );
 
   if (tagNames.length === 0) return '';

package/modules/erudit/setup/runtimeConfig.ts

@@ -43,6 +43,8 @@ export async function setupEruditRuntimeConfig(nuxt: Nuxt) {
       slowTransition: eruditConfig.debug?.slowTransition ?? false,
       fakeApi: {
         repository: eruditConfig.debug?.fakeApi?.repository ?? nuxt.options.dev,
+        lastChanged:
+          eruditConfig.debug?.fakeApi?.lastChanged ?? nuxt.options.dev,
       },
       analytics: eruditConfig.debug?.analytics,
     },

package/nuxt.config.ts

@@ -50,9 +50,9 @@ export default defineNuxtConfig({
       },
     },
     rollupConfig: {
-      // Prevent inlining some packages to avoid singleton and Symbol duplication issues
+      // Prevent inlining some packages
       external(source) {
-        const ignore = ['jiti', '@jsprose'];
+        const ignore = ['jiti', 'tsprose'];
 
         for (const ignoreItem of ignore) {
           if (source.includes(ignoreItem)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erudit",
-  "version": "4.1.0",
+  "version": "4.2.0-dev.1",
   "type": "module",
   "description": "🤓 CMS for perfect educational sites.",
   "license": "MIT",
@@ -24,30 +24,31 @@
     }
   },
   "dependencies": {
-    "@erudit-js/cli": "4.1.0",
-    "@erudit-js/core": "4.1.0",
-    "@erudit-js/prose": "4.1.0",
+    "@erudit-js/cli": "4.2.0-dev.1",
+    "@erudit-js/core": "4.2.0-dev.1",
+    "@erudit-js/prose": "4.2.0-dev.1",
     "unslash": "^2.0.0",
     "@floating-ui/vue": "^1.1.10",
-    "@jsprose/core": "^1.0.0",
-    "@tailwindcss/vite": "^4.1.18",
+    "tsprose": "^1.0.0",
+    "@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.8",
+    "drizzle-kit": "^0.31.9",
     "drizzle-orm": "^0.45.1",
-    "esbuild": "^0.27.2",
+    "esbuild": "^0.27.3",
     "flexsearch": "^0.8.212",
-    "glob": "^13.0.0",
+    "glob": "^13.0.6",
     "image-size": "^2.0.2",
     "jiti": "^2.6.1",
-    "nuxt": "4.3.0",
+    "nuxt": "4.3.1",
     "nuxt-my-icons": "1.2.2",
     "perfect-debounce": "^2.1.0",
-    "tailwindcss": "^4.1.18",
-    "vue": "^3.5.27",
-    "vue-router": "^5.0.2"
+    "tailwindcss": "^4.2.0",
+    "vue": "^3.5.28",
+    "vue-router": "^5.0.3",
+    "ts-xor": "^1.3.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13"

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

@@ -64,7 +64,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
   }
 
   if (contentTypePath.type === 'page' || contentTypePath.type === 'topic') {
-    const proseElement = await ERUDIT.repository.prose.getContent(
+    const prose = await ERUDIT.repository.prose.getContent(
       contentTypePath.type === 'topic'
         ? contentTypePath.topicPart
         : contentTypePath.type,
@@ -72,7 +72,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
     );
 
     const topicParts = await ERUDIT.repository.content.topicParts(fullId);
-    const { storage } = await ERUDIT.repository.prose.finalize(proseElement);
+    const { storage } = await ERUDIT.repository.prose.finalize(prose);
 
     const where = (() => {
       if (contentTypePath.type === 'topic') {
@@ -101,7 +101,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
         type: 'topic',
         part: contentTypePath.topicPart,
         parts: topicParts,
-        proseElement,
+        prose,
         storage,
       };
 
@@ -123,7 +123,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
     const mainContentPage: MainContentPage = {
       ...mainContentBase,
       type: 'page',
-      proseElement,
+      prose,
       storage,
     };
 
@@ -141,6 +141,7 @@ export default defineEventHandler<Promise<MainContent>>(async (event) => {
   //
   // Rest content types
   //
+
   return {
     ...mainContentBase,
     type: contentTypePath.type,

package/server/api/prerender/content.ts

@@ -68,9 +68,7 @@ export async function problemScripts() {
   for (const dbProblemScript of dbProblemScripts) {
     routes.push(
       `/api/problemScript/` +
-        dbProblemScript
-          .problemScript!.replace(ERUDIT.paths.project() + '/', '')
-          .replace('.tsx', '') +
+        dbProblemScript.problemScript!.replace('.tsx', '') +
         '.js',
     );
   }

package/server/api/preview/contentPage/[...contentTypePath].ts

@@ -3,7 +3,7 @@ import { eq } from 'drizzle-orm';
 export default defineEventHandler<Promise<PreviewContentPage>>(
   async (event) => {
     // <typeOrPart>/<fullOrShortId>.json
-    const strContentTypePath = event.context.params!.contentTypePath.slice(
+    const strContentTypePath = event.context.params!.contentTypePath!.slice(
       0,
       -5,
     );
@@ -17,7 +17,6 @@ export default defineEventHandler<Promise<PreviewContentPage>>(
       columns: {
         title: true,
         description: true,
-        // TODO: decoration svg!
       },
       where: eq(ERUDIT.db.schema.content.fullId, fullId),
     }))!;

package/server/api/preview/contentUnique/[...contentTypePathUnique].ts

@@ -1,73 +1,58 @@
-import { mixSchema, uniqueName2Id, type ProseElement } from '@jsprose/core';
 import { headingSchema } from '@erudit-js/prose/elements/heading/core';
 import { detailsSchema } from '@erudit-js/prose/elements/details/core';
+import { isProseElement, makeProseElement, mixSchema } from 'tsprose';
 
 export default defineEventHandler<Promise<PreviewContentUnique>>(
   async (event) => {
     // <typeOrPart>/<fullContentId>/<uniqueName>.json
     const strContentTypePathUnique =
-      event.context.params!.contentTypePathUnique.slice(0, -5);
+      event.context.params!.contentTypePathUnique!.slice(0, -5);
     const parts = strContentTypePathUnique.split('/');
-
     const strContentTypePath = parts.slice(0, -1).join('/');
-    const uniqueName = parts.at(-1)!;
-
+    const uniqueName = decodeURIComponent(parts.at(-1)!);
     const contentTypePath = parseContentTypePath(strContentTypePath);
     const fullId = contentTypePath.contentId;
     const navNode = ERUDIT.contentNav.getNodeOrThrow(fullId);
     const shortId = navNode.shortId;
-
     const contentTitle = await ERUDIT.repository.content.title(fullId);
-
     const unique = await ERUDIT.repository.content.unique(
       fullId,
       contentTypePath.type === 'topic' ? contentTypePath.topicPart : 'page',
       uniqueName,
     );
-
     const uniqueProse = await (async () => {
-      if (unique.prose.schemaName === headingSchema.name) {
+      if (isProseElement(unique.prose, headingSchema)) {
         return await ERUDIT.repository.content.uniqueHeading(
           fullId,
           contentTypePath.type === 'topic' ? contentTypePath.topicPart : 'page',
-          uniqueName,
+          unique.prose.id,
         );
-      } else if (unique.prose.schemaName === detailsSchema.name) {
-        const mix: ProseElement<typeof mixSchema> = {
-          __JSPROSE_element: true,
-          schemaName: mixSchema.name,
-          children: unique.prose.children!,
-        } as ProseElement<typeof mixSchema>;
-
-        return mix;
+      } else if (isProseElement(unique.prose, detailsSchema)) {
+        return makeProseElement({
+          schema: mixSchema,
+          elementHandler: (element) => {
+            element.children = unique.prose.children!;
+          },
+        });
       } else {
         return unique.prose;
       }
     })();
-
     const finalizedProse = await ERUDIT.repository.prose.finalize(uniqueProse);
-
     const link = (() => {
       if (contentTypePath.type === 'topic') {
-        return PAGES.topic(
-          contentTypePath.topicPart,
-          shortId,
-          uniqueName2Id(uniqueName),
-        );
+        return PAGES.topic(contentTypePath.topicPart, shortId, unique.prose.id);
       }
-
-      return PAGES[contentTypePath.type](shortId, uniqueName2Id(uniqueName));
+      return PAGES[contentTypePath.type](shortId, unique.prose.id);
     })();
-
     const previewContentUnique: PreviewContentUnique = {
-      schemaName: unique.prose.schemaName,
+      schemaName: unique.prose.schema.name,
       elementTitle: unique.title || undefined,
-      fadeOverlay: unique.prose.schemaName === headingSchema.name,
+      fadeOverlay: isProseElement(unique.prose, headingSchema),
       contentTitle,
       link,
       ...finalizedProse,
     };
-
     return previewContentUnique;
   },
 );

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

@@ -1,12 +1,14 @@
 import { resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
 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';
 
 export default defineEventHandler<Promise<string>>(async (event) => {
   // <filepathToScriptFile>.js
-  const problemScriptPath = event.context.params!.problemScriptPath.slice(
+  const problemScriptPath = event.context.params!.problemScriptPath!.slice(
     0,
     -3,
   ); // remove .js
@@ -23,14 +25,14 @@ export default defineEventHandler<Promise<string>>(async (event) => {
       $CONTRIBUTOR: '{}',
     },
     jsx: 'automatic',
-    plugins: [jsxRuntimePlugin, staticFilesPlugin],
+    plugins: [jsxRuntimePlugin, proseGlobalsPlugin, staticFilesPlugin],
     alias: {
       '#project': ERUDIT.paths.project() + '/',
       '#content': ERUDIT.paths.project('content') + '/',
     },
   });
 
-  let code = buildResult.outputFiles[0].text;
+  let code = buildResult.outputFiles[0]!.text;
 
   // Transform $CONTENT patterns to link objects
   code = code.replace(/\$CONTENT(\.[a-zA-Z_$][\w$]*)+/g, (match) => {
@@ -71,6 +73,69 @@ const jsxRuntimePlugin: Plugin = {
   },
 };
 
+// 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',
+  setup(build) {
+    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);
+            }
+          }
+
+          const lines: string[] = [];
+          if (keepParts.length > 0)
+            lines.push(`import { ${keepParts.join(', ')} } from '${pkg}';`);
+          lines.push(...shimLines);
+          return lines.join('\n');
+        },
+      );
+
+      const ext = (args.path.match(/[jt]sx?$/)?.[0] ?? 'js') as
+        | 'js'
+        | 'jsx'
+        | 'ts'
+        | 'tsx';
+      return {
+        contents: transformed,
+        loader: ext,
+      };
+    });
+  },
+};
+
 const staticFilesPlugin: Plugin = {
   name: 'static-files',
   setup(build) {
@@ -80,7 +145,11 @@ const staticFilesPlugin: Plugin = {
       },
       async (args) => {
         const absPath = resolve(args.path).replace(/\\/g, '/');
-        const contents = `export default ${JSON.stringify(absPath)};`;
+        const projectPath = ERUDIT.paths.project();
+        const relPath = absPath.startsWith(projectPath + '/')
+          ? absPath.slice(projectPath.length + 1)
+          : absPath;
+        const contents = `export default ${JSON.stringify(relPath)};`;
         return { contents, loader: 'js' };
       },
     );

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

@@ -9,6 +9,8 @@ let initialBuild = true;
 
 const contentRoot = () => ERUDIT.paths.project('content');
 
+export let builtLinkObject: Record<string, any> | null = null;
+
 export async function buildGlobalContent() {
   ERUDIT.log.debug.start('Building global content...');
 
@@ -21,6 +23,7 @@ export async function buildGlobalContent() {
   }
 
   const linkObject = await buildLinkObject();
+  builtLinkObject = linkObject;
 
   const linkTypes = linkObjectToTypes(linkObject);
   writeFileSync(
@@ -51,6 +54,10 @@ function linkObjectToTypes(linkObject: any): string {
     return str.replace(/[-_](.)/g, (_, char) => char.toUpperCase());
   }
 
+  function isValidIdentifier(key: string): boolean {
+    return /^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(key);
+  }
+
   function processObject(obj: any, level: number): string {
     const lines: string[] = [];
 
@@ -58,6 +65,9 @@ function linkObjectToTypes(linkObject: any): string {
       if (key === '__jsdoc' || key === '__typeguard') continue;
 
       const camelKey = toCamelCase(key);
+      const outputKey = isValidIdentifier(camelKey)
+        ? camelKey
+        : `'${camelKey}'`;
 
       // Add JSDoc comment if present
       if (value && typeof value === 'object' && value.__jsdoc) {
@@ -77,11 +87,11 @@ function linkObjectToTypes(linkObject: any): string {
       const typeguard = value?.__typeguard || 'GlobalContentItemTypeguard';
 
       if (hasNestedProps) {
-        lines.push(indent(level) + `${camelKey}: ${typeguard} & {`);
+        lines.push(indent(level) + `${outputKey}: ${typeguard} & {`);
         lines.push(processObject(value, level + 1));
         lines.push(indent(level) + `}`);
       } else {
-        lines.push(indent(level) + `${camelKey}: ${typeguard} & {}`);
+        lines.push(indent(level) + `${outputKey}: ${typeguard} & {}`);
       }
     }
 
@@ -118,7 +128,7 @@ async function buildLinkObject() {
 
     // Navigate through parent parts
     for (let i = 0; i < pathParts.length - 1; i++) {
-      cursor = cursor[pathParts[i]];
+      cursor = cursor[pathParts[i]!];
     }
 
     //
@@ -230,10 +240,10 @@ ${jsdoc}
 }
 
 function tryGetTitle(moduleContent: string) {
-  const titleMatch = moduleContent.match(/title:\s*['"`](.*?)['"`]/);
+  const titleMatch = moduleContent.match(/title:\s*(['"`])(.*?)\1/);
 
   if (titleMatch) {
-    return titleMatch[1].trim();
+    return titleMatch[2]!.trim();
   }
 }
 
@@ -259,7 +269,7 @@ function tryGetUniquesObject(
   const uniquesContent = uniquesMatch[1];
 
   // Parse key-value pairs from uniques object
-  const lines = uniquesContent.split('\n');
+  const lines = uniquesContent!.split('\n');
   const result: any = {};
 
   for (const line of lines) {
@@ -273,7 +283,11 @@ function tryGetUniquesObject(
       continue;
     }
 
-    const pairMatch = line.match(/(\w+):\s*(\w+)/);
+    // Support bracket notation ['any string'], quoted keys "any string" / 'any string', and plain identifiers
+    const pairMatch =
+      line.match(/\[['"](.*?)['"]\]:\s*(\w+)/) ||
+      line.match(/['"](.*?)['"]:\s*(\w+)/) ||
+      line.match(/(\w+):\s*(\w+)/);
     if (!pairMatch) {
       continue;
     }

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

@@ -216,16 +216,16 @@ function parseContentPath(relPath: string):
 
   for (let i = 0; i < parts.length; i++) {
     const part = parts[i];
-    const typeDelimiterPos = part.search(/[+-]/);
+    const typeDelimiterPos = part!.search(/[+-]/);
     if (typeDelimiterPos <= 0) return;
 
-    const posStr = part.slice(0, typeDelimiterPos);
+    const posStr = part!.slice(0, typeDelimiterPos);
     if (!/^\d+$/.test(posStr)) return;
     const posNum = Number(posStr);
 
-    const typeDelimiter = part.charAt(typeDelimiterPos);
+    const typeDelimiter = part!.charAt(typeDelimiterPos);
     skip = typeDelimiter === '+';
-    idPart = part.slice(typeDelimiterPos + 1);
+    idPart = part!.slice(typeDelimiterPos + 1);
     if (!idPart) return;
 
     fullId += `/${idPart}`;

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

@@ -24,7 +24,7 @@ export async function getContentChildren(
     const elementSnippets = await ERUDIT.repository.content.elementSnippets(
       childNode.fullId,
     );
-    const quickLinks = elementSnippets?.filter((snippet) => snippet.quick);
+    const keyLinks = elementSnippets?.filter((snippet) => snippet.key);
     const stats = await ERUDIT.repository.content.stats(childNode.fullId);
 
     const child: MainContentChildrenItem = {
@@ -37,8 +37,8 @@ export async function getContentChildren(
       child.description = description;
     }
 
-    if (quickLinks && quickLinks.length > 0) {
-      child.quickLinks = quickLinks;
+    if (keyLinks && keyLinks.length > 0) {
+      child.keyLinks = keyLinks;
     }
 
     if (stats) {