janissary 0.5.0

package/dist/editor-watch-manager.js

@@ -0,0 +1,84 @@
+import { watch, statSync } from 'node:fs';
+import { messageBus } from './bus.js';
+const DEBOUNCE_MS = 100;
+// Watches an open editor tab's underlying file for changes made by other processes, keyed by tab
+// label. `markSaved` moves the baseline mtime forward before the write's own `fs.watch` event
+// arrives, so the app's own saves never appear as an external change.
+export class EditorWatchManager {
+    managers;
+    tabs = new Map();
+    constructor(managers) {
+        this.managers = managers;
+    }
+    watch(label, filePath) {
+        this.unwatch(label);
+        let baselineMtimeMs;
+        try {
+            baselineMtimeMs = statSync(filePath).mtimeMs;
+        }
+        catch {
+            return;
+        }
+        try {
+            const watcher = watch(filePath, () => this.scheduleCheck(label));
+            this.tabs.set(label, { filePath, watcher, baselineMtimeMs });
+        }
+        catch {
+            // Exotic filesystems, fd limits, races — the editor still works, just without live reload.
+        }
+    }
+    // Move the baseline forward after the app's own write, so the resulting `fs.watch` event isn't
+    // mistaken for an external change.
+    markSaved(label, mtimeMs) {
+        const state = this.tabs.get(label);
+        if (state)
+            state.baselineMtimeMs = mtimeMs;
+    }
+    closeTab(label) {
+        this.unwatch(label);
+    }
+    dispose() {
+        for (const label of this.tabs.keys())
+            this.unwatch(label);
+    }
+    unwatch(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        if (state.debounce)
+            clearTimeout(state.debounce);
+        try {
+            state.watcher.close();
+        }
+        catch { /* already gone */ }
+        this.tabs.delete(label);
+    }
+    scheduleCheck(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        if (state.debounce)
+            clearTimeout(state.debounce);
+        state.debounce = setTimeout(() => this.check(label), DEBOUNCE_MS);
+    }
+    check(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        let mtimeMs;
+        try {
+            mtimeMs = statSync(state.filePath).mtimeMs;
+        }
+        catch {
+            return;
+        }
+        if (mtimeMs === state.baselineMtimeMs)
+            return;
+        state.baselineMtimeMs = mtimeMs;
+        const tab = this.managers.tab.tabs.find((t) => t.label === label);
+        if (!tab?.editor)
+            return;
+        tab.editor = { ...tab.editor, mtimeMs };
+        messageBus.emit('state', { type: 'dirty' });
+    }
+}

package/dist/file-tree-args.js

@@ -0,0 +1,36 @@
+// Parses the argument tail of a `files [left|right] [path]` / `files in <label> [on <side>]`
+// command. Consumes leading `in <label>` / `on <left|right>` clauses (either order, each at most
+// once), then falls back to the bare `left`/`right` keyword if neither clause was used. Whatever's
+// left over is the path target.
+export function parseFileTreeArgs(rest) {
+    let cursor = rest;
+    let inLabel;
+    let dock = null;
+    for (;;) {
+        if (inLabel === undefined) {
+            const inMatch = /^in\s+(\S+)\b\s*/i.exec(cursor);
+            if (inMatch) {
+                inLabel = inMatch[1];
+                cursor = cursor.slice(inMatch[0].length);
+                continue;
+            }
+        }
+        if (dock === null) {
+            const onMatch = /^on\s+(left|right)\b\s*/i.exec(cursor);
+            if (onMatch) {
+                dock = onMatch[1].toLowerCase();
+                cursor = cursor.slice(onMatch[0].length);
+                continue;
+            }
+        }
+        break;
+    }
+    if (inLabel === undefined && dock === null) {
+        const keyword = /^(left|right)\b\s*/i.exec(cursor);
+        if (keyword) {
+            dock = keyword[1].toLowerCase();
+            cursor = cursor.slice(keyword[0].length);
+        }
+    }
+    return { inLabel, dock, target: cursor.trim() };
+}

package/dist/file-tree-git-refresh.js

