@brftech/filex-core 0.30.1 → 0.32.0

package/src/lib/fileFilters.ts

@@ -0,0 +1,143 @@
+/**
+ * surucu:d1 — the filter row's model, kept out of the components so the
+ * predicate has one definition and can be tested without a DOM.
+ *
+ * ⚠ EVERY filter here answers from a field the listing row ALREADY carries
+ * (`type`, `extension`, `mime_type`, `size`, `last_modified`). That is not a
+ * shortcut, it is the constraint: `GET /api/files/manager?action=index` reads
+ * no `mime` / `min_size` / `modified_after` / `owner` parameter — it returns
+ * the whole directory and ignores anything else you send it (handlers/manager.go
+ * `List`, the complete parameter list is `action`, `path`, `filter`, `storage`,
+ * `parent`, `cache`). A control wired to a parameter the server does not read
+ * looks like it works and quietly changes nothing, which is worse than not
+ * shipping it.
+ *
+ * Because the endpoint has no `limit`/`offset` either, the listing in hand IS
+ * the folder — so filtering it client-side is complete for the folder, not a
+ * filter over "the first page". That is exactly why these three are honest and
+ * a People/owner filter is not: `nodes.owner_id` exists for quota accounting,
+ * is nil for anything a sync discovered, and is serialized by nothing
+ * (handlers/shared.go: "There is no per-node owner").
+ */
+import type { FileNode } from '../types/FileNode';
+import { iconFamilyFor, type IconFamily } from './fileIcons';
+
+export type TypeFilter =
+  | 'any'
+  | 'folder'
+  | 'document'
+  | 'spreadsheet'
+  | 'presentation'
+  | 'pdf'
+  | 'image'
+  | 'video'
+  | 'audio'
+  | 'archive'
+  | 'code';
+
+export type ModifiedFilter = 'any' | 'today' | '7d' | '30d' | 'year';
+
+export type SizeFilter = 'any' | 'lt1' | '1to10' | '10to100' | 'gt100';
+
+export interface DriveFilters {
+  type: TypeFilter;
+  modified: ModifiedFilter;
+  size: SizeFilter;
+}
+
+export const EMPTY_FILTERS: DriveFilters = { type: 'any', modified: 'any', size: 'any' };
+
+export function filtersActive(f: DriveFilters): boolean {
+  return f.type !== 'any' || f.modified !== 'any' || f.size !== 'any';
+}
+
+export function activeFilterCount(f: DriveFilters): number {
+  return (f.type !== 'any' ? 1 : 0) + (f.modified !== 'any' ? 1 : 0) + (f.size !== 'any' ? 1 : 0);
+}
+
+/** Families a type choice accepts. `iconFamilyFor` is the taxonomy the icons
+ *  already use, so a row's filter group and its glyph can never disagree. */
+const TYPE_FAMILIES: Record<Exclude<TypeFilter, 'any'>, IconFamily[]> = {
+  folder: ['folder'],
+  document: ['doc', 'text'],
+  spreadsheet: ['sheet'],
+  presentation: ['slides'],
+  pdf: ['pdf'],
+  image: ['image'],
+  video: ['video'],
+  audio: ['audio'],
+  archive: ['archive'],
+  code: ['code'],
+};
+
+/** MIME fallback — a file with no extension still has a `mime_type` from the
+ *  backend sniffer, and "IMG_0042" with no suffix is a real thing people have. */
+const MIME_PREFIXES: Partial<Record<Exclude<TypeFilter, 'any'>, string[]>> = {
+  image: ['image/'],
+  video: ['video/'],
+  audio: ['audio/'],
+  pdf: ['application/pdf'],
+  document: ['text/plain', 'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessing'],
+  spreadsheet: ['text/csv', 'application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheet'],
+  presentation: ['application/vnd.ms-powerpoint', 'application/vnd.openxmlformats-officedocument.presentation'],
+  archive: ['application/zip', 'application/x-tar', 'application/gzip', 'application/x-7z'],
+};
+
+function matchesType(n: FileNode, t: TypeFilter): boolean {
+  if (t === 'any') return true;
+  if (t === 'folder') return n.type === 'dir';
+  if (n.type === 'dir') return false;
+  if (TYPE_FAMILIES[t].includes(iconFamilyFor(n))) return true;
+  const mime = (n.mime_type || '').toLowerCase();
+  return !!mime && (MIME_PREFIXES[t] ?? []).some((p) => mime.startsWith(p));
+}
+
+/** `now` is a parameter so a test can pin the clock instead of sleeping. */
+function matchesModified(n: FileNode, f: ModifiedFilter, now: number): boolean {
+  if (f === 'any') return true;
+  const ms = typeof n.last_modified === 'number' ? n.last_modified : 0;
+  // No timestamp = no answer. Dropping the row would hide files whose driver
+  // gave us nothing; keeping it would put them in "Today". Hiding is the
+  // honest one: the row does not satisfy "modified today", it is unknown.
+  if (!ms) return false;
+  if (f === 'year') {
+    return new Date(ms).getFullYear() === new Date(now).getFullYear();
+  }
+  if (f === 'today') {
+    const start = new Date(now);
+    start.setHours(0, 0, 0, 0);
+    return ms >= start.getTime();
+  }
+  const days = f === '7d' ? 7 : 30;
+  return ms >= now - days * 86_400_000;
+}
+
+const MB = 1024 * 1024;
+
+function matchesSize(n: FileNode, f: SizeFilter): boolean {
+  if (f === 'any') return true;
+  // ⚠ Folders drop out of every size choice rather than passing through. A
+  // directory row's `size` is 0 from the projector, so "under 1 MB" would
+  // otherwise list every folder in the drive — an answer that looks like a
+  // measurement and is not one.
+  if (n.type === 'dir') return false;
+  const s = typeof n.size === 'number' ? n.size : 0;
+  if (f === 'lt1') return s < MB;
+  if (f === '1to10') return s >= MB && s < 10 * MB;
+  if (f === '10to100') return s >= 10 * MB && s < 100 * MB;
+  return s >= 100 * MB;
+}
+
+export function applyFilters(
+  files: FileNode[],
+  f: DriveFilters,
+  now: number = Date.now(),
+): FileNode[] {
+  // No active filter → the SAME array reference, so an unfiltered explorer
+  // renders exactly what it rendered before this file existed.
+  if (!filtersActive(f)) return files;
+  return files.filter(
+    (n) =>
+      matchesType(n, f.type) && matchesModified(n, f.modified, now) && matchesSize(n, f.size),
+  );
+}

