@brftech/filex-core 0.42.1 → 0.43.0

package/src/composables/useLocale.ts

@@ -27,14 +27,41 @@
 
 import { computed, getCurrentInstance, inject, type Ref } from 'vue';
 import type { LocaleCode } from '../types/ExplorerConfig';
-import { messages } from '../locales';
+import { localeOwnTable, localesVersion, type OwnLocaleTable } from '../lib/uiLocales';
+import { pluralCategory } from '../lib/plural';
+// ⚠ The table itself, not `../locales` (its index re-exports `locales/resolve`,
+// which reads `lib/uiLocales` — the cycle uiLocales avoids the same way).
+import { en as EN } from '../locales/en';
+import { foreignText, isolateLtrRuns, isolateValue, localeDir } from '../lib/direction';
 import { EXPLORER_CLOCK, activeTimeZoneFor, deviceTimeZone } from '../lib/timezone';
 
 /* ── the tag ──────────────────────────────────────────────────────────── */
 
-/** The BCP-47 tag a catalogue code means. ONE mapping, for every surface. */
+/**
+ * The BCP-47 tag a catalogue code means. ONE mapping, for every surface.
+ *
+ * ⚠ `tr` → `tr-TR` and `en` (or nothing) → `en-US` are pinned — the two
+ * catalogues the product ships, and what every date and size on screen has
+ * been measured against. Every OTHER code is a language pack's, and it is
+ * its own tag: it used to fall through to `en-US`, so a Spanish interface
+ * printed "Sep 12, 2026, 3:25 PM" beside Spanish words (measured 2026-09-21).
+ * A pack that needs a region's conventions names itself with the region
+ * (`es-mx`, `pt-br`) and gets them; `Intl` canonicalises the case.
+ */
+const tagCache = new Map<string, string>();
 export function localeTag(code: LocaleCode | string | undefined): string {
-  return code === 'tr' ? 'tr-TR' : 'en-US';
+  if (!code || code === 'en') return 'en-US';
+  if (code === 'tr') return 'tr-TR';
+  let tag = tagCache.get(code);
+  if (!tag) {
+    try {
+      tag = Intl.getCanonicalLocales(code)[0] || 'en-US';
+    } catch {
+      tag = 'en-US';
+    }
+    tagCache.set(code, tag);
+  }
+  return tag;
 }
 
 /* ── bytes ────────────────────────────────────────────────────────────── */