@@ -0,0 +1,33 @@
+import { changedPaths, currentBranch } from './git-status.js';
+// Recompute one tab's git-changed set and current branch off the event loop, then re-render with
+// them via `rebuild` (decision 6's second `dirty` emit). Coalesced: if a refresh is already in
+// flight for this tab, the request only sets a stale bit and exactly one follow-up runs when the
+// current one resolves — no overlapping git processes. The captured `root` guards against a
+// mid-flight `reroot` or tab close: a result whose tab is gone or whose root has changed is
+// discarded, never written.
+export function refreshGit(states, label, rebuild) {
+    const state = states.get(label);
+    if (!state)
+        return;
+    if (state.gitRefreshing) {
+        state.gitRefreshStale = true;
+        return;
+    }
+    state.gitRefreshing = true;
+    const root = state.root;
+    void Promise.all([changedPaths(root), currentBranch(root)]).then(([changed, branch]) => {
+        const current = states.get(label);
+        if (!current)
+            return;
+        if (current.root === root) {
+            current.changed = changed;
+            current.branch = branch;
+            rebuild(label);
+        }
+        current.gitRefreshing = false;
+        if (current.gitRefreshStale) {
+            current.gitRefreshStale = false;
+            refreshGit(states, label, rebuild);
+        }
+    });
+}

package/dist/file-tree-manager.js

