@brftech/filex-core 0.44.1 → 0.45.1

package/src/lib/connectionGuides.ts

@@ -21,6 +21,13 @@
  * look exactly like filex bugs.
  */
 
+import { gioUri, isPlainHttp, netUseCommand, webdavUrl, WEBCLIENT_LIMIT_COMMANDS } from './webdavMount';
+
+// ⚠ The address forms and the OS commands live in webdavMount.ts, because the
+// desktop app's "Mount as a drive" RUNS the same commands this page prints.
+// Re-exported so the existing importers keep working.
+export { isPlainHttp };
+
 export type Translate = (key: string, vars?: Record<string, string | number>) => string;
 
 /** Everything a guide is allowed to know about the deployment. */
@@ -131,12 +138,6 @@ export function hostOf(origin: string): string {
   }
 }
 
-/** True when the deployment is not on TLS — several clients refuse that,
- *  and Windows refuses it silently, which is worse. */
-export function isPlainHttp(origin: string): boolean {
-  return /^http:\/\//i.test(origin);
-}
-
 /**
  * The username a client should be given. Falls back to a placeholder so a
  * guide rendered before `/api/auth/me` answers is still readable rather
@@ -152,8 +153,7 @@ function userOf(ctx: GuideContext, t: Translate): string {
 
 export const buildWebdavGuide: GuideBuilder = (ctx, t) => {
   const origin = ctx.origin.replace(/\/+$/, '');
-  const root = `${origin}/dav/`;
-  const target = ctx.storage ? `${origin}/dav/${ctx.storage}/` : root;
+  const target = webdavUrl(origin, ctx.storage);
   const user = userOf(ctx, t);
   const secret = t('conn.guide.secretPlaceholder');
 
@@ -180,7 +180,7 @@ export const buildWebdavGuide: GuideBuilder = (ctx, t) => {
         {
           kind: 'code',
           caption: t('conn.guide.webdav.win.cmdCaption'),
-          code: `net use Z: "${target}" /user:${user} ${secret} /persistent:yes`,
+          code: netUseCommand({ letter: 'Z:', url: target, user, password: secret, persistent: true }),
         },
         {
           kind: 'warn',
@@ -189,11 +189,7 @@ export const buildWebdavGuide: GuideBuilder = (ctx, t) => {
         {
           kind: 'code',
           caption: t('conn.guide.webdav.win.regCaption'),
-          code: [
-            'reg add "HKLM\\SYSTEM\\CurrentControlSet\\Services\\WebClient\\Parameters" /v FileSizeLimitInBytes /t REG_DWORD /d 4294967295 /f',
-            'reg add "HKLM\\SYSTEM\\CurrentControlSet\\Services\\WebClient\\Parameters" /v FileAttributesLimitInBytes /t REG_DWORD /d 20000000 /f',
-            'net stop webclient && net start webclient',
-          ].join('\n'),
+          code: WEBCLIENT_LIMIT_COMMANDS.join('\n'),
         },
         { kind: 'note', text: t('conn.guide.webdav.win.https') },
         { kind: 'note', text: t('conn.guide.webdav.win.persist') },
@@ -228,7 +224,7 @@ export const buildWebdavGuide: GuideBuilder = (ctx, t) => {
             `sudo mount -t davfs ${target} /mnt/filex`,
             '',
             `# ${t('conn.guide.webdav.linux.gvfsComment')}`,
-            `gio mount ${target.replace(/^https:/i, 'davs:').replace(/^http:/i, 'dav:')}`,
+            `gio mount ${gioUri(target)}`,
           ].join('\n'),
         },
         {

package/src/lib/downloadSelection.ts

@@ -105,6 +105,40 @@ export async function requestArchive(
   });
 }
 
+/**
+ * #71 — a short-lived, single-use, credential-free link to ONE file: the
+ * browser's drag-out (`DownloadURL`) for a session whose credential cannot
+ * travel on its own (a bearer — the admin SPA). The same mint as an archive,
+ * asked with `mode: "file"`, and the same `/z/<ticket>` redeem; the server
+ * streams the file as itself and re-checks the minter's reach at the drop
+ * (backend handlers/download_link.go).
+ *
+ * Resolves `null` for a server that does not know the mode. An older one
+ * ignores the field and mints a ZIP of the one file, and a zip dropped on the
+ * desktop under the file's own name is a broken file — worse than a drag that
+ * carries nothing. `ttlMs` is the link's life as the server counted it, so the
+ * caller never has to compare its clock with the server's.
+ */
+export async function requestFileLink(
+  api: Pick<FileApi, 'jsonFetch' | 'endpoints'>,
+  path: string,
+): Promise<{ url: string; ttlMs: number } | null> {
+  const ticket = await api.jsonFetch<ArchiveTicket & { mode?: string; ttl_seconds?: number }>(
+    archiveTicketUrl(api.endpoints.manager),
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ paths: [path], mode: 'file' }),
+    },
+  );
+  if (!ticket || ticket.mode !== 'file' || typeof ticket.url !== 'string') return null;
+  const ttl = Number(ticket.ttl_seconds);
+  return {
+    url: absoluteTicketUrl(api.endpoints.manager, ticket.url),
+    ttlMs: Number.isFinite(ttl) && ttl > 0 ? ttl * 1000 : 60_000,
+  };
+}
+
 /**
  * How long a download iframe is left in the document.
  *

package/src/lib/searchHit.ts

@@ -0,0 +1,129 @@
+/**
+ * A search hit, turned into the things the explorer can act on — task #47.
+ *
+ * `/api/files/search` answers with raw node rows, not listing rows: an
+ * in-storage relative `path`, a numeric `storage_id` and (on current servers)
+ * the drive's NAME in `storage`. Everything done with a hit — the advanced
+ * search's result rows, and the ⌘K palette's open / download / drag-out —
+ * needs the wire address a listing row carries (`name://rel`). One module
+ * builds it, so those surfaces cannot disagree about where a file is: "open
+ * works, download 404s" is what several inline copies of one rule turn into.
+ *
+ * The second half is the desktop's rail: several accounts searched at once,
+ * each hit tagged with its account, one group per account.
+ */
+
+import type { GlobalSearchHit } from '../composables/useFileApi';
+import type { SearchAccount } from '../types/ExplorerConfig';
+import type { FileNode } from '../types/FileNode';
+import type { DragItem } from './dragOut';
+
+/** What the explorer knows about drives when a hit does not say its own. */
+export interface HitDriveContext {
+  /** Drive names the host configured (`config.storages`). */
+  configured: string[];
+  /** The drive the explorer has open right now. */
+  current: string;
+}
+
+/** The hit's path inside its drive, without leading or trailing slashes. */
+export function hitRelPath(hit: GlobalSearchHit): string {
+  return String(hit.path ?? '').replace(/^\/+|\/+$/g, '');
+}
+
+/**
+ * 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 function hitStorageName(hit: GlobalSearchHit, ctx: HitDriveContext): string {
+  if (typeof hit.storage === 'string' && hit.storage) return hit.storage;
+  if (typeof hit.storage_name === 'string' && hit.storage_name) return hit.storage_name;
+  if (ctx.configured.length === 1 && ctx.configured[0]) return ctx.configured[0];
+  return ctx.current || '';
+}
+
+/**
+ * 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 function hitToNode(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,
+  };
+}
+
+/**
+ * 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 function hitItem(hit: GlobalSearchHit, ctx: HitDriveContext): DragItem | null {
+  const drive = hitStorageName(hit, ctx);
+  if (!hitRelPath(hit) || !drive) return null;
+  const n = hitToNode(hit, drive);
+  return { path: n.path, basename: n.basename, type: n.type };
+}
+
+/** One account's hits, in the server's order. `account` undefined = no rail. */
+export interface HitGroup {
+  account?: SearchAccount;
+  hits: GlobalSearchHit[];
+}
+
+/**
+ * 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 function groupHitsByAccount(hits: GlobalSearchHit[], limit: number): HitGroup[] {
+  const groups: HitGroup[] = [];
+  const byKey = new Map<string, HitGroup>();
+  for (const hit of hits) {
+    const key = hit.account?.id ?? '';
+    let group = byKey.get(key);
+    if (!group) {
+      group = { account: hit.account, hits: [] };
+      byKey.set(key, group);
+      groups.push(group);
+    }
+    if (group.hits.length < limit) group.hits.push(hit);
+  }
+  return groups;
+}

package/src/lib/storageLine.ts

@@ -0,0 +1,124 @@
+/**
+ * storageLine — WHICH number the storage line prints: the "Storage · 245.3 GB
+ * used" at the foot of the navigation panel (web explorer and desktop app)
+ * and the storage chip in the admin top bar.
+ *
+ * Two figures are in reach and they answer different questions:
+ *
+ *   - `GET /api/files/quota/me` — the person's upload counter,
+ *     `SUM(nodes.size) WHERE owner_id = me`. Only the upload path sets an
+ *     owner, so every file a storage sync discovered counts for nobody;
+ *   - `GET /api/files/quota/storages` — how full each drive the person can
+ *     open is (RBAC-filtered, the figure Home's drive cards print).
+ *
+ * The line used to print the first for everybody, under "Storage", in the
+ * very sentence Home's card uses for the second. Measured on a production
+ * install (2026-09-25): the card said 245.3 GB, the line 523.5 MB — 228.6 GB
+ * of that drive had arrived through a sync and the rest was uploaded by
+ * eleven people.
+ *
+ * So:
+ *   - a person WITH a quota sees their share against it. That ceiling is what
+ *     refuses their next upload, so it is the number that matters to them;
+ *   - a person WITHOUT one sees the size of the drives the panel lists — the
+ *     host's figures where it sent them (the Home cards print those), the
+ *     measured ones for the rest;
+ *   - a figure the server does not stand behind in full is a lower bound:
+ *     a drive whose catalogue does not cover it yet, or one nobody measured;
+ *   - and with nothing trustworthy to say, the line says nothing (null).
+ */
+import { incomplete, type CatalogCoverage } from './catalogCoverage';
+
+/** What the line says. */
+export 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;
+}
+
+/** The fields of `GET /api/files/quota/me` (quota.Snapshot) the line reads. */
+export interface PersonUsage {
+  used_bytes: number;
+  quota_bytes: number;
+  unlimited?: boolean;
+}
+
+/** One drive as the navigation panel holds it (`ExplorerConfig.storages`). */
+export interface PanelDrive {
+  name: string;
+  usedBytes?: number;
+  usedPartial?: boolean;
+}
+
+/** One row of `GET /api/files/quota/storages` (handlers.StorageUsageRow). */
+export interface MeasuredDrive {
+  name: string;
+  used_bytes: number;
+  file_count?: number;
+  coverage?: CatalogCoverage | null;
+}
+
+/** A byte count that can be added up. */
+function bytes(n: unknown): number | null {
+  return typeof n === 'number' && Number.isFinite(n) && n >= 0 ? n : null;
+}
+
+/** The person has a ceiling: a positive quota the server did not call unlimited. */
+export function hasCeiling(p: PersonUsage | null | undefined): boolean {
+  return !!p && !p.unlimited && p.quota_bytes > 0;
+}
+
+/**
+ * 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 function needsMeasuredDrives(
+  p: PersonUsage | null | undefined,
+  panel: readonly PanelDrive[],
+): boolean {
+  if (!p || hasCeiling(p)) return false;
+  return panel.length === 0 || panel.some((d) => bytes(d.usedBytes) === null);
+}
+
+export function storageLine(
+  p: PersonUsage | null | undefined,
+  panel: readonly PanelDrive[],
+  measured: readonly MeasuredDrive[] | null | undefined,
+): StorageLine | null {
+  if (!p) return null;
+  if (hasCeiling(p)) {
+    return { used: bytes(p.used_bytes) ?? 0, total: p.quota_bytes, unlimited: false, partial: false };
+  }
+
+  const rows = new Map<string, MeasuredDrive>();
+  for (const r of measured ?? []) if (r && typeof r.name === 'string') rows.set(r.name, r);
+  // A host that lists no drives gets every drive the server measured for it.
+  const drives: readonly PanelDrive[] = panel.length ? panel : [...rows.keys()].map((name) => ({ name }));
+
+  let used = 0;
+  let counted = 0;
+  let partial = false;
+  const seen = new Set<string>();
+  for (const d of drives) {
+    if (seen.has(d.name)) continue; // one drive, one figure, however often it is listed
+    seen.add(d.name);
+    const own = bytes(d.usedBytes);
+    const row = own === null ? rows.get(d.name) : undefined;
+    const figure = own ?? bytes(row?.used_bytes);
+    if (figure === null) {
+      partial = true; // listed, but nobody could say how full it is
+      continue;
+    }
+    used += figure;
+    counted++;
+    if (own !== null ? d.usedPartial === true : incomplete(row?.coverage) !== null) partial = true;
+  }
+  if (!counted || used <= 0) return null;
+  return { used, total: 0, unlimited: true, partial };
+}

package/src/lib/webdavMount.ts

@@ -0,0 +1,120 @@
+/**
+ * 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 function isPlainHttp(origin: string): boolean {
+  return /^http:\/\//i.test(origin);
+}
+
+/**
+ * `https://fm.example.com` (+ `docs`) → `https://fm.example.com/dav/docs/`.
+ *
+ * The storage name is NOT percent-encoded: this is the form a person reads and
+ * types, and the form `net use` and Explorer's "Map network drive" take — both
+ * encode it on the wire themselves. Consumers that need a URI (GVfs, NetFS)
+ * go through `new URL()`, which encodes it for them.
+ */
+export function webdavUrl(origin: string, storage?: string): string {
+  const base = origin.replace(/\/+$/, '');
+  return storage ? `${base}/dav/${storage}/` : `${base}/dav/`;
+}
+
+/**
+ * The GVfs form (`gio mount`, GNOME Files, Dolphin): `https:` → `davs:`,
+ * `http:` → `dav:`. With `user`, the account goes in the URI — which is what
+ * makes `gio mount` ask for the PASSWORD only, so the one line piped to it
+ * lands in the right prompt (gvfs adds the username prompt only when the URI
+ * carries none).
+ */
+export function gioUri(url: string, user?: string): string {
+  let u: URL;
+  try {
+    u = new URL(url);
+  } catch {
+    return url.replace(/^https:/i, 'davs:').replace(/^http:/i, 'dav:');
+  }
+  const scheme = u.protocol === 'http:' ? 'dav' : 'davs';
+  const auth = user ? `${encodeURIComponent(user)}@` : '';
+  return `${scheme}://${auth}${u.host}${u.pathname}`;
+}
+
+/**
+ * The UNC path Windows' WebDAV redirector gives the same address:
+ * `https://fm.example.com:8443/dav/My files/` → `\\fm.example.com@SSL@8443\dav\My files`.
+ *
+ * It is what `net use` lists for a mapped drive and what WNetAddConnection2
+ * takes, so it is also how a mapping is recognised as ours.
+ */
+export function webdavUnc(url: string): string {
+  const u = new URL(url);
+  const ssl = u.protocol === 'https:';
+  let host = u.hostname.replace(/^\[|\]$/g, '');
+  if (ssl) host += '@SSL';
+  if (u.port) host += `@${u.port}`;
+  const segments = u.pathname
+    .split('/')
+    .filter(Boolean)
+    .map((s) => decodeURIComponent(s));
+  return `\\\\${host}${segments.length ? '\\' + segments.join('\\') : ''}`;
+}
+
+export interface NetUseOptions {
+  /** `Z:` */
+  letter: string;
+  url: string;
+  user: string;
+  /** What goes in the password slot. The guide prints a placeholder there;
+   *  nothing that runs this should ever put a real secret in an argv. */
+  password: string;
+  persistent: boolean;
+}
+
+/** `net use` arguments (without `net`), in the order `net` wants them. */
+export function netUseArgs(o: NetUseOptions): string[] {
+  return ['use', o.letter, o.url, `/user:${o.user}`, o.password, `/persistent:${o.persistent ? 'yes' : 'no'}`];
+}
+
+/** The same, as a line to paste into cmd.exe — the address quoted, since a
+ *  storage name may carry a space. */
+export function netUseCommand(o: NetUseOptions): string {
+  const [verb, letter, url, ...rest] = netUseArgs(o);
+  return ['net', verb, letter, `"${url}"`, ...rest].join(' ');
+}
+
+/** Detaching a mapped drive: no credential involved, safe to run as is. */
+export function netUseDeleteArgs(letter: string): string[] {
+  return ['use', letter, '/delete', '/y'];
+}
+
+/**
+ * Windows' WebDAV client has two built-in limits that look exactly like filex
+ * bugs: transfers stop at ~47.7 MB (`FileSizeLimitInBytes`, default
+ * 50,000,000) and folders of roughly a thousand entries fail to open
+ * (`FileAttributesLimitInBytes`, default 1,000,000). These are the values the
+ * guide recommends, and the registry lines that set them (an administrator
+ * runs them; the WebClient service must restart after).
+ */
+export const WEBCLIENT_KEY = 'HKLM\\SYSTEM\\CurrentControlSet\\Services\\WebClient\\Parameters';
+export const WEBCLIENT_FILE_SIZE_RECOMMENDED = 4294967295;
+export const WEBCLIENT_ATTRIBUTES_RECOMMENDED = 20000000;
+export const WEBCLIENT_LIMIT_COMMANDS: string[] = [
+  `reg add "${WEBCLIENT_KEY}" /v FileSizeLimitInBytes /t REG_DWORD /d ${WEBCLIENT_FILE_SIZE_RECOMMENDED} /f`,
+  `reg add "${WEBCLIENT_KEY}" /v FileAttributesLimitInBytes /t REG_DWORD /d ${WEBCLIENT_ATTRIBUTES_RECOMMENDED} /f`,
+  'net stop webclient && net start webclient',
+];

