@plebeiantech/lat.md 0.12.3-fork.15 → 0.12.3-fork.17

package/dist/src/view/markdown.js

@@ -18,6 +18,7 @@ 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',
@@ -323,6 +324,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':
@@ -488,6 +493,11 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
             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
         ? nodeText(firstHeading)
@@ -563,6 +573,15 @@ export async function renderMarkdown(markdown, filePath, resolveWikiLink, option
             };
     });
     const hast = await documentTreeProcessor.run(tree);
+    // 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 '../lattice-model.js';
+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,3 +1,4 @@
+import type { SearchEvidence } from '../search/types.js';
 export type ViewGitFileStatus = 'modified' | 'new';
 export type ViewGitState = {
     files: Record<string, ViewGitFileStatus>;
@@ -9,6 +10,8 @@ export type ViewExternalFile = {
 };
 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>;
@@ -30,7 +33,12 @@ 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;
@@ -73,6 +81,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;

package/dist/src/view/references.js

@@ -3,14 +3,14 @@ import { buildFileIndex, buildSectionSlugIndex, flattenSections, resolveRef, } f
 import { analyzeMarkdownFile, } from '../markdown-analysis.js';
 import { toPosix } from '../path.js';
 import { renderMarkdown } from './markdown.js';
-import { viewSourceTarget } from './source-target.js';
-import { documentUrl as routeDocumentUrl, rewriteDocumentLink, } from './document-route.js';
+import { viewSourceTarget, rewriteLocalFileLink } from './source-target.js';
+import { documentUrl as routeDocumentUrl } from './document-route.js';
 /** Parse one Markdown file once into every structure needed by the view store. */
 export function parseViewMarkdownFile(absolutePath, content, latDir, projectRoot) {
     return analyzeMarkdownFile(absolutePath, content, latDir, projectRoot);
 }
 function contextMarkdownLink(requestedPath, url) {
-    return rewriteDocumentLink(url, requestedPath);
+    return rewriteLocalFileLink(url, requestedPath);
 }
 function documentUrl(latDir, projectRoot, section) {
     const path = toPosix(relative(latDir, resolve(projectRoot, section.filePath)));
@@ -34,20 +34,19 @@ export function linkedSection(url, sourcePath, sectionsByPath) {
         .join('/');
     let destination;
     try {
-        destination = new URL(url, `http://lat.local/docs/${encodedSourcePath}`);
+        destination = new URL(url, `http://lat.local/${encodedSourcePath}`);
     }
     catch {
         return null;
     }
-    if (destination.origin !== 'http://lat.local' ||
-        !destination.pathname.startsWith('/docs/')) {
+    if (destination.origin !== 'http://lat.local') {
         return null;
     }
     let path;
     let fragment;
     try {
         path = destination.pathname
-            .slice('/docs/'.length)
+            .slice(1)
             .split('/')
             .map(decodeURIComponent)
             .join('/');

package/dist/src/view/repository.js

@@ -316,7 +316,7 @@ async function readViewSource(latDir, projectRoot, requestedPath, requestedSymbo
     if (!requestedPath ||
         requestedPath.includes('\\') ||
         isAbsolute(requestedPath) ||
-        !isSourceFileExtension(extname(requestedPath))) {
+        (requestedSymbol && !isSourceFileExtension(extname(requestedPath)))) {
         throw new ViewSourceNotFoundError('Source document not found');
     }
     const candidate = resolve(projectRoot, requestedPath);
@@ -334,7 +334,15 @@ async function readViewSource(latDir, projectRoot, requestedPath, requestedSymbo
     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 };

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

@@ -0,0 +1,4 @@
+import type { SectionMatch } from '../lattice-model.js';
+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 '../path.js';
+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-model.js';
+import type { Section, SectionMatch } from '../lattice-model.js';
 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,41 +1,34 @@
-import { dirname, relative, resolve } from 'node:path';
-import { toPosix } from '../path.js';
-import { documentUrl } from './document-route.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 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);
@@ -52,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 '../context.js';
+import { analyzeMarkdownProject, type MarkdownProjectAnalysis } from '../project-analysis.js';
+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 {};

package/dist/src/view/server-build.js

@@ -0,0 +1,145 @@
+import { readFileSync } from 'node:fs';
+import { fork } from 'node:child_process';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { getLatServerVersion } from '../../vendor/lat.md-server/index.js';
+import { analyzeMarkdownProject, } from '../project-analysis.js';
+import { getLocalVersion } from '../version.js';
+import { toPosix } from '../path.js';
+import { buildStaticView, moveViewBuildOutput, removeViewBuildStaging, normalizeStaticViewBasePath, validateViewBuildOutput, } from './static-build.js';
+import { SERVER_VIEW_SCHEMA_VERSION, } from './server-deployment.js';
+const defaultDependencies = {
+    analyzeMarkdownProject,
+    buildStaticView,
+    getLocalVersion,
+    getLatServerVersion,
+    getPackageVersion,
+    buildSearchIndex: buildServerSearchIndex,
+};
+/** Wait for the index process to exit so native handles cannot lock staging. */
+export function buildServerSearchIndex(latDir, project, cacheDir) {
+    const sourceRuntime = import.meta.url.endsWith('.ts');
+    const child = fork(new URL(sourceRuntime ? './server-index-worker.ts' : './server-index-worker.js', import.meta.url), [], {
+        execArgv: sourceRuntime ? ['--import', 'tsx'] : [],
+        serialization: 'advanced',
+        stdio: ['ignore', 'ignore', 'pipe', 'ipc'],
+    });
+    return new Promise((resolveIndex, reject) => {
+        let stderr = '';
+        let sendError = null;
+        child.stderr.setEncoding('utf8');
+        child.stderr.on('data', (chunk) => {
+            stderr = (stderr + chunk).slice(-64_000);
+        });
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            if (sendError)
+                reject(sendError);
+            else if (code === 0)
+                resolveIndex();
+            else {
+                reject(new Error(`Server search indexing failed (${signal ?? code}): ${stderr.trim()}`));
+            }
+        });
+        child.send({ latDir, project, cacheDir }, (error) => {
+            if (error) {
+                sendError = error;
+                child.kill();
+            }
+        });
+    });
+}
+function getPackageVersion(name) {
+    let directory = dirname(fileURLToPath(import.meta.resolve(name)));
+    while (true) {
+        try {
+            const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));
+            if (manifest.name === name && manifest.version)
+                return manifest.version;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const parent = dirname(directory);
+        if (parent === directory)
+            break;
+        directory = parent;
+    }
+    throw new Error(`Could not resolve package version: ${name}`);
+}
+function appModule() {
+    return `import { createEmbedder } from '@lat.md/embed';
+import minilm from '@lat.md/embed-minilm-fp16';
+import express from 'express';
+import { createServerViewApp } from 'lat.md/server';
+const view = createServerViewApp({
+  app: express(),
+  manifestFile: new URL('./server-data/server.json', import.meta.url),
+  indexFile: new URL('./server-data/search.db', import.meta.url),
+  createSearchEngine: () => createEmbedder({ model: minilm }),
+});
+export const close = view.close;
+export default view.app;
+`;
+}
+function packageManifest(latVersion, serverVersion, runtimeVersions) {
+    return `${JSON.stringify({
+        name: 'lat-ui-server',
+        private: true,
+        type: 'module',
+        scripts: { start: 'lat-ui-server app.mjs' },
+        dependencies: {
+            '@lat.md/embed': runtimeVersions.embed,
+            '@lat.md/embed-minilm-fp16': runtimeVersions.model,
+            '../../vendor/lat.md-server/index.js': serverVersion,
+            express: runtimeVersions.express,
+            'lat.md': latVersion,
+        },
+    }, null, 2)}\n`;
+}
+/** Build immutable UI data plus the small portable Express search service. */
+export async function buildServerView(ctx, requestedOutput, options = {}, dependencies = defaultDependencies) {
+    const outputDir = resolve(ctx.projectRoot, requestedOutput);
+    const basePath = normalizeStaticViewBasePath(options.basePath ?? '/');
+    await validateViewBuildOutput(outputDir, ctx.projectRoot, 'Server', options.force);
+    await mkdir(dirname(outputDir), { recursive: true });
+    const stagingDir = await mkdtemp(join(dirname(outputDir), '.lat-server-staging-'));
+    try {
+        const publicDir = join(stagingDir, 'public');
+        const dataDir = join(stagingDir, 'server-data');
+        const staticResult = await dependencies.buildStaticView(ctx, publicDir, {
+            ...options,
+            basePath,
+            searchApi: `${basePath}api/search`,
+        });
+        const project = await dependencies.analyzeMarkdownProject(ctx.latDir, ctx.projectRoot, { executor: 'auto' });
+        await dependencies.buildSearchIndex(ctx.latDir, project, dataDir);
+        const sections = project.sections.map(({ children: _children, ...section }) => ({
+            ...section,
+            documentPath: toPosix(relative(ctx.latDir, resolve(ctx.projectRoot, section.filePath))),
+        }));
+        const manifest = {
+            version: SERVER_VIEW_SCHEMA_VERSION,
+            basePath,
+            sections,
+        };
+        await writeFile(join(dataDir, 'server.json'), `${JSON.stringify(manifest)}\n`);
+        await writeFile(join(stagingDir, 'app.mjs'), appModule());
+        await writeFile(join(stagingDir, 'package.json'), packageManifest(dependencies.getLocalVersion(), dependencies.getLatServerVersion(), {
+            embed: dependencies.getPackageVersion('@lat.md/embed'),
+            express: dependencies.getPackageVersion('express'),
+            model: dependencies.getPackageVersion('@lat.md/embed-minilm-fp16'),
+        }));
+        if (options.force) {
+            await rm(outputDir, { recursive: true, force: true });
+        }
+        await moveViewBuildOutput(stagingDir, outputDir);
+        return { ...staticResult, outputDir };
+    }
+    catch (error) {
+        await removeViewBuildStaging(stagingDir);
+        throw error;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { type LatServerApp } from '../../vendor/lat.md-server/index.js';
+import type { Express } from 'express';
+import type { Section } from '../lattice-model.js';
+import type { CreateSearchEngine } from '../search/embedder.js';
+import type { ViewSearchResponse } from './protocol.js';
+export declare const SERVER_VIEW_SCHEMA_VERSION = 1;
+export type ServerViewSection = Omit<Section, 'children'> & {
+    documentPath: string;
+};
+export type ServerViewManifest = {
+    version: number;
+    basePath: string;
+    sections: ServerViewSection[];
+};
+export type ServerViewAppOptions = {
+    app: Express;
+    manifestFile: string | URL;
+    indexFile: string | URL;
+    cacheDir?: string | URL;
+    createSearchEngine?: CreateSearchEngine;
+    search?: (query: string) => Promise<ViewSearchResponse>;
+};
+export type ServerViewApp = {
+    app: LatServerApp;
+    close: () => Promise<void>;
+};
+/**
+ * Create the portable Express application emitted by `lat ui build server`.
+ * Static assets are also mounted for ordinary Node hosts; platforms with a CDN
+ * can serve `public/` directly and forward only the search route to this app.
+ */
+export declare function createServerViewApp(options: ServerViewAppOptions): ServerViewApp;

package/dist/src/view/server-deployment.js

@@ -0,0 +1,134 @@
+import { INDEX_FILE } from '../search/db.js';
+import { copyFile, mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLatServerApp } from '../../vendor/lat.md-server/index.js';
+import { createPreindexedViewSearch, } from './preindexed-search.js';
+export const SERVER_VIEW_SCHEMA_VERSION = 1;
+function searchRoute(basePath) {
+    return `${basePath === '/' ? '' : basePath.slice(0, -1)}/api/search`;
+}
+function sendJson(res, status, value, headOnly) {
+    const body = JSON.stringify(value);
+    res.statusCode = status;
+    res.setHeader('Cache-Control', 'no-store');
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.setHeader('Content-Length', Buffer.byteLength(body));
+    res.end(headOnly ? undefined : body);
+}
+function localPath(path) {
+    return resolve(typeof path === 'string' ? path : fileURLToPath(path));
+}
+async function readManifest(path) {
+    const manifest = JSON.parse(await readFile(path, 'utf8'));
+    if (manifest.version !== SERVER_VIEW_SCHEMA_VERSION ||
+        typeof manifest.basePath !== 'string' ||
+        !Array.isArray(manifest.sections)) {
+        throw new Error(`Unsupported Lat server build manifest: ${path}`);
+    }
+    return manifest;
+}
+/** Native SQLite handles may outlive close until the Windows process exits. */
+async function removeRuntimeCache(path) {
+    try {
+        await rm(path, {
+            recursive: true,
+            force: true,
+            maxRetries: 10,
+            retryDelay: 150,
+        });
+    }
+    catch (error) {
+        const code = error.code;
+        if (process.platform !== 'win32' ||
+            (code !== 'EBUSY' && code !== 'EPERM' && code !== 'ENOTEMPTY')) {
+            throw error;
+        }
+        // This is an owned OS-temp copy, never the deployed index or user data.
+        // A lingering native lock must not fail otherwise successful shutdown.
+    }
+}
+async function prepareServerView(options, manifestFile, indexFile) {
+    const manifest = await readManifest(manifestFile);
+    let runtimeCacheDir = options.cacheDir ? localPath(options.cacheDir) : '';
+    let ownsCache = false;
+    let search = options.search;
+    let ownedSearch;
+    if (!search) {
+        if (!runtimeCacheDir) {
+            runtimeCacheDir = await mkdtemp(join(tmpdir(), 'lat-ui-search-'));
+            ownsCache = true;
+        }
+        await mkdir(runtimeCacheDir, { recursive: true });
+        try {
+            await copyFile(indexFile, join(runtimeCacheDir, INDEX_FILE));
+        }
+        catch (error) {
+            if (ownsCache) {
+                await removeRuntimeCache(runtimeCacheDir);
+            }
+            throw error;
+        }
+        const documentPaths = new Map();
+        const sections = manifest.sections.map(({ documentPath, ...section }) => {
+            documentPaths.set(section.id.toLowerCase(), documentPath);
+            return { ...section, children: [] };
+        });
+        ownedSearch = await createPreindexedViewSearch(dirname(indexFile), runtimeCacheDir, sections, documentPaths, undefined, options.createSearchEngine);
+        search = ownedSearch;
+    }
+    return {
+        manifest,
+        search,
+        close: async () => {
+            try {
+                await ownedSearch?.close();
+            }
+            finally {
+                if (ownsCache)
+                    await removeRuntimeCache(runtimeCacheDir);
+            }
+        },
+    };
+}
+/**
+ * Create the portable Express application emitted by `lat ui build server`.
+ * Static assets are also mounted for ordinary Node hosts; platforms with a CDN
+ * can serve `public/` directly and forward only the search route to this app.
+ */
+export function createServerViewApp(options) {
+    const manifestFile = localPath(options.manifestFile);
+    const publicDir = resolve(dirname(manifestFile), '..', 'public');
+    const prepared = prepareServerView(options, manifestFile, localPath(options.indexFile));
+    const app = createLatServerApp({
+        publicDir,
+        async handle(req, res, next) {
+            const { manifest, search } = await prepared;
+            const method = req.method ?? 'GET';
+            const headOnly = method === 'HEAD';
+            if (method !== 'GET' && !headOnly)
+                return next();
+            const url = new URL(req.url ?? '/', 'http://lat.local');
+            if (url.pathname !== searchRoute(manifest.basePath))
+                return next();
+            try {
+                const query = (url.searchParams.get('query') ?? '').trim();
+                if (query.length > 500) {
+                    sendJson(res, 400, { error: 'Search query is too long' }, headOnly);
+                    return;
+                }
+                sendJson(res, 200, await search(query), headOnly);
+            }
+            catch (error) {
+                next(error);
+            }
+        },
+    }, options.app);
+    return {
+        app,
+        close: async () => {
+            await (await prepared).close();
+        },
+    };
+}

package/dist/src/view/server-index-worker.d.ts

@@ -0,0 +1,6 @@
+import type { MarkdownProjectAnalysis } from '../project-analysis.js';
+export type ServerIndexRequest = {
+    latDir: string;
+    project: MarkdownProjectAnalysis;
+    cacheDir: string;
+};