@jini-ai/ui 0.5.5 → 0.6.10

package/dist/features/asset-tree-browser/react/components/AssetTreeBrowserParts.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useT } from '../../../i18n/index.js';
+import { EMPTY_TOOLBAR_ACTIONS } from '../../constants.js';
+import { basenameForRename, canCopyLocalPath, countFilesUnderDir, resolveKindConfig } from '../../rules.js';
+import { AssetTreeBreadcrumbs } from './AssetTreeBreadcrumbs.js';
+import { AssetTreeEmptyState } from './AssetTreeEmptyState.js';
+import { AssetTreeFileRow } from './AssetTreeFileRow.js';
+import { AssetTreeFolderRow } from './AssetTreeFolderRow.js';
+import { AssetTreeRowMenu } from './AssetTreeRowMenu.js';
+import { AssetTreeSelectionBar } from './AssetTreeSelectionBar.js';
+import { AssetTreeToolbar } from './AssetTreeToolbar.js';
+import { AssetTreeUploadErrorBanner } from './AssetTreeUploadErrorBanner.js';
+import { FilePreviewPane } from './FilePreviewPane.js';
+/** Breadcrumbs (root label defaults to `t('Files')`) plus the host toolbar. */
+export function AssetTreeBrowserTopbar({ currentDir, rootLabel, onNavigate, toolbarActions = EMPTY_TOOLBAR_ACTIONS, }) {
+    const t = useT();
+    return (_jsxs("div", { className: "asset-tree-topbar", children: [_jsx("div", { className: "asset-tree-topbar-left", children: _jsx(AssetTreeBreadcrumbs, { currentDir: currentDir, rootLabel: rootLabel ?? t('Files'), onNavigate: onNavigate }) }), _jsx("div", { className: "asset-tree-topbar-right", children: _jsx(AssetTreeToolbar, { actions: toolbarActions }) })] }));
+}
+/** The drop-target listing area: upload-error banner, selection bar, folders + kind sections (or the empty state), footer. */
+export function AssetTreeBrowserBody(props) {
+    const { controller, downloadFiles, footer } = props;
+    const { dragUpload, preview } = controller;
+    return (_jsxs("div", { className: "asset-tree-body", "data-testid": "asset-tree-body", onDragEnter: dragUpload.onDragEnter, onDragOver: dragUpload.onDragOver, onDragLeave: dragUpload.onDragLeave, onDrop: dragUpload.onDrop, children: [dragUpload.dropReadError && !preview.previewPath ? (_jsx(AssetTreeUploadErrorBanner, { message: dragUpload.dropReadError, onDismiss: dragUpload.clearDropReadError })) : null, _jsx(AssetTreeBrowserSelectionBar, { controller: controller, downloadFiles: downloadFiles }), _jsx(AssetTreeBrowserListing, { ...props }), footer] }));
+}
+function AssetTreeBrowserSelectionBar({ controller, downloadFiles, }) {
+    const { selection, batchActions } = controller;
+    if (selection.selected.size === 0)
+        return null;
+    return (_jsx(AssetTreeSelectionBar, { count: selection.selected.size, onClear: selection.clearSelection, onDelete: () => void batchActions.deleteSelected(), deleting: batchActions.deleting, onDownload: downloadFiles ? () => void batchActions.downloadSelected() : undefined, downloading: batchActions.downloading, downloadError: batchActions.downloadError }));
+}
+function AssetTreeBrowserListing({ controller, files, folders, selectors, kindConfig, emptyStateActions = EMPTY_TOOLBAR_ACTIONS, }) {
+    const { navigation } = controller;
+    const isEmpty = files.length === 0 && (folders?.length ?? 0) === 0;
+    if (isEmpty)
+        return _jsx(AssetTreeEmptyState, { actions: emptyStateActions });
+    return (_jsxs(_Fragment, { children: [_jsx(AssetTreeFoldersSection, { files: files, dirs: navigation.dirsAtCurrentDir, currentDir: navigation.currentDir, onNavigate: navigation.setCurrentDir }, "folders"), navigation.sections.map((section) => (_jsx(AssetTreeKindSection, { controller: controller, section: section, selectors: selectors, kindConfig: kindConfig }, `kind:${section.kind}`)))] }));
+}
+function AssetTreeFoldersSection({ files, dirs, currentDir, onNavigate, }) {
+    const t = useT();
+    if (dirs.length === 0)
+        return null;
+    return (_jsxs("div", { className: "asset-tree-section", children: [_jsxs("div", { className: "asset-tree-section-label", children: [t('Folders'), _jsx("span", { className: "asset-tree-section-count", children: dirs.length })] }), dirs.map((dirName) => {
+                const fullPath = currentDir === '' ? dirName : `${currentDir}/${dirName}`;
+                return (_jsx(AssetTreeFolderRow, { name: dirName, path: fullPath, fileCount: countFilesUnderDir(files, fullPath), onNavigate: onNavigate }, fullPath));
+            })] }));
+}
+function AssetTreeKindSection({ controller, section, selectors, kindConfig, }) {
+    const t = useT();
+    const { navigation, preview, selection, rename, rowMenu, openPath } = controller;
+    const config = resolveKindConfig(section.kind, kindConfig);
+    return (_jsxs("div", { className: "asset-tree-section", children: [_jsxs("div", { className: "asset-tree-section-label", children: [t(config.label), _jsx("span", { className: "asset-tree-section-count", children: section.files.length })] }), section.files.map((f) => (_jsx(AssetTreeFileRow, { path: f.path, displayName: basenameForRename(f.path, navigation.currentDir), active: preview.previewPath === f.path, selected: selection.selected.has(f.path), kindLabel: t(config.label), kindGlyph: config.glyph, size: selectors.getSize(f), modifiedAt: selectors.getModifiedAt(f), renaming: rename.renaming?.path === f.path ? rename.renaming : null, onSelectPreview: preview.setPreviewPath, onOpen: openPath, onToggleSelect: selection.toggleSelect, onOpenMenu: rowMenu.openMenuFor, onRenameDraftChange: rename.updateDraft, onCommitRename: () => void rename.commitRename(), onCancelRename: rename.cancelRename }, f.path)))] }));
+}
+/** `FilePreviewPane` for the previewed `file`, with its kind display config resolved. */
+export function AssetTreeBrowserPreview({ file, selectors, kindConfig, onOpenFile, onClose, getFileUrl, renderPreviewThumbnail, thumbnailIsInteractive, }) {
+    const t = useT();
+    const previewKindConfig = resolveKindConfig(selectors.getKind(file), kindConfig);
+    return (_jsx(FilePreviewPane, { file: file, path: file.path, kindLabel: t(previewKindConfig.label), kindGlyph: previewKindConfig.glyph, size: selectors.getSize(file), modifiedAt: selectors.getModifiedAt(file), onOpen: () => onOpenFile(file), onClose: onClose, downloadHref: getFileUrl?.(file), renderThumbnail: renderPreviewThumbnail, thumbnailIsInteractive: thumbnailIsInteractive }));
+}
+/** The open row context menu for `menuPos.path`, with every action wired. */
+export function AssetTreeBrowserRowMenu({ controller, menuPos, selectors, getFileUrl, onDeleteFile, }) {
+    const { navigation, rowMenu, rename, copyLocalPath, findFile, openPath } = controller;
+    const { path } = menuPos;
+    const menuFile = findFile(path) ?? null;
+    return (_jsx(AssetTreeRowMenu, { path: path, displayName: basenameForRename(path, navigation.currentDir), top: menuPos.top, left: menuPos.left, containerRef: rowMenu.containerRef, canCopyLocalPath: !!menuFile && canCopyLocalPath(menuFile, selectors), copied: copyLocalPath.copiedPath === path, download: getFileUrl && menuFile ? { href: getFileUrl(menuFile), onClick: rowMenu.closeMenu } : undefined, onOpen: () => {
+            rowMenu.closeMenu();
+            openPath(path);
+        }, onRename: () => {
+            rowMenu.closeMenu();
+            rename.startRename(path);
+        }, 
+        // Deliberately does NOT close the menu (unlike every other action
+        // here) — the origin `DesignFilesPanel`'s equivalent handler did
+        // call `setMenuPos(null)` before copying, which meant its
+        // "Copied" confirmation label could never actually become visible
+        // to a user (it only ever renders inside the now-closed popover).
+        // Since the whole point of `copiedPath`/the transient-confirmation
+        // UI is to be seen, this keeps the menu open so it can be; the
+        // existing outside-dismiss/Escape handling still closes it
+        // normally afterward.
+        onCopyLocalPath: () => {
+            // `canCopyLocalPath` (passed below) already gates the button's
+            // `disabled` state on `!!menuFile`, so a click can only reach
+            // this handler when `menuFile` is non-null — asserting that
+            // instead of re-guarding it here avoids an unreachable `: null`
+            // ternary arm (a real click can never fire on a disabled
+            // button, so that arm was dead code, not defensive coding).
+            const localPath = selectors.getLocalPath?.(menuFile);
+            if (localPath)
+                void copyLocalPath.copyLocalPath(path, localPath);
+        }, onDelete: () => {
+            rowMenu.closeMenu();
+            onDeleteFile(path);
+        } }));
+}
+//# sourceMappingURL=AssetTreeBrowserParts.js.map

