@brftech/filex-core 0.43.0 → 0.44.0

package/src/composables/useThumbs.ts

@@ -1,4 +1,4 @@
-// useThumbs — authenticated thumbnail loader for the grid view.
+// useThumbs — authenticated thumbnail loader for the folder views.
 //
 // The backend emits `thumb_url` as a ROOT-RELATIVE path ("/api/files/thumb/{id}").
 // A plain `<img src>` only works for the native same-origin SPA: an embedded
@@ -6,9 +6,24 @@
 // and, even with the URL fixed, `<img>` cannot carry the bearer header a
 // proxied host (fishapp PWA) requires. So thumbs are fetched through the same
 // auth machinery as every API call (headers + credentials), cached as object
-// URLs, and handed to the grid; a failed fetch falls back to the file icon.
+// URLs, and handed to the views; a failed fetch falls back to the file icon.
+//
+// ⚠⚠ An arrival wakes ONE tile. The object URLs used to live in one reactive
+// record that was REPLACED as each thumbnail arrived, so every arrival woke
+// everything that had read any thumbnail — the whole folder view, which read
+// them all. Field report: a folder of 344 files (~240 thumbnails) re-rendered
+// itself ~240 times in a few seconds; a fast Mac lost ~4 s, a slower Windows PC
+// froze Edge for ~30 s and ran a Chrome tab out of memory. The cache is now a
+// reactive Map read per key, and the views read it through ThumbTile (one
+// component per tile), so an arrival re-renders the tile that shows it.
+//
+// ⚠ Keyed by picture, not by URL. `thumb_url` carries a signature whose expiry
+// moves every hour; keyed by URL, the first listing after the hour turned
+// fetched every thumbnail of the folder again. The key is the URL's path plus
+// the file's `last_modified`: a rotated signature is the same picture, an edited
+// file is not.
 
