@brftech/filex-core 0.44.2 → 0.45.1

package/dist/index.d.ts

@@ -1127,11 +1127,11 @@ store: ComputedRef<ColumnStore<string>>;
 layout: ComputedRef<GenericTableLayout<string>>;
 pinLead: ComputedRef<boolean>;
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
-page: (page: number) => any;
 sort: (payload: {
 key: string;
 dir: "asc" | "desc";
 }) => any;
+page: (page: number) => any;
 "row-click": (row: any, ev: MouseEvent) => any;
 "row-dblclick": (row: any, ev: MouseEvent) => any;
 "row-contextmenu": (row: any, ev: MouseEvent) => any;
@@ -1145,11 +1145,11 @@ dir: "asc" | "desc";
 "row-touchend": (ev: TouchEvent) => any;
 "row-touchmove": (ev: TouchEvent) => any;
 }, string, PublicProps, Readonly<__VLS_Props_45> & Readonly<{
-onPage?: ((page: number) => any) | undefined;
 onSort?: ((payload: {
 key: string;
 dir: "asc" | "desc";
 }) => any) | undefined;
+onPage?: ((page: number) => any) | undefined;
 "onRow-click"?: ((row: any, ev: MouseEvent) => any) | undefined;
 "onRow-dblclick"?: ((row: any, ev: MouseEvent) => any) | undefined;
 "onRow-contextmenu"?: ((row: any, ev: MouseEvent) => any) | undefined;
@@ -1163,12 +1163,12 @@ dir: "asc" | "desc";
 "onRow-touchend"?: ((ev: TouchEvent) => any) | undefined;
 "onRow-touchmove"?: ((ev: TouchEvent) => any) | undefined;
 }>, {
-page: number;
+total: number;
 sort: {
 key: string;
 dir: "asc" | "desc";
 } | null;
-total: number;
+page: number;
 locale: LocaleCode;
 theme: ThemeMode;
 ariaLabel: string;
@@ -3249,6 +3249,30 @@ export declare function accentStyleOf(raw: string | undefined | null): Record<st
  */
 export declare function acceptableLocale(code: string | undefined | null): boolean;
 
+/** See `ExplorerConfig.accountSearch`. */
+export declare interface AccountSearchHook {
+    /** The account THIS explorer is mounted for — heads its own group. */
+    self: SearchAccount;
+    /** Every OTHER account signed in right now. Read on each query, so an
+     *  account added or signed out while the explorer is mounted counts. */
+    others: () => SearchAccount[] | Promise<SearchAccount[]>;
+    /** `/api/files/search` on that account's server, with its credential. */
+    search: (accountId: string, query: string, opts: {
+        limit: number;
+        scope: GlobalSearchScope;
+    }) => Promise<GlobalSearchHit[]>;
+    /**
+     * Open another account's hit — the host switches to that account. The hit
+     * arrives ADDRESSED (`name://rel`, as a listing row carries it): the host
+     * never re-derives where a file is.
+     */
+    open: (accountId: string, item: SearchHitItem) => void | Promise<void>;
+    /** Download another account's hit. Absent: its rows offer no Download. */
+    download?: (accountId: string, item: SearchHitItem) => void | Promise<void>;
+    /** Drag another account's hit out to the OS. Absent: its rows do not drag. */
+    dragStart?: (accountId: string, items: SearchHitItem[]) => void | Promise<unknown>;
+}
+
 /** The account zone `owner` last recorded (`null` = none recorded). Reactive. */
 export declare function accountTimeZoneOf(owner: symbol): string | null;
 
@@ -4620,6 +4644,48 @@ export declare function downloadArchive(api: Pick<FileApi, 'jsonFetch' | 'endpoi
     doc?: Document;
 }): Promise<ArchiveTicket>;
 