package/dist/features/asset-tree-browser/react/components/useAssetTreeBrowserController.d.ts

@@ -0,0 +1,56 @@
+import type { AssetTreeDependencies } from '../../ports.js';
+import type { AssetTreeFileItem, AssetTreeFolderItem, AssetTreeNavState, AssetTreeSelectors } from '../../types.js';
+import { type UseAssetTreeBatchActionsResult } from '../hooks/useAssetTreeBatchActions.js';
+import { type UseAssetTreeCopyLocalPathResult } from '../hooks/useAssetTreeCopyLocalPath.js';
+import { type UseAssetTreeDragUploadResult } from '../hooks/useAssetTreeDragUpload.js';
+import { useAssetTreeNavigation, type UseAssetTreeNavigationResult } from '../hooks/useAssetTreeNavigation.js';
+import { useAssetTreePreview, type UseAssetTreePreviewResult } from '../hooks/useAssetTreePreview.js';
+import { useAssetTreeRename, type UseAssetTreeRenameResult } from '../hooks/useAssetTreeRename.js';
+import { type UseAssetTreeRowMenuResult } from '../hooks/useAssetTreeRowMenu.js';
+import { useAssetTreeSelection, type UseAssetTreeSelectionResult } from '../hooks/useAssetTreeSelection.js';
+/** The `AssetTreeBrowser` props every controller run needs. */
+export interface AssetTreeBrowserControllerInput<TFile extends AssetTreeFileItem> {
+    files: TFile[];
+    selectors: AssetTreeSelectors<TFile>;
+    onOpenFile: (file: TFile) => void;
+    onRenameFile: (path: string, nextPath: string) => Promise<TFile | null> | TFile | null;
+    onDeleteFiles: (paths: string[]) => Promise<void> | void;
+    onUploadFiles: (files: File[]) => void;
+}
+/** The optional `AssetTreeBrowser` props the controller consumes, with the same defaults the component documents. */
+export interface AssetTreeBrowserControllerOptions<TFile extends AssetTreeFileItem> {
+    folders?: AssetTreeFolderItem[];
+    sectionOrder?: readonly string[];
+    dependencies?: AssetTreeDependencies;
+    navState?: AssetTreeNavState;
+    onNavStateChange?: (state: AssetTreeNavState) => void;
+    onSelectionChange?: (paths: Set<string>) => void;
+    downloadFiles?: (paths: string[]) => Promise<{
+        blob: Blob;
+        filename: string;
+    }>;
+    selectInitialPreviewFile?: (files: TFile[]) => TFile | null;
+    useAssetTreeNavigation?: typeof useAssetTreeNavigation;
+    useAssetTreePreview?: typeof useAssetTreePreview;
+    useAssetTreeRename?: typeof useAssetTreeRename;
+    useAssetTreeSelection?: typeof useAssetTreeSelection;
+}
+export interface AssetTreeBrowserController<TFile> {
+    navigation: UseAssetTreeNavigationResult<TFile>;
+    preview: UseAssetTreePreviewResult<TFile>;
+    rename: UseAssetTreeRenameResult;
+    selection: UseAssetTreeSelectionResult;
+    rowMenu: UseAssetTreeRowMenuResult;
+    dragUpload: UseAssetTreeDragUploadResult;
+    batchActions: UseAssetTreeBatchActionsResult;
+    copyLocalPath: UseAssetTreeCopyLocalPathResult;
+    findFile: (path: string) => TFile | undefined;
+    /** Resolves `path` against `files` and opens it; a path no longer in `files` is a no-op. */
+    openPath: (path: string) => void;
+}
+/**
+ * Every hook `AssetTreeBrowser` composes, wired together in the one order
+ * their cross-references need, so the component itself is pure rendering.
+ */
+export declare function useAssetTreeBrowserController<TFile extends AssetTreeFileItem>(input: AssetTreeBrowserControllerInput<TFile>, { folders, sectionOrder, dependencies, navState, onNavStateChange, onSelectionChange, downloadFiles, selectInitialPreviewFile, useAssetTreeNavigation: useAssetTreeNavigationHook, useAssetTreePreview: useAssetTreePreviewHook, useAssetTreeRename: useAssetTreeRenameHook, useAssetTreeSelection: useAssetTreeSelectionHook, }: AssetTreeBrowserControllerOptions<TFile>): AssetTreeBrowserController<TFile>;
+//# sourceMappingURL=useAssetTreeBrowserController.d.ts.map

