@jini-ai/ui 0.1.0

package/dist/features/asset-tree-browser/react/hooks/useAssetTreePreview.js

@@ -0,0 +1,37 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+/**
+ * Preview-pane selection: which file (by path) is previewed, resolved
+ * against the FULL `files` list (not just the current directory's listing)
+ * — the origin `DesignFilesPanel` never clears the preview on navigation, so
+ * it can keep showing a file after the user has navigated elsewhere.
+ * Auto-applies an optional host-supplied initial pick exactly once per
+ * mount, and clears the preview if its file vanishes from `files` (a delete
+ * or a refresh).
+ */
+export function useAssetTreePreview(files, selectInitialPreviewFile) {
+    const [previewPath, setPreviewPathState] = useState(null);
+    const autoPreviewAppliedRef = useRef(false);
+    const previewFile = useMemo(() => files.find((f) => f.path === previewPath) ?? null, [files, previewPath]);
+    useEffect(() => {
+        if (autoPreviewAppliedRef.current)
+            return;
+        if (!selectInitialPreviewFile)
+            return;
+        const initial = selectInitialPreviewFile([...files]);
+        if (!initial)
+            return;
+        autoPreviewAppliedRef.current = true;
+        setPreviewPathState(initial.path);
+    }, [files, selectInitialPreviewFile]);
+    useEffect(() => {
+        if (!previewPath)
+            return;
+        if (files.some((f) => f.path === previewPath))
+            return;
+        setPreviewPathState(null);
+    }, [files, previewPath]);
+    const setPreviewPath = useCallback((path) => setPreviewPathState(path), []);
+    const clearPreview = useCallback(() => setPreviewPathState(null), []);
+    return { previewPath, previewFile, setPreviewPath, clearPreview };
+}
+//# sourceMappingURL=useAssetTreePreview.js.map

package/dist/features/asset-tree-browser/react/hooks/useAssetTreePreview.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssetTreePreview.js","sourceRoot":"","sources":["../../../../../src/features/asset-tree-browser/react/hooks/useAssetTreePreview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAU1E;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB,CACjC,KAAuB,EACvB,wBAA2D;IAE3D,MAAM,CAAC,WAAW,EAAE,mBAAmB,CAAC,GAAG,QAAQ,CAAgB,IAAI,CAAC,CAAC;IACzE,MAAM,qBAAqB,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAE5C,MAAM,WAAW,GAAG,OAAO,CACzB,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI,IAAI,EACvD,CAAC,KAAK,EAAE,WAAW,CAAC,CACrB,CAAC;IAEF,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,qBAAqB,CAAC,OAAO;YAAE,OAAO;QAC1C,IAAI,CAAC,wBAAwB;YAAE,OAAO;QACtC,MAAM,OAAO,GAAG,wBAAwB,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;QACrD,IAAI,CAAC,OAAO;YAAE,OAAO;QACrB,qBAAqB,CAAC,OAAO,GAAG,IAAI,CAAC;QACrC,mBAAmB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC,EAAE,CAAC,KAAK,EAAE,wBAAwB,CAAC,CAAC,CAAC;IAEtC,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,WAAW;YAAE,OAAO;QACzB,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,CAAC;YAAE,OAAO;QACtD,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;IAEzB,MAAM,cAAc,GAAG,WAAW,CAAC,CAAC,IAAmB,EAAE,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAC3F,MAAM,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAEtE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,CAAC;AACpE,CAAC"}

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeRename.d.ts

@@ -0,0 +1,28 @@
+import type { AssetTreeFileItem, AssetTreeRenameState } from '../../types.js';
+export interface UseAssetTreeRenameParams<TFile extends AssetTreeFileItem> {
+    currentDir: string;
+    onRenameFile: (path: string, nextPath: string) => Promise<TFile | null> | TFile | null;
+    /** Fired after a successful rename, so the orchestrator can carry the preview/selection over to the new path. */
+    onRenamed?: (oldPath: string, renamedFile: TFile) => void;
+}
+export interface UseAssetTreeRenameResult {
+    renaming: AssetTreeRenameState | null;
+    /** Set when `onRenameFile` rejects or resolves falsy; cleared on the next `startRename`/`cancelRename`. */
+    renameError: string | null;
+    startRename: (path: string) => void;
+    updateDraft: (draft: string) => void;
+    commitRename: () => Promise<void>;
+    cancelRename: () => void;
+}
+/**
+ * Inline rename: start (seeds the draft with the current basename) / edit /
+ * commit / cancel. Diverges from the origin `DesignFilesPanel`'s
+ * `commitRename` in one deliberate way: a failed rename here is surfaced as
+ * `renameError` state instead of a blocking native `alert()` — this package
+ * ships into a headless, agent-drivable engine (see the repo's own
+ * `AGENTS.md`), where a hardcoded blocking dialog call is exactly the kind
+ * of host-hostile side effect a generic UI feature must not own. A host
+ * (or `RowContextMenu`) renders `renameError` however fits its own UI.
+ */
+export declare function useAssetTreeRename<TFile extends AssetTreeFileItem>(params: UseAssetTreeRenameParams<TFile>): UseAssetTreeRenameResult;
+//# sourceMappingURL=useAssetTreeRename.d.ts.map

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeRename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssetTreeRename.d.ts","sourceRoot":"","sources":["../../../../../src/features/asset-tree-browser/react/hooks/useAssetTreeRename.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE9E,MAAM,WAAW,wBAAwB,CAAC,KAAK,SAAS,iBAAiB;IACvE,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC;IACvF,iHAAiH;IACjH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,KAAK,IAAI,CAAC;CAC3D;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACtC,2GAA2G;IAC3G,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,YAAY,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,YAAY,EAAE,MAAM,IAAI,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,iBAAiB,EAChE,MAAM,EAAE,wBAAwB,CAAC,KAAK,CAAC,GACtC,wBAAwB,CA0C1B"}

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeRename.js