@@ -0,0 +1,252 @@
+import { statSync, renameSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { messageBus } from './bus.js';
+import { buildRows, isSameOrDescendantPath, parentPath } from './file-tree.js';
+import { refreshGit } from './file-tree-git-refresh.js';
+import { parseFileTreeArgs } from './file-tree-args.js';
+import { expandUserPath } from './paths.js';
+import { resolveTarget } from './commands/resolve-target.js';
+import { openOrRetarget } from './file-tree-open.js';
+import { applyStackMove } from './file-tree-moves.js';
+import { watchDir, unwatchDir } from './file-tree-watch.js';
+import { pruneAndBuildRows } from './file-tree-rebuild.js';
+const DEBOUNCE_MS = 100;
+// Owns file tree tabs: opening/focusing them, their `expanded` directory sets, and one
+// non-recursive `fs.watch` per visible directory. Any watch event schedules a single per-tab
+// debounced rebuild; the server always owns the tree — the client only ever renders rows.
+export class FileTreeManager {
+    managers;
+    tabs = new Map();
+    constructor(managers) {
+        this.managers = managers;
+    }
+    // Handle a `files [left|right] [path]` command: open a new tree tab rooted at `path` (or the
+    // issuing tab's cwd), or focus/redock the existing tab if one is already open on that root.
+    // A leading `left`/`right` keyword docks the tab into that sidebar; a directory literally named
+    // `left`/`right` is still reachable via a path form (`files ./left`), since the keyword is only
+    // recognized as the first word. `in <label>` roots the tree at another tab's cwd instead of the
+    // issuing tab's, and `on <left|right>` is an explicit spelling of the same docking the bare
+    // keyword provides; both are optional, independent, and may appear in either order (`files in
+    // claude on left`). Like `left`/`right`, they are only recognized as clause keywords — a
+    // directory literally named `in`/`on` stays reachable via a path form (`files ./in`).
+    open(command, label) {
+        const rest = command.replace(/^files\b\s*/i, '');
+        const { inLabel, dock, target } = parseFileTreeArgs(rest);
+        const out = (text) => this.managers.tab.append(label, { input: command, output: text });
+        let cwd;
+        if (inLabel === undefined) {
+            cwd = this.managers.tab.cwdOf(label) ?? process.cwd();
+        }
+        else {
+            const sourceTab = resolveTarget(inLabel, this.managers, out);
+            if (!sourceTab)
+                return;
+            cwd = this.managers.tab.cwdOf(sourceTab.label) ?? process.cwd();
+        }
+        const expandedPath = target ? expandUserPath(target, { root: this.managers.tab.launchDir }) : '';
+        const root = target ? (path.isAbsolute(expandedPath) ? expandedPath : path.resolve(cwd, expandedPath)) : cwd;
+        let stat;
+        try {
+            stat = statSync(root);
+        }
+        catch {
+            stat = undefined;
+        }
+        if (!stat?.isDirectory()) {
+            out(`files: ${root}: not a directory`);
+            return;
+        }
+        const existing = this.managers.tab.tabs.find((t) => t.files?.root === root);
+        if (existing) {
+            this.managers.tab.setDock(this.managers.tab.findIndex(existing.label), dock);
+            return;
+        }
+        const expanded = new Set();
+        this.managers.tab.openFilesTab({ root, absoluteRoot: root, rows: buildRows(root, expanded) });
+        const newLabel = this.managers.tab.cur().label;
+        this.managers.tab.setCwd(newLabel, root);
+        this.tabs.set(newLabel, { root, expanded, watchers: new Map(), undoStack: [], redoStack: [], changed: new Set() });
+        this.watchDir(newLabel, root, '');
+        if (dock)
+            this.managers.tab.setDock(this.managers.tab.findIndex(newLabel), dock);
+        this.refreshGit(newLabel);
+    }
+    // Expand/collapse one directory row.
+    toggle(label, relPath) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        if (state.expanded.has(relPath)) {
+            state.expanded.delete(relPath);
+            this.unwatchDir(state, relPath);
+        }
+        else {
+            state.expanded.add(relPath);
+            this.watchDir(label, path.join(state.root, relPath), relPath);
+        }
+        this.rebuild(label);
+    }
+    // Collapse every expanded directory back to just the root.
+    collapseAll(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        for (const relPath of state.expanded)
+            this.unwatchDir(state, relPath);
+        state.expanded.clear();
+        this.rebuild(label);
+    }
+    // Re-root the tree to the parent directory. Clears expanded state and watchers, then rebuilds.
+    reroot(label, relPath) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        const target = relPath ? path.resolve(state.root, relPath) : path.resolve(state.root, '..');
+        if (target === state.root)
+            return;
+        for (const relPath of state.expanded)
+            this.unwatchDir(state, relPath);
+        state.expanded.clear();
+        this.unwatchDir(state, '');
+        state.root = target;
+        state.changed = new Set();
+        state.branch = undefined;
+        this.watchDir(label, target, '');
+        if (this.managers.tab.tabs.some((t) => t.label === label))
+            this.managers.tab.setCwd(label, target);
+        this.rebuild(label);
+        this.refreshGit(label);
+    }
+    // Open a file navigator at `label`'s cwd (the metadata-row 📁 button). If a file-tree tab is
+    // already open, retarget the most-recently-focused one to that cwd in place — preserving its
+    // identity, dock placement, and strip position; otherwise open a fresh tree docked in the left
+    // sidebar. Either way, focus stays on the tab whose button was clicked. See `file-tree-open.ts`.
+    openOrRetarget(label) {
+        openOrRetarget(this.openPort(), label);
+    }
+    // The narrow set of manager internals `file-tree-open.ts` operates through, passed as bound
+    // closures so the tab-state map and watcher methods stay private to this class.
+    openPort() {
+        return {
+            managers: this.managers,
+            states: this.tabs,
+            watchDir: (label, absDir, relPath) => this.watchDir(label, absDir, relPath),
+            unwatchDir: (state, relPath) => this.unwatchDir(state, relPath),
+            rebuild: (label) => this.rebuild(label),
+        };
+    }
+    // Move a file or directory into a different directory (drag-and-release in the tree). Rejects
+    // moving an item onto itself or into one of its own descendants; a same-named entry already at
+    // the destination is overwritten (the client has already confirmed that via its own dialog
+    // before sending this). Pushes the move onto the tab's undo stack and clears its redo stack —
+    // mirroring the editor's own "any new edit invalidates the redo stack" rule. Rebuilds so the
+    // tree reflects the change immediately, without waiting on the directory watcher's own debounce.
+    move(label, fromRelPath, toRelPath) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        if (isSameOrDescendantPath(toRelPath, fromRelPath))
+            return;
+        const fromAbs = path.join(state.root, fromRelPath);
+        const name = path.basename(fromAbs);
+        const toAbs = path.join(state.root, toRelPath, name);
+        try {
+            renameSync(fromAbs, toAbs);
+        }
+        catch {
+            return;
+        }
+        state.undoStack.push({ from: fromRelPath, to: toRelPath ? `${toRelPath}/${name}` : name });
+        state.redoStack = [];
+        this.rebuild(label);
+    }
+    // Undo the most recent move: moves the item back from `to` to `from`'s original directory. A
+    // conflict at the destination is reported back without mutating either stack, so a caller-driven
+    // overwrite (passing `overwrite: true`) can retry the same pending entry. An empty undo stack is
+    // a silent no-op.
+    undo(label, overwrite = false) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return {};
+        const entry = state.undoStack.at(-1);
+        if (!entry)
+            return {};
+        return applyStackMove(state.root, entry.to, parentPath(entry.from), entry, state.undoStack, state.redoStack, overwrite, () => this.rebuild(label));
+    }
+    // Redo the most recently undone move: re-applies it from `from` to `to`'s original directory.
+    // Same conflict-reporting and no-op behavior as `undo`.
+    redo(label, overwrite = false) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return {};
+        const entry = state.redoStack.at(-1);
+        if (!entry)
+            return {};
+        return applyStackMove(state.root, entry.from, parentPath(entry.to), entry, state.redoStack, state.undoStack, overwrite, () => this.rebuild(label));
+    }
+    // Delete a file or directory (recursively) from disk — the client has already confirmed with
+    // the user before sending this. Rebuilds so the tree reflects the removal immediately, without
+    // waiting on the directory watcher's own debounce.
+    delete(label, relPath) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        const abs = path.join(state.root, relPath);
+        try {
+            rmSync(abs, { recursive: true });
+        }
+        catch {
+            return;
+        }
+        this.rebuild(label);
+    }
+    // Tear down one tab's watchers and debounce timer (on tab close).
+    closeTab(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        if (state.debounce)
+            clearTimeout(state.debounce);
+        for (const watcher of state.watchers.values()) {
+            try {
+                watcher.close();
+            }
+            catch { /* already gone */ }
+        }
+        this.tabs.delete(label);
+    }
+    // Tear down every tab's watchers (app shutdown).
+    dispose() {
+        for (const label of this.tabs.keys())
+            this.closeTab(label);
+    }
+    watchDir(label, absDir, relPath) {
+        watchDir(this.tabs, label, absDir, relPath, () => this.scheduleRebuild(label));
+    }
+    unwatchDir(state, relPath) {
+        unwatchDir(state, relPath);
+    }
+    scheduleRebuild(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        if (state.debounce)
+            clearTimeout(state.debounce);
+        state.debounce = setTimeout(() => { this.rebuild(label); this.refreshGit(label); }, DEBOUNCE_MS);
+    }
+    refreshGit(label) {
+        refreshGit(this.tabs, label, (l) => this.rebuild(l));
+    }
+    // Rebuild the visible row list (pruning expanded directories that no longer exist) and write it
+    // onto the tab's payload.
+    rebuild(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        const tab = this.managers.tab.tabs.find((t) => t.label === label);
+        if (!tab?.files)
+            return;
+        tab.files = { root: state.root, absoluteRoot: state.root, rows: pruneAndBuildRows(state), branch: state.branch };
+        messageBus.emit('state', { type: 'dirty' });
+    }
+}

