Skip to content

The OSINT investigator's workbench. One case, one folder, every tool. Local-first: your media and your investigations never leave your machine.

JavaScript
35.0 KB
Raw Blame
<script>
  import { untrack } from 'svelte';
  import { api } from '../lib/api.js';
  import {
    caseState,
    uiState,
    reloadCase,
    toast,
    setSidebarWidth,
    persistSidebarWidth,
  } from '../lib/state.svelte.js';
  import { DEFAULT_W, saveSidebarView } from '../lib/sidebar.js';
  import { buildTree, flattenPaths } from '../lib/folderTree.js';
  import { buildCatalogQuery, settleCatalogSummary } from '../lib/catalog.js';
  import { createPagedList } from '../lib/pagedList.svelte.js';
  import { filterEntities, isFiltering, typeChips } from '../lib/sidebarSearch.js';
  import { assignFolder as fileEntity, assignFolderBatch, renameEntity } from '../lib/filing.js';
  import { createNote } from '../lib/notes.js';
  import { openEntity, openInTimeline, openNotebook } from '../lib/navigate.js';
  import {
    ancestorsOf,
    leafOf,
    removeFolder,
    removeFolderPrompt,
    renameFolder,
    renamedPath,
    setWorkFolder,
  } from '../lib/folders.js';
  import { emptyTrash, purgeGroup, readTrash, restoreGroup, undoAction } from '../lib/trash.js';
  import Icon from './Icon.svelte';
  import Modal from './Modal.svelte';
  import ConfirmDialog from './ConfirmDialog.svelte';
  import FolderSelect from './FolderSelect.svelte';
  import SidebarHeader from './sidebar/SidebarHeader.svelte';
  import SidebarTree from './sidebar/SidebarTree.svelte';
  import SidebarResults from './sidebar/SidebarResults.svelte';
  import DetailsDrawer from './sidebar/DetailsDrawer.svelte';
  import CaseTodos from '../tools/overview/CaseTodos.svelte';

  // ── bounded catalog loading (docs/STORAGE_AND_PERFORMANCE.md, Step 5) ───────
  // The sidebar no longer holds the whole graph. It builds the folder tree from
  // the (small) folder list plus the summary's folder keys, takes its badge
  // counts from the summary, and loads entities a page at a time per section:
  // Suggestions, Unfiled, and each folder on expand. `seq` guards a stale
  // response from landing after the case or a mutation moved on.
  const CATALOG_PAGE = 200;
  const emptySection = () => ({ items: [], cursor: null, done: false, loading: false, loaded: false });

  let summary = $state(null); // { total, by_type, by_status, by_folder }
  let suggestedData = $state(emptySection());
  let unfiledData = $state(emptySection());
  let folderData = $state({}); // path -> section
  let seq = 0;
  let loadedCaseId = null;

  const byFolder = $derived(summary?.by_folder ?? {});
  // A folder opens on its accepted rows, so it counts those; a suggestion filed in it
  // is counted under Suggestions.
  const filedByFolder = $derived(summary?.confirmed?.by_folder ?? {});
  const suggestedCount = $derived(summary?.by_status?.suggested ?? 0);

  async function loadSection(sec, params, { id, mySeq, more = false } = {}) {
    id ??= caseState.current?.id;
    mySeq ??= seq;
    if (!id) return;
    if (more && (sec.loading || sec.done)) return; // don't stack a "show more"
    sec.loading = true;
    try {
      const page = await api.get(
        buildCatalogQuery(id, { ...params, limit: CATALOG_PAGE, cursor: more ? sec.cursor : null })
      );
      if (mySeq !== seq) return; // a case switch or reload superseded us
      sec.items = more ? [...sec.items, ...(page.items ?? [])] : page.items ?? [];
      sec.cursor = page.next_cursor ?? null;
      sec.done = !sec.cursor;
      sec.loaded = true;
      sec.loading = false;
    } catch (e) {
      if (mySeq !== seq) return;
      sec.loading = false;
      toast(e.message, 'danger');
    }
  }

  const loadSuggested = (more = false) => loadSection(suggestedData, { status: 'suggested' }, { more });
  const loadUnfiled = (more = false) =>
    loadSection(unfiledData, { status: 'confirmed', unfiled: true }, { more });
  function loadFolder(path, more = false) {
    if (!folderData[path]) folderData[path] = emptySection();
    return loadSection(folderData[path], { status: 'confirmed', folder: path }, { more });
  }

  // ── the trash node ────────────────────────────────────────────────────────
  // Head rows only: the recipe to undo a delete never leaves the backend, so
  // this stays one indexed query however much is waiting in there.
  const emptyTrashState = () => ({ groups: [], items: 0, size_bytes: 0 });
  let trashData = $state(emptyTrashState());
  let trashOpen = $state(false);

  async function loadTrash(id, mySeq) {
    try {
      const listed = await readTrash(id);
      if (mySeq === seq) trashData = listed;
    } catch {
      if (mySeq === seq) trashData = emptyTrashState();
    }
  }

  async function restoreTrashGroup(group) {
    try {
      await restoreGroup(caseState.current.id, group.id);
      toast(`Restored “${group.label}”`, 'ok', 2200);
    } catch (e) {
      toast(e.message, 'danger');
    }
  }

  function askPurge(group) {
    confirmState = {
      title: 'Delete permanently?',
      message: `“${group.label}” will be gone for good.`,
      detail: 'The files will be deleted from disk.',
      confirmLabel: 'Delete permanently',
      tone: 'danger',
      icon: 'trash',
      action: async () => {
        await purgeGroup(caseState.current.id, group.id);
        await reloadCase();
      },
    };
  }

  function askEmptyTrash() {
    const noun = trashData.items === 1 ? 'item' : 'items';
    confirmState = {
      title: 'Empty the trash?',
      message: `${trashData.items} ${noun} will be gone for good.`,
      detail: 'The files will be deleted from disk.',
      confirmLabel: 'Empty the trash',
      tone: 'danger',
      icon: 'trash',
      action: async () => {
        await emptyTrash(caseState.current.id);
        await reloadCase();
      },
    };
  }

  async function loadSummary(id, mySeq) {
    try {
      const s = await api.get(`/api/cases/${id}/catalog/summary`);
      summary = settleCatalogSummary(summary, s, mySeq === seq);
    } catch {
      summary = settleCatalogSummary(summary, null, mySeq === seq);
      /* counts are a nicety; an empty summary just shows zeroes */
    }
  }

  // Reload the summary and every open section. Runs on case change (full reset
  // first) and on every reloadCase() (caseState.rev), so a mutation anywhere is
  // reflected without re-reading the whole graph.
  function refreshAll(id) {
    seq++;
    if (id !== loadedCaseId) {
      loadedCaseId = id;
      summary = null;
      expanded = {};
      folderData = {};
      unfiledOpen = false;
      suggestedOpen = false;
      infoEntity = null;
      query = '';
      typeFilter = null;
      suggestedData = emptySection();
      unfiledData = emptySection();
      trashData = emptyTrashState();
      trashOpen = false;
    }
    if (!id) {
      summary = null;
      return;
    }
    loadSummary(id, seq);
    loadTrash(id, seq);
    loadSuggested();
    loadUnfiled();
    for (const path of Object.keys(expanded)) if (expanded[path]) loadFolder(path);
  }

  $effect(() => {
    const id = caseState.current?.id;
    caseState.rev; // re-run on every reload (a mutation elsewhere or our own)
    untrack(() => refreshAll(id));
  });

  // ── search: one rule, browse or results (lib/sidebarSearch.js) ─────────────
  // No filter shows the tree; a text query or a type chip shows a flat list.
  // The list is only fetched once something is actually filtered — opening a
  // case still costs the same bounded pages it did before.
  let query = $state('');
  let typeFilter = $state(null);
  const filtering = $derived(isFiltering({ query, type: typeFilter }));
  const chips = $derived(typeChips(summary));

  const results = createPagedList({
    fetchPage: ({ query: q, cursor }) =>
      api.get(
        buildCatalogQuery(caseState.current?.id, {
          query: q,
          types: typeFilter ? [typeFilter] : null,
          limit: CATALOG_PAGE,
          cursor,
        })
      ),
  });
  // In client mode the fetched page is the whole case, so the term filters in
  // memory; in server mode the request already carries it.
  const resultRows = $derived(
    results.serverMode ? results.items : filterEntities(results.items, { query, type: typeFilter })
  );

  let resultsKey = null; // non-reactive: only the load effect reads/writes it
  $effect(() => {
    const id = caseState.current?.id;
    const rev = caseState.rev; // a filing elsewhere changes a row's folder meta
    const key = filtering && id ? `${id}|${typeFilter ?? ''}|${rev}` : null;
    if (key === resultsKey) return;
    resultsKey = key;
    if (!key) results.clear();
    else results.reload();
  });
  $effect(() => {
    results.setQuery(query);
  });

  async function confirmEntity(entity) {
    await api.patch(`/api/cases/${caseState.current.id}/entities/${entity.id}`, {
      status: 'confirmed',
    });
    await reloadCase();
  }

  // Dismiss a suggestion outright (quick triage — no heavy confirmation).
  // It goes through the same delete as everything else, so a dismissal that
  // turns out to have been a good lead comes back from the toast.
  async function dismissSuggestion(entity) {
    const caseId = caseState.current.id;
    const result = await api.del(`/api/cases/${caseId}/entities/${entity.id}`);
    await reloadCase();
    toast(`Dismissed “${entity.label}”`, 'info', 7000, undoAction(caseId, result));
  }

  // Clicking a row opens its owning workspace; notes share the Notebook.
  // openEntity / gotoCapture live in lib/navigate.js — the case sidebar and the
  // Details editor send an analyst to the same place.
  function onEntityActivate(entity) {
    if (entity.type === 'capture') return openInfo(entity);
    openEntity(entity);
  }

  // ── Folders: the analyst's own nested folder tree ('/'-separated paths) ────
  let newFolderOpen = $state(false);
  let newFolder = $state('');
  let expanded = $state({}); // path -> bool (absent = collapsed)

  const caseFolders = $derived(caseState.current?.folders ?? []);

  // Structure only: the tree is built from folders plus any folder a summary
  // count refers to (an entity filed into a path that was never an explicit
  // folder still gets a node), with no entities attached — those load per node.
  const tree = $derived(buildTree([...new Set([...caseFolders, ...Object.keys(byFolder)])], []));
  const allFolders = $derived(flattenPaths(tree));
  let unfiledOpen = $state(false);
  let suggestedOpen = $state(false);

  function toggle(path) {
    expanded[path] = expanded[path] !== true;
    if (expanded[path]) loadFolder(path);
  }
  function focusInput(node) { node.focus(); }

  async function createFolder(name) {
    const clean = (name ?? '').trim();
    if (!clean) return;
    try {
      await api.post(`/api/cases/${caseState.current.id}/folders`, { name: clean });
      let acc = '';
      for (const seg of clean.split('/')) { acc = acc ? `${acc}/${seg}` : seg; expanded[acc] = true; }
      await reloadCase();
    } catch (e) {
      toast(e.message, 'danger');
    }
  }

  function submitNewFolder() {
    const name = newFolder;
    newFolder = '';
    newFolderOpen = false;
    createFolder(name);
  }

  // File (or unfile, with folder='') an entity into a My-work folder, then
  // refresh. Routing lives in lib/filing.js so the desktop organizer files
  // items the same way.
  async function assignFolder(entity, folder) {
    await fileEntity(caseState.current.id, entity, folder);
    await reloadCase();
  }

  // A drop carries whatever was selected — one row, or a ctrl/shift-picked run.
  // Filed in order, then one refresh for the batch.
  async function onFileDrop(entities, folder) {
    try {
      await assignFolderBatch(caseState.current.id, entities, folder);
      await reloadCase();
      if (entities.length > 1)
        toast(folder ? `Filed ${entities.length} items in ${folder}` : `Unfiled ${entities.length} items`, 'ok', 1600);
    } catch (e) {
      toast(e.message, 'danger');
    }
  }

  // A file dragged in from the Media library. Its card only changes a badge,
  // so the toast says where it went.
  async function onFileMedia(entities, folder) {
    const moving = entities.filter((e) => (e.attrs.folder ?? '') !== folder);
    if (!moving.length) {
      toast(folder ? `Already in ${folder}` : 'Already unfiled', 'ok', 1600);
      return;
    }
    try {
      await assignFolderBatch(caseState.current.id, moving, folder);
      await reloadCase();
      toast(folder ? `Filed in ${folder}` : 'Unfiled', 'ok', 1600);
    } catch (e) {
      toast(e.message, 'danger');
    }
  }

  // ── scrolling while a drag is in flight ───────────────────────────────────
  // A native drag swallows the wheel in Chromium, so the tree scrolls itself
  // when the pointer nears an edge. Firefox does deliver the wheel, and the
  // handler below uses it when it arrives.
  let bodyEl = $state(null);
  let dragActive = $state(false);
  const EDGE = 44;
  const EDGE_SPEED = 12;
  let edgeDir = 0;
  let edgeRaf = 0;

  function stepEdgeScroll() {
    if (!edgeDir || !bodyEl) { edgeRaf = 0; return; }
    bodyEl.scrollTop += edgeDir * EDGE_SPEED;
    edgeRaf = requestAnimationFrame(stepEdgeScroll);
  }
  function setEdgeScroll(dir) {
    edgeDir = dir;
    if (dir && !edgeRaf) edgeRaf = requestAnimationFrame(stepEdgeScroll);
  }
  function onBodyDragOver(ev) {
    if (!bodyEl) return;
    const box = bodyEl.getBoundingClientRect();
    if (ev.clientY < box.top + EDGE) setEdgeScroll(-1);
    else if (ev.clientY > box.bottom - EDGE) setEdgeScroll(1);
    else setEdgeScroll(0);
  }
  function onBodyWheel(ev) {
    if (!dragActive || !bodyEl) return; // otherwise the browser scrolls it itself
    ev.preventDefault();
    bodyEl.scrollTop += ev.deltaY;
  }
  function onDragActive(active) {
    dragActive = active;
    if (!active) setEdgeScroll(0);
  }

  // ── confirmation dialog (replaces browser confirm()) ──────────────────────
  let confirmState = $state(null); // { title, message, detail, confirmLabel, tone, icon, action }
  let confirmBusy = $state(false);

  async function runConfirm() {
    const s = confirmState;
    if (!s) return;
    confirmBusy = true;
    try {
      await s.action();
    } catch (e) {
      toast(e.message, 'danger');
    } finally {
      confirmBusy = false;
      confirmState = null;
    }
  }

  // Move to Unfiled: just clears the filing. The item stays in its tool.
  function askRemoveFromMyWork(entity) {
    confirmState = {
      title: 'Move to Unfiled?',
      message: `“${entity.label}” leaves its folder. Nothing is deleted.`,
      confirmLabel: 'Move to Unfiled',
      tone: 'default',
      icon: 'folderMinus',
      action: () => assignFolder(entity, ''),
    };
  }

  function askDeleteFolder(path) {
    confirmState = {
      ...removeFolderPrompt(path, allFolders),
      // The backend unfiles every entity under the removed subtree, so this
      // does not enumerate the graph — it just drops the folder and refreshes.
      action: () => removeFolder(caseState.current.id, path),
    };
  }

  // ── the work folder ───────────────────────────────────────────────────────
  // Pinned above the tree, so the folder new files land in is always in view, and
  // one press away from being opened.
  const working = $derived(caseState.current?.work_folder ?? null);
  async function toggleWorkFolder(path) {
    try {
      await setWorkFolder(caseState.current.id, working === path ? null : path);
    } catch (e) {
      toast(e.message, 'danger');
    }
  }
  function revealWorkFolder() {
    if (!working) return;
    for (const path of ancestorsOf(working)) {
      if (!expanded[path]) {
        expanded[path] = true;
        loadFolder(path);
      }
    }
  }

  // ── views: folders, to-do, recent ─────────────────────────────────────────
  const view = $derived(uiState.sidebarView);
  function setView(next) {
    uiState.sidebarView = next;
    saveSidebarView(next);
  }
  // What was filed last, read only while the view is open, and again after any
  // write so a save in another tool shows up here.
  const RECENT = 40;
  let recent = $state({ items: [], loading: false });
  $effect(() => {
    const id = caseState.current?.id;
    void caseState.rev;
    if (view !== 'recent' || !id) return;
    untrack(() => loadRecent(id));
  });
  async function loadRecent(id) {
    recent.loading = true;
    try {
      const page = await api.get(buildCatalogQuery(id, { status: 'confirmed', limit: RECENT, order: '-created' }));
      if (caseState.current?.id === id) recent.items = page.items ?? [];
    } catch {
      if (caseState.current?.id === id) recent.items = [];
    } finally {
      recent.loading = false;
    }
  }

  // ── right-click ───────────────────────────────────────────────────────────
  // A short menu on a folder or an item: what the row's hover buttons do, plus
  // renaming, which needs a field the row has no room for. The field opens in
  // the menu itself.
  // menu: { x, y, kind: 'folder', path, mode } | { x, y, kind: 'entity', entity, mode }
  // mode: 'menu' | 'rename' | 'subfolder'
  let menu = $state(null);
  let menuText = $state('');
  const MENU_W = 220;
  const MENU_H = 280;
  function placeMenu(ev) {
    return {
      x: Math.min(ev.clientX, window.innerWidth - MENU_W - 8),
      y: Math.min(ev.clientY, Math.max(8, window.innerHeight - MENU_H - 8)),
    };
  }
  function openFolderMenu(ev, path) {
    menu = { ...placeMenu(ev), kind: 'folder', path, mode: 'menu' };
  }
  function openEntityMenu(ev, entity) {
    menu = { ...placeMenu(ev), kind: 'entity', entity, mode: 'menu' };
  }
  function menuField(mode) {
    menuText = mode === 'rename' ? (menu.kind === 'folder' ? leafOf(menu.path) : menu.entity.label) : '';
    menu = { ...menu, mode };
  }
  function menuRun(fn) {
    const held = menu;
    menu = null;
    fn(held);
  }
  async function submitMenuField() {
    const held = menu;
    const text = menuText.trim();
    menu = null;
    if (!held || !text) return;
    const caseId = caseState.current.id;
    try {
      if (held.mode === 'subfolder') {
        await createFolder(`${held.path}/${text}`);
      } else if (held.kind === 'folder') {
        if (text.includes('/')) {
          toast('A folder name cannot hold a slash', 'warn');
          return;
        }
        const target = renamedPath(held.path, text);
        if (target) await renameFolder(caseId, held.path, target);
      } else if (text !== held.entity.label) {
        await renameEntity(caseId, held.entity, text);
        await reloadCase();
      }
    } catch (e) {
      toast(e.message, 'danger');
    }
  }
  function focusSelect(node) {
    node.focus();
    node.select();
  }

  // ── details drawer (docs/UI.md §Case sidebar) ─────────────────────────────
  // The editor body lives in EntityDetails.svelte (shared with the Media
  // Library modal). It opens over the sidebar instead of growing under the
  // tree, so selecting a row never pushes the case out of the viewport.
  let infoEntity = $state(null);
  let returnFocusEl = null;

  function openInfo(entity) {
    returnFocusEl = document.activeElement;
    infoEntity = entity;
  }

  function closeInfo() {
    infoEntity = null;
    returnFocusEl?.focus?.();
    returnFocusEl = null;
  }

  // ── note entities ─────────────────────────────────────────────────────────
  let noteModal = $state(null); // { title, folder }
  let noteModalSaving = $state(false);

  async function saveNote() {
    if (!noteModal) return;
    const { title, folder } = noteModal;
    if (!title.trim()) { toast('Title required', 'warn'); return; }
    noteModalSaving = true;
    try {
      const note = await createNote(caseState.current.id, { title, folder });
      await reloadCase();
      noteModal = null;
      openNotebook(note.id);
    } catch (e) {
      toast(e.message, 'danger');
    } finally {
      noteModalSaving = false;
    }
  }

  // --- resize: the sidebar's left edge is a drag handle ---
  let resizing = $state(false);
  const KEY_STEP = 16;

  function startResize(e) {
    if (e.button !== 0) return;
    e.preventDefault(); // don't start a text selection under the cursor
    const startX = e.clientX;
    const startW = uiState.sidebarW;
    resizing = true;
    // dragging left (a smaller clientX) widens the sidebar — it grows into the canvas
    const move = (ev) => setSidebarWidth(startW + startX - ev.clientX);
    const up = () => {
      resizing = false;
      persistSidebarWidth(); // one write per drag, not one per frame
      window.removeEventListener('pointermove', move);
      window.removeEventListener('pointerup', up);
    };
    window.addEventListener('pointermove', move);
    window.addEventListener('pointerup', up);
  }

  function onResizeKey(e) {
    const step = { ArrowLeft: KEY_STEP, ArrowRight: -KEY_STEP }[e.key];
    if (step === undefined) return;
    e.preventDefault();
    setSidebarWidth(uiState.sidebarW + step);
    persistSidebarWidth();
  }

  function resetWidth() {
    setSidebarWidth(DEFAULT_W);
    persistSidebarWidth();
  }

  // A width dragged out on a wide screen would eat a narrower window whole, so
  // re-clamp against the viewport as it changes. The clamped-down value is not
  // written back — what the user actually chose is what a later session restores.
  $effect(() => {
    const onWindowResize = () => setSidebarWidth(uiState.sidebarW);
    window.addEventListener('resize', onWindowResize);
    return () => {
      window.removeEventListener('resize', onWindowResize);
      cancelAnimationFrame(edgeRaf);
    };
  });