@@ -0,0 +1,51 @@
+import { useCallback, useState } from 'react';
+import { basenameForRename, resolveRenameCommit } from '../../rules.js';
+/**
+ * Inline rename: start (seeds the draft with the current basename) / edit /
+ * commit / cancel. Diverges from the origin `DesignFilesPanel`'s
+ * `commitRename` in one deliberate way: a failed rename here is surfaced as
+ * `renameError` state instead of a blocking native `alert()` — this package
+ * ships into a headless, agent-drivable engine (see the repo's own
+ * `AGENTS.md`), where a hardcoded blocking dialog call is exactly the kind
+ * of host-hostile side effect a generic UI feature must not own. A host
+ * (or `RowContextMenu`) renders `renameError` however fits its own UI.
+ */
+export function useAssetTreeRename(params) {
+    const { currentDir, onRenameFile, onRenamed } = params;
+    const [renaming, setRenaming] = useState(null);
+    const [renameError, setRenameError] = useState(null);
+    const startRename = useCallback((path) => {
+        setRenameError(null);
+        setRenaming({ path, draft: basenameForRename(path, currentDir), saving: false });
+    }, [currentDir]);
+    const updateDraft = useCallback((draft) => {
+        setRenaming((prev) => (prev ? { ...prev, draft } : prev));
+    }, []);
+    const cancelRename = useCallback(() => {
+        setRenaming(null);
+        setRenameError(null);
+    }, []);
+    const commitRename = useCallback(async () => {
+        if (!renaming)
+            return;
+        const decision = resolveRenameCommit(renaming.path, currentDir, renaming.draft);
+        if (!decision) {
+            setRenaming(null);
+            return;
+        }
+        setRenaming({ ...renaming, saving: true });
+        try {
+            const renamedFile = await onRenameFile(renaming.path, decision.nextPath);
+            if (!renamedFile)
+                throw new Error('Rename failed');
+            onRenamed?.(renaming.path, renamedFile);
+            setRenaming(null);
+        }
+        catch (err) {
+            setRenameError(err instanceof Error ? err.message : String(err));
+            setRenaming((prev) => (prev ? { ...prev, saving: false } : prev));
+        }
+    }, [renaming, currentDir, onRenameFile, onRenamed]);
+    return { renaming, renameError, startRename, updateDraft, commitRename, cancelRename };
+}
+//# sourceMappingURL=useAssetTreeRename.js.map

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeRename.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssetTreeRename.js","sourceRoot":"","sources":["../../../../../src/features/asset-tree-browser/react/hooks/useAssetTreeRename.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAoBxE;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAuC;IAEvC,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IACvD,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,CAA8B,IAAI,CAAC,CAAC;IAC5E,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,GAAG,QAAQ,CAAgB,IAAI,CAAC,CAAC;IAEpE,MAAM,WAAW,GAAG,WAAW,CAC7B,CAAC,IAAY,EAAE,EAAE;QACf,cAAc,CAAC,IAAI,CAAC,CAAC;QACrB,WAAW,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IACnF,CAAC,EACD,CAAC,UAAU,CAAC,CACb,CAAC;IAEF,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,KAAa,EAAE,EAAE;QAChD,WAAW,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC5D,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE;QACpC,WAAW,CAAC,IAAI,CAAC,CAAC;QAClB,cAAc,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,YAAY,GAAG,WAAW,CAAC,KAAK,IAAI,EAAE;QAC1C,IAAI,CAAC,QAAQ;YAAE,OAAO;QACtB,MAAM,QAAQ,GAAG,mBAAmB,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;QAChF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,WAAW,CAAC,IAAI,CAAC,CAAC;YAClB,OAAO;QACT,CAAC;QACD,WAAW,CAAC,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3C,IAAI,CAAC;YACH,MAAM,WAAW,GAAG,MAAM,YAAY,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACzE,IAAI,CAAC,WAAW;gBAAE,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;YACnD,SAAS,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;YACxC,WAAW,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,cAAc,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YACjE,WAAW,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACpE,CAAC;IACH,CAAC,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC,CAAC;IAEpD,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;AACzF,CAAC"}

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeRowMenu.d.ts

