@openviking/react 0.1.5 → 0.1.6

package/dist/l~0.js

@@ -1,14 +1,16 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
+import { createElement, useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
 import { FilePreview as file_preview_FilePreview } from "./3~0.js";
-import { Tooltip } from "./r~0.js";
-import { getFileTypeColor, resolveFileTypeIconKey, FolderIcon, getFileTypeIcon } from "./k~0.js";
+import { Tooltip } from "./rt~0.js";
+import { getFileTypeColor, getFileTypeIcon, WikiBookIcon, ExperienceBoardIcon, WikiConflictBoardIcon, FolderIcon, WikiBoardIcon, resolveFileTypeIconKey } from "./k~0.js";
 import { FileBrowserEntries } from "./2~0.js";
 import { FileTree as file_tree_FileTree } from "./n~0.js";
 import { resolveLocale } from "./nx~0.js";
 import { OV_PATHS } from "./ck~0.js";
+import { isOvClientError, useOvSignal, useOvClient } from "./ae~0.js";
+import { ExperienceDashboard } from "./f~0.js";
+import { WikiDashboard } from "./fj~0.js";
 import { useLocale, LocaleProvider } from "./28~0.js";
-import { useOvClient } from "./ae~0.js";
 function clampResizableWidth(width, min, max) {
     const rounded = Math.round(width);
     const lower = Math.max(min, rounded);
@@ -238,6 +240,26 @@ function resolveTreeMaxWidth(containerWidth) {
     if (!containerWidth) return TREE_MAX_WIDTH;
     return Math.max(TREE_MIN_WIDTH, Math.min(TREE_MAX_WIDTH, containerWidth - DETAIL_MIN_WIDTH - RESIZE_FOOTPRINT));
 }
+const en = {
+    experienceTitle: 'Experience dashboard',
+    wikiTitle: 'Dashboard',
+    openExperience: 'Open experience dashboard',
+    openWiki: 'Open Wiki dashboard',
+    wikiConflicts: 'View pending Wiki conflicts',
+    failed: 'Could not load dashboard information'
+};
+const zh = {
+    experienceTitle: '经验看板',
+    wikiTitle: '看板',
+    openExperience: '打开经验看板',
+    openWiki: '打开 Wiki 看板',
+    wikiConflicts: '查看 Wiki 待确认冲突',
+    failed: '看板信息加载失败'
+};
+const dashboard_labels_dashboardLabels = (locale, labels)=>({
+        ...'zh-CN' === locale ? zh : en,
+        ...labels
+    });
 const file_browser_icons_SIZE = 16;
 const strokeProps = {
     width: file_browser_icons_SIZE,
@@ -304,6 +326,25 @@ function FileBrowserToolbar({ searchId, query, refreshing, canRefresh, placehold
         ]
     });
 }
+function DashboardIndicator({ dashboard, locale, labels, onOpen }) {
+    const text = dashboard_labels_dashboardLabels(locale, labels);
+    const label = 'experience' === dashboard.kind ? text.openExperience : dashboard.pendingConflicts ? text.wikiConflicts : text.openWiki;
+    const Icon = 'experience' === dashboard.kind ? ExperienceBoardIcon : dashboard.pendingConflicts ? WikiConflictBoardIcon : WikiBoardIcon;
+    return /*#__PURE__*/ jsx("button", {
+        type: "button",
+        className: `ov-file-browser__dashboard${dashboard.pendingConflicts ? ' ov-file-browser__dashboard--pending' : ''}`,
+        "aria-label": label,
+        title: label,
+        onClick: (event)=>{
+            event.stopPropagation();
+            onOpen(dashboard.uri);
+        },
+        children: /*#__PURE__*/ jsx(Icon, {
+            width: 12,
+            height: 12
+        })
+    });
+}
 function fileTypeIcon(name) {
     const Icon = getFileTypeIcon(name);
     const key = resolveFileTypeIconKey(name);
@@ -320,7 +361,7 @@ function directoryIcon() {
         className: "ov-file-tree__file-type-icon"
     });
 }