+/**
+ * Dragging files OUT of filex — onto the desktop, into another app.
+ *
+ * There are exactly two ways a page can hand real files to the operating
+ * system, and filex uses both because neither one alone covers the ask:
+ *
+ * 1. **`DownloadURL`** (any Chromium browser, so the web explorer AND the
+ *    desktop app get it for free). One `dataTransfer.setData('DownloadURL',
+ *    'mime:name:url')` and the browser downloads that URL into wherever the
+ *    drop landed. Costs nothing until the drop happens — but Chromium carries
+ *    exactly ONE such entry, so it is a single-file gesture, and the URL is
+ *    fetched by the browser's own download stack, which sends cookies but no
+ *    Authorization header (see `canDownloadUrlDrag`).
+ *
+ * 2. **A native OS drag** (`webContents.startDrag`, desktop app only). Takes a
+ *    list of real paths, so folders and multi-selections drop as separate real
+ *    files — the WinRAR gesture. The catch is in the word *real*: the shell
+ *    copies the bytes at DROP time, from a path, so the file has to be on this
+ *    computer BEFORE the drag starts. There is no lazy/virtual-file API to
+ *    borrow (that is a Win32 `IDataObject` affair Chromium does not expose).
+ *
+ * ⚠ The native drag REPLACES the HTML5 drag — `startDrag` requires
+ * `preventDefault()` on `dragstart`, and after that the app's own drop targets
+ * see an OS file drag instead of `application/x-brf-files`. Dropping a row on a
+ * folder inside filex would then UPLOAD the temp copy back to the server: a
+ * round trip of the same bytes, a copy instead of a move, and the original left
+ * behind. That is what `beginNativeDrag` is for — the payload is remembered on
+ * this side, and every drop target asks `internalDragItems(ev)` rather than
+ * reading the dataTransfer directly. An OS drag we started is still an internal
+ * drag when it lands inside our own window.
+ *
+ * Because the bytes must exist first, the shell is asked to prepare them on
+ * `mousedown` — before the gesture becomes a drag — and the native path is only
+ * taken when it answered "ready". Anything else keeps the ordinary HTML5 drag,
+ * so an internal move never waits on a download it does not need.
+ */
+declare interface DragItem {
+    path: string;
+    basename: string;
+    type: 'file' | 'dir';
+}
+
 declare interface DriveFilters {
     type: TypeFilter;
     modified: ModifiedFilter;
@@ -5565,7 +5631,9 @@ export declare interface ExplorerConfig {
         /**
          * gorunum:v3-shell — bytes this storage holds, when the host knows. Drawn
          * as the caption on the Home view's storage card; absent means the card
-         * names the kind of thing instead.
+         * names the kind of thing instead. For a person without a quota the
+         * storage line under the navigation sums these (lib/storageLine), and a
+         * storage left without one is measured by the explorer itself.
          *
          * ⚠ It must be the SAME quantity for every caller who gets it (in our own
          * app: `/api/admin/storages` for an operator, the RBAC-filtered
@@ -5677,6 +5745,21 @@ export declare interface ExplorerConfig {
          *  ONE subscriber (the mounted explorer) and overwrites it on remount. */
         onChange?: (cb: () => void) => void;
     };
+    /**
+     * #47 — the host holds several accounts at once (the desktop app's rail),
+     * and ⌘K's "Everywhere" group should search all of them.
+     *
+     * The explorer never talks to another account's server itself: it has no
+     * credential for one, and it must not be handed any. Every call that reaches
+     * another account goes through this hook, and the host answers it with the
+     * credential it already keeps for that account. Hits come back tagged with
+     * the account they belong to (`GlobalSearchHit.account`) and the palette
+     * draws one group per account under a badge, this mount's own first.
+     *
+     * Absent — the web admin, every embed, a desktop with one account — and the
+     * palette is exactly what it was: this account's hits, no badges.
+     */
+    accountSearch?: AccountSearchHook;
 }
 
 /** Component emits — the parent listens for these events. */
@@ -6213,6 +6296,15 @@ export declare interface GlobalSearchHit {
     snippet?: string;
     /** Where the hit matched: name | content | both. */
     matched?: 'name' | 'content' | 'both';
+    /** Drive NAME the hit lives on (the server fills it; older ones did not). */
+    storage?: string;
+    /**
+     * #47 — which signed-in account the hit came from. Never on the wire: the
+     * explorer stamps it when the host searches several accounts
+     * (`ExplorerConfig.accountSearch`). Absent = this mount's own account, with
+     * no other account in play.
+     */
+    account?: SearchAccount;
     [k: string]: unknown;
 }
 