@@ -0,0 +1,19 @@
+import { type RefObject } from 'react';
+import { type MenuAnchorRect } from '../../rules.js';
+import type { AssetTreeDomBridgePort } from '../../ports.js';
+import type { AssetTreeMenuPosition } from '../../types.js';
+export interface UseAssetTreeRowMenuResult {
+    menuPos: AssetTreeMenuPosition | null;
+    /** Attach to the popover's root element — used as the outside-dismiss containment box. */
+    containerRef: RefObject<HTMLDivElement | null>;
+    openMenuFor: (path: string, anchor: MenuAnchorRect) => void;
+    closeMenu: () => void;
+}
+/**
+ * The row `⋯` context menu's open/positioned/dismiss state. Positioning is
+ * the pure viewport-flip math from `rules.ts`'s `computeMenuPosition`;
+ * dismissal (outside pointerdown or Escape) is wired through the
+ * `AssetTreeDomBridgePort` so it stays fake-able in tests.
+ */
+export declare function useAssetTreeRowMenu(dom: AssetTreeDomBridgePort): UseAssetTreeRowMenuResult;
+//# sourceMappingURL=useAssetTreeRowMenu.d.ts.map

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeRowMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssetTreeRowMenu.d.ts","sourceRoot":"","sources":["../../../../../src/features/asset-tree-browser/react/hooks/useAssetTreeRowMenu.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACjF,OAAO,EAAuB,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAE5D,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACtC,0FAA0F;IAC1F,YAAY,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC/C,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAC5D,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,sBAAsB,GAAG,yBAAyB,CAoB1F"}

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeRowMenu.js

@@ -0,0 +1,24 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { computeMenuPosition } from '../../rules.js';
+/**
+ * The row `⋯` context menu's open/positioned/dismiss state. Positioning is
+ * the pure viewport-flip math from `rules.ts`'s `computeMenuPosition`;
+ * dismissal (outside pointerdown or Escape) is wired through the
+ * `AssetTreeDomBridgePort` so it stays fake-able in tests.
+ */
+export function useAssetTreeRowMenu(dom) {
+    const [menuPos, setMenuPos] = useState(null);
+    const containerRef = useRef(null);
+    const openMenuFor = useCallback((path, anchor) => {
+        const { top, left } = computeMenuPosition(anchor, dom.getViewportHeight());
+        setMenuPos({ path, top, left });
+    }, [dom]);
+    const closeMenu = useCallback(() => setMenuPos(null), []);
+    useEffect(() => {
+        if (!menuPos)
+            return;
+        return dom.subscribeOutsideDismiss(containerRef, closeMenu);
+    }, [menuPos, dom, closeMenu]);
+    return { menuPos, containerRef, openMenuFor, closeMenu };
+}
+//# sourceMappingURL=useAssetTreeRowMenu.js.map

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeRowMenu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssetTreeRowMenu.js","sourceRoot":"","sources":["../../../../../src/features/asset-tree-browser/react/hooks/useAssetTreeRowMenu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAkB,MAAM,OAAO,CAAC;AACjF,OAAO,EAAE,mBAAmB,EAAuB,MAAM,gBAAgB,CAAC;AAY1E;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAA2B;IAC7D,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,QAAQ,CAA+B,IAAI,CAAC,CAAC;IAC3E,MAAM,YAAY,GAAG,MAAM,CAAwB,IAAI,CAAC,CAAC;IAEzD,MAAM,WAAW,GAAG,WAAW,CAC7B,CAAC,IAAY,EAAE,MAAsB,EAAE,EAAE;QACvC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,iBAAiB,EAAE,CAAC,CAAC;QAC3E,UAAU,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;IAClC,CAAC,EACD,CAAC,GAAG,CAAC,CACN,CAAC;IAEF,MAAM,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;IAE1D,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,OAAO;YAAE,OAAO;QACrB,OAAO,GAAG,CAAC,uBAAuB,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;IAC9D,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC;IAE9B,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC;AAC3D,CAAC"}

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeSelection.d.ts

