@plebeiantech/lat.md 0.12.3-fork.8 → 0.13.4-fork.1

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 '@plebeiantech/lat.md-core/lattice-model';
+import { createExternalResolver, } from '@plebeiantech/lat.md-core/external-sources';
+import { addExternalDocumentAliasAnchors, externalDocumentSections, } from '@plebeiantech/lat.md-core/external-documents';
+import { resolveSourceSymbol, SourceParserRuntime, } from '@plebeiantech/lat.md-core/source-parser';
+import { isSourceFileExtension } from '@plebeiantech/lat.md-core/source-formats';
+import { toPosix } from '@plebeiantech/lat.md-core/path';
+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) ||
+        /^\/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, publishable) {
+    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;
@@ -68,10 +210,10 @@ export async function createMarkdownWikiLinkResolver(latDir, requestedPath, load
             };
         }
         const source = viewSourceTarget(target);
-        if (!source)
+        if (!source || (publishable && !(await publishable(source.path))))
             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,102 @@ 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, publishable) {
+    let resolved;
+    try {
+        resolved = await external.resolve(targetValue);
+    }
+    catch (error) {
+        throw new ViewExternalNotFoundError(error.message);
+    }
+    const createResolver = (path) => createMarkdownWikiLinkResolver(latDir, path, allSections, referenceIndex, external, publishable);
+    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);
+        // Remote-authored wiki links may resolve only to configured external files.
+        // Do not call the local resolver before rewriting their URLs.
+        const available = availableExternalFiles(external, referenceIndex, resolved.target);
+        const resolver = async (target) => {
+            try {
+                const parsed = external.parse(target);
+                if (parsed)
+                    return { href: externalUrl(parsed.identity), referenceCount: 0 };
+            }
+            catch {
+                return null;
+            }
+            const href = externalDocumentLink(target, resolved.target, external, available);
+            return typeof href === 'string' ? { href, referenceCount: 0 } : null;
+        };
+        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))) {
+        (requestedSymbol && !isSourceFileExtension(extname(requestedPath)))) {
         throw new ViewSourceNotFoundError('Source document not found');
     }
     const candidate = resolve(projectRoot, requestedPath);
@@ -115,7 +348,15 @@ async function readViewSource(projectRoot, requestedPath, requestedSymbol = '',
     if (!isInside(realRoot, realFile)) {
         throw new ViewSourceNotFoundError('Source document not found');
     }
-    const content = await readFile(realFile, 'utf-8');
+    let content;
+    try {
+        content = new TextDecoder('utf-8', { fatal: true }).decode(await readFile(realFile));
+        if (content.includes('\0'))
+            throw new Error('Binary file');
+    }
+    catch {
+        throw new ViewSourceNotFoundError('Source file is not readable UTF-8 text');
+    }
     if (!requestedSymbol) {
         if (!requestedLine)
             return { path: requestedPath, content, focus: null };
@@ -135,7 +376,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;
@@ -155,14 +396,14 @@ 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);
+export async function getViewSource(latDir, projectRoot, requestedPath, requestedSymbol = '', origin, requestedLine = 0, allSections = [], referenceIndex, publishable) {
+    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))
+        ? await renderSourceReferenceContext(referenceIndex, `${source.path}${requestedSymbol ? `#${requestedSymbol}` : ''}`, origin, latDir, projectRoot, (path) => createMarkdownWikiLinkResolver(latDir, path, allSections, referenceIndex, undefined, publishable))
         : { context: null, otherReferences: [] };
     return {
         ...source,
-        highlightedHtmlLines: highlightSource(source.path, source.content),
+        highlightedLines: highlightSource(source.path, source.content),
         ...references,
     };
 }

package/dist/src/view/request-security.d.ts

@@ -0,0 +1,5 @@
+import type { IncomingMessage } from 'node:http';
+/** Check the actual listener authority; forwarding headers are not trusted. */
+export declare function trustedLiveRequest(req: IncomingMessage, configuredHost: string): boolean;
+/** Untrusted repository resources cannot execute with the editor's origin. */
+export declare const RESOURCE_CONTENT_SECURITY_POLICY = "sandbox; default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";

package/dist/src/view/request-security.js

