erudit 3.0.0-dev.10 → 3.0.0-dev.11

package/app/components/SiteMain.vue

@@ -1,8 +1,6 @@
 <template>
     <main :class="$style.main" erudit-main>
-        <ClientOnly>
-            <Preview />
-        </ClientOnly>
+        <Preview />
         <div :class="$style.mainInner">
             <slot></slot>
         </div>

package/app/components/aside/major/panes/Pages.vue

@@ -27,7 +27,7 @@ function linkAttrs(link: string) {
         <AsideListItem
             icon="users"
             v-bind="linkAttrs('/members')"
-            :main="phrase.members + ':'"
+            :main="phrase.members"
             :secondary="memberCount!.toString()"
         />
     </PaneContentScroll>

package/app/components/aside/major/panes/other/ItemContent.vue

@@ -23,7 +23,7 @@ if (strDate) {
         :link="`https://github.com/${eruditConfig.repository?.name}`"
         target="_blank"
         icon="draw"
-        :main="phrase.content + ':'"
+        :main="phrase.content"
         :secondary
     />
 </template>

package/app/components/aside/major/panes/other/ItemGenerator.vue

@@ -7,7 +7,7 @@ import { version } from '@erudit/package.json';
         link="https://github.com/erudit-js/erudit"
         target="_blank"
         icon="chip"
-        main="Erudit:"
+        main="Erudit"
         :secondary="version"
     />
 </template>

package/app/components/aside/major/panes/other/ItemTheme.vue

@@ -47,7 +47,7 @@ onMounted(() => {
         <AsideListItem
             @click="_cycle"
             :icon="themeItem![0]"
-            :main="phrase.theme + ':'"
+            :main="phrase.theme"
             :secondary="themeItem![1]"
         />
     </ClientOnly>

package/app/components/bitran/BitranContent.vue

@@ -56,7 +56,7 @@ const isServer = import.meta.server;
 <style lang="scss" module>
 @use '$/def/bp';
 
-.eruditBitranContainer {
+:global(.bitran-component).eruditBitranContainer {
     padding: var(--_pMainY) var(--_pMainX);
     padding-left: calc(var(--_pMainX) - var(--_bitran_asideWidth));
 

package/app/components/preview/display/Unique.vue

@@ -21,7 +21,7 @@ const root = await bitranTranspiler.parser.parse(data.bitran.content.biCode);
             <BitranContent
                 :content="{
                     root,
-                    preRenderData: data.bitran.content.preRenderData,
+                    renderDataStorage: data.bitran.content.renderDataStorage,
                 }"
                 :context="data.bitran.context"
             />

package/app/composables/bitran.ts

@@ -88,7 +88,7 @@ export async function useBitranRenderers() {
 
 export async function useBitranElementRenderer(productName: string) {
     const renderer =
-        (await useBitranRenderers())[productName] ||
+        (await getRenderers())[productName] ||
         getDefaultBitranRenderers()[productName];
 
     if (!renderer)

package/app/composables/bitranContent.ts

@@ -7,6 +7,7 @@ import {
     stringifyBitranLocation,
     type BitranLocation,
 } from '@erudit-js/cog/schema';
+
 import type { StringBitranContent } from '@erudit/shared/bitran/stringContent';
 
 import eruditConfig from '#erudit/config';
@@ -33,9 +34,32 @@ export async function useBitranContent(
 
         // @ts-ignore
         contentPromise = (async () => {
-            const stringContent = (await $fetch(apiRoute, {
-                responseType: 'json',
-            })) as StringBitranContent;
+            const locationString = encodeBitranLocation(
+                stringifyBitranLocation(location.value!),
+            );
+
+            const payloadKey = `content`;
+            const payload =
+                (nuxtApp.static.data[payloadKey] ||=
+                nuxtApp.payload.data[payloadKey] ||=
+                    {});
+
+            let stringContent: StringBitranContent;
+
+            if (payload.location === locationString) {
+                stringContent = payload;
+            } else {
+                stringContent = await $fetch(apiRoute, {
+                    responseType: 'json',
+                });
+
+                // Clear the payload and set new data
+                Object.keys(payload).forEach((key) => delete payload[key]);
+                Object.assign(payload, {
+                    ...stringContent,
+                    location: locationString,
+                });
+            }
 
             const bitranTranspiler = await useBitranTranspiler();
 
@@ -58,7 +82,7 @@ export async function useBitranContent(
 
             content.value = {
                 root,
-                preRenderData: stringContent.preRenderData,
+                renderDataStorage: stringContent.renderDataStorage,
             };
 
             return content;

package/app/scripts/preview/build.ts

@@ -1,13 +1,15 @@
 import { PreviewDataType, type PreviewData } from './data';
 import { PreviewRequestType, type PreviewRequest } from './request';
-
-import { buildGenericLink } from './data/genericLink';
-import { buildPageLink } from './data/pageLink';
-import { buildUnique } from './data/unique';
-import { createPreviewError } from './data/alert';
 import { PreviewThemeName } from './state';
 
-const builders = [buildGenericLink, buildPageLink, buildUnique];
+const builders = [
+    async (request: PreviewRequest) =>
+        (await import('./data/genericLink')).buildGenericLink(request),
+    async (request: PreviewRequest) =>
+        (await import('./data/pageLink')).buildPageLink(request),
+    async (request: PreviewRequest) =>
+        (await import('./data/unique')).buildUnique(request),
+];
 
 export async function buildPreviewData(
     request: PreviewRequest,
@@ -24,6 +26,8 @@ export async function buildPreviewData(
                 'expected_page_hash',
             );
 
+            const { createPreviewError } = await import('./data/alert');
+
             return createPreviewError({
                 title: phrase.preview_missing_title,
                 message: phrase.preview_missing_explain_mismatch,
@@ -36,6 +40,8 @@ export async function buildPreviewData(
                 'element_id',
             );
 
+            const { createPreviewError } = await import('./data/alert');
+
             return createPreviewError({
                 title: phrase.preview_missing_title,
                 message: phrase.preview_missing_explain,
@@ -66,6 +72,7 @@ export async function buildPreviewData(
         if (result) return result;
     }
 
+    const { createPreviewError } = await import('./data/alert');
     throw createPreviewError({
         message: `Unable to build preview data for request!`,
         pre: JSON.stringify(request, null, 4),

package/module/imports.ts

@@ -33,6 +33,11 @@ export function setupGlobalImports() {
                 from: eruditPath(`globals/content`),
             }));
         })(),
+        // Problems Generation
+        {
+            name: 'defineProblemGenerator',
+            from: '@erudit-js/bitran-elements/problem/generator',
+        },
         // Helper Asset Path Functions
         ...(() => {
             const imports = [

package/module/index.ts

@@ -7,6 +7,7 @@ import { logger } from '@erudit/module/logger';
 import { setupGlobalImports } from '@erudit/module/imports';
 import { setupBitranTemplates } from './bitran';
 import { setupGlobalPaths } from './paths';
+import { setupProblemGenerators } from './problemGenerators';
 
 export default defineNuxtModule({
     meta: { name: 'Erudit', configKey: 'erudit' },
@@ -18,6 +19,7 @@ export default defineNuxtModule({
 
         const eruditConfig = await setupEruditConfig(_nuxt);
         await setupBitranTemplates(_nuxt);
+        await setupProblemGenerators(_nuxt);
         setupGlobalPaths(_nuxt);
 
         if (eruditConfig.site?.baseUrl) {

package/module/problemGenerators.ts

@@ -0,0 +1,46 @@
+import { addTemplate } from 'nuxt/kit';
+import type { Nuxt } from 'nuxt/schema';
+import { globSync } from 'glob';
+
+import { eruditEndNuxtPath, projectPath } from '@erudit/globalPath';
+import { getContentPath } from '@erudit/utils/contentPath';
+
+export async function setupProblemGenerators(_nuxt: Nuxt) {
+    const templateName = '#erudit/problemGenerators.ts';
+
+    addTemplate({
+        filename: templateName,
+        write: true,
+        async getContents() {
+            const generatorFiles = findGenerators();
+
+            return `
+export const loaders = {
+${generatorFiles
+    .map((file) => {
+        const filePath = projectPath('content/' + file);
+        const contentPath = getContentPath(
+            file,
+            projectPath('content'),
+        ).replace(/\.gen\.(js|ts)$/, '');
+        return `    '${contentPath}': async () => (await import('${filePath}')).default,`;
+    })
+    .join('\n')}
+}
+            `.trim();
+        },
+    });
+
+    const alias = (_nuxt.options.alias ||= {});
+    alias['#erudit/problemGenerators'] = eruditEndNuxtPath(
+        `.nuxt/${templateName}`,
+    );
+}
+
+function findGenerators() {
+    const generatorFiles = globSync('**/*.gen.{js,ts}', {
+        cwd: projectPath('content'),
+        posix: true,
+    });
+    return generatorFiles;
+}

package/nuxt.config.ts

@@ -18,11 +18,17 @@ export default defineNuxtConfig({
         '@shared': eruditPath('shared'),
         '@app': eruditPath('app'),
         $: eruditPath('app/styles'),
+        //
+        '#project': projectPath(),
+        '#content': projectPath('content'),
     },
     modules: [eruditPath('module'), 'nuxt-my-icons'],
     myicons: {
         iconsDir: eruditPath('app/assets/icons'),
     },
+    features: {
+        inlineStyles: false,
+    },
     typescript: {
         tsConfig: {
             include: [eruditPath('**/*'), projectPath('**/*')],

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "erudit",
-    "version": "3.0.0-dev.10",
+    "version": "3.0.0-dev.11",
     "type": "module",
     "description": "🤓 CMS for perfect educational sites.",
     "license": "MIT",
@@ -15,14 +15,14 @@
         "erudit": "bin/erudit.mjs"
     },
     "peerDependencies": {
-        "@erudit-js/cog": "3.0.0-dev.10",
-        "@erudit-js/cli": "3.0.0-dev.10",
-        "@erudit-js/bitran-elements": "3.0.0-dev.10"
+        "@erudit-js/cog": "3.0.0-dev.11",
+        "@erudit-js/cli": "3.0.0-dev.11",
+        "@erudit-js/bitran-elements": "3.0.0-dev.11"
     },
     "dependencies": {
-        "@bitran-js/core": "1.0.0-dev.11",
-        "@bitran-js/renderer-vue": "1.0.0-dev.11",
-        "@bitran-js/transpiler": "1.0.0-dev.11",
+        "@bitran-js/core": "1.0.0-dev.12",
+        "@bitran-js/renderer-vue": "1.0.0-dev.12",
+        "@bitran-js/transpiler": "1.0.0-dev.12",
         "@floating-ui/vue": "^1.1.6",
         "chalk": "^5.4.1",
         "chokidar": "^4.0.3",

package/server/plugin/bitran/content.ts

@@ -1,11 +1,13 @@
-import { createPreRenderData, type PreRenderData } from '@bitran-js/transpiler';
 import {
     BlockErrorNode,
     BlockNode,
     BlocksNode,
+    createRenderData,
+    ElementNode,
     InlinerErrorNode,
+    walkDown,
+    type RenderDataStorage,
 } from '@bitran-js/core';
-
 import {
     isTopicPart,
     mergeAliases,
@@ -26,11 +28,10 @@ import { DbTopic } from '@server/db/entities/Topic';
 import { DbGroup } from '@server/db/entities/Group';
 import { traverseInclude } from '@server/bitran/elements/include';
 import { createBitranTranspiler } from '@server/bitran/transpiler';
+import { logger } from '@server/logger';
 
 import type { StringBitranContent } from '@shared/bitran/stringContent';
 
-import { logger } from '@server/logger';
-
 interface RawBitranContent {
     context: BitranContext;
     biCode: string;
@@ -122,63 +123,56 @@ async function createBitranContent(
         setEruditBitranRuntime(item, runtime),
     );
 
+    const renderDataStorage: RenderDataStorage = {};
+
+    async function makePreRender(node: ElementNode) {
+        if (generatePrerenderData === false) {
+            return;
+        }
+
+        const transpiler = bitranTranspiler.transpilers[node.name];
+        await createRenderData({
+            storage: renderDataStorage,
+            node,
+            extra: runtime,
+            generator: transpiler?.renderDataGenerator,
+        });
+    }
+
     const root = await bitranTranspiler.parser.parse(biCode, {
         async step(node) {
-            if (node instanceof AliasesNode) {
-                mergeAliases(context.aliases, node.parseData);
-                return;
+            switch (true) {
+                case node instanceof AliasesNode:
+                    mergeAliases(context.aliases, node.parseData);
+                    break;
+                case node instanceof IncludeNode:
+                    await resolveInclude(node, context);
+                    break;
+                case node instanceof BlockErrorNode:
+                case node instanceof InlinerErrorNode:
+                    logParseError(node.name, node.error);
+                    return;
             }
 
-            if (node instanceof IncludeNode) {
-                await resolveInclude(node, context);
-                return;
-            }
+            await makePreRender(node);
 
-            if (
-                node instanceof BlockErrorNode ||
-                node instanceof InlinerErrorNode
-            ) {
-                logParseError(node.name, node.error);
-                return;
+            if (node instanceof IncludeNode) {
+                for (const block of node.parseData.blocks?.children || []) {
+                    await walkDown(block, async (child) => {
+                        if (child instanceof ElementNode) {
+                            await makePreRender(child);
+                        }
+                    });
+                }
             }
         },
     });
 
     const finalContent = await bitranTranspiler.stringifier.stringify(root);
 
-    // Building render data
-    const preRenderDataMap: Record<string, PreRenderData> = {};
-
-    if (generatePrerenderData) {
-        await bitranTranspiler.parser.parse(finalContent, {
-            step: async (node) => {
-                const id = node.autoId;
-                const elementTranspiler =
-                    bitranTranspiler.transpilers[node.name]!;
-
-                if (id) {
-                    const preRenderData = await createPreRenderData(
-                        node,
-                        elementTranspiler,
-                        runtime,
-                    );
-                    if (preRenderData) preRenderDataMap[id] = preRenderData;
-                }
-
-                if (
-                    node instanceof BlockErrorNode ||
-                    node instanceof InlinerErrorNode
-                ) {
-                    logParseError(node.name, node.error);
-                    return;
-                }
-            },
-        });
-    }
-
     return {
         biCode: finalContent,
-        preRenderData: preRenderDataMap,
+        renderDataStorage,
     };
 }
 

package/server/plugin/bitran/elements/include.ts

@@ -1,6 +1,5 @@
 import { BlockNode, type ElementNode } from '@bitran-js/core';
 import type { BitranTranspiler } from '@bitran-js/transpiler';
-
 import {
     parseBitranLocation,
     parsePartialBitranLocation,
@@ -34,11 +33,6 @@ export type TraverseStepFn = (payload: {
 
 export type TraverseLeaveFn = (payload: { _location: string }) => Promise<any>;
 
-/**
- * This operation is heavy as fuck.
- * It consumes a lot of memory and is slow.
- * Use as rarely as possible!
- */
 export async function traverseInclude(
     includeNode: IncludeNode,
     context: BitranContext,
@@ -52,27 +46,32 @@ export async function traverseInclude(
         parsePartialBitranLocation(includeNode.id, context.location),
     );
 
+    // Always use absolute locations as keys for travelMap to avoid infinite loop bugs
+    const absEntryLocation = toAbsoluteLocation(
+        entryLocation,
+        context.location.path!,
+        getNavBookIds(),
+    );
+
     const travelMap: Record<string, string | null> = {
-        // Not displayed when error, but needed for checking infinite loops
-        [entryLocation]: null,
+        [absEntryLocation]: null,
     };
 
     try {
         await _traverseStep(
             includeNode,
-            entryLocation,
+            absEntryLocation,
             context.aliases,
             listeners,
             travelMap,
         );
     } catch (message) {
-        let finalMessage = `Include Traversal Error!\n\n${message}\n\n`;
+        let finalMessage = `Include Traversal Error!\n\n${message instanceof Error ? message.message : message}\n\n`;
 
-        for (const [location, includeTarget] of Object.entries(
-            travelMap,
-        ).reverse()) {
+        // Print the traversal path in the order of traversal
+        for (const location of Object.keys(travelMap)) {
+            const includeTarget = travelMap[location];
             if (includeTarget === null) continue;
-
             finalMessage += `at "${printIncludeTarget(includeTarget)}" in "${location}"\n`;
         }
 
@@ -110,11 +109,16 @@ async function _traverseStep(
         );
     } catch (error) {
         travelMap[location] = includeNode.parseData.location;
-        throw error;
+        throw new Error(
+            `Failed to resolve include target location "${includeNode.parseData.location}" from "${location}": ${error instanceof Error ? error.message : error}`,
+        );
     }
 
+    // Use only absolute locations as keys for infinite loop detection
     if (includeTargetLocation in travelMap)
-        throw `Include "${printIncludeTarget(includeNode.parseData.location)}" targets "${includeTargetLocation}" which creates infinite loop!`;
+        throw new Error(
+            `Include "${printIncludeTarget(includeNode.parseData.location)}" targets "${includeTargetLocation}" which creates infinite loop!`,
+        );
 
     travelMap[location] = includeNode.parseData.location;
 
@@ -127,7 +131,9 @@ async function _traverseStep(
     });
 
     if (!dbUnique)
-        throw `Include "${printIncludeTarget(includeNode.parseData.location)}" is targeting to non-existing unique "${includeTargetLocation}"!`;
+        throw new Error(
+            `Include "${printIncludeTarget(includeNode.parseData.location)}" is targeting non-existing unique "${includeTargetLocation}"!`,
+        );
 
     //
     // Creating Bitran core within loaded unique's location context.
@@ -148,18 +154,19 @@ async function _traverseStep(
         }),
     );
 
-    listeners.enter &&
-        (await listeners.enter({
+    if (listeners.enter) {
+        await listeners.enter({
             _biCode: dbUnique.content,
             _location: includeTargetLocation,
             _bitranTranspiler: bitranTranspiler,
-        }));
+        });
+    }
 
     //
     // Parsing unique content and sub-traversing all includes if any.
     //
 
-    let stepErrorMessage: string | undefined;
+    let stepErrorMessage: string | Error | undefined;
 
     await bitranTranspiler.parser.parse(dbUnique.content, {
         step: async (node) => {
@@ -175,13 +182,13 @@ async function _traverseStep(
                     .join('__');
 
             if (!(node instanceof IncludeNode)) {
-                listeners.step &&
-                    (await listeners.step({
+                if (listeners.step) {
+                    await listeners.step({
                         _location: includeTargetLocation,
                         _node: node,
                         _bitranTranspiler: bitranTranspiler,
-                    }));
-
+                    });
+                }
                 return;
             }
 
@@ -193,8 +200,9 @@ async function _traverseStep(
                     listeners,
                     travelMap,
                 );
-            } catch (message: any) {
-                stepErrorMessage = message;
+            } catch (err: any) {
+                stepErrorMessage =
+                    err instanceof Error ? err : new Error(String(err));
             }
         },
     });
@@ -205,10 +213,11 @@ async function _traverseStep(
     // Leaving from current Include
     //
 
-    listeners.leave &&
-        (await listeners.leave({
+    if (listeners.leave) {
+        await listeners.leave({
             _location: includeTargetLocation,
-        }));
+        });
+    }
 }
 
 function printIncludeTarget(target: string) {

package/server/plugin/bitran/toc.ts

@@ -4,6 +4,10 @@ import {
     headingName,
     HeadingNode,
 } from '@erudit-js/bitran-elements/heading/shared';
+import {
+    ProblemNode,
+    ProblemsNode,
+} from '@erudit-js/bitran-elements/problem/shared';
 
 import type { Toc } from '@erudit/shared/bitran/toc';
 import { ERUDIT_SERVER } from '@server/global';
@@ -58,6 +62,16 @@ export async function getBitranToc(location: BitranLocation) {
             return 0;
         };
 
+        // Problems by default are in TOC
+        if (node instanceof ProblemsNode || node instanceof ProblemNode) {
+            toc.push({
+                ...tocItemBase,
+                level: notHeadingLevel(),
+                title: node.meta?.title || node.parseData.info.title,
+            });
+            return;
+        }
+
         if (
             ERUDIT_SERVER.CONFIG.bitran?.toc?.includes(node.name) ||
             node.meta?.toc

package/server/plugin/build/close.ts

@@ -4,7 +4,9 @@ import { ERUDIT_SERVER } from '@server/global';
 export async function close() {
     debug.start('Shutting down server...');
 
-    await ERUDIT_SERVER.DB?.destroy();
+    if (ERUDIT_SERVER.DB && ERUDIT_SERVER.DB.isInitialized) {
+        await ERUDIT_SERVER.DB.destroy();
+    }
 
     logger.success('Server shut down gracefully!');
 }

package/server/plugin/build/jobs/content/generic.ts

@@ -11,6 +11,7 @@ import {
 import { resolvePaths } from '@erudit-js/cog/kit';
 
 import { PROJECT_DIR } from '#erudit/globalPaths';
+import { scanContentPaths } from '@erudit/utils/contentPath';
 import { stress } from '@erudit/utils/stress';
 
 import { debug, logger } from '@server/logger';
@@ -31,7 +32,6 @@ import { contentItemPath } from './path';
 import { buildBook } from './type/book';
 import { buildGroup } from './type/group';
 import { buildTopic } from './type/topic';
-import { scanFiles } from './files';
 
 const typeBuilders: Record<ContentType, Function> = {
     book: buildBook,
@@ -69,7 +69,7 @@ export async function buildContent() {
 }
 
 async function scanContentFiles() {
-    const contentFiles = scanFiles(PROJECT_DIR + '/content');
+    const contentFiles = scanContentPaths(PROJECT_DIR + '/content');
     for (const [path, fullPath] of Object.entries(contentFiles)) {
         const dbFile = new DbFile();
         dbFile.path = path;

package/server/plugin/build/process.ts

@@ -5,6 +5,7 @@ import { setupLanguage } from './jobs/language';
 import { buildContributors } from './jobs/contributors';
 import { buildNav } from './jobs/nav';
 import { buildContent } from './jobs/content/generic';
+import { resetDatabase } from '../db/reset';
 
 let initial = true;
 
@@ -16,6 +17,7 @@ export async function build() {
         initial = false;
     }
 
+    await resetDatabase();
     await setupLanguage();
     await buildContributors();
     await buildNav();

package/server/plugin/build/rebuild.ts

@@ -26,6 +26,7 @@ const rebuildDelay = 300;
 let watcher: FSWatcher;
 let rebuildTimeout: any;
 let rebuildRequested = false;
+let pendingRebuild = false;
 
 export async function setupRebuildWatcher() {
     if (watcher) return;
@@ -41,7 +42,11 @@ export async function setupRebuildWatcher() {
 }
 
 export async function requestServerRebuild(reason?: string) {
-    if (rebuildRequested) return;
+    // If rebuild is in progress, set flag for another rebuild after completion
+    if (rebuildRequested) {
+        pendingRebuild = true;
+        return;
+    }
 
     clearTimeout(rebuildTimeout);
     rebuildTimeout = setTimeout(async () => {
@@ -51,5 +56,11 @@ export async function requestServerRebuild(reason?: string) {
         logger.info(`Rebuilding server data!${reason ? ` ${reason}` : ''}\n\n`);
         await build();
         rebuildRequested = false;
+
+        // If changes were detected during rebuild, start another rebuild
+        if (pendingRebuild) {
+            pendingRebuild = false;
+            requestServerRebuild('Changes detected during previous rebuild');
+        }
     }, rebuildDelay);
 }

package/server/plugin/db/reset.ts

@@ -0,0 +1,12 @@
+import { ERUDIT_SERVER } from '@server/global';
+
+export async function resetDatabase() {
+    const db = ERUDIT_SERVER.DB;
+
+    if (!db) {
+        return;
+    }
+
+    await db.dropDatabase();
+    await db.synchronize(true);
+}

package/server/plugin/db/setup.ts

@@ -1,3 +1,4 @@
+import { rmSync } from 'node:fs';
 import { DataSource } from 'typeorm';
 
 import { PROJECT_DIR } from '#erudit/globalPaths';
@@ -13,12 +14,17 @@ import { DbHash } from './entities/Hash';
 import { DbTopic } from './entities/Topic';
 import { DbUnique } from './entities/Unique';
 import { DbFile } from './entities/File';
+import { logger } from '../logger';
 
 export async function setupDatabase() {
+    rmSync(PROJECT_DIR + '/.erudit/data.sqlite', { force: true });
+
     ERUDIT_SERVER.DB = new DataSource({
         type: 'sqlite',
+        enableWAL: true,
         database: PROJECT_DIR + '/.erudit/data.sqlite',
         synchronize: true,
+        dropSchema: true,
         entities: [
             DbBook,
             DbContent,
@@ -32,5 +38,12 @@ export async function setupDatabase() {
         ],
     });
 
-    await ERUDIT_SERVER.DB.initialize();
+    try {
+        // Wait before creating connection in case fast server restarts
+        // Otherwise, it may crash the whole Node process
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        await ERUDIT_SERVER.DB.initialize();
+    } catch (error) {
+        logger.error('Error creating database connection:', error);
+    }
 }

package/shared/bitran/stringContent.ts

@@ -1,6 +1,6 @@
-import type { PreRenderData } from '@bitran-js/transpiler';
+import type { RenderDataStorage } from '@bitran-js/core';
 
 export interface StringBitranContent {
     biCode: string;
-    preRenderData?: Record<string, PreRenderData>;
+    renderDataStorage: RenderDataStorage;
 }

package/utils/contentPath.ts

@@ -0,0 +1,67 @@
+import { readdirSync, statSync } from 'fs';
+
+// A directory is considered a "content directory" if it contains book, group, or topic with a file having a .js or .ts extension.
+// When a directory qualifies as a content directory, its name is simplified by removing any leading digits and a '+' or '-' (e.g., "29+foo" becomes "foo").
+
+const contentFileRegex = /^(book|group|topic)\.(js|ts)$/i;
+
+function normalizePath(path: string): string {
+    return path.replace(/\\/g, '/');
+}
+
+export function isContentDirectory(directory: string): boolean {
+    if (!statSync(directory).isDirectory()) {
+        return false;
+    }
+
+    return readdirSync(directory).some((file) => {
+        return contentFileRegex.test(file);
+    });
+}
+
+export function getContentPath(path: string, cwd?: string): string {
+    path = normalizePath(path);
+    cwd = cwd ? normalizePath(cwd) : undefined;
+
+    const unresolvedParts = path.split('/').filter(Boolean);
+    const resolvedParts: string[] = [];
+
+    let currentPath = cwd || '';
+    while (unresolvedParts.length) {
+        const currentPart = unresolvedParts.shift()!;
+        currentPath += '/' + currentPart;
+        if (isContentDirectory(currentPath)) {
+            resolvedParts.push(currentPart.replace(/^\d+(?:\+|-)/, ''));
+        } else {
+            resolvedParts.push(currentPart);
+        }
+    }
+
+    return resolvedParts.join('/');
+}
+
+export function scanContentPaths(directory: string): Record<string, string> {
+    directory = normalizePath(directory);
+
+    const map: Record<string, string> = {};
+
+    function traverse(currentPath: string) {
+        const files = readdirSync(currentPath);
+
+        for (const file of files) {
+            const fullPath = currentPath + '/' + file;
+            const relativePath = fullPath.slice(directory.length + 1);
+            const stat = statSync(fullPath);
+
+            if (stat.isDirectory()) {
+                traverse(fullPath);
+            } else {
+                map[getContentPath(relativePath, directory)] = relativePath;
+            }
+        }
+    }
+
+    traverse(directory);
+
+    return map;
+}

package/server/plugin/build/jobs/content/files.ts

@@ -1,79 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-interface FileMap {
-    [simplifiedPath: string]: string;
-}
-
-// Regex to check if a directory is a "content directory".
-const contentFileRegex = /^(book|group|topic)\.(js|ts)$/i;
-
-// Regex to simplify directory names (remove leading digits + '+' or '-').
-const simplifyDirRegex = /^\d+(?:\+|-)/;
-
-/**
- * Recursively scans files starting from `dirPath` and builds a mapping where:
- *  - The key is the "simplified" path using forward slashes.
- *  - The value is the relative filesystem path, also using forward slashes.
- *
- * A directory is considered a "content directory" if it contains any file that matches:
- * book, group, or topic with a .js or .ts extension.
- * When a directory qualifies as a content directory, its name is simplified
- * by removing any leading digits and a '+' or '-' (e.g., "29+foo" becomes "foo").
- *
- * @param dirPath The root directory to scan.
- * @returns An object mapping simplified file paths to relative file paths.
- */
-export function scanFiles(dirPath: string): FileMap {
-    const result: FileMap = {};
-    const absoluteRoot = path.resolve(dirPath); // Ensure absolute root path
-
-    function isContentDirectory(directory: string): boolean {
-        try {
-            return fs
-                .readdirSync(directory)
-                .some((entry) => contentFileRegex.test(entry));
-        } catch {
-            return false;
-        }
-    }
-
-    function traverse(currentPath: string, simplifiedParts: string[]) {
-        let currentSimplifiedParts = simplifiedParts;
-        if (currentPath !== absoluteRoot) {
-            let dirName = path.basename(currentPath);
-            if (isContentDirectory(currentPath)) {
-                dirName = dirName.replace(simplifyDirRegex, '');
-            }
-            currentSimplifiedParts = [...simplifiedParts, dirName];
-        }
-
-        for (const entry of fs.readdirSync(currentPath)) {
-            const fullPath = path.join(currentPath, entry);
-            const relativePath = path
-                .relative(absoluteRoot, fullPath)
-                .replace(/\\/g, '/'); // Always forward slashes
-            const stat = fs.statSync(fullPath);
-
-            if (stat.isDirectory()) {
-                traverse(fullPath, currentSimplifiedParts);
-            } else if (stat.isFile()) {
-                const simplifiedFilePath = path.posix.join(
-                    ...currentSimplifiedParts,
-                    entry,
-                );
-
-                // Remove first repeating part in the key
-                const keyParts = simplifiedFilePath.split('/');
-                if (keyParts.length > 1 && keyParts[0] === keyParts[1]) {
-                    keyParts.shift(); // Remove first repeating part
-                }
-
-                result[keyParts.join('/')] = relativePath;
-            }
-        }
-    }
-
-    traverse(absoluteRoot, []);
-    return result;
-}