package/dist/file-tree-moves.js

@@ -0,0 +1,26 @@
+import path from 'node:path';
+import { renameSync } from 'node:fs';
+import { hasNameConflict } from './file-tree.js';
+// Shared reverse/re-apply logic for `undo`/`redo`: moves `sourceRel` (relative to `root`) into
+// `destDir`, unless the destination already has a same-named entry and the caller hasn't confirmed
+// an overwrite, in which case it reports the conflict and leaves both stacks untouched. On success
+// it pops `fromStack`, pushes `entry` onto `toStack`, and invokes `rebuild`.
+export function applyStackMove(root, sourceRel, destDir, entry, fromStack, toStack, overwrite, rebuild) {
+    const sourceAbs = path.join(root, sourceRel);
+    const name = path.basename(sourceAbs);
+    const destAbsDir = path.join(root, destDir);
+    const destAbs = path.join(destAbsDir, name);
+    if (!overwrite && sourceAbs !== destAbs && hasNameConflict(destAbsDir, name)) {
+        return { conflict: { fromRelPath: sourceRel, toRelPath: destDir } };
+    }
+    try {
+        renameSync(sourceAbs, destAbs);
+    }
+    catch {
+        return {};
+    }
+    fromStack.pop();
+    toStack.push(entry);
+    rebuild();
+    return {};
+}

package/dist/file-tree-open.js