@@ -110,9 +137,11 @@ export interface ByteSizeOptions {
  *     back as "10 GB" and a stored volume matches the invoice beside it.
  *
  * `base: 1024` exists for exactly one reason: mirroring a number some other
- * program already printed. Today that is the share message, which has to read
- * like `humanSize()` in backend/internal/api/handlers/mail_templates.go.
- * That is an argument to this function, not a fifth copy of it.
+ * program already printed. Nothing in the product needs it today — the share
+ * message used it to copy the server's e-mail (`humanSize()`, base 1024), and
+ * the server writes sizes by THESE rules now (backend/internal/srvtext
+ * `Bytes`), so the message, the mail and the listing say one thing. If a
+ * mirror is ever needed again it is an argument here, not a fifth copy.
  */
 export function formatByteSize(
   bytes: number | null | undefined,
@@ -215,6 +244,37 @@ export function formatInstant(
   }
 }
 
+const DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+const dayFormatters = new Map<string, Intl.DateTimeFormat>();
+
+/**
+ * A calendar DAY (`YYYY-MM-DD`) for a human: the same words formatDate's date
+ * part prints ("29 Eyl 2026"), but read as that day, not as an instant — it is
+ * formatted in UTC, so no viewer's time zone can move a due date to the day
+ * before. '' for anything that is not such a day.
+ *
+ * ⚠ Here, beside formatInstant, because this file is the home of "a date for
+ * a human" (web/tests/quality/duplication.test.ts, `datetime-format`): an
+ * app's date column (lib/surfaceCell) must not grow a formatter of its own.
+ */
+export function formatCalendarDay(day: string, code: LocaleCode | string | undefined): string {
+  const m = DAY.exec(day.trim());
+  if (!m) return '';
+  const d = new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])));
+  if (Number.isNaN(d.getTime())) return '';
+  const tag = localeTag(code);
+  let fmt = dayFormatters.get(tag);
+  try {
+    if (!fmt) {
+      fmt = new Intl.DateTimeFormat(tag, { month: 'short', day: 'numeric', year: 'numeric', timeZone: 'UTC' });
+      dayFormatters.set(tag, fmt);
+    }
+    return fmt.format(d);
+  } catch {
+    return '';
+  }
+}
+
 /** Seconds or milliseconds — the backend has sent both. Normalised once. */
 function toDate(ms: number | undefined | null): Date | null {
   if (!ms) return null;
@@ -222,6 +282,67 @@ function toDate(ms: number | undefined | null): Date | null {
   return Number.isNaN(d.getTime()) ? null : d;
 }
 
+/** Anything a date arrives as: epoch seconds or milliseconds, an ISO string,
+ *  a Date. Null for nothing or for something that is not an instant. */
+export type WhenInput = number | string | Date | null | undefined;
+
+function instantOf(value: WhenInput): Date | null {
+  if (value == null || value === '') return null;
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  if (typeof value === 'number') return toDate(value);
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+const DATE_PART: Intl.DateTimeFormatOptions = { month: 'short', day: 'numeric', year: 'numeric' };
+// ⚠ The clock is the LANGUAGE's short time, not a field list: `hour: 'numeric'`
+//   printed Turkish "8:05" where Turkish writes "08:05", and `'2-digit'` would
+//   print English "08:05 AM". Only noticed on CI: its zone is UTC, so the
+//   test's 08:05Z stayed before ten there and became 11:05 at +3 (2026-09-24).
+const TIME_PART: Intl.DateTimeFormatOptions = { timeStyle: 'short' };
+
+/**
+ * An instant as a person reads it — THE date format of the product: the
+ * explorer's, "Sep 21, 2026, 2:50 PM" / "21 Eyl 2026, 14:50", in the viewer's
+ * language and on the viewer's chosen clock. `time: true` adds the clock.
+ *
+ * ⚠⚠ One definition for every surface (QA, 2026-09-21): the explorer printed
+ * "21 Eyl 2026, 14:50", the admin tables and the share dialog "21 Eyl 2026
+ * 15:02" (a `dateStyle: 'medium'` pair and a `day: '2-digit', hour: '2-digit'`
+ * set of their own), and English times read "2:50 PM" on one screen and
+ * "02:51 PM" on the next. The admin panel's `formatDate`, `useLocale`'s
+ * `formatDate` and the share lines all call this now; nothing else builds a
+ * date formatter for a person to read (scripts/dup-scan.mjs, `datetime-format`).
+ */
+export function formatWhen(
+  value: WhenInput,
+  code: LocaleCode | string | undefined,
+  opts: { time?: boolean } = {},
+  /** The explorer whose clock applies (EXPLORER_CLOCK); omitted = page-wide. */
+  owner?: symbol,
+): string {
+  const d = instantOf(value);
+  if (!d) return '';
+  const date = formatInstant(d, code, DATE_PART, owner);
+  return opts.time ? `${date}, ${formatInstant(d, code, TIME_PART, owner)}` : date;
+}
+
+/**
+ * The whole truth, for a tooltip behind a short date: full date, seconds, the
+ * zone's name AND its IANA id — "whose 14:05 is this?" answered. The IANA id
+ * rides along because half the world's zones display as "GMT+3".
+ */
+export function formatWhenFull(
+  value: WhenInput,
+  code: LocaleCode | string | undefined,
+  owner?: symbol,
+): string {
+  const d = instantOf(value);
+  if (!d) return '';
+  const zone = activeTimeZoneFor(owner) ?? deviceTimeZone();
+  return `${formatInstant(d, code, { dateStyle: 'full', timeStyle: 'long' }, owner)} (${zone})`;
+}
+
 /* ── counted messages ─────────────────────────────────────────────────── */
 
 /**
@@ -231,8 +352,14 @@ function toDate(ms: number | undefined | null): Date | null {
 export const COUNT_VARS = ['count', 'n', 'days'] as const;
 
 /**
- * Which catalogue key a counted message reads: `key_one` when the count is
- * exactly one and the catalogue has that form, otherwise `key`.
+ * Which key of ONE table a counted message reads: `key_<category>` when the
+ * count falls in a category other than `other` in `lang` (CLDR, via
+ * `lib/plural`) and the table has that form, otherwise the plain `key` — which
+ * IS the `other` form (there is no `_other` key).
+ *
+ * The forms: `_zero`, `_one`, `_two`, `_few`, `_many`. A language writes the
+ * ones it has — English and Turkish `_one`, Russian `_one` `_few` `_many`,
+ * Arabic all five — and never `_other`.
  *
  * ⚠⚠ ONE rule, here, for every counted string in the package. The catalogue
  * is a flat table with no plural machinery, so a `{n} items` message printed
@@ -242,43 +369,162 @@ export const COUNT_VARS = ['count', 'n', 'days'] as const;
  * and the empty-trash confirmation); every other counted message had not, and
  * a few hedged with "item(s)". A rule each caller has to remember is a rule
  * the next caller forgets, so `t()` applies it and the catalogue only has to
- * SAY the singular.
+ * SAY the forms.
+ *
+ * ⚠ Until v0.43.0 the rule was English's alone ("`_one` for exactly 1"),
+ * which no language with few/many can be written in — the Arabic pack could
+ * not say "2 files" at all.
  *
  * ⚠ Turkish does not inflect a noun after a number ("1 öğe", "5 öğe"), so its
  * `_one` entries read exactly like the plain ones. They exist for key parity,
- * not because the language needs them. `web/tests/i18n/corePlurals.test.ts`
+ * not because the language needs them. `web/tests/i18n/plurals.test.ts`
  * fails an English counted message that has no singular.
+ *
+ * `lang` defaults to English — the rule this function had before it had the
+ * argument. `t()` does not call this on a merged table; see `pickMessage`.
  */
 export function countedKey(
   key: string,
   vars: Record<string, string | number>,
   has: (key: string) => boolean,
+  lang = 'en',
 ): string {
   const counter = COUNT_VARS.find((v) => v in vars);
-  if (counter === undefined || Number(vars[counter]) !== 1) return key;
-  const one = `${key}_one`;
-  return has(one) ? one : key;
+  if (counter === undefined) return key;
+  const cat = pluralCategory(lang, Number(vars[counter]));
+  if (cat === 'other') return key;
+  const form = `${key}_${cat}`;
+  return has(form) ? form : key;
+}
+
+/** A catalogue value, or undefined — never an `Object.prototype` member. */
+function entry(table: Readonly<Record<string, string>>, key: string): string | undefined {
+  const v = table[key];
+  return typeof v === 'string' && v ? v : undefined;
+}
+
+/**
+ * The raw (uninterpolated) message a key reads in a language.
+ *
+ *   1. the form the count's category calls for, if the language WROTE it;
+ *   2. else the language's own plain `key` (its `other` form);
+ *   3. else English as a whole — English's form by English's rule
+ *      (`key_one` for 1), then English's plain `key`;
+ *   4. else the key itself.
+ *
+ * ⚠⚠ Step 2 before step 3, and `own` must be the language's OWN words
+ * (`localeOwnTable`), not the English-under-pack merge (`localeTable`). With
+ * the merge, a Spanish pack that wrote only `toast.restored` still "had"
+ * `toast.restored_one` — the English one underneath — and a count of one
+ * printed "1 item restored" in the middle of a Spanish screen. A language's
+ * own plain form, even if it reads as a plural for 1, is its translator's
+ * choice; an English word in its place is nobody's.
+ */
+export function pickMessage(
+  own: OwnLocaleTable,
+  key: string,
+  vars: Record<string, string | number> = {},
+): string {
+  const mine = own.strings;
+  const form = countedKey(key, vars, (k) => entry(mine, k) !== undefined, own.lang);
+  const said = entry(mine, form) ?? entry(mine, key);
+  if (said !== undefined) return said;
+  if (mine === EN) return key;
+  const enForm = countedKey(key, vars, (k) => entry(EN, k) !== undefined, 'en');
+  return entry(EN, enForm) ?? entry(EN, key) ?? key;
+}
+
+/** `{name}` placeholders, replaced verbatim. */
+function interpolate(raw: string, vars: Record<string, string | number>): string {
+  return Object.entries(vars).reduce(
+    (acc, [k, v]) => acc.replaceAll(`{${k}}`, String(v)),
+    raw,
+  );
 }
 
-export function useLocale(localeRef: Ref<LocaleCode> | (() => LocaleCode)) {
-  const code = (): LocaleCode =>
+/**
+ * One message, rendered: the plural form picked on the ORIGINAL vars (a count
+ * wrapped in isolation marks is no longer a number to pick on), the values
+ * put in, and — RTL only — a name interpolated into the sentence isolated so
+ * its own letters decide its direction (`isolateValue`, strings only), and a
+ * `3 / 10` or a `tag:…` kept reading left to right (`isolateLtrRuns`). A
+ * left-to-right string comes back exactly as it always did.
+ *
+ * ⚠ The one path for `t()` and `translate()`, so a sentence built outside a
+ * component (lib/shareTtl) reads the same way under Arabic as one inside.
+ */
+function render(
+  table: OwnLocaleTable,
+  key: string,
+  vars: Record<string, string | number>,
+  rtl: boolean,
+): string {
+  const raw = pickMessage(table, key, vars);
+  if (!rtl) return interpolate(raw, vars);
+  const isolated: Record<string, string | number> = {};
+  for (const [k, v] of Object.entries(vars)) isolated[k] = typeof v === 'string' ? isolateValue(v) : v;
+  return isolateLtrRuns(interpolate(raw, isolated));
+}
+
+/**
+ * `t()` for code that is not a component (`lib/shareTtl`): the same lookup,
+ * the same plural rule, the same placeholders. ⚠ Not reactive — a caller that
+ * renders the result in a template must read `localesVersion` itself.
+ */
+export function translate(
+  code: LocaleCode | string | undefined,
+  key: string,
+  vars: Record<string, string | number> = {},
+): string {
+  return render(localeOwnTable(code), key, vars, localeDir(code) === 'rtl');
+}
+
+export function useLocale(
+  /**
+   * ⚠ Widened past `LocaleCode` on purpose (v3 §5). The list of languages
+   * the interface offers is no longer the two this package ships: an app
+   * plugin may add one (`lib/uiLocales`), so the active code can be a tag
+   * this file has never heard of. It resolves through `localeOwnTable`, and
+   * every key the language does not have reads English.
+   */
+  localeRef: Ref<LocaleCode | string> | (() => LocaleCode | string),
+) {
+  const code = (): string =>
     typeof localeRef === 'function' ? localeRef() : localeRef.value;
 
-  const lookup = computed(() => messages[code()] ?? messages.en);
+  /**
+   * ⚠ `localesVersion` is READ here so the table is re-derived when an app
+   * installs or removes a language. Without it a screen already on the page
+   * would keep the table it was mounted with — an app's own words would
+   * arrive one navigation late, which is the kind of miss nobody reports as
+   * a bug and everybody works around.
+   */
+  const lookup = computed(() => {
+    void localesVersion.value;
+    return localeOwnTable(code());
+  });
 
   // The explorer this component sits in, whose clock its dates are read on
   // (lib/timezone, timeZoneSourcesFor). Outside a component, or outside any
   // explorer, the page-wide answer.
   const clock = getCurrentInstance() ? inject(EXPLORER_CLOCK, undefined) : undefined;
 
+  /** ⚠ RTL — which way this surface's language is written (lib/direction). */
+  const dir = computed(() => localeDir(code()));
+
   function t(key: string, vars: Record<string, string | number> = {}): string {
-    const table = lookup.value;
-    const raw = table[countedKey(key, vars, (k) => k in table)] ?? key;
-    return Object.entries(vars).reduce(
-      (acc, [k, v]) => acc.replaceAll(`{${k}}`, String(v)),
-      raw,
-    );
+    return render(lookup.value, key, vars, dir.value === 'rtl');
   }
+  /**
+   * ⚠⚠ Text filex did NOT write, said the way this surface's language needs:
+   * the server's own sentence, an installed app's words, a notification built
+   * from what happened. None of it passes through `t()`, so none of it was
+   * isolated — see lib/direction `foreignText`. It rides ON `t` so that the
+   * helpers a component hands its translator to (lib/errorWords `sayFailure`,
+   * `jobFailure`, `opFailure`) get the reader's direction without five more
+   * signatures to thread a locale code through.
+   */
+  t.foreign = (text: string): string => foreignText(code(), text);
 
   /** A byte count in the viewer's language and number format. */
   function formatSize(bytes: number | undefined | null): string {
@@ -328,20 +574,7 @@ export function useLocale(localeRef: Ref<LocaleCode> | (() => LocaleCode)) {
    * device's zone, resolved live by Intl rather than frozen at first run.
    */
   function formatDate(ms: number | undefined | null, opts: { time?: boolean } = {}): string {
-    const d = toDate(ms);
-    if (!d) return '';
-    const date = formatInstant(
-      d,
-      code(),
-      {
-        month: 'short',
-        day: 'numeric',
-        year: 'numeric',
-      },
-      clock,
-    );
-    if (!opts.time) return date;
-    return `${date}, ${formatInstant(d, code(), { hour: 'numeric', minute: '2-digit' }, clock)}`;
+    return formatWhen(ms, code(), opts, clock);
   }
 
   /**
@@ -356,11 +589,7 @@ export function useLocale(localeRef: Ref<LocaleCode> | (() => LocaleCode)) {
    * zones render as "GMT+3".
    */
   function formatDateFull(ms: number | undefined | null): string {
-    const d = toDate(ms);
-    if (!d) return '';
-    const zone = activeTimeZoneFor(clock) ?? deviceTimeZone();
-    const stamp = formatInstant(d, code(), { dateStyle: 'full', timeStyle: 'long' }, clock);
-    return `${stamp} (${zone})`;
+    return formatWhenFull(ms, code(), clock);
   }
 
   /**
@@ -414,5 +643,12 @@ export function useLocale(localeRef: Ref<LocaleCode> | (() => LocaleCode)) {
      */
     toDate,
     nodeDisplayName,
+    /**
+     * ⚠ RTL — which way this surface's language is written (`lib/direction`,
+     * the server's one list). Bind it as `dir` on anything Teleported out of
+     * the explorer's root: under `<body>` a menu inherits the HOST page's
+     * direction, not the language its own words are in.
+     */
+    dir,
   };
 }

package/src/composables/useNFSExports.ts

@@ -11,6 +11,7 @@ import type { ExplorerConfig } from '../types/ExplorerConfig';
 import type { NFSConnection, NFSExport, NFSExportCreated } from '../types/NFSExports';
 import { connectionsBase } from './useConnections';
 import { useFileApi } from './useFileApi';
+import { serverWords } from '../lib/errorWords';
 
 export function useNFSExports(config: ExplorerConfig) {
   const api = useFileApi(config);
@@ -26,17 +27,14 @@ export function useNFSExports(config: ExplorerConfig) {
   /** The path, held only while the user is looking at it. */
   const revealed = ref<NFSExportCreated | null>(null);
 
+  /** A refusal, said — lib/errorWords `serverWords`, the one rule every
+   *  connection panel shares (it used to print the server's `error` field as
+   *  it came: an environment variable, to a regular user). ⚠ The locale is
+   *  passed because what comes back may be the SERVER's own sentence: it
+   *  never met a translator, and an Arabic panel needs its machine runs
+   *  isolated (lib/direction `foreignText`). */
   function messageOf(e: unknown): string {
-    const err = e as { message?: string; detail?: string } | null;
-    if (err?.detail) {
-      try {
-        const parsed = JSON.parse(err.detail) as { error?: string };
-        if (parsed?.error) return parsed.error;
-      } catch {
-        /* not JSON */
-      }
-    }
-    return err?.message || String(e);
+    return serverWords(e, config.locale);
   }
 
   function statusOf(e: unknown): number | undefined {

package/src/composables/useOperations.ts

@@ -25,7 +25,9 @@
 
 import { computed, getCurrentScope, onScopeDispose, ref } from 'vue';
 
-export type OperationKind = 'upload' | 'copy' | 'move' | 'delete' | 'convert' | 'archive';
+/** `plugin` — an app-plugin job (docs/APP-PLUGINS-API.md); also what any
+ *  queue kind this package has no drawing for is shown as. */
+export type OperationKind = 'upload' | 'copy' | 'move' | 'delete' | 'convert' | 'archive' | 'plugin' | 'trash';
 export type OperationStatus = 'running' | 'done' | 'error' | 'aborted';
 
 /** What a publisher hands to `sync()` for one row. */
@@ -38,7 +40,11 @@ export interface OperationInput {
   /** 0..100, or null for indeterminate (renderer shows a spinner). */
   percent: number | null;
   status: OperationStatus;
+  /** The failure, SAID (lib/errorWords) — never a raw server string. */
   error?: string | null;
+  /** The raw words behind it — set only for a caller who administers the
+   *  instance; drawn as a second line under the sentence. */
+  errorDetail?: string | null;
   /** Queue op accepted but not started yet ("Queued"). */
   queued?: boolean;
   /** Progress counters for queue ops (3/5 items). */
@@ -49,6 +55,20 @@ export interface OperationInput {
   totalBytes?: number;
   cancellable?: boolean;
   retryable?: boolean;
+  /** A plugin job's last progress message — shown under the name while it runs. */
+  message?: string | null;
+  /** Files a finished job produced (adapter-qualified paths); the row offers "Open". */
+  outputs?: string[];
+  /**
+   * An app-plugin job's output mode — `sibling` (a new file beside the
+   * original) or `version` (the same file, a new version of it).
+   *
+   * ⚠ It is on the row because the two are indistinguishable once the job
+   * lands: "Open" navigates to `outputs[0]`, which in `version` mode IS the
+   * input the person started from, so without the chip the tray reads as if
+   * nothing was produced. Absent for every other kind.
+   */
+  outputMode?: string | null;
 }
 
 export interface OperationActions {
@@ -56,6 +76,8 @@ export interface OperationActions {
   /** Clean the row out of the OWNING source list (called on retire/dismiss). */
   dismiss?: () => void;
   retry?: () => void;
+  /** Reveal one of the row's outputs in the listing. */
+  open?: (path: string) => void;
 }
 
 export interface Operation {
@@ -66,6 +88,7 @@ export interface Operation {
   percent: number | null;
   status: OperationStatus;
   error: string | null;
+  errorDetail: string | null;
   queued: boolean;
   doneCount: number | null;
   totalCount: number | null;
@@ -73,6 +96,9 @@ export interface Operation {
   totalBytes: number | null;
   cancellable: boolean;
   retryable: boolean;
+  message: string | null;
+  outputs: string[];
+  outputMode: string | null;
   startedAt: number;
   settledAt: number | null;
 }
@@ -89,6 +115,7 @@ function toOperation(key: string, input: OperationInput, prev?: Operation): Oper
     percent: input.percent,
     status: input.status,
     error: input.error ?? null,
+    errorDetail: input.errorDetail ?? null,
     queued: input.queued ?? false,
     doneCount: input.doneCount ?? null,
     totalCount: input.totalCount ?? null,
@@ -96,6 +123,9 @@ function toOperation(key: string, input: OperationInput, prev?: Operation): Oper
     totalBytes: input.totalBytes ?? null,
     cancellable: input.cancellable ?? false,
     retryable: input.retryable ?? false,
+    message: input.message ?? null,
+    outputs: input.outputs ?? [],
+    outputMode: input.outputMode ?? null,
     startedAt: prev?.startedAt ?? Date.now(),
     settledAt: prev?.settledAt ?? (terminal ? Date.now() : null),
   };
@@ -204,8 +234,11 @@ export function useOperations() {
     }
     for (const key of [...actions.keys()]) {
       if (key.startsWith(prefix) && !present.has(key) && !active.value.some((o) => o.key === key)) {
-        // keep actions for rows still on screen (sticky errors)
-        if (!next.some((o) => o.key === key)) actions.delete(key);
+        // keep actions for rows still on screen (sticky errors) and for
+        // history rows that can still be opened (a finished job's outputs)
+        if (next.some((o) => o.key === key)) continue;
+        if (history.value.some((o) => o.key === key && o.outputs.length > 0)) continue;
+        actions.delete(key);
       }
     }
 
@@ -229,6 +262,13 @@ export function useOperations() {
     acts?.dismiss?.();
   }
 
+  /** Reveal a finished row's output — the first one unless a path is named. */
+  function open(key: string, path?: string) {
+    const row = active.value.find((o) => o.key === key) ?? history.value.find((o) => o.key === key);
+    const target = path ?? row?.outputs[0];
+    if (target) actions.get(key)?.open?.(target);
+  }
+
   function clearHistory() {
     history.value = [];
   }
@@ -284,6 +324,7 @@ export function useOperations() {
     cancel,
     retry,
     dismiss,
+    open,
     clearHistory,
   };
 }