</script>

<aside class="sidebar" data-guide="start.sidebar" class:resizing style="width: {uiState.sidebarW}px">
  <!-- a <button> rather than a bare div: the handle must be focusable and
       keyboard-driven (arrows resize), and the element carries that for free -->
  <button
    type="button"
    class="resizer"
    aria-label="Resize sidebar"
    title="Drag to resize · double-click to reset"
    onpointerdown={startResize}
    ondblclick={resetWidth}
    onkeydown={onResizeKey}
  ></button>

  {#if !caseState.current}
    <div class="empty">
      <div class="empty-icon"><Icon name="folder" size={34} /></div>
      <h3>No case open</h3>
      <p>Tools work without one. Create a case to keep the investigation together.</p>
    </div>
  {:else}
    <SidebarHeader
      caseName={caseState.current.name}
      caseId={caseState.current.id}
      bind:query
      type={typeFilter}
      {chips}
      total={summary?.total ?? 0}
      resultCount={filtering ? resultRows.length : null}
      {view}
      onnotes={() => openNotebook()}
      onselecttype={(t) => (typeFilter = t)}
      onview={setView}
    />

    <!-- the drag handlers here only auto-scroll; the drop targets are the
         folder rows inside, which carry their own roles -->
    <!-- svelte-ignore a11y_no_static_element_interactions -->
    <div
      class="body"
      bind:this={bodyEl}
      ondragover={onBodyDragOver}
      ondragleave={() => setEdgeScroll(0)}
      ondrop={() => setEdgeScroll(0)}
      onwheel={onBodyWheel}
    >
      {#if view === 'todo'}
        <div class="todo-view">
          <CaseTodos caseId={caseState.current.id} compact />
        </div>
      {:else if view === 'recent'}
        <SidebarResults
          rows={recent.items}
          caseId={caseState.current.id}
          loading={recent.loading}
          empty="Nothing filed yet."
          onactivate={onEntityActivate}
          oninfo={openInfo}
          onunfile={askRemoveFromMyWork}
          onmenu={openEntityMenu}
        />
      {:else if filtering}
        <SidebarResults
          rows={resultRows}
          caseId={caseState.current.id}
          loading={results.loading}
          hasMore={results.serverMode && results.hasMore}
          onmore={() => results.loadMore()}
          onactivate={onEntityActivate}
          oninfo={openInfo}
          onunfile={askRemoveFromMyWork}
          onmenu={openEntityMenu}
        />
      {:else}
        {#if working}
          <div class="work-line">
            <Icon name="pushpin" size={13} />
            <button
              class="work-name"
              title="Show the folder new work lands in"
              onclick={revealWorkFolder}
            >
              {working}
            </button>
            <button
              class="work-stop"
              title="Stop working in this folder"
              aria-label="Stop working in this folder"
              onclick={() => toggleWorkFolder(working)}
            >
              <Icon name="x" size={12} />
            </button>
          </div>
        {/if}
        <div class="actions">
          <button class="act-btn" onclick={() => (newFolderOpen = !newFolderOpen)}>
            <Icon name="plus" size={12} /><Icon name="folder" size={13} /><span>Folder</span>
          </button>
          <button class="act-btn" onclick={() => (noteModal = { title: '', folder: '' })}>
            <Icon name="plus" size={12} /><Icon name="note" size={13} /><span>Note</span>
          </button>
        </div>
        {#if newFolderOpen}
          <form class="new-folder" onsubmit={(e) => { e.preventDefault(); submitNewFolder(); }}>
            <input
              class="input"
              placeholder="New folder…"
              bind:value={newFolder}
              use:focusInput
              onkeydown={(e) => e.key === 'Escape' && (newFolderOpen = false)}
            />
            <button class="btn btn-sm" type="submit" title="Create folder" disabled={!newFolder.trim()}>
              <Icon name="plus" size={13} />
            </button>
          </form>
        {/if}

        <SidebarTree
          {tree}
          byFolder={filedByFolder}
          {expanded}
          {folderData}
          unfiled={unfiledData}
          {unfiledOpen}
          suggested={suggestedData}
          {suggestedCount}
          {suggestedOpen}
          caseId={caseState.current.id}
          ontoggle={toggle}
          onmorefolder={(path) => loadFolder(path, true)}
          ontoggleunfiled={() => (unfiledOpen = !unfiledOpen)}
          onmoreunfiled={() => loadUnfiled(true)}
          ontogglesuggested={() => (suggestedOpen = !suggestedOpen)}
          onmoresuggested={() => loadSuggested(true)}
          oncreatefolder={createFolder}
          onremovefolder={askDeleteFolder}
          workFolder={working}
          onworkfolder={toggleWorkFolder}
          onfoldermenu={openFolderMenu}
          onentitymenu={openEntityMenu}
          onfile={onFileDrop}
          onfilemedia={onFileMedia}
          onactivate={onEntityActivate}
          oninfo={openInfo}
          onunfile={askRemoveFromMyWork}
          onconfirm={confirmEntity}
          ondismiss={dismissSuggestion}
          ondragactive={onDragActive}
          trash={trashData}
          {trashOpen}
          ontoggletrash={() => (trashOpen = !trashOpen)}
          onrestore={restoreTrashGroup}
          onpurge={askPurge}
          onempty={askEmptyTrash}
        />
      {/if}
    </div>

    {#if infoEntity}
      <DetailsDrawer entity={infoEntity} onclose={closeInfo} ondeleted={closeInfo} />
    {/if}
  {/if}
</aside>

<!-- right-click menu on a folder or an item -->
{#if menu}
  <div
    class="menu-backdrop"
    role="presentation"
    onpointerdown={() => (menu = null)}
    oncontextmenu={(e) => { e.preventDefault(); menu = null; }}
  ></div>
  <div
    class="menu card"
    role="menu"
    tabindex="-1"
    style="left:{menu.x}px; top:{menu.y}px"
    onkeydown={(e) => e.key === 'Escape' && (menu = null)}
  >
    <div class="menu-head">{menu.kind === 'folder' ? leafOf(menu.path) : menu.entity.label}</div>
    {#if menu.mode !== 'menu'}
      <form class="menu-field" onsubmit={(e) => { e.preventDefault(); submitMenuField(); }}>
        <input
          class="input"
          aria-label={menu.mode === 'subfolder' ? 'Subfolder name' : 'New name'}
          placeholder={menu.mode === 'subfolder' ? 'Subfolder…' : 'Name…'}
          bind:value={menuText}
          use:focusSelect
        />
        <button class="btn btn-primary btn-sm" type="submit" disabled={!menuText.trim()}>
          {menu.mode === 'subfolder' ? 'Create' : 'Rename'}
        </button>
      </form>
    {:else if menu.kind === 'folder'}
      <button class="menu-item" role="menuitem" onclick={() => menuField('rename')}>
        <Icon name="edit" size={13} /> Rename
      </button>
      <button class="menu-item" role="menuitem" onclick={() => menuField('subfolder')}>
        <Icon name="folder" size={13} /> New subfolder
      </button>
      <button class="menu-item" role="menuitem" onclick={() => menuRun((m) => (noteModal = { title: '', folder: m.path }))}>
        <Icon name="note" size={13} /> New note here
      </button>
      <button class="menu-item" role="menuitem" onclick={() => menuRun((m) => toggleWorkFolder(m.path))}>
        <Icon name="pushpin" size={13} /> {working === menu.path ? 'Stop working here' : 'Work in this folder'}
      </button>
      <div class="menu-sep"></div>
      <button class="menu-item danger" role="menuitem" onclick={() => menuRun((m) => askDeleteFolder(m.path))}>
        <Icon name="folderMinus" size={13} /> Remove folder
      </button>
    {:else}
      <button class="menu-item" role="menuitem" onclick={() => menuRun((m) => onEntityActivate(m.entity))}>
        <Icon name="external" size={13} /> Open
      </button>
      <button class="menu-item" role="menuitem" onclick={() => menuRun((m) => openInfo(m.entity))}>
        <Icon name="info" size={13} /> Details
      </button>
      <button class="menu-item" role="menuitem" onclick={() => menuField('rename')}>
        <Icon name="edit" size={13} /> Rename
      </button>
      <button class="menu-item" role="menuitem" onclick={() => menuRun((m) => (uiState.moving = [m.entity]))}>
        <Icon name="move" size={13} /> Move to…
      </button>
      <button class="menu-item" role="menuitem" onclick={() => menuRun((m) => openInTimeline(m.entity))}>
        <Icon name="clock" size={13} /> Show in Timeline
      </button>
      {#if menu.entity.attrs?.folder}
        <div class="menu-sep"></div>
        <button class="menu-item" role="menuitem" onclick={() => menuRun((m) => askRemoveFromMyWork(m.entity))}>
          <Icon name="folderMinus" size={13} /> Move to Unfiled
        </button>
      {/if}
    {/if}
  </div>
{/if}

<!-- Note create modal -->
{#if noteModal}
  <Modal title="New note" onclose={() => (noteModal = null)} width="580px">
    <label class="modal-label" for="note-title">Title</label>
    <input id="note-title" class="input" placeholder="Note title…" bind:value={noteModal.title} />

    <span class="modal-label" style="margin-top:10px">Folder</span>
    <FolderSelect bind:value={noteModal.folder} folders={allFolders} emptyLabel="Unfiled" fresh />

    <div class="modal-row">
      <div style="flex:1"></div>
      <button class="btn" onclick={() => (noteModal = null)}>Cancel</button>
      <button class="btn btn-primary" onclick={saveNote} disabled={noteModalSaving}>
        {noteModalSaving ? 'Creating…' : 'Create'}
      </button>
    </div>
  </Modal>
{/if}

<!-- Confirmation dialog (move to Unfiled / remove folder) -->
{#if confirmState}
  <ConfirmDialog
    title={confirmState.title}
    message={confirmState.message}
    detail={confirmState.detail}
    consequences={confirmState.consequences}
    restorable={confirmState.restorable ?? ''}
    confirmLabel={confirmState.confirmLabel}
    tone={confirmState.tone}
    icon={confirmState.icon}
    busy={confirmBusy}
    onconfirm={runConfirm}
    oncancel={() => (confirmState = null)}
  />
{/if}

<style>
  .sidebar {
    /* width is driven by uiState.sidebarW (inline style) — see lib/sidebar.js */
    position: relative;
    flex-shrink: 0;
    border-left: 1px solid var(--border);
    background: var(--bg-1);
    display: flex;
    flex-direction: column;
    overflow: hidden;
  }
  /* the grab strip sits just inside the left edge, over the sections' padding */
  .resizer {
    position: absolute;
    top: 0;
    left: 0;
    width: 5px;
    height: 100%;
    z-index: 2;
    cursor: col-resize;
    background: transparent;
    transition: background 0.12s;
  }
  .resizer:hover,
  .resizer:focus-visible,
  .sidebar.resizing .resizer {
    background: var(--accent);
    outline: none;
  }
  /* a drag reads as one gesture — no text selection, no cursor flicker on hover
     targets the pointer crosses on the way */
  .sidebar.resizing {
    user-select: none;
  }
  /* one scroll region: the header stays put, the drawer covers this */
  .body { flex: 1; min-height: 0; overflow-y: auto; padding: 6px 4px; }
  .actions { display: flex; gap: 4px; padding: 2px 8px 6px; }
  .act-btn {
    display: flex;
    align-items: center;
    gap: 3px;
    padding: 3px 8px;
    border-radius: var(--r-sm);
    color: var(--text-3);
    font-size: var(--fs-xs);
    font-weight: 600;
    cursor: pointer;
  }
  .act-btn:hover { color: var(--text-1); background: var(--bg-2); }
  .new-folder { display: flex; gap: 6px; padding: 2px 8px 8px; }
  .new-folder .input { flex: 1; font-size: var(--fs-xs); }
  .modal-label { display: block; font-size: var(--fs-xs); color: var(--text-3); margin: 8px 0 4px; }
  .todo-view { padding: 4px 8px 12px; }
  .work-line {
    display: flex;
    align-items: center;
    gap: 6px;
    margin: 0 8px 6px;
    padding: 5px 8px;
    border: 1px solid var(--accent);
    border-radius: var(--r-sm);
    background: var(--accent-soft);
    color: var(--accent);
    font-size: var(--fs-xs);
  }
  .work-name {
    flex: 1;
    min-width: 0;
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
    color: var(--text-1);
    font-weight: 600;
    text-align: left;
  }
  .work-stop { display: flex; color: var(--text-3); padding: 2px; border-radius: 4px; }
  .work-stop:hover { color: var(--text-1); }
  .menu-backdrop { position: fixed; inset: 0; z-index: 940; }
  .menu {
    position: fixed;
    z-index: 950;
    width: 220px;
    padding: 6px;
    box-shadow: var(--shadow-2);
  }
  .menu-head {
    margin: 2px 4px 6px;
    color: var(--text-3);
    font-size: var(--fs-xs);
    overflow: hidden;
    text-overflow: ellipsis;
    white-space: nowrap;
  }
  .menu-item {
    display: flex;
    align-items: center;
    gap: 8px;
    width: 100%;
    padding: 6px 8px;
    border-radius: var(--r-sm);
    color: var(--text-1);
    font-size: var(--fs-sm);
    text-align: left;
  }
  .menu-item:hover { background: var(--bg-2); }
  .menu-item > :global(svg) { color: var(--text-3); flex-shrink: 0; }
  .menu-item.danger { color: var(--danger, #e5484d); }
  .menu-item.danger > :global(svg) { color: inherit; }
  .menu-sep { height: 1px; margin: 5px 2px; background: var(--border); }
  .menu-field { display: flex; gap: 6px; }
  .menu-field .input { flex: 1; min-width: 0; font-size: var(--fs-sm); }
  .modal-row { display: flex; align-items: center; gap: 8px; margin-top: 14px; }
</style>