@@ -0,0 +1,56 @@
+import { statSync } from 'node:fs';
+import { buildRows } from './file-tree.js';
+// Open a file navigator at `label`'s cwd (the metadata-row 📁 button). If a file-tree tab is already
+// open, retarget the most-recently-focused one to that cwd in place — preserving its identity, dock
+// placement, and strip position; otherwise open a fresh tree docked in the left sidebar. Either way,
+// focus stays on the tab whose button was clicked — opening or retargeting the navigator must not
+// steal focus.
+export function openOrRetarget(port, label) {
+    const cwd = port.managers.tab.cwdOf(label) ?? process.cwd();
+    let stat;
+    try {
+        stat = statSync(cwd);
+    }
+    catch {
+        stat = undefined;
+    }
+    if (!stat?.isDirectory())
+        return;
+    const existing = port.managers.tab.mostRecentFileTreeLabel();
+    if (existing)
+        retarget(port, existing, cwd);
+    else
+        openFresh(port, cwd);
+    port.managers.tab.setActiveTab(port.managers.tab.findIndex(label));
+}
+// Open a fresh tree rooted at `root`, docked left by default (unlike the bare `files` command's
+// center-strip default). Mirrors `FileTreeManager.open()`'s create-and-watch sequence.
+function openFresh(port, root) {
+    const expanded = new Set();
+    port.managers.tab.openFilesTab({ root, absoluteRoot: root, rows: buildRows(root, expanded) });
+    const newLabel = port.managers.tab.cur().label;
+    port.managers.tab.setCwd(newLabel, root);
+    port.states.set(newLabel, { root, expanded, watchers: new Map(), undoStack: [], redoStack: [] });
+    port.watchDir(newLabel, root, '');
+    port.managers.tab.setDock(port.managers.tab.findIndex(newLabel), 'left');
+}
+// Retarget an existing file-tree tab's root to an arbitrary absolute directory in place. Reuses
+// `reroot()`'s clear-expanded/unwatch/rewatch/rebuild sequence, but — unlike `reroot()` — also
+// clears the undo/redo stacks, since jumping to an unrelated directory leaves their relative paths
+// meaningless at the new root.
+function retarget(port, label, root) {
+    const state = port.states.get(label);
+    if (!state || root === state.root)
+        return;
+    for (const relPath of state.expanded)
+        port.unwatchDir(state, relPath);
+    state.expanded.clear();
+    port.unwatchDir(state, '');
+    state.root = root;
+    state.undoStack = [];
+    state.redoStack = [];
+    port.watchDir(label, root, '');
+    if (port.managers.tab.tabs.some((t) => t.label === label))
+        port.managers.tab.setCwd(label, root);
+    port.rebuild(label);
+}

package/dist/file-tree-rebuild.js

@@ -0,0 +1,22 @@
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { buildRows, markChanged } from './file-tree.js';
+import { unwatchDir } from './file-tree-watch.js';
+// Prunes expanded directories that no longer exist on disk (closing their watchers) and returns
+// the current visible row list for `state.root`, with git-changed paths marked.
+export function pruneAndBuildRows(state) {
+    for (const relPath of state.expanded) {
+        let stillDir;
+        try {
+            stillDir = statSync(path.join(state.root, relPath)).isDirectory();
+        }
+        catch {
+            stillDir = false;
+        }
+        if (!stillDir) {
+            state.expanded.delete(relPath);
+            unwatchDir(state, relPath);
+        }
+    }
+    return markChanged(buildRows(state.root, state.expanded), state.changed ?? new Set());
+}

package/dist/file-tree-watch.js

@@ -0,0 +1,27 @@
+import { watch } from 'node:fs';
+// Starts a non-recursive `fs.watch` on `absDir` (keyed by `relPath` in `label`'s watcher map),
+// invoking `onChange` on every event. A no-op if the tab is unknown or already watching that path.
+// Exotic filesystems, fd limits, and races are swallowed — the tree still works, just refreshes on
+// toggle instead of live.
+export function watchDir(states, label, absDir, relPath, onChange) {
+    const state = states.get(label);
+    if (!state || state.watchers.has(relPath))
+        return;
+    try {
+        state.watchers.set(relPath, watch(absDir, onChange));
+    }
+    catch {
+        // Exotic filesystems, fd limits, races — the tree still works, just refreshes on toggle.
+    }
+}
+// Stops and forgets the watcher at `relPath`, if any.
+export function unwatchDir(state, relPath) {
+    const watcher = state.watchers.get(relPath);
+    if (!watcher)
+        return;
+    try {
+        watcher.close();
+    }
+    catch { /* already gone */ }
+    state.watchers.delete(relPath);
+}

