@plebeiantech/lat.md 0.12.3-fork.1

package/dist/src/view/client/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="color-scheme" content="light dark" />
+    <title>lat.md</title>
+    <script type="module" crossorigin src="/assets/index-xm2_px4q.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B0n0u03y.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

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

@@ -0,0 +1,5 @@
+import { type Section } from '../lattice.js';
+import type { ViewDocumentError } from './protocol.js';
+import type { ViewCodeReferenceFile, ViewParsedMarkdownFile } from './references.js';
+/** Build per-document validation errors entirely from the current view snapshot. */
+export declare function buildViewDiagnostics(markdownFiles: Iterable<ViewParsedMarkdownFile>, codeFiles: Iterable<ViewCodeReferenceFile>, allSections: Section[], projectRoot: string): Promise<ReadonlyMap<string, readonly ViewDocumentError[]>>;

package/dist/src/view/diagnostics.js

@@ -0,0 +1,171 @@
+import { existsSync } from 'node:fs';
+import { extname, relative, resolve, dirname } from 'node:path';
+import { ambiguousRefMessage, sourceRefError } from '../cli/check.js';
+import { buildFileIndex, buildSectionSlugIndex, flattenSections, parseFrontmatter, resolveRef, } from '../lattice.js';
+import { clearSymbolCache } from '../source-parser.js';
+import { toPosix } from '../walk.js';
+const MAX_BODY_LENGTH = 250;
+function decodeLinkPart(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function localLinkTarget(url) {
+    const value = url.trim();
+    if (value.startsWith('/'))
+        return null;
+    const windowsDrivePath = /^[a-zA-Z]:\\/.test(value);
+    if (!windowsDrivePath && /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)) {
+        return null;
+    }
+    const queryAt = value.indexOf('?');
+    const fragmentAt = value.indexOf('#');
+    const pathEnd = Math.min(queryAt === -1 ? value.length : queryAt, fragmentAt === -1 ? value.length : fragmentAt);
+    const rawPath = value.slice(0, pathEnd);
+    const path = rawPath === '' ? null : decodeLinkPart(rawPath);
+    const fragment = fragmentAt === -1 ? null : decodeLinkPart(value.slice(fragmentAt + 1));
+    if (rawPath === '' && fragment === null)
+        return null;
+    if (path?.includes('\\'))
+        return { kind: 'invalid-backslash' };
+    return { kind: 'target', path, fragment };
+}
+function bodyTextLength(body) {
+    return body.replace(/\[\[[^\]]*\]\]/g, '').length;
+}
+function error(line, target, message, options = {}) {
+    return {
+        anchor: options.anchor || `user-content-markdown-error-${line}`,
+        line,
+        marker: options.marker ?? 'target',
+        message,
+        target,
+    };
+}
+function addError(errors, path, diagnostic) {
+    const fileErrors = errors.get(path) ?? [];
+    const duplicate = fileErrors.some((candidate) => candidate.line === diagnostic.line &&
+        candidate.message === diagnostic.message);
+    if (!duplicate) {
+        let unique = diagnostic;
+        if (diagnostic.marker === 'target' &&
+            fileErrors.some((candidate) => candidate.anchor === diagnostic.anchor)) {
+            let suffix = 2;
+            while (fileErrors.some((candidate) => candidate.anchor === `${diagnostic.anchor}-${suffix}`)) {
+                suffix++;
+            }
+            unique = { ...diagnostic, anchor: `${diagnostic.anchor}-${suffix}` };
+        }
+        fileErrors.push(unique);
+    }
+    errors.set(path, fileErrors);
+}
+async function markdownLinkError(file, filesByAbsolutePath, link, projectRoot) {
+    const target = localLinkTarget(link.url);
+    if (target === null)
+        return null;
+    if (target.kind === 'invalid-backslash') {
+        return error(link.line, link.url, `invalid ${link.kind} (${link.url}) — backslashes are not path separators in Markdown; use "/" instead`);
+    }
+    const absolutePath = target.path
+        ? resolve(dirname(file.absolutePath), target.path)
+        : file.absolutePath;
+    if (!existsSync(absolutePath)) {
+        return error(link.line, link.url, `broken ${link.kind} (${link.url}) — file "${toPosix(relative(projectRoot, absolutePath))}" not found`);
+    }
+    if (!target.fragment ||
+        extname(absolutePath).toLowerCase() !== '.md' ||
+        link.kind === 'image') {
+        return null;
+    }
+    const destination = filesByAbsolutePath.get(resolve(absolutePath));
+    if (!destination)
+        return null;
+    const headings = new Set(flattenSections(destination.sections).map((section) => section.githubSlug));
+    if (headings.has(target.fragment))
+        return null;
+    return error(link.line, link.url, `broken link (${link.url}) — heading "#${target.fragment}" not found in "${destination.path}"`);
+}
+/** Build per-document validation errors entirely from the current view snapshot. */
+export async function buildViewDiagnostics(markdownFiles, codeFiles, allSections, projectRoot) {
+    clearSymbolCache();
+    const files = [...markdownFiles];
+    const errors = new Map();
+    const sections = flattenSections(allSections);
+    const sectionIds = new Set(sections.map((section) => section.id.toLowerCase()));
+    const fileIndex = buildFileIndex(allSections);
+    const slugIndex = buildSectionSlugIndex(allSections);
+    const filesByAbsolutePath = new Map(files.map((file) => [resolve(file.absolutePath), file]));
+    for (const file of files) {
+        for (const ref of file.wikiRefs) {
+            const resolved = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
+            let message = null;
+            if (resolved.ambiguous) {
+                message = ambiguousRefMessage(ref.target, resolved.ambiguous, resolved.suggested);
+            }
+            else if (!sectionIds.has(resolved.resolved.toLowerCase())) {
+                message = await sourceRefError(ref.target, projectRoot);
+            }
+            if (message)
+                addError(errors, file.path, error(ref.line, ref.target, message));
+        }
+        const links = new Map();
+        for (const link of file.validationLinks) {
+            if ('identifier' in link) {
+                addError(errors, file.path, error(link.line, link.identifier, `undefined ${link.kind === 'imageReference' ? 'image' : 'link'} reference (${link.source}) — definition "[${link.identifier}]" not found`, { marker: 'line' }));
+            }
+            else if (link.kind !== 'definition') {
+                links.set(`${link.kind}:${link.line}:${link.url}`, {
+                    kind: link.kind,
+                    line: link.line,
+                    url: link.url,
+                });
+            }
+        }
+        for (const link of file.markdownLinks) {
+            links.set(`${link.kind}:${link.line}:${link.url}`, link);
+        }
+        for (const link of links.values()) {
+            const diagnostic = await markdownLinkError(file, filesByAbsolutePath, link, projectRoot);
+            if (diagnostic)
+                addError(errors, file.path, diagnostic);
+        }
+        for (const section of flattenSections(file.sections)) {
+            if (!section.firstParagraph) {
+                addError(errors, file.path, error(section.startLine, section.id, `section "${section.id}" has no leading paragraph. Every section must start with a brief overview (≤${MAX_BODY_LENGTH} chars).`, { anchor: section.githubSlug, marker: 'heading' }));
+                continue;
+            }
+            const length = bodyTextLength(section.firstParagraph);
+            if (length > MAX_BODY_LENGTH) {
+                addError(errors, file.path, error(section.startLine, section.id, `section "${section.id}" leading paragraph is ${length} characters (max ${MAX_BODY_LENGTH}, excluding [[wiki links]]).`, { anchor: section.githubSlug, marker: 'heading' }));
+            }
+        }
+    }
+    const mentionedSections = new Set();
+    for (const file of codeFiles) {
+        for (const ref of file.refs) {
+            const resolved = resolveRef(ref.target, sectionIds, fileIndex, slugIndex);
+            if (!resolved.ambiguous &&
+                sectionIds.has(resolved.resolved.toLowerCase())) {
+                mentionedSections.add(resolved.resolved.toLowerCase());
+            }
+        }
+    }
+    for (const file of files) {
+        if (!parseFrontmatter(file.content).requireCodeMention)
+            continue;
+        for (const section of flattenSections(file.sections)) {
+            if (section.children.length === 0 &&
+                !mentionedSections.has(section.id.toLowerCase())) {
+                addError(errors, file.path, error(section.startLine, section.id, `section "${section.id}" requires a code mention but none found`, { anchor: section.githubSlug, marker: 'heading' }));
+            }
+        }
+    }
+    return new Map([...errors].map(([path, diagnostics]) => [
+        path,
+        diagnostics.sort((left, right) => left.line - right.line || left.message.localeCompare(right.message)),
+    ]));
+}

package/dist/src/view/git-diff.d.ts

@@ -0,0 +1,3 @@
+import type { Root } from 'mdast';
+/** Build a renderable Markdown tree with HEAD deletions and local additions. */
+export declare function buildGitDiffTree(baseMarkdown: string, currentMarkdown: string, currentTree?: Root): Root;

package/dist/src/view/git-diff.js

@@ -0,0 +1,255 @@
+import { parse } from '../parser.js';
+const MAX_DIFF_CELLS = 1_000_000;
+const WORDS = /\s+|[\p{L}\p{N}_]+|[^\s\p{L}\p{N}_]+/gu;
+function sequenceDiff(oldValues, newValues, key) {
+    const oldKeys = oldValues.map(key);
+    const newKeys = newValues.map(key);
+    if (oldKeys.length * newKeys.length > MAX_DIFF_CELLS) {
+        let prefix = 0;
+        while (prefix < oldKeys.length &&
+            prefix < newKeys.length &&
+            oldKeys[prefix] === newKeys[prefix]) {
+            prefix++;
+        }
+        let suffix = 0;
+        while (suffix < oldKeys.length - prefix &&
+            suffix < newKeys.length - prefix &&
+            oldKeys[oldKeys.length - suffix - 1] ===
+                newKeys[newKeys.length - suffix - 1]) {
+            suffix++;
+        }
+        return [
+            ...oldValues.slice(0, prefix).map((oldValue, index) => ({
+                kind: 'same',
+                oldValue,
+                newValue: newValues[index],
+            })),
+            ...oldValues
+                .slice(prefix, oldValues.length - suffix)
+                .map((value) => ({ kind: 'removed', value })),
+            ...newValues
+                .slice(prefix, newValues.length - suffix)
+                .map((value) => ({ kind: 'added', value })),
+            ...oldValues.slice(oldValues.length - suffix).map((oldValue, index) => ({
+                kind: 'same',
+                oldValue,
+                newValue: newValues[newValues.length - suffix + index],
+            })),
+        ];
+    }
+    const rows = Array.from({ length: oldKeys.length + 1 }, () => new Uint32Array(newKeys.length + 1));
+    for (let oldIndex = oldKeys.length - 1; oldIndex >= 0; oldIndex--) {
+        for (let newIndex = newKeys.length - 1; newIndex >= 0; newIndex--) {
+            rows[oldIndex][newIndex] =
+                oldKeys[oldIndex] === newKeys[newIndex]
+                    ? rows[oldIndex + 1][newIndex + 1] + 1
+                    : Math.max(rows[oldIndex + 1][newIndex], rows[oldIndex][newIndex + 1]);
+        }
+    }
+    const changes = [];
+    let oldIndex = 0;
+    let newIndex = 0;
+    while (oldIndex < oldValues.length || newIndex < newValues.length) {
+        if (oldIndex < oldValues.length &&
+            newIndex < newValues.length &&
+            oldKeys[oldIndex] === newKeys[newIndex]) {
+            changes.push({
+                kind: 'same',
+                oldValue: oldValues[oldIndex++],
+                newValue: newValues[newIndex++],
+            });
+        }
+        else if (newIndex < newValues.length &&
+            (oldIndex === oldValues.length ||
+                rows[oldIndex][newIndex + 1] > rows[oldIndex + 1][newIndex])) {
+            changes.push({ kind: 'added', value: newValues[newIndex++] });
+        }
+        else {
+            changes.push({ kind: 'removed', value: oldValues[oldIndex++] });
+        }
+    }
+    return changes;
+}
+function withChildren(node) {
+    return 'children' in node && Array.isArray(node.children);
+}
+function wikiText(node) {
+    return node.data.alias ?? node.value;
+}
+function nodeText(node) {
+    if (node.type === 'wikiLink')
+        return wikiText(node);
+    if ('value' in node && typeof node.value === 'string')
+        return node.value;
+    return withChildren(node) ? node.children.map(nodeText).join('') : '';
+}
+function wrapperSignature(node) {
+    switch (node.type) {
+        case 'link':
+            return `link:${node.url}:${node.title ?? ''}`;
+        case 'linkReference':
+            return `link-reference:${node.identifier}:${node.referenceType}`;
+        default:
+            return node.type;
+    }
+}
+function inlineUnits(node, prefix = '') {
+    if (node.type === 'text') {
+        return [...node.value.matchAll(WORDS)].map((match) => ({
+            key: `${prefix}text:${match[0]}`,
+            node: { ...structuredClone(node), value: match[0] },
+        }));
+    }
+    if (node.type === 'wikiLink') {
+        const wiki = node;
+        return [
+            {
+                key: `${prefix}wiki:${wiki.value}:${wiki.data.alias ?? ''}`,
+                node: structuredClone(node),
+            },
+        ];
+    }
+    if (withChildren(node)) {
+        const nextPrefix = `${prefix}${wrapperSignature(node)}>`;
+        return node.children.flatMap((child) => inlineUnits(child, nextPrefix).map((unit) => ({
+            key: unit.key,
+            node: {
+                ...structuredClone(node),
+                children: [unit.node],
+            },
+        })));
+    }
+    return [
+        {
+            key: `${prefix}${wrapperSignature(node)}:${nodeText(node)}`,
+            node: structuredClone(node),
+        },
+    ];
+}
+function wrapInline(node, kind) {
+    return {
+        type: 'emphasis',
+        data: {
+            hName: kind === 'added' ? 'ins' : 'del',
+            hProperties: { className: [`git-${kind}`] },
+        },
+        children: [node],
+    };
+}
+function diffInline(oldChildren, newChildren) {
+    const oldUnits = oldChildren.flatMap((child) => inlineUnits(child));
+    const newUnits = newChildren.flatMap((child) => inlineUnits(child));
+    return sequenceDiff(oldUnits, newUnits, (unit) => unit.key).map((change) => {
+        switch (change.kind) {
+            case 'same':
+                return change.newValue.node;
+            case 'added':
+                return wrapInline(change.value.node, 'added');
+            case 'removed':
+                return wrapInline(change.value.node, 'removed');
+        }
+    });
+}
+function sourceForNode(markdown, node) {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    return start === undefined || end === undefined
+        ? `${node.type}:${nodeText(node)}`
+        : `${node.type}:${markdown.slice(start, end)}`;
+}
+function addClass(node, kind) {
+    const result = structuredClone(node);
+    const properties = result.data?.hProperties ?? {};
+    const current = properties.className;
+    const classes = Array.isArray(current)
+        ? current.map(String)
+        : current
+            ? [String(current)]
+            : [];
+    classes.push(`git-${kind}`);
+    result.data = {
+        ...result.data,
+        hName: kind === 'removed' && result.type === 'heading'
+            ? 'div'
+            : result.data?.hName,
+        hProperties: { ...properties, className: classes },
+    };
+    if (kind === 'removed')
+        stripPositions(result);
+    return result;
+}
+function stripPositions(node) {
+    delete node.position;
+    if (withChildren(node))
+        node.children.forEach(stripPositions);
+}
+function pairedNode(oldNode, newNode, oldMarkdown, newMarkdown) {
+    if (oldNode.type !== newNode.type)
+        return null;
+    if ((newNode.type === 'heading' || newNode.type === 'paragraph') &&
+        withChildren(oldNode) &&
+        withChildren(newNode)) {
+        return {
+            ...structuredClone(newNode),
+            children: diffInline(oldNode.children, newNode.children),
+        };
+    }
+    if ((newNode.type === 'blockquote' ||
+        newNode.type === 'list' ||
+        newNode.type === 'listItem') &&
+        withChildren(oldNode) &&
+        withChildren(newNode)) {
+        return {
+            ...structuredClone(newNode),
+            children: diffBlocks(oldNode.children, newNode.children, oldMarkdown, newMarkdown),
+        };
+    }
+    return null;
+}
+function diffBlocks(oldNodes, newNodes, oldMarkdown, newMarkdown) {
+    const changes = sequenceDiff(oldNodes, newNodes, (node) => oldNodes.includes(node)
+        ? sourceForNode(oldMarkdown, node)
+        : sourceForNode(newMarkdown, node));
+    const output = [];
+    for (let index = 0; index < changes.length;) {
+        const change = changes[index];
+        if (change.kind === 'same') {
+            output.push(structuredClone(change.newValue));
+            index++;
+            continue;
+        }
+        const removed = [];
+        const added = [];
+        while (index < changes.length && changes[index].kind !== 'same') {
+            const pending = changes[index++];
+            if (pending.kind === 'removed')
+                removed.push(pending.value);
+            if (pending.kind === 'added')
+                added.push(pending.value);
+        }
+        const paired = Math.min(removed.length, added.length);
+        let pairedCount = 0;
+        while (pairedCount < paired) {
+            const node = pairedNode(removed[pairedCount], added[pairedCount], oldMarkdown, newMarkdown);
+            if (!node)
+                break;
+            output.push(node);
+            pairedCount++;
+        }
+        output.push(...removed.slice(pairedCount).map((node) => addClass(node, 'removed')), ...added.slice(pairedCount).map((node) => addClass(node, 'added')));
+    }
+    return output;
+}
+/** Build a renderable Markdown tree with HEAD deletions and local additions. */
+export function buildGitDiffTree(baseMarkdown, currentMarkdown, currentTree) {
+    const oldTree = parse(baseMarkdown);
+    const newTree = currentTree
+        ? structuredClone(currentTree)
+        : parse(currentMarkdown);
+    const oldNodes = oldTree.children.filter((node) => node.type !== 'yaml');
+    const newNodes = newTree.children.filter((node) => node.type !== 'yaml');
+    return {
+        type: 'root',
+        children: diffBlocks(oldNodes, newNodes, baseMarkdown, currentMarkdown),
+    };
+}

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

@@ -0,0 +1,22 @@
+import type { ViewGitFileStatus } from './protocol.js';
+export type ViewGitFileSnapshot = {
+    status: ViewGitFileStatus;
+    baseContent: string;
+};
+export type ViewGitSnapshot = {
+    available: boolean;
+    files: ReadonlyMap<string, ViewGitFileSnapshot>;
+};
+export type ViewGitRepository = {
+    root: string;
+    latRelative: string;
+};
+export type ViewGitRunner = (cwd: string, args: string[]) => Promise<string>;
+/** Find the Git worktree containing the active lat.md directory. */
+export declare function findViewGitRepository(projectRoot: string, latDir: string, runner?: ViewGitRunner): Promise<ViewGitRepository | null>;
+/** Read the cached HEAD-to-working-tree state for visible lat.md files. */
+export declare function readViewGitSnapshot(repository: ViewGitRepository, currentFiles: ReadonlyMap<string, {
+    content: string;
+}>, runner?: ViewGitRunner): Promise<ViewGitSnapshot>;
+export declare function emptyViewGitSnapshot(): ViewGitSnapshot;
+export declare function sameViewGitSnapshot(left: ViewGitSnapshot, right: ViewGitSnapshot): boolean;

package/dist/src/view/git.js

@@ -0,0 +1,193 @@
+import { execFile } from 'node:child_process';
+import { realpath } from 'node:fs/promises';
+import { isAbsolute, relative, sep } from 'node:path';
+import { toPosix } from '../walk.js';
+const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+const MAX_GIT_OUTPUT = 50 * 1024 * 1024;
+function runGit(cwd, args) {
+    return new Promise((resolve, reject) => {
+        execFile('git', args, { cwd, encoding: 'utf8', maxBuffer: MAX_GIT_OUTPUT }, (error, stdout) => (error ? reject(error) : resolve(stdout)));
+    });
+}
+function inside(root, candidate) {
+    const path = relative(root, candidate);
+    return (path === '' ||
+        (!isAbsolute(path) && path !== '..' && !path.startsWith(`..${sep}`)));
+}
+/** Find the Git worktree containing the active lat.md directory. */
+export async function findViewGitRepository(projectRoot, latDir, runner = runGit) {
+    try {
+        const output = await runner(projectRoot, [
+            'rev-parse',
+            '--show-toplevel',
+            '--is-inside-work-tree',
+        ]);
+        const lines = output.trim().split('\n');
+        const reportedRoot = lines[0]?.trim();
+        if (!reportedRoot || lines.at(-1)?.trim() !== 'true') {
+            return null;
+        }
+        const [root, realLatDir] = await Promise.all([
+            realpath(reportedRoot),
+            realpath(latDir),
+        ]);
+        if (!inside(root, realLatDir))
+            return null;
+        return {
+            root,
+            latRelative: toPosix(relative(root, realLatDir)),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function vaultPath(repository, path) {
+    const normalized = toPosix(path);
+    if (!repository.latRelative)
+        return normalized;
+    const prefix = `${repository.latRelative}/`;
+    return normalized.startsWith(prefix) ? normalized.slice(prefix.length) : null;
+}
+function statusFiles(repository, output) {
+    const files = new Map();
+    const entries = output.split('\0');
+    for (let index = 0; index < entries.length; index++) {
+        const entry = entries[index];
+        if (!entry || entry.length < 4)
+            continue;
+        const status = entry.slice(0, 2);
+        const path = vaultPath(repository, entry.slice(3));
+        if (path) {
+            files.set(path, status.includes('?') || status.includes('A') ? 'new' : 'modified');
+        }
+        if (status.includes('R') || status.includes('C'))
+            index++;
+    }
+    return files;
+}
+function patchPath(line) {
+    const path = line.slice(4);
+    if (path === '/dev/null')
+        return null;
+    return path.startsWith('b/') ? path.slice(2) : path;
+}
+/** Reconstruct each tracked file's HEAD content from one full-context diff. */
+function baseContentsFromPatch(output) {
+    const contents = new Map();
+    let path = null;
+    let oldLines = [];
+    let inHunk = false;
+    let sawFile = false;
+    let oldEndsWithNewline = true;
+    let previousWasOldLine = false;
+    const finish = () => {
+        if (path && sawFile) {
+            contents.set(path, `${oldLines.join('\n')}${oldLines.length > 0 && oldEndsWithNewline ? '\n' : ''}`);
+        }
+        path = null;
+        oldLines = [];
+        inHunk = false;
+        sawFile = false;
+        oldEndsWithNewline = true;
+        previousWasOldLine = false;
+    };
+    for (const line of output.split('\n')) {
+        if (line.startsWith('diff --git ')) {
+            finish();
+            sawFile = true;
+            continue;
+        }
+        if (sawFile && line.startsWith('+++ ')) {
+            path = patchPath(line);
+            continue;
+        }
+        if (sawFile && line.startsWith('@@ ')) {
+            inHunk = true;
+            previousWasOldLine = false;
+            continue;
+        }
+        if (!inHunk)
+            continue;
+        if (line === '\') {
+            if (previousWasOldLine)
+                oldEndsWithNewline = false;
+            continue;
+        }
+        const marker = line[0];
+        previousWasOldLine = marker === ' ' || marker === '-';
+        if (previousWasOldLine)
+            oldLines.push(line.slice(1));
+    }
+    finish();
+    return contents;
+}
+async function hasHead(repository, runner) {
+    try {
+        await runner(repository.root, ['rev-parse', '--verify', 'HEAD']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Read the cached HEAD-to-working-tree state for visible lat.md files. */
+export async function readViewGitSnapshot(repository, currentFiles, runner = runGit) {
+    const baseline = (await hasHead(repository, runner)) ? 'HEAD' : EMPTY_TREE;
+    const pathspec = repository.latRelative || '.';
+    const relative = repository.latRelative
+        ? [`--relative=${repository.latRelative}`]
+        : [];
+    const [statusOutput, patchOutput] = await Promise.all([
+        runner(repository.root, [
+            'status',
+            '--porcelain=v1',
+            '-z',
+            '--untracked-files=all',
+            '--',
+            pathspec,
+        ]),
+        runner(repository.root, [
+            '-c',
+            'core.quotePath=false',
+            'diff',
+            '--no-ext-diff',
+            '--no-color',
+            '--unified=1000000',
+            ...relative,
+            baseline,
+            '--',
+            pathspec,
+        ]),
+    ]);
+    const statuses = statusFiles(repository, statusOutput);
+    const baseContents = baseContentsFromPatch(patchOutput);
+    const files = new Map();
+    for (const [path, status] of statuses) {
+        const current = currentFiles.get(path);
+        if (!current)
+            continue;
+        files.set(path, {
+            status,
+            baseContent: status === 'new' ? '' : (baseContents.get(path) ?? current.content),
+        });
+    }
+    return { available: true, files };
+}
+export function emptyViewGitSnapshot() {
+    return { available: false, files: new Map() };
+}
+export function sameViewGitSnapshot(left, right) {
+    if (left.available !== right.available ||
+        left.files.size !== right.files.size)
+        return false;
+    for (const [path, file] of left.files) {
+        const candidate = right.files.get(path);
+        if (!candidate ||
+            candidate.status !== file.status ||
+            candidate.baseContent !== file.baseContent) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,2 @@
+/** Highlight source into independently valid, escaped HTML lines. */
+export declare function highlightSource(path: string, content: string): string[];