@brftech/filex-core 0.44.1 → 0.45.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brftech/filex-core",
-  "version": "0.44.1",
+  "version": "0.45.1",
   "description": "filex core — Vue 3 source of truth for the filex file manager (FileExplorer + ConnectionsPanel SFCs, composables, types)",
   "type": "module",
   "main": "./dist/filex-core.umd.cjs",

package/src/FileExplorer.vue

@@ -15,7 +15,7 @@
  * the difference.
  */
 import { computed, nextTick, onBeforeUnmount, onMounted, onScopeDispose, ref, watch, watchEffect } from 'vue';
-import type { ExplorerConfig, ThemeMode } from './types/ExplorerConfig';
+import type { ExplorerConfig, SearchAccount, ThemeMode } from './types/ExplorerConfig';
 import type {
   FileNode,
   ShareInfo,
@@ -25,7 +25,7 @@ import type {
   ArchiveCreateFormat,
 } from './types/FileNode';
 import { isExternalUsable } from './types/FileNode';
-import { useFileApi, type GlobalSearchHit, type ManagerResponse } from './composables/useFileApi';
+import { useFileApi, type GlobalSearchHit, type ManagerResponse, type QuotaSnapshot } from './composables/useFileApi';
 import {
   useUploadChunked,
   isStagedUnsupported,
@@ -34,6 +34,7 @@ import {
 import { useSelection } from './composables/useSelection';
 import { useKeyboardShortcuts } from './composables/useKeyboardShortcuts';
 import { useLocale, localeTag } from './composables/useLocale';
+import { useSystemDark } from './composables/useSystemDark';
 import { usePendingOps, type PendingOp } from './composables/usePendingOps';
 import { usePluginActions } from './composables/usePluginActions'; /* App plugins — docs/APP-PLUGINS-API.md */
 import { useRealtime } from './composables/useRealtime';
@@ -98,6 +99,7 @@ import {
 import ShortcutsHelp from './components/ShortcutsHelp.vue';
 /* /cila:c wiring */
 import { coverageByStorage, coverageNotice, type CatalogCoverage } from './lib/catalogCoverage';
+import { needsMeasuredDrives, storageLine, type MeasuredDrive } from './lib/storageLine'; /* surucu:d1 — which number the storage line prints */
 /* wiring:c1 — tema galerisi */
 import ThemeGallery from './components/ThemeGallery.vue';
 import {
@@ -187,12 +189,14 @@ import { setNodeStarred } from './lib/star';
 import { emptyTrashAndFollow, TrashEmptyBusy, type TrashEmptyStatus } from './lib/trashEmpty';
 import { fetchAllTags, fetchTaggedRows, onTagsChanged, type TagItem, type TagKind } from './lib/tags';
 import { resolveTransfer, type TransferIntent } from './lib/transfer';
-import { downloadArchive } from './lib/downloadSelection'; /* tasi:m1 */
+import { downloadArchive, requestFileLink } from './lib/downloadSelection'; /* tasi:m1, #71 */
+import { hitItem, hitRelPath, hitStorageName, hitToNode, type HitDriveContext } from './lib/searchHit'; /* #47 */
 import { labelOfWire } from './lib/destinationTree'; /* tasi:m1 */
 import {
   activeNativeDrag,
   beginNativeDrag,
   canDownloadUrlDrag,
+  createDragLinks,
   dragKey,
   downloadUrlPayload,
   endNativeDrag,
@@ -979,6 +983,8 @@ const pluginView = ref<{
   view: string;
   surface: PluginSurface;
   path?: string;
+  /** Every row the view was opened on — a menu action on a selection (#64). */
+  paths?: string[];
   /** A `home` view is drawn full-size whatever the surface says. */
   size?: 'xl';
 } | null>(null);
@@ -1153,11 +1159,14 @@ async function runPluginAction(action: PluginActionRow, targets: FileNode[]) {
   try {
     const res = await pluginActions.run(action, targets);
     if (res.surface) {
+      // ⚠ `paths` too: the screen's later events must name the same files the
+      // run did, or its second screen talks about targets[0] alone (#64).
       pluginView.value = {
         plugin: action.plugin,
         view: action.view || action.id,
         surface: res.surface,
         path: targets[0]?.path,
+        paths: targets.map((n) => n.path),
       };
       return;
     }
@@ -2110,7 +2119,8 @@ const advPathBase = ref('');
  * its owner) in `describeHits`, so there is nothing left to guess and the
  * scopes are offered everywhere. Kept as a computed rather than deleted: the
  * prop is public API, and an embedder pointed at an older backend still gets
- * hits with no `storage` — which `advHitToNode` falls back for, row by row.
+ * hits with no `storage` — which `hitToNode` (lib/searchHit) falls back for,
+ * row by row.
  */
 const advContentAvailable = computed(() => true);
 
@@ -2118,46 +2128,6 @@ const advContentAvailable = computed(() => true);
  *  uses 250 internally; matching it keeps the two scopes comparable. */
 const ADV_CONTENT_LIMIT = 250;
 
-/** Map one raw search hit onto the listing shape.
- *
- *  ⚠ The drive comes from the HIT (`describeHits` puts it there), not from the
- *  pane we happen to be standing in — a content search spans storages, so
- *  `adapter.value` is only the right answer by accident. It stays as the
- *  fallback for a backend older than that field. */
-function advHitToNode(h: GlobalSearchHit, storageName: string): FileNode {
-  const rel = String(h.path ?? '').replace(/^\/+/, '');
-  const drive = typeof h.storage === 'string' && h.storage ? h.storage : storageName;
-  const name = String(h.name ?? rel.split('/').pop() ?? '');
-  const dot = name.lastIndexOf('.');
-  const mtime = typeof h.backend_mtime === 'string' ? h.backend_mtime : h.updated_at;
-  const ms = typeof mtime === 'string' ? Date.parse(mtime) : NaN;
-  return {
-    id: typeof h.id === 'number' ? h.id : undefined,
-    path: drive ? `${drive}://${rel}` : rel,
-    basename: name,
-    relativePath: rel,
-    type: h.type === 'dir' ? 'dir' : 'file',
-    extension: dot > 0 ? name.slice(dot + 1).toLowerCase() : '',
-    size: typeof h.size === 'number' ? h.size : 0,
-    // ⚠ Left UNSET when the row carries no parseable timestamp rather than
-    // defaulted to 0 or to now: `matchesModified` treats a missing timestamp
-    // as "unknown" and drops the row from a date filter, which is the honest
-    // answer. Stamping it with `Date.now()` would file every such file under
-    // "Today".
-    last_modified: Number.isNaN(ms) ? undefined : ms,
-    mime_type: typeof h.mime === 'string' ? h.mime : '',
-    /* The content snippet the hit came with, so a content match can show why
-       it matched. Undefined on name-only hits, exactly as the backend sends. */
-    snippet: typeof h.snippet === 'string' && h.snippet ? h.snippet : undefined,
-    /* Owner, so the People filter and the Owner column mean the same thing in a
-       content result as they do in a folder listing. Undefined rather than
-       guessed when the backend does not send it. */
-    owner_id: typeof h.owner_id === 'number' ? h.owner_id : undefined,
-    owner_name: typeof h.owner_name === 'string' ? h.owner_name : undefined,
-    owner_self: h.owner_self === true ? true : undefined,
-  };
-}
-
 /** Run one advanced search and hand back the rows, unfiltered — and whether
  *  the answer was cut. The name scope has the server's own word for that
  *  (`truncated`); /api/files/search's flag does not survive `globalSearch`,
@@ -2177,7 +2147,7 @@ async function advFetchRows(
   const hits = await api.globalSearch(query, { limit: ADV_CONTENT_LIMIT, scope });
   const storageName = adapter.value || (props.config.storages ?? [])[0]?.name || '';
   return {
-    rows: filterListing(hits.map((h) => advHitToNode(h, storageName))),
+    rows: filterListing(hits.map((h) => hitToNode(h, storageName))),
     truncated: advSearchTruncated(hits.length, ADV_CONTENT_LIMIT),
   };
 }
@@ -2315,33 +2285,33 @@ function onInspectorShareCreated(payload: { path: string; url: string }) {
  * every surface that has a person behind it draws the same line — this is the
  * shell, not a profile. `quotaMe()` answers null for a server without the
  * route, and null renders nothing at all.
+ *
+ * ⚠ WHICH number the line prints is `lib/storageLine`'s decision, not this
+ * function's. It used to print `used_bytes` for everybody — the person's
+ * upload counter (`SUM(nodes.size) WHERE owner_id = me`, and the upload path
+ * is the only one that sets an owner) — under "Storage", in the sentence
+ * Home's card uses for a drive's size. Measured on a production install
+ * (2026-09-25): card 245.3 GB, line 523.5 MB. Now a person with a quota sees
+ * their share of it; everybody else sees the drives the panel lists, from the
+ * same `homeStorages` the Home cards are drawn from, and the server is asked
+ * only for the drives the host sent no size for (the desktop app sends names
+ * only).
  */
-const quotaSnapshot = ref<{ used: number; total: number; unlimited: boolean } | null>(null);
+const quotaMine = ref<QuotaSnapshot | null>(null);
+const quotaDrives = ref<MeasuredDrive[] | null>(null);
+/* ⚠ A lazy `computed`, and it has to stay one: `homeStorages` is declared
+   further down, so anything that reads it at setup time — a `watch` on this
+   line, say — throws "Cannot access before initialization" and takes the
+   explorer down (the `isNarrow` note in onMounted). */
+const quotaSnapshot = computed(() => storageLine(quotaMine.value, homeStorages.value, quotaDrives.value));
 async function loadQuota() {
   if (!identitySurfaces.value) {
-    quotaSnapshot.value = null;
+    quotaMine.value = null;
     return;
   }
   const q = await api.quotaMe();
-  if (!q) {
-    quotaSnapshot.value = null;
-    return;
-  }
-  const unlimited = !!q.unlimited || q.quota_bytes <= 0;
-  // ⚠ No ceiling AND nothing counted = nothing to say, so say nothing.
-  //
-  // Measured, not guessed: `used_bytes` is `SUM(nodes.size) WHERE owner_id = me`
-  // and `nodes.owner_id` is set by the UPLOAD path only — it is nil for every
-  // file a storage sync discovered (handlers/shared.go). On an install whose
-  // drives were mounted rather than uploaded into, the honest figure is
-  // therefore "0 B", and a line reading "0 B used" under a drive visibly full
-  // of files reads as a broken widget, not as a fact about quota. With a quota
-  // set the line still earns its place — the ceiling is real and uploads count
-  // against it — so only the no-quota-no-usage case is dropped.
-  quotaSnapshot.value =
-    unlimited && q.used_bytes <= 0
-      ? null
-      : { used: q.used_bytes, total: q.quota_bytes, unlimited };
+  quotaMine.value = q;
+  quotaDrives.value = needsMeasuredDrives(q, homeStorages.value) ? await api.storageUsage() : null;
 }
 
 /**
@@ -2982,9 +2952,14 @@ function toggleHiddenFiles() {
  * The listing is ours; the storage list is the host's (`config.storages`), so
  * the host is told and re-answers it in its own time. Nothing here waits on
  * that: the folder is on screen again either way.
+ *
+ * surucu:d1 — the storage line is read again too: the person's usage and the
+ * drives' sizes both move, and a host that sends no sizes (the desktop app)
+ * would otherwise keep the figure the panel mounted with.
  */
 function refreshAll() {
   void load();
+  void loadQuota();
   emit('refresh');
 }
 
@@ -3700,34 +3675,74 @@ const showShortcutsHelp = ref(false);
 
 /* bul:s3 — palette "everywhere" search + open-hit navigation */
 
-// Debounce/min-chars live in the palette; this is just the API call.
-function paletteGlobalSearch(q: string): Promise<GlobalSearchHit[]> {
-  return api.globalSearch(q, { limit: 8, scope: 'all' });
+/** What this mount knows about drives, for a hit that does not name its own. */
+function hitDrives(): HitDriveContext {
+  return { configured: (props.config.storages ?? []).map((s) => s.name), current: adapter.value };
+}
+
+/**
+ * #47 — the account a hit belongs to when it is NOT this mount's own, else
+ * null. Only a host that searches several accounts stamps hits at all.
+ */
+function foreignAccountOf(hit: GlobalSearchHit): SearchAccount | null {
+  const hook = props.config.accountSearch;
+  const acc = hit.account;
+  if (!hook || !acc || acc.id === hook.self.id) return null;
+  return acc;
+}
+
+/** #47 — the hit as an item. Another account's hit is addressed by what the
+ *  HIT says and nothing else: this mount's drives are not that server's. */
+function paletteHitItem(hit: GlobalSearchHit) {
+  return hitItem(hit, foreignAccountOf(hit) ? { configured: [], current: '' } : hitDrives());
+}
+
+// Debounce/min-chars live in the palette; this is the API call — and, when
+// the host holds several accounts (#47), one call per account through the
+// host's hook, each answer stamped with its account. One account failing
+// costs its own group, not the others'.
+async function paletteGlobalSearch(q: string): Promise<GlobalSearchHit[]> {
+  const own = api.globalSearch(q, { limit: 8, scope: 'all' });
+  const hook = props.config.accountSearch;
+  if (!hook) return own;
+  let others: SearchAccount[] = [];
+  try {
+    others = (await hook.others()) ?? [];
+  } catch {
+    others = [];
+  }
+  if (others.length === 0) return own;
+  const accounts = [hook.self, ...others];
+  const answers = await Promise.allSettled([
+    own,
+    ...others.map((a) => hook.search(a.id, q, { limit: 8, scope: 'all' })),
+  ]);
+  const out: GlobalSearchHit[] = [];
+  answers.forEach((r, i) => {
+    if (r.status !== 'fulfilled' || !Array.isArray(r.value)) return;
+    for (const h of r.value) out.push({ ...h, account: accounts[i] });
+  });
+  return out;
 }
 
 /**
  * Open a global-search hit: navigate to the file's folder, then select +
  * preview it through the existing openNode mechanics. Hits come back as raw
  * node rows (in-storage relative `path`, numeric `storage_id`), so the
- * storage segment for multi-storage mode is resolved best-effort: an
- * explicit name on the hit (future backends) > the only configured storage
- * > the storage currently open. A wrong guess lands on the existing
- * "folder not found" state, which is already a graceful dead-end.
+ * storage segment for multi-storage mode is resolved by `hitStorageName`
+ * (lib/searchHit): the name on the hit > the only configured storage > the
+ * storage currently open. A wrong guess lands on the existing "folder not
+ * found" state, which is already a graceful dead-end.
  */
 async function openSearchHit(hit: GlobalSearchHit) {
-  const rel = String(hit.path ?? '').replace(/^\/+|\/+$/g, '');
+  const rel = hitRelPath(hit);
   if (!rel) return;
   const isDir = hit.type === 'dir';
   const slash = rel.lastIndexOf('/');
   const targetRel = isDir ? rel : slash === -1 ? '' : rel.slice(0, slash);
   let target = targetRel;
   if (multiStorageRoot.value) {
-    const configured = props.config.storages ?? [];
-    const storageName =
-      (typeof hit.storage === 'string' && hit.storage) ||
-      (typeof hit.storage_name === 'string' && hit.storage_name) ||
-      (configured.length === 1 ? configured[0].name : '') ||
-      adapter.value;
+    const storageName = hitStorageName(hit, hitDrives());
     if (!storageName) return;
     target = targetRel ? `${storageName}/${targetRel}` : storageName;
   }
@@ -3740,6 +3755,97 @@ async function openSearchHit(hit: GlobalSearchHit) {
     openNode(node);
   }
 }
+
+/* === #47 — the palette's hit verbs ====================================
+ *
+ * Open, download and drag out, each answered by what a LISTING row of the
+ * same file already uses: `openSearchHit` → openNode, `downloadSelection`,
+ * `handDragOut`. Another account's hit goes to the host's hook instead — the
+ * explorer holds no credential for that server.
+ */
+
+function reportHookFailure(op: string) {
+  return (err: unknown) => emit('error', { message: (err as Error)?.message ?? String(err), context: { op } });
+}
+
+function onPaletteOpenHit(hit: GlobalSearchHit) {
+  const acc = foreignAccountOf(hit);
+  const hook = props.config.accountSearch;
+  if (acc && hook) {
+    const item = paletteHitItem(hit);
+    if (item) void Promise.resolve(hook.open(acc.id, item)).catch(reportHookFailure('search-open'));
+    return;
+  }
+  void openSearchHit(hit);
+}
+
+/** Which verbs a hit row offers. Mirrors what a listing row of it would do. */
+function paletteHitCan(hit: GlobalSearchHit, action: 'download' | 'drag'): boolean {
+  const item = paletteHitItem(hit);
+  if (!item) return false;
+  if (foreignAccountOf(hit)) {
+    const hook = props.config.accountSearch;
+    return action === 'download' ? !!hook?.download : !!hook?.dragStart;
+  }
+  if (action === 'download') return true;
+  // The shell carries anything; the browser's own path carries ONE file — on
+  // the plain download URL where the session is a cookie, on a minted link
+  // where it is a bearer (#71, lib/dragOut createDragLinks), and not at all
+  // against a server too old to mint one.
+  return (
+    !!dragOut.value ||
+    (item.type === 'file' && (canDownloadUrlDrag(props.config.auth) || dragLinksSupported.value))
+  );
+}
+
+/** #71 — the pointer rests on / presses a hit: get its drag-out link ready. */
+function onPaletteWarmHit(hit: GlobalSearchHit) {
+  if (foreignAccountOf(hit)) return;
+  const item = paletteHitItem(hit);
+  if (item && item.type === 'file') warmDragLink(item.path);
+}
+
+function downloadSearchHit(hit: GlobalSearchHit) {
+  const item = paletteHitItem(hit);
+  if (!item) return;
+  const acc = foreignAccountOf(hit);
+  if (acc) {
+    const hook = props.config.accountSearch;
+    if (hook?.download) void Promise.resolve(hook.download(acc.id, item)).catch(reportHookFailure('search-download'));
+    return;
+  }
+  // The same row the advanced search draws for this hit, through the same
+  // download a selected listing row takes: a file is its own body, a folder
+  // one streaming archive.
+  void downloadSelection([hitToNode(hit, hitStorageName(hit, hitDrives()))]);
+}
+
+function onPaletteDragHit(hit: GlobalSearchHit, ev: DragEvent) {
+  const item = paletteHitItem(hit);
+  if (!item || !ev.dataTransfer) {
+    ev.preventDefault();
+    return;
+  }
+  ev.dataTransfer.effectAllowed = 'copy';
+  const acc = foreignAccountOf(hit);
+  if (acc) {
+    const hook = props.config.accountSearch;
+    // Always the OS drag: the browser's own path would fetch another
+    // server's file with THIS page's session.
+    ev.preventDefault();
+    if (hook?.dragStart) void Promise.resolve(hook.dragStart(acc.id, [item])).catch(reportHookFailure('drag-out'));
+    return;
+  }
+  // `null` origin: a hit is dragged OUT, never moved — the palette covers the
+  // listing, so there is no folder in this window for it to land on.
+  handDragOut(ev, [item], null, typeof hit.mime === 'string' ? hit.mime : undefined);
+}
+
+/** A hit drag let go inside the palette: the shell stops waiting for a drop. */
+function onPaletteDropInside() {
+  endNativeDrag();
+  cancelShellDrag();
+}
 /* /bul:s3 */
 
 useKeyboardShortcuts(rootEl, {
@@ -5721,6 +5827,19 @@ function onPaneItemDragStart(pane: 'main' | 'split', node: FileNode, ev: DragEve
     .map((n) => ({ path: n.path, basename: n.basename, type: n.type })); // qualified
   if (items.length === 0) return;
 
+  handDragOut(ev, items, dirWire, node.mime_type);
+}
+
+/**
+ * Hand a drag to whatever can carry it out of this window.
+ *
+ * #47 — ONE function for a listing row and a ⌘K search hit, so a hit drags
+ * out exactly the way the same file's row does. `origin` is the folder the
+ * rows came from: set, the drag is ALSO an internal one (dropped on a folder
+ * inside filex it is a move); null, it only goes out (a palette hit — the
+ * palette covers the listing, so there is nowhere inside to drop it).
+ */
+function handDragOut(ev: DragEvent, items: DragItem[], origin: string | null, mime?: string): void {
   /* wiring:f1 — drag-out (to the desktop / another application).
      When a shell is present the drag is ALWAYS an OS drag: folders and
      multi-selections land as REAL files, one by one, with NO SIZE LIMIT.
@@ -5732,7 +5851,7 @@ function onPaneItemDragStart(pane: 'main' | 'split', node: FileNode, ev: DragEve
      nothing. */
   if (dragOut.value) {
     ev.preventDefault();
-    beginNativeDrag(items, dirWire);
+    if (origin !== null) beginNativeDrag(items, origin);
     void Promise.resolve(dragOut.value.start(items)).catch((err) => {
       endNativeDrag();
       cancelShellDrag();
@@ -5742,17 +5861,67 @@ function onPaneItemDragStart(pane: 'main' | 'split', node: FileNode, ev: DragEve
     return;
   }
 
-  /* Single file + a cookie session: the browser's own download path
-     (DownloadURL) fetches the file onto the desktop at drop time; no
-     preparation is needed at all. In a bearer-token setup (the desktop app)
-     that path goes out unauthenticated, which is why the local path above
-     takes over there — see lib/dragOut.ts. */
-  if (items.length === 1 && items[0] && canDownloadUrlDrag(props.config.auth)) {
-    const payload = downloadUrlPayload(items[0], api.downloadUrl(items[0].path), node.mime_type);
+  /* Single file, no shell: the browser's own download path (DownloadURL)
+     fetches the file onto the desktop at drop time. Which URL depends on the
+     credential. A cookie session hands over the plain download URL — the
+     cookie travels with it, and it rides whatever route the embed already
+     proxies. A bearer session (the admin SPA) cannot: the download stack
+     sends no Authorization header, so it hands over the short-lived link
+     minted while the pointer rested on the row (#71). None ready yet — the
+     drag simply carries no download; it never waits (see lib/dragOut). */
+  if (items.length === 1 && items[0] && ev.dataTransfer) {
+    const one = items[0];
+    const url = canDownloadUrlDrag(props.config.auth) ? api.downloadUrl(one.path) : dragLinks.take(one.path);
+    const payload = url ? downloadUrlPayload(one, url, mime) : null;
     if (payload) ev.dataTransfer.setData('DownloadURL', payload);
   }
 }
 
+/* === #71 — a drag-out link for a session the browser cannot sign ========
+ *
+ * `dragstart` fills the dataTransfer synchronously, and the link is a server
+ * round trip, so it is asked for BEFORE the drag: when the pointer comes to
+ * rest on a file row and again on the press (lib/dragOut createDragLinks has
+ * the rules). One delegated listener pair on the root, the way the middle-
+ * click delegation below reads `[data-fe-path]` — every view (list, grid,
+ * gallery) and both panes, with nothing added to any of them; the palette's
+ * hits say so themselves (`warm-hit`), because they are not listing rows.
+ *
+ * Only where it is needed: no shell (the desktop app drags through the OS)
+ * and a credential the browser cannot carry (a cookie session has the plain
+ * URL). Nowhere else does a hover cost a request.
+ */
+const dragLinksSupported = ref(true);
+const dragLinks = createDragLinks((p) => requestFileLink(api, p), {
+  onUnsupported: () => {
+    dragLinksSupported.value = false;
+  },
+});
+const dragNeedsLink = computed(() => !dragOut.value && !canDownloadUrlDrag(props.config.auth));
+
+function warmDragLink(path: string | null | undefined) {
+  if (!path || !dragNeedsLink.value || trashActive.value) return;
+  dragLinks.warm(path);
+}
+
+function onRowPointerWarm(ev: PointerEvent) {
+  if (ev.pointerType === 'touch' || !dragNeedsLink.value) return;
+  const host = ev.target as Element | null;
+  const el = host && typeof host.closest === 'function' ? host.closest('[data-fe-path]') : null;
+  const p = el?.getAttribute('data-fe-path');
+  if (!p) return;
+  const node = files.value.find((f) => f.path === p) ?? splitDisplayOrder.value.find((f) => f.path === p);
+  if (node && node.type === 'file' && node.basename !== '.trash') warmDragLink(node.path);
+}
+onMounted(() => {
+  rootEl.value?.addEventListener('pointerover', onRowPointerWarm, { passive: true });
+  rootEl.value?.addEventListener('pointerdown', onRowPointerWarm, { capture: true, passive: true });
+});
+onBeforeUnmount(() => {
+  rootEl.value?.removeEventListener('pointerover', onRowPointerWarm);
+  rootEl.value?.removeEventListener('pointerdown', onRowPointerWarm, { capture: true });
+});
+
 /* === wiring:f1 — drag-out preparation ===
  *
  * The bytes have to be on disk BEFORE the drag starts (the OS copies from the
@@ -5989,16 +6158,7 @@ provideTableEnv({ locale, theme: themeMode });
 // Resolved mode: an explicit choice wins, otherwise the OS preference — the
 // same logic variables.css encodes in CSS. The inline root variables beat every
 // stylesheet rule, so they must track this resolution at runtime.
-const themeMq =
-  typeof window !== 'undefined' && window.matchMedia
-    ? window.matchMedia('(prefers-color-scheme: dark)')
-    : undefined;
-const themeOsDark = ref(!!themeMq?.matches);
-function onThemeMqChange(e: MediaQueryListEvent) {
-  themeOsDark.value = e.matches;
-}
-onMounted(() => themeMq?.addEventListener?.('change', onThemeMqChange));
-onBeforeUnmount(() => themeMq?.removeEventListener?.('change', onThemeMqChange));
+const themeOsDark = useSystemDark();
 const themeResolvedDark = computed(
   () => themeMode.value === 'dark' || (themeMode.value !== 'light' && themeOsDark.value),
 );
@@ -8419,6 +8579,7 @@ function closeRecoveryKey() {
       :view="pluginView.view"
       :surface="pluginView.surface"
       :path="pluginView.path"
+      :paths="pluginView.paths"
       :size="pluginView.size"
       :storages="(props.config.storages ?? []).map((st) => st.name)"
       :start-at="qualify(paneIsActive ? (splitPaneRef?.getPath() ?? '') : currentPath)"
@@ -8557,8 +8718,13 @@ function closeRecoveryKey() {
       :can-write="canWriteHere && !atVirtualRoot && !trashActive"
       :can-go-up="canGoUp"
       :global-search="paletteGlobalSearch"
+      :hit-can="paletteHitCan /* #47 */"
       @close="showPalette = false"
-      @open-hit="openSearchHit"
+      @open-hit="onPaletteOpenHit /* #47 — another account's hit goes to the host */"
+      @download-hit="downloadSearchHit /* #47 */"
+      @drag-hit="onPaletteDragHit /* #47 */"
+      @warm-hit="onPaletteWarmHit /* #71 */"
+      @drop-inside="onPaletteDropInside /* #47 */"
       @open-node="openNode"
       @navigate="(p: string) => load(p)"
       @new-folder="showNewFolder = true"

package/src/components/AdvancedSearch.vue

@@ -35,7 +35,7 @@
  * Owner select answers from a field the rows ALREADY carry — the same bargain
  * as type, date and size, and it is named in the same sentence under the
  * count. ⚠ It is offered on NAME searches only: the explorer maps a content
- * hit onto the listing shape by hand (`FileExplorer.advHitToNode`) and that
+ * hit onto the listing shape by hand (`lib/searchHit.hitToNode`) and that
  * mapping does not carry the owner through, so under the content scopes every
  * row would read as "System" — a wrong answer, which is worse than a control
  * that says why it is off.
@@ -123,7 +123,7 @@ const props = defineProps<{
    * carries `storage` (the drive's name) as well as its id, the same way the
    * starred and recently-opened handlers have always answered
    * (`handlers/search.go` `describeHits`). What is left is the explorer's own
-   * hand-written mapping, `FileExplorer.advHitToNode`, which builds a listing
+   * hand-written mapping, `lib/searchHit.hitToNode`, which builds a listing
    * row from the hit and does not read that field — so the caller still has to
    * pass `false` on a multi-storage install until it does.
    */
@@ -263,7 +263,7 @@ const PEOPLE_FIXED: PeopleFilter[] = ['any', 'me', 'system'];
  * maps those hits onto the listing shape by hand; that mapping carries no
  * owner, so every row would read as "System" and both `me` and `system` would
  * answer the wrong question confidently. Off, and it says so, until the
- * mapping carries it (`FileExplorer.advHitToNode`).
+ * mapping carries it (`lib/searchHit.hitToNode`).
  */
 const ownerFilterable = computed(() => scope.value === 'name');