package/dist/file-tree.js

@@ -0,0 +1,82 @@
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+// VS Code's `files.exclude` defaults. Other dotfiles are shown.
+const EXCLUDES = new Set(['.git', '.svn', '.hg', '.DS_Store', 'Thumbs.db']);
+// One directory's sorted, filtered entries: directories first, then files, `localeCompare`
+// case-insensitive within each group. A symlink (file or directory) reports as a file — never
+// expandable — which is the cheap way to stay cycle-proof. An unreadable directory (permission
+// denied, deleted mid-read) yields [].
+export function readDirSorted(absDir) {
+    let dirents;
+    try {
+        dirents = readdirSync(absDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const entries = dirents
+        .filter((d) => !EXCLUDES.has(d.name))
+        .map((d) => ({ name: d.name, dir: d.isDirectory() }));
+    return entries.toSorted((a, b) => {
+        if (a.dir !== b.dir)
+            return a.dir ? -1 : 1;
+        return a.name.localeCompare(b.name, undefined, { sensitivity: 'base' });
+    });
+}
+// A depth-first, pre-flattened list of the currently *visible* rows: the root's direct children,
+// plus — for each directory whose path is in `expanded` — that directory's children too, and so
+// on. Children are read from disk only for expanded directories. An `expanded` entry for a path
+// that no longer exists (or isn't found under its parent) is simply never reached, so it's
+// naturally skipped rather than needing special-case pruning here.
+export function buildRows(root, expanded) {
+    const rows = [];
+    const walk = (absDir, relDir, depth) => {
+        for (const entry of readDirSorted(absDir)) {
+            const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+            const isExpanded = entry.dir && expanded.has(relPath);
+            rows.push({
+                path: relPath, name: entry.name, depth, dir: entry.dir,
+                ...(entry.dir && { expanded: isExpanded }),
+            });
+            if (isExpanded)
+                walk(path.join(absDir, entry.name), relPath, depth + 1);
+        }
+    };
+    walk(root, '', 0);
+    if (path.dirname(root) !== root) {
+        rows.unshift({ path: '..', name: '..', depth: 0, dir: true });
+    }
+    return rows;
+}
+// Return `rows` with a `changed` flag set on every row git considers changed: a file row when its
+// own `path` is in `changed`; a directory row when any changed path is nested beneath it (a prefix
+// check, `changedPath` starts with `${row.path}/`). Propagation is purely this flat-set prefix
+// scan — no directory is re-read, so a collapsed directory still colors when something deep inside
+// it changed. Rows with no match are returned as-is; an empty `changed` set marks nothing.
+export function markChanged(rows, changed) {
+    if (changed.size === 0)
+        return rows;
+    return rows.map((row) => {
+        const isChanged = row.dir
+            ? [...changed].some((p) => p.startsWith(`${row.path}/`))
+            : changed.has(row.path);
+        return isChanged ? { ...row, changed: true } : row;
+    });
+}
+// The containing directory of a tree-relative path — the empty string for a root-level entry,
+// matching the root-as-empty-string convention `buildRows` already uses.
+export function parentPath(relPath) {
+    const idx = relPath.lastIndexOf('/');
+    return idx === -1 ? '' : relPath.slice(0, idx);
+}
+// True if `candidate` is `base` itself, or is nested inside it — the check that blocks dropping a
+// dragged item onto itself or one of its own descendants (moving a directory into its own child).
+export function isSameOrDescendantPath(candidate, base) {
+    return candidate === base || candidate.startsWith(`${base}/`);
+}
+// True if the directory at `absDestDir` already has a child named `name` — used to detect a
+// same-name conflict at the drop target. Re-reads the destination directory fresh from disk
+// rather than trusting the client's row list, which can be briefly stale.
+export function hasNameConflict(absDestDir, name) {
+    return readDirSorted(absDestDir).some((e) => e.name === name);
+}