-import { ref } from 'vue';
+import { shallowReactive, toRaw } from 'vue';
 import type { FileNode } from '../types/FileNode';
 
 interface ThumbApiSlice {
@@ -20,10 +35,22 @@ interface ThumbApiSlice {
  *  small (~KBs) so this is generous while still bounding a long session. */
 const MAX_CACHED = 500;
 
+/** The cache key for a node's thumbnail — null when it has none. */
+function thumbKey(n: FileNode): string | null {
+  const raw = n.thumb_url;
+  if (!raw) return null;
+  const q = raw.indexOf('?');
+  return `${q === -1 ? raw : raw.slice(0, q)}|${n.last_modified ?? ''}`;
+}
+
 export function useThumbs(apiBase: string | undefined, api: ThumbApiSlice) {
-  const urls = ref<Record<string, string>>({});
+  const cache = shallowReactive(new Map<string, string>());
   const order: string[] = [];
+  /** Signed URLs that failed. Per URL, not per key: 404 (thumb evicted
+   *  server-side) or an auth hiccup is not retried within the session, but a
+   *  freshly signed URL for the same picture may be tried once. */
   const failed = new Set<string>();
+  /** Keys being fetched — one request per picture however many URLs name it. */
   const pending = new Set<string>();
 
   function resolveUrl(raw: string): string {
@@ -32,19 +59,21 @@ export function useThumbs(apiBase: string | undefined, api: ThumbApiSlice) {
     return base && raw.startsWith('/') ? base + raw : raw;
   }
 
-  /** Reactive: returns the loaded object URL for the node's thumb, kicking off
-   *  the fetch on first sight. null = not (yet) available → show the icon. */
+  /** Reactive, per node: returns the loaded object URL for the node's thumb,
+   *  kicking off the fetch on first sight. null = not (yet) available → show
+   *  the icon. Only what read THIS node's key is woken when it arrives. */
   function src(n: FileNode): string | null {
     const raw = n.thumb_url;
-    if (!raw) return null;
-    const got = urls.value[raw];
+    const key = thumbKey(n);
+    if (!raw || !key) return null;
+    const got = cache.get(key);
     if (got) return got;
-    if (!failed.has(raw) && !pending.has(raw)) void load(raw);
+    if (!failed.has(raw) && !pending.has(key)) void load(raw, key);
     return null;
   }
 
-  async function load(raw: string): Promise<void> {
-    pending.add(raw);
+  async function load(raw: string, key: string): Promise<void> {
+    pending.add(key);
     try {
       const res = await fetch(resolveUrl(raw), {
         headers: await api.authHeaders({ Accept: '*/*' }),
@@ -53,22 +82,25 @@ export function useThumbs(apiBase: string | undefined, api: ThumbApiSlice) {
       if (!res.ok) throw new Error(String(res.status));
       const blob = await res.blob();
       if (order.length >= MAX_CACHED) {
+        // ⚠ Dropped without a word to the tile still showing it: woken, the
+        // tile would fetch it again, and that arrival would drop the next
+        // oldest — past MAX_CACHED thumbnails on screen, a loop that never
+        // ends. Its <img> has long loaded, and a loaded image outlives its
+        // revoked URL; a tile drawn later asks again, once.
         const evict = order.shift();
-        if (evict && urls.value[evict]) {
-          URL.revokeObjectURL(urls.value[evict]);
-          const next = { ...urls.value };
-          delete next[evict];
-          urls.value = next;
+        const store = toRaw(cache);
+        const old = evict ? store.get(evict) : undefined;
+        if (evict && old) {
+          URL.revokeObjectURL(old);
+          store.delete(evict);
         }
       }
-      order.push(raw);
-      urls.value = { ...urls.value, [raw]: URL.createObjectURL(blob) };
+      order.push(key);
+      cache.set(key, URL.createObjectURL(blob));
     } catch {
-      // 404 (thumb evicted server-side) or auth hiccup — icon fallback, and we
-      // don't retry within this session to avoid hammering.
       failed.add(raw);
     } finally {
-      pending.delete(raw);
+      pending.delete(key);
     }
   }
 

package/src/index.ts

@@ -32,6 +32,17 @@ export { default as StarButton } from './components/StarButton.vue';
 export { default as TagPicker } from './components/TagPicker.vue';
 export { default as TagKindIcon } from './components/TagKindIcon.vue';
 export { tagItemsOf, tagKey, isTagKind, type TagItem, type TagKind } from './lib/tags';
+export {
+  coverageByStorage,
+  coverageMessage,
+  coverageNotice,
+  coveragePercent,
+  incomplete as coverageIncomplete,
+  type CatalogCoverage,
+  type CoverageNotice,
+  type CoverageReason,
+  type StorageInfo,
+} from './lib/catalogCoverage';
 // tablo:t3 — the row's ONE action control ("Actions" / "Aksiyon"). DataTable
 // draws it for every table (`rowActions`); it stays exported for a host that
 // needs the same control outside a table. A second menu built beside
@@ -333,6 +344,10 @@ export type { NavApp } from './components/SideNav.vue';
 export { opPercent } from './lib/opProgress';
 export type { OpProgressLike } from './lib/opProgress';
 
+/* #48 — how an archive format is written (ZIP, TAR.GZ, 7z), for the explorer's
+ * create dialog and a host's own archive settings alike. */
+export { archiveFormatLabel } from './lib/archiveFormats';
+
 /* tasi:m1 — "download the selection as one archive". Exported so a host that
  * draws its own selection bar gets the real two-step flow (authorized mint,
  * then a navigation that streams) instead of reaching for window.open per

package/src/lib/actionIcons.ts

@@ -66,6 +66,12 @@ const GLYPHS: Record<string, string> = {
     '<path d="M9.5 4.5v5"/>',
   preview: EYE,
   download: TRAY + '<path d="M12 4v11.5"/><path d="M7.5 11L12 15.5 16.5 11"/>',
+  'archive-create':
+    '<path d="M5 8.5h14v11H5z"/><path d="M4 4h16v4.5H4z"/>' +
+    '<path d="M12 11v5"/><path d="M9.5 13.5h5"/>',
+  'archive-extract':
+    '<path d="M5 8.5h14v11H5z"/><path d="M4 4h16v4.5H4z"/>' +
+    '<path d="M12 10.5v6"/><path d="M9.5 14l2.5 2.5 2.5-2.5"/>',
   upload:
     '<path d="M4.5 15.5v3A2 2 0 0 0 6.5 20.5h11a2 2 0 0 0 2-2v-3"/>' +
     '<path d="M12 15.5V4"/><path d="M7.5 8.5L12 4l4.5 4.5"/>',

package/src/lib/archiveFormats.ts

@@ -0,0 +1,12 @@
+/**
+ * archiveFormatLabel — how an archive format is written wherever a person
+ * reads it: the create dialog, the admin Archives page, its provider cards.
+ *
+ * Upper case (ZIP, TAR.GZ, RAR), except 7z, which its own project writes in
+ * lower case. One rule in one place: the dialog wrote "7z" while the admin
+ * page wrote "7Z" for the same format (measured, 0.44.0 integration of #48).
+ */
+export function archiveFormatLabel(format: string): string {
+  const f = format.trim().toLowerCase();
+  return f === '7z' ? '7z' : f.toUpperCase();
+}

package/src/lib/archivePreviewCache.ts

@@ -0,0 +1,61 @@
+export interface CachedArchiveEntry {
+  name: string;
+  size: number;
+  mtime?: string;
+  is_dir?: boolean;
+}
+
+export interface ArchivePreviewCache {
+  recall(path: string): CachedArchiveEntry[] | undefined;
+  remember(path: string, entries: CachedArchiveEntry[]): void;
+  forget(path: string): void;
+  clear(): void;
+}
+
+export const ARCHIVE_PREVIEW_CACHE_TTL_MS = 2 * 60 * 1000;
+
+export function createArchivePreviewCache(
+  ttlMs = ARCHIVE_PREVIEW_CACHE_TTL_MS,
+  now: () => number = Date.now,
+): ArchivePreviewCache {
+  type Cached = {
+    entries: CachedArchiveEntry[];
+    expiresAt: number;
+    timer: ReturnType<typeof setTimeout>;
+  };
+  const values = new Map<string, Cached>();
+
+  function forget(path: string): void {
+    const cached = values.get(path);
+    if (cached) clearTimeout(cached.timer);
+    values.delete(path);
+  }
+
+  return {
+    recall(path) {
+      const cached = values.get(path);
+      if (!cached) return undefined;
+      if (cached.expiresAt <= now()) {
+        forget(path);
+        return undefined;
+      }
+      return cached.entries.map((entry) => ({ ...entry }));
+    },
+    remember(path, entries) {
+      forget(path);
+      const cached: Cached = {
+        entries: entries.map((entry) => ({ ...entry })),
+        expiresAt: now() + ttlMs,
+        timer: setTimeout(() => {
+          if (values.get(path) === cached) values.delete(path);
+        }, ttlMs),
+      };
+      values.set(path, cached);
+    },
+    forget,
+    clear() {
+      for (const cached of values.values()) clearTimeout(cached.timer);
+      values.clear();
+    },
+  };
+}

package/src/lib/catalogCoverage.ts

@@ -0,0 +1,137 @@
+/**
+ * catalogCoverage — how much of a storage its catalog covers, as the server
+ * says it, and the one set of rules every view draws that by.
+ *
+ * filex keeps a catalog of every storage, and search, folder sizes and drive
+ * usage are answered from it. While it does not cover a storage in full the
+ * server says so (docs/LAZY-CATALOGUE.md → "Coverage in the UI"):
+ *
+ *   - `first_scan`   — any storage whose first sync has not finished;
+ *   - `lazy_filling` — a lazily cataloged storage whose background pass is
+ *                      still going (behaviour A);
+ *   - `lazy_on_open` — a lazily cataloged storage that catalogs only the
+ *                      folders people open (behaviour B).
+ *
+ * The listing and search responses carry it per storage in `storage_info`,
+ * drive usage per row. A folder row whose own size leaves something out
+ * carries `size_partial` (see useLocale `formatNodeSize`).
+ *
+ * ⚠ One module for the whole explorer: the banner over a listing, the banner
+ * over search results and Home's drive cards read the SAME object through the
+ * SAME rules, so they cannot tell a person two different things about one
+ * storage.
+ */
+
+/** Why a storage's catalog is not complete. */
+export type CoverageReason = 'first_scan' | 'lazy_filling' | 'lazy_on_open';
+
+/** The server's `coverage` object (sync.CatalogueCoverage). */
+export interface CatalogCoverage {
+  complete: boolean;
+  reason?: CoverageReason | string;
+  /** `lazy` for a lazily cataloged storage. */
+  mode?: string;
+  /** The lazy behaviour: `background` (A) or `on_open` (B). */
+  fill?: string;
+  catalogued_folders?: number;
+  pending_folders?: number;
+  watched_folders?: number;
+  max_watches?: number;
+  filler?: string;
+  held_back_folders?: number;
+  reconciles?: number;
+}
+
+/** One entry of a listing's `storage_info`. */
+export interface StorageInfo {
+  name: string;
+  read_only?: boolean;
+  coverage?: CatalogCoverage | null;
+}
+
+/** A coverage object worth telling anybody about, or null. */
+export function incomplete(c: CatalogCoverage | null | undefined): CatalogCoverage | null {
+  if (!c || typeof c !== 'object' || c.complete === true) return null;
+  return c;
+}
+
+/**
+ * The share of the folders found so far that are cataloged, 0–99 while any
+ * is still waiting (a floor, so "100%" is never shown beside a notice that
+ * says the work is not done).
+ */
+export function coveragePercent(c: CatalogCoverage): number {
+  const done = Math.max(0, c.catalogued_folders ?? 0);
+  const pending = Math.max(0, c.pending_folders ?? 0);
+  if (done + pending === 0) return 0;
+  const pct = Math.floor((done * 100) / (done + pending));
+  return pending > 0 ? Math.min(pct, 99) : pct;
+}
+
+/** The sentence one storage's coverage is told in: a catalog key and its values. */
+export function coverageMessage(c: CatalogCoverage): { key: string; vars: Record<string, number> } {
+  switch (c.reason) {
+    case 'lazy_on_open':
+      return { key: 'coverage.lazy_on_open', vars: {} };
+    case 'lazy_filling':
+      return { key: 'coverage.lazy_filling', vars: { pct: coveragePercent(c) } };
+    default:
+      return { key: 'coverage.first_scan', vars: {} };
+  }
+}
+
+/** `storage_info` → storage name → its incomplete coverage (null = complete). */
+export function coverageByStorage(info: unknown): Record<string, CatalogCoverage | null> {
+  const out: Record<string, CatalogCoverage | null> = {};
+  if (!Array.isArray(info)) return out;
+  for (const row of info as StorageInfo[]) {
+    if (!row || typeof row.name !== 'string' || row.name === '') continue;
+    out[row.name] = incomplete(row.coverage ?? null);
+  }
+  return out;
+}
+
+/** What the banner over a listing or a search says, and whether it offers an action. */
+export interface CoverageNotice {
+  key: string;
+  vars: Record<string, string | number>;
+  /** The storage the notice is about, when it is about one. */
+  storage?: string;
+  /** Offer "Catalog everything" (an administrator, behaviour B). */
+  offerCatalogAll: boolean;
+}
+
+/**
+ * The notice for what is on screen.
+ *
+ *   - A listing, or a search inside one storage: that storage's coverage.
+ *   - A search that spans every storage (the server searches them all when
+ *     the query is typed at a storage's root and there is more than one):
+ *     the names of the ones not fully cataloged.
+ *
+ * `admin` decides the action only; everybody reads the same sentence.
+ */
+export function coverageNotice(opts: {
+  map: Record<string, CatalogCoverage | null>;
+  adapter: string;
+  searching: boolean;
+  crossStorage: boolean;
+  admin: boolean;
+}): CoverageNotice | null {
+  const { map, adapter, searching, crossStorage, admin } = opts;
+  if (searching && crossStorage) {
+    const names = Object.keys(map)
+      .filter((n) => map[n] !== null)
+      .sort((a, b) => a.localeCompare(b));
+    if (names.length === 0) return null;
+    if (names.length === 1) return single(names[0], map[names[0]] as CatalogCoverage, admin);
+    return { key: 'coverage.search_some', vars: { names: names.join(', ') }, offerCatalogAll: false };
+  }
+  const c = map[adapter];
+  return c ? single(adapter, c, admin) : null;
+}
+
+function single(storage: string, c: CatalogCoverage, admin: boolean): CoverageNotice {
+  const m = coverageMessage(c);
+  return { key: m.key, vars: m.vars, storage, offerCatalogAll: admin && c.reason === 'lazy_on_open' };
+}

package/src/lib/nearViewport.ts

@@ -0,0 +1,77 @@
+/**
+ * whenNearViewport — call `cb` once `el` comes within NEAR of the viewport.
+ *
+ * A folder view puts every tile on the page at once, and a thumbnail is a
+ * request: a folder of 344 files asked for ~240 of them the moment it opened,
+ * most for tiles nobody had scrolled to. ThumbTile asks only once this says
+ * its tile is close.
+ *
+ * ONE IntersectionObserver for the page, not one per tile, and each element is
+ * heard once and then forgotten. With a null root it watches the viewport, and
+ * a tile hidden by the scroll box it sits in (the explorer's pane scrolls on
+ * its own) does not count as near. Where IntersectionObserver does not exist
+ * (an old engine, a test DOM) every element counts as near at once — which is
+ * how every tile behaved before.
+ */
+
+/** How far outside the viewport a tile already counts as near: a thumbnail
+ *  should be on its way before the tile scrolls in, not after. */
+const NEAR = '300px';
+
+let io: IntersectionObserver | null = null;
+const waiting = new Map<Element, Set<() => void>>();
+
+function observer(): IntersectionObserver {
+  if (!io) {
+    io = new IntersectionObserver(
+      (entries) => {
+        for (const e of entries) {
+          if (!e.isIntersecting) continue;
+          const cbs = waiting.get(e.target);
+          if (!cbs) continue;
+          waiting.delete(e.target);
+          io?.unobserve(e.target);
+          cbs.forEach((cb) => cb());
+        }
+      },
+      // `rootMargin` widens the viewport only: a tile in the pane's own scroll
+      // box is still cut off at that box's edge. `scrollMargin` widens the
+      // scroll boxes too (Chromium 120+; an engine that does not know it
+      // ignores it, and the picture is asked for as the tile scrolls in).
+      { rootMargin: NEAR, scrollMargin: NEAR } as IntersectionObserverInit,
+    );
+  }
+  return io;
+}
+
+/** Call `cb` once `el` is near the viewport. Returns a function that cancels
+ *  the wait (call it when the element goes away first). */
+export function whenNearViewport(el: Element | null | undefined, cb: () => void): () => void {
+  if (!el || typeof IntersectionObserver === 'undefined') {
+    cb();
+    return () => {};
+  }
+  let cbs = waiting.get(el);
+  if (!cbs) {
+    cbs = new Set();
+    waiting.set(el, cbs);
+    observer().observe(el);
+  }
+  cbs.add(cb);
+  return () => {
+    const set = waiting.get(el);
+    if (!set) return;
+    set.delete(cb);
+    if (set.size === 0) {
+      waiting.delete(el);
+      io?.unobserve(el);
+    }
+  };
+}
+
+/** Tests only: drop the shared observer so the next wait builds a fresh one. */
+export function __resetNearViewport(): void {
+  io?.disconnect();
+  io = null;
+  waiting.clear();
+}

package/src/locales/en.ts

@@ -12,6 +12,8 @@ export const en: Record<string, string> = {
   'ctx.open': 'Open',
   'ctx.preview': 'Preview',
   'ctx.download': 'Download',
+  'ctx.archive_create': 'Create archive…',
+  'ctx.archive_extract': 'Extract archive…',
   'ctx.convert': 'Convert',
   'ctx.rename': 'Rename',
   'ctx.delete': 'Delete',
@@ -57,6 +59,51 @@ export const en: Record<string, string> = {
   'modal.newfolder.cancel': 'Cancel',
 
   'modal.share.title': 'Share link',
+  'archive.create_title': 'Create archive',
+  'archive.extract_title': 'Extract archive',
+  'archive.create_count': '{count} selected items',
+  'archive.create_count_one': '{count} selected item',
+  'archive.filename': 'Archive name',
+  'archive.format': 'Format',
+  'archive.password_optional': 'Password (optional)',
+  'archive.password_confirm': 'Confirm password',
+  'archive.password_mismatch': 'Passwords do not match.',
+  'archive.encrypt_names': 'Encrypt file names',
+  'archive.compression': 'Compression',
+  'archive.solid': 'Create solid archive',
+  'archive.dictionary_size': 'Dictionary size',
+  'archive.dictionary_size_value': '{n} MiB',
+  'archive.dictionary_hint': 'Larger dictionaries can improve compression but use more memory while creating and extracting.',
+  'archive.destination_folder': 'Extract to folder',
+  'archive.create': 'Create',
+  'archive.creating': 'Creating…',
+  'archive.extract': 'Extract',
+  'archive.extract_here': 'Extract here',
+  'archive.extract_to_folder': 'Extract to folder',
+  'archive.extracting': 'Extracting…',
+  'archive.cancel': 'Cancel',
+  'archive.invalid_name': 'Enter a file name without slashes.',
+  'archive.invalid_extension': 'Archive name must use one of the available format extensions.',
+  'archive.invalid_folder': 'Enter a folder name without slashes.',
+  'archive.password_required': 'This archive requires a password.',
+  'archive.password_title': 'Archive password',
+  'archive.continue': 'Continue',
+  'archive.opening': 'Opening…',
+  'archive.bad_password': 'The archive password is incorrect.',
+  'archive.target_exists': 'An item with that name already exists. Choose another name or remove it first.',
+  'archive.password_charset': 'A ZIP password can use only ASCII characters: unaccented letters, digits and ordinary punctuation. Choose 7z to use any characters.',
+  'archive.error_unsupported': 'This archive cannot be extracted: this server cannot read its format, or it holds something filex does not extract (a link, a special file, or a file whose size it does not state).',
+  'archive.error_limit': 'This archive is larger than the server allows to extract.',
+  'archive.error_unavailable': 'This server cannot open this kind of archive right now.',
+  'archive.created': 'Archive created',
+  'archive.queued': 'Archive creation is running in the background',
+  'archive.extracted': 'Extracted {count} files',
+  'archive.extracted_one': 'Extracted {count} file',
+  'archive.extraction_queued': 'Archive extraction is running in the background',
+  'archive.extraction_completed': 'Extraction completed',
+  'archive.extraction_cancelled': 'Extraction cancelled after {count} files',
+  'archive.extraction_cancelled_one': 'Extraction cancelled after {count} file',
+
   'modal.share.pin': 'PIN protected',
   'modal.share.expires': 'Expires at',
   'modal.share.max_downloads': 'Download limit',
@@ -169,6 +216,9 @@ export const en: Record<string, string> = {
   'viewer.archive.error': 'Could not read archive contents.',
   'viewer.archive.unsupported': 'This kind of archive cannot be listed here. Download it to see what is inside.',
   'viewer.archive.too_large': 'This archive is too large to list here. Download it to see what is inside.',
+  'viewer.archive.open': 'Open archive',
+  'viewer.archive.root': 'Archive',
+  'viewer.archive.location': 'Archive location',
   'viewer.name': 'Name',
   'viewer.size': 'Size',
 
@@ -314,6 +364,19 @@ export const en: Record<string, string> = {
   'search.in_content': 'In content',
   'search.truncated': 'More results than shown — narrow your search',
 
+  /* Catalog coverage (docs/LAZY-CATALOGUE.md, lib/catalogCoverage). One
+     sentence per reason; the banner sits over a listing and over search
+     results, and says what is left out and why. */
+  'coverage.first_scan': 'This storage’s first sync has not finished. Until it does, search, folder sizes and usage leave part of it out.',
+  'coverage.lazy_filling': 'filex is still cataloging this storage ({pct}% of the folders found so far). Until it finishes, search, folder sizes and usage leave part of it out.',
+  'coverage.lazy_on_open': 'Only the folders people open on this storage are cataloged. Search, folder sizes and usage cover those folders only.',
+  'coverage.search_some': 'Not everything on these storages is cataloged yet: {names}. This search may miss files there.',
+  'coverage.catalog_all': 'Catalog everything',
+  'coverage.catalog_started': 'Sync started — the whole storage is being cataloged.',
+  'size.at_least': '≥ {size}',
+  'size.partial_hint': 'Part of this folder is not cataloged yet, so its size is at least this.',
+  'size.unknown_hint': 'This folder is not cataloged yet, so its size is not known.',
+
   /* === bag:b4 === */
   'toolbar.more': 'More actions',
   'toolbar.search.close': 'Close search',
@@ -461,6 +524,7 @@ export const en: Record<string, string> = {
   'opc.retry': 'Retry',
   'opc.dismiss': 'Dismiss',
   'opc.queued': 'Queued',
+  'opc.cancelling': 'Cancel requested…',
   'opc.percent': '{n}%',
   'opc.status.running': 'In progress',
   'opc.status.done': 'Done',
@@ -677,6 +741,8 @@ export const en: Record<string, string> = {
   'plugin.pdf.date_order': 'Date order',
   'plugin.pdf.date_separator': 'Separator',
   'plugin.pdf.date_example': 'Example',
+  'opc.kind.archive-create': 'Creating archive',
+  'opc.kind.archive-extract': 'Extracting archive',
   /* === wiring:c4 — onboarding tour + accessibility + error card === */
   'tour.aria': 'Onboarding tour',
   'tour.restart': 'Restart the tour',
@@ -1392,6 +1458,7 @@ export const en: Record<string, string> = {
   '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.used_partial': 'at least {used} used',
   'drive.storage.label': 'Storage',
   /* === gorunum:v3-shell — the Home view (the overview, inside the shell) ==
    * The section headings are `sidenav.storages` / `sidenav.recent` /