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

package/dist/src/code-refs.js

@@ -1,15 +1,23 @@
+import { lstatSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
+import { availableParallelism } from 'node:os';
 import { join, posix, relative } from 'node:path';
-import { toPosix, walkEntries } from './walk.js';
+import { isSourceFilePath, SOURCE_FILE_EXTENSIONS } from './source-formats.js';
+import { toPosix } from './path.js';
+import { ALWAYS_IGNORED_DIRECTORIES, walkEntries } from './walk.js';
 /** Glob patterns used to exclude directories/files from code-ref scanning.
  *  Shared between rg args and the TS fallback's walkFiles filter. */
-const EXCLUDE_DIRS = ['lat.md', '.claude'];
-const EXCLUDE_GLOBS = ['*.md'];
-/** Walk project files for code-ref scanning. Uses walkEntries for .gitignore
- *  support, then additionally skips .md files, lat.md/, .claude/, and sub-projects. */
+const EXCLUDE_DIRS = ['lat.md', '.claude', ...ALWAYS_IGNORED_DIRECTORIES];
+const EXCLUDE_GLOBS = ['*.md', '.*', '**/.*'];
+const RG_IGNORE_ARGS = ['--no-require-git', '--ignore-file-case-insensitive'];
+/** Walk supported source files for code-ref scanning. Uses walkEntries for
+ *  .gitignore support, then additionally skips lat.md/, .claude/, generated
+ *  UI output, and sub-projects. */
 export async function walkFiles(dir) {
     const entries = (await walkEntries(dir)).map(toPosix);
+    // Generated UI output carries a .lat-ui-build marker; the whole directory it
+    // marks is build product, not source, so nothing in it is a real code ref.
     const generatedOutputs = new Set(entries
         .filter((entry) => entry.endsWith('/.lat-ui-build'))
         .map((entry) => `${posix.dirname(entry)}/`));
@@ -21,7 +29,7 @@ export async function walkFiles(dir) {
             subProjects.add(e.slice(0, i + 1));
     }
     return entries
-        .filter((e) => !e.endsWith('.md') &&
+        .filter((e) => isSourceFilePath(e) &&
         !e.startsWith('lat.md/') &&
         !e.startsWith('.claude/') &&
         ![...generatedOutputs].some((prefix) => e.startsWith(prefix)) &&
@@ -97,6 +105,9 @@ function extractRefsFromLine(line) {
     }
     return targets;
 }
+function profileScan(profile, label, work) {
+    return profile ? profile.time(label, work) : work();
+}
 /**
  * Run an external command and return stdout, or null if the command is not found
  * or fails.
@@ -105,13 +116,13 @@ function tryExec(cmd, args, cwd) {
     return new Promise((resolve) => {
         execFile(cmd, args, { cwd, maxBuffer: 50 * 1024 * 1024 }, (err, out) => {
             if (err) {
-                // Exit code 1 with no stderr typically means "no matches" for grep/rg
+                // Exit code 1 with no stderr typically means "no matches" for rg.
                 const exitCode = err.code;
                 if (exitCode === 'ENOENT') {
                     resolve(null); // command not found
                     return;
                 }
-                // rg/grep exit 1 = no matches (not an error)
+                // rg exit 1 = no matches (not an error)
                 if ('status' in err &&
                     err.status === 1 &&
                     out === '') {
@@ -134,7 +145,7 @@ async function findSubProjects(projectRoot) {
     // List files inside any lat.md/ dir, then extract unique parent paths.
     // The root lat.md/ is excluded by EXCLUDE_DIRS in the caller, so we only
     // need to find nested ones here — search for files under */lat.md/.
-    const out = await tryExec('rg', ['--files', '--glob', '**/lat.md/**', '.'], projectRoot);
+    const out = await tryExec('rg', ['--files', ...RG_IGNORE_ARGS, '--glob', '**/lat.md/**', '.'], projectRoot);
     if (!out)
         return [];
     const subProjects = new Set();
@@ -152,9 +163,69 @@ async function findSubProjects(projectRoot) {
     }
     return [...subProjects];
 }
-/** Find static UI exports so generated JSON and bundles never become code refs. */
+function nestedLatProjects(paths) {
+    const projects = new Set();
+    for (const path of paths) {
+        const index = path.indexOf('/lat.md/');
+        if (index !== -1)
+            projects.add(path.slice(0, index));
+    }
+    return [...projects];
+}
+function hasDotDirectory(path) {
+    const parts = path.split('/');
+    return parts.slice(0, -1).some((part) => part.startsWith('.'));
+}
+/** List readable regular source files tracked by the enclosing Git repository. */
+async function findGitTrackedSourceFiles(projectRoot) {
+    const out = await tryExec('git', ['ls-files', '--stage', '-z', '--', '.'], projectRoot);
+    if (out === null)
+        return null;
+    const entries = out
+        .split('\0')
+        .filter(Boolean)
+        .flatMap((entry) => {
+        const tab = entry.indexOf('\t');
+        if (tab === -1)
+            return [];
+        const mode = entry.slice(0, entry.indexOf(' '));
+        if (mode !== '100644' && mode !== '100755')
+            return [];
+        return [toPosix(entry.slice(tab + 1))];
+    });
+    const subProjects = nestedLatProjects(entries);
+    const candidates = entries.filter((path) => isSourceFilePath(path) &&
+        !hasDotDirectory(path) &&
+        !path.startsWith('lat.md/') &&
+        !subProjects.some((project) => path === project || path.startsWith(`${project}/`)));
+    return candidates
+        .flatMap((path) => {
+        const absolute = join(projectRoot, path);
+        try {
+            return lstatSync(absolute).isFile() ? [absolute] : [];
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    })
+        .sort((a, b) => a.localeCompare(b, 'en'));
+}
+/**
+ * Directories holding generated UI output, found by the `.lat-ui-build` marker
+ * the build writes beside what it produces. Build product is not source, so a
+ * `@lat:` string inside it is not a reference to anything.
+ */
 async function findGeneratedOutputs(projectRoot) {
-    const out = await tryExec('rg', ['--files', '--hidden', '--glob', '**/.lat-ui-build', '.'], projectRoot);
+    const out = await tryExec('rg', [
+        '--files',
+        '--hidden',
+        ...RG_IGNORE_ARGS,
+        '--glob',
+        '**/.lat-ui-build',
+        '.',
+    ], projectRoot);
     if (!out)
         return [];
     return [
@@ -167,7 +238,7 @@ async function findGeneratedOutputs(projectRoot) {
     ];
 }
 /** Build rg glob exclusion args. */
-function rgExcludeArgs(subProjects, generatedOutputs) {
+function rgExcludeArgs(subProjects, generatedOutputs = []) {
     const args = [];
     for (const dir of EXCLUDE_DIRS)
         args.push('--glob', `!${dir}/`);
@@ -179,44 +250,105 @@ function rgExcludeArgs(subProjects, generatedOutputs) {
         args.push('--glob', `!${output}/`);
     return args;
 }
-/**
- * Try scanning with ripgrep. Returns parsed refs and scanned file list, or null
- * if rg is not available. rg respects .gitignore by default; we add glob
- * exclusions for lat.md/, .claude/, *.md files, and sub-projects.
- */
-async function tryRipgrep(projectRoot) {
-    // Detect sub-projects first so we can exclude them from all rg calls
-    const subProjects = await findSubProjects(projectRoot);
-    const generatedOutputs = await findGeneratedOutputs(projectRoot);
-    const excludes = rgExcludeArgs(subProjects, generatedOutputs);
-    // Search for @lat refs
+/** Build an rg file type from the shared supported-source registry. */
+function rgSourceIncludeArgs() {
+    return [
+        ...SOURCE_FILE_EXTENSIONS.flatMap((extension) => [
+            '--type-add',
+            `latsource:*${extension}`,
+        ]),
+        '--type',
+        'latsource',
+    ];
+}
+async function discoverRipgrepExcludes(projectRoot, profile) {
+    const [subProjects, generatedOutputs] = await Promise.all([
+        profileScan(profile, 'find nested lat.md projects with ripgrep', () => findSubProjects(projectRoot)),
+        profileScan(profile, 'find generated UI output with ripgrep', () => findGeneratedOutputs(projectRoot)),
+    ]);
+    return rgExcludeArgs(subProjects, generatedOutputs);
+}
+function ripgrepPathBatches(paths) {
+    const batches = [];
+    let batch = [];
+    let length = 0;
+    for (const path of paths) {
+        if (batch.length > 0 && length + path.length + 1 > 16_000) {
+            batches.push(batch);
+            batch = [];
+            length = 0;
+        }
+        batch.push(path);
+        length += path.length + 1;
+    }
+    if (batch.length > 0)
+        batches.push(batch);
+    return batches;
+}
+async function runRipgrepBatches(projectRoot, args, paths) {
+    const batches = ripgrepPathBatches(paths);
+    if (batches.length === 0)
+        return [];
+    const results = new Array(batches.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(availableParallelism(), batches.length);
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const index = nextIndex++;
+            if (index >= batches.length)
+                return;
+            results[index] = await tryExec('rg', [...args, '--', ...batches[index]], projectRoot);
+        }
+    }));
+    return results.some((result) => result === null)
+        ? null
+        : results;
+}
+/** Search supported source files for code references with ripgrep. */
+async function tryRipgrepCodeRefs(projectRoot, excludes, profile, files) {
     const searchArgs = [
         '--no-heading',
         '--line-number',
         '--with-filename',
+        ...RG_IGNORE_ARGS,
+        ...rgSourceIncludeArgs(),
         ...excludes,
         '@lat:.*\\[\\[',
-        '.',
     ];
-    const out = await tryExec('rg', searchArgs, projectRoot);
-    if (out === null)
+    const outputs = await profileScan(profile, 'scan @lat references with ripgrep', () => files
+        ? runRipgrepBatches(projectRoot, searchArgs, files.map((file) => toPosix(relative(projectRoot, file))))
+        : tryExec('rg', [...searchArgs, '.'], projectRoot).then((output) => output === null ? null : [output]));
+    if (outputs === null)
+        return null;
+    const refs = outputs.flatMap((output) => parseGrepOutput(output, projectRoot).refs);
+    refs.sort((a, b) => a.file.localeCompare(b.file, 'en') || a.line - b.line);
+    return refs;
+}
+/** Discover the supported source-file scope with ripgrep. */
+async function tryRipgrepSourceFiles(projectRoot, excludes, profile) {
+    const filesOut = await profileScan(profile, 'list source files with ripgrep', () => tryExec('rg', [
+        '--files',
+        ...RG_IGNORE_ARGS,
+        ...rgSourceIncludeArgs(),
+        ...excludes,
+        '.',
+    ], projectRoot));
+    if (filesOut === null)
         return null;
-    const { refs } = parseGrepOutput(out);
-    // List all scanned files (for stats) — rg --files is fast
-    const filesOut = await tryExec('rg', ['--files', ...excludes, '.'], projectRoot);
     const files = (filesOut || '')
         .split('\n')
         .filter(Boolean)
         .map((f) => {
         const clean = toPosix(f).replace(/^\.\//, '');
         return join(projectRoot, clean);
-    });
-    return { refs, files };
+    })
+        .sort((a, b) => a.localeCompare(b, 'en'));
+    return files;
 }
 /**
  * Parse rg output lines (file:line:content) into CodeRef entries.
  */
-function parseGrepOutput(output) {
+function parseGrepOutput(output, projectRoot) {
     const refs = [];
     if (!output.trim())
         return { refs };
@@ -250,30 +382,51 @@ function parseGrepOutput(output) {
     }
     return { refs };
 }
-/**
- * TypeScript fallback: read every file and scan for @lat refs.
- */
-async function scanWithTs(files, projectRoot) {
+async function scanFileWithTs(file, projectRoot) {
+    let content;
+    try {
+        content = await readFile(file, 'utf-8');
+    }
+    catch (err) {
+        return {
+            refs: [],
+            error: `Error: failed to read ${file}: ${err.message}\n`,
+        };
+    }
     const refs = [];
-    for (const file of files) {
-        let content;
-        try {
-            content = await readFile(file, 'utf-8');
-        }
-        catch (err) {
-            process.stderr.write(`Error: failed to read ${file}: ${err.message}\n`);
-            continue;
+    const relativePath = toPosix(relative(projectRoot, file));
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        // Same literal-span and `lat:ignore` filtering the ripgrep path applies in
+        // parseGrepOutput, so both paths agree on what counts as a reference.
+        for (const target of extractRefsFromLine(lines[i])) {
+            refs.push({
+                target,
+                file: relativePath,
+                line: i + 1,
+            });
         }
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            for (const target of extractRefsFromLine(lines[i])) {
-                refs.push({
-                    target,
-                    file: toPosix(relative(projectRoot, file)),
-                    line: i + 1,
-                });
-            }
+    }
+    return { refs };
+}
+/** TypeScript fallback: scan supported source files through a bounded pool. */
+async function scanWithTs(files, projectRoot) {
+    const results = new Array(files.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(availableParallelism(), files.length);
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const index = nextIndex++;
+            if (index >= files.length)
+                return;
+            results[index] = await scanFileWithTs(files[index], projectRoot);
         }
+    }));
+    const refs = [];
+    for (const result of results) {
+        if (result.error)
+            process.stderr.write(result.error);
+        refs.push(...result.refs);
     }
     return refs;
 }
@@ -282,17 +435,45 @@ export async function hasRipgrep() {
     const result = await tryExec('rg', ['--version'], '.');
     return result !== null;
 }
-export async function scanCodeRefs(projectRoot) {
-    // Fast path: use rg for both searching and file listing
-    // _LAT_DISABLE_RG is a test-only escape hatch to force the TS fallback
-    if (process.env._LAT_DISABLE_RG !== '1') {
-        const rgResult = await tryRipgrep(projectRoot);
-        if (rgResult !== null) {
-            return { refs: rgResult.refs, files: rgResult.files, usedRg: true };
+/**
+ * Create a lazy project-scoped discovery API. Code-reference scanning and
+ * source-file inventory are separate operations, but share ripgrep exclusion
+ * discovery and coalesce fallback file walking when both are requested.
+ */
+export function createCodeReferenceDiscovery(projectRoot, profile) {
+    let excludesPromise;
+    let trackedFilesPromise;
+    let sourceFilesPromise;
+    let scanPromise;
+    const ripgrepExcludes = () => (excludesPromise ??= discoverRipgrepExcludes(projectRoot, profile));
+    const trackedFiles = () => (trackedFilesPromise ??= profileScan(profile, 'list tracked source files with git', () => findGitTrackedSourceFiles(projectRoot)));
+    const listSourceFiles = () => (sourceFilesPromise ??= (async () => {
+        const tracked = await trackedFiles();
+        if (tracked !== null)
+            return tracked;
+        if (process.env._LAT_DISABLE_RG !== '1') {
+            const files = await tryRipgrepSourceFiles(projectRoot, await ripgrepExcludes(), profile);
+            if (files !== null)
+                return files;
         }
-    }
-    // Fallback: walk files ourselves and scan with TS
-    const files = await walkFiles(projectRoot);
-    const refs = await scanWithTs(files, projectRoot);
-    return { refs, files, usedRg: false };
+        return profileScan(profile, 'walk project source files', () => walkFiles(projectRoot));
+    })());
+    const scan = () => (scanPromise ??= (async () => {
+        const tracked = await trackedFiles();
+        if (process.env._LAT_DISABLE_RG !== '1') {
+            const refs = await tryRipgrepCodeRefs(projectRoot, tracked === null ? await ripgrepExcludes() : [], profile, tracked ?? undefined);
+            if (refs !== null)
+                return { refs };
+        }
+        const refs = await profileScan(profile, 'scan project files with TypeScript fallback', async () => scanWithTs(await listSourceFiles(), projectRoot));
+        return { refs };
+    })());
+    return { scan, listSourceFiles };
+}
+export async function scanCodeRefs(projectRoot, profile) {
+    return createCodeReferenceDiscovery(projectRoot, profile).scan();
+}
+/** Discover the source files that may contain code references. */
+export async function discoverSourceFiles(projectRoot, profile) {
+    return createCodeReferenceDiscovery(projectRoot, profile).listSourceFiles();
 }

package/dist/src/context.d.ts

@@ -1,3 +1,4 @@
+import type { MarkdownProjectSession } from './project-analysis.js';
 export type Styler = {
     bold: (s: string) => string;
     dim: (s: string) => string;
@@ -16,6 +17,8 @@ export type CmdContext = {
     mode: 'cli' | 'mcp';
     /** The check target was supplied explicitly instead of discovered as lat.md. */
     headless?: boolean;
+    /** Lazy Markdown analysis shared by nested operations in this request. */
+    analysis?: MarkdownProjectSession;
 };
 export type CmdResult = {
     output: string;

package/dist/src/document-formats.d.ts

@@ -0,0 +1,7 @@
+/** Document formats that external sources can resolve by heading. */
+export declare const DOCUMENT_FILE_EXTENSIONS: ReadonlySet<string>;
+export type DocumentFormat = 'asciidoc' | 'markdown' | 'restructuredtext';
+export declare function documentFormat(path: string): DocumentFormat | null;
+export declare function isDocumentPath(path: string): boolean;
+export declare function stripDocumentExtension(path: string): string;
+export declare function documentFormatLabel(format: DocumentFormat): string;

package/dist/src/document-formats.js

@@ -0,0 +1,39 @@
+/** Document formats that external sources can resolve by heading. */
+export const DOCUMENT_FILE_EXTENSIONS = new Set([
+    '.adoc',
+    '.asciidoc',
+    '.md',
+    '.rst',
+]);
+export function documentFormat(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith('.md'))
+        return 'markdown';
+    if (lower.endsWith('.rst'))
+        return 'restructuredtext';
+    if (lower.endsWith('.adoc') || lower.endsWith('.asciidoc')) {
+        return 'asciidoc';
+    }
+    return null;
+}
+export function isDocumentPath(path) {
+    return documentFormat(path) !== null;
+}
+export function stripDocumentExtension(path) {
+    const lower = path.toLowerCase();
+    for (const extension of DOCUMENT_FILE_EXTENSIONS) {
+        if (lower.endsWith(extension))
+            return path.slice(0, -extension.length);
+    }
+    return path;
+}
+export function documentFormatLabel(format) {
+    switch (format) {
+        case 'asciidoc':
+            return 'AsciiDoc';
+        case 'markdown':
+            return 'Markdown';
+        case 'restructuredtext':
+            return 'reStructuredText';
+    }
+}

package/dist/src/extensions/alert-marker.d.ts

@@ -0,0 +1,25 @@
+import type { Data, Literal, Root } from 'mdast';
+import type { Options } from 'mdast-util-to-markdown';
+export declare const ALERT_KINDS: readonly ["NOTE", "TIP", "IMPORTANT", "WARNING", "CAUTION"];
+export type AlertKind = (typeof ALERT_KINDS)[number];
+export interface AlertMarker extends Literal {
+    type: 'alertMarker';
+    value: AlertKind;
+    data?: Data;
+}
+/** Promote GitHub alert markers so serialization does not escape their brackets. */
+export declare function markAlertMarkers(tree: Root): void;
+export declare function alertMarkerToMarkdown(): Options;
+declare module 'mdast' {
+    interface RootContentMap {
+        alertMarker: AlertMarker;
+    }
+    interface PhrasingContentMap {
+        alertMarker: AlertMarker;
+    }
+}
+declare module 'mdast-util-to-markdown' {
+    interface ConstructNameMap {
+        alertMarker: 'alertMarker';
+    }
+}

package/dist/src/extensions/alert-marker.js

@@ -0,0 +1,55 @@
+import { visit } from 'unist-util-visit';
+export const ALERT_KINDS = [
+    'NOTE',
+    'TIP',
+    'IMPORTANT',
+    'WARNING',
+    'CAUTION',
+];
+const ALERT_PATTERN = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\](?:\r?\n|$)/;
+/** Promote GitHub alert markers so serialization does not escape their brackets. */
+export function markAlertMarkers(tree) {
+    visit(tree, 'blockquote', (node) => {
+        const firstBlock = node.children[0];
+        if (firstBlock?.type !== 'paragraph')
+            return;
+        const firstInline = firstBlock.children[0];
+        if (firstInline?.type !== 'text')
+            return;
+        const match = firstInline.value.match(ALERT_PATTERN);
+        if (!match)
+            return;
+        const marker = {
+            type: 'alertMarker',
+            value: match[1],
+        };
+        const start = firstInline.position?.start;
+        if (start) {
+            const markerLength = match[0].replace(/\r?\n$/, '').length;
+            marker.position = {
+                start,
+                end: {
+                    line: start.line,
+                    column: start.column + markerLength,
+                    ...(start.offset === undefined
+                        ? {}
+                        : { offset: start.offset + markerLength }),
+                },
+            };
+        }
+        const remaining = firstInline.value.slice(match[0].length);
+        const replacement = [marker];
+        if (remaining !== '')
+            replacement.push({ type: 'text', value: remaining });
+        firstBlock.children.splice(0, 1, ...replacement);
+    });
+}
+function alertMarkerHandler(node, _parent, state, _info) {
+    const exit = state.enter('alertMarker');
+    const value = `[!${node.value}]\n`;
+    exit();
+    return value;
+}
+export function alertMarkerToMarkdown() {
+    return { handlers: { alertMarker: alertMarkerHandler } };
+}

package/dist/src/external-documents.d.ts

@@ -0,0 +1,56 @@
+import { type Section } from './lattice-model.js';
+import { type DocumentFormat } from './document-formats.js';
+import type { ParserImportObserver } from './parser-import.js';
+import type { ViewDocumentTree } from './view/protocol.js';
+export type ExternalDocumentSection = {
+    title: string;
+    depth: number;
+    anchor: string;
+    aliases: string[];
+    hierarchy: string[];
+    startLine: number;
+    endLine: number;
+};
+/** Serializable document facts retained after a format parser discards its AST. */
+export type ExternalDocumentAnalysis = {
+    format: DocumentFormat;
+    title: string;
+    sections: ExternalDocumentSection[];
+};
+export type ExternalDocumentCacheStatus = 'disabled' | 'hit' | 'miss';
+export type ExternalDocumentAnalysisTimings = {
+    hashMs: number;
+    cacheReadMs: number;
+    cacheWriteMs: number;
+    parseMs: number;
+    cacheStatus: ExternalDocumentCacheStatus;
+};
+export type ExternalDocumentFileAnalysis = {
+    path: string;
+    document: ExternalDocumentAnalysis;
+    timings: ExternalDocumentAnalysisTimings;
+};
+export type AnalyzeExternalDocumentOptions = {
+    identity?: string;
+    cache?: boolean;
+    runtime?: ExternalDocumentParserRuntime;
+    onFileAnalyzed?: (analysis: ExternalDocumentFileAnalysis) => void;
+    onParserImport?: ParserImportObserver;
+};
+/** Accept legacy AsciiDoc source listings whose delimiter lengths do not match. */
+export declare function asciidocCompatibleContent(content: string): string;
+export declare function analyzeExternalDocument(path: string, content: string, onParserImport?: ParserImportObserver, importDetail?: string): Promise<ExternalDocumentAnalysis>;
+/** Request-scoped owner for external document parser work. */
+export declare class ExternalDocumentParserRuntime {
+    readonly analyses: Map<string, Promise<ExternalDocumentFileAnalysis>>;
+    clear(): void;
+}
+/** Return the shared parsed-cache path for one external document identity. */
+export declare function externalDocumentAnalysisCachePath(latDir: string, identity: string): string;
+/** Analyze an external document through the shared persistent parser cache. */
+export declare function analyzeExternalDocumentCached(path: string, content: string, latDir: string, options?: AnalyzeExternalDocumentOptions): Promise<ExternalDocumentFileAnalysis>;
+export declare function findExternalDocumentSection(analysis: ExternalDocumentAnalysis, fragment: string): ExternalDocumentSection | undefined;
+/** Project format-neutral document sections into the existing browser TOC model. */
+export declare function externalDocumentSections(path: string, analysis: ExternalDocumentAnalysis): Section[];
+/** Add zero-size alias anchors to the normalized external document tree. */
+export declare function addExternalDocumentAliasAnchors(source: ViewDocumentTree, analysis: ExternalDocumentAnalysis): ViewDocumentTree;