Two issues here:

1. CSS-selector injection / breakage. #${slug} builds a CSS selector by string interpolation. Slugs are derived from heading text, so any heading containing characters that are not a-z/0-9/-/_ (e.g. 1.2 Title, Foo:Bar, headings starting with a digit, non-ASCII characters that the slugifier may emit) will produce an invalid selector and throw SyntaxError, breaking all subsequent cursor-tracking logic in this listener. The headings are rendered with id=slug already, so use container.querySelector('[id="' + CSS.escape(slug) + '"]') — or, simpler and faster, document.getElementById(slug) (IDs must be unique anyway).

2. Performance. selectionChange fires on every cursor movement (every keypress in some configurations). This loop does N DOM queries per event, where N is the number of headings in the document. For a long doc, that's a measurable hit per keystroke.

Minimal fix: build a slug → element map once per tocData change (watch listToc), then in the listener just iterate the cached entries comparing offsetTop. Optionally throttle via requestAnimationFrame since cursor coordinates only need to update once per frame anyway.

This watcher fires with { immediate: true }, so on mount it immediately sets expandedKeys.value = [] and writes [] to localStorage — wiping any persisted state that loadExpandedKeys() at line 83 just read. The result: the localStorage round-trip is dead code, and persistence across reloads doesn't actually work.

If the intent is "per-file, start collapsed and only expand ancestors of the active heading" (as the comment says), then loadExpandedKeys and the expandedKeys localStorage writes in onNodeExpand / onNodeCollapse should be removed entirely — they cost storage churn and add no behavior.

If the intent is real persistence (the PR body lists "Persist expand/collapse state across sessions" under follow-up, so probably not this PR), then the watcher needs to key by file id and not wipe across the board.

Either way the current shape is incoherent. Pick one direction.

(tree as any).store (repeated at lines 126, 167) — please drop the as any cast and reach for typed access. Element Plus does expose tree.store in its public types (TreeStore), and nodesMap is a documented field. Casting to any hides future breakage when the upstream type changes.

More importantly, mutating nodesMap[key].expanded directly is reaching into Element Plus's internal reactive state. Prefer the public methods: tree.store.setData(...), tree.setCurrentKey(...), or iterating tree.store.nodesMap and calling each node's .expand() / .collapse(). That keeps the integration on the supported surface.

Bug: loadCollapsed (= isCollapsed in collapsedFolders.ts) returns boolean, never null/undefined. ?? only triggers on nullish values, so this fallback is dead code — props.folder.isCollapsed is silently ignored for every folder.

Concretely: any folder the project tree opens with isCollapsed: true (e.g. the persistent-state restore path the rest of the app uses) will now render expanded on first load, until the user explicitly toggles it.

Fix: make isCollapsed() in collapsedFolders.ts return boolean | undefined (return undefined when the pathname isn't in the persisted Set), then ?? works correctly. Or rename + restructure to make the intent explicit, e.g. getPersistedCollapsed(path) returning boolean | undefined.

These bus.on(...) calls register anonymous handlers with no matching bus.off(...) in onBeforeUnmount. Every time a folder is unmounted (e.g. parent collapse, project switch, file deletion) the handlers remain attached, the closures keep the captured isCollapsed ref alive, and the next emit fires against stale components.

For a project with hundreds of folders this is a real memory leak and a correctness bug (you'll see ghost folders flipping state). Mirror the existing pattern — store the handler in a const, attach in onMounted, detach in onBeforeUnmount. Same applies to the other bus.on calls above; the existing ones should probably also have bus.off counterparts but that's pre-existing.

load() calls localStorage.getItem + JSON.parse on every isCollapsed(...) / setCollapsed(...) call. Each <TreeFolder> calls loadCollapsed(props.folder.pathname) on mount, so for a project with N folders that's N parses per render of the tree. Cheap individually, but at hundreds of folders it shows up.

Cache the parsed Set in module scope and re-read only when an external write occurs (or just on first access + after setCollapsed/clearAll/collapseAll).

This watcher is registered inside every <TreeFile> instance. A project with hundreds of .md files = hundreds of watchers all comparing the same currentFile.pathname to their own. Only one of them will ever match per change.

Move this to the parent tree component (tree.vue) as a single watcher that locates the active file's DOM node by data-pathname attribute and scrolls it. Or use the existing bus to emit a single FILE-TREE::scroll-active event the active file row listens for. Either way, one watcher rather than N.

Accessibility nit: the icon-only buttons rely on :title= (tooltip) but no aria-label. Screen readers don't reliably announce title on buttons — add :aria-label="t('sideBar.toc.expandAll')" (and the same for collapse).

Also, the inline SVG path strings are duplicated verbatim in tree.vue (lines 84/91). Extract these into a small <ToolbarIconButton> component, or at least move the path data into a constant — currently the same path is hand-copied four times.

(Pre-existing in this PR but worth flagging: the matching <a href="javascript:;"> pattern in tree.vue should be <button type="button"> for keyboard focus + correct semantics — the rest of the sidebar already uses real buttons.)