@@ -0,0 +1,29 @@
+import type { AssetTreeFileItem } from '../../types.js';
+export interface UseAssetTreeSelectionResult {
+    selected: Set<string>;
+    toggleSelect: (path: string) => void;
+    clearSelection: () => void;
+    /** Carries a selected path over to its new path after a successful rename, instead of silently dropping the selection. */
+    renamePath: (oldPath: string, newPath: string) => void;
+}
+/**
+ * Row selection: a `Set` of selected paths, reset whenever the viewed
+ * directory changes, and pruned whenever a previously-selected path
+ * disappears from the current listing (a delete or a refresh) — mirrors
+ * `features/asset-grid`'s `useAssetGridSelection`, scoped to `path` instead
+ * of `id`.
+ *
+ * `pendingRenamePath` (the path `useAssetTreeRename` currently has in
+ * flight, if any) is exempted from pruning. Without this, a host that
+ * updates its `files` prop as soon as `onRenameFile` resolves — before
+ * `AssetTreeBrowser`'s own `onRenamed` callback gets to call `renamePath`
+ * below — creates a real race: the old path vanishes from `filesAtCurrentDir`
+ * and gets pruned away *before* `renamePath` runs, so `renamePath`'s own
+ * `prev.has(oldPath)` guard (see below) then finds nothing to carry over and
+ * silently no-ops, dropping the selection. Keeping the in-flight path "live"
+ * for pruning purposes closes that window; once the rename actually
+ * resolves, `renamePath` swaps it for the new path, which is by then always
+ * present in the caller's updated `files`.
+ */
+export declare function useAssetTreeSelection<TFile extends AssetTreeFileItem>(filesAtCurrentDir: readonly TFile[], currentDir: string, pendingRenamePath?: string | null): UseAssetTreeSelectionResult;
+//# sourceMappingURL=useAssetTreeSelection.d.ts.map

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssetTreeSelection.d.ts","sourceRoot":"","sources":["../../../../../src/features/asset-tree-browser/react/hooks/useAssetTreeSelection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtB,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,0HAA0H;IAC1H,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACxD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,SAAS,iBAAiB,EACnE,iBAAiB,EAAE,SAAS,KAAK,EAAE,EACnC,UAAU,EAAE,MAAM,EAClB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,GAChC,2BAA2B,CAgC7B"}

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeSelection.js

@@ -0,0 +1,51 @@
+import { useCallback, useEffect, useState } from 'react';
+import { pruneMissingPaths, toggleInSet } from '../../rules.js';
+/**
+ * Row selection: a `Set` of selected paths, reset whenever the viewed
+ * directory changes, and pruned whenever a previously-selected path
+ * disappears from the current listing (a delete or a refresh) — mirrors
+ * `features/asset-grid`'s `useAssetGridSelection`, scoped to `path` instead
+ * of `id`.
+ *
+ * `pendingRenamePath` (the path `useAssetTreeRename` currently has in
+ * flight, if any) is exempted from pruning. Without this, a host that
+ * updates its `files` prop as soon as `onRenameFile` resolves — before
+ * `AssetTreeBrowser`'s own `onRenamed` callback gets to call `renamePath`
+ * below — creates a real race: the old path vanishes from `filesAtCurrentDir`
+ * and gets pruned away *before* `renamePath` runs, so `renamePath`'s own
+ * `prev.has(oldPath)` guard (see below) then finds nothing to carry over and
+ * silently no-ops, dropping the selection. Keeping the in-flight path "live"
+ * for pruning purposes closes that window; once the rename actually
+ * resolves, `renamePath` swaps it for the new path, which is by then always
+ * present in the caller's updated `files`.
+ */
+export function useAssetTreeSelection(filesAtCurrentDir, currentDir, pendingRenamePath) {
+    const [selected, setSelected] = useState(() => new Set());
+    useEffect(() => {
+        setSelected(new Set());
+    }, [currentDir]);
+    useEffect(() => {
+        setSelected((prev) => {
+            const livePaths = filesAtCurrentDir.map((f) => f.path);
+            if (pendingRenamePath)
+                livePaths.push(pendingRenamePath);
+            return pruneMissingPaths(prev, livePaths);
+        });
+    }, [filesAtCurrentDir, pendingRenamePath]);
+    const toggleSelect = useCallback((path) => {
+        setSelected((prev) => toggleInSet(prev, path));
+    }, []);
+    const clearSelection = useCallback(() => setSelected(new Set()), []);
+    const renamePath = useCallback((oldPath, newPath) => {
+        setSelected((prev) => {
+            if (!prev.has(oldPath))
+                return prev;
+            const next = new Set(prev);
+            next.delete(oldPath);
+            next.add(newPath);
+            return next;
+        });
+    }, []);
+    return { selected, toggleSelect, clearSelection, renamePath };
+}
+//# sourceMappingURL=useAssetTreeSelection.js.map

