@plebeiantech/lat.md 0.12.3-fork.13 → 0.12.3-fork.14

package/dist/src/view/references.js

@@ -1,112 +1,21 @@
 import { relative, resolve } from 'node:path';
-import { visit } from 'unist-util-visit';
-import { buildFileIndex, buildSectionSlugIndex, extractRefs, extractLinks, flattenSections, parseSections, resolveRef, } from '../lattice.js';
-import { parse } from '../parser.js';
-import { toPosix } from '../walk.js';
+import { buildFileIndex, buildSectionSlugIndex, flattenSections, resolveRef, } from '../lattice-model.js';
+import { analyzeMarkdownFile, } from '../markdown-analysis.js';
+import { toPosix } from '../path.js';
 import { renderMarkdown } from './markdown.js';
 import { viewSourceTarget } from './source-target.js';
-function inlineText(node) {
-    if (node.type === 'wikiLink')
-        return node.data.alias ?? node.value;
-    if ('value' in node && typeof node.value === 'string')
-        return node.value;
-    if (node.type === 'image')
-        return node.alt ?? '';
-    if (!('children' in node) || !Array.isArray(node.children))
-        return '';
-    return node.children
-        .map((child) => inlineText(child))
-        .join('');
-}
-function paragraphs(content, tree) {
-    const byLine = new Map();
-    visit(tree, 'paragraph', (node) => {
-        const start = node.position?.start.line;
-        const end = node.position?.end.line;
-        if (!start || !end)
-            return;
-        const text = inlineText(node).replace(/\s+/g, ' ').trim();
-        const startOffset = node.position?.start.offset;
-        const endOffset = node.position?.end.offset;
-        const paragraph = {
-            markdown: startOffset === undefined || endOffset === undefined
-                ? text
-                : content.slice(startOffset, endOffset),
-            startLine: start,
-            text,
-        };
-        for (let line = start; line <= end; line++)
-            byLine.set(line, paragraph);
-    });
-    return byLine;
-}
-function markdownLinks(tree) {
-    const definitions = new Map();
-    visit(tree, 'definition', (node) => {
-        definitions.set(node.identifier.toLowerCase(), node.url);
-    });
-    const links = [];
-    visit(tree, (node) => {
-        if (node.type !== 'link' &&
-            node.type !== 'image' &&
-            node.type !== 'linkReference' &&
-            node.type !== 'imageReference') {
-            return;
-        }
-        const line = node.position?.start.line;
-        if (!line)
-            return;
-        const url = node.type === 'link' || node.type === 'image'
-            ? node.url
-            : definitions.get(node.identifier.toLowerCase());
-        if (url) {
-            links.push({
-                kind: node.type === 'image' || node.type === 'imageReference'
-                    ? 'image'
-                    : 'link',
-                line,
-                url,
-            });
-        }
-    });
-    return links;
-}
+import { documentUrl as routeDocumentUrl, rewriteDocumentLink, } from './document-route.js';
 /** Parse one Markdown file once into every structure needed by the view store. */
 export function parseViewMarkdownFile(absolutePath, content, latDir, projectRoot) {
-    const tree = parse(content);
-    return {
-        absolutePath,
-        content,
-        path: toPosix(relative(latDir, absolutePath)),
-        projectPath: toPosix(relative(projectRoot, absolutePath)),
-        tree,
-        sections: parseSections(absolutePath, content, projectRoot, tree),
-        wikiRefs: extractRefs(absolutePath, content, projectRoot, tree),
-        paragraphs: paragraphs(content, tree),
-        markdownLinks: markdownLinks(tree),
-        validationLinks: extractLinks(content, tree),
-    };
+    return analyzeMarkdownFile(absolutePath, content, latDir, projectRoot);
 }
 function contextMarkdownLink(requestedPath, url) {
-    if (url.startsWith('/') ||
-        url.startsWith('//') ||
-        /^[a-z][a-z\d+.-]*:/i.test(url)) {
-        return url;
-    }
-    const encodedPath = requestedPath
-        .split('/')
-        .map(encodeURIComponent)
-        .join('/');
-    const resolved = new URL(url, `http://lat.local/docs/${encodedPath}`);
-    return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+    return rewriteDocumentLink(url, requestedPath);
 }
 function documentUrl(latDir, projectRoot, section) {
     const path = toPosix(relative(latDir, resolve(projectRoot, section.filePath)));
-    const encoded = path.split('/').map(encodeURIComponent).join('/');
-    const fragment = section.githubSlug
-        ? `#${encodeURIComponent(section.githubSlug)}`
-        : '';
-    return `/docs/${encoded}${fragment}`;
+    const fragment = section.githubSlug ? section.githubSlug : '';
+    return routeDocumentUrl(path, fragment);
 }
 function breadcrumbs(latDir, projectRoot, section) {
     const path = toPosix(relative(latDir, resolve(projectRoot, section.filePath))).replace(/\.md$/i, '');
@@ -155,14 +64,15 @@ export function linkedSection(url, sourcePath, sectionsByPath) {
     return (sections.find((section) => section.githubSlug?.toLowerCase() === fragment.toLowerCase()) ?? null);
 }
 function paragraphFor(file, section, line) {
-    return (file.paragraphs.get(line) ?? {
+    return (file.paragraphs.find((paragraph) => line >= paragraph.startLine && line <= paragraph.endLine) ?? {
         markdown: section.firstParagraph,
         startLine: line,
+        endLine: line,
         text: section.firstParagraph,
     });
 }
 /** Resolve cached outgoing occurrences into direct section and source indexes. */
-export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
+export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections, resolveExternalTarget) {
     const files = [...markdownFiles].sort((a, b) => a.path.localeCompare(b.path));
     const sections = flattenSections(allSections);
     const sectionIds = new Set(sections.map((section) => section.id.toLowerCase()));
@@ -175,6 +85,7 @@ export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
     }
     const incoming = new Map();
     const sourceByTarget = new Map();
+    const externalByTarget = new Map();
     const addIncoming = (targetId, key, reference) => {
         const target = targetId.toLowerCase();
         let references = incoming.get(target);
@@ -194,6 +105,15 @@ export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
         if (!references.has(key))
             references.set(key, reference);
     };
+    const addExternalReference = (target, key, reference) => {
+        let references = externalByTarget.get(target);
+        if (!references) {
+            references = new Map();
+            externalByTarget.set(target, references);
+        }
+        if (!references.has(key))
+            references.set(key, reference);
+    };
     for (const file of files) {
         const fileSections = flattenSections(file.sections).sort((a, b) => a.startLine - b.startLine);
         for (const ref of file.wikiRefs) {
@@ -209,6 +129,10 @@ export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
                 activeWikiLink: ref.target,
             };
             const locationKey = `markdown:${section.filePath}:${reference.paragraph.startLine}`;
+            const externalTarget = resolveExternalTarget?.(ref.target);
+            if (externalTarget) {
+                addExternalReference(externalTarget, locationKey, reference);
+            }
             const source = viewSourceTarget(ref.target);
             if (source) {
                 addSourceReference(source.key, locationKey, reference);
@@ -247,6 +171,16 @@ export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
     }
     for (const file of [...codeFiles].sort((a, b) => a.path.localeCompare(b.path))) {
         for (const ref of [...file.refs].sort((a, b) => a.line - b.line)) {
+            const externalTarget = resolveExternalTarget?.(ref.target);
+            if (externalTarget) {
+                addExternalReference(externalTarget, `code:${ref.file}:${ref.line}`, {
+                    kind: 'code',
+                    path: ref.file,
+                    line: ref.line,
+                    snippet: file.lines[ref.line - 1]?.trim() ?? '',
+                    url: sourceLineUrl(ref.file, ref.line),
+                });
+            }
             const resolved = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
             if (resolved.ambiguous ||
                 !sectionById.has(resolved.resolved.toLowerCase())) {
@@ -274,21 +208,99 @@ export function buildViewReferenceIndex(markdownFiles, codeFiles, allSections) {
             target,
             references.size,
         ])),
+        externalByTarget: new Map([...externalByTarget].map(([target, references]) => [
+            target,
+            [...references.values()],
+        ])),
     };
 }
+async function renderExternalReference(reference, latDir, projectRoot, createWikiLinkResolver) {
+    if (reference.kind === 'code')
+        return reference;
+    const resolver = createWikiLinkResolver
+        ? await createWikiLinkResolver(reference.sourcePath)
+        : undefined;
+    return renderIndexedMarkdownReference(reference, latDir, projectRoot, resolver);
+}
+/** Render exact local Markdown and code backlinks for external targets. */
+export async function renderExternalSectionBackReferences(index, targets, latDir, projectRoot, createWikiLinkResolver) {
+    const sections = new Map();
+    for (const [target, headingId] of targets) {
+        let section = sections.get(headingId);
+        if (!section) {
+            section = { sectionId: target, references: new Map() };
+            sections.set(headingId, section);
+        }
+        const lowerTarget = target.toLowerCase();
+        const indexed = [...index.externalByTarget]
+            .filter(([candidate]) => candidate.toLowerCase() === lowerTarget)
+            .flatMap(([, references]) => references);
+        for (const reference of indexed) {
+            const key = reference.kind === 'markdown'
+                ? `markdown:${reference.sourcePath}:${reference.paragraph.startLine}`
+                : `code:${reference.path}:${reference.line}`;
+            if (!section.references.has(key))
+                section.references.set(key, reference);
+        }
+    }
+    const result = [];
+    for (const [headingId, section] of sections) {
+        const references = await Promise.all([...section.references.values()].map((reference) => renderExternalReference(reference, latDir, projectRoot, createWikiLinkResolver)));
+        result.push({ sectionId: section.sectionId, headingId, references });
+    }
+    return result;
+}
+/** Adapt exact external backlinks to the source context presentation. */
+export async function renderExternalSourceReferences(index, target, latDir, projectRoot, createWikiLinkResolver) {
+    const indexed = index.externalByTarget.get(target) ?? [];
+    const result = [];
+    for (const reference of indexed) {
+        const rendered = await renderExternalReference(reference, latDir, projectRoot, createWikiLinkResolver);
+        if (rendered.kind === 'markdown') {
+            result.push({
+                sectionId: rendered.sectionId,
+                breadcrumbs: rendered.breadcrumbs,
+                paragraph: rendered.paragraph,
+                paragraphTree: rendered.paragraphTree,
+                url: rendered.url,
+            });
+        }
+        else {
+            result.push({
+                sectionId: `code:${rendered.path}:${rendered.line}`,
+                breadcrumbs: [...rendered.path.split('/'), `line ${rendered.line}`],
+                paragraph: rendered.snippet,
+                paragraphTree: {
+                    version: 1,
+                    type: 'root',
+                    children: [
+                        {
+                            type: 'element',
+                            tagName: 'code',
+                            properties: {},
+                            children: [{ type: 'text', value: rendered.snippet }],
+                        },
+                    ],
+                },
+                url: rendered.url,
+            });
+        }
+    }
+    return result;
+}
 async function renderIndexedMarkdownReference(reference, latDir, projectRoot, resolveWikiLink) {
-    const paragraphHtml = (await renderMarkdown(reference.paragraph.markdown, reference.sourcePath, resolveWikiLink, {
+    const paragraphTree = (await renderMarkdown(reference.paragraph.markdown, reference.sourcePath, resolveWikiLink, {
         activeWikiLink: reference.activeWikiLink,
         activeMarkdownLink: reference.activeMarkdownLink,
         lineOffset: reference.paragraph.startLine - 1,
         rewriteMarkdownLink: (url) => contextMarkdownLink(reference.sourcePath, url),
-    })).html;
+    })).tree;
     return {
         kind: 'markdown',
         sectionId: reference.section.id,
         breadcrumbs: breadcrumbs(latDir, projectRoot, reference.section),
         paragraph: reference.paragraph.text,
-        paragraphHtml,
+        paragraphTree,
         url: documentUrl(latDir, projectRoot, reference.section),
     };
 }
@@ -308,8 +320,6 @@ export async function renderSectionBackReferences(index, visibleSections, latDir
     const result = [];
     for (const section of flattenSections(visibleSections)) {
         const indexed = index.incomingBySection.get(section.id.toLowerCase()) ?? [];
-        if (indexed.length === 0)
-            continue;
         const references = [];
         for (const reference of indexed) {
             references.push(reference.kind === 'code'
@@ -345,7 +355,7 @@ export async function renderSourceReferenceContext(index, target, origin, latDir
                 sectionId: rendered.sectionId,
                 breadcrumbs: rendered.breadcrumbs,
                 paragraph: rendered.paragraph,
-                paragraphHtml: rendered.paragraphHtml,
+                paragraphTree: rendered.paragraphTree,
                 url: rendered.url,
             },
         });

package/dist/src/view/repository.d.ts

@@ -1,15 +1,25 @@
-import { type Section } from '../lattice.js';
-import type { ViewSourceDocument } from './protocol.js';
+import { type Section } from '../lattice-model.js';
+import { type ExternalResolver } from '../external-sources.js';
+import type { ExternalTarget } from '../external-sources.js';
+import { renderExternalDocumentTree } from './external-document-tree.js';
+import type { ViewExternalDocument, ViewSourceDocument } from './protocol.js';
 import { type SourceReferenceOrigin, type ViewReferenceIndex } from './references.js';
 export declare class ViewDocumentNotFoundError extends Error {
 }
 export declare class ViewSourceNotFoundError extends Error {
 }
-export declare function createMarkdownWikiLinkResolver(latDir: string, requestedPath: string, loadedSections: Section[], referenceIndex?: ViewReferenceIndex): Promise<(target: string, context: {
+export declare class ViewExternalNotFoundError extends Error {
+}
+export declare function externalUrl(target: string): string;
+/** Make repository-relative external-document links reflect pulled files. */
+export declare function resolveExternalDocumentLinks(tree: Awaited<ReturnType<typeof renderExternalDocumentTree>>, current: ExternalTarget, external: ExternalResolver, referenceIndex: ViewReferenceIndex): typeof tree;
+export declare function createMarkdownWikiLinkResolver(latDir: string, requestedPath: string, loadedSections: Section[], referenceIndex?: ViewReferenceIndex, externalResolver?: ExternalResolver): Promise<(target: string, context: {
     line: number;
 }) => Promise<{
     href: string;
     referenceCount: number;
 } | null>>;
+/** Resolve and render one configured external file through the normal view models. */
+export declare function getViewExternal(latDir: string, projectRoot: string, targetValue: string, external: ExternalResolver, allSections: Section[], referenceIndex: ViewReferenceIndex): Promise<ViewExternalDocument>;
 /** Read and highlight a source file after constraining it to the project root. */
 export declare function getViewSource(latDir: string, projectRoot: string, requestedPath: string, requestedSymbol?: string, origin?: SourceReferenceOrigin, requestedLine?: number, allSections?: Section[], referenceIndex?: ViewReferenceIndex): Promise<ViewSourceDocument>;

package/dist/src/view/repository.js

@@ -1,23 +1,30 @@
 import { readFile, realpath } from 'node:fs/promises';
-import { dirname, extname, isAbsolute, relative, resolve, sep, } from 'node:path';
-import { buildFileIndex, buildSectionSlugIndex, flattenSections, resolveRef, } from '../lattice.js';
-import { resolveSourceSymbol, SOURCE_EXTENSIONS, } from '../source-parser.js';
-import { toPosix } from '../walk.js';
+import { dirname, extname, isAbsolute, join, posix, relative, resolve, sep, } from 'node:path';
+import { buildFileIndex, buildSectionSlugIndex, flattenSections, resolveRef, } from '../lattice-model.js';
+import { createExternalResolver, } from '../external-sources.js';
+import { addExternalDocumentAliasAnchors, externalDocumentSections, } from '../external-documents.js';
+import { resolveSourceSymbol, SourceParserRuntime, } from '../source-parser.js';
+import { isSourceFileExtension } from '../source-formats.js';
+import { toPosix } from '../path.js';
+import { renderExternalDocumentTree } from './external-document-tree.js';
+import { visitDocumentElements } from './document-tree.js';
 import { highlightSource } from './highlight.js';
-import { renderSourceReferenceContext, } from './references.js';
+import { renderMarkdown } from './markdown.js';
+import { renderExternalSectionBackReferences, renderExternalSourceReferences, renderSourceReferenceContext, } from './references.js';
+import { buildViewTableOfContents } from './table-of-contents.js';
 import { viewSourceTarget } from './source-target.js';
+import { documentUrl } from './document-route.js';
 export class ViewDocumentNotFoundError extends Error {
 }
 export class ViewSourceNotFoundError extends Error {
 }
+export class ViewExternalNotFoundError extends Error {
+}
 function isInside(root, candidate) {
     const rel = relative(root, candidate);
     return (rel === '' ||
         (!isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${sep}`)));
 }
-function documentUrl(path) {
-    return `/docs/${path.split('/').map(encodeURIComponent).join('/')}`;
-}
 function sourceUrl(path, symbol, origin) {
     const encodedPath = path.split('/').map(encodeURIComponent).join('/');
     const query = new URLSearchParams();
@@ -29,6 +36,128 @@ function sourceUrl(path, symbol, origin) {
     const fragment = symbol ? `#${encodeURIComponent(symbol)}` : '';
     return `/code/${encodedPath}${search}${fragment}`;
 }
+export function externalUrl(target) {
+    const colon = target.indexOf(':');
+    const hash = target.indexOf('#', colon + 1);
+    const handle = target.slice(0, colon);
+    const path = hash === -1 ? target.slice(colon + 1) : target.slice(colon + 1, hash);
+    const fragment = hash === -1 ? '' : target.slice(hash + 1);
+    const encodedPath = path.split('/').map(encodeURIComponent).join('/');
+    return `/external/${encodeURIComponent(handle)}/${encodedPath}${fragment ? `#${encodeURIComponent(fragment)}` : ''}`;
+}
+function baseExternalTarget(identity) {
+    const hash = identity.indexOf('#');
+    return hash === -1 ? identity : identity.slice(0, hash);
+}
+function externalFileKey(handle, path) {
+    return `${handle}\0${path}`;
+}
+function availableExternalFiles(external, referenceIndex, current) {
+    const files = new Map();
+    for (const target of referenceIndex.externalByTarget.keys()) {
+        try {
+            const parsed = external.parse(target);
+            if (!parsed)
+                continue;
+            files.set(externalFileKey(parsed.handle, parsed.resolvedPath), baseExternalTarget(parsed.identity));
+        }
+        catch {
+            // Invalid external references remain diagnostics and are not navigable.
+        }
+    }
+    files.set(externalFileKey(current.handle, current.resolvedPath), baseExternalTarget(current.identity));
+    return files;
+}
+function externalDocumentLink(href, current, external, available) {
+    if (href.startsWith('#') ||
+        href.startsWith('?') ||
+        href.startsWith('//') ||
+        /^[a-z][a-z\d+.-]*:/i.test(href) ||
+        /^\/(?:code|docs|external)(?:\/|$)/.test(href)) {
+        return undefined;
+    }
+    let destination;
+    try {
+        const encodedPath = current.resolvedPath
+            .split('/')
+            .map(encodeURIComponent)
+            .join('/');
+        destination = new URL(href, `http://lat.external/${encodedPath}`);
+    }
+    catch {
+        return null;
+    }
+    if (destination.origin !== 'http://lat.external')
+        return undefined;
+    let path;
+    let fragment;
+    try {
+        path = destination.pathname
+            .slice(1)
+            .split('/')
+            .map(decodeURIComponent)
+            .join('/');
+        fragment = decodeURIComponent(destination.hash.slice(1));
+    }
+    catch {
+        return null;
+    }
+    path = posix.normalize(path);
+    if (!path || path === '.' || path === '..' || path.startsWith('../')) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = external.parse(`${current.handle}:${path}${fragment ? `#${fragment}` : ''}`);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed)
+        return null;
+    const availableTarget = available.get(externalFileKey(parsed.handle, parsed.resolvedPath));
+    if (!availableTarget)
+        return null;
+    const route = externalUrl(`${availableTarget}${fragment ? `#${fragment}` : ''}`);
+    if (!destination.search)
+        return route;
+    const hash = route.indexOf('#');
+    return hash === -1
+        ? `${route}${destination.search}`
+        : `${route.slice(0, hash)}${destination.search}${route.slice(hash)}`;
+}
+/** Make repository-relative external-document links reflect pulled files. */
+export function resolveExternalDocumentLinks(tree, current, external, referenceIndex) {
+    const available = availableExternalFiles(external, referenceIndex, current);
+    visitDocumentElements(tree, (element) => {
+        if (element.tagName !== 'a')
+            return;
+        const href = element.properties.href;
+        if (typeof href !== 'string')
+            return;
+        const resolved = externalDocumentLink(href, current, external, available);
+        if (resolved === undefined)
+            return;
+        if (resolved !== null) {
+            element.properties.href = resolved;
+            return;
+        }
+        const currentClasses = element.properties.className;
+        const classes = Array.isArray(currentClasses)
+            ? currentClasses.map(String)
+            : typeof currentClasses === 'string'
+                ? currentClasses.split(/\s+/).filter(Boolean)
+                : [];
+        element.tagName = 'span';
+        element.properties = {
+            ...element.properties,
+            className: [...classes, 'external-source-link-unavailable'],
+            title: 'Linked file is not included in this Lat project',
+        };
+        delete element.properties.href;
+    });
+    return tree;
+}
 function matchingSymbol(symbols, symbolPath) {
     const parts = symbolPath.split('#');
     if (parts.length === 1) {
@@ -39,7 +168,8 @@ function matchingSymbol(symbols, symbolPath) {
     }
     return undefined;
 }
-export async function createMarkdownWikiLinkResolver(latDir, requestedPath, loadedSections, referenceIndex) {
+export async function createMarkdownWikiLinkResolver(latDir, requestedPath, loadedSections, referenceIndex, externalResolver) {
+    const external = externalResolver ?? (await createExternalResolver(latDir, dirname(latDir)));
     const projectRoot = dirname(latDir);
     const flat = flattenSections(loadedSections);
     const sectionIds = new Set(flat.map((section) => section.id.toLowerCase()));
@@ -51,6 +181,18 @@ export async function createMarkdownWikiLinkResolver(latDir, requestedPath, load
         .filter((section) => section.filePath === currentFile)
         .sort((a, b) => a.startLine - b.startLine);
     return async (target, context) => {
+        try {
+            const parsed = external.parse(target);
+            if (parsed) {
+                return {
+                    href: externalUrl(parsed.identity),
+                    referenceCount: referenceIndex?.externalByTarget.get(parsed.identity)?.length ?? 0,
+                };
+            }
+        }
+        catch {
+            return null;
+        }
         const result = resolveRef(target, sectionIds, fileIndex, slugIndex);
         if (result.ambiguous)
             return null;
@@ -71,7 +213,7 @@ export async function createMarkdownWikiLinkResolver(latDir, requestedPath, load
         if (!source)
             return null;
         try {
-            await readViewSource(projectRoot, source.path, source.symbol);
+            await readViewSource(latDir, projectRoot, source.path, source.symbol);
             let section;
             for (const candidate of currentSections) {
                 if (candidate.startLine > context.line)
@@ -93,11 +235,88 @@ export async function createMarkdownWikiLinkResolver(latDir, requestedPath, load
         }
     };
 }
-async function readViewSource(projectRoot, requestedPath, requestedSymbol = '', requestedLine = 0) {
+/** Resolve and render one configured external file through the normal view models. */
+export async function getViewExternal(latDir, projectRoot, targetValue, external, allSections, referenceIndex) {
+    let resolved;
+    try {
+        resolved = await external.resolve(targetValue);
+    }
+    catch (error) {
+        throw new ViewExternalNotFoundError(error.message);
+    }
+    const createResolver = (path) => createMarkdownWikiLinkResolver(latDir, path, allSections, referenceIndex, external);
+    if (resolved.kind === 'document') {
+        const virtualPath = join(projectRoot, 'lat.md', '.external', resolved.target.handle, resolved.target.resolvedPath);
+        const analysis = resolved.document;
+        const sections = externalDocumentSections(virtualPath, analysis);
+        const resolver = await createResolver(resolved.target.resolvedPath);
+        const rendered = analysis.format === 'markdown'
+            ? await renderMarkdown(resolved.fullContent, resolved.target.resolvedPath, resolver, {})
+            : {
+                title: analysis.title,
+                tree: await renderExternalDocumentTree(analysis.format, resolved.fullContent),
+            };
+        resolveExternalDocumentLinks(rendered.tree, resolved.target, external, referenceIndex);
+        const fragmentIndex = resolved.target.identity.indexOf('#');
+        const baseTarget = fragmentIndex === -1
+            ? resolved.target.identity
+            : resolved.target.identity.slice(0, fragmentIndex);
+        const targetHeadings = new Map();
+        targetHeadings.set(baseTarget, analysis.sections[0]?.anchor ?? '');
+        for (const section of analysis.sections) {
+            for (const alias of section.aliases) {
+                const target = `${baseTarget}#${alias}`;
+                if (!targetHeadings.has(target)) {
+                    targetHeadings.set(target, section.anchor);
+                }
+            }
+        }
+        return {
+            kind: 'markdown',
+            target: resolved.target.identity,
+            document: {
+                path: baseTarget,
+                ...rendered,
+                tree: addExternalDocumentAliasAnchors(rendered.tree, analysis),
+                gitTree: null,
+                graphNodeIds: {},
+                tableOfContents: buildViewTableOfContents(sections, analysis.sections.map((section) => section.title), {
+                    errors: [],
+                    gitTree: null,
+                }),
+                errors: [],
+                backReferences: await renderExternalSectionBackReferences(referenceIndex, targetHeadings, latDir, projectRoot, createResolver),
+                frontmatter: { requireCodeMention: false },
+            },
+        };
+    }
+    const references = await renderExternalSourceReferences(referenceIndex, resolved.target.identity, latDir, projectRoot, createResolver);
+    return {
+        kind: 'source',
+        target: resolved.target.identity,
+        source: {
+            path: `${resolved.target.handle}:${resolved.target.authoredPath}`,
+            content: resolved.fullContent,
+            highlightedLines: highlightSource(resolved.target.resolvedPath, resolved.fullContent),
+            focus: resolved.target.fragment
+                ? {
+                    symbol: resolved.target.fragment,
+                    kind: 'external',
+                    signature: resolved.signature ?? resolved.target.fragment,
+                    startLine: resolved.startLine,
+                    endLine: resolved.endLine,
+                }
+                : null,
+            context: null,
+            otherReferences: references,
+        },
+    };
+}
+async function readViewSource(latDir, projectRoot, requestedPath, requestedSymbol = '', requestedLine = 0) {
     if (!requestedPath ||
         requestedPath.includes('\\') ||
         isAbsolute(requestedPath) ||
-        !SOURCE_EXTENSIONS.has(extname(requestedPath))) {
+        !isSourceFileExtension(extname(requestedPath))) {
         throw new ViewSourceNotFoundError('Source document not found');
     }
     const candidate = resolve(projectRoot, requestedPath);
@@ -135,7 +354,7 @@ async function readViewSource(projectRoot, requestedPath, requestedSymbol = '',
             },
         };
     }
-    const resolved = await resolveSourceSymbol(requestedPath, requestedSymbol, projectRoot);
+    const resolved = await resolveSourceSymbol(requestedPath, requestedSymbol, projectRoot, { latDir, runtime: new SourceParserRuntime() });
     const symbol = resolved.found
         ? matchingSymbol(resolved.symbols, requestedSymbol)
         : undefined;
@@ -156,13 +375,13 @@ async function readViewSource(projectRoot, requestedPath, requestedSymbol = '',
 }
 /** Read and highlight a source file after constraining it to the project root. */
 export async function getViewSource(latDir, projectRoot, requestedPath, requestedSymbol = '', origin, requestedLine = 0, allSections = [], referenceIndex) {
-    const source = await readViewSource(projectRoot, requestedPath, requestedSymbol, requestedLine);
+    const source = await readViewSource(latDir, projectRoot, requestedPath, requestedSymbol, requestedLine);
     const references = referenceIndex
         ? await renderSourceReferenceContext(referenceIndex, `${source.path}${requestedSymbol ? `#${requestedSymbol}` : ''}`, origin, latDir, projectRoot, (path) => createMarkdownWikiLinkResolver(latDir, path, allSections, referenceIndex))
         : { context: null, otherReferences: [] };
     return {
         ...source,
-        highlightedHtmlLines: highlightSource(source.path, source.content),
+        highlightedLines: highlightSource(source.path, source.content),
         ...references,
     };
 }

package/dist/src/view/search.d.ts

@@ -1,4 +1,4 @@
-import type { SectionMatch } from '../lattice.js';
+import type { SectionMatch } from '../lattice-model.js';
 import type { ViewSearchResponse } from './protocol.js';
 export type ViewSearch = (query: string) => Promise<ViewSearchResponse>;
 export type ViewSearchDependencies = {