-function FileBrowserTreePane({ entries, locale, searchId, browser, treeLabels, searchPlaceholder, refreshLabel, searchLoading, searchEmpty, searchErrorLabel, retryLabel }) {
+function FileBrowserTreePane({ entries, locale, dashboardLabels, searchId, browser, treeLabels, searchPlaceholder, refreshLabel, searchLoading, searchEmpty, searchErrorLabel, retryLabel }) {
     return /*#__PURE__*/ jsxs(Fragment, {
         children: [
             /*#__PURE__*/ jsx(FileBrowserEntries, {
@@ -338,44 +379,77 @@ function FileBrowserTreePane({ entries, locale, searchId, browser, treeLabels, s
                 onQueryChange: browser.actions.setQuery,
                 onRefresh: ()=>void browser.actions.refresh()
             }),
-            /*#__PURE__*/ jsx("div", {
+            /*#__PURE__*/ jsxs("div", {
                 className: "ov-file-browser__tree-scroll",
-                children: /*#__PURE__*/ jsx(file_tree_FileTree, {
-                    locale: locale,
-                    rows: browser.rows,
-                    selectedId: browser.selectedId,
-                    isReady: browser.isReady,
-                    labels: treeLabels,
-                    emptyFallback: browser.searching ? browser.searchError ? /*#__PURE__*/ jsxs("div", {
+                children: [
+                    browser.dashboardError ? /*#__PURE__*/ jsxs("div", {
                         className: "ov-file-browser__hint ov-file-browser__hint--error",
+                        "aria-live": "polite",
                         children: [
-                            /*#__PURE__*/ jsx("p", {
-                                className: "ov-file-browser__failure-title",
-                                children: searchErrorLabel
-                            }),
-                            /*#__PURE__*/ jsx("p", {
-                                className: "ov-file-browser__failure-detail",
-                                children: browser.searchError.message
+                            /*#__PURE__*/ jsxs("p", {
+                                children: [
+                                    dashboard_labels_dashboardLabels(locale, dashboardLabels).failed,
+                                    ":",
+                                    ' ',
+                                    browser.dashboardError.message
+                                ]
                             }),
                             /*#__PURE__*/ jsx("button", {
                                 type: "button",
-                                className: "ov-file-browser__retry",
                                 onClick: ()=>void browser.actions.refresh(),
                                 children: retryLabel
                             })
                         ]
-                    }) : /*#__PURE__*/ jsx("p", {
-                        className: "ov-file-browser__hint",
-                        children: browser.searchLoading ? searchLoading : searchEmpty
-                    }) : void 0,
-                    renderRowIcon: (row)=>fileTypeIcon(row.name),
-                    operations: {
-                        select: browser.actions.select,
-                        toggleExpand: browser.actions.toggleExpand,
-                        loadMore: browser.actions.loadMore,
-                        retry: browser.actions.retry
-                    }
-                })
+                    }) : null,
+                    /*#__PURE__*/ jsx(file_tree_FileTree, {
+                        locale: locale,
+                        rows: browser.rows,
+                        selectedId: browser.selectedId,
+                        isReady: browser.isReady,
+                        labels: treeLabels,
+                        emptyFallback: browser.searching ? browser.searchError ? /*#__PURE__*/ jsxs("div", {
+                            className: "ov-file-browser__hint ov-file-browser__hint--error",
+                            children: [
+                                /*#__PURE__*/ jsx("p", {
+                                    className: "ov-file-browser__failure-title",
+                                    children: searchErrorLabel
+                                }),
+                                /*#__PURE__*/ jsx("p", {
+                                    className: "ov-file-browser__failure-detail",
+                                    children: browser.searchError.message
+                                }),
+                                /*#__PURE__*/ jsx("button", {
+                                    type: "button",
+                                    className: "ov-file-browser__retry",
+                                    onClick: ()=>void browser.actions.refresh(),
+                                    children: retryLabel
+                                })
+                            ]
+                        }) : /*#__PURE__*/ jsx("p", {
+                            className: "ov-file-browser__hint",
+                            children: browser.searchLoading ? searchLoading : searchEmpty
+                        }) : void 0,
+                        renderRowIcon: (row)=>browser.dashboards.get(row.uri)?.isRoot ? /*#__PURE__*/ jsx(WikiBookIcon, {
+                                width: 14,
+                                height: 14
+                            }) : fileTypeIcon(row.name),
+                        renderDashboard: (row)=>{
+                            const dashboard = browser.dashboards.get(row.uri);
+                            return dashboard ? /*#__PURE__*/ jsx(DashboardIndicator, {
+                                dashboard: dashboard,
+                                locale: locale,
+                                labels: dashboardLabels,
+                                onOpen: browser.actions.openDashboard
+                            }) : null;
+                        },
+                        operations: {
+                            select: browser.actions.select,
+                            toggleExpand: browser.actions.toggleExpand,
+                            loadMore: browser.actions.loadMore,
+                            retry: browser.actions.retry
+                        }
+                    })
+                ]
             })
         ]
     });
@@ -476,6 +550,11 @@ function useContainerWidth() {
         width
     };
 }
+function selectedRowId(uri, results) {
+    if (!uri || null === results) return uri;
+    const index = results.findIndex((entry)=>entry.uri === uri);
+    return index < 0 ? uri : `${uri}#${index}`;
+}
 const emptyDir = ()=>({
         entries: [],
         hasMore: false,
@@ -503,6 +582,7 @@ function nameFromUri(uri) {
 function toEntryRow(entry, depth, expanded, index, busy) {
     const isDir = true === entry.isDir;
     return {
+        tags: entry.tags,
         kind: 'entry',
         id: void 0 === index ? entry.uri : `${entry.uri}#${index}`,
         depth,
@@ -513,7 +593,7 @@ function toEntryRow(entry, depth, expanded, index, busy) {
         busy: busy || void 0
     };
 }
-function toFileTab(entry, content, maxLines, icon, openParent) {
+function toFileTab(entry, content, maxLines, icon, openParent, truncated = content.split('\n').length >= maxLines) {
     const name = nameFromUri(entry.uri);
     return {
         kind: 'file',
@@ -527,7 +607,7 @@ function toFileTab(entry, content, maxLines, icon, openParent) {
             content,
             fileName: name,
             path: entry.uri,
-            truncated: content.split('\n').length >= maxLines
+            truncated
         }
     };
 }
@@ -612,6 +692,39 @@ function isAbort(error) {
 function toError(cause) {
     return cause instanceof Error ? cause : new Error(String(cause));
 }
+async function readDirectory(client, uri, options) {
+    const read = (path)=>client.request({
+            method: 'GET',
+            path,
+            query: {
+                uri
+            },
+            options
+        }).then((value)=>({
+                ok: true,
+                text: 'string' == typeof value ? value : ''
+            })).catch((cause)=>({
+                ok: false,
+                cause
+            }));
+    const [abstractResult, overviewResult] = await Promise.all([
+        read(OV_PATHS.contentAbstract),
+        read(OV_PATHS.contentOverview)
+    ]);
+    const aborted = [
+        abstractResult,
+        overviewResult
+    ].find((result)=>!result.ok && isAbort(result.cause));
+    if (aborted && !aborted.ok) throw aborted.cause;
+    if (!abstractResult.ok && !overviewResult.ok) throw abstractResult.cause;
+    const reason = (result)=>result.ok ? void 0 : result.cause instanceof Error ? result.cause.message : String(result.cause);
+    return {
+        abstract: abstractResult.ok ? abstractResult.text : '',
+        overview: overviewResult.ok ? overviewResult.text : '',
+        abstractError: reason(abstractResult),
+        overviewError: reason(overviewResult)
+    };
+}
 const BINARY_EXTENSIONS = new Set([
     'png',
     'jpg',
@@ -695,38 +808,152 @@ function toBinaryTab(uri, name, file, icon, openParent) {
         }
     };
 }
-async function readDirectory(client, uri, options) {
-    const read = (path)=>client.request({
+const LINE_BREAK_CODES = new Set([
+    0x0a,
+    0x0b,
+    0x0c,
+    0x0d,
+    0x1c,
+    0x1d,
+    0x1e,
+    0x85,
+    0x2028,
+    0x2029
+]);
+function splitLines(text) {
+    if (!text) return [];
+    const lines = [];
+    let start = 0;
+    for(let index = 0; index < text.length; index++){
+        if (!LINE_BREAK_CODES.has(text.charCodeAt(index))) continue;
+        const paired = 0x0d === text.charCodeAt(index) && 0x0a === text.charCodeAt(index + 1);
+        const end = index + (paired ? 2 : 1);
+        lines.push(text.slice(start, end));
+        start = end;
+        index = end - 1;
+    }
+    if (start < text.length) lines.push(text.slice(start));
+    return lines;
+}
+function joinLines(lines) {
+    return lines.join('');
+}
+const PY_WHITESPACE_CODES = [
+    0x09,
+    0x0a,
+    0x0b,
+    0x0c,
+    0x0d,
+    0x1c,
+    0x1d,
+    0x1e,
+    0x1f,
+    0x20,
+    0x85,
+    0xa0,
+    0x1680,
+    0x2000,
+    0x2001,
+    0x2002,
+    0x2003,
+    0x2004,
+    0x2005,
+    0x2006,
+    0x2007,
+    0x2008,
+    0x2009,
+    0x200a,
+    0x2028,
+    0x2029,
+    0x202f,
+    0x205f,
+    0x3000
+];
+const PY_WHITESPACE = String.fromCharCode(...PY_WHITESPACE_CODES);
+const PY_WORD = '\\p{L}\\p{N}_';
+const MEMORY_FIELDS_COMMENT = new RegExp(`<!--[${PY_WHITESPACE}]*MEMORY_FIELDS(?![${PY_WORD}])[\\s\\S]*?[${PY_WHITESPACE}]*-->`, 'gu');
+function isPythonBlank(text) {
+    for (const char of text)if (!PY_WHITESPACE.includes(char)) return false;
+    return true;
+}
+function trimPythonEnd(text) {
+    let end = text.length;
+    while(end > 0 && PY_WHITESPACE.includes(text[end - 1] ?? ''))end--;
+    return text.slice(0, end);
+}
+function uriParts(uri) {
+    const [beforeQuery = ''] = uri.split('?');
+    const path = beforeQuery.replace(/\/+$/, '');
+    if (!path.startsWith('viking://')) return [];
+    return path.slice(9).split('/').filter(Boolean);
+}
+function isMemoryUri(uri) {
+    const parts = uriParts(uri);
+    if (parts.length < 3) return false;
+    if ('user' !== parts[0] && '~' !== parts[0]) return false;
+    const scoped = '~' === parts[0] ? [
+        'user',
+        '~',
+        ...parts.slice(1)
+    ] : parts;
+    if ('memories' === scoped[2]) return true;
+    return scoped.length >= 5 && 'peers' === scoped[2] && 'memories' === scoped[4];
+}
+function stripMemoryFieldsTrailer(text) {
+    let visible = text;
+    for(;;){
+        let start = -1;
+        MEMORY_FIELDS_COMMENT.lastIndex = 0;
+        let match;
+        while(null !== (match = MEMORY_FIELDS_COMMENT.exec(visible))){
+            const after = visible.slice(match.index + match[0].length);
+            if (isPythonBlank(after)) start = match.index;
+        }
+        if (start < 0) return visible;
+        visible = trimPythonEnd(visible.slice(0, start));
+    }
+}
+const MAX_LINES = 2000;
+async function readFile(client, uri, options, openParent) {
+    const name = nameFromUri(uri);
+    const icon = fileTypeIcon(name);
+    if (isBinaryFile(name)) {
+        const blob = await client.request({
             method: 'GET',
-            path,
+            path: OV_PATHS.contentDownload,
             query: {
                 uri
             },
+            responseType: 'blob',
             options
-        }).then((value)=>({
-                ok: true,
-                text: 'string' == typeof value ? value : ''
-            })).catch((cause)=>({
-                ok: false,
-                cause
-            }));
-    const [abstractResult, overviewResult] = await Promise.all([
-        read(OV_PATHS.contentAbstract),
-        read(OV_PATHS.contentOverview)
-    ]);
-    const aborted = [
-        abstractResult,
-        overviewResult
-    ].find((result)=>!result.ok && isAbort(result.cause));
-    if (aborted && !aborted.ok) throw aborted.cause;
-    if (!abstractResult.ok && !overviewResult.ok) throw abstractResult.cause;
-    const reason = (result)=>result.ok ? void 0 : result.cause instanceof Error ? result.cause.message : String(result.cause);
-    return {
-        abstract: abstractResult.ok ? abstractResult.text : '',
-        overview: overviewResult.ok ? overviewResult.text : '',
-        abstractError: reason(abstractResult),
-        overviewError: reason(overviewResult)
-    };
+        });
+        const typed = new Blob([
+            blob
+        ], {
+            type: mimeTypeOf(name)
+        });
+        return toBinaryTab(uri, name, typed, icon, openParent);
+    }
+    const read = (limit)=>client.request({
+            method: 'GET',
+            path: OV_PATHS.contentRead,
+            query: {
+                uri,
+                limit
+            },
+            options
+        }).then((value)=>'string' == typeof value ? value : '');
+    const first = await read(MAX_LINES);
+    if (!isMemoryUri(uri)) return toFileTab({
+        uri
+    }, first, MAX_LINES, icon, openParent, splitLines(first).length >= MAX_LINES);
+    const full = splitLines(first).length < MAX_LINES ? first : await read(-1);
+    const lines = splitLines(stripMemoryFieldsTrailer(full));
+    const truncated = lines.length > MAX_LINES;
+    const visible = joinLines(truncated ? lines.slice(0, MAX_LINES) : lines);
+    return toFileTab({
+        uri
+    }, visible, MAX_LINES, icon, openParent, truncated);
 }
 async function resolveIsDirectory(client, uri, options) {
     try {
@@ -748,7 +975,6 @@ function abortError() {
     error.name = 'AbortError';
     return error;
 }
-const MAX_LINES = 2000;
 function useFsPreview({ client, uri, resourceType = 'file', labels = resolveSummaryLabels('en-US'), formatCharacterCount = resolveLabels(void 0, 'en-US').formatCharacterCount, openParent, generation = 0, requestOptions }) {
     const [directory, setDirectory] = useState(null);
     const [tabs, setTabs] = useState(null);
@@ -867,39 +1093,6 @@ function loadingTab(uri, isDirectory) {
         }
     };
 }
-async function readFile(client, uri, options, openParent) {
-    const name = nameFromUri(uri);
-    const icon = fileTypeIcon(name);
-    if (isBinaryFile(name)) {
-        const blob = await client.request({
-            method: 'GET',
-            path: OV_PATHS.contentDownload,
-            query: {
-                uri
-            },
-            responseType: 'blob',
-            options
-        });
-        const typed = new Blob([
-            blob
-        ], {
-            type: mimeTypeOf(name)
-        });
-        return toBinaryTab(uri, name, typed, icon, openParent);
-    }
-    const content = await client.request({
-        method: 'GET',
-        path: OV_PATHS.contentRead,
-        query: {
-            uri,
-            limit: MAX_LINES
-        },
-        options
-    });
-    return toFileTab({
-        uri
-    }, 'string' == typeof content ? content : '', MAX_LINES, icon, openParent);
-}
 function mergeFindResult(result) {
     const seen = new Set();
     const entries = [];
@@ -971,6 +1164,659 @@ function useFsSearch({ client, query, targetUri, generation = 0, requestOptions
         error
     };
 }
+const isHomeUri = (uri)=>'viking://~' === uri || uri.startsWith('viking://~/');
+async function readDashboardStat(client, uri, options) {
+    const stat = await client.request({
+        method: 'GET',
+        path: OV_PATHS.fsStat,
+        query: {
+            uri
+        },
+        options
+    });
+    const canonical = stat?.uri ?? uri;
+    if ('boolean' != typeof stat?.isDir || 'string' != typeof canonical || !canonical || isHomeUri(canonical)) throw new TypeError('Invalid canonical resource stat');
+    return {
+        uri: canonical,
+        isDir: stat.isDir
+    };
+}
+async function resolveDashboardUri(client, uri, options) {
+    return isHomeUri(uri) ? (await readDashboardStat(client, uri, options)).uri : uri;
+}
+async function readDashboardHint(client, uri, options) {
+    const result = await client.request({
+        method: 'GET',
+        path: OV_PATHS.fsAttrs,
+        query: {
+            uri
+        },
+        options
+    });
+    return {
+        uri: await resolveDashboardUri(client, result?.uri ?? uri, options),
+        tags: result?.attrs?.tags ?? []
+    };
+}
+const EXPERIENCE_PAGE_SIZE = 20;
+const isExperienceDirectory = (uri)=>/^viking:\/\/(?:user\/[^/]+|~)\/memories\/experiences\/?$/.test(uri);
+const isExperienceFile = (uri)=>/^viking:\/\/(?:user\/[^/]+|~)\/memories\/experiences\/[^/]+\.md$/i.test(uri);
+function experienceDateRange(days, now = new Date()) {
+    if (!days) return {};
+    const start = new Date(now);
+    start.setUTCDate(start.getUTCDate() - days + 1);
+    return {
+        start_date: start.toISOString().slice(0, 10),
+        end_date: now.toISOString().slice(0, 10)
+    };
+}
+async function readExperiences(client, uri, page, options) {
+    uri = await resolveDashboardUri(client, uri, options);
+    const result = await client.requestEnvelope({
+        method: 'GET',
+        path: OV_PATHS.fsLs,
+        query: {
+            uri,
+            output: 'original',
+            limit: EXPERIENCE_PAGE_SIZE,
+            offset: page * EXPERIENCE_PAGE_SIZE,
+            sort_by: 'mtime',
+            sort_order: 'desc'
+        },
+        options
+    });
+    if (!Array.isArray(result.result)) throw new TypeError('Invalid Experience listing');
+    const prefix = `${uri.replace(/\/+$/, '')}/`;
+    return {
+        items: result.result.filter((item)=>!item.isDir && item.uri.startsWith(prefix) && isExperienceFile(item.uri)),
+        hasMore: result.hasMore
+    };
+}
+async function readExperienceSources(client, uri, options) {
+    uri = await resolveDashboardUri(client, uri, options);
+    const result = await client.request({
+        method: 'GET',
+        path: OV_PATHS.fsAttrs,
+        query: {
+            uri
+        },
+        options
+    });
+    const links = result?.attrs?.memory?.links;
+    if (void 0 !== links && !Array.isArray(links)) throw new TypeError('Invalid Experience links');
+    const prefix = uri.slice(0, uri.indexOf('/memories/experiences/')) + '/memories/trajectories/';
+    const seen = new Set();
+    return (links ?? []).flatMap((link)=>{
+        if ('derived_from' !== link.link_type || 'string' != typeof link.to_uri || !link.to_uri.startsWith(prefix) || seen.has(link.to_uri)) return [];
+        seen.add(link.to_uri);
+        return [
+            {
+                uri: link.to_uri,
+                name: link.to_uri.split('/').pop() ?? link.to_uri,
+                description: link.description ?? link.match_text
+            }
+        ];
+    });
+}
+const dashboardKey = (uri)=>`dashboard:${uri}`;
+const within = (uri, root)=>uri === root || uri.startsWith(`${root.replace(/\/+$/, '')}/`);
+function resolveDashboard(uri, rows, targets) {
+    if (isExperienceDirectory(uri) || isExperienceFile(uri)) return {
+        kind: 'experience',
+        uri
+    };
+    const entries = rows.filter((row)=>'entry' === row.kind);
+    const row = entries.find((item)=>item.uri === uri);
+    const hasWiki = entries.some((item)=>item.tags?.includes('compile_target=true') && within(uri, item.uri));
+    const owner = targets.filter((item)=>within(uri, item.to)).sort((a, b)=>b.to.length - a.to.length)[0];
+    if (!hasWiki && !owner) return;
+    const tagged = row?.tags?.find((tag)=>tag.startsWith('has_conflict='));
+    return {
+        kind: 'wiki',
+        uri,
+        isRoot: Boolean(row?.tags?.includes('compile_target=true') || owner?.to === uri),
+        pendingConflicts: tagged ? 'has_conflict=true' === tagged : owner?.to === uri && void 0 !== owner.conflicts_num ? owner.conflicts_num > 0 : void 0
+    };
+}
+async function readCompileTargets(client, rootUri, options) {
+    rootUri = await resolveDashboardUri(client, rootUri, options);
+    const targets = [];
+    let cursor;
+    const seen = new Set();
+    do {
+        const result = await client.request({
+            method: 'GET',
+            path: OV_PATHS.compileConfigs,
+            query: {
+                limit: 100,
+                cursor
+            },
+            options
+        });
+        if (!Array.isArray(result?.targets)) throw new TypeError('Invalid Compile target registry');
+        targets.push(...result.targets.filter((item)=>'string' == typeof item.to && 'memory' !== item.compile_type && false !== item.initialized && (within(item.to, rootUri) || within(rootUri, item.to))));
+        cursor = result.next_cursor ?? void 0;
+        if (cursor && seen.has(cursor)) throw new TypeError('Compile target cursor did not advance');
+        if (cursor) seen.add(cursor);
+    }while (cursor)
+    return targets;
+}
+function useDashboardQuery(load, requestOptions, enabled = true, refreshGeneration = 0) {
+    const client = useOvClient();
+    const inheritedSignal = useOvSignal();
+    const { baseURL, apiKey, accountId, userId, resourceId, signal } = requestOptions ?? {};
+    const [generation, setGeneration] = useState(0);
+    const [state, setState] = useState({
+        owner: [],
+        error: null
+    });
+    const owner = useMemo(()=>[
+            client,
+            load,
+            baseURL,
+            apiKey,
+            accountId,
+            userId,
+            resourceId,
+            signal,
+            inheritedSignal,
+            generation,
+            enabled,
+            refreshGeneration
+        ], [
+        client,
+        load,
+        baseURL,
+        apiKey,
+        accountId,
+        userId,
+        resourceId,
+        signal,
+        inheritedSignal,
+        generation,
+        enabled,
+        refreshGeneration
+    ]);
+    const current = owner.every((value, i)=>value === state.owner[i]);
+    useEffect(()=>{
+        if (!enabled) return;
+        if (!client) return void setState({
+            owner,
+            error: new Error('OpenVikingProvider is required')
+        });
+        const controller = new AbortController();
+        const signals = [
+            controller.signal,
+            signal,
+            inheritedSignal
+        ].filter((value)=>Boolean(value));
+        const options = {
+            baseURL,
+            apiKey,
+            accountId,
+            userId,
+            resourceId,
+            signal: AbortSignal.any(signals)
+        };
+        load(client, options).then((data)=>{
+            if (!options.signal.aborted) setState({
+                owner,
+                data,
+                error: null
+            });
+        }, (cause)=>{
+            if (!options.signal.aborted) setState({
+                owner,
+                error: cause instanceof Error ? cause : new Error(String(cause))
+            });
+        });
+        return ()=>controller.abort();
+    }, [
+        client,
+        load,
+        baseURL,
+        apiKey,
+        accountId,
+        userId,
+        resourceId,
+        signal,
+        inheritedSignal,
+        generation,
+        enabled,
+        owner
+    ]);
+    return {
+        data: current ? state.data : void 0,
+        loading: enabled && !current,
+        error: current ? state.error : null,
+        retry: ()=>setGeneration((value)=>value + 1)
+    };
+}
+function useExperienceDashboard({ uri, requestOptions, enabled = true, refreshGeneration = 0 }) {
+    const client = useOvClient();
+    const signal = useOvSignal();
+    const owner = useMemo(()=>[
+            uri,
+            client,
+            signal,
+            requestOptions?.baseURL,
+            requestOptions?.apiKey,
+            requestOptions?.accountId,
+            requestOptions?.userId,
+            requestOptions?.resourceId
+        ], [
+        uri,
+        client,
+        signal,
+        requestOptions?.baseURL,
+        requestOptions?.apiKey,
+        requestOptions?.accountId,
+        requestOptions?.userId,
+        requestOptions?.resourceId
+    ]);
+    const [state, setState] = useState({
+        owner,
+        page: 0,
+        days: 7,
+        tab: 'impact'
+    });
+    const current = state.owner === owner ? state : {
+        owner,
+        page: 0,
+        days: 7,
+        tab: 'impact'
+    };
+    const { page, days, tab } = current;
+    const setPage = (value)=>setState({
+            ...current,
+            page: Math.max(0, value)
+        });
+    const setDays = (value)=>setState({
+            ...current,
+            days: value,
+            page: 0
+        });
+    const setTab = (value)=>setState({
+            ...current,
+            tab: value,
+            page: 0
+        });
+    const directory = isExperienceDirectory(uri);
+    const loadList = useCallback((client, options)=>readExperiences(client, uri, page, options), [
+        uri,
+        page
+    ]);
+    const loadSources = useCallback((client, options)=>readExperienceSources(client, uri, options), [
+        uri
+    ]);
+    const loadTrajectories = useCallback(async (client, options)=>{
+        const result = await client.request({
+            method: 'GET',
+            path: OV_PATHS.experienceTrajectories,
+            query: {
+                experience_uri: uri,
+                offset: 20 * page,
+                limit: 20,
+                ...experienceDateRange(days)
+            },
+            options
+        });
+        if (!Array.isArray(result?.items) || !Number.isSafeInteger(result.total) || result.total < 0 || result.items.some((item)=>'string' != typeof item?.uri || 'string' != typeof item.name)) throw new TypeError('Invalid Experience trajectories');
+        return result;
+    }, [
+        uri,
+        page,
+        days
+    ]);
+    const loadOutcomes = useCallback(async (client, options)=>{
+        const result = await client.request({
+            method: 'GET',
+            path: OV_PATHS.experienceOutcomes,
+            query: {
+                experience_uri: uri,
+                ...experienceDateRange(days)
+            },
+            options
+        });
+        if (!Array.isArray(result?.outcome_distribution) || result.outcome_distribution.some((entry)=>![
+                'success',
+                'partial',
+                'unfinished',
+                'failure',
+                'unknown'
+            ].includes(entry?.outcome) || !Number.isSafeInteger(entry.count) || entry.count < 0)) throw new TypeError('Invalid Experience outcomes');
+        return result.outcome_distribution;
+    }, [
+        uri,
+        days
+    ]);
+    const list = useDashboardQuery(loadList, requestOptions, enabled && directory, refreshGeneration);
+    const sources = useDashboardQuery(loadSources, requestOptions, enabled && !directory && 'source' === tab, refreshGeneration);
+    const trajectories = useDashboardQuery(loadTrajectories, requestOptions, enabled && !directory && 'impact' === tab, refreshGeneration);
+    const outcomes = useDashboardQuery(loadOutcomes, requestOptions, enabled && !directory && 'impact' === tab, refreshGeneration);
+    return {
+        list,
+        sources,
+        trajectories,
+        outcomes,
+        page,
+        setPage,
+        days,
+        setDays,
+        tab,
+        setTab
+    };
+}
+function ExperienceDashboardPane({ uri, locale, requestOptions, refreshGeneration, onOpenUri }) {
+    const browser = useExperienceDashboard({
+        uri,
+        requestOptions,
+        refreshGeneration
+    });
+    const directory = isExperienceDirectory(uri);
+    const status = (query)=>({
+            loading: query.loading,
+            error: query.error,
+            onRetry: query.retry
+        });
+    return /*#__PURE__*/ jsx(ExperienceDashboard, {
+        uri: uri,
+        kind: directory ? 'directory' : 'file',
+        locale: locale,
+        onOpenUri: onOpenUri,
+        data: {
+            experiences: browser.list.data?.items,
+            outcomes: browser.outcomes.data,
+            trajectories: browser.trajectories.data?.items,
+            trajectoryTotal: browser.trajectories.data?.total,
+            sources: browser.sources.data
+        },
+        tab: browser.tab,
+        days: browser.days,
+        page: browser.page,
+        startIndex: 20 * browser.page,
+        hasMore: Boolean(directory ? browser.list.data?.hasMore : 'impact' === browser.tab && browser.trajectories.data?.has_more),
+        states: {
+            list: status(browser.list),
+            sources: status(browser.sources),
+            outcomes: status(browser.outcomes),
+            trajectories: status(browser.trajectories)
+        },
+        onTabChange: browser.setTab,
+        onDaysChange: browser.setDays,
+        onPageChange: browser.setPage
+    });
+}
+const wiki_conflicts_prefix = '<!-- CONFLICTS_CONTENT';
+const manualResolutionBasis = '\u4eba\u5de5\u4fee\u590d';
+const timestamp = (value)=>'number' == typeof value && Number.isSafeInteger(value) && value >= 0 && Number.isFinite(new Date(1000 * value).getTime());
+const locateWikiConflict = (document, matchText)=>{
+    const mask = (value)=>value.replace(/[^\r\n]/g, ' ');
+    const body = document.replace(/^(?:\uFEFF)?---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/, mask).replace(/<!--[\s\S]*?(?:-->|$)/g, mask);
+    const start = matchText ? body.indexOf(matchText) : -1;
+    if (start < 0) return {
+        status: 'missing'
+    };
+    if (body.indexOf(matchText, start + 1) >= 0) return {
+        status: 'ambiguous'
+    };
+    return {
+        status: 'unique',
+        start,
+        end: start + matchText.length,
+        line: document.slice(0, start).split('\n').length
+    };
+};
+const parseWikiFileConflicts = (content)=>{
+    const start = content.lastIndexOf(wiki_conflicts_prefix);
+    if (start < 0) return {
+        status: 'missing'
+    };
+    const footer = content.slice(start).trimEnd();
+    if (!footer.endsWith('-->')) return {
+        status: 'invalid'
+    };
+    const document = content.slice(0, start);
+    const source = footer.slice(wiki_conflicts_prefix.length, -3).trim();
+    let parsed;
+    try {
+        parsed = source ? JSON.parse(`[${source}]`) : [];
+    } catch  {
+        return {
+            status: 'invalid'
+        };
+    }
+    if (!Array.isArray(parsed)) return {
+        status: 'invalid'
+    };
+    const records = [];
+    for (const [index, raw] of parsed.entries()){
+        if (!raw || 'object' != typeof raw || Array.isArray(raw)) return {
+            status: 'invalid'
+        };
+        const value = raw;
+        if ('string' != typeof value.match_text || !value.match_text || 'string' != typeof value.problem_description || 'string' != typeof value.reason || ![
+            'high',
+            'medium',
+            'low'
+        ].includes(value.severity) || ![
+            'unfixed',
+            'fixed'
+        ].includes(value.state) || !timestamp(value.begin_time) || 'string' != typeof value.fix_plan || 'string' != typeof value.resolution_basis) return {
+            status: 'invalid'
+        };
+        if ('fixed' === value.state ? !timestamp(value.fix_time) || value.fix_time < value.begin_time : null !== value.fix_time) return {
+            status: 'invalid'
+        };
+        const matchText = value.match_text;
+        const location = locateWikiConflict(document, matchText);
+        records.push({
+            id: JSON.stringify([
+                index,
+                value.begin_time,
+                matchText
+            ]),
+            matchText,
+            description: value.problem_description,
+            reason: value.reason,
+            severity: value.severity,
+            state: value.state,
+            beginTime: value.begin_time,
+            fixTime: value.fix_time,
+            fixPlan: value.fix_plan,
+            resolutionBasis: value.resolution_basis,
+            resolutionSource: 'fixed' === value.state && value.resolution_basis.trim() ? value.resolution_basis.trim() === manualResolutionBasis ? 'manual' : 'automatic' : void 0,
+            location
+        });
+    }
+    return {
+        status: 'available',
+        document,
+        records
+    };
+};
+async function readWikiDashboard(client, uri, options) {
+    const stat = await readDashboardStat(client, uri, options);
+    uri = stat.uri;
+    if (!stat.isDir) {
+        const result = await client.request({
+            method: 'GET',
+            path: OV_PATHS.contentRead,
+            query: {
+                uri,
+                limit: -1
+            },
+            options
+        });
+        if ('string' != typeof result) throw new TypeError('Invalid Wiki content response');
+        const parsed = parseWikiFileConflicts(result);
+        if ('invalid' === parsed.status) throw new TypeError('Invalid CONFLICTS_CONTENT metadata');
+        return {
+            kind: 'file',
+            data: {
+                path: uri,
+                conflicts: 'available' === parsed.status ? parsed.records : []
+            }
+        };
+    }
+    const page = await client.requestEnvelope({
+        method: 'GET',
+        path: OV_PATHS.fsLs,
+        query: {
+            uri,
+            recursive: true,
+            output: 'agent',
+            tags: [
+                'has_conflict=true'
+            ],
+            limit: 100,
+            sort_by: 'mtime',
+            sort_order: 'desc'
+        },
+        options
+    });
+    if (!Array.isArray(page.result)) throw new TypeError('Invalid Wiki conflict listing');
+    const prefix = `${uri.replace(/\/+$/, '')}/`;
+    const files = page.result.filter((entry)=>!entry.isDir && entry.uri.startsWith(prefix)).map((entry)=>entry.uri);
+    return {
+        kind: 'directory',
+        data: {
+            files,
+            conflictFileCount: files.length,
+            limited: page.hasMore || files.length >= 100
+        }
+    };
+}
+function useWikiDashboard({ uri, requestOptions, enabled = true, refreshGeneration = 0 }) {
+    const load = useCallback((client, options)=>readWikiDashboard(client, uri, options), [
+        uri
+    ]);
+    return useDashboardQuery(load, requestOptions, enabled, refreshGeneration);
+}
+function WikiDashboardPane({ uri, kind, requestOptions, refreshGeneration, onOpenUri, onOpenDashboard, onEdit, onDiscuss, ...props }) {
+    const query = useWikiDashboard({
+        uri,
+        requestOptions,
+        refreshGeneration
+    });
+    const common = {
+        ...props,
+        loading: query.loading,
+        error: query.error,
+        onRetry: query.retry
+    };
+    if ((query.data?.kind ?? kind) === 'file') return /*#__PURE__*/ createElement(WikiDashboard, {
+        ...common,
+        key: uri,
+        kind: "file",
+        data: query.data?.kind === 'file' ? query.data.data : void 0,
+        onOpenUri: onOpenUri && (()=>onOpenUri(uri)),
+        onEdit: onEdit && ((conflict)=>onEdit(uri, conflict)),
+        onDiscuss: onDiscuss && ((conflict)=>onDiscuss(uri, conflict))
+    });
+    return /*#__PURE__*/ createElement(WikiDashboard, {
+        ...common,
+        key: uri,
+        kind: "directory",
+        data: query.data?.kind === 'directory' ? query.data.data : void 0,
+        onOpenUri: onOpenUri,
+        onOpenDashboard: onOpenDashboard,
+        onEdit: onEdit
+    });
+}
+function useBrowserDashboards({ rows, metadataRows, uri, rootUri, generation, locale, requestOptions, onOpenUri, dashboardKinds, renderDashboard, dashboardLabels }) {
+    const [opened, setOpened] = useState(null);
+    const load = useCallback((client, options)=>readCompileTargets(client, rootUri, options), [
+        rootUri
+    ]);
+    const wikiEnabled = void 0 === dashboardKinds || dashboardKinds.includes('wiki');
+    const catalog = useDashboardQuery(load, requestOptions, wikiEnabled, generation);
+    const loadHint = useCallback(async (client, options)=>uri ? readDashboardHint(client, uri, options) : void 0, [
+        uri
+    ]);
+    const hint = useDashboardQuery(loadHint, requestOptions, wikiEnabled && Boolean(uri), generation);
+    const canonicalUri = hint.data?.uri ?? uri;
+    const knownRows = canonicalUri && hint.data?.tags.includes('compile_target=true') ? [
+        ...metadataRows,
+        {
+            kind: 'entry',
+            uri: canonicalUri,
+            id: canonicalUri,
+            name: canonicalUri,
+            depth: 0,
+            type: 'directory',
+            tags: hint.data.tags
+        }
+    ] : metadataRows;
+    const unsupported = isOvClientError(catalog.error) && 404 === catalog.error.statusCode;
+    const targets = catalog.data ?? [];
+    const resolve = (target)=>{
+        const match = resolveDashboard(target === uri ? canonicalUri ?? target : target, knownRows, targets);
+        return match ? {
+            ...match,
+            uri: target
+        } : void 0;
+    };
+    const dashboards = new Map(rows.filter((row)=>'entry' === row.kind).flatMap((row)=>{
+        const dashboard = resolve(row.uri);
+        return dashboard && (void 0 === dashboardKinds || dashboardKinds.includes(dashboard.kind)) ? [
+            [
+                row.uri,
+                dashboard
+            ]
+        ] : [];
+    }));
+    const resolved = uri ? resolve(uri) : void 0;
+    const current = resolved && (void 0 === dashboardKinds || dashboardKinds.includes(resolved.kind)) ? resolved : void 0;
+    const open = useCallback((target)=>{
+        setOpened(target);
+        onOpenUri(target);
+    }, [
+        onOpenUri
+    ]);
+    const close = useCallback(()=>setOpened(null), []);
+    const text = dashboard_labels_dashboardLabels(locale, dashboardLabels);
+    const title = current?.kind === 'experience' ? text.experienceTitle : text.wikiTitle;
+    const tab = current && uri ? {
+        key: dashboardKey(uri),
+        title,
+        icon: createElement('experience' === current.kind ? ExperienceBoardIcon : WikiBoardIcon, {
+            width: 14,
+            height: 14
+        }),
+        kind: 'content',
+        content: renderDashboard?.(current) ?? ('experience' === current.kind ? createElement(ExperienceDashboardPane, {
+            uri,
+            locale,
+            requestOptions,
+            refreshGeneration: generation,
+            onOpenUri: (target)=>{
+                setOpened(null);
+                onOpenUri(target);
+            }
+        }) : createElement(WikiDashboardPane, {
+            uri,
+            kind: knownRows.some((row)=>'entry' === row.kind && row.uri === canonicalUri && 'file' === row.type) ? 'file' : 'directory',
+            locale,
+            requestOptions,
+            refreshGeneration: generation,
+            onOpenUri: (target)=>{
+                setOpened(null);
+                onOpenUri(target);
+            },
+            onOpenDashboard: open
+        }))
+    } : void 0;
+    return {
+        dashboards,
+        tab,
+        isOpen: null !== uri && opened === uri && Boolean(current),
+        open,
+        close,
+        error: unsupported ? null : catalog.error,
+        retry: catalog.retry
+    };
+}
 function knownDirectories(rootUri, dirs) {
     const known = new Set([
         rootUri
@@ -994,6 +1840,21 @@ function useKnownFile(dirs) {
         files
     ]);
 }
+function useTreeMetadata(rootUri, dirs) {
+    const directoryUris = useMemo(()=>knownDirectories(rootUri, dirs), [
+        rootUri,
+        dirs
+    ]);
+    const isKnownFile = useKnownFile(dirs);
+    const metadataRows = useMemo(()=>Object.values(dirs).flatMap((dir)=>dir.entries.map((entry)=>toEntryRow(entry, 0, false))), [
+        dirs
+    ]);
+    return {
+        directoryUris,
+        isKnownFile,
+        metadataRows
+    };
+}
 const ids = new WeakMap();
 let nextId = 1;
 function idOf(value) {
@@ -1064,6 +1925,7 @@ async function loadPage(client, uri, offset, signal, requestOptions) {
         query: {
             uri,
             output: 'agent',
+            include_tags: true,
             node_limit: PAGE_SIZE,
             offset
         },
@@ -1189,6 +2051,14 @@ function useFsTree({ client, rootUri, defaultExpandedUri, requestOptions }) {
                 setExpanded((prev)=>new Set(prev).add(uri));
                 if (!dirsRef.current[uri]) await fetchPage(uri, 0);
             },
+            openPath: async (uri)=>{
+                const current = scope.current();
+                for (const parent of expandChain(rootUri, uri)){
+                    if (current.controller.signal.aborted || scope.current().key !== current.key) return;
+                    setExpanded((prev)=>new Set(prev).add(parent));
+                    if (!dirsRef.current[parent]) await fetchPage(parent, 0);
+                }
+            },
             toggleExpand: async (row)=>{
                 const isOpen = expandedRef.current.has(row.uri);
                 setExpanded((prev)=>{
@@ -1226,21 +2096,16 @@ function useFsTree({ client, rootUri, defaultExpandedUri, requestOptions }) {
         dirs,
         expanded
     ]);
-    const directoryUris = useMemo(()=>knownDirectories(rootUri, dirs), [
-        rootUri,
-        dirs
-    ]);
-    const isKnownFile = useKnownFile(dirs);
+    const metadata = useTreeMetadata(rootUri, dirs);
     return {
         rows,
+        ...metadata,
         isReady,
         error,
-        directoryUris,
-        isKnownFile,
         ...state
     };
 }
-function useFileBrowser({ rootUri, locale: localeProp, controlled = false, summaryLabels, formatCharacterCount, defaultExpandedUri, currentUri, requestOptions, onUriChange }) {
+function useFileBrowser({ rootUri, locale: localeProp, dashboardKinds, renderDashboard, dashboardLabels, controlled = false, summaryLabels, formatCharacterCount, defaultExpandedUri, currentUri, requestOptions, onUriChange }) {
     const locale = useLocale(localeProp);
     const client = useOvClient();
     const [query, setQuery] = useState('');
@@ -1289,17 +2154,36 @@ function useFileBrowser({ rootUri, locale: localeProp, controlled = false, summa
         search.results,
         tree.rows
     ]);
-    const selectedId = useMemo(()=>{
-        if (!activeUri || null === search.results) return activeUri;
-        const index = search.results.findIndex((entry)=>entry.uri === activeUri);
-        return index < 0 ? activeUri : `${activeUri}#${index}`;
-    }, [
-        activeUri,
-        search.results
+    const openPath = tree.openPath;
+    const openResource = useMemo(()=>async (uri)=>{
+            setPendingUri(uri);
+            notifyUriChange.current(uri);
+            const directory = tree.directoryUris.has(uri) ? uri : uri.slice(0, uri.lastIndexOf('/'));
+            await openPath(directory);
+        }, [
+        openPath,
+        tree.directoryUris
     ]);
+    const boards = useBrowserDashboards({
+        rows,
+        metadataRows: tree.metadataRows,
+        uri: activeUri,
+        rootUri,
+        generation: refreshGeneration,
+        locale,
+        requestOptions,
+        onOpenUri: openResource,
+        dashboardKinds,
+        renderDashboard,
+        dashboardLabels
+    });
+    const selectedId = selectedRowId(activeUri, search.results);
     const { open, toggleExpand, loadMore, retry, refresh } = tree;
+    const { open: openDashboard, close: closeDashboard } = boards;
+    const setActiveKey = preview.setActiveKey;
     const actions = useMemo(()=>({
             select: async (row)=>{
+                closeDashboard();
                 setPendingUri(row.uri);
                 notifyUriChange.current(row.uri);
                 if ('directory' === row.type) await open(row.uri);
@@ -1322,15 +2206,25 @@ function useFileBrowser({ rootUri, locale: localeProp, controlled = false, summa
                     setRefreshing(false);
                 }
             },
-            setPreviewKey: preview.setActiveKey,
+            openDashboard: openDashboard,
+            setPreviewKey: (key)=>{
+                if (activeUri && key === dashboardKey(activeUri)) openDashboard(activeUri);
+                else {
+                    closeDashboard();
+                    setActiveKey(key);
+                }
+            },
             setQuery
         }), [
-        preview.setActiveKey,
+        setActiveKey,
         open,
         toggleExpand,
         loadMore,
         retry,
-        refresh
+        refresh,
+        openDashboard,
+        closeDashboard,
+        activeUri
     ]);
     return {
         rows,
@@ -1341,8 +2235,13 @@ function useFileBrowser({ rootUri, locale: localeProp, controlled = false, summa
         treeError: tree.error,
         previewError: preview.error,
         searchError: search.error,
-        previewTabs: preview.tabs,
-        previewKey: preview.activeKey,
+        dashboards: boards.dashboards,
+        dashboardError: boards.error,
+        previewTabs: boards.tab ? [
+            ...preview.tabs ?? [],
+            boards.tab
+        ] : preview.tabs,
+        previewKey: boards.isOpen && activeUri ? dashboardKey(activeUri) : preview.activeKey,
         previewFooter: preview.footer,
         query,
         searching: null !== search.results,
@@ -1351,7 +2250,7 @@ function useFileBrowser({ rootUri, locale: localeProp, controlled = false, summa
         actions
     };
 }
-function FileBrowser({ uri, defaultUri, rootUri = 'viking://', defaultExpandedUri, locale: localeProp, agentConnect, onUriChange, onImportResources, renderImportResources, labels, requestOptions, className, style, ...rest }) {
+function FileBrowser({ uri, defaultUri, rootUri = 'viking://', defaultExpandedUri, locale: localeProp, agentConnect, dashboardKinds, renderDashboard, onUriChange, onImportResources, renderImportResources, labels, requestOptions, className, style, ...rest }) {
     const locale = useLocale(localeProp);
     const [internalUri, setInternalUri] = useState(()=>defaultUri ?? null);
     const [preferredTreeWidth, setPreferredTreeWidth] = useState(352);
@@ -1385,6 +2284,9 @@ function FileBrowser({ uri, defaultUri, rootUri = 'viking://', defaultExpandedUr
     const browser = useFileBrowser({
         rootUri,
         locale,
+        dashboardKinds,
+        renderDashboard,
+        dashboardLabels: labels?.dashboard,
         controlled: isControlled,
         summaryLabels,
         formatCharacterCount: text.formatCharacterCount,
@@ -1420,6 +2322,7 @@ function FileBrowser({ uri, defaultUri, rootUri = 'viking://', defaultExpandedUr
                         browser: browser,
                         treeLabels: text.tree,
                         locale: locale,
+                        dashboardLabels: labels?.dashboard,
                         searchPlaceholder: text.searchPlaceholder,
                         refreshLabel: text.refresh,
                         searchLoading: text.searchLoading,
@@ -1469,4 +2372,4 @@ function FileBrowser({ uri, defaultUri, rootUri = 'viking://', defaultExpandedUr
         })
     });
 }
-export { FileBrowser, useFileBrowser };
+export { FileBrowser };