package/dist/features/asset-tree-browser/react/hooks/useAssetTreeSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssetTreeSelection.js","sourceRoot":"","sources":["../../../../../src/features/asset-tree-browser/react/hooks/useAssetTreeSelection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAWhE;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,qBAAqB,CACnC,iBAAmC,EACnC,UAAkB,EAClB,iBAAiC;IAEjC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAc,GAAG,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;IAEvE,SAAS,CAAC,GAAG,EAAE;QACb,WAAW,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;IACzB,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjB,SAAS,CAAC,GAAG,EAAE;QACb,WAAW,CAAC,CAAC,IAAI,EAAE,EAAE;YACnB,MAAM,SAAS,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACvD,IAAI,iBAAiB;gBAAE,SAAS,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YACzD,OAAO,iBAAiB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC,EAAE,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAE3C,MAAM,YAAY,GAAG,WAAW,CAAC,CAAC,IAAY,EAAE,EAAE;QAChD,WAAW,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACjD,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,IAAI,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;IAErE,MAAM,UAAU,GAAG,WAAW,CAAC,CAAC,OAAe,EAAE,OAAe,EAAE,EAAE;QAClE,WAAW,CAAC,CAAC,IAAI,EAAE,EAAE;YACnB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC;gBAAE,OAAO,IAAI,CAAC;YACpC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;YAC3B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACrB,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YAClB,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,CAAC;AAChE,CAAC"}

package/dist/features/asset-tree-browser/rules.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Pure logic for the asset-tree-browser feature. No React.
+ *
+ * The clipboard-paste and drag-and-drop directory-expansion primitives
+ * (`filesFromDataTransfer`/`filesFromFileSystemEntry`/`filesFromClipboardData`/
+ * `normalizePastedFile`/`extensionForMimeType`/`shouldIgnoreClipboardFilePaste`)
+ * were promoted (2026-07-18) to `utils/file-transfer.ts` once
+ * `features/file-dropzone/` needed the identical directory-walking algorithm —
+ * re-exported here unchanged so this feature's own barrel/tests don't churn.
+ */
+export { filesFromClipboardData, normalizePastedFile, extensionForMimeType, shouldIgnoreClipboardFilePaste, filesFromDataTransfer, filesFromFileSystemEntry, } from '../../utils/file-transfer.js';
+import type { AssetTreeBreadcrumbSegment, AssetTreeFileItem, AssetTreeFolderItem, AssetTreeKindConfig, AssetTreeKindConfigMap, AssetTreeRelativeTime, AssetTreeSection, AssetTreeSelectors } from './types.js';
+export interface TreeChildren<TFile> {
+    dirsAtCurrentDir: string[];
+    filesAtCurrentDir: TFile[];
+}
+/**
+ * Derives the immediate subdirectories and files visible at `currentDir`
+ * from the flat `files` list plus any persisted (possibly-empty) `folders`.
+ *
+ * Preserves the origin's root-level behavior exactly: at the tree root
+ * (`currentDir === ''`), every file is pushed into `filesAtCurrentDir` —
+ * both root-level files AND files nested under a subdirectory (which also
+ * contribute their top segment to `dirsAtCurrentDir`) — so the root view is
+ * a flattened "everything" listing with folders offered as a secondary
+ * drill-down. Inside a non-root directory, only files strictly at that one
+ * level are included. Verified against the real `DesignFilesPanel.tsx`
+ * (`dirsAtCurrentDir`/`filesAtCurrentDir` `useMemo`) rather than assumed —
+ * this asymmetry looks surprising but is exactly what the source does.
+ */
+export declare function deriveTreeChildren<TFile extends AssetTreeFileItem>(files: readonly TFile[], folders: readonly AssetTreeFolderItem[], currentDir: string): TreeChildren<TFile>;
+/** Total files (at every depth, not just the immediate level) under `dirPath` — what a folder row's "N files" subtitle counts. */
+export declare function countFilesUnderDir<TFile extends AssetTreeFileItem>(files: readonly TFile[], dirPath: string): number;
+/**
+ * Groups files at the current level into kind sections, ordered by the
+ * host's `sectionOrder` with any kind absent from it appended afterward in
+ * first-seen order (the origin's `SECTION_ORDER` never needed this fallback
+ * since it enumerated every `ProjectFileKind` — this package's `kind` is an
+ * arbitrary host string, so an unconfigured kind must still render
+ * somewhere rather than silently vanishing). Files within a section sort
+ * most-recently-modified first.
+ */
+export declare function groupFilesByKind<TFile>(files: readonly TFile[], sectionOrder: readonly string[], getKind: (file: TFile) => string, getModifiedAt: (file: TFile) => number): AssetTreeSection<TFile>[];
+/**
+ * The nearest ancestor of `currentDir` that still exists (has files under it
+ * or is itself a persisted folder), or `''` if none do. Returns `null` when
+ * no correction is needed (already at the root, or `currentDir` itself still
+ * exists) — callers should treat `null` as "don't navigate".
+ */
+export declare function nextExistingAncestorDir<TFile extends AssetTreeFileItem>(files: readonly TFile[], folders: readonly AssetTreeFolderItem[], currentDir: string): string | null;
+export declare function toggleInSet(prev: ReadonlySet<string>, path: string): Set<string>;
+/**
+ * Drops selected paths absent from `livePaths`. Returns `prev` unchanged
+ * (the exact same `Set` reference) when nothing was dropped, so a caller's
+ * `setSelected` bails out of the state update instead of forcing an extra
+ * render — same reasoning as `features/asset-grid/rules.ts`'s
+ * `pruneMissingSelection`.
+ */
+export declare function pruneMissingPaths(prev: Set<string>, livePaths: Iterable<string>): Set<string>;
+/** The editable basename for `path` when renaming inside `currentDir` (strips the directory prefix). */
+export declare function basenameForRename(path: string, currentDir: string): string;
+export interface RenameCommitDecision {
+    nextPath: string;
+}
+/**
+ * Whether a commit of `draft` (the edited basename) should proceed, and the
+ * resulting full path if so. Returns `null` for the two no-op cases the
+ * origin's `commitRename` short-circuits on: an empty (whitespace-only)
+ * draft, or a draft that resolves back to the exact same path.
+ */
+export declare function resolveRenameCommit(path: string, currentDir: string, draft: string): RenameCommitDecision | null;
+export interface MenuAnchorRect {
+    top: number;
+    bottom: number;
+    right: number;
+}
+export interface MenuPositionOptions {
+    estimatedHeight?: number;
+    safePadding?: number;
+}
+/**
+ * Viewport-flip position for the row context menu: opens below its anchor
+ * when there's room, above when there isn't but there IS room above, and
+ * otherwise clamps to the viewport with `safePadding` clearance.
+ */
+export declare function computeMenuPosition(anchor: MenuAnchorRect, viewportHeight: number, options?: MenuPositionOptions): {
+    top: number;
+    left: number;
+};
+/** Whether the row menu's "copy local path" action should be enabled for `file`. */
+export declare function canCopyLocalPath<TFile>(file: TFile, selectors: AssetTreeSelectors<TFile>): boolean;
+/** Whether `nowMs` lands within `windowMs` of a prior activation timestamp — the double-Enter-to-open gesture on a keyboard-focused row name. */
+export declare function isDoubleActivation(lastTimestampMs: number | undefined, nowMs: number, windowMs?: number): boolean;
+/** Display config for `kind`, falling back to the raw kind key as the label and a generic glyph when the host's `AssetTreeKindConfigMap` has no entry for it. */
+export declare function resolveKindConfig(kind: string, kindConfig: AssetTreeKindConfigMap): AssetTreeKindConfig;
+export declare function humanBytes(n: number): string;
+/** See {@link AssetTreeRelativeTime} for why this returns a template + params instead of a finished string. */
+export declare function relativeTimeResult(ts: number, nowMs?: number): AssetTreeRelativeTime;
+/** Uppercase extension for a path's display, e.g. `"a/b.TXT"` -> `"TXT"`; `""` for an extensionless or dotfile-only path. */
+export declare function fileExtensionLabel(path: string): string;
+/** Breadcrumb segments for every path component below the tree root (the root itself is rendered separately by `Breadcrumbs` since its label is host-configurable). */
+export declare function buildBreadcrumbSegments(currentDir: string): AssetTreeBreadcrumbSegment[];
+//# sourceMappingURL=rules.d.ts.map

