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

package/dist/src/lattice.js

@@ -1,25 +1,15 @@
 import { readFile } from 'node:fs/promises';
-import { dirname, join, basename, relative, resolve } from 'node:path';
-import { existsSync, statSync } from 'node:fs';
+import { dirname, basename, relative } from 'node:path';
 import GithubSlugger from 'github-slugger';
 import { parse as parseYaml } from 'yaml';
 import { parse } from './parser.js';
-import { toPosix, walkEntries } from './walk.js';
+import { toPosix } from './path.js';
 import { visit } from 'unist-util-visit';
-/**
- * Every field this build reads out of the `lat:` mapping. Kept in one place so
- * a field added later is covered by the misplacement check without a second
- * edit — the trap this list guards against is silent, so it must not depend on
- * whoever adds the next field remembering to register it twice.
- */
-export const LAT_FIELDS = [
-    'require-code-mention',
-    'mode',
-    'require-mode',
-    'status',
-    'reviewed-hash',
-    'tags',
-];
+import { listLatticeFiles } from './project-discovery.js';
+import { LAT_FIELDS, } from './fork/frontmatter-fields.js';
+export { buildFileIndex, buildSectionSlugIndex, findSections, flattenSections, resolveRef, } from './lattice-model.js';
+export { findLatticeDir, findProjectRoot, listLatticeFiles, } from './project-discovery.js';
+export { LAT_FIELDS } from './fork/frontmatter-fields.js';
 export function parseFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match)
@@ -66,30 +56,6 @@ export function parseFrontmatter(content) {
         result.problems = problems;
     return result;
 }