package/src/lib/listing.ts

@@ -120,14 +120,61 @@ export function makeTrashRow(adapter: string): FileNode {
  * Inject the virtual `.trash` row at the front of a root listing when
  * enabled. Returns true if a row was added (so the caller can hydrate
  * it). Mutates `files` in place. Single source for both panes.
+ *
+ * ⚠ `isSearchResult` is not optional politeness — it is the one thing
+ * `dirname` cannot tell you. A search answers with the SCOPE it searched, so
+ * `?action=search&path=main://&filter=brief` comes back with
+ * `dirname: "main://"`, identical to the folder listing of the same path
+ * (measured). Without this flag the sentinel is unshifted into the search
+ * results, and a search for "brief" answers with `brief.md` and a folder
+ * called Trash that is not a folder, is not a hit, and cannot be searched for.
+ * Same family as the `.trash` / `.shared` sentinel bugs fixed in v0.31.0: a
+ * virtual row rendered somewhere it has no meaning.
+ *
+ * Both flags default to `false`, i.e. to the historical behaviour: a caller
+ * that never searches and has no panel — which is what an embed with
+ * `sideNav: false` is — keeps the row it has always had by saying nothing.
  */
+export interface TrashRowContext {
+  /**
+   * This listing is the answer to a SEARCH, not the contents of a folder.
+   *
+   * ⚠ The one thing `dirname` cannot tell you: a search answers with the scope
+   * it searched, so `?action=search&path=main://&filter=notes` comes back
+   * carrying `dirname: "main://"`, byte-identical to that folder's listing
+   * (measured). Without this the sentinel lands among the hits.
+   */
+  isSearchResult?: boolean;
+  /**
+   * The navigation panel is already offering Trash as a destination.
+   *
+   * ⚠ This row only ever existed because a listing had no other way into the
+   * bin. Once the panel carries a Trash entry that reason is gone and the row
+   * is a second door to the same place — drawn as a 0-byte folder that is not
+   * a folder, sitting among real ones, while the panel's own Trash entry is
+   * three inches to its left. Owner's decision, this release: do not offer the
+   * same door twice.
+   *
+   * ⚠ It is a question about the PANEL, not about the profile. The duplication
+   * is exactly as wrong in `standard` with the panel on as it is in `drive`;
+   * keying it to `uiProfile` would be a rule about the wrong thing.
+   */
+  navOffersTrash?: boolean;
+}
+
 export function injectTrashRow(
   files: FileNode[],
   adapter: string,
   dirname: string,
   trashVisible: boolean,
+  ctx: TrashRowContext = {},
 ): boolean {
+  // The host's own switch, and still the outer gate: `trashVisible: false`
+  // means no Trash anywhere — no row here, and no entry in the panel either,
+  // so this must be answered before anything about the panel is considered.
   if (!trashVisible) return false;
+  if (ctx.navOffersTrash) return false;
+  if (ctx.isSearchResult) return false;
   if (isTrashListing(dirname)) return false;
   if (!isStorageRootDir(dirname)) return false;
   files.unshift(makeTrashRow(adapter));
@@ -179,7 +226,62 @@ export const VIRTUAL_SEGMENTS: Record<string, string> = {
   '.shared': 'node.shared',
 };
 
-/** The locale key for a sentinel segment, or '' when it is a real folder. */
+/**
+ * The tag view's sentinel: `.tag~<name>`, ONE segment, e.g. `.tag~invoices`.
+ *
+ * Every other virtual view has a fixed label, so a segment→locale-key map is
+ * enough for them. A tag's label is the tag itself, so it cannot live in that
+ * map — but it must not become a SECOND place that knows about sentinels
+ * either, which is exactly how the tab strip came to print `.shared`. Hence
+ * `virtualSegmentLabel()` below: the map keeps the static views, this prefix
+ * keeps the dynamic one, and every surface that renders a path segment calls
+ * the one function that knows both.
+ *
+ * ⚠ `~` rather than `:` or `/`. `writePersistedPath` runs each segment through
+ * `encodeURIComponent`, which leaves `~ - _ . ! * ' ( )` alone and escapes `:`
+ * — so `#.tag~invoices` stays readable in the address bar while `.tag:` would
+ * show as `#.tag%3Ainvoices`. And one segment rather than two (`.tag/name`)
+ * because a two-segment path gives the breadcrumb a clickable `.tag` parent
+ * crumb that leads nowhere.
+ */
+export const TAG_SEGMENT_PREFIX = '.tag~';
+
+/** `invoices` → `.tag~invoices`. */
+export function makeTagSegment(tag: string): string {
+  return `${TAG_SEGMENT_PREFIX}${tag}`;
+}
+
+/** `.tag~invoices` → `invoices`; '' for anything else (incl. a bare `.tag~`). */
+export function tagOfSegment(segment: string): string {
+  return segment.startsWith(TAG_SEGMENT_PREFIX)
+    ? segment.slice(TAG_SEGMENT_PREFIX.length)
+    : '';
+}
+
+/** True when `path` (user-facing form) IS a tag listing. */
+export function tagOfPath(path: string): string {
+  const clean = (path || '').replace(/^\/+|\/+$/g, '');
+  return tagOfSegment(clean.split('/').pop() || clean);
+}
+
+/** The locale key for a STATIC sentinel segment, or '' otherwise. Prefer
+ *  `virtualSegmentLabel` — a tag segment has no locale key to return. */
 export function virtualSegmentKey(segment: string): string {
   return VIRTUAL_SEGMENTS[segment] ?? '';
 }
+
+/**
+ * What a path segment READS AS: the translated view name for a static
+ * sentinel, `#<tag>` for a tag view, '' when it is an ordinary folder (the
+ * caller then shows the segment itself).
+ *
+ * `#` and not the bare name: a lone `invoices` crumb between `/` and nothing
+ * is indistinguishable from a folder called invoices. The glyph needs no
+ * translation and carries the tag's own name verbatim, which is the point.
+ */
+export function virtualSegmentLabel(segment: string, t: (key: string) => string): string {
+  const key = VIRTUAL_SEGMENTS[segment];
+  if (key) return t(key);
+  const tag = tagOfSegment(segment);
+  return tag ? `#${tag}` : '';
+}

package/src/lib/star.ts

@@ -0,0 +1,42 @@
+/**
+ * star.ts — the ONE place that talks to `POST /api/files/manager/star`.
+ *
+ * Starring grew a second surface (the context menu, then the grid/gallery
+ * cards) and a menu entry cannot render a component, so the request had to
+ * come out of `StarButton.vue` — but only ONCE. `StarButton` calls this, the
+ * explorer's menu action calls this, and there is no third copy of the URL,
+ * the credentials rule or the payload shape anywhere.
+ *
+ * ⚠ `credentials` defaults to 'same-origin', never 'include': a credentialed
+ * cross-origin request may not be answered with `Access-Control-Allow-Origin:
+ * *`, which is what filex sends — hardcoding 'include' silently broke starring
+ * in every embed served from a different origin to the API (the desktop app is
+ * one). Same trap as `loadStarred`/`fetchNavRows` in FileExplorer.
+ */
+
+export interface StarRequestOptions {
+  apiBase?: string;
+  authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+  authCredentials?: RequestCredentials;
+}
+
+/** Toggle the starred flag for ONE node. Throws on a non-2xx answer so the
+ *  caller can roll its optimistic state back. */
+export async function setNodeStarred(
+  nodeId: number,
+  starred: boolean,
+  opts: StarRequestOptions = {},
+): Promise<void> {
+  const headers = {
+    'Content-Type': 'application/json',
+    ...(await (opts.authHeaders ?? (() => ({})))()),
+  };
+  const base = opts.apiBase ?? '';
+  const res = await fetch(`${base}/api/files/manager/star`, {
+    method: 'POST',
+    headers,
+    credentials: opts.authCredentials ?? 'same-origin',
+    body: JSON.stringify({ node_id: nodeId, starred }),
+  });
+  if (!res.ok) throw new Error(`star toggle failed: ${res.status}`);
+}

package/src/lib/tags.ts

@@ -0,0 +1,105 @@
+/**
+ * tags.ts — the list of tags that exist, for the navigation panel.
+ *
+ * `GET /api/files/manager/tags/all` is one query per call, and the panel is
+ * rendered by every mounted explorer: the web app, the desktop app and every
+ * embed on a page (work.example.com renders two side by side). Asking on each mount
+ * would multiply a database scan by however many explorers a host happens to
+ * put on screen, for a list that changes when somebody edits a tag — i.e.
+ * rarely.
+ *
+ * So: a MODULE-level cache, shared by every instance in the page.
+ *   - in-flight requests are deduped, so N explorers mounting in the same tick
+ *     produce ONE request;
+ *   - the answer is reused for TTL_MS;
+ *   - `invalidateTagCache()` drops it the moment tags are written, so the
+ *     panel is never stale after the user's own edit — which is the only
+ *     staleness a user can actually notice.
+ *
+ * Keyed by apiBase: the desktop app can point at a different server between
+ * mounts and must not be handed the previous server's tags.
+ */
+
+const TTL_MS = 60_000;
+
+interface CacheEntry {
+  at: number;
+  tags: string[];
+}
+
+const cache = new Map<string, CacheEntry>();
+const inflight = new Map<string, Promise<string[]>>();
+
+export interface TagListOptions {
+  apiBase?: string;
+  authHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
+  authCredentials?: RequestCredentials;
+  /** Skip the cache (after a tag edit). */
+  force?: boolean;
+}
+
+/** Drop every cached tag list. Called after a successful tag write. */
+export function invalidateTagCache(): void {
+  cache.clear();
+  inflight.clear();
+}
+
+/**
+ * Every distinct tag, alphabetical, as the backend returns them. Never
+ * throws: an older backend with no such route, or a caller with no
+ * permission, gets an empty list and the panel simply shows no tag section.
+ */
+export async function fetchAllTags(opts: TagListOptions = {}): Promise<string[]> {
+  const base = opts.apiBase ?? '';
+  const key = base || '(same-origin)';
+  if (!opts.force) {
+    const hit = cache.get(key);
+    if (hit && Date.now() - hit.at < TTL_MS) return hit.tags;
+    const pending = inflight.get(key);
+    if (pending) return pending;
+  }
+  const run = (async () => {
+    try {
+      const res = await fetch(`${base}/api/files/manager/tags/all`, {
+        headers: await (opts.authHeaders ?? (() => ({})))(),
+        credentials: opts.authCredentials ?? 'same-origin',
+      });
+      if (!res.ok) return [];
+      const body = await res.json();
+      const tags: string[] = Array.isArray(body?.tags)
+        ? body.tags.filter((x: unknown): x is string => typeof x === 'string' && x !== '')
+        : [];
+      cache.set(key, { at: Date.now(), tags });
+      return tags;
+    } catch {
+      return [];
+    } finally {
+      inflight.delete(key);
+    }
+  })();
+  inflight.set(key, run);
+  return run;
+}
+
+/**
+ * Nodes carrying `tag`, as raw node rows (`{id, path, name, type, …}`) — the
+ * same shape `star/list` and `recent` answer with, so the caller maps them
+ * through its own `nodeRowToFileNode`.
+ */
+export async function fetchTaggedRows(
+  tag: string,
+  opts: TagListOptions = {},
+  limit = 200,
+): Promise<Record<string, unknown>[]> {
+  const base = opts.apiBase ?? '';
+  const res = await fetch(
+    `${base}/api/files/manager/tagged?tag=${encodeURIComponent(tag)}&limit=${limit}`,
+    {
+      headers: await (opts.authHeaders ?? (() => ({})))(),
+      credentials: opts.authCredentials ?? 'same-origin',
+    },
+  );
+  if (!res.ok) throw new Error(String(res.status));
+  const body = await res.json();
+  return Array.isArray(body?.nodes) ? body.nodes : [];
+}

package/src/locales/en.ts

@@ -186,6 +186,7 @@ export const en: Record<string, string> = {
   'shortcuts.toggle_hidden': 'Show/hide hidden files',
   'shortcuts.help': 'This help dialog',
   'shortcuts.select_all': 'Select all',
+  'shortcuts.star': 'Star / unstar',
   'shortcuts.rename': 'Rename',
   'shortcuts.delete': 'Delete',
   'shortcuts.cut': 'Cut',
@@ -227,6 +228,10 @@ export const en: Record<string, string> = {
   /* === koru:k1 === */
   'toolbar.inspector': 'Details',
   'ctx.details': 'Details',
+  /* yildiz:s1 — starring is an action, so it has a verb in the menu. */
+  'ctx.star': 'Star',
+  'ctx.unstar': 'Unstar',
+  'star.failed': 'Could not change the star',
   'shortcuts.inspector': 'Toggle details panel',
   'inspector.title': 'Details',
   'inspector.close': 'Close',
@@ -403,8 +408,8 @@ export const en: Record<string, string> = {
   'e2e.create.pw2_placeholder': 'Repeat the password',
   'e2e.create.warn_title': 'NO WAY BACK',
   'e2e.create.warn_body':
-    'Files open ONLY with this password. The password is NEVER stored on the server; if you forget it the content is lost forever. There is no recovery — not even an admin can open it.',
-  'e2e.create.ack': 'I understand: if I lose the password my data cannot be recovered.',
+    'Files in this folder can only be opened with this password or the recovery key shown once when the folder is created. The password is NEVER stored on the server, and filex keeps no copy of the recovery key either. Lose both and the contents are gone for good.',
+  'e2e.create.ack': 'I understand: if I lose both the password and the recovery key, my data cannot be recovered.',
   'e2e.create.ack_required': 'Please confirm the warning to continue.',
   'e2e.create.pw_short': 'Password must be at least 8 characters.',
   'e2e.create.pw_mismatch': 'Passwords do not match.',
@@ -428,6 +433,86 @@ export const en: Record<string, string> = {
   'e2e.upload.locked': 'Unlock the folder first',
   'e2e.decrypting': 'Decrypting…',
   'e2e.decrypt_failed': 'Could not decrypt the file (password changed or file corrupted).',
+  /* wiring:e2 recovery — recovery keys + operator escrow */
+  'e2e.create.escrow_title': 'This server holds a second key',
+  'e2e.create.escrow_body':
+    'Key escrow is enabled on this installation, so its operator can open this folder without your password. Using that key notifies you. Escrow is fixed when the server is installed and cannot be turned off for a folder.',
+  'e2e.locked.use_recovery': 'Lost the password? Use a recovery key',
+  'e2e.recovery.title': 'Save your recovery key',
+  'e2e.recovery.title_upgraded': 'Your recovery key',
+  'e2e.recovery.lead':
+    'This key opens the folder without its password. It is shown once — filex does not store it and cannot show it again.',
+  'e2e.recovery.lead_upgraded':
+    'This folder now has a recovery key. It opens the folder without its password, is shown once, and is not stored by filex.',
+  'e2e.recovery.copy': 'Copy',
+  'e2e.recovery.copied': 'Copied',
+  'e2e.recovery.download': 'Download as a file',
+  'e2e.recovery.warn_title': 'TREAT THIS LIKE A PASSWORD',
+  'e2e.recovery.warn_body':
+    'Anyone holding this key can read the folder. Keep it somewhere separate from the password — a key stored next to the password protects you from forgetting, not from anyone else.',
+  'e2e.recovery.escrow_title': 'This server also holds a key',
+  'e2e.recovery.escrow_body':
+    'Key escrow is enabled here, so the operator of this installation can open this folder without your password. You are notified when that key is used.',
+  'e2e.recovery.escrow_kid': 'Escrow key',
+  'e2e.recovery.ack': 'I have saved this key somewhere safe.',
+  'e2e.recovery.done': 'Done',
+  'e2e.recover.title': 'Unlock without the password',
+  'e2e.recover.none':
+    'This folder was created before recovery keys existed, so it has none. Its password is the only way in. Unlock it with the password once and filex will offer to add a recovery key.',
+  'e2e.recover.tab_recovery': 'Recovery key',
+  'e2e.recover.tab_escrow': 'Escrow key',
+  'e2e.recover.recovery_hint': 'The key shown once when this folder was created.',
+  'e2e.recover.recovery_placeholder': 'XXXX-XXXX-XXXX-XXXX-XXXX-XXXX-XXXX-XXXX',
+  'e2e.recover.escrow_warn_title': 'The owner will be told',
+  'e2e.recover.escrow_warn_body':
+    'Opening a folder with the escrow key notifies its owner. Use it only when you are entitled to.',
+  'e2e.recover.escrow_kid': 'Escrow key',
+  'e2e.recover.escrow_predates':
+    'This installation has an escrow key, but this folder does not. It was created before escrow was turned on here, so its master key was never wrapped to the escrow identity. The escrow key will not open it. Nothing the operator can do changes that — adding a slot needs this folder\u2019s password, which the server has never had. The folder\u2019s owner can grant it: unlock with the password, then choose to give the operator a key. Until they do, use the password or the recovery key.',
+  'e2e.recover.escrow_other_key':
+    'This folder carries an escrow key from a DIFFERENT installation. It was created elsewhere and restored here, so this installation\u2019s escrow key does not open it. Only the private key belonging to the escrow key it was sealed to can.',
+  'e2e.recover.escrow_placeholder': 'Paste the escrow private key (PKCS#8, base64 or PEM)',
+  'e2e.recover.bad_format':
+    'That does not look like a recovery key. It is 32 characters in eight groups of four.',
+  'e2e.recover.escrow_required': 'Paste the escrow private key.',
+  'e2e.recover.wrong_recovery': 'That recovery key does not open this folder.',
+  'e2e.recover.wrong_escrow':
+    'That escrow key does not open this folder. Folders created before escrow was enabled have no escrow key, and cannot be given one.',
+  'e2e.recover.bad_escrow_key': 'That is not a readable private key (expected PKCS#8, base64 or PEM).',
+  'e2e.recover.notify_failed':
+    'Could not notify the folder owner, so the folder was not unlocked. Escrow use is always announced.',
+  'e2e.recover.recovery_done': 'Unlocked with the recovery key',
+  'e2e.recover.escrow_done': 'Unlocked with the escrow key — the owner has been notified',
+  'e2e.recover.unlock': 'Unlock',
+  'e2e.recover.busy': 'Unlocking…',
+  'e2e.escrowoffer.title': 'Give the operator a key to this folder?',
+  'e2e.escrowoffer.body':
+    'This folder was created before key escrow was turned on here, so the operator of this installation cannot open it. Right now — while your password is in memory — filex can seal this folder to the escrow key. Your files are not re-encrypted or moved; only the key file changes.',
+  'e2e.escrowoffer.consequence':
+    'What this means: the operator gains a second, permanent way into this folder, without your password. You are notified when that key is used, but that notification is an announcement rather than a control.',
+  'e2e.escrowoffer.learn_more': 'What escrow can and cannot do',
+  'e2e.escrowoffer.password_label': 'Folder password',
+  'e2e.escrowoffer.password_required': 'Enter the folder password.',
+  'e2e.escrowoffer.wrong_password': 'That is not this folder\u2019s password.',
+  'e2e.escrowoffer.accept': 'Give the operator a key',
+  'e2e.escrowoffer.decline': 'No, keep it to myself',
+  'e2e.escrowoffer.cancel': 'Cancel',
+  'e2e.escrowoffer.busy': 'Sealing…',
+  'e2e.escrowoffer.done': 'The operator can now open this folder with the escrow key',
+  'e2e.escrowoffer.declined_toast': 'Kept to yourself. filex will not ask again for this folder.',
+  'e2e.escrowoffer.decline_failed':
+    'Could not record your answer, so filex will ask again next time. Nothing about the folder changed.',
+  'e2e.escrowoffer.failed': 'Could not give the operator a key to this folder',
+  'e2e.escrowoffer.strip_action': 'Escrow key…',
+  'e2e.upgrade.title': 'This folder has no recovery key',
+  'e2e.upgrade.body':
+    'It was created before recovery keys existed, so its password is the only way in. Right now — and only right now, while the password is in memory — filex can add one. Your files are not re-encrypted or moved.',
+  'e2e.upgrade.escrow_note':
+    'Note: this installation has key escrow enabled, so adding a recovery key also lets its operator open this folder without your password.',
+  'e2e.upgrade.accept': 'Create a recovery key',
+  'e2e.upgrade.decline': 'Not now',
+  'e2e.upgrade.busy': 'Creating…',
+  'e2e.upgrade.failed': 'Could not add a recovery key to this folder',
   'e2e.download.failed': 'Could not download the encrypted file.',
   /* /wiring:e2 */
 
@@ -863,6 +948,13 @@ export const en: Record<string, string> = {
   'empty.starred.hint': 'Star a file to find it here',
   'empty.shared.title': 'Nothing has been shared with you',
   'empty.shared.hint': 'Folders and files other people share appear here',
+  /* etiket:t1 */
+  'sidenav.tags': 'Tags',
+  'sidenav.tags.empty': 'No tags yet — add one from a file’s right-click menu.',
+  'sidenav.tags.more': 'Show {count} more',
+  'sidenav.tags.less': 'Show fewer',
+  'empty.tag.title': 'Nothing is tagged “{tag}”',
+  'empty.tag.hint': 'Right-click a file and choose Tags to put it here',
   'sidenav.connections': 'Connections',
   'sidenav.connect': 'How to connect',
   'sidenav.apikeys': 'API keys',
@@ -874,4 +966,64 @@ export const en: Record<string, string> = {
   'conn.tokens.expiryNever': 'never',
   'conn.tokens.capNote': 'Your account and its permissions are the ceiling — asking for more than you have is refused, not granted.',
   /* === /gezinti:g1 === */
+
+  /* === surucu:d1 — the Drive shell (uiProfile: 'drive', GitHub #14) ===== */
+  'drive.new': 'New',
+  'drive.new.upload': 'Upload files',
+  'drive.new.folder': 'New folder',
+  'drive.new.request': 'Request files',
+  'drive.search.placeholder': 'Search in {scope}',
+  'drive.search.placeholder_all': 'Search your files',
+  'drive.search.hint_title': 'Search everywhere and run commands ({combo})',
+  'drive.storage.used': '{used} of {total} used',
+  'drive.storage.used_unlimited': '{used} used',
+  'drive.storage.label': 'Storage',
+  'drive.section.folders': 'Folders',
+  'drive.section.files': 'Files',
+  'filter.aria': 'Filters',
+  'filter.type': 'Type',
+  'filter.type.any': 'Any type',
+  'filter.type.folder': 'Folders',
+  'filter.type.document': 'Documents',
+  'filter.type.spreadsheet': 'Spreadsheets',
+  'filter.type.presentation': 'Presentations',
+  'filter.type.pdf': 'PDFs',
+  'filter.type.image': 'Images',
+  'filter.type.video': 'Videos',
+  'filter.type.audio': 'Audio',
+  'filter.type.archive': 'Archives',
+  'filter.type.code': 'Code',
+  'filter.modified': 'Modified',
+  'filter.modified.any': 'Any time',
+  'filter.modified.today': 'Today',
+  'filter.modified.7d': 'Last 7 days',
+  'filter.modified.30d': 'Last 30 days',
+  'filter.modified.year': 'This year',
+  'filter.size': 'Size',
+  'filter.size.any': 'Any size',
+  'filter.size.lt1': 'Under 1 MB',
+  'filter.size.1to10': '1 - 10 MB',
+  'filter.size.10to100': '10 - 100 MB',
+  'filter.size.gt100': 'Over 100 MB',
+  'filter.clear': 'Clear filters',
+  'filter.empty.title': 'Nothing here matches those filters',
+  'filter.empty.hint': 'Clear a filter, or search everywhere with the field above.',
+  'filter.count': '{shown} of {total}',
+  'inspector.tab.details': 'Details',
+  'inspector.tab.activity': 'Activity',
+  'inspector.people': 'People with access',
+  'inspector.people.you': 'You',
+  'inspector.people.inherited': 'from a parent folder',
+  'inspector.people.empty': 'Only you, and anyone with a link below.',
+  'inspector.people.manage': 'Manage access',
+  'inspector.link': 'Shared link',
+  'inspector.link.none': 'Not shared',
+  'inspector.link.create': 'Create link',
+  'inspector.link.copy': 'Copy link',
+  'inspector.activity.empty': 'No activity recorded for this item yet.',
+  'inspector.activity.hint': 'Versions are written when a file changes; comments are written by people.',
+  'inspector.activity.version': 'Version {n} saved',
+  'inspector.activity.comment': 'Comment by {who}',
+  'inspector.activity.select': 'Select a file or folder to see its activity.',
+  /* === /surucu:d1 === */
 };