@@ -6242,6 +6334,13 @@ declare interface Group {
 
 export declare function groupByDate<T>(items: readonly T[], opts: DateGroupOptions<T>): DateGrouping<T>;
 
+/**
+ * Hits → one group per account, in the order accounts first appear (the
+ * explorer lists its own account first), each capped at `limit` on its own —
+ * a busy account must not push a quieter one off the list.
+ */
+export declare function groupHitsByAccount(hits: GlobalSearchHit[], limit: number): HitGroup[];
+
 /**
  * Is a date heading honest over THIS listing?
  *
@@ -6360,6 +6459,9 @@ export declare function guideProtocols(): string[];
 /** Is there anything in this value at all? `false` and `0` count as answers. */
 export declare function hasAnswer(v: unknown): boolean;
 
+/** The person has a ceiling: a positive quota the server did not call unlimited. */
+export declare function hasCeiling(p: PersonUsage | null | undefined): boolean;
+
 /** Is this a language the interface can actually be set to? (Reactive.) */
 export declare function hasLocale(code: string | undefined | null): boolean;
 
@@ -6381,6 +6483,48 @@ export declare function hasSteps(nodes: SurfaceNode[] | undefined): boolean;
 /** The keys a surface is currently NOT showing (across every form on it). */
 export declare function hiddenKeys(nodes: SurfaceNode[] | undefined, values: Record<string, unknown>): string[];
 
+/** What the explorer knows about drives when a hit does not say its own. */
+export declare interface HitDriveContext {
+    /** Drive names the host configured (`config.storages`). */
+    configured: string[];
+    /** The drive the explorer has open right now. */
+    current: string;
+}
+
+/** One account's hits, in the server's order. `account` undefined = no rail. */
+export declare interface HitGroup {
+    account?: SearchAccount;
+    hits: GlobalSearchHit[];
+}
+
+/**
+ * The hit as a drag-out / download item (`name://rel`, its name, its kind) —
+ * or null when there is nothing to address: no path, or no drive to put it on.
+ * The same `{path, basename, type}` a listing row hands the drag-out hook.
+ */
+export declare function hitItem(hit: GlobalSearchHit, ctx: HitDriveContext): DragItem | null;
+
+/**
+ * Which drive a hit lives on: the name the server sent > `storage_name`
+ * (older servers) > the only configured drive > the drive that is open.
+ * A wrong last-resort guess lands on the listing's "folder not found" state,
+ * which is a graceful dead end — not a request against the wrong file.
+ */
+export declare function hitStorageName(hit: GlobalSearchHit, ctx: HitDriveContext): string;
+
+/**
+ * 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 the
+ * open drive is only the right answer by accident. `storageName` stays as the
+ * fallback for a backend older than that field.
+ *
+ * (Moved here from FileExplorer's `advHitToNode` for #47, unchanged: the
+ * palette's download and drag-out need the same row the advanced search draws.)
+ */
+export declare function hitToNode(h: GlobalSearchHit, storageName: string): FileNode;
+
 /** `https://fm.example.com` → `fm.example.com`; anything unparseable comes back whole. */
 export declare function hostOf(origin: string): string;
 
@@ -6517,6 +6661,23 @@ export declare function isPagePlacement(placement: string | undefined | null): b
 /** Is this box on the page yet? Absent `placed` means yes. */
 export declare function isPlaced(f: PdfField): boolean;
 
+/**
+ * webdavMount — the forms of a filex WebDAV address, and the operating
+ * systems' own commands that attach one as a drive.
+ *
+ * Two readers, one source:
+ *  - the connection guide (`connectionGuides.ts`) PRINTS these for a person to
+ *    copy;
+ *  - the desktop app's "Mount as a drive" (`desktop/src/drive.ts`) RUNS them.
+ * Written twice, the command the guide teaches and the one the button runs
+ * would drift apart, and the person who copied the guide's version would hit
+ * a failure the button never shows — or the other way round.
+ *
+ * ⚠ No imports, and none may be added. The desktop main process and its
+ * `node --test` runner import this file by relative path (the way
+ * `web/src/lib/notificationTarget.ts` is imported), and plain node does not
+ * resolve an extensionless specifier.
+ */
 /** True when the deployment is not on TLS — several clients refuse that,
  *  and Windows refuses it silently, which is worse. */
 export declare function isPlainHttp(origin: string): boolean;
@@ -7030,6 +7191,14 @@ export declare function markTourSeen(): void;
 /** True when the hit matched (at least partly) inside file CONTENT. */
 export declare function matchedInContent(matched: unknown): boolean;
 
+/** One row of `GET /api/files/quota/storages` (handlers.StorageUsageRow). */
+export declare interface MeasuredDrive {
+    name: string;
+    used_bytes: number;
+    file_count?: number;
+    coverage?: CatalogCoverage | null;
+}
+
 /**
  * A backing that lives in this component's memory only — for a table on a
  * surface with no account behind it (a public page), and for tests.
@@ -7083,6 +7252,13 @@ export declare interface NavApp {
     icon?: string;
 }
 
+/**
+ * Whether the line has to ask the server for drive sizes: there is no
+ * ceiling, and the host left at least one of the panel's drives unsized (the
+ * desktop app hands over names only) — or listed none at all.
+ */
+export declare function needsMeasuredDrives(p: PersonUsage | null | undefined, panel: readonly PanelDrive[]): boolean;
+
 /** The request never got an answer (offline, DNS, CORS, a dropped socket). */
 export declare function networkFailure(locale: string | undefined, cause?: unknown): RequestFailure;
 
@@ -7528,6 +7704,13 @@ export declare function pageRoot(base: string | undefined, token: string): Publi
 
 declare type PaneId = 'main' | 'split';
 
+/** One drive as the navigation panel holds it (`ExplorerConfig.storages`). */
+export declare interface PanelDrive {
+    name: string;
+    usedBytes?: number;
+    usedPartial?: boolean;
+}
+
 /**
  * The wire path one level up, or null when there is nowhere further up.
  *
@@ -7877,6 +8060,13 @@ export declare interface PersonLike {
 
 export declare function personName(p: PersonLike | null | undefined): string;
 
+/** The fields of `GET /api/files/quota/me` (quota.Snapshot) the line reads. */
+export declare interface PersonUsage {
+    used_bytes: number;
+    quota_bytes: number;
+    unlimited?: boolean;
+}
+
 export declare type PinFailure = '' | 'wrong' | 'locked';
 
 export declare interface PinInputNodeProps {
@@ -8257,6 +8447,13 @@ export declare interface PluginSurfaceHost {
     view: string;
     /** Adapter-qualified path the view was opened on — echoed on every event. */
     path?: () => string | undefined;
+    /**
+     * Every row the view was opened on (a selection) — echoed on every event
+     * as `paths`, beside `path`. Absent or empty for a frame opened on one
+     * row or on none (a deep link, a home page, the inspector, a public page),
+     * which then sends `path` alone, exactly as before.
+     */
+    paths?: () => readonly string[] | undefined;
     locale: () => string;
     /** The words for an answer without a surface. */
     errorText: () => string;
@@ -8308,6 +8505,18 @@ export declare interface PluginUsersResponse {
 export declare interface PluginViewEventBody {
     /** Adapter-qualified wire path of the row the view was opened on. */
     path?: string;
+    /**
+     * Every row the view was opened on, adapter-qualified, in selection order.
+     *
+     * ⚠⚠ Sent on EVERY event of a screen opened on a selection, not only the
+     * first: the server builds the event's inputs from it (and falls back to
+     * `path` only when it is absent), so a conversation that echoed `path`
+     * alone shrank to the first file after the opening screen — the second
+     * screen said "a.txt" where the first said "3 files", and the job its
+     * submit queued ran on one file (#64). The server re-checks each path for
+     * the person asking; this is a report of the selection, not a grant.
+     */
+    paths?: string[];
     storage_id?: number;
     state?: Record<string, unknown>;
     event: 'open' | 'change' | 'submit' | 'action';
@@ -8497,14 +8706,14 @@ export declare function prefsSettled(): boolean;
 export declare function preloadEditor(): void;
 
 export declare const PreviewModal: DefineComponent<__VLS_Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
-starred: (value: boolean) => any;
 close: () => any;
 nav: (delta: number) => any;
+starred: (value: boolean) => any;
 share: () => any;
 }, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{
-onStarred?: ((value: boolean) => any) | undefined;
 onClose?: (() => any) | undefined;
 onNav?: ((delta: number) => any) | undefined;
+onStarred?: ((value: boolean) => any) | undefined;
 onShare?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
 viewerEl: HTMLDivElement;
@@ -9010,15 +9219,15 @@ declare interface PublicUploadOptions {
 }
 
 export declare const QuickLook: DefineComponent<__VLS_Props_30, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
-starred: (value: boolean) => any;
 close: () => any;
 nav: (delta: number) => any;
+starred: (value: boolean) => any;
 share: () => any;
 "open-full": () => any;
 }, string, PublicProps, Readonly<__VLS_Props_30> & Readonly<{
-onStarred?: ((value: boolean) => any) | undefined;
 onClose?: (() => any) | undefined;
 onNav?: ((delta: number) => any) | undefined;
+onStarred?: ((value: boolean) => any) | undefined;
 onShare?: (() => any) | undefined;
 "onOpen-full"?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
@@ -9539,6 +9748,26 @@ export declare function sayFailure(err: unknown, fallback: string, opts?: {
 /** This document is a public link: the answer is no, and it is not remembered. */
 export declare function sealSessionless(): void;
 
+/** One signed-in account, as the palette's group badge draws it. */
+export declare interface SearchAccount {
+    /** The host's own id for the account; passed back on every hook call. */
+    id: string;
+    /** Short name on the badge — the server's brand name or its host. */
+    label: string;
+    /** Second line, quieter — typically the email signed in there. */
+    detail?: string;
+    /** The account's colour on the host (the rail avatar's), for the badge dot. */
+    color?: string;
+}
+
+/** A search hit, addressed — the `{path, basename, type}` a listing row hands
+ *  the drag-out hook, with `path` = `name://rel`. */
+export declare interface SearchHitItem {
+    path: string;
+    basename: string;
+    type: 'file' | 'dir';
+}
+
 /** Matched-in values the search contract allows on a hit. */
 export declare type SearchMatched = 'name' | 'content' | 'both';
 
@@ -10250,6 +10479,20 @@ export declare interface StorageInfo {
     coverage?: CatalogCoverage | null;
 }
 
+/** What the line says. */
+export declare interface StorageLine {
+    /** The bytes it reports. */
+    used: number;
+    /** The person's ceiling; 0 when there is none. */
+    total: number;
+    /** No ceiling — `used` is the drives' size, not the person's uploads. */
+    unlimited: boolean;
+    /** `used` is a lower bound. */
+    partial: boolean;
+}
+
+export declare function storageLine(p: PersonUsage | null | undefined, panel: readonly PanelDrive[], measured: readonly MeasuredDrive[] | null | undefined): StorageLine | null;
+
 /** A configured storage, as `GET /api/admin/storages` returns it. */
 export declare interface StorageRow {
     id: number;
@@ -10917,28 +11160,6 @@ export declare function tourSeen(): boolean;
 /** Turkish UI strings. */
 export declare const tr: Record<string, string>;
 
-/**
- * connectionGuides — "how do I connect to this thing?", generated from the
- * live deployment instead of written as prose.
- *
- * A published document says `https://fm.example.com/dav/` and leaves the
- * reader to substitute three values, one of which (their own username) they
- * usually get wrong. What ships here is the real host, the real storage
- * name and the caller's own credential, with a copy button — which is the
- * difference between a doc and a working paste. No surveyed product
- * (Backblaze, R2, Storj, MinIO, Garage) does this; it is the cheapest win
- * on the whole surface.
- *
- * Shape of the thing: a protocol is a `GuideBuilder` registered in
- * `GUIDE_BUILDERS`. WebDAV is built here because WebDAV is what filex
- * serves today; S3 and SFTP are a builder each and a registry line when
- * their servers land — no second implementation, no second UI.
- *
- * The commands are not invented. They are the ones verified on 2026-08-14
- * and written down in `docs/WEBDAV.md` and §13.5 of the write-path
- * handover, including the three Windows registry limits that otherwise
- * look exactly like filex bugs.
- */
 export declare type Translate = (key: string, vars?: Record<string, string | number>) => string;
 
 /**
@@ -11256,6 +11477,7 @@ export declare function useFileApi(config: ExplorerConfig): {
         scope?: GlobalSearchScope;
     }) => Promise<GlobalSearchHit[]>;
     quotaMe: () => Promise<QuotaSnapshot | null>;
+    storageUsage: () => Promise<MeasuredDrive[] | null>;
     subfolders: (path: string) => Promise<{
         folders: FileNode[];
     }>;