@plebeiantech/lat.md 0.12.3-fork.9 → 0.13.4-fork.2

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

@@ -1,4 +1,5 @@
 import type { Root } from 'mdast';
+import type { ViewDocumentTree } from './protocol.js';
 export type WikiLinkContext = {
     line: number;
 };
@@ -19,8 +20,8 @@ export type MarkdownRenderOptions = {
     lineOffset?: number;
     rewriteMarkdownLink?: (url: string) => string;
 };
-/** Render a lat.md file as safe HTML with resolved wiki links. */
+/** Normalize a lat.md file into the safe, parser-neutral view tree. */
 export declare function renderMarkdown(markdown: string, filePath: string, resolveWikiLink?: WikiLinkResolver, options?: MarkdownRenderOptions, parsedTree?: Root): Promise<{
-    html: string;
+    tree: ViewDocumentTree;
     title: string;
 }>;

package/dist/src/view/markdown.js

@@ -1,11 +1,15 @@
 import { basename, extname } from 'node:path';
 import rehypeSanitize, { defaultSchema } from 'rehype-sanitize';
+import rehypeRaw from 'rehype-raw';
+import rehypeKatex from 'rehype-katex';
 import rehypeSlug from 'rehype-slug';
-import rehypeStringify from 'rehype-stringify';
+import remarkEmoji from 'remark-emoji';
 import remarkRehype from 'remark-rehype';
 import { unified } from 'unified';
 import { visit } from 'unist-util-visit';