package/dist/features/asset-tree-browser/react/components/useAssetTreeBrowserController.js

@@ -0,0 +1,80 @@
+import { useEffect, useMemo } from 'react';
+import { DEFAULT_SECTION_ORDER } from '../../constants.js';
+import { createBrowserAssetTreeDependencies } from '../../dependencies.js';
+import { useAssetTreeBatchActions } from '../hooks/useAssetTreeBatchActions.js';
+import { useAssetTreeClipboardPasteUpload } from '../hooks/useAssetTreeClipboardPasteUpload.js';
+import { useAssetTreeCopyLocalPath } from '../hooks/useAssetTreeCopyLocalPath.js';
+import { useAssetTreeDragUpload } from '../hooks/useAssetTreeDragUpload.js';
+import { useAssetTreeNavigation } from '../hooks/useAssetTreeNavigation.js';
+import { useAssetTreePreview } from '../hooks/useAssetTreePreview.js';
+import { useAssetTreeRename } from '../hooks/useAssetTreeRename.js';
+import { useAssetTreeRowMenu } from '../hooks/useAssetTreeRowMenu.js';
+import { useAssetTreeSelection } from '../hooks/useAssetTreeSelection.js';
+/**
+ * Every hook `AssetTreeBrowser` composes, wired together in the one order
+ * their cross-references need, so the component itself is pure rendering.
+ */
+export function useAssetTreeBrowserController(input, { folders, sectionOrder = DEFAULT_SECTION_ORDER, dependencies, navState, onNavStateChange, onSelectionChange, downloadFiles, selectInitialPreviewFile, useAssetTreeNavigation: useAssetTreeNavigationHook = useAssetTreeNavigation, useAssetTreePreview: useAssetTreePreviewHook = useAssetTreePreview, useAssetTreeRename: useAssetTreeRenameHook = useAssetTreeRename, useAssetTreeSelection: useAssetTreeSelectionHook = useAssetTreeSelection, }) {
+    const { files, selectors, onOpenFile, onRenameFile, onDeleteFiles, onUploadFiles } = input;
+    // KNOWN FOLLOW-UP (flagged by the 2026-07-22 verification pass, not yet
+    // fixed): this has the same useWiredX gap ConnectorsBrowser had — `deps`
+    // resolution is still inline instead of behind a `useWiredAssetTreeBrowser`
+    // wrapper. Deliberately not fixed here: unlike ConnectorsBrowser's `deps`
+    // (fed to exactly the 3 already-overridable sub-hooks), this `deps` also
+    // feeds `useAssetTreeRowMenu`, `useAssetTreeClipboardPasteUpload`, and
+    // `useAssetTreeCopyLocalPath` below — none of which currently have their
+    // own override props — so collapsing it into one wired hook is a real
+    // design decision (what belongs in the wired hook vs. stays overridable)
+    // rather than a mechanical port of the ConnectorsBrowser pattern. Lower
+    // severity than that one too: these are DOM/clipboard adapters, not
+    // remote data fetching.
+    const deps = useMemo(() => dependencies ?? createBrowserAssetTreeDependencies(), [dependencies]);
+    const navigation = useAssetTreeNavigationHook({
+        files,
+        folders,
+        sectionOrder,
+        getKind: selectors.getKind,
+        getModifiedAt: selectors.getModifiedAt,
+        navState,
+        onNavStateChange,
+    });
+    const preview = useAssetTreePreviewHook(files, selectInitialPreviewFile);
+    // Declared before `useAssetTreeSelection` so its in-flight `renaming.path`
+    // (if any) can be threaded into selection's prune logic as
+    // `pendingRenamePath` — see that hook's doc comment for the race this
+    // closes. `onRenamed` referencing `selection` here (declared below) is
+    // safe: it's a closure that only actually runs later, once `selection` is
+    // fully bound.
+    const rename = useAssetTreeRenameHook({
+        currentDir: navigation.currentDir,
+        onRenameFile,
+        onRenamed: (oldPath, renamedFile) => {
+            if (preview.previewPath === oldPath)
+                preview.setPreviewPath(renamedFile.path);
+            selection.renamePath(oldPath, renamedFile.path);
+        },
+    });
+    const selection = useAssetTreeSelectionHook(navigation.filesAtCurrentDir, navigation.currentDir, rename.renaming?.path ?? null);
+    const rowMenu = useAssetTreeRowMenu(deps.dom);
+    const dragUpload = useAssetTreeDragUpload(onUploadFiles);
+    useAssetTreeClipboardPasteUpload({
+        dom: deps.dom,
+        onUploadFiles,
+        onBeforeUpload: dragUpload.clearDropReadError,
+    });
+    const batchActions = useAssetTreeBatchActions({ selected: selection.selected, onDeleteFiles, downloadFiles });
+    const copyLocalPath = useAssetTreeCopyLocalPath(deps.clipboard);
+    useEffect(() => {
+        onSelectionChange?.(selection.selected);
+    }, [selection.selected, onSelectionChange]);
+    function findFile(path) {
+        return files.find((f) => f.path === path);
+    }
+    function openPath(path) {
+        const target = findFile(path);
+        if (target)
+            onOpenFile(target);
+    }
+    return { navigation, preview, rename, selection, rowMenu, dragUpload, batchActions, copyLocalPath, findFile, openPath };
+}
+//# sourceMappingURL=useAssetTreeBrowserController.js.map