package/src/locales/en.ts

@@ -1339,6 +1339,19 @@ export const en: Record<string, string> = {
   'storages.fields.tls': 'FTPS (explicit AUTH TLS)',
   'storages.fields.url': 'Base URL',
   'storages.fields.user': 'User',
+  'storages.fields.s3AttemptTimeout': 'Attempt timeout (seconds)',
+  'storages.fields.s3MaxAttempts': 'Attempts per request',
+  'storages.fields.s3TotalTimeout': 'Give up after (seconds)',
+  'storages.fieldHelp.s3AttemptTimeout': 'How long one attempt may wait for a sign of life from the store: connecting, the TLS handshake, the answer after the request is sent, and each next piece of the answer. A transfer that keeps moving is never cut, however long it takes; an upload the store stops taking is cut after 60 seconds, or after this if it is longer. Copies and renames wait up to 10 minutes for the answer, because the store answers them only when the copy is done.',
+  'storages.fieldHelp.s3MaxAttempts': 'How many times a request is tried in all when the failure can pass: a network error, a timeout, a 5xx answer, throttling. 1 turns retrying off. A refusal (403, a missing bucket, a host name that does not resolve) is never retried.',
+  'storages.fieldHelp.s3TotalTimeout': 'No new attempt starts unless it could finish within this many seconds of the first, so an upload or a listing on a store that is down reports the outage within this time. A transfer that is under way is not cut. A request that timed out is tried again only when this is at least twice the attempt timeout.',
+  'storages.fields.attemptTimeout': 'Attempt timeout (seconds)',
+  'storages.fields.maxAttempts': 'Attempts per request',
+  'storages.fields.totalTimeout': 'Give up after (seconds)',
+  'storages.fieldHelp.attemptTimeout': 'How long one attempt may wait for a sign of life from the server: connecting, logging in, the answer to each request, and each next piece of a transfer. A transfer that keeps moving is never cut, however long it takes; an upload the server stops taking is cut after 60 seconds, or after this if it is longer.',
+  'storages.fieldHelp.webdavAttemptTimeout': 'How long one attempt may wait for a sign of life from the server: connecting, logging in, the answer to each request, and each next piece of a transfer. A transfer that keeps moving is never cut, however long it takes; an upload the server stops taking is cut after 60 seconds, or after this if it is longer. Copies, moves and deletes wait up to 10 minutes for the answer, because the server answers them only when the work is done.',
+  'storages.fieldHelp.maxAttempts': 'How many times a request is tried in all when the failure can pass: the connection is refused or drops, no answer comes in time, the server answers that it is unavailable (5xx). 1 turns retrying off. A refusal (a wrong password, a missing folder, a certificate that does not verify) is never retried, and neither is an upload that has started sending.',
+  'storages.fieldHelp.totalTimeout': 'No new attempt starts unless it could finish within this many seconds of the first, so a server that is down is reported within this time. A transfer that is under way is not cut. A request that timed out is tried again only when this is at least twice the attempt timeout.',
 
 
   /* === gezinti:g1 — navigation panel (SideNav) === */

package/src/locales/tr.ts

@@ -1329,6 +1329,19 @@ export const tr: Record<string, string> = {
   'storages.fields.tls': 'FTPS (açık AUTH TLS)',
   'storages.fields.url': 'Temel URL',
   'storages.fields.user': 'Kullanıcı',
+  'storages.fields.s3AttemptTimeout': 'Deneme zaman aşımı (saniye)',
+  'storages.fields.s3MaxAttempts': 'İstek başına deneme sayısı',
+  'storages.fields.s3TotalTimeout': 'Vazgeçme süresi (saniye)',
+  'storages.fieldHelp.s3AttemptTimeout': 'Tek bir denemenin depodan bir yaşam belirtisi için bekleyebileceği süre: bağlanma, TLS el sıkışması, istek gönderildikten sonraki cevap ve cevabın her yeni parçası. İlerleyen bir aktarım, süresi ne olursa olsun hiçbir zaman kesilmez; deponun almayı bıraktığı bir yükleme 60 saniye sonra, bu değer daha uzunsa bu kadar sonra kesilir. Kopyalama ve yeniden adlandırma cevap için 10 dakikaya kadar bekler, çünkü depo bunları ancak kopya bittiğinde cevaplar.',
+  'storages.fieldHelp.s3MaxAttempts': 'Hata geçebilecek türdeyse bir isteğin toplamda kaç kez deneneceği: ağ hatası, zaman aşımı, 5xx cevabı, hız sınırlaması. 1 yeniden denemeyi kapatır. Bir ret (403, bulunmayan bir kova, çözümlenmeyen bir sunucu adı) hiçbir zaman yeniden denenmez.',
+  'storages.fieldHelp.s3TotalTimeout': 'İlk denemeden itibaren bu kadar saniye içinde bitemeyecek yeni bir deneme başlatılmaz; böylece çalışmayan bir depoya yükleme ya da listeleme, kesintiyi bu süre içinde bildirir. Sürmekte olan bir aktarım kesilmez. Zaman aşımına uğrayan bir istek ancak bu değer deneme zaman aşımının en az iki katıysa yeniden denenir.',
+  'storages.fields.attemptTimeout': 'Deneme zaman aşımı (saniye)',
+  'storages.fields.maxAttempts': 'İstek başına deneme sayısı',
+  'storages.fields.totalTimeout': 'Vazgeçme süresi (saniye)',
+  'storages.fieldHelp.attemptTimeout': 'Tek bir denemenin sunucudan bir yaşam belirtisi için bekleyebileceği süre: bağlanma, oturum açma, her isteğin cevabı ve bir aktarımın her yeni parçası. İlerleyen bir aktarım, süresi ne olursa olsun hiçbir zaman kesilmez; sunucunun almayı bıraktığı bir yükleme 60 saniye sonra, bu değer daha uzunsa bu kadar sonra kesilir.',
+  'storages.fieldHelp.webdavAttemptTimeout': 'Tek bir denemenin sunucudan bir yaşam belirtisi için bekleyebileceği süre: bağlanma, oturum açma, her isteğin cevabı ve bir aktarımın her yeni parçası. İlerleyen bir aktarım, süresi ne olursa olsun hiçbir zaman kesilmez; sunucunun almayı bıraktığı bir yükleme 60 saniye sonra, bu değer daha uzunsa bu kadar sonra kesilir. Kopyalama, taşıma ve silme cevap için 10 dakikaya kadar bekler, çünkü sunucu bunları ancak iş bittiğinde cevaplar.',
+  'storages.fieldHelp.maxAttempts': 'Hata geçebilecek türdeyse bir isteğin toplamda kaç kez deneneceği: bağlantı reddedilir ya da kopar, cevap zamanında gelmez, sunucu şu an hizmet veremediğini söyler (5xx). 1 yeniden denemeyi kapatır. Bir ret (yanlış parola, bulunmayan bir klasör, doğrulanamayan bir sertifika) hiçbir zaman yeniden denenmez; gönderilmeye başlamış bir yükleme de yeniden denenmez.',
+  'storages.fieldHelp.totalTimeout': 'İlk denemeden itibaren bu kadar saniye içinde bitemeyecek yeni bir deneme başlatılmaz; böylece çalışmayan bir sunucu bu süre içinde bildirilir. Sürmekte olan bir aktarım kesilmez. Zaman aşımına uğrayan bir istek ancak bu değer deneme zaman aşımının en az iki katıysa yeniden denenir.',
 
 
   /* === gezinti:g1 — gezinti paneli (SideNav) === */