@wonseok-han/confluence-sync 1.5.0 → 1.6.0

package/dist/sync/push.js

@@ -0,0 +1,302 @@
+/** Incremental Confluence push and local preview orchestration. */
+import { positionalArgs } from '../cli/args.js';
+import { existsSync, statSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import { readEnv, requireEnv } from '../confluence/config.js';
+import { docHash } from '../documents/markdown.js';
+import { buildTreeRenderer } from './render.js';
+import { collectMarkdown, buildFolderIndex, readDoc, parentKeyOf, containerKeyOf, sortForSync, resolveSelection, withParents, } from '../documents/catalog.js';
+import { loadMapping, saveMapping } from './mapping.js';
+import { createClient } from '../confluence/client.js';
+import { buildIgnorer } from './ignore.js';
+import { bold, dim, red, green, yellow, magenta, cyan, gray } from '../shared/colors.js';
+export async function runPush(argv) {
+    const DRY_RUN = argv.includes('--dry-run');
+    const LIST = argv.includes('--list');
+    const REBUILD = argv.includes('--rebuild');
+    const FORCE = argv.includes('--force');
+    const VERIFY = argv.includes('--verify');
+    function optVal(name) {
+        const i = argv.indexOf(name);
+        return i >= 0 && i + 1 < argv.length ? argv[i + 1] : undefined;
+    }
+    /** 반복 가능한 옵션의 모든 값 수집(예: --exclude a --exclude b) */
+    function optVals(name) {
+        const out = [];
+        for (let i = 0; i < argv.length; i++)
+            if (argv[i] === name && i + 1 < argv.length)
+                out.push(argv[++i]);
+        return out;
+    }
+    const EXCLUDES = optVals('--exclude');
+    const positionals = positionalArgs(argv);
+    const baseInput = optVal('--base') ?? process.env.CONFLUENCE_SYNC_BASE;
+    if (!baseInput) {
+        console.error(red('✗ 동기화 루트가 지정되지 않았습니다.') + '\n' +
+            '  --base <dir> 인자 또는 env CONFLUENCE_SYNC_BASE 로 동기화할 디렉토리를 지정하세요.\n' +
+            `  예) ${cyan('confluence-sync --base ./docs')}\n` +
+            `  설정(.env)을 만들려면:  ${cyan('confluence-sync init')}\n` +
+            `  전체 도움말:           ${cyan('confluence-sync --help')}`);
+        process.exit(1);
+    }
+    const BASE_DIR = resolve(baseInput);
+    // mapping 은 base 루트에 둔다(문서셋에 종속). --mapping 으로 위치 override 가능.
+    const mappingOpt = optVal('--mapping');
+    const MAPPING_PATH = mappingOpt ? resolve(mappingOpt) : resolve(BASE_DIR, '.confluence-sync.json');
+    const env = readEnv();
+    if (!existsSync(BASE_DIR) || !statSync(BASE_DIR).isDirectory()) {
+        console.error(red(`동기화 루트가 디렉토리가 아닙니다: ${BASE_DIR}`));
+        process.exit(1);
+    }
+    if (!DRY_RUN && !LIST)
+        requireEnv(env); // list/dry 는 Confluence 호출이 없어 인증 불필요
+    const ignorer = buildIgnorer(BASE_DIR, EXCLUDES);
+    const collected = collectMarkdown(BASE_DIR).map((f) => relative(BASE_DIR, f).split('\\').join('/'));
+    const allRel = collected.filter((r) => !ignorer.ignores(r)); // 제외된 문서는 모든 단계에서 빠짐
+    const ignoredCount = collected.length - allRel.length;
+    const folderIndex = buildFolderIndex(allRel);
+    // 링크·섹션 링크 변환은 항상 트리 전체 기준이다. 선택 동기화여도 대상 문서의 제목·헤딩을 알아야 하고,
+    // 다른 문서가 이 문서의 섹션을 가리킬 수 있다. 제외된 문서는 링크 대상에서도 빠진다.
+    const { titles: titleIndex, render } = buildTreeRenderer(BASE_DIR, allRel, { referenceRoots: optVals('--reference-root'), baseUrl: env.baseUrl });
+    // 사용자가 실제로 고른 문서. 경로 인자가 없으면 전체가 대상이다.
+    const picked = positionals.length ? resolveSelection(allRel, positionals, BASE_DIR) : allRel;
+    const explicit = new Set(picked);
+    // 상위 README 를 함께 넣는 것은 **자식의 부모 pageId 를 얻기 위해서**다(발행 대상이 아니다).
+    const selected = positionals.length ? withParents(picked, folderIndex) : allRel;
+    const files = sortForSync(selected);
+    /** 딸려온 상위 README 인가 — 이미 페이지가 있으면 내용은 건드리지 않는다. */
+    const isCarriedParent = (rel) => !explicit.has(rel);
+    const scope = positionals.length
+        ? `선택 ${explicit.size}/${allRel.length}건` +
+            (files.length > explicit.size ? dim(` (+상위 ${files.length - explicit.size})`) : '')
+        : `${files.length}건`;
+    const ignoredNote = ignoredCount ? dim(`  (제외 ${ignoredCount})`) : '';
+    console.log(`${dim('base:')} ${cyan(BASE_DIR)}\n${dim('대상:')} ${scope}${ignoredNote}`);
+    // ---- 경로 헬퍼 ----
+    const isReadmeFile = (p) => /README\.md$/.test(p);
+    const segOf = (s) => (s === '' ? 0 : s.split('/').length);
+    const dirOf = (p) => p.split('/').slice(0, -1).join('/');
+    const parentDirOf = (d) => (d.includes('/') ? d.slice(0, d.lastIndexOf('/')) : '');
+    const fileDepth = (rel) => (isReadmeFile(rel) ? Math.max(0, segOf(dirOf(rel)) - 1) : segOf(dirOf(rel)));
+    const folderDepth = (d) => Math.max(0, segOf(d) - 1);
+    // 파일의 README 없는(=폴더로 만들) 조상 dir들, shallow→deep
+    const ancestorFolderDirs = (rel) => {
+        const out = [];
+        for (let d = dirOf(rel); d !== ''; d = parentDirOf(d))
+            if (!folderIndex[d])
+                out.unshift(d);
+        return out;
+    };
+    // --list: base에서 인식된 문서·제목·계층만 출력(Confluence 호출 없음)
+    if (LIST) {
+        const seen = new Set();
+        for (const rel of files) {
+            for (const d of ancestorFolderDirs(rel))
+                if (!seen.has(d)) {
+                    seen.add(d);
+                    console.log(`  ${'  '.repeat(folderDepth(d))}${cyan(`📁 ${d}/`)}`);
+                }
+            console.log(`  ${'  '.repeat(fileDepth(rel))}${rel}  ${dim('—')}  ${cyan(`"${titleIndex[rel]}"`)}`);
+        }
+        return;
+    }
+    const mapping = loadMapping(MAPPING_PATH);
+    if (DRY_RUN) {
+        const seen = new Set();
+        for (const rel of files) {
+            for (const d of ancestorFolderDirs(rel))
+                if (!seen.has(d)) {
+                    seen.add(d);
+                    const fex = mapping[`${d}/`];
+                    console.log(`  [${fex?.pageId ? gray('폴더') : green('폴더+')}] 📁 ${d}/`);
+                }
+            const ex0 = mapping[rel];
+            // 딸려온 상위 README 는 pageId 만 쓰고 지나간다 — 고르지 않은 문서를 발행하지 않는다
+            if (isCarriedParent(rel) && ex0?.pageId) {
+                console.log(`  [${gray('상위')}] ${rel}  ${dim(`(pageId #${ex0.pageId} 만 사용)`)}`);
+                continue;
+            }
+            const { title, body, fm } = readDoc(BASE_DIR, rel);
+            const r = render(rel, body, title);
+            for (const link of r.referenceLinks)
+                console.log(dim(`  참조 링크: ${link}`));
+            for (const warning of r.linkWarnings)
+                console.error(yellow(`  ⚠ ${rel}: ${warning}`));
+            const hash = docHash(title, r);
+            const ex = mapping[rel];
+            // 매핑엔 없지만 frontmatter 에 pageId 가 있으면 신규 생성이 아니라 기존 페이지에 연결된다
+            const status = !ex?.pageId
+                ? (fm.pageId ? cyan('연결') : green('신규'))
+                : ex.hash === hash ? gray('동일') : yellow('변경');
+            const pk = parentKeyOf(rel, folderIndex);
+            const anchorNote = r.anchorLinks || r.anchorsPlaced
+                ? `, 섹션링크: ${r.anchorLinks}, 앵커: ${r.anchorsPlaced}` : '';
+            console.log(`  [${status}] ${rel}  ${dim('→')}  ${cyan(`"${title}"`)}  ${dim(`(부모: ${pk ?? 'ROOT'}, 내부링크: ${r.internalLinks}${anchorNote}, 이미지: ${r.images.length})`)}`);
+            if (r.deadAnchors.length) {
+                console.error(yellow(`    ⚠ 대응 헤딩 없는 앵커 ${r.deadAnchors.length}개: `) + dim(r.deadAnchors.slice(0, 3).join(' ')));
+            }
+        }
+        console.log('\n' + dim('--dry-run: 실제 호출 없음.'));
+        return;
+    }
+    const client = createClient({ baseUrl: env.baseUrl, email: env.email, token: env.token }, { force: FORCE, verify: VERIFY });
+    const spaceId = await client.getSpaceId(env.spaceKey);
+    if (REBUILD) {
+        await client.deleteAll(mapping);
+        saveMapping(MAPPING_PATH, {});
+    }
+    const work = REBUILD ? {} : mapping;
+    let created = 0, updated = 0, skipped = 0, recreated = 0, relinked = 0, foldersMade = 0, linked = 0, carried = 0;
+    const rendered = new Map();
+    const recreatedTitles = new Set(); // 이번에 재생성된 문서의 제목
+    const touched = new Set(); // 이번에 발행(생성/갱신/재생성)된 문서
+    const handledFolders = new Set(); // 이번 실행에서 처리한 폴더 dir
+    // README 없는 폴더를 Confluence 폴더로 생성(없으면)하고 work 에 등록. 성공 여부 반환.
+    const ensureFolder = async (dir) => {
+        const key = `${dir}/`;
+        const pcKey = containerKeyOf(parentDirOf(dir), folderIndex);
+        const parentId = pcKey ? work[pcKey]?.pageId : env.parentId;
+        if (pcKey && !parentId) {
+            console.error(yellow(`  ✗ 폴더 건너뜀  ${dir}/  (부모 '${pcKey}' 가 아직 없음)`));
+            return false;
+        }
+        const ex = work[key];
+        if (ex?.pageId && ex.type === 'folder' && (await client.getContentOrNull(ex.pageId))) {
+            return true; // 이미 존재
+        }
+        try {
+            const title = dir.split('/').pop();
+            const fid = await client.createFolder(spaceId, title, parentId);
+            work[key] = { pageId: fid, title, type: 'folder' };
+            saveMapping(MAPPING_PATH, work);
+            console.log(`  ${cyan('📁 폴더')}  ${dir}/  ${dim(`(부모: ${pcKey ?? 'ROOT'})`)}`);
+            foldersMade++;
+            return true;
+        }
+        catch (e) {
+            console.error(red(`  ✗ 폴더 생성 실패  ${dir}/`) + `\n${e.message}`);
+            return false;
+        }
+    };
+    for (const rel of files) {
+        // 상위 README-less 폴더들 보장(shallow→deep)
+        let folderOk = true;
+        for (const d of ancestorFolderDirs(rel)) {
+            if (!handledFolders.has(d)) {
+                handledFolders.add(d);
+                if (!(await ensureFolder(d)))
+                    folderOk = false;
+            }
+            else if (!work[`${d}/`]?.pageId)
+                folderOk = false;
+            if (!folderOk)
+                break;
+        }
+        if (!folderOk) {
+            console.error(yellow(`  ✗ 건너뜀  ${rel}  (상위 폴더 미생성)`));
+            continue;
+        }
+        // 딸려온 상위 README 는 자식의 부모 pageId 를 얻으려고 들어온 것이다.
+        // 이미 페이지가 있으면 내용은 건드리지 않는다 — `csync <파일>` 이 고르지 않은 문서를 발행하면 안 된다.
+        // (페이지가 아직 없으면 자식을 붙일 곳이 없으므로 아래에서 생성한다)
+        if (isCarriedParent(rel) && work[rel]?.pageId) {
+            console.log(`  ${gray('· 상위')}  ${rel}  ${dim(`(pageId #${work[rel].pageId} 만 사용)`)}`);
+            carried++;
+            continue;
+        }
+        const { title, body, fm } = readDoc(BASE_DIR, rel);
+        const r = render(rel, body, title);
+        for (const link of r.referenceLinks)
+            console.log(dim(`  참조 링크: ${link}`));
+        for (const warning of r.linkWarnings)
+            console.error(yellow(`  ⚠ ${rel}: ${warning}`));
+        const hash = docHash(title, r);
+        const pk = parentKeyOf(rel, folderIndex);
+        if (r.deadAnchors.length) {
+            console.error(yellow(`  ⚠ 대응 헤딩 없는 앵커  ${rel}`) + dim(`  ${r.deadAnchors.slice(0, 3).join(' ')}${r.deadAnchors.length > 3 ? ` 외 ${r.deadAnchors.length - 3}` : ''}`));
+        }
+        const parentId = pk ? work[pk]?.pageId : env.parentId;
+        rendered.set(rel, { ...r, title, hash, parentId });
+        if (pk && !parentId) {
+            console.error(yellow(`  ✗ 건너뜀  ${rel}  (부모 '${pk}' 가 아직 없음)`));
+            continue;
+        }
+        // pull 로 받은 문서(frontmatter 에 pageId)는 매핑이 없어도 원본 페이지에 다시 연결한다.
+        // 매핑 파일을 잃었거나 vault 를 다른 곳에 복제한 경우 중복 생성을 막아준다.
+        if (!work[rel]?.pageId && fm.pageId) {
+            try {
+                if (await client.getContentOrNull(fm.pageId)) {
+                    work[rel] = { pageId: fm.pageId, title };
+                    saveMapping(MAPPING_PATH, work);
+                    console.log(`  ${cyan('🔗 연결')}  ${rel}  ${dim(`→ 기존 페이지 #${fm.pageId}`)}`);
+                    linked++;
+                }
+                else {
+                    console.error(yellow(`  ⚠ frontmatter 의 pageId #${fm.pageId} 를 찾을 수 없습니다 → 새로 생성  (${rel})`));
+                }
+            }
+            catch (e) {
+                console.error(yellow(`  ⚠ pageId 확인 실패 #${fm.pageId}: ${e.message}`));
+            }
+        }
+        try {
+            const result = await client.upsertPage(work, spaceId, rel, title, r.storage, hash, parentId);
+            saveMapping(MAPPING_PATH, work);
+            if (result === 'skipped') {
+                console.log(`  ${gray('=  변경없음')}  ${rel}`);
+                skipped++;
+                continue;
+            }
+            const imgOk = await client.uploadImages(work[rel].pageId, r.images, BASE_DIR);
+            const imgNote = r.images.length ? `, 이미지 ${imgOk}/${r.images.length}` : '';
+            const label = result === 'created' ? green('＋ 생성')
+                : result === 'recreated' ? magenta('♻ 재생성(삭제 복구)')
+                    : yellow('↻ 갱신');
+            console.log(`  ${label}  ${rel}  ${dim('→')}  ${cyan(`"${title}"`)}  ${dim(`(부모: ${pk ?? 'ROOT'}${imgNote})`)}`);
+            if (result === 'created')
+                created++;
+            else if (result === 'recreated') {
+                recreated++;
+                recreatedTitles.add(title);
+            }
+            else
+                updated++;
+            touched.add(rel);
+        }
+        catch (e) {
+            console.error(red(`  ✗ 실패  ${rel}`) + `\n${e.message}`);
+        }
+    }
+    // 링크 정합성: 재생성된 문서를 가리키던, 이번에 발행 안 된(스킵된) 문서를 강제 재발행해 링크를 새 페이지로 재연결
+    if (recreatedTitles.size) {
+        for (const rel of files) {
+            if (touched.has(rel))
+                continue;
+            const r = rendered.get(rel);
+            if (!r || !work[rel]?.pageId)
+                continue;
+            if (!r.linkedTitles.some((t) => recreatedTitles.has(t)))
+                continue;
+            try {
+                await client.upsertPage(work, spaceId, rel, r.title, r.storage, r.hash, r.parentId, true);
+                saveMapping(MAPPING_PATH, work);
+                await client.uploadImages(work[rel].pageId, r.images, BASE_DIR);
+                console.log(`  ${cyan('🔗 링크 재연결')}  ${rel}  ${dim('→')}  ${cyan(`"${r.title}"`)}`);
+                relinked++;
+            }
+            catch (e) {
+                console.error(red(`  ✗ 링크 재연결 실패  ${rel}`) + `\n${e.message}`);
+            }
+        }
+    }
+    console.log('\n' + bold('완료') +
+        `  ${green(`생성 ${created}`)}` +
+        `  ${yellow(`갱신 ${updated}`)}` +
+        `  ${magenta(`재생성 ${recreated}`)}` +
+        `  ${cyan(`링크재연결 ${relinked}`)}` +
+        `  ${gray(`변경없음 ${skipped}`)}` +
+        (linked ? `  ${cyan(`연결 ${linked}`)}` : '') +
+        (foldersMade ? `  ${cyan(`폴더 ${foldersMade}`)}` : '') +
+        (carried ? `  ${gray(`상위 ${carried}`)}` : '') +
+        `  ${dim(`대상 ${files.length - carried}`)}`);
+}

package/dist/sync/references.js

@@ -0,0 +1,93 @@
+/** Read-only link lookup across independently synchronized document roots. */
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { parse } from 'dotenv';
+import { collectMarkdown } from '../documents/catalog.js';
+import { buildIgnorer } from './ignore.js';
+import { MAPPING_FILE } from './mapping.js';
+const key = (s) => s.normalize('NFC').toLowerCase();
+const slash = (s) => s.split('\\').join('/');
+const decode = (s) => { try {
+    return decodeURIComponent(s);
+}
+catch {
+    return s;
+} };
+export function referenceRoots(base, roots) {
+    const own = realpathSync(base);
+    return [...new Set(roots.map(root => {
+            const path = realpathSync(resolve(root));
+            if (!statSync(path).isDirectory() || dirname(path) === path)
+                throw new Error('참조 문서 폴더를 확인하세요: ' + root);
+            const rel = slash(relative(own, path));
+            if (rel && rel !== '..' && !rel.startsWith('../') && !isAbsolute(rel))
+                throw new Error('참조 폴더는 업로드 기준 폴더 밖에 있어야 합니다: ' + root);
+            return path;
+        }))].filter(root => root !== own);
+}
+export function buildReferenceLookup(base, rels, roots, baseUrl) {
+    const candidates = rels.map(rel => ({ root: base, rel, local: true }));
+    const server = baseUrl?.replace(/\/$/, '');
+    for (const root of referenceRoots(base, roots)) {
+        const envPath = join(root, '.env');
+        const configured = existsSync(envPath) ? parse(readFileSync(envPath)).CONFLUENCE_BASE_URL?.replace(/\/$/, '') : undefined;
+        if (configured && configured !== server)
+            throw new Error('참조 폴더의 Confluence 서버가 현재 설정과 다릅니다: ' + root);
+        let mapping = {};
+        const path = join(root, MAPPING_FILE);
+        if (existsSync(path)) {
+            mapping = JSON.parse(readFileSync(path, 'utf8'));
+            if (!mapping || typeof mapping !== 'object' || Array.isArray(mapping)
+                || Object.values(mapping).some(v => !v || typeof v.pageId !== 'string'))
+                throw new Error('참조 페이지 매핑이 올바르지 않습니다: ' + path);
+        }
+        const ignorer = buildIgnorer(root, []);
+        for (const file of collectMarkdown(root)) {
+            // Overlapping roots must not create duplicate candidates or export ignored local documents.
+            const fromBase = slash(relative(realpathSync(base), file));
+            if (fromBase !== '..' && !fromBase.startsWith('../') && !isAbsolute(fromBase))
+                continue;
+            const rel = slash(relative(root, file));
+            if (!ignorer.ignores(rel))
+                candidates.push({ root, rel, local: false, pageId: mapping[rel]?.pageId });
+        }
+    }
+    const unique = [...new Map(candidates.map(c => [realpathSync(join(c.root, c.rel)), c])).values()];
+    function find(from, raw, wiki) {
+        const target = decode(raw).replace(/\.md$/i, '') + '.md';
+        const exact = wiki ? target : slash(relative(base, resolve(base, dirname(from), target)));
+        const local = unique.filter(c => c.local && key(c.rel) === key(exact));
+        if (local.length)
+            return local;
+        const refs = unique.filter(c => !c.local && key(c.rel) === key(target));
+        if (refs.length)
+            return refs;
+        return unique.filter(c => key(basename(c.rel)) === key(basename(slash(target))));
+    }
+    return {
+        localTarget(from, target, wiki) {
+            const hits = find(from, target, wiki);
+            return hits.length === 1 && hits[0].local ? hits[0].rel : null;
+        },
+        resolve(from, target, wiki, warn, linked = () => { }) {
+            const hits = find(from, target, wiki);
+            if (hits.length !== 1) {
+                warn(hits.length ? `중복 문서 링크: ${target} → ${hits.map(c => join(c.root, c.rel)).join(', ')}` : `대상 없는 문서 링크: ${target}`);
+                return null;
+            }
+            const hit = hits[0];
+            if (hit.local)
+                return slash(relative(dirname(from), hit.rel));
+            if (!hit.pageId || !/^\d+$/.test(hit.pageId)) {
+                warn(`게시 매핑 없는 문서 링크: ${target} → ${join(hit.root, hit.rel)}`);
+                return null;
+            }
+            if (!server || !/^https?:\/\//i.test(server)) {
+                warn(`참조 링크에 CONFLUENCE_BASE_URL이 필요합니다: ${target}`);
+                return null;
+            }
+            linked(`${target} → pageId ${hit.pageId} (${join(hit.root, hit.rel)})`);
+            return `${server}/pages/viewpage.action?pageId=${encodeURIComponent(hit.pageId)}`;
+        },
+    };
+}

package/dist/sync/render.js

@@ -0,0 +1,47 @@
+import { buildReferenceLookup } from './references.js';
+/**
+ * 문서 트리 하나를 storage format 으로 옮기는 렌더러.
+ *
+ * 링크·섹션 링크는 **트리 전체**를 알아야 풀린다(다른 문서의 제목과 헤딩을 참조하므로),
+ * 그래서 문서 하나가 아니라 트리 단위로 만든다.
+ *
+ * push(sync)와 pull 의 매핑 기록이 **같은 문서에 같은 해시**를 내야 하므로 —
+ * 어긋나면 pull 직후 push 가 전부 "변경"으로 보인다 — 두 곳이 이 함수 하나를 함께 쓴다.
+ */
+import { relative } from 'node:path';
+import { toStorage } from '../documents/markdown.js';
+import { buildDocIndex, buildVault, collectAssets, vaultResolver, resolveAnchorTargets, } from '../documents/catalog.js';
+export function buildTreeRenderer(baseDir, rels, options) {
+    const { titles, anchors, docs } = buildDocIndex(rels, baseDir);
+    // Obsidian [[wikilink]] 해석용 이름 인덱스
+    const vault = buildVault(rels, collectAssets(baseDir).map((f) => relative(baseDir, f)));
+    // 누가 어느 헤딩을 가리키는지 먼저 모은다 — 그 헤딩에만 Anchor 매크로를 심는다.
+    const lookup = options ? buildReferenceLookup(baseDir, rels, options.referenceRoots, options.baseUrl) : null;
+    const anchorTargets = resolveAnchorTargets(docs, vault, lookup?.localTarget);
+    const render = (rel, body, title) => {
+        const warnings = new Set(), references = new Set();
+        const linked = (message) => references.add(message);
+        const warn = (message) => warnings.add(message);
+        const ordinary = vaultResolver(rel, vault);
+        const result = toStorage(body, rel, titles, baseDir, {
+            resolveLink: (target, embed) => {
+                if (!lookup || embed || !!vault.assets[target.toLowerCase()])
+                    return ordinary(target, embed);
+                return lookup.resolve(rel, target, true, warn, linked);
+            },
+            rewriteHref: lookup ? href => {
+                if (/^[a-z][a-z0-9+.-]*:|^\/\//i.test(href))
+                    return href;
+                const index = href.indexOf('#'), path = index < 0 ? href : href.slice(0, index);
+                if (!/\.md$/i.test(path))
+                    return href;
+                const found = lookup.resolve(rel, path, false, warn, linked);
+                return found ? found + (index < 0 ? '' : href.slice(index)) : href;
+            } : undefined,
+            anchorIndex: anchors, title,
+            anchorNames: anchorTargets[rel], bodySlugs: docs[rel]?.bodySlugs,
+        });
+        return { ...result, linkWarnings: [...warnings], referenceLinks: [...references] };
+    };
+    return { titles, docs, render };
+}