package/dist/features/asset-tree-browser/rules.js

@@ -25,36 +25,54 @@ import { DEFAULT_KIND_GLYPH, DOUBLE_ACTIVATION_WINDOW_MS, ROW_MENU_ESTIMATED_HEI
  * this asymmetry looks surprising but is exactly what the source does.
  */
 export function deriveTreeChildren(files, folders, currentDir) {
-    const prefix = currentDir === '' ? '' : `${currentDir}/`;
+    const isRoot = currentDir === '';
+    const prefix = isRoot ? '' : `${currentDir}/`;
     const dirs = new Set();
+    const localFiles = collectFileChildren({ files, prefix, isRoot, dirs });
+    collectFolderChildren({ folders, prefix, dirs });
+    return {
+        dirsAtCurrentDir: [...dirs].sort((a, b) => a.localeCompare(b)),
+        filesAtCurrentDir: localFiles,
+    };
+}
+/** The first path component of `path` below `prefix`, or `null` when `path` is outside `prefix`. */
+function childSegment(path, prefix) {
+    if (!path.startsWith(prefix))
+        return null;
+    const remainder = path.slice(prefix.length);
+    const slashIdx = remainder.indexOf('/');
+    if (slashIdx === -1)
+        return { head: remainder, nested: false };
+    return { head: remainder.slice(0, slashIdx), nested: true };
+}
+/**
+ * File half of {@link deriveTreeChildren}: adds each nested file's top
+ * segment to `dirs` and returns the files listed at this level (every
+ * in-prefix file at the root, only one-level-deep files elsewhere).
+ */
+function collectFileChildren(input) {
     const localFiles = [];
-    for (const f of files) {
-        if (!f.path.startsWith(prefix))
+    for (const f of input.files) {
+        const segment = childSegment(f.path, input.prefix);
+        if (!segment)
             continue;
-        const remainder = f.path.slice(prefix.length);
-        const slashIdx = remainder.indexOf('/');
-        if (slashIdx === -1) {
+        if (segment.nested)
+            input.dirs.add(segment.head);
+        if (!segment.nested || input.isRoot)
             localFiles.push(f);
-        }
-        else {
-            dirs.add(remainder.slice(0, slashIdx));
-            if (currentDir === '')
-                localFiles.push(f);
-        }
     }
-    for (const folder of folders) {
-        if (!folder.path.startsWith(prefix))
+    return localFiles;
+}
+/** Folder half of {@link deriveTreeChildren}: adds each persisted folder's top segment below `prefix` to `dirs`. */
+function collectFolderChildren(input) {
+    for (const folder of input.folders) {
+        const segment = childSegment(folder.path, input.prefix);
+        if (!segment)
             continue;
-        const remainder = folder.path.slice(prefix.length);
-        if (!remainder)
+        if (!segment.nested && !segment.head)
             continue; // the current directory itself
-        const slashIdx = remainder.indexOf('/');
-        dirs.add(slashIdx === -1 ? remainder : remainder.slice(0, slashIdx));
+        input.dirs.add(segment.head);
     }
-    return {
-        dirsAtCurrentDir: [...dirs].sort((a, b) => a.localeCompare(b)),
-        filesAtCurrentDir: localFiles,
-    };
 }
 /** Total files (at every depth, not just the immediate level) under `dirPath` — what a folder row's "N files" subtitle counts. */
 export function countFilesUnderDir(files, dirPath) {

package/dist/features/browser-chrome/rules.js

@@ -2,27 +2,26 @@ import { DEFAULT_HOME_NAVIGATION_ENTRY, EMPTY_URL, HISTORY_LIMIT } from './const
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/** Resolves a `/`-rooted address: against `appOrigin` when it matches a configured app-route prefix, else as a local `file://` path. */
+function resolveAbsolutePath(value, options) {
+    const { appRoutePrefixes = [], appOrigin } = options;
+    if (appOrigin && appRoutePrefixes.length > 0) {
+        const prefixPattern = new RegExp(`^/(${appRoutePrefixes.map(escapeRegExp).join('|')})(/|$)`);
+        if (prefixPattern.test(value))
+            return new URL(value, appOrigin).toString();
+    }
+    return `file://${encodeURI(value)}`;
+}
 export function normalizeBrowserAddress(rawAddress, options = {}) {
     const value = rawAddress.trim();
-    if (!value)
-        return EMPTY_URL;
-    if (value === EMPTY_URL)
+    if (!value || value === EMPTY_URL)
         return EMPTY_URL;
     if (/^(https?|file):\/\//i.test(value))
         return value;
-    if (/^localhost(:\d+)?(\/.*)?$/i.test(value))
+    if (/^(localhost|127\.0\.0\.1|0\.0\.0\.0)(:\d+)?(\/.*)?$/i.test(value))
         return `http://${value}`;
-    if (/^(127\.0\.0\.1|0\.0\.0\.0)(:\d+)?(\/.*)?$/i.test(value))
-        return `http://${value}`;
-    if (value.startsWith('/')) {
-        const { appRoutePrefixes = [], appOrigin } = options;
-        if (appOrigin && appRoutePrefixes.length > 0) {
-            const prefixPattern = new RegExp(`^/(${appRoutePrefixes.map(escapeRegExp).join('|')})(/|$)`);
-            if (prefixPattern.test(value))
-                return new URL(value, appOrigin).toString();
-        }
-        return `file://${encodeURI(value)}`;
-    }
+    if (value.startsWith('/'))
+        return resolveAbsolutePath(value, options);
     if (/^[\w.-]+\.[a-z]{2,}(:\d+)?(\/.*)?$/i.test(value))
         return `https://${value}`;
     return `https://www.google.com/search?q=${encodeURIComponent(value)}`;
@@ -137,37 +136,37 @@ export function mergeHistoryEntry(history, url, meta = {}, options = {}, now = D
     if (!isHistoryUrl(url))
         return history;
     const existing = history.find((entry) => sameUrl(entry.url, url));
-    // `isHistoryUrl` above already excludes `EMPTY_URL`, so `labelFromUrl`'s
-    // home-label branch can never trigger here — no `homeLabel` option to pass.
-    const nextTitle = meta.title && meta.title.trim()
-        ? meta.title.trim()
-        : existing?.title || labelFromUrl(url);
-    const nextIconUrl = cleanIconUrl(meta.iconUrl) || existing?.iconUrl || faviconUrl(url);
-    const visitIncrement = options.countVisit === false ? 0 : 1;
-    const entry = existing
-        ? {
-            ...existing,
-            ...(nextIconUrl !== undefined ? { iconUrl: nextIconUrl } : {}),
-            title: nextTitle,
-            lastVisitedAt: visitIncrement > 0 ? now : existing.lastVisitedAt,
-            visitCount: existing.visitCount + visitIncrement,
-        }
-        : {
-            ...(nextIconUrl !== undefined ? { iconUrl: nextIconUrl } : {}),
-            title: nextTitle,
-            url,
-            lastVisitedAt: now,
-            visitCount: 1,
-        };
-    if (existing
-        && existing.title === entry.title
-        && existing.iconUrl === entry.iconUrl
-        && existing.lastVisitedAt === entry.lastVisitedAt
-        && existing.visitCount === entry.visitCount) {
+    const entry = buildHistoryEntry({ url, meta, now, countVisit: options.countVisit !== false }, { existing });
+    if (existing && sameHistoryEntryState(existing, entry))
         return history;
-    }
     return [entry, ...history.filter((item) => !sameUrl(item.url, url))].slice(0, HISTORY_LIMIT);
 }
+/** Builds the merged entry for `url`: an update of `existing` when present, otherwise a fresh first-visit entry. */
+function buildHistoryEntry({ url, meta, now, countVisit }, { existing }) {
+    const resolved = resolveHistoryMeta({ url, meta }, { existing });
+    if (!existing)
+        return { ...resolved, url, lastVisitedAt: now, visitCount: 1 };
+    return {
+        ...existing,
+        ...resolved,
+        lastVisitedAt: countVisit ? now : existing.lastVisitedAt,
+        visitCount: existing.visitCount + (countVisit ? 1 : 0),
+    };
+}
+/** Title and icon for a merged entry: the caller's meta wins, then the existing entry's, then values derived from `url`. */
+function resolveHistoryMeta({ url, meta }, { existing }) {
+    // `isHistoryUrl` above already excludes `EMPTY_URL`, so `labelFromUrl`'s
+    // home-label branch can never trigger here — no `homeLabel` option to pass.
+    const title = meta.title?.trim() || existing?.title || labelFromUrl(url);
+    const iconUrl = cleanIconUrl(meta.iconUrl) || existing?.iconUrl || faviconUrl(url);
+    return iconUrl !== undefined ? { iconUrl, title } : { title };
+}
+function sameHistoryEntryState(left, right) {
+    return (left.title === right.title
+        && left.iconUrl === right.iconUrl
+        && left.lastVisitedAt === right.lastVisitedAt
+        && left.visitCount === right.visitCount);
+}
 // ---------------------------------------------------------------------------
 // Navigation stack
 // ---------------------------------------------------------------------------
@@ -201,6 +200,20 @@ export function recordNavigation(state, url, title, options = {}) {
     if (url !== EMPTY_URL && !isHistoryUrl(url))
         return state;
     const { navigationStack: stack, navigationIndex: index } = state;
+    const nextTitle = navigationTitle({ url }, { title, homeLabel: options.homeLabel });
+    const rejoin = findRejoinTarget({ state, url }, options);
+    if (rejoin) {
+        const next = stack.slice();
+        // `nextTitle` is only ever '' for EMPTY_URL with an explicit '' homeLabel;
+        // keep the rejoined entry's own title rather than blanking it.
+        next[rejoin.index] = { title: nextTitle || rejoin.entry.title, url };
+        return { navigationStack: next, navigationIndex: rejoin.index };
+    }
+    const base = index >= 0 ? stack.slice(0, index + 1) : [];
+    const nextStack = [...base, { title: nextTitle, url }].slice(-HISTORY_LIMIT);
+    return { navigationStack: nextStack, navigationIndex: nextStack.length - 1 };
+}
+function navigationTitle({ url }, { title, homeLabel }) {
     // Bug fix: this used to hardcode DEFAULT_HOME_NAVIGATION_ENTRY.title here,
     // ignoring a caller-supplied `options.homeLabel` — so a host configuring a
     // custom `homeEntry` (via useBrowserNavigationStack) would see the entry's
@@ -208,34 +221,25 @@ export function recordNavigation(state, url, title, options = {}) {
     // even though `initialNavigationState`/`labelFromUrl` both honor the
     // custom label correctly. Falls back to the generic default only when no
     // homeLabel is supplied.
-    const nextTitle = url === EMPTY_URL
-        ? (options.homeLabel ?? DEFAULT_HOME_NAVIGATION_ENTRY.title)
-        : title && title.trim()
-            ? title.trim()
-            : labelFromUrl(url, options.homeLabel);
-    const nextEntry = { title: nextTitle, url };
-    const updateEntry = (entries, entryIndex) => {
-        const existing = entries[entryIndex];
-        const next = entries.slice();
-        next[entryIndex] = { title: nextTitle || existing?.title || labelFromUrl(url, options.homeLabel), url };
-        return next;
-    };
-    const currentEntry = index >= 0 ? stack[index] : undefined;
-    const shouldReplacePending = Boolean(options.replacePendingTarget && options.pendingTarget && currentEntry && sameUrl(currentEntry.url, options.pendingTarget));
-    if (currentEntry && (sameUrl(currentEntry.url, url) || shouldReplacePending)) {
-        return { navigationStack: updateEntry(stack, index), navigationIndex: index };
-    }
-    const previousIndex = index - 1;
-    if (previousIndex >= 0 && sameUrl(stack[previousIndex]?.url ?? '', url)) {
-        return { navigationStack: updateEntry(stack, previousIndex), navigationIndex: previousIndex };
-    }
-    const nextIndex = index + 1;
-    if (nextIndex < stack.length && sameUrl(stack[nextIndex]?.url ?? '', url)) {
-        return { navigationStack: updateEntry(stack, nextIndex), navigationIndex: nextIndex };
+    if (url === EMPTY_URL)
+        return homeLabel ?? DEFAULT_HOME_NAVIGATION_ENTRY.title;
+    return title?.trim() || labelFromUrl(url, homeLabel);
+}
+/**
+ * The stack entry `url` should update in place instead of appending: the
+ * current entry (same url, or the pending-load target being replaced), else
+ * the adjacent back entry, else the adjacent forward entry. An out-of-range
+ * index reads as `undefined`, which never matches.
+ */
+function findRejoinTarget({ state, url }, { replacePendingTarget, pendingTarget }) {
+    const { navigationStack: stack, navigationIndex: index } = state;
+    const current = stack[index];
+    if (current && (sameUrl(current.url, url) || (replacePendingTarget && pendingTarget && sameUrl(current.url, pendingTarget)))) {
+        return { index, entry: current };
     }
-    const base = index >= 0 ? stack.slice(0, index + 1) : [];
-    const nextStack = [...base, nextEntry].slice(-HISTORY_LIMIT);
-    return { navigationStack: nextStack, navigationIndex: nextStack.length - 1 };
+    return [index - 1, index + 1]
+        .map((candidate) => ({ index: candidate, entry: stack[candidate] }))
+        .find((target) => target.entry !== undefined && sameUrl(target.entry.url, url));
 }
 export function updateCurrentNavigationTitle(state, title) {
     const trimmedTitle = title?.trim();

package/dist/features/charts/browser.js

@@ -59,6 +59,12 @@ export function mountChart({ element, spec, registry }, options = {}) {
     function candidates() {
         return selectChartProviders({ registry, spec: input.spec }, { siteProvider: options.siteProvider }).filter(({ id }) => !failed.has(id));
     }
+    function isStaleMount({ token }, _options = {}) {
+        return destroyed || token !== generation;
+    }
+    function isCurrentUpdate({ current, updateRevision }, _options = {}) {
+        return !destroyed && active === current && updateRevision === revision;
+    }
     /** Async renderer errors arrive after mount; defer teardown outside the provider's commit. */
     function renderError(entry, error, token) {
         queueMicrotask(() => {
@@ -76,7 +82,7 @@ export function mountChart({ element, spec, registry }, options = {}) {
             let renderRevision = revision;
             try {
                 const provider = await entry.load({});
-                if (destroyed || token !== generation)
+                if (isStaleMount({ token }))
                     return;
                 const frame = element.ownerDocument.createElement('div');
                 renderer.replaceChildren(frame);
@@ -84,13 +90,13 @@ export function mountChart({ element, spec, registry }, options = {}) {
                 const instance = provider.mount({ element: frame, ...input }, { onError: (error) => renderError(entry, error, token) });
                 active = { entry, instance };
                 await instance.ready;
-                if (destroyed || token !== generation || renderRevision !== revision)
+                if (isStaleMount({ token }) || renderRevision !== revision)
                     return;
                 fallback.hidden = true;
                 return;
             }
             catch (error) {
-                if (destroyed || token !== generation || renderRevision !== revision)
+                if (isStaleMount({ token }) || renderRevision !== revision)
                     return;
                 failed.add(entry.id);
                 report(entry, error);
@@ -113,12 +119,12 @@ export function mountChart({ element, spec, registry }, options = {}) {
                 const current = active;
                 try {
                     await current.instance.update(input);
-                    if (!destroyed && active === current && updateRevision === revision)
+                    if (isCurrentUpdate({ current, updateRevision }))
                         fallback.hidden = true;
                     return;
                 }
                 catch (error) {
-                    if (destroyed || active !== current || updateRevision !== revision)
+                    if (!isCurrentUpdate({ current, updateRevision }))
                         return;
                     failed.add(current.entry.id);
                     report(current.entry, error);

package/dist/features/charts/react.js

@@ -13,8 +13,8 @@ export function ChartHost({ spec, registry, theme = DEFAULT_CHART_THEME, sitePro
     const instance = useRef(undefined);
     const previous = useRef({ spec, theme });
     useEffect(() => {
-        if (!element.current)
-            return;
+        // The container `<div>` below is rendered unconditionally, so React has always attached the ref
+        // by the time this effect runs; the old `if (!element.current) return` could never fire.
         const mounted = mountChart({ element: element.current, spec, registry }, {
             theme, siteProvider, ...(onProviderError ? { onProviderError } : {}),
         });

package/dist/features/charts/table.js

@@ -41,8 +41,8 @@ export function renderChartTable({ element, spec }, _options = {}) {
         const tr = body.insertRow();
         for (const { key } of columns) {
             const cell = tr.insertCell();
-            const value = row[key];
-            cell.textContent = value == null ? '' : typeof value === 'object' ? JSON.stringify(value) : String(value);
+            const value = row[key] ?? '';
+            cell.textContent = typeof value === 'object' ? JSON.stringify(value) : String(value);
             cell.dataset.numeric = String(numeric.has(key));
         }
     }

package/dist/features/command-palette/react/hooks/useCommandPalette.js

@@ -30,18 +30,12 @@ export function useCommandPalette(options, dependencies) {
             onClose();
             return;
         }
-        if (event.key === 'ArrowDown') {
+        if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
             event.preventDefault();
             if (results.length === 0)
                 return;
-            setCursor((current) => nextCursor(current, results.length, 1));
-            return;
-        }
-        if (event.key === 'ArrowUp') {
-            event.preventDefault();
-            if (results.length === 0)
-                return;
-            setCursor((current) => nextCursor(current, results.length, -1));
+            const direction = event.key === 'ArrowDown' ? 1 : -1;
+            setCursor((current) => nextCursor(current, results.length, direction));
             return;
         }
         if (event.key === 'Enter') {

package/dist/features/connectors/ConnectorsBrowser.d.ts

@@ -1,8 +1,8 @@
 import type { ConnectorsDependencies } from './ports.js';
 import type { Connector, ConnectorAuthResultEvent, ProviderTab } from './types.js';
-import { useConnectorCatalog } from './hooks/useConnectorCatalog.js';
-import { useConnectorAuthorization } from './hooks/useConnectorAuthorization.js';
-import { useConnectorDetail } from './hooks/useConnectorDetail.js';
+import type { useConnectorCatalog } from './hooks/useConnectorCatalog.js';
+import type { useConnectorAuthorization } from './hooks/useConnectorAuthorization.js';
+import type { useConnectorDetail } from './hooks/useConnectorDetail.js';
 import type { ConnectorGateProps } from './components/ConnectorGate.js';
 export interface ConnectorsBrowserProps {
     /** Whether the host's provider is configured (e.g. an API key is saved) — gates enrichment + unmasks the grid. */
@@ -36,5 +36,5 @@ export interface ConnectorsBrowserProps {
  * messages. Ported from OD's `ConnectorsBrowser.tsx` — see
  * `packages/ui/source-map.md` for full provenance.
  */
-export declare function ConnectorsBrowser({ unlocked, providerTabs, catalogRefreshKey, dependencies, getCategoryLabel, getDisplayableAccountLabel, gate, onProviderTabClick, onConnectorAuthResult, onConnectorsChanged, useConnectorCatalog: useConnectorCatalogHook, useConnectorAuthorization: useConnectorAuthorizationHook, useConnectorDetail: useConnectorDetailHook, agentHandle, }: ConnectorsBrowserProps): import("react").JSX.Element;
+export declare function ConnectorsBrowser({ unlocked, providerTabs, catalogRefreshKey, dependencies, getCategoryLabel, getDisplayableAccountLabel, gate, onProviderTabClick, onConnectorAuthResult, onConnectorsChanged, useConnectorCatalog, useConnectorAuthorization, useConnectorDetail, agentHandle, }: ConnectorsBrowserProps): import("react").JSX.Element;
 //# sourceMappingURL=ConnectorsBrowser.d.ts.map