package/dist/features/asset-tree-browser/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/features/asset-tree-browser/rules.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,254 @@
+/**
+ * Pure logic for the asset-tree-browser feature. No React.
+ *
+ * The clipboard-paste and drag-and-drop directory-expansion primitives
+ * (`filesFromDataTransfer`/`filesFromFileSystemEntry`/`filesFromClipboardData`/
+ * `normalizePastedFile`/`extensionForMimeType`/`shouldIgnoreClipboardFilePaste`)
+ * were promoted (2026-07-18) to `utils/file-transfer.ts` once
+ * `features/file-dropzone/` needed the identical directory-walking algorithm —
+ * re-exported here unchanged so this feature's own barrel/tests don't churn.
+ */
+export { filesFromClipboardData, normalizePastedFile, extensionForMimeType, shouldIgnoreClipboardFilePaste, filesFromDataTransfer, filesFromFileSystemEntry, } from '../../utils/file-transfer.js';
+import { DEFAULT_KIND_GLYPH, DOUBLE_ACTIVATION_WINDOW_MS, ROW_MENU_ESTIMATED_HEIGHT_PX, ROW_MENU_SAFE_PADDING_PX, } from './constants.js';
+/**
+ * Derives the immediate subdirectories and files visible at `currentDir`
+ * from the flat `files` list plus any persisted (possibly-empty) `folders`.
+ *
+ * Preserves the origin's root-level behavior exactly: at the tree root
+ * (`currentDir === ''`), every file is pushed into `filesAtCurrentDir` —
+ * both root-level files AND files nested under a subdirectory (which also
+ * contribute their top segment to `dirsAtCurrentDir`) — so the root view is
+ * a flattened "everything" listing with folders offered as a secondary
+ * drill-down. Inside a non-root directory, only files strictly at that one
+ * level are included. Verified against the real `DesignFilesPanel.tsx`
+ * (`dirsAtCurrentDir`/`filesAtCurrentDir` `useMemo`) rather than assumed —
+ * this asymmetry looks surprising but is exactly what the source does.
+ */
+export function deriveTreeChildren(files, folders, currentDir) {
+    const prefix = currentDir === '' ? '' : `${currentDir}/`;
+    const dirs = new Set();
+    const localFiles = [];
+    for (const f of files) {
+        if (!f.path.startsWith(prefix))
+            continue;
+        const remainder = f.path.slice(prefix.length);
+        const slashIdx = remainder.indexOf('/');
+        if (slashIdx === -1) {
+            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))
+            continue;
+        const remainder = folder.path.slice(prefix.length);
+        if (!remainder)
+            continue; // the current directory itself
+        const slashIdx = remainder.indexOf('/');
+        dirs.add(slashIdx === -1 ? remainder : remainder.slice(0, slashIdx));
+    }
+    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) {
+    const prefix = `${dirPath}/`;
+    let count = 0;
+    for (const f of files) {
+        if (f.path.startsWith(prefix))
+            count += 1;
+    }
+    return count;
+}
+/**
+ * Groups files at the current level into kind sections, ordered by the
+ * host's `sectionOrder` with any kind absent from it appended afterward in
+ * first-seen order (the origin's `SECTION_ORDER` never needed this fallback
+ * since it enumerated every `ProjectFileKind` — this package's `kind` is an
+ * arbitrary host string, so an unconfigured kind must still render
+ * somewhere rather than silently vanishing). Files within a section sort
+ * most-recently-modified first.
+ */
+export function groupFilesByKind(files, sectionOrder, getKind, getModifiedAt) {
+    const grouped = new Map();
+    const firstSeenOrder = [];
+    for (const f of files) {
+        const kind = getKind(f);
+        let bucket = grouped.get(kind);
+        if (!bucket) {
+            bucket = [];
+            grouped.set(kind, bucket);
+            firstSeenOrder.push(kind);
+        }
+        bucket.push(f);
+    }
+    for (const bucket of grouped.values()) {
+        bucket.sort((a, b) => getModifiedAt(b) - getModifiedAt(a));
+    }
+    const ordered = sectionOrder.filter((kind) => grouped.has(kind));
+    const seen = new Set(ordered);
+    for (const kind of firstSeenOrder) {
+        if (!seen.has(kind)) {
+            ordered.push(kind);
+            seen.add(kind);
+        }
+    }
+    return ordered.map((kind) => ({ kind, files: grouped.get(kind) }));
+}
+/**
+ * The nearest ancestor of `currentDir` that still exists (has files under it
+ * or is itself a persisted folder), or `''` if none do. Returns `null` when
+ * no correction is needed (already at the root, or `currentDir` itself still
+ * exists) — callers should treat `null` as "don't navigate".
+ */
+export function nextExistingAncestorDir(files, folders, currentDir) {
+    if (currentDir === '')
+        return null;
+    const dirExists = (dir) => files.some((f) => f.path.startsWith(`${dir}/`)) ||
+        folders.some((fo) => fo.path === dir || fo.path.startsWith(`${dir}/`));
+    if (dirExists(currentDir))
+        return null;
+    const parts = currentDir.split('/');
+    for (let i = parts.length - 1; i > 0; i--) {
+        const ancestor = parts.slice(0, i).join('/');
+        if (dirExists(ancestor))
+            return ancestor;
+    }
+    return '';
+}
+// --- selection ---------------------------------------------------------
+export function toggleInSet(prev, path) {
+    const next = new Set(prev);
+    if (next.has(path))
+        next.delete(path);
+    else
+        next.add(path);
+    return next;
+}
+/**
+ * Drops selected paths absent from `livePaths`. Returns `prev` unchanged
+ * (the exact same `Set` reference) when nothing was dropped, so a caller's
+ * `setSelected` bails out of the state update instead of forcing an extra
+ * render — same reasoning as `features/asset-grid/rules.ts`'s
+ * `pruneMissingSelection`.
+ */
+export function pruneMissingPaths(prev, livePaths) {
+    if (prev.size === 0)
+        return prev;
+    const live = new Set(livePaths);
+    const next = new Set(prev);
+    let changed = false;
+    for (const p of next) {
+        if (!live.has(p)) {
+            next.delete(p);
+            changed = true;
+        }
+    }
+    return changed ? next : prev;
+}
+// --- rename ---------------------------------------------------------
+/** The editable basename for `path` when renaming inside `currentDir` (strips the directory prefix). */
+export function basenameForRename(path, currentDir) {
+    return currentDir === '' ? path : path.slice(currentDir.length + 1);
+}
+/**
+ * Whether a commit of `draft` (the edited basename) should proceed, and the
+ * resulting full path if so. Returns `null` for the two no-op cases the
+ * origin's `commitRename` short-circuits on: an empty (whitespace-only)
+ * draft, or a draft that resolves back to the exact same path.
+ */
+export function resolveRenameCommit(path, currentDir, draft) {
+    const nextBasename = draft.trim();
+    if (!nextBasename)
+        return null;
+    const nextPath = currentDir === '' ? nextBasename : `${currentDir}/${nextBasename}`;
+    if (nextPath === path)
+        return null;
+    return { nextPath };
+}
+/**
+ * Viewport-flip position for the row context menu: opens below its anchor
+ * when there's room, above when there isn't but there IS room above, and
+ * otherwise clamps to the viewport with `safePadding` clearance.
+ */
+export function computeMenuPosition(anchor, viewportHeight, options = {}) {
+    const estimatedHeight = options.estimatedHeight ?? ROW_MENU_ESTIMATED_HEIGHT_PX;
+    const safePadding = options.safePadding ?? ROW_MENU_SAFE_PADDING_PX;
+    const spaceBelow = viewportHeight - anchor.bottom;
+    const spaceAbove = anchor.top;
+    let top;
+    if (spaceBelow >= estimatedHeight + safePadding) {
+        top = anchor.bottom + 4;
+    }
+    else if (spaceAbove >= estimatedHeight + safePadding) {
+        top = anchor.top - estimatedHeight - 4;
+    }
+    else {
+        top = Math.max(safePadding, viewportHeight - estimatedHeight - safePadding);
+    }
+    const left = Math.max(safePadding, anchor.right - 160);
+    return { top, left };
+}
+/** Whether the row menu's "copy local path" action should be enabled for `file`. */
+export function canCopyLocalPath(file, selectors) {
+    return !!selectors.getLocalPath?.(file);
+}
+// --- keyboard row activation ---------------------------------------------------
+/** Whether `nowMs` lands within `windowMs` of a prior activation timestamp — the double-Enter-to-open gesture on a keyboard-focused row name. */
+export function isDoubleActivation(lastTimestampMs, nowMs, windowMs = DOUBLE_ACTIVATION_WINDOW_MS) {
+    return lastTimestampMs !== undefined && nowMs - lastTimestampMs < windowMs;
+}
+// --- display formatting ---------------------------------------------------
+/** Display config for `kind`, falling back to the raw kind key as the label and a generic glyph when the host's `AssetTreeKindConfigMap` has no entry for it. */
+export function resolveKindConfig(kind, kindConfig) {
+    return kindConfig[kind] ?? { label: kind, glyph: DEFAULT_KIND_GLYPH };
+}
+export function humanBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+/** See {@link AssetTreeRelativeTime} for why this returns a template + params instead of a finished string. */
+export function relativeTimeResult(ts, nowMs = Date.now()) {
+    const diff = nowMs - ts;
+    const min = 60_000;
+    const hr = 60 * min;
+    const day = 24 * hr;
+    if (diff < min)
+        return { label: 'Just now', translatable: true };
+    if (diff < hr)
+        return { label: '{n}m ago', translatable: true, params: { n: Math.floor(diff / min) } };
+    if (diff < day)
+        return { label: '{n}h ago', translatable: true, params: { n: Math.floor(diff / hr) } };
+    if (diff < 7 * day)
+        return { label: '{n}d ago', translatable: true, params: { n: Math.floor(diff / day) } };
+    if (diff < 30 * day) {
+        return { label: '{n}w ago', translatable: true, params: { n: Math.floor(diff / (7 * day)) } };
+    }
+    return { label: new Date(ts).toLocaleDateString(), translatable: false };
+}
+/** Uppercase extension for a path's display, e.g. `"a/b.TXT"` -> `"TXT"`; `""` for an extensionless or dotfile-only path. */
+export function fileExtensionLabel(path) {
+    const dot = path.lastIndexOf('.');
+    if (dot < 0 || dot === path.length - 1)
+        return '';
+    return path.slice(dot + 1).toUpperCase();
+}
+/** Breadcrumb segments for every path component below the tree root (the root itself is rendered separately by `Breadcrumbs` since its label is host-configurable). */
+export function buildBreadcrumbSegments(currentDir) {
+    const parts = currentDir.split('/').filter(Boolean);
+    return parts.map((segment, idx) => ({
+        path: parts.slice(0, idx + 1).join('/'),
+        label: segment,
+        isLast: idx === parts.length - 1,
+    }));
+}
+//# sourceMappingURL=rules.js.map