erudit 4.1.1 → 4.2.0

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

@@ -1,12 +1,10 @@
-import { isDocument, type AnyDocument } from '@jsprose/core';
+import { isDocument, type Document } from 'tsprose';
 import { isContentItem } from '@erudit-js/core/content/item';
 import type { PageContentItem } from '@erudit-js/core/content/page';
-import { isIncludedRawElement } from '@erudit-js/prose';
 
 import type { ContentNavNode } from '../nav/types';
 import { logContentError } from './utils/contentError';
 import { insertContentItem } from './utils/insertContentItem';
-import { resolveEruditProse } from '../../prose/repository/resolve';
 import { insertContentResolved } from './utils/insertContentResolved';
 
 export async function resolvePage(pageNode: ContentNavNode) {
@@ -16,7 +14,7 @@ export async function resolvePage(pageNode: ContentNavNode) {
 
   try {
     const pageModule = await ERUDIT.import<{
-      content: AnyDocument;
+      content: Document;
       page: PageContentItem;
     }>(ERUDIT.paths.project(`content/${pageNode.contentRelPath}/page`));
 
@@ -30,49 +28,31 @@ export async function resolvePage(pageNode: ContentNavNode) {
 
     await insertContentItem(pageNode, pageModule.page);
 
-    const elementsCount: Record<string, number> = {};
-
     const proseDocument = pageModule.content;
-    const resolveResult = await resolveEruditProse(
-      proseDocument.content,
-      true,
-      async ({ rawElement }) => {
-        // Counting elements for statistics
-
-        if (isIncludedRawElement(rawElement)) {
-          return;
-        }
-
-        if (
-          ERUDIT.config.countElements.flat().includes(rawElement.schemaName)
-        ) {
-          elementsCount[rawElement.schemaName] =
-            (elementsCount[rawElement.schemaName] || 0) + 1;
-        }
-      },
-    );
+    const result = await ERUDIT.repository.prose.fromRaw({
+      rawProse: proseDocument.rawProse,
+      toc: { enabled: true },
+      snippets: { enabled: true },
+    });
 
-    if (resolveResult.tocItems?.length) {
+    if (result.toc?.length) {
       await ERUDIT.db.insert(ERUDIT.db.schema.contentToc).values({
         fullId: pageNode.fullId,
-        toc: resolveResult.tocItems,
+        toc: result.toc,
       });
     }
 
-    for (const [schemaName, count] of Object.entries(elementsCount)) {
-      await ERUDIT.repository.content.addElementCount(
-        pageNode.fullId,
-        schemaName,
-        count,
-      );
-    }
+    await ERUDIT.repository.content.updateSchemaCounts(
+      pageNode.fullId,
+      result.schemaCounts,
+    );
 
     await ERUDIT.db.insert(ERUDIT.db.schema.pages).values({
       fullId: pageNode.fullId,
-      prose: resolveResult.proseElement,
+      prose: result.prose,
     });
 
-    await insertContentResolved(pageNode.fullId, 'page', resolveResult);
+    await insertContentResolved(pageNode.fullId, 'page', result);
   } catch (error) {
     logContentError(pageNode);
     throw error;

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

@@ -1,29 +1,18 @@
 import { eq } from 'drizzle-orm';
-import {
-  isDocument,
-  isRawElement,
-  walkElements,
-  type AnyDocument,
-  type AnySchema,
-} from '@jsprose/core';
+import { existsSync } from 'node:fs';
+import { isDocument, type Document } from 'tsprose';
 import {
   topicParts,
   type TopicContentItem,
 } from '@erudit-js/core/content/topic';
 import { isContentItem } from '@erudit-js/core/content/item';
-import {
-  isIncludedRawElement,
-  type EruditRawElement,
-  type ResolvedTocItem,
-} from '@erudit-js/prose';
-import { problemSchema } from '@erudit-js/prose/elements/problem/problem';
-import { problemsSchema } from '@erudit-js/prose/elements/problem/problems';
 
 import type { ContentNavNode } from '../nav/types';
 import { logContentError } from './utils/contentError';
 import { insertContentItem } from './utils/insertContentItem';
-import { resolveEruditProse } from '../../prose/repository/resolve';
 import { insertContentResolved } from './utils/insertContentResolved';
+import { problemSchema } from '@erudit-js/prose/elements/problem/problem';
+import { problemsSchema } from '@erudit-js/prose/elements/problem/problems';
 
 export async function resolveTopic(topicNode: ContentNavNode) {
   ERUDIT.log.debug.start(
@@ -44,179 +33,59 @@ export async function resolveTopic(topicNode: ContentNavNode) {
       fullId: topicNode.fullId,
     });
 
-    const elementsCount: Record<string, number> = {};
-
     for (const topicPart of topicParts) {
-      const topicPartDocument = await ERUDIT.import<{
-        default: AnyDocument;
-      }>(
-        ERUDIT.paths.project(
-          `content/${topicNode.contentRelPath}/${topicPart}`,
-        ),
-        { try: true },
+      const topicPartPath = ERUDIT.paths.project(
+        `content/${topicNode.contentRelPath}/${topicPart}`,
       );
 
-      if (isDocument(topicPartDocument?.default)) {
-        const practiceProblemsTocItems: ResolvedTocItem[] = [];
-
-        const resolvedTopicPart = await resolveEruditProse(
-          topicPartDocument.default.content,
-          true,
-          async ({ rawElement, proseElement }) => {
-            //
-            // Auto-adding problems to TOC if in practice topic part
-            //
-
-            if (topicPart === 'practice') {
-              if (
-                (rawElement as EruditRawElement<AnySchema>).title &&
-                proseElement.id
-              ) {
-                if (
-                  isRawElement(rawElement, problemSchema) ||
-                  isRawElement(rawElement, problemsSchema)
-                ) {
-                  practiceProblemsTocItems.push({
-                    type: 'element',
-                    elementId: proseElement.id,
-                    schemaName: rawElement.schemaName,
-                    title: (rawElement as EruditRawElement<AnySchema>).title!,
-                  });
-                }
-              }
-            }
+      const topicPartExists = ['.js', '.jsx', '.ts', '.tsx'].some((ext) =>
+        existsSync(topicPartPath + ext),
+      );
 
-            //
-            // Counting elements for statistics
-            //
+      if (!topicPartExists) continue;
 
-            if (isIncludedRawElement(rawElement)) {
-              return;
-            }
+      const topicPartDocument = await ERUDIT.import<{
+        default: Document;
+      }>(topicPartPath, { try: true });
 
-            if (
-              ERUDIT.config.countElements.flat().includes(rawElement.schemaName)
-            ) {
-              elementsCount[rawElement.schemaName] =
-                (elementsCount[rawElement.schemaName] || 0) + 1;
-            }
+      if (isDocument(topicPartDocument?.default)) {
+        const result = await ERUDIT.repository.prose.fromRaw({
+          rawProse: topicPartDocument.default.rawProse,
+          toc: {
+            enabled: true,
+            addSchemas:
+              topicPart === 'practice'
+                ? [problemSchema, problemsSchema]
+                : undefined,
           },
-        );
+          snippets: { enabled: true },
+        });
 
-        let finalTocItems = resolvedTopicPart.tocItems;
-
-        if (topicPart === 'practice' && practiceProblemsTocItems.length) {
-          // Map elementId -> TocItem for both headings and problems
-          const itemMap = new Map<string, ResolvedTocItem>();
-
-          // Collect all existing TOC items (headings) recursively
-          const collectItems = (items: ResolvedTocItem[]) => {
-            for (const item of items) {
-              if (item.elementId) {
-                itemMap.set(item.elementId, item);
-              }
-              if (item.type === 'heading' && item.children?.length) {
-                collectItems(item.children);
-              }
-            }
-          };
-          collectItems(resolvedTopicPart.tocItems || []);
-
-          // Add practice problems to the map
-          practiceProblemsTocItems.forEach((p) => {
-            if (p.elementId) {
-              itemMap.set(p.elementId, p);
-            }
-          });
-
-          // Rebuild TOC in document order using walkElements
-          const result: ResolvedTocItem[] = [];
-          const stack: ResolvedTocItem[] = [];
-
-          await walkElements(resolvedTopicPart.proseElement, (element) => {
-            if (element.id && itemMap.has(element.id)) {
-              const item = itemMap.get(element.id)!;
-
-              if (item.type === 'heading') {
-                // Pop headings at same or deeper level
-                while (stack.length > 0) {
-                  const last = stack[stack.length - 1]!;
-                  if (last.type === 'heading' && last.level >= item.level) {
-                    stack.pop();
-                  } else {
-                    break;
-                  }
-                }
-
-                // Create new heading with empty children array
-                const newItem: ResolvedTocItem = {
-                  ...item,
-                  children: [],
-                };
-
-                // Add to parent heading or root
-                if (stack.length > 0) {
-                  const parent = stack[stack.length - 1]!;
-                  if (parent.type === 'heading') {
-                    parent.children.push(newItem);
-                  }
-                } else {
-                  result.push(newItem);
-                }
-
-                stack.push(newItem);
-              } else {
-                // Non-heading item (problems, etc.)
-                if (stack.length > 0) {
-                  const parent = stack[stack.length - 1]!;
-                  if (parent.type === 'heading') {
-                    parent.children.push(item);
-                  } else {
-                    result.push(item);
-                  }
-                } else {
-                  result.push(item);
-                }
-              }
-            }
-          });
-
-          finalTocItems = result;
-        }
-
-        if (finalTocItems?.length) {
+        if (result.toc?.length) {
           await ERUDIT.db.insert(ERUDIT.db.schema.contentToc).values({
             fullId: topicNode.fullId,
             topicPart,
-            toc: finalTocItems,
+            toc: result.toc,
           });
         }
 
+        await ERUDIT.repository.content.updateSchemaCounts(
+          topicNode.fullId,
+          result.schemaCounts,
+        );
+
         await ERUDIT.db
           .update(ERUDIT.db.schema.topics)
           .set({
-            [topicPart]: resolvedTopicPart.proseElement,
+            [topicPart]: result.prose,
           })
           .where(eq(ERUDIT.db.schema.topics.fullId, topicNode.fullId));
 
-        await insertContentResolved(
-          topicNode.fullId,
-          topicPart,
-          resolvedTopicPart,
-        );
+        await insertContentResolved(topicNode.fullId, topicPart, result);
       }
     }
-
-    for (const [schemaName, count] of Object.entries(elementsCount)) {
-      await ERUDIT.repository.content.addElementCount(
-        topicNode.fullId,
-        schemaName,
-        count,
-      );
-    }
   } catch (error) {
     logContentError(topicNode);
-    //console.log(error);
     throw error;
   }
 }

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

@@ -1,42 +1,47 @@
 import chalk from 'chalk';
 import { sql } from 'drizzle-orm';
-import { type ResolvedRawElement } from '@jsprose/core';
 import type { ContentProseType } from '@erudit-js/core/content/prose';
-import type { ResolvedEruditRawElement } from '@erudit-js/prose';
+import { builtValidPaths } from '../../global/build';
 import type {
   ContentLinks,
   ContentLinkUsage,
-} from '@erudit-js/prose/elements/link/step';
+} from '@erudit-js/prose/elements/link/hook';
+import {
+  toKeySnippet,
+  toSearchSnippet,
+  toSeoSnippet,
+  type EruditRawToProseResult,
+} from '@erudit-js/prose';
 
 export async function insertContentResolved(
   contentFullId: string,
   contentProseType: ContentProseType,
-  resolveResult: ResolvedRawElement & ResolvedEruditRawElement,
+  result: EruditRawToProseResult,
 ) {
-  for (const file of resolveResult.files) {
+  for (const file of result.files) {
     await ERUDIT.repository.db.pushFile(file, `content-item:${contentFullId}`);
   }
 
-  for (const [uniqueName, unique] of Object.entries(resolveResult.uniques)) {
+  for (const [uniqueName, unique] of Object.entries(result.uniques)) {
     await ERUDIT.db.insert(ERUDIT.db.schema.contentUniques).values({
       contentFullId,
       contentProseType,
       uniqueName,
-      title: resolveResult.uniqueTitles[uniqueName],
+      title: result.uniqueTitles[uniqueName],
       prose: unique,
     });
   }
 
-  for (const snippet of resolveResult.snippets) {
+  for (const snippet of result.snippets) {
     await ERUDIT.db.insert(ERUDIT.db.schema.contentSnippets).values({
       contentFullId,
       contentProseType,
       elementId: snippet.elementId,
       schemaName: snippet.schemaName,
-      snippetData: snippet.snippetData,
-      search: !!snippet.snippetData.search,
-      quick: !!snippet.snippetData.quick,
-      seo: !!snippet.snippetData.seo,
+      snippetData: snippet.snippet,
+      search: !!toSearchSnippet(snippet.snippet),
+      key: !!toKeySnippet(snippet.snippet),
+      seo: !!toSeoSnippet(snippet.snippet),
     });
   }
 
@@ -49,25 +54,26 @@ export async function insertContentResolved(
     await deduplicateTopicSnippetsSearch(contentFullId);
   }
 
-  for (const problemScript of resolveResult.problemScripts) {
+  for (const problemScript of result.problemScripts) {
     await ERUDIT.repository.db.pushProblemScript(problemScript, contentFullId);
   }
 
-  const targetFullIds = filterTargetFullIds(
-    contentFullId,
-    resolveResult.contentLinks,
-  );
+  const targetMap = filterTargetMap(contentFullId, result.contentLinks);
 
-  await insertContentDeps(contentFullId, Array.from(targetFullIds));
+  await insertContentDeps(contentFullId, targetMap);
 }
 
-async function insertContentDeps(fromFullId: string, toFullIds: string[]) {
-  const contentDeps = toFullIds
-    .filter((toFullId) => toFullId !== fromFullId)
-    .map((toFullId) => ({
+async function insertContentDeps(
+  fromFullId: string,
+  targetMap: Map<string, Set<string>>,
+) {
+  const contentDeps = Array.from(targetMap.entries())
+    .filter(([toFullId]) => toFullId !== fromFullId)
+    .map(([toFullId, uniqueSet]) => ({
       fromFullId,
       toFullId,
       hard: false,
+      uniqueNames: uniqueSet.size > 0 ? Array.from(uniqueSet).join(',') : null,
     }));
 
   if (contentDeps.length > 0) {
@@ -78,10 +84,12 @@ async function insertContentDeps(fromFullId: string, toFullIds: string[]) {
   }
 }
 
-function filterTargetFullIds(
+// Returns a map from resolved toFullId → set of unique names targeted in that
+// content item. An empty set means the dep targets the whole page (no unique).
+function filterTargetMap(
   contentFullId: string,
   contentLinks: ContentLinks,
-) {
+): Map<string, Set<string>> {
   const brokenLinkMessage = (message: string, metas: ContentLinkUsage[]) => {
     let output = `${message} in ${ERUDIT.log.stress(contentFullId)}:\n`;
     for (const { type, label } of metas) {
@@ -90,7 +98,7 @@ function filterTargetFullIds(
     return output;
   };
 
-  const targetFullIds = new Set<string>();
+  const targetMap = new Map<string, Set<string>>();
 
   for (const [storageKey, metas] of contentLinks) {
     if (storageKey.startsWith('<link:unknown>/')) {
@@ -103,6 +111,14 @@ function filterTargetFullIds(
     } else if (storageKey.startsWith('<link:global>')) {
       try {
         const globalContentId = storageKey.replace('<link:global>/', '');
+
+        // Extract unique name before stripping it for nav resolution
+        const parts = globalContentId.split('/');
+        const lastPart = parts.at(-1);
+        const uniqueName = lastPart?.startsWith('$')
+          ? lastPart.slice(1)
+          : undefined;
+
         const targetFullId = globalContentToNavNode(globalContentId).fullId;
 
         if (
@@ -110,7 +126,12 @@ function filterTargetFullIds(
             (meta) => meta.type === 'Dep' || meta.type === 'Dependency',
           )
         ) {
-          targetFullIds.add(targetFullId);
+          if (!targetMap.has(targetFullId)) {
+            targetMap.set(targetFullId, new Set());
+          }
+          if (uniqueName) {
+            targetMap.get(targetFullId)!.add(uniqueName);
+          }
         }
       } catch {
         ERUDIT.log.warn(
@@ -123,21 +144,28 @@ function filterTargetFullIds(
     }
   }
 
-  return targetFullIds;
+  return targetMap;
 }
 
 function globalContentToNavNode(globalContentPath: string) {
+  // Validate the full path (including any $unique suffix) against the complete
+  // set of known valid paths built from source files. This catches broken
+  // unique names and content paths before we ever touch the nav tree.
+  if (builtValidPaths && !builtValidPaths.has(globalContentPath)) {
+    throw new Error(`Path not found in \$CONTENT: ${globalContentPath}`);
+  }
+
   const parts = globalContentPath.split('/');
 
   if (parts.at(-1)?.startsWith('$')) {
     parts.pop();
   }
 
-  const navNode =
+  // If the exact node isn't found the last segment is a topic part — fall back to parent.
+  return (
     ERUDIT.contentNav.getNode(parts.join('/')) ??
-    ERUDIT.contentNav.getNodeOrThrow(parts.slice(0, -1).join('/'));
-
-  return navNode;
+    ERUDIT.contentNav.getNodeOrThrow(parts.slice(0, -1).join('/'))
+  );
 }
 
 async function deduplicateTopicSnippetsSearch(contentFullId: string) {

package/server/erudit/content/search.ts

@@ -2,6 +2,7 @@ import { eq } from 'drizzle-orm';
 import { contentTypes } from '@erudit-js/core/content/type';
 import { headingSchema } from '@erudit-js/prose/elements/heading/core';
 import type { TopicPart } from '@erudit-js/core/content/topic';
+import { toSearchSnippet } from '@erudit-js/prose';
 
 export async function searchIndexContentTypes(): Promise<SearchEntriesList[]> {
   const entryLists: SearchEntriesList[] = [];
@@ -119,33 +120,15 @@ export async function searchIndexSnippets(): Promise<SearchEntriesList[]> {
         });
     }
 
-    const snippetSearch = dbSnippet.snippetData.search;
-    let searchTitle = dbSnippet.snippetData.title!;
-    let searchDescription = dbSnippet.snippetData.description;
-    let searchSynonyms: string[] | undefined = undefined;
-    if (snippetSearch) {
-      if (typeof snippetSearch === 'boolean') {
-      } else if (typeof snippetSearch === 'string') {
-        snippetSearch.trim() && (searchTitle = snippetSearch.trim());
-      } else if (Array.isArray(snippetSearch)) {
-        searchSynonyms = snippetSearch.length > 0 ? snippetSearch : undefined;
-      } else {
-        searchTitle = snippetSearch.title || searchTitle;
-        searchDescription = snippetSearch.description || searchDescription;
-        searchSynonyms =
-          snippetSearch.synonyms && snippetSearch.synonyms.length > 0
-            ? snippetSearch.synonyms
-            : undefined;
-      }
-    }
+    const searchSnippet = toSearchSnippet(dbSnippet.snippetData)!;
 
     entryLists.get(dbSnippet.schemaName)!.entries.push({
       category: 'element:' + dbSnippet.schemaName,
-      title: searchTitle,
-      description: searchDescription,
+      title: searchSnippet.title,
+      description: searchSnippet.description,
       link,
       location: locationTitle,
-      synonyms: searchSynonyms,
+      synonyms: searchSnippet.synonyms,
     });
   }
 

package/server/erudit/contributors/build.ts

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync, writeFileSync } from 'node:fs';
 import { eq, like } from 'drizzle-orm';
 import { globSync } from 'glob';
-import { isRawElement, type AnySchema, type ProseElement } from '@jsprose/core';
+import { isRawElement, type ProseElement } from 'tsprose';
 import {
   contributorIdToPropertyName,
   globalContributorsObject,
@@ -131,19 +131,18 @@ async function buildContributor(contributorId: string) {
     }
   }
 
-  let description: ProseElement<AnySchema> | undefined;
+  let description: ProseElement | undefined;
 
   if (isRawElement(def?.description)) {
-    const resolved = await ERUDIT.repository.prose.resolve(
-      def.description,
-      false,
-    );
+    const result = await ERUDIT.repository.prose.fromRaw({
+      rawProse: def.description,
+    });
 
-    for (const file of resolved.files) {
+    for (const file of result.files) {
       await ERUDIT.repository.db.pushFile(file, `contributor:${contributorId}`);
     }
 
-    description = resolved.proseElement;
+    description = result.prose;
   }
 
   await ERUDIT.db.insert(ERUDIT.db.schema.contributors).values({

package/server/erudit/db/repository/pushFile.ts

@@ -3,16 +3,23 @@ import { sn } from 'unslash';
 export async function pushFile(filepath: string, role: string): Promise<void> {
   filepath = sn(filepath);
 
-  if (!filepath.startsWith(ERUDIT.paths.project())) {
+  let relativePath: string;
+
+  if (filepath.startsWith(ERUDIT.paths.project() + '/')) {
+    // Absolute path inside the project – convert to relative
+    relativePath = filepath.slice(ERUDIT.paths.project().length + 1);
+  } else if (/^([A-Za-z]:\/|\/)/.test(filepath)) {
+    // Absolute path outside the project – reject
     throw createError({
       statusCode: 400,
       statusMessage: 'File is outside of project directory!',
       message: `Can not add ${filepath} as it is outside of the project directory!`,
     });
+  } else {
+    // Already a project-relative path
+    relativePath = filepath;
   }
 
-  const relativePath = filepath.replace(ERUDIT.paths.project() + '/', '');
-
   await ERUDIT.db
     .insert(ERUDIT.db.schema.files)
     .values({

package/server/erudit/db/repository/pushProblemScript.ts

@@ -1,19 +1,30 @@
+import { sn } from 'unslash';
+
 export async function pushProblemScript(
   problemScriptSrc: string,
   contentFullId: string,
 ): Promise<void> {
-  const parsedId = problemScriptSrc;
+  problemScriptSrc = sn(problemScriptSrc);
+
+  let relativePath: string;
 
-  if (!problemScriptSrc.startsWith(ERUDIT.paths.project())) {
+  if (problemScriptSrc.startsWith(ERUDIT.paths.project() + '/')) {
+    // Absolute path inside the project – convert to relative
+    relativePath = problemScriptSrc.slice(ERUDIT.paths.project().length + 1);
+  } else if (/^([A-Za-z]:\/|\/)/.test(problemScriptSrc)) {
+    // Absolute path outside the project – reject
     throw createError({
       statusCode: 400,
       statusMessage: 'Problem script is outside of project directory!',
       message: `Can not add problem script from ${problemScriptSrc} as it is outside of the project directory!`,
     });
+  } else {
+    // Already a project-relative path
+    relativePath = problemScriptSrc;
   }
 
   await ERUDIT.db.insert(ERUDIT.db.schema.problemScripts).values({
-    problemScriptSrc,
+    problemScriptSrc: relativePath,
     contentFullId,
   });
 }

package/server/erudit/db/schema/contentDeps.ts

@@ -12,6 +12,9 @@ export const contentDeps = sqliteTable(
     toFullId: text().notNull(),
     hard: integer({ mode: 'boolean' }).notNull(),
     reason: text(),
+    // Comma-separated unique names that were specifically targeted via <Dep>.
+    // Only set for auto deps; null means the dep targets the whole page.
+    uniqueNames: text(),
   },
   (table) => [
     primaryKey({