@@ -0,0 +1,46 @@
+const LOOPBACK_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+const urlHost = (host) => host.includes(':') && !host.startsWith('[')
+    ? `[${host}]`
+    : host.toLowerCase();
+/** Check the actual listener authority; forwarding headers are not trusted. */
+export function trustedLiveRequest(req, configuredHost) {
+    const authority = req.headers.host;
+    if (!authority || !/^[a-z\d.\-:[\]]+$/i.test(authority))
+        return false;
+    let url;
+    try {
+        url = new URL(`http://${authority}`);
+    }
+    catch {
+        return false;
+    }
+    if (Number(url.port || 80) !== req.socket.localPort)
+        return false;
+    const host = urlHost(configuredHost);
+    const allowed = new Set([host]);
+    if (LOOPBACK_HOSTS.has(host) || host === '0.0.0.0' || host === '[::]') {
+        for (const name of LOOPBACK_HOSTS)
+            allowed.add(name);
+        if (req.socket.localAddress)
+            allowed.add(urlHost(req.socket.localAddress));
+    }
+    if (!allowed.has(url.hostname))
+        return false;
+    const origin = req.headers.origin;
+    if (origin !== undefined && origin !== url.origin)
+        return false;
+    if (!['GET', 'HEAD'].includes(req.method ?? 'GET') &&
+        req.headers['sec-fetch-site'] === 'cross-site')
+        return false;
+    // Do not accept an absolute-form URL for a different authority.
+    try {
+        if (new URL(req.url ?? '/', url).origin !== url.origin)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/** Untrusted repository resources cannot execute with the editor's origin. */
+export const RESOURCE_CONTENT_SECURITY_POLICY = "sandbox; default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";

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

@@ -0,0 +1,4 @@
+import type { SectionMatch } from '@plebeiantech/lat.md-core/lattice-model';
+import type { ViewSearchResult } from './protocol.js';
+/** Convert one graph section match into the browser search protocol. */
+export declare function viewSearchResult(latDir: string, match: SectionMatch, documentPaths?: ReadonlyMap<string, string>): ViewSearchResult;

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

@@ -0,0 +1,25 @@
+import { dirname, relative, resolve } from 'node:path';
+import { toPosix } from '@plebeiantech/lat.md-core/path';
+import { documentUrl } from './document-route.js';
+/** Convert one graph section match into the browser search protocol. */
+export function viewSearchResult(latDir, match, documentPaths) {
+    const section = match.section;
+    const projectRoot = dirname(latDir);
+    const path = documentPaths?.get(section.id.toLowerCase()) ??
+        toPosix(relative(latDir, resolve(projectRoot, section.filePath)));
+    const fileBreadcrumbs = path.replace(/\.md$/i, '').split('/');
+    return {
+        sectionId: section.id,
+        title: section.heading,
+        path,
+        breadcrumbs: [...fileBreadcrumbs, ...section.id.split('#').slice(1)],
+        description: match.evidence?.[0]?.text ?? section.firstParagraph,
+        introduction: section.firstParagraph,
+        evidence: match.evidence ?? [],
+        semanticSimilarity: match.semanticSimilarity,
+        semanticRank: match.semanticRank,
+        lexicalRank: match.lexicalRank,
+        url: documentUrl(path, section.githubSlug ?? ''),
+        rankScore: match.rankScore ?? 0,
+    };
+}

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

@@ -1,4 +1,4 @@
-import type { SectionMatch } from '../lattice.js';
+import type { Section, SectionMatch } from '@plebeiantech/lat.md-core/lattice-model';
 import type { ViewSearchResponse } from './protocol.js';
 export type ViewSearch = (query: string) => Promise<ViewSearchResponse>;
 export type ViewSearchDependencies = {
@@ -11,4 +11,9 @@ export type ViewSearchDependencies = {
     }>;
 };
 /** Create the lazily indexed semantic search service used by `lat ui`. */
-export declare function createViewSearch(latDir: string, dependencies?: ViewSearchDependencies, getGeneration?: () => number): ViewSearch;
+export declare function createViewSearch(latDir: string, dependencies?: ViewSearchDependencies, getGeneration?: () => number, options?: {
+    cacheDir?: string;
+    preindexed?: boolean;
+    sections?: readonly Section[];
+    documentPaths?: ReadonlyMap<string, string>;
+}): ViewSearch;

package/dist/src/view/search.js

@@ -1,45 +1,34 @@
-import { dirname, relative, resolve } from 'node:path';
-import { toPosix } from '../walk.js';
+import { viewSearchResult } from './search-result.js';
 const VIEW_SEARCH_LIMIT = 10;
-const defaultDependencies = {
-    async runIndex(latDir) {
-        const { runIndex } = await import('../cli/search.js');
-        await runIndex(latDir);
-    },
-    async runSearch(latDir, query, limit, options) {
-        const { runSearch } = await import('../cli/search.js');
-        return runSearch(latDir, query, limit, undefined, options);
-    },
-};
-function documentUrl(path, headingId) {
-    const encodedPath = path.split('/').map(encodeURIComponent).join('/');
-    const fragment = headingId ? `#${encodeURIComponent(headingId)}` : '';
-    return `/docs/${encodedPath}${fragment}`;
-}
-function viewSearchResult(latDir, match) {
-    const section = match.section;
-    const projectRoot = dirname(latDir);
-    const path = toPosix(relative(latDir, resolve(projectRoot, section.filePath)));
-    const fileBreadcrumbs = path.replace(/\.md$/i, '').split('/');
+function defaultDependencies(cacheDir, sectionById) {
     return {
-        sectionId: section.id,
-        title: section.heading,
-        path,
-        breadcrumbs: [...fileBreadcrumbs, ...section.id.split('#').slice(1)],
-        description: section.firstParagraph,
-        url: documentUrl(path, section.githubSlug),
-        score: match.score ?? 0,
+        async runIndex(latDir) {
+            const { runIndex } = await import('../cli/search.js');
+            await runIndex(latDir, undefined, undefined, { cacheDir });
+        },
+        async runSearch(latDir, query, limit, options) {
+            const { runSearch } = await import('../cli/search.js');
+            return runSearch(latDir, query, limit, undefined, {
+                ...options,
+                cacheDir,
+                sectionById,
+            });
+        },
     };
 }
 /** Create the lazily indexed semantic search service used by `lat ui`. */
-export function createViewSearch(latDir, dependencies = defaultDependencies, getGeneration = () => 0) {
+export function createViewSearch(latDir, dependencies, getGeneration = () => 0, options = {}) {
+    const sectionById = options.sections
+        ? new Map(options.sections.map((section) => [section.id.toLowerCase(), section]))
+        : undefined;
+    const resolvedDependencies = dependencies ?? defaultDependencies(options.cacheDir, sectionById);
     let indexReady = null;
-    let indexedGeneration = -1;
+    let indexedGeneration = options.preindexed ? getGeneration() : -1;
     const prepareIndex = async () => {
         while (indexedGeneration < getGeneration() || indexedGeneration < 0) {
             if (!indexReady) {
                 const generation = getGeneration();
-                indexReady = dependencies
+                indexReady = resolvedDependencies
                     .runIndex(latDir)
                     .then(() => {
                     indexedGeneration = Math.max(indexedGeneration, generation);
@@ -56,10 +45,10 @@ export function createViewSearch(latDir, dependencies = defaultDependencies, get
         if (!query)
             return { query: '', results: [] };
         await prepareIndex();
-        const search = await dependencies.runSearch(latDir, query, VIEW_SEARCH_LIMIT, { buildIndex: false });
+        const search = await resolvedDependencies.runSearch(latDir, query, VIEW_SEARCH_LIMIT, { buildIndex: false });
         return {
             query: search.query,
-            results: search.matches.map((match) => viewSearchResult(latDir, match)),
+            results: search.matches.map((match) => viewSearchResult(latDir, match, options.documentPaths)),
         };
     };
 }

package/dist/src/view/server-build.d.ts

@@ -0,0 +1,21 @@
+import { getLatServerVersion } from '../../vendor/lat.md-server/index.js';
+import type { CmdContext } from '@plebeiantech/lat.md-core/context';
+import { analyzeMarkdownProject, type MarkdownProjectAnalysis } from '@plebeiantech/lat.md-core/project-analysis';
+import { getLocalVersion } from '../version.js';
+import { buildStaticView, type StaticViewBuildOptions, type StaticViewBuildResult } from './static-build.js';
+export type ServerViewBuildOptions = Omit<StaticViewBuildOptions, 'searchApi'>;
+export type ServerViewBuildResult = StaticViewBuildResult;
+export type ServerViewBuildDependencies = {
+    analyzeMarkdownProject: typeof analyzeMarkdownProject;
+    buildStaticView: typeof buildStaticView;
+    getLocalVersion: typeof getLocalVersion;
+    getLatServerVersion: typeof getLatServerVersion;
+    getPackageVersion: typeof getPackageVersion;
+    buildSearchIndex: typeof buildServerSearchIndex;
+};
+/** Wait for the index process to exit so native handles cannot lock staging. */
+export declare function buildServerSearchIndex(latDir: string, project: MarkdownProjectAnalysis, cacheDir: string): Promise<void>;
+declare function getPackageVersion(name: string): string;
+/** Build immutable UI data plus the small portable Express search service. */
+export declare function buildServerView(ctx: CmdContext, requestedOutput: string, options?: ServerViewBuildOptions, dependencies?: ServerViewBuildDependencies): Promise<ServerViewBuildResult>;
+export {};