-import { parse } from '../parser.js';
+import { parse } from '@plebeiantech/lat.md-core/parser';
+import { decorateExternalSiteLinks, toViewDocumentTree, } from './document-tree.js';
+import { highlightCode } from './highlight.js';
 const CODE_LINK_CLASSES = [
     'wiki-link-code',
     'wiki-link-active',
@@ -14,22 +18,66 @@ const CODE_LINK_CLASSES = [
     'code-language-ts',
     'code-language-js',
     'code-language-py',
+    'code-language-rb',
     'code-language-rs',
     'code-language-go',
     'code-language-c',
+    'code-language-dart',
+    'code-language-java',
+    'code-language-swift',
 ];
 const ERROR_CLASS = 'markdown-error';
-const EXTERNAL_LINK_CLASS = 'external-link';
-const EXTERNAL_LINK_ICON_CLASS = 'external-link-icon';
 const GIT_CLASSES = ['git-added', 'git-removed'];
-function classAttributes(tag) {
+const GEOJSON_SOURCE_CLASS = 'markdown-geojson-source';
+const HIGHLIGHT_CLASS = 'hljs';
+const MERMAID_SOURCE_CLASS = 'markdown-mermaid-source';
+const MATH_DIFF_BLOCK_CLASS = 'git-math-block';
+const RICH_FENCE_SOURCE_CLASS = 'markdown-diagram-source';
+const STL_SOURCE_CLASS = 'markdown-stl-source';
+const TOPOJSON_SOURCE_CLASS = 'markdown-topojson-source';
+const ALERT_KINDS = ['note', 'tip', 'important', 'warning', 'caution'];
+const ALERT_CLASSES = [
+    'markdown-alert',
+    'markdown-alert-title',
+    ...ALERT_KINDS.map((kind) => `markdown-alert-${kind}`),
+];
+const GITHUB_CUSTOM_EMOJI = new Set([
+    'atom',
+    'basecamp',
+    'basecampy',
+    'bowtie',
+    'electron',
+    'feelsgood',
+    'finnadie',
+    'fishsticks',
+    'fu',
+    'goberserk',
+    'godmode',
+    'hurtrealbad',
+    'neckbeard',
+    'octocat',
+    'rage1',
+    'rage2',
+    'rage3',
+    'rage4',
+    'shipit',
+    'suspect',
+    'trollface',
+]);
+function classAttributes(tag, extraClasses = []) {
     const attributes = defaultSchema.attributes?.[tag] ?? [];
     const allowedClasses = attributes.flatMap((attribute) => Array.isArray(attribute) && attribute[0] === 'className'
         ? attribute.slice(1)
         : []);
     return [
         ...attributes.filter((attribute) => !(Array.isArray(attribute) && attribute[0] === 'className')),
-        ['className', ...allowedClasses, ERROR_CLASS, ...GIT_CLASSES],
+        [
+            'className',
+            ...allowedClasses,
+            ERROR_CLASS,
+            ...GIT_CLASSES,
+            ...extraClasses,
+        ],
     ];
 }
 const sanitizeSchema = {
@@ -45,50 +93,168 @@ const sanitizeSchema = {
                 'wiki-link-segmented',
                 'wiki-link-code',
                 'wiki-link-active',
-                EXTERNAL_LINK_CLASS,
                 ERROR_CLASS,
                 ...GIT_CLASSES,
             ],
         ],
         blockquote: classAttributes('blockquote'),
-        code: classAttributes('code'),
+        code: classAttributes('code', [
+            HIGHLIGHT_CLASS,
+            'math-display',
+            'math-inline',
+        ]),
         del: classAttributes('del'),
-        div: classAttributes('div'),
+        details: [...(defaultSchema.attributes?.details ?? []), ['open', true]],
+        div: classAttributes('div', [...ALERT_CLASSES, MATH_DIFF_BLOCK_CLASS]),
         h1: classAttributes('h1'),
         h2: classAttributes('h2'),
         h3: classAttributes('h3'),
         h4: classAttributes('h4'),
         h5: classAttributes('h5'),
         h6: classAttributes('h6'),
-        img: classAttributes('img'),
+        img: classAttributes('img', ['markdown-emoji']),
+        input: [...(defaultSchema.attributes?.input ?? []), ['checked', true]],
         ins: classAttributes('ins'),
         li: classAttributes('li'),
         ol: classAttributes('ol'),
-        p: classAttributes('p'),
-        pre: classAttributes('pre'),
+        p: classAttributes('p', ALERT_CLASSES),
+        pre: classAttributes('pre', [
+            GEOJSON_SOURCE_CLASS,
+            MERMAID_SOURCE_CLASS,
+            RICH_FENCE_SOURCE_CLASS,
+            STL_SOURCE_CLASS,
+            TOPOJSON_SOURCE_CLASS,
+        ]),
         span: [
             ...(defaultSchema.attributes?.span ?? []),
             'ariaHidden',
             'ariaLabel',
+            'role',
             [
                 'className',
                 'wiki-link-context',
                 'wiki-link-leaf',
                 'wiki-link-ref-count',
-                EXTERNAL_LINK_ICON_CLASS,
                 ...CODE_LINK_CLASSES.slice(2),
+                /^hljs-./,
                 ERROR_CLASS,
                 ...GIT_CLASSES,
             ],
         ],
+        table: classAttributes('table'),
+        tr: classAttributes('tr'),
         ul: classAttributes('ul'),
     },
 };
-const htmlProcessor = unified()
-    .use(remarkRehype)
+const highlightedCodeHandler = (state, rawNode) => {
+    const node = rawNode;
+    const language = node.lang?.split(/\s+/, 1)[0];
+    const richSourceClass = language?.toLowerCase() === 'mermaid'
+        ? MERMAID_SOURCE_CLASS
+        : language?.toLowerCase() === 'geojson'
+            ? GEOJSON_SOURCE_CLASS
+            : language?.toLowerCase() === 'topojson'
+                ? TOPOJSON_SOURCE_CLASS
+                : language?.toLowerCase() === 'stl'
+                    ? STL_SOURCE_CLASS
+                    : null;
+    const highlighted = language && !richSourceClass ? highlightCode(language, node.value) : null;
+    const code = {
+        type: 'element',
+        tagName: 'code',
+        properties: {
+            className: [
+                ...(language ? [`language-${language}`] : []),
+                ...(highlighted === null ? [] : [HIGHLIGHT_CLASS]),
+            ],
+        },
+        children: highlighted === null
+            ? [
+                {
+                    type: 'text',
+                    value: node.value ? `${node.value}\n` : '',
+                },
+            ]
+            : [...highlighted.children, { type: 'text', value: '\n' }],
+        ...(node.meta ? { data: { meta: node.meta } } : {}),
+    };
+    state.patch(node, code);
+    const result = state.applyData(node, code);
+    const pre = {
+        type: 'element',
+        tagName: 'pre',
+        properties: {
+            className: richSourceClass
+                ? [RICH_FENCE_SOURCE_CLASS, richSourceClass]
+                : [],
+        },
+        children: [result],
+    };
+    state.patch(node, pre);
+    return pre;
+};
+const documentTreeProcessor = unified()
+    .use(remarkRehype, {
+    allowDangerousHtml: true,
+    handlers: { code: highlightedCodeHandler },
+})
+    .use(rehypeRaw)
+    .use(() => (tree, file) => {
+    const rewrite = file.data.rewriteMarkdownLink;
+    if (typeof rewrite !== 'function')
+        return;
+    // HTML attributes only become nodes after rehypeRaw. Resolve remaining
+    // relative URLs here, before the sanitizer enforces allowed protocols.
+    visit(tree, 'element', (node) => {
+        for (const name of ['href', 'src']) {
+            const value = node.properties[name];
+            if (typeof value === 'string' &&
+                value &&
+                !/^(?:[#/]|[a-z][a-z\d+.-]*:)/i.test(value)) {
+                node.properties[name] = rewrite(value);
+            }
+        }
+    });
+})
     .use(rehypeSanitize, sanitizeSchema)
-    .use(rehypeSlug)
-    .use(rehypeStringify);
+    .use(rehypeKatex)
+    .use(rehypeSlug);
+const emojiProcessor = unified().use(remarkEmoji, { accessible: true });
+function transformCustomEmoji(tree) {
+    visit(tree, 'text', (node, index, parent) => {
+        if (index === undefined || !parent || !node.value.includes(':'))
+            return;
+        const pattern = /:([a-z0-9_+-]+):/g;
+        const children = [];
+        let cursor = 0;
+        let match;
+        while ((match = pattern.exec(node.value))) {
+            if (!GITHUB_CUSTOM_EMOJI.has(match[1]))
+                continue;
+            if (match.index > cursor) {
+                children.push({
+                    type: 'text',
+                    value: node.value.slice(cursor, match.index),
+                });
+            }
+            children.push({
+                type: 'image',
+                url: `https://github.githubassets.com/images/icons/emoji/${match[1]}.png?v8`,
+                alt: match[0],
+                title: null,
+                data: { hProperties: { className: ['markdown-emoji'] } },
+            });
+            cursor = match.index + match[0].length;
+        }
+        if (children.length === 0)
+            return;
+        if (cursor < node.value.length) {
+            children.push({ type: 'text', value: node.value.slice(cursor) });
+        }
+        parent.children.splice(index, 1, ...children);
+        return index + children.length;
+    });
+}
 function nodeText(node) {
     if (typeof node.value === 'string')
         return node.value;
@@ -98,6 +264,38 @@ function nodeText(node) {
         .map((child) => nodeText(child))
         .join('');
 }
+function transformAlerts(tree) {
+    visit(tree, 'blockquote', (node) => {
+        const firstBlock = node.children[0];
+        if (firstBlock?.type !== 'paragraph')
+            return;
+        const firstInline = firstBlock.children[0];
+        if (firstInline?.type !== 'alertMarker')
+            return;
+        const label = firstInline.value;
+        const kind = label.toLowerCase();
+        firstBlock.children.shift();
+        if (firstBlock.children.length === 0)
+            node.children.shift();
+        node.data = {
+            ...node.data,
+            hName: 'div',
+            hProperties: {
+                ...(node.data?.hProperties ?? {}),
+                className: ['markdown-alert', `markdown-alert-${kind}`],
+            },
+        };
+        node.children.unshift({
+            type: 'paragraph',
+            data: {
+                hProperties: { className: ['markdown-alert-title'] },
+            },
+            children: [
+                { type: 'text', value: label[0] + label.slice(1).toLowerCase() },
+            ],
+        });
+    });
+}
 function wikiLinkContent(node) {
     if (node.data.alias) {
         return {
@@ -144,6 +342,10 @@ function codeLanguage(target) {
             return { className: 'code-language-js', label: 'JS' };
         case '.py':
             return { className: 'code-language-py', label: 'PY' };
+        case '.erb':
+        case '.rake':
+        case '.rb':
+            return { className: 'code-language-rb', label: 'RB' };
         case '.rs':
             return { className: 'code-language-rs', label: 'RS' };
         case '.go':
@@ -151,6 +353,12 @@ function codeLanguage(target) {
         case '.c':
         case '.h':
             return { className: 'code-language-c', label: 'C' };
+        case '.dart':
+            return { className: 'code-language-dart', label: 'DART' };
+        case '.swift':
+            return { className: 'code-language-swift', label: 'SWIFT' };
+        case '.java':
+            return { className: 'code-language-java', label: 'JAVA' };
         default:
             return null;
     }
@@ -194,22 +402,6 @@ function codeLinkContent(language, children) {
         ...rest,
     ];
 }
-function externalLinkIcon() {
-    return {
-        type: 'emphasis',
-        data: {
-            hName: 'span',
-            hProperties: {
-                ariaHidden: 'true',
-                className: [EXTERNAL_LINK_ICON_CLASS],
-            },
-        },
-        children: [],
-    };
-}
-function isExternalSiteUrl(url) {
-    return /^(?:https?:)?\/\//i.test(url);
-}
 function referenceCountBadge(count) {
     return {
         type: 'emphasis',
@@ -291,10 +483,13 @@ function markMarkdownErrors(tree, errors) {
         };
     }
 }
-/** Render a lat.md file as safe HTML with resolved wiki links. */
+/** Normalize a lat.md file into the safe, parser-neutral view tree. */
 export async function renderMarkdown(markdown, filePath, resolveWikiLink, options = {}, parsedTree) {
     const tree = parsedTree ? structuredClone(parsedTree) : parse(markdown);
     tree.children = tree.children.filter((node) => node.type !== 'yaml');
+    await emojiProcessor.run(tree);
+    transformCustomEmoji(tree);
+    transformAlerts(tree);
     if (options.errors)
         markMarkdownErrors(tree, options.errors);
     visit(tree, 'link', (node) => {
@@ -312,23 +507,16 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
         if (options.rewriteMarkdownLink) {
             node.url = options.rewriteMarkdownLink(authoredUrl);
         }
-        if (!isExternalSiteUrl(node.url))
-            return;
-        const properties = node.data?.hProperties ?? {};
-        const currentClasses = properties.className;
-        const classes = Array.isArray(currentClasses)
-            ? currentClasses.map(String)
-            : currentClasses
-                ? [String(currentClasses)]
-                : [];
-        node.data = {
-            ...node.data,
-            hProperties: {
-                ...properties,
-                className: [...classes, EXTERNAL_LINK_CLASS],
-            },
-        };
-        node.children.push(externalLinkIcon());
+    });
+    visit(tree, 'image', (node) => {
+        if (options.rewriteMarkdownLink) {
+            node.url = options.rewriteMarkdownLink(node.url);
+        }
+    });
+    visit(tree, 'definition', (node) => {
+        if (options.rewriteMarkdownLink) {
+            node.url = options.rewriteMarkdownLink(node.url);
+        }
     });
     const firstHeading = tree.children.find((node) => node.type === 'heading');
     const title = firstHeading
@@ -354,7 +542,7 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
         if (resolution) {
             const { href, referenceCount } = resolution;
             const content = wikiLinkContent(node);
-            const language = href.startsWith('/code/')
+            const language = href.startsWith('/code/') || href.startsWith('/external/')
                 ? codeLanguage(node.value)
                 : null;
             const classes = content.segmented ? ['wiki-link-segmented'] : [];
@@ -404,6 +592,20 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
                 value: `[[${node.value}${alias}]]`,
             };
     });
-    const hast = await htmlProcessor.run(tree);
-    return { html: htmlProcessor.stringify(hast), title };
+    const hast = await documentTreeProcessor.run(tree, {
+        data: { rewriteMarkdownLink: options.rewriteMarkdownLink },
+    });
+    // Attach source ranges after sanitization, before positions are discarded.
+    visit(hast, 'element', (node) => {
+        if (!/^(p|pre|li|tr|h[1-6])$/.test(node.tagName) || !node.position)
+            return;
+        node.properties['data-source-start-line'] =
+            node.position.start.line + (options.lineOffset ?? 0);
+        node.properties['data-source-end-line'] =
+            node.position.end.line + (options.lineOffset ?? 0);
+    });
+    return {
+        tree: decorateExternalSiteLinks(toViewDocumentTree(hast)),
+        title,
+    };
 }

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

@@ -0,0 +1,15 @@
+import type { Section } from '@plebeiantech/lat.md-core/lattice-model';
+import type { CreateSearchEngine } from '../search/embedder.js';
+import { type IndexedSearchSession } from '../search/query.js';
+import type { ViewSearchResponse } from './protocol.js';
+export type PreindexedViewSearchDependencies = {
+    openSearchSession: (latDir: string, options: {
+        cacheDir?: string;
+        createSearchEngine?: CreateSearchEngine;
+    }) => Promise<IndexedSearchSession>;
+};
+export type PreindexedViewSearch = ((query: string) => Promise<ViewSearchResponse>) & {
+    close: () => Promise<void>;
+};
+/** Serve a built search index without importing indexing or Markdown parsers. */
+export declare function createPreindexedViewSearch(latDir: string, cacheDir: string, sections: readonly Section[], documentPaths: ReadonlyMap<string, string>, dependencies?: PreindexedViewSearchDependencies, createSearchEngine?: CreateSearchEngine): Promise<PreindexedViewSearch>;

package/dist/src/view/preindexed-search.js

@@ -0,0 +1,25 @@
+import { openIndexedSearchSession, resolveSearchMatches, } from '../search/query.js';
+import { viewSearchResult } from './search-result.js';
+const VIEW_SEARCH_LIMIT = 10;
+/** Serve a built search index without importing indexing or Markdown parsers. */
+export async function createPreindexedViewSearch(latDir, cacheDir, sections, documentPaths, dependencies = {
+    openSearchSession: openIndexedSearchSession,
+}, createSearchEngine) {
+    const sectionById = new Map(sections.map((section) => [section.id.toLowerCase(), section]));
+    const session = await dependencies.openSearchSession(latDir, {
+        cacheDir,
+        createSearchEngine,
+    });
+    const search = async (rawQuery) => {
+        const query = rawQuery.trim();
+        if (!query)
+            return { query: '', results: [] };
+        const results = await session.search(query, VIEW_SEARCH_LIMIT);
+        return {
+            query,
+            results: resolveSearchMatches(results, sectionById).map((match) => viewSearchResult(latDir, match, documentPaths)),
+        };
+    };
+    search.close = session.close;
+    return search;
+}

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

@@ -1,9 +1,18 @@
+import type { SearchEvidence } from '../search/types.js';
 export type ViewGitFileStatus = 'modified' | 'new';
 export type ViewGitState = {
     files: Record<string, ViewGitFileStatus>;
 };
+export type ViewExternalFile = {
+    handle: string;
+    path: string;
+    target: string;
+};
 export type ViewIndex = {
     files: string[];
+    /** Authored directory-index entries, keyed by vault-relative directory ('' at root). */
+    directoryOrder: Record<string, string[]>;
+    externalFiles: ViewExternalFile[];
     entry: string;
     errorCounts: Record<string, number>;
     git: ViewGitState | null;
@@ -24,16 +33,31 @@ export type ViewSearchResult = {
     breadcrumbs: string[];
     description: string;
     url: string;
-    score: number;
+    rankScore: number;
+    introduction: string;
+    evidence: SearchEvidence[];
+    semanticSimilarity?: number;
+    semanticRank?: number;
+    lexicalRank?: number;
 };
 export type ViewSearchResponse = {
     query: string;
     results: ViewSearchResult[];
 };
-export type ViewProjectChange = {
+import type { ViewDocumentTree } from '@plebeiantech/lat.md-core/document-tree';
+export type { ViewDocumentProperty, ViewDocumentText, ViewDocumentElement, ViewDocumentNode, ViewDocumentTree, } from '@plebeiantech/lat.md-core/document-tree';
+export type ViewSectionCommandOutput = {
+    output: string;
+    tree: ViewDocumentTree;
+    isError: boolean;
+};
+export type ViewProjectGeneration = {
     generation: number;
     markdownGeneration: number;
 };
+export type ViewProjectChange = ViewProjectGeneration & {
+    instanceId: string;
+};
 export type ViewGraphNodeKind = 'document' | 'source' | 'code-reference';
 export type ViewGraphNode = {
     id: string;
@@ -41,6 +65,7 @@ export type ViewGraphNode = {
     label: string;
     url: string;
     breadcrumbs: string[];
+    /** Local documents sum direct backlink counts across every heading. Other nodes use incoming edge weights. */
     inDegree: number;
     outDegree: number;
     documentPath?: string;
@@ -49,6 +74,7 @@ export type ViewGraphNode = {
     symbol?: string;
     line?: number;
     snippet?: string;
+    externalTarget?: string;
     gitStatus?: ViewGitFileStatus;
     errorCount?: number;
 };
@@ -75,8 +101,8 @@ export type ViewDocumentTocItem = {
 export type ViewDocument = {
     path: string;
     title: string;
-    html: string;
-    gitHtml: string | null;
+    tree: ViewDocumentTree;
+    gitTree: ViewDocumentTree | null;
     graphNodeIds: Record<string, string>;
     tableOfContents: ViewDocumentTocItem[];
     errors: ViewDocumentError[];
@@ -85,12 +111,23 @@ export type ViewDocument = {
         requireCodeMention: boolean;
     };
 };
+export type ViewDocumentSource = {
+    path: string;
+    content: string;
+};
+export type ViewDocumentEditRequest = {
+    baseContent: string;
+    content: string;
+};
+export type ViewDocumentEditResponse = ViewDocumentSource & {
+    merged: boolean;
+};
 export type ViewMarkdownBackReference = {
     kind: 'markdown';
     sectionId: string;
     breadcrumbs: string[];
     paragraph: string;
-    paragraphHtml: string;
+    paragraphTree: ViewDocumentTree;
     url: string;
 };
 export type ViewCodeBackReference = {
@@ -110,13 +147,13 @@ export type ViewSourceReference = {
     sectionId: string;
     breadcrumbs: string[];
     paragraph: string;
-    paragraphHtml: string;
+    paragraphTree: ViewDocumentTree;
     url: string;
 };
 export type ViewSourceDocument = {
     path: string;
     content: string;
-    highlightedHtmlLines: string[];
+    highlightedLines: ViewDocumentTree[];
     focus: {
         symbol: string;
         kind: string;
@@ -127,6 +164,15 @@ export type ViewSourceDocument = {
     context: ViewSourceReference | null;
     otherReferences: ViewSourceReference[];
 };
+export type ViewExternalDocument = {
+    kind: 'markdown';
+    target: string;
+    document: ViewDocument;
+} | {
+    kind: 'source';
+    target: string;
+    source: ViewSourceDocument;
+};
 export type ViewError = {
     error: string;
 };

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

@@ -0,0 +1,2 @@
+/** Publication scope is deliberately narrower than interactive source browsing. */
+export declare function createPublicationPolicy(projectRoot: string): Promise<(path: string) => Promise<boolean>>;