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

package/dist/src/view/store.js

@@ -1,21 +1,29 @@
+import { randomUUID } from 'node:crypto';
 import { watch as watchFiles } from 'node:fs';
-import { readFile, realpath } from 'node:fs/promises';
+import { readFile, realpath, rename, rm, stat, writeFile, } from 'node:fs/promises';
 import { basename, extname, isAbsolute, relative, resolve, sep, } from 'node:path';
-import { LAT_REF_RE, scanCodeRefs } from '../code-refs.js';
-import { listLatticeFiles, parseFrontmatter, } from '../lattice.js';
-import { SOURCE_EXTENSIONS } from '../source-parser.js';
-import { toPosix } from '../walk.js';
+import { createCodeReferenceDiscovery, LAT_REF_RE, } from '../code-refs.js';
+import { createExternalResolver, } from '../external-sources.js';
+import { listLatticeFiles } from '../project-discovery.js';
+import { analyzeMarkdownPath } from '../markdown-analysis-cache.js';
+import { isSourceFileExtension } from '../source-formats.js';
+import { toPosix } from '../path.js';
 import { renderMarkdown } from './markdown.js';
 import { buildViewDiagnostics } from './diagnostics.js';
+import { applyDocumentEdit, ViewDocumentConflictError, } from './document-edit.js';
 import { buildGitDiffTree } from './git-diff.js';
 import { buildViewGraph } from './graph.js';
 import { buildViewTableOfContents } from './table-of-contents.js';
 import { emptyViewGitSnapshot, findViewGitRepository, readViewGitSnapshot, sameViewGitSnapshot, } from './git.js';
 import { DEFAULT_VIEW_LOGO_TEXT } from './protocol.js';
-import { createMarkdownWikiLinkResolver, getViewSource, ViewDocumentNotFoundError, } from './repository.js';
-import { buildViewReferenceIndex, parseViewMarkdownFile, renderSectionBackReferences, } from './references.js';
+import { createMarkdownWikiLinkResolver, getViewExternal, getViewSource, ViewDocumentNotFoundError, } from './repository.js';
+import { buildViewReferenceIndex, renderSectionBackReferences, } from './references.js';
+import { rewriteDocumentLink } from './document-route.js';
 const DEFAULT_DEBOUNCE_MS = 75;
 const DEFAULT_GIT_POLL_MS = 2_000;
+const EXTERNAL_REFRESH_PATH = '@lat-external-refresh';
+const DOCUMENT_EDIT_WRITE_ATTEMPTS = 3;
+const DOCUMENT_EDIT_TEMP_PREFIX = '.lat-edit-';
 function isInside(root, candidate) {
     const rel = relative(root, candidate);
     return (rel === '' ||
@@ -25,12 +33,16 @@ function projectPath(projectRoot, path) {
     const normalized = isAbsolute(path) ? relative(projectRoot, path) : path;
     return toPosix(normalized).replace(/^\.\//, '');
 }
+function isInternalLatCachePath(path, latPath) {
+    const cachePath = latPath ? `${latPath}/.cache` : '.cache';
+    return path === cachePath || path.startsWith(`${cachePath}/`);
+}
 function excludedCodePath(projectRoot, path, excludedPaths) {
     const absolutePath = resolve(projectRoot, path);
     return excludedPaths.some((root) => isInside(resolve(root), absolutePath));
 }
 function sourcePath(path) {
-    return SOURCE_EXTENSIONS.has(extname(path).toLowerCase());
+    return isSourceFileExtension(extname(path).toLowerCase());
 }
 function obviouslyIgnoredCodePath(path, latPath) {
     const parts = path.split('/');
@@ -73,9 +85,13 @@ async function loadCodeReferenceFiles(projectRoot, refs) {
     return files;
 }
 async function scanCodeState(projectRoot, excludedPaths = []) {
-    const scan = await scanCodeRefs(projectRoot);
+    const discovery = createCodeReferenceDiscovery(projectRoot);
+    const [scan, sourceFiles] = await Promise.all([
+        discovery.scan(),
+        discovery.listSourceFiles(),
+    ]);
     const allowed = (path) => !excludedCodePath(projectRoot, path, excludedPaths);
-    const files = scan.files.filter(allowed);
+    const files = sourceFiles.filter(allowed);
     const refs = scan.refs.filter((ref) => allowed(ref.file));
     const scope = new Set(files.map((path) => projectPath(projectRoot, path)));
     return {
@@ -83,14 +99,34 @@ async function scanCodeState(projectRoot, excludedPaths = []) {
         scope,
     };
 }
-function viewIndex(latDir, paths, diagnostics, git) {
+function viewIndex(latDir, paths, diagnostics, git, references, external) {
     const files = [...paths].sort();
+    const externalFiles = new Map();
+    for (const target of references.externalByTarget.keys()) {
+        try {
+            const parsed = external.parse(target);
+            if (!parsed)
+                continue;
+            const hash = parsed.identity.indexOf('#');
+            const baseTarget = hash === -1 ? parsed.identity : parsed.identity.slice(0, hash);
+            externalFiles.set(baseTarget, {
+                handle: parsed.handle,
+                path: parsed.resolvedPath,
+                target: baseTarget,
+            });
+        }
+        catch {
+            // Invalid external targets remain diagnostics, not sidebar entries.
+        }
+    }
     const directoryName = basename(latDir);
     const indexName = directoryName.endsWith('.md')
         ? directoryName
         : `${directoryName}.md`;
     return {
         files,
+        externalFiles: [...externalFiles.values()].sort((left, right) => left.handle.localeCompare(right.handle) ||
+            left.path.localeCompare(right.path)),
         entry: files.includes(indexName) ? indexName : (files[0] ?? ''),
         errorCounts: Object.fromEntries([...diagnostics]
             .filter(([, errors]) => errors.length > 0)
@@ -103,21 +139,34 @@ function viewIndex(latDir, paths, diagnostics, git) {
         logoText: DEFAULT_VIEW_LOGO_TEXT,
     };
 }
-async function buildSnapshot(latDir, projectRoot, markdownFiles, codeFiles, git, generation, markdownGeneration) {
+async function buildSnapshot(latDir, projectRoot, markdownFiles, codeFiles, git, generation, markdownGeneration, options) {
     const files = new Map([...markdownFiles].sort(([left], [right]) => left.localeCompare(right)));
     const allSections = [...files.values()].flatMap((file) => file.sections);
-    const diagnostics = await buildViewDiagnostics(files.values(), codeFiles.values(), allSections, projectRoot);
-    const references = buildViewReferenceIndex(files.values(), codeFiles.values(), allSections);
+    const external = await createExternalResolver(latDir, projectRoot, {
+        ignoreLocal: options.externalIgnoreLocal,
+        ca: options.externalCa,
+    });
+    await external.reconcile();
+    const diagnostics = await buildViewDiagnostics(files.values(), codeFiles.values(), allSections, projectRoot, external, latDir);
+    const references = buildViewReferenceIndex(files.values(), codeFiles.values(), allSections, (target) => {
+        try {
+            return external.parse(target)?.identity ?? null;
+        }
+        catch {
+            return target;
+        }
+    });
     return {
         generation,
         markdownGeneration,
         files,
         allSections,
         references,
-        graph: buildViewGraph(files.values(), codeFiles.values(), allSections, diagnostics, git, generation),
+        graph: buildViewGraph(files.values(), codeFiles.values(), allSections, diagnostics, git, generation, external),
         diagnostics,
         git,
-        index: viewIndex(latDir, [...files.keys()], diagnostics, git),
+        index: viewIndex(latDir, [...files.keys()], diagnostics, git, references, external),
+        external,
     };
 }
 /** Own the immutable, incrementally refreshed project snapshot for `lat ui`. */
@@ -133,11 +182,13 @@ export class ViewStore {
     ignoredCodePaths = new Set();
     listeners = new Set();
     watcher = null;
+    externalWatchers = [];
     pendingPaths = new Set();
     debounceTimer = null;
     gitPollTimer = null;
     gitPollQueued = false;
     refreshTail = Promise.resolve();
+    editTail = Promise.resolve();
     closed = false;
     constructor(latDir, projectRoot, realLatDir, snapshot, codeFiles, codeScope, gitRepository, options) {
         this.latDir = latDir;
@@ -168,6 +219,29 @@ export class ViewStore {
         catch (error) {
             process.stderr.write(`lat ui watcher: ${error.message}\n`);
         }
+        this.refreshExternalWatchers();
+    }
+    refreshExternalWatchers() {
+        for (const watcher of this.externalWatchers)
+            watcher.close();
+        this.externalWatchers = [];
+        if (this.options.watch === false)
+            return;
+        const paths = new Set([...this.snapshotValue.external.snapshot.sources.values()]
+            .map((source) => source.localPath)
+            .filter((path) => Boolean(path)));
+        for (const path of paths) {
+            try {
+                const watcher = watchFiles(path, { recursive: true }, () => this.scheduleRefresh(EXTERNAL_REFRESH_PATH));
+                watcher.on('error', (error) => {
+                    process.stderr.write(`lat ui external watcher: ${error.message}\n`);
+                });
+                this.externalWatchers.push(watcher);
+            }
+            catch (error) {
+                process.stderr.write(`lat ui external watcher: ${error.message}\n`);
+            }
+        }
     }
     subscribe(listener) {
         this.listeners.add(listener);
@@ -179,6 +253,15 @@ export class ViewStore {
     getGraph() {
         return this.snapshotValue.graph;
     }
+    async renderSectionOutput(markdown, sectionId) {
+        const snapshot = this.snapshotValue;
+        const section = snapshot.allSections.find((candidate) => candidate.id.toLowerCase() === sectionId.toLowerCase());
+        const requestedPath = section
+            ? toPosix(relative(this.latDir, resolve(this.projectRoot, section.filePath)))
+            : 'section-output.md';
+        const resolver = await createMarkdownWikiLinkResolver(this.latDir, requestedPath, snapshot.allSections, snapshot.references, snapshot.external);
+        return (await renderMarkdown(markdown, requestedPath, resolver)).tree;
+    }
     async getDocument(requestedPath) {
         if (!requestedPath ||
             requestedPath.includes('\\') ||
@@ -191,24 +274,27 @@ export class ViewStore {
         if (!file) {
             throw new ViewDocumentNotFoundError('Markdown document not found');
         }
-        const resolver = await createMarkdownWikiLinkResolver(this.latDir, requestedPath, snapshot.allSections, snapshot.references);
-        const rendered = await renderMarkdown(file.content, requestedPath, resolver, { errors: [...(snapshot.diagnostics.get(requestedPath) ?? [])] }, file.tree);
+        const resolver = await createMarkdownWikiLinkResolver(this.latDir, requestedPath, snapshot.allSections, snapshot.references, snapshot.external);
+        const rendered = await renderMarkdown(file.content, requestedPath, resolver, {
+            errors: [...(snapshot.diagnostics.get(requestedPath) ?? [])],
+            rewriteMarkdownLink: (url) => rewriteDocumentLink(url, requestedPath),
+        });
         const errors = [...(snapshot.diagnostics.get(requestedPath) ?? [])];
         const gitFile = snapshot.git.files.get(requestedPath);
         const gitTree = gitFile
-            ? buildGitDiffTree(gitFile.baseContent, file.content, file.tree)
+            ? buildGitDiffTree(gitFile.baseContent, file.content)
             : null;
         const gitRendered = gitTree
-            ? await renderMarkdown(file.content, requestedPath, resolver, { errors }, gitTree)
+            ? await renderMarkdown(file.content, requestedPath, resolver, {
+                errors,
+                rewriteMarkdownLink: (url) => rewriteDocumentLink(url, requestedPath),
+            }, gitTree)
             : null;
         return {
             path: requestedPath,
             ...rendered,
-            gitHtml: gitRendered?.html ?? null,
-            tableOfContents: buildViewTableOfContents(file.sections, file.tree, {
-                errors,
-                gitTree,
-            }),
+            gitTree: gitRendered?.tree ?? null,
+            tableOfContents: buildViewTableOfContents(file.sections, file.headingTitles, { errors, gitTree }),
             graphNodeIds: Object.fromEntries(snapshot.graph.nodes
                 .filter((node) => node.documentPath === requestedPath && node.kind === 'document')
                 .map((node) => {
@@ -223,20 +309,107 @@ export class ViewStore {
                 return [headingId, node.id];
             })),
             errors,
-            backReferences: await renderSectionBackReferences(snapshot.references, file.sections, this.latDir, this.projectRoot, (path) => createMarkdownWikiLinkResolver(this.latDir, path, snapshot.allSections, snapshot.references)),
+            backReferences: await renderSectionBackReferences(snapshot.references, file.sections, this.latDir, this.projectRoot, (path) => createMarkdownWikiLinkResolver(this.latDir, path, snapshot.allSections, snapshot.references, snapshot.external)),
             frontmatter: {
-                requireCodeMention: parseFrontmatter(file.content).requireCodeMention === true,
+                requireCodeMention: file.frontmatter.requireCodeMention === true,
             },
         };
     }
+    async editableDocumentPath(requestedPath) {
+        if (!requestedPath ||
+            requestedPath.includes('\\') ||
+            isAbsolute(requestedPath) ||
+            !requestedPath.toLowerCase().endsWith('.md') ||
+            !this.snapshotValue.files.has(requestedPath)) {
+            throw new ViewDocumentNotFoundError('Markdown document not found');
+        }
+        let realFile;
+        try {
+            realFile = await realpath(resolve(this.latDir, requestedPath));
+        }
+        catch {
+            throw new ViewDocumentNotFoundError('Markdown document not found');
+        }
+        if (!isInside(this.realLatDir, realFile)) {
+            throw new ViewDocumentNotFoundError('Markdown document not found');
+        }
+        return realFile;
+    }
+    async getDocumentSource(requestedPath) {
+        const path = await this.editableDocumentPath(requestedPath);
+        return { path: requestedPath, content: await readFile(path, 'utf8') };
+    }
+    async getDocumentResource(requestedPath) {
+        if (!requestedPath ||
+            requestedPath.includes('\\') ||
+            isAbsolute(requestedPath) ||
+            requestedPath.toLowerCase().endsWith('.md')) {
+            throw new ViewDocumentNotFoundError('Document resource not found');
+        }
+        let path;
+        try {
+            path = await realpath(resolve(this.latDir, requestedPath));
+            if (!isInside(this.realLatDir, path) || !(await stat(path)).isFile()) {
+                throw new ViewDocumentNotFoundError('Document resource not found');
+            }
+            return await readFile(path);
+        }
+        catch (error) {
+            if (error instanceof ViewDocumentNotFoundError)
+                throw error;
+            throw new ViewDocumentNotFoundError('Document resource not found');
+        }
+    }
+    editDocument(requestedPath, baseContent, editedContent) {
+        const operation = this.editTail.then(async () => {
+            const path = await this.editableDocumentPath(requestedPath);
+            for (let attempt = 0; attempt < DOCUMENT_EDIT_WRITE_ATTEMPTS; attempt++) {
+                const currentContent = await readFile(path, 'utf8');
+                const edit = applyDocumentEdit(baseContent, editedContent, currentContent);
+                if (edit.content === currentContent) {
+                    return { path: requestedPath, ...edit };
+                }
+                const currentStat = await stat(path);
+                const temporaryPath = resolve(this.latDir, `${DOCUMENT_EDIT_TEMP_PREFIX}${process.pid}-${randomUUID()}.tmp`);
+                try {
+                    await writeFile(temporaryPath, edit.content, {
+                        encoding: 'utf8',
+                        flag: 'wx',
+                        mode: currentStat.mode,
+                    });
+                    if ((await readFile(path, 'utf8')) !== currentContent)
+                        continue;
+                    await rename(temporaryPath, path);
+                }
+                finally {
+                    await rm(temporaryPath, { force: true });
+                }
+                await this.refresh([resolve(this.latDir, requestedPath)]);
+                return { path: requestedPath, ...edit };
+            }
+            throw new ViewDocumentConflictError('Could not save because this file kept changing. Your edits are still in the editor.');
+        });
+        this.editTail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
     getSource(requestedPath, requestedSymbol = '', origin, requestedLine = 0) {
         const snapshot = this.snapshotValue;
         return getViewSource(this.latDir, this.projectRoot, requestedPath, requestedSymbol, origin, requestedLine, snapshot.allSections, snapshot.references);
     }
+    getExternal(target) {
+        const snapshot = this.snapshotValue;
+        return getViewExternal(this.latDir, this.projectRoot, target, snapshot.external, snapshot.allSections, snapshot.references);
+    }
     refresh(paths) {
         if (this.closed)
             return Promise.resolve();
-        const normalized = paths.map((path) => path ? projectPath(this.projectRoot, path) : '');
+        const latPath = projectPath(this.projectRoot, this.latDir);
+        const normalized = paths
+            .map((path) => (path ? projectPath(this.projectRoot, path) : ''))
+            .filter((path) => !isInternalLatCachePath(path, latPath));
+        if (paths.length > 0 && normalized.length === 0) {
+            return Promise.resolve();
+        }
         return this.queueRefresh(normalized, false);
     }
     queueRefresh(paths, pollGit) {
@@ -254,13 +427,30 @@ export class ViewStore {
         this.gitPollTimer = null;
         this.watcher?.close();
         this.watcher = null;
+        for (const watcher of this.externalWatchers)
+            watcher.close();
+        this.externalWatchers = [];
+        await this.editTail;
         await this.refreshTail;
         this.listeners.clear();
     }
     scheduleRefresh(path) {
         if (this.closed)
             return;
-        this.pendingPaths.add(path ? projectPath(this.projectRoot, path) : '');
+        if (path !== EXTERNAL_REFRESH_PATH &&
+            basename(path).startsWith(DOCUMENT_EDIT_TEMP_PREFIX) &&
+            path.endsWith('.tmp')) {
+            return;
+        }
+        const normalizedPath = path === EXTERNAL_REFRESH_PATH
+            ? path
+            : path
+                ? projectPath(this.projectRoot, path)
+                : '';
+        const latPath = projectPath(this.projectRoot, this.latDir);
+        if (isInternalLatCachePath(normalizedPath, latPath))
+            return;
+        this.pendingPaths.add(normalizedPath);
         if (this.debounceTimer)
             clearTimeout(this.debounceTimer);
         this.debounceTimer = setTimeout(() => {
@@ -300,12 +490,13 @@ export class ViewStore {
         }
         if (!isInside(this.realLatDir, realFile))
             return null;
-        const content = await readFile(realFile, 'utf8');
-        return parseViewMarkdownFile(absolutePath, content, this.latDir, this.projectRoot);
+        return analyzeMarkdownPath(absolutePath, this.latDir, this.projectRoot);
     }
     async applyRefresh(paths, pollGit) {
         const fullRefresh = paths.includes('');
         const latPath = projectPath(this.projectRoot, this.latDir);
+        const externalChanged = paths.includes(EXTERNAL_REFRESH_PATH) ||
+            paths.includes(`${latPath}/config.local.yaml`);
         const touchesMarkdown = fullRefresh ||
             paths.some((path) => path === latPath || path.startsWith(`${latPath}/`));
         let markdownFiles = new Map(this.snapshotValue.files);
@@ -419,10 +610,12 @@ export class ViewStore {
         if (!markdownChanged &&
             !codeChanged &&
             !gitChanged &&
-            !linkedResourceChanged)
+            !linkedResourceChanged &&
+            !externalChanged)
             return;
         this.codeFiles = codeFiles;
-        this.snapshotValue = await buildSnapshot(this.latDir, this.projectRoot, markdownFiles, codeFiles, git, this.snapshotValue.generation + 1, this.snapshotValue.markdownGeneration + (markdownChanged ? 1 : 0));
+        this.snapshotValue = await buildSnapshot(this.latDir, this.projectRoot, markdownFiles, codeFiles, git, this.snapshotValue.generation + 1, this.snapshotValue.markdownGeneration + (markdownChanged ? 1 : 0), this.options);
+        this.refreshExternalWatchers();
         const change = {
             generation: this.snapshotValue.generation,
             markdownGeneration: this.snapshotValue.markdownGeneration,
@@ -449,8 +642,7 @@ export async function createViewStore(latDir, projectRoot, options = {}) {
         const realFile = await realpath(absolutePath);
         if (!isInside(realLatDir, realFile))
             return;
-        const content = await readFile(realFile, 'utf8');
-        const parsed = parseViewMarkdownFile(absolutePath, content, latDir, projectRoot);
+        const parsed = await analyzeMarkdownPath(absolutePath, latDir, projectRoot);
         markdownFiles.set(parsed.path, parsed);
     }));
     if (markdownFiles.size === 0) {
@@ -465,7 +657,7 @@ export async function createViewStore(latDir, projectRoot, options = {}) {
             process.stderr.write(`lat ui git: ${error.message}\n`);
         }
     }
-    const store = new ViewStore(latDir, projectRoot, realLatDir, await buildSnapshot(latDir, projectRoot, markdownFiles, codeState.files, git, 0, 0), codeState.files, codeState.scope, gitRepository, options);
+    const store = new ViewStore(latDir, projectRoot, realLatDir, await buildSnapshot(latDir, projectRoot, markdownFiles, codeState.files, git, 0, 0, options), codeState.files, codeState.scope, gitRepository, options);
     store.startWatching();
     return store;
 }

package/dist/src/view/table-of-contents.d.ts

@@ -1,9 +1,9 @@
 import type { Root } from 'mdast';
-import { type Section } from '../lattice.js';
+import { type Section } from '../lattice-model.js';
 import type { ViewDocumentError, ViewDocumentTocItem } from './protocol.js';
 export type ViewTableOfContentsOptions = {
     errors?: readonly ViewDocumentError[];
     gitTree?: Root | null;
 };
 /** Project rendered headings into the document's local navigation. */
-export declare function buildViewTableOfContents(sections: Section[], tree: Root, options?: ViewTableOfContentsOptions): ViewDocumentTocItem[];
+export declare function buildViewTableOfContents(sections: Section[], titles: readonly string[], options?: ViewTableOfContentsOptions): ViewDocumentTocItem[];

package/dist/src/view/table-of-contents.js

@@ -1,20 +1,4 @@
-import { visit } from 'unist-util-visit';
-import { flattenSections } from '../lattice.js';
-function headingText(node) {
-    if (!node || typeof node !== 'object')
-        return '';
-    const value = node;
-    if (value.type === 'text' || value.type === 'inlineCode') {
-        return value.value ?? '';
-    }
-    if (value.type === 'image' || value.type === 'imageReference') {
-        return value.alt ?? '';
-    }
-    if (value.type === 'wikiLink') {
-        return value.data?.alias ?? value.value ?? '';
-    }
-    return value.children?.map(headingText).join('') ?? '';
-}
+import { flattenSections } from '../lattice-model.js';
 function sectionAtLine(sections, line) {
     let owner = null;
     for (const section of sections) {
@@ -76,12 +60,8 @@ function gitChangedSections(sections, tree) {
     return changed;
 }
 /** Project rendered headings into the document's local navigation. */
-export function buildViewTableOfContents(sections, tree, options = {}) {
+export function buildViewTableOfContents(sections, titles, options = {}) {
     const flatSections = flattenSections(sections);
-    const titles = [];
-    visit(tree, 'heading', (node) => {
-        titles.push(headingText(node));
-    });
     const errorCounts = new Map();
     for (const error of options.errors ?? []) {
         const owner = sectionAtLine(flatSections, error.line);

package/dist/src/walk.d.ts

@@ -1,6 +1,9 @@
+/** Dependency trees are never project source, even without ignore metadata. */
+export declare const ALWAYS_IGNORED_DIRECTORIES: readonly ["node_modules"];
 /**
- * Walk a directory tree respecting .gitignore rules. Returns relative paths
- * of all non-ignored files, excluding .git/ and dotfiles (e.g. .gitignore).
+ * Walk a directory tree respecting nested .gitignore rules. Directories are
+ * consumed through a bounded queue, and each completed job submits its visible
+ * children back to the pool. Returns sorted project-relative POSIX paths.
  *
  * This is the single entry point for all directory walking in lat.md — both
  * code-ref scanning and lat.md/ index validation use it so .gitignore rules
@@ -15,4 +18,3 @@ export declare function walkEntries(dir: string): Promise<string[]>;
  * a single invariant — stored paths are always POSIX — so downstream lookups
  * (e.g. `buildFileIndex`, ref resolution) work identically on every platform.
  */
-export declare function toPosix(p: string): string;

package/dist/src/walk.js

@@ -1,18 +1,115 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { availableParallelism } from 'node:os';
+import { join } from 'node:path';
 // @ts-expect-error -- no type declarations
 import walk from 'ignore-walk';
+const IgnoreWalker = walk
+    .Walker;
+/** Dependency trees are never project source, even without ignore metadata. */
+export const ALWAYS_IGNORED_DIRECTORIES = ['node_modules'];
+class IgnoreContext extends IgnoreWalker {
+    filterEntry(entry, partial, entryBasename) {
+        const candidate = entryBasename ?? entry;
+        if (candidate
+            .split(/[\\/]/)
+            .some((part) => ALWAYS_IGNORED_DIRECTORIES.includes(part) ||
+            (part.startsWith('.') && part !== '.' && part !== '..'))) {
+            return false;
+        }
+        return super.filterEntry(entry, partial, entryBasename);
+    }
+}
+async function readDirectory(job) {
+    const entries = await readdir(job.path, { withFileTypes: true });
+    if (entries.some((entry) => entry.name === '.gitignore')) {
+        const rules = await readFile(join(job.path, '.gitignore'), 'utf8');
+        job.ignoreContext.onReadIgnoreFile('.gitignore', rules, () => { });
+    }
+    const directories = [];
+    const files = [];
+    for (const entry of entries) {
+        if (entry.isSymbolicLink())
+            continue;
+        if (entry.isDirectory()) {
+            const passDirectory = job.ignoreContext.filterEntry(entry.name, true);
+            if (!passDirectory)
+                continue;
+            const passFile = job.ignoreContext.filterEntry(entry.name);
+            const path = join(job.path, entry.name);
+            directories.push({
+                path,
+                relativePath: job.relativePath
+                    ? `${job.relativePath}/${entry.name}`
+                    : entry.name,
+                ignoreContext: new IgnoreContext({
+                    path,
+                    parent: job.ignoreContext,
+                    ignoreFiles: ['.gitignore'],
+                    exact: passFile || job.ignoreContext.filterEntry(`${entry.name}/`),
+                }),
+            });
+        }
+        else if (job.ignoreContext.filterEntry(entry.name)) {
+            files.push(job.relativePath ? `${job.relativePath}/${entry.name}` : entry.name);
+        }
+    }
+    return { directories, files };
+}
+async function walkWithDirectoryPool(root) {
+    const queue = [root];
+    const files = [];
+    const workerLimit = availableParallelism();
+    let nextJob = 0;
+    let activeWorkers = 0;
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const schedule = () => {
+            if (settled)
+                return;
+            while (activeWorkers < workerLimit && nextJob < queue.length) {
+                const job = queue[nextJob++];
+                activeWorkers++;
+                void readDirectory(job).then((result) => {
+                    files.push(...result.files);
+                    queue.push(...result.directories);
+                    activeWorkers--;
+                    if (activeWorkers === 0 && nextJob === queue.length) {
+                        settled = true;
+                        files.sort((a, b) => a.localeCompare(b, 'en'));
+                        resolve(files);
+                    }
+                    else {
+                        schedule();
+                    }
+                }, (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    reject(error);
+                });
+            }
+        };
+        schedule();
+    });
+}
 /**
- * Walk a directory tree respecting .gitignore rules. Returns relative paths
- * of all non-ignored files, excluding .git/ and dotfiles (e.g. .gitignore).
+ * Walk a directory tree respecting nested .gitignore rules. Directories are
+ * consumed through a bounded queue, and each completed job submits its visible
+ * children back to the pool. Returns sorted project-relative POSIX paths.
  *
  * This is the single entry point for all directory walking in lat.md — both
  * code-ref scanning and lat.md/ index validation use it so .gitignore rules
  * are consistently honored.
  */
 export function walkEntries(dir) {
-    return walk({
+    return walkWithDirectoryPool({
         path: dir,
-        ignoreFiles: ['.gitignore'],
-    }).then((entries) => entries.filter((e) => !e.startsWith('.git/') && !e.startsWith('.')));
+        relativePath: '',
+        ignoreContext: new IgnoreContext({
+            path: dir,
+            ignoreFiles: ['.gitignore'],
+        }),
+    });
 }
 /**
  * Normalize a filesystem path to forward-slash (POSIX) form. Node's
@@ -22,6 +119,3 @@ export function walkEntries(dir) {
  * a single invariant — stored paths are always POSIX — so downstream lookups
  * (e.g. `buildFileIndex`, ref resolution) work identically on every platform.
  */
-export function toPosix(p) {
-    return p.replace(/\\/g, '/');
-}

package/dist/vendor/lat.md-server/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/vendor/lat.md-server/cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { runLatServer } from './index.js';
+const entry = process.argv[2];
+if (!entry)
+    throw new Error('Usage: lat-ui-server <app-module>');
+const module = (await import(pathToFileURL(resolve(entry)).href));
+if (typeof module.default !== 'function') {
+    throw new Error(`${entry} must default-export an Express app`);
+}
+await runLatServer(module.default, { close: module.close });