-export function findLatticeDir(from) {
-    let dir = resolve(from ?? process.cwd());
-    while (true) {
-        const candidate = join(dir, 'lat.md');
-        if (existsSync(candidate) && statSync(candidate).isDirectory()) {
-            return candidate;
-        }
-        const parent = dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-export function findProjectRoot(from) {
-    const latDir = findLatticeDir(from);
-    return latDir ? dirname(latDir) : null;
-}
-export async function listLatticeFiles(latticeDir) {
-    const entries = await walkEntries(latticeDir);
-    return entries
-        .filter((e) => e.endsWith('.md'))
-        .sort()
-        .map((e) => join(latticeDir, e));
-}
 function headingText(node) {
     return node.children
         .filter((c) => c.type === 'text')
@@ -207,477 +173,23 @@ export function parseSections(filePath, content, projectRoot, tree = parse(conte
     }
     return roots;
 }
-export async function loadAllSections(latticeDir, projectRoot = dirname(latticeDir)) {
-    const files = await listLatticeFiles(latticeDir);
+export async function loadAllSections(latticeDir, projectRoot = dirname(latticeDir), profile) {
+    const files = profile
+        ? await profile.time('list Markdown files', () => listLatticeFiles(latticeDir))
+        : await listLatticeFiles(latticeDir);
     const all = [];
     for (const file of files) {
-        const content = await readFile(file, 'utf-8');
-        all.push(...parseSections(file, content, projectRoot));
+        const detail = toPosix(relative(latticeDir, file));
+        const content = profile
+            ? await profile.time('read Markdown file', () => readFile(file, 'utf-8'), detail)
+            : await readFile(file, 'utf-8');
+        const sections = profile
+            ? profile.timeSync('parse Markdown sections', () => parseSections(file, content, projectRoot), detail)
+            : parseSections(file, content, projectRoot);
+        all.push(...sections);
     }
     return all;
 }
-export function flattenSections(sections) {
-    const result = [];
-    for (const s of sections) {
-        result.push(s);
-        result.push(...flattenSections(s.children));
-    }
-    return result;
-}
-function levenshtein(a, b) {
-    const m = a.length;
-    const n = b.length;
-    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-    for (let i = 0; i <= m; i++)
-        dp[i][0] = i;
-    for (let j = 0; j <= n; j++)
-        dp[0][j] = j;
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            dp[i][j] =
-                a[i - 1] === b[j - 1]
-                    ? dp[i - 1][j - 1]
-                    : 1 + Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]);
-        }
-    }
-    return dp[m][n];
-}
-/**
- * Returns the trailing segment(s) of a section id.
- * e.g. "markdown#Frontmatter#require-code-mention" → ["Frontmatter#require-code-mention", "require-code-mention"]
- * The full id itself is not included (handled by exact match).
- */
-function tailSegments(id) {
-    const parts = id.split('#');
-    const tails = [];
-    for (let i = 1; i < parts.length; i++) {
-        tails.push(parts.slice(i).join('#'));
-    }
-    return tails;
-}
-/**
- * Build an index mapping path suffixes to their full vault-relative paths.
- * Used by resolveRef to allow short references when a suffix is unambiguous.
- *
- * For a file like `lat.md/guides/setup`, indexes both `guides/setup` and `setup`.
- * This ensures backward-compatible short refs after the vault root moved to the
- * project root (so section IDs now include the `lat.md/` prefix).
- */
-export function buildFileIndex(sections) {
-    const flat = flattenSections(sections);
-    const index = new Map();
-    for (const s of flat) {
-        const parts = s.file.split('/');
-        // Index all trailing path suffixes (excluding the full path itself,
-        // which is handled by exact match). Keys are lowercase for
-        // case-insensitive lookup.
-        for (let i = 1; i < parts.length; i++) {
-            const suffix = parts.slice(i).join('/').toLowerCase();
-            if (!index.has(suffix))
-                index.set(suffix, new Set());
-            index.get(suffix).add(s.file);
-        }
-    }
-    const result = new Map();
-    for (const [stem, paths] of index) {
-        result.set(stem, [...paths]);
-    }
-    return result;
-}
-/**
- * Map GitHub-slugged heading paths back to canonical, literal-heading ids.
- * Every path segment accepts either representation so an implicit literal h1
- * can still prefix slugged child headings during short-ref resolution.
- */
-export function buildSectionSlugIndex(sections) {
-    const aliases = new Map();
-    const stacks = new Map();
-    const sluggers = new Map();
-    for (const section of flattenSections(sections)) {
-        let slugger = sluggers.get(section.file);
-        if (!slugger) {
-            slugger = new GithubSlugger();
-            sluggers.set(section.file, slugger);
-        }
-        // Always advance the fallback slugger so manually constructed Section
-        // objects without githubSlug still get correct duplicate suffixes.
-        const fallbackSlug = slugger.slug(section.heading);
-        const headingSlug = section.githubSlug ?? fallbackSlug;
-        const stack = stacks.get(section.file) ?? [];
-        while (stack.length > 0 && stack[stack.length - 1].depth >= section.depth) {
-            stack.pop();
-        }
-        const levels = [
-            ...stack,
-            {
-                depth: section.depth,
-                literal: section.heading.toLowerCase(),
-                slug: headingSlug.toLowerCase(),
-            },
-        ];
-        let paths = [''];
-        for (const level of levels) {
-            const options = [...new Set([level.literal, level.slug])];
-            paths = paths.flatMap((path) => options.map((part) => (path ? `${path}#${part}` : part)));
-        }
-        for (const path of paths) {
-            const alias = `${section.file.toLowerCase()}#${path}`;
-            if (!aliases.has(alias))
-                aliases.set(alias, section.id);
-        }
-        stack.push(levels[levels.length - 1]);
-        stacks.set(section.file, stack);
-    }
-    return aliases;
-}
-/**
- * Normalize separators only in the file portion of a section reference.
- * Headings are authored text and may legitimately contain backslashes.
- */
-function normalizeRefFilePath(target) {
-    const hashIdx = target.indexOf('#');
-    if (hashIdx === -1)
-        return toPosix(target);
-    return toPosix(target.slice(0, hashIdx)) + target.slice(hashIdx);
-}
-/**
- * Resolve a potentially short reference to its canonical full-path form.
- * If the file segment of the ref is a bare stem that uniquely maps to one
- * full path, expands it. Otherwise returns the ref unchanged.
- *
- * When ambiguous (multiple files share the stem), returns all candidates.
- * If exactly one candidate actually contains the referenced section,
- * `suggested` is set to that candidate so the caller can propose a fix.
- */
-export function resolveRef(target, sectionIds, fileIndex, slugIndex) {
-    target = normalizeRefFilePath(target);
-    const resolveKnown = (candidate) => {
-        // Preserve existing wiki-link meaning when a literal heading happens to
-        // collide with a different heading's GitHub slug.
-        if (sectionIds.has(candidate.toLowerCase()))
-            return candidate;
-        return slugIndex?.get(candidate.toLowerCase()) ?? null;
-    };
-    const resolveInFile = (file, rest) => {
-        const direct = resolveKnown(file + rest);
-        if (direct)
-            return direct;
-        // Try inserting root headings between file and rest. This also works for
-        // slugged child segments because the slug index contains mixed paths.
-        const rootHeadings = findRootHeadings(file, sectionIds);
-        for (const h1 of rootHeadings) {
-            const withRoot = rest ? `${file}#${h1}${rest}` : `${file}#${h1}`;
-            const resolved = resolveKnown(withRoot);
-            if (resolved)
-                return resolved;
-        }
-        return null;
-    };
-    // Already matches a known section — no resolution needed
-    const direct = resolveKnown(target);
-    if (direct) {
-        return { resolved: direct, ambiguous: null, suggested: null };
-    }
-    // Extract the file segment (before first #) and try resolving it
-    const hashIdx = target.indexOf('#');
-    const filePart = hashIdx === -1 ? target : target.slice(0, hashIdx);
-    const rest = hashIdx === -1 ? '' : target.slice(hashIdx);
-    // Try resolving the file part: either it's a full path or a bare stem
-    // File index keys are lowercase for case-insensitive lookup.
-    const lcFilePart = filePart.toLowerCase();
-    const filePaths = fileIndex.has(lcFilePart)
-        ? fileIndex.get(lcFilePart)
-        : [filePart];
-    if (filePaths.length === 1) {
-        const fp = filePaths[0];
-        const resolved = resolveInFile(fp, rest);
-        if (resolved) {
-            return { resolved, ambiguous: null, suggested: null };
-        }
-    }
-    else if (filePaths.length > 1) {
-        // Multiple files share this stem — ambiguous at the filename level
-        const all = filePaths.map((c) => c + rest);
-        const valid = filePaths.filter((c) => resolveInFile(c, rest) !== null);
-        return {
-            resolved: target,
-            ambiguous: all,
-            suggested: valid.length === 1 ? valid[0] + rest : null,
-        };
-    }
-    return { resolved: target, ambiguous: null, suggested: null };
-}
-/**
- * Find root (h1) headings for a file by scanning sectionIds for entries
- * that have exactly the pattern `file#heading` (no further # segments).
- */
-function findRootHeadings(file, sectionIds) {
-    const prefix = file.toLowerCase() + '#';
-    const headings = [];
-    for (const id of sectionIds) {
-        if (id.startsWith(prefix) && !id.includes('#', prefix.length)) {
-            headings.push(id.slice(prefix.length));
-        }
-    }
-    return headings;
-}
-const MAX_DISTANCE_RATIO = 0.4;
-export function findSections(sections, query) {
-    const flat = flattenSections(sections);
-    // Leading # means "search for a heading", strip it
-    const normalized = normalizeRefFilePath(query.startsWith('#') ? query.slice(1) : query);
-    const q = normalized.toLowerCase();
-    const isFullPath = normalized.includes('#');
-    const byId = new Map(flat.map((s) => [s.id.toLowerCase(), s]));
-    const slugIndex = buildSectionSlugIndex(sections);
-    const sectionFor = (candidate) => {
-        const key = candidate.toLowerCase();
-        return byId.get(key) ?? byId.get(slugIndex.get(key)?.toLowerCase() ?? '');
-    };
-    // Tier 1: exact full-id match
-    const literalExact = flat.filter((s) => s.id.toLowerCase() === q);
-    const slugExact = literalExact.length === 0 && isFullPath
-        ? sectionFor(normalized)
-        : undefined;
-    const exact = slugExact ? [slugExact] : literalExact;
-    const exactMatches = exact.map((s) => ({
-        section: s,
-        reason: 'exact match',
-    }));
-    if (exactMatches.length > 0 && isFullPath)
-        return exactMatches;
-    // Build file index early — used by both tier 1a and 1b
-    const fileIndex = buildFileIndex(sections);
-    // Tier 1a: bare name matches file — return root sections of that file
-    // Also checks via file index (e.g. "dev-process" → "lat.md/dev-process")
-    if (!isFullPath && exactMatches.length === 0) {
-        const matchFiles = new Set();
-        // Direct match
-        for (const s of flat) {
-            if (s.file.toLowerCase() === q &&
-                !s.id.includes('#', s.file.length + 1)) {
-                matchFiles.add(s.file);
-            }
-        }
-        // File index expansion (keys are lowercase)
-        const indexPaths = fileIndex.get(q) ?? [];
-        for (const p of indexPaths) {
-            matchFiles.add(p);
-        }
-        if (matchFiles.size > 0) {
-            const fileRoots = flat.filter((s) => matchFiles.has(s.file) && !s.id.includes('#', s.file.length + 1));
-            if (fileRoots.length > 0) {
-                return fileRoots.map((s) => ({
-                    section: s,
-                    reason: 'exact match',
-                }));
-            }
-        }
-    }
-    // Tier 1b: file stem expansion
-    // For bare names: "locate" → matches root section of "tests/locate.md"
-    // For paths with #: "setup#Install" → expands to "guides/setup#Install"
-    const stemMatches = [];
-    if (isFullPath) {
-        // Expand file stem in the file part of the query
-        const hashIdx = normalized.indexOf('#');
-        const filePart = normalized.slice(0, hashIdx);
-        const rest = normalized.slice(hashIdx);
-        const stemPaths = fileIndex.get(filePart.toLowerCase()) ?? [];
-        // Also try filePart as a direct file path (for root-level files not in index)
-        const allPaths = stemPaths.length > 0 ? stemPaths : filePart ? [filePart] : [];
-        for (const p of allPaths) {
-            const s = sectionFor(p + rest);
-            if (s) {
-                if (exact.includes(s))
-                    continue;
-                stemMatches.push({
-                    section: s,
-                    reason: stemPaths.length > 0
-                        ? `file stem expanded: ${filePart} → ${p}`
-                        : 'exact match',
-                });
-                continue;
-            }
-            // Try inserting root headings: file#rest → file#h1#rest
-            const rootsOfFile = flat.filter((s) => s.file.toLowerCase() === p.toLowerCase() &&
-                !s.id.includes('#', s.file.length + 1));
-            for (const root of rootsOfFile) {
-                const match = sectionFor(root.id + rest);
-                if (match) {
-                    if (exact.includes(match))
-                        continue;
-                    stemMatches.push({
-                        section: match,
-                        reason: stemPaths.length > 0
-                            ? `file stem expanded: ${filePart} → ${p}`
-                            : 'exact match',
-                    });
-                }
-            }
-        }
-        if (stemMatches.length > 0)
-            return [...exactMatches, ...stemMatches];
-    }
-    else {
-        // Bare name: match root sections of files via stem index (keys lowercase)
-        const paths = fileIndex.get(q) ?? [];
-        for (const p of paths) {
-            for (const s of flat) {
-                if (exact.includes(s))
-                    continue;
-                // Root sections have id = "file#heading" (exactly 2 segments)
-                if (s.file.toLowerCase() === p.toLowerCase() &&
-                    !s.id.includes('#', s.file.length + 1)) {
-                    stemMatches.push({ section: s, reason: 'file stem match' });
-                }
-            }
-        }
-    }
-    // Tier 2: exact match on trailing segments (subsection name match)
-    const seen = new Set([
-        ...exact.map((s) => s.id),
-        ...stemMatches.map((m) => m.section.id),
-    ]);
-    const slugTailMatches = new Set();
-    if (!isFullPath) {
-        for (const [alias, canonical] of slugIndex) {
-            if (alias.slice(alias.lastIndexOf('#') + 1) === q) {
-                slugTailMatches.add(canonical.toLowerCase());
-            }
-        }
-    }
-    const literalTailMatches = new Set(isFullPath
-        ? []
-        : flat
-            .filter((s) => tailSegments(s.id).some((tail) => tail.toLowerCase() === q))
-            .map((s) => s.id.toLowerCase()));
-    const subsection = isFullPath
-        ? []
-        : flat
-            .filter((s) => {
-            if (seen.has(s.id))
-                return false;
-            const id = s.id.toLowerCase();
-            return literalTailMatches.size > 0
-                ? literalTailMatches.has(id)
-                : slugTailMatches.has(id);
-        })
-            .map((s) => ({ section: s, reason: 'section name match' }));
-    // Tier 2b: subsequence match — query segments are a subsequence of section id segments
-    // e.g. "Markdown#Resolution Rules" matches "markdown#Wiki Links#Resolution Rules"
-    // Also tries expanding the file part via the file index for short refs.
-    const seenSub = new Set([...seen, ...subsection.map((m) => m.section.id)]);
-    const qParts = q.split('#');
-    // Build query variants: original + file-index-expanded forms
-    const qVariants = [qParts];
-    if (qParts.length >= 2) {
-        const expanded = fileIndex.get(qParts[0]);
-        if (expanded) {
-            for (const exp of expanded) {
-                qVariants.push([exp.toLowerCase(), ...qParts.slice(1)]);
-            }
-        }
-    }
-    const subsequence = qParts.length >= 2
-        ? flat
-            .filter((s) => {
-            if (seenSub.has(s.id))
-                return false;
-            const sParts = s.id.toLowerCase().split('#');
-            return qVariants.some((variant) => {
-                if (sParts.length <= variant.length)
-                    return false;
-                let qi = 0;
-                for (const sp of sParts) {
-                    if (sp === variant[qi])
-                        qi++;
-                    if (qi === variant.length)
-                        return true;
-                }
-                return false;
-            });
-        })
-            .map((s) => {
-            const skipped = s.id.split('#').length - qParts.length;
-            return {
-                section: s,
-                reason: `path match, ${skipped} intermediate ${skipped === 1 ? 'section' : 'sections'} skipped`,
-            };
-        })
-        : [];
-    // Tier 3: fuzzy match by edit distance on each segment tail and full id
-    const seenAll = new Set([
-        ...seenSub,
-        ...subsequence.map((m) => m.section.id),
-    ]);
-    const fuzzy = [];
-    // For full-path queries, extract the file and heading parts so we can
-    // fuzzy-match only the heading portion when the file part matches exactly.
-    // This prevents the shared file prefix from inflating similarity scores
-    // (e.g. "cli#locat" would otherwise fuzzy-match "cli#prompt").
-    const qHashIdx = normalized.indexOf('#');
-    const qFile = qHashIdx === -1 ? null : normalized.slice(0, qHashIdx).toLowerCase();
-    const qHeading = qHashIdx === -1 ? null : normalized.slice(qHashIdx + 1).toLowerCase();
-    for (const s of flat) {
-        if (seenAll.has(s.id))
-            continue;
-        const candidates = [s.id, ...tailSegments(s.id)];
-        let best = Infinity;
-        let bestCandidate = '';
-        for (const c of candidates) {
-            let d;
-            let maxLen;
-            const cl = c.toLowerCase();
-            const cHashIdx = cl.indexOf('#');
-            // When both query and candidate have # and their file parts match,
-            // compare only the heading portions to avoid file-prefix inflation
-            if (qFile && qHeading && cHashIdx !== -1) {
-                const cFile = cl.slice(0, cHashIdx);
-                const cHeading = cl.slice(cHashIdx + 1);
-                if (cFile === qFile) {
-                    d = levenshtein(cHeading, qHeading);
-                    maxLen = Math.max(cHeading.length, qHeading.length);
-                }
-                else {
-                    d = levenshtein(cl, q);
-                    maxLen = Math.max(c.length, q.length);
-                }
-            }
-            else {
-                d = levenshtein(cl, q);
-                maxLen = Math.max(c.length, q.length);
-            }
-            if (maxLen > 0 && d / maxLen <= MAX_DISTANCE_RATIO && d < best) {
-                best = d;
-                bestCandidate = c;
-            }
-        }
-        if (best < Infinity) {
-            fuzzy.push({ section: s, distance: best, matched: bestCandidate });
-        }
-    }
-    fuzzy.sort((a, b) => a.distance - b.distance);
-    const fuzzyMatches = fuzzy.map((f) => ({
-        section: f.section,
-        reason: f.matched.toLowerCase() === f.section.id.toLowerCase()
-            ? `fuzzy match, distance ${f.distance}`
-            : `fuzzy match on "${f.matched}", distance ${f.distance}`,
-    }));
-    // Sort results: shallower depth first, then fewer path segments
-    const sortKey = (s) => {
-        const pathDepth = (s.file.match(/\//g) || []).length;
-        return s.depth * 100 + pathDepth;
-    };
-    const sortedStems = [...stemMatches].sort((a, b) => sortKey(a.section) - sortKey(b.section));
-    return [
-        ...exactMatches,
-        ...sortedStems,
-        ...subsection,
-        ...subsequence,
-        ...fuzzyMatches,
-    ];
-}
 export function extractRefs(filePath, content, projectRoot, tree = parse(content)) {
     const file = projectRoot
         ? toPosix(relative(projectRoot, filePath)).replace(/\.md$/, '')
@@ -749,7 +261,7 @@ function closingBracket(value, open) {
     }
     return -1;
 }
-/** Extract link destinations and undefined full/collapsed references. */
+/** Extract link destinations and undefined reference syntax. */
 export function extractLinks(content, tree = parse(content)) {
     const links = [];
     visit(tree, ['link', 'image', 'definition'], (node) => {
@@ -764,12 +276,16 @@ export function extractLinks(content, tree = parse(content)) {
         'code',
         'inlineCode',
         'html',
+        'math',
+        'inlineMath',
         'yaml',
         'link',
         'image',
         'definition',
         'linkReference',
         'imageReference',
+        'footnoteReference',
+        'alertMarker',
         'wikiLink',
     ], (node) => {
         const start = node.position?.start.offset;
@@ -778,28 +294,58 @@ export function extractLinks(content, tree = parse(content)) {
             excluded.push({ start, end });
         }
     });
+    // GFM removes task-list markers from the paragraph AST. Exclude just the
+    // marker prefix so strict shortcut checks still apply to the item body.
+    visit(tree, 'listItem', (node) => {
+        if (typeof node.checked !== 'boolean')
+            return;
+        const start = node.position?.start.offset;
+        const bodyStart = node.children[0]?.position?.start.offset;
+        if (start === undefined || bodyStart === undefined)
+            return;
+        const marker = /\[[ xX]\]/.exec(content.slice(start, bodyStart));
+        if (marker) {
+            excluded.push({
+                start: start + marker.index,
+                end: start + marker.index + marker[0].length,
+            });
+        }
+    });
+    // Likewise, exclude only a footnote definition's label and delimiter. Its
+    // body remains prose and must still obey strict shortcut validation.
+    visit(tree, 'footnoteDefinition', (node) => {
+        const start = node.position?.start.offset;
+        const bodyStart = node.children[0]?.position?.start.offset;
+        if (start !== undefined && bodyStart !== undefined) {
+            excluded.push({ start, end: bodyStart });
+        }
+    });
     const overlapsExcluded = (start, end) => excluded.some((range) => start < range.end && end > range.start);
     for (let open = 0; open < content.length; open++) {
         if (content[open] !== '[' || isEscapedAt(content, open))
             continue;
         const labelEnd = closingBracket(content, open);
-        const identifierStart = labelEnd + 1;
-        if (labelEnd === -1 ||
-            content[identifierStart] !== '[' ||
-            isEscapedAt(content, identifierStart)) {
+        if (labelEnd === -1)
             continue;
-        }
-        const identifierEnd = closingBracket(content, identifierStart);
+        const identifierStart = labelEnd + 1;
+        const hasSecondLabel = content[identifierStart] === '[' &&
+            !isEscapedAt(content, identifierStart);
+        const identifierEnd = hasSecondLabel
+            ? closingBracket(content, identifierStart)
+            : labelEnd;
         if (identifierEnd === -1)
             continue;
         const isImage = open > 0 && content[open - 1] === '!' && !isEscapedAt(content, open - 1);
+        const isMalformedDefinition = !isImage && !hasSecondLabel && content[labelEnd + 1] === ':';
         const start = isImage ? open - 1 : open;
-        const end = identifierEnd + 1;
+        const end = identifierEnd + 1 + (isMalformedDefinition ? 1 : 0);
         if (overlapsExcluded(start, end)) {
             open = identifierEnd;
             continue;
         }
-        const explicitIdentifier = content.slice(identifierStart + 1, identifierEnd);
+        const explicitIdentifier = hasSecondLabel
+            ? content.slice(identifierStart + 1, identifierEnd)
+            : '';
         const identifier = explicitIdentifier || content.slice(open + 1, labelEnd);
         if (identifier.trim() === '') {
             open = identifierEnd;
@@ -809,6 +355,13 @@ export function extractLinks(content, tree = parse(content)) {
             identifier: identifier.trim(),
             source: content.slice(start, end),
             kind: isImage ? 'imageReference' : 'linkReference',
+            style: !hasSecondLabel
+                ? isMalformedDefinition
+                    ? 'definition'
+                    : 'shortcut'
+                : explicitIdentifier
+                    ? 'full'
+                    : 'collapsed',
             line: content.slice(0, start).split('\n').length,
         });
         open = identifierEnd;

package/dist/src/markdown-analysis-cache.d.ts

@@ -0,0 +1,20 @@
+import type { MarkdownAnalysisTimings, MarkdownFileAnalysis } from './markdown-analysis.js';
+import type { ParserImportObserver } from './parser-import.js';
+export { PARSER_CACHE_VERSION } from './parser-cache.js';
+export type MarkdownAnalysisCacheStatus = 'disabled' | 'hit' | 'miss';
+export type PreparedMarkdownAnalysis = {
+    absolutePath: string;
+    cachePath: string;
+    content: string;
+    contentHash: string;
+    analysis?: MarkdownFileAnalysis;
+    timings: Pick<MarkdownAnalysisTimings, 'readMs' | 'hashMs' | 'cacheReadMs' | 'cacheStatus'>;
+};
+/** Return the collision-safe, sharded cache path for one Markdown file. */
+export declare function markdownAnalysisCachePath(latDir: string, projectRoot: string, absolutePath: string): string;
+/** Read, hash, and attempt to hydrate one Markdown file from persistent cache. */
+export declare function prepareMarkdownAnalysis(absolutePath: string, latDir: string, projectRoot: string, cache?: boolean): Promise<PreparedMarkdownAnalysis>;
+/** Attach I/O timings and best-effort publish one newly parsed analysis. */
+export declare function publishMarkdownAnalysis(prepared: PreparedMarkdownAnalysis, analysis: MarkdownFileAnalysis): Promise<MarkdownFileAnalysis>;
+/** Analyze one path through the same persistent cache used by project runs. */
+export declare function analyzeMarkdownPath(absolutePath: string, latDir: string, projectRoot: string, cache?: boolean, onParserImport?: ParserImportObserver): Promise<MarkdownFileAnalysis>;