@antelopejs/dms 0.12.0 → 0.13.0

package/frontend-vue/layers/dms-ui/app/build/composables/chart/groupPoints.ts

@@ -0,0 +1,51 @@
+import type {
+  ChartGroupPoint,
+  ChartResponse,
+  ChartSeries,
+} from "../../../composables/chart/types";
+
+type XAxisType = "category" | "datetime" | "numeric";
+
+function isGroupPoint(
+  entry: ChartSeries | ChartGroupPoint,
+): entry is ChartGroupPoint {
+  return "x" in entry && "y" in entry && !("data" in entry);
+}
+
+function isSeries(entry: ChartSeries | ChartGroupPoint): entry is ChartSeries {
+  return "data" in entry && Array.isArray(entry.data);
+}
+
+/**
+ * The series of a fetched answer that carry their points. The answer comes
+ * from a route, so one answering another shape leaves its chart empty rather
+ * than failing the page the chart sits on.
+ */
+export function drawableSeries(
+  series: ReadonlyArray<ChartSeries | ChartGroupPoint>,
+): ChartSeries[] {
+  return series.filter(isSeries);
+}
+
+/**
+ * The series a bare chart draws from its data source's answer.
+ *
+ * One point per group becomes one series called `name`. On a category axis
+ * each group key becomes its label: Apex lays numeric keys out on a number
+ * line whatever axis type it is given, which bunches `202512` and `202601`
+ * apart and shifts the bars of a numeric breakdown off their labels.
+ */
+export function responseSeries(
+  series: ChartResponse["series"],
+  name: string,
+  xaxisType: XAxisType = "category",
+): ChartSeries[] {
+  const entries: Array<ChartSeries | ChartGroupPoint> = series;
+  if (entries.length === 0 || !entries.every(isGroupPoint))
+    return drawableSeries(entries);
+  const labelled = xaxisType === "category";
+  const data = entries
+    .filter(isGroupPoint)
+    .map((point) => (labelled ? { ...point, x: String(point.x) } : point));
+  return [{ name, data }];
+}

package/frontend-vue/layers/dms-ui/app/build/composables/confirm/actionError.ts

@@ -1,150 +1,21 @@
-import {
-  isObject as isObjectType,
-  isString,
-} from "../../../../../dms-core/app/utils/type-check";
-import {
-  readTranslationKey,
-  type I18nTranslate,
-} from "#dms-core/app/composables/translation/useTranslation";
-import { describeFieldErrors } from "#dms-core/app/composables/useFieldErrors";
+import type { I18nTranslate } from "#dms-core/app/composables/translation/useTranslation";
 
-/** Shown when the request never reached the server (offline, DNS, CORS…). */
+/** Legacy fallback key for requests that could not reach the server. */
 export const ACTION_ERROR_NETWORK_KEY = "error.network.description";
-/** Shown for a 401/403 whose body is not a user-facing message. */
+/** Legacy fallback key for permission refusals. */
 export const ACTION_ERROR_FORBIDDEN_KEY = "dms.action_error.forbidden";
-/** Shown when the server's message is missing or not meant for users. */
+/** Fallback key for actions without a more specific context. */
 export const ACTION_ERROR_GENERIC_KEY = "dms.action_error.generic";
 
-const HTTP_UNAUTHORIZED = 401;
-const HTTP_FORBIDDEN = 403;
-const HTTP_SERVER_ERROR = 500;
-
-const MAX_MESSAGE_LENGTH = 300;
-
-const KEY_PATTERN = /^\$?[\w-]+(\.[\w-]+)+$/;
-
-const TECHNICAL_PATTERNS = [
-  /^\s*[[{<]/,
-  /\n\s*at\s/,
-  /^\s*[A-Z]\w*Error\b/,
-  /<no response>/,
-];
-
-const NETWORK_MESSAGES = [/failed to fetch/i, /networkerror/i, /load failed/i];
-
-interface FetchErrorLike {
-  name?: string;
-  message?: string;
-  statusCode?: number;
-  status?: number;
-  response?: { status?: number };
-  data?: unknown;
-}
-
-// oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- Error bodies are untrusted; property values remain unknown until their individual checks.
-const isObject = (value: unknown): value is Record<string, unknown> =>
-  isObjectType(value) && value !== null;
-
-const isFetchError = (error: unknown): error is FetchErrorLike =>
-  isObject(error) &&
-  (error.name === "FetchError" ||
-    "statusCode" in error ||
-    "response" in error ||
-    "data" in error);
-
-const statusOf = (error: FetchErrorLike): number | undefined =>
-  error.statusCode ?? error.status ?? error.response?.status;
-
-/** The message the server put in the error body, when it sent one. */
-const serverMessageOf = (error: FetchErrorLike): string | undefined => {
-  const { data } = error;
-  if (isString(data)) return data;
-  // oxlint-disable-next-line anti-slop/no-known-value-widening -- The object guard accepts all untrusted error data; only an actual string message is returned.
-  if (isObject(data) && isString(data.message)) return data.message;
-  return undefined;
-};
-
-const isTechnical = (text: string) =>
-  text.length > MAX_MESSAGE_LENGTH ||
-  TECHNICAL_PATTERNS.some((pattern) => pattern.test(text));
-
-/**
- * `text` as the user should read it: a translated i18n key, or plain prose
- * as it came. Undefined when it is not user-facing (an untranslated key, JSON,
- * a stack trace…), for the caller to fall back on a generic message.
- */
-export const userFacingText = (
-  text: string | undefined,
-  translate: I18nTranslate,
-): string | undefined => {
-  const trimmed = text?.trim();
-  if (!trimmed) return undefined;
-  const { key } = readTranslationKey(trimmed);
-  if (KEY_PATTERN.test(trimmed)) {
-    const translated = translate(key, {});
-    return translated !== key ? translated : undefined;
-  }
-  return isTechnical(trimmed) ? undefined : trimmed;
-};
-
-const translateKey = (translate: I18nTranslate, key: string) =>
-  translate(key, {});
-
-/**
- * The message telling a user why an action failed, from whatever the request
- * threw: the server's own message when it is user-facing (an i18n key, or
- * plain text on a 4xx), else a translated fallback: the request never got
- * through, it was refused for lack of permission, or something went wrong.
- * Never a stack trace, raw JSON or an ofetch error line. A body the data API
- * refused for some fields names them by `labelOf` ("Loss reason is
- * required."): a table view's write passes its column labels.
- */
+/** @deprecated Capture useApiErrorPresenter().resolveError during setup instead. */
 export function resolveActionError(
-  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- The request's catch value is decoded here and may be any thrown JavaScript value.
   error: unknown,
-  translate: I18nTranslate,
-  labelOf: (field: string) => string | undefined = () => undefined,
+  _translate: I18nTranslate,
+  _labelOf?: (field: string) => string | undefined,
 ): string {
-  if (isFetchError(error)) {
-    const status = statusOf(error);
-    if (status === undefined) {
-      return translateKey(translate, ACTION_ERROR_NETWORK_KEY);
-    }
-    const raw = serverMessageOf(error);
-    const isForbidden =
-      status === HTTP_UNAUTHORIZED || status === HTTP_FORBIDDEN;
-
-    if (isForbidden || status >= HTTP_SERVER_ERROR) {
-      const translated =
-        raw && KEY_PATTERN.test(raw.trim())
-          ? userFacingText(raw, translate)
-          : undefined;
-      return (
-        translated ??
-        translateKey(
-          translate,
-          isForbidden ? ACTION_ERROR_FORBIDDEN_KEY : ACTION_ERROR_GENERIC_KEY,
-        )
-      );
-    }
-    return (
-      describeFieldErrors(error, translate, labelOf) ??
-      userFacingText(raw, translate) ??
-      translateKey(translate, ACTION_ERROR_GENERIC_KEY)
-    );
-  }
-
-  const message =
-    error instanceof Error
-      ? error.message
-      : isString(error)
-        ? error
-        : undefined;
-  if (message && NETWORK_MESSAGES.some((pattern) => pattern.test(message))) {
-    return translateKey(translate, ACTION_ERROR_NETWORK_KEY);
-  }
   return (
-    userFacingText(message, translate) ??
-    translateKey(translate, ACTION_ERROR_GENERIC_KEY)
+    useApiErrorPresenter().resolveError(error, {
+      fallbackKey: ACTION_ERROR_GENERIC_KEY,
+    })?.message ?? ""
   );
 }

package/frontend-vue/layers/dms-ui/app/build/composables/confirm/useActionConfirm.ts

@@ -3,7 +3,6 @@ import type {
   ConfirmDialog,
 } from "#dms-core/app/types/confirm-dialog";
 import { isConfirmFrom } from "#dms-core/app/types/confirm-dialog";
-import { resolveActionError } from "./actionError";
 import type {
   ConfirmOptions,
   ConfirmPartialOutcome,
@@ -43,7 +42,7 @@ export function useActionConfirm() {
   const { confirm } = useConfirm();
   const { $authFetch } = useAuthFetch();
   const { t } = useI18n();
-  const toast = useToast();
+  const { presentError } = useApiErrorPresenter();
   const runSecondaryTarget = secondaryTargetRunner($authFetch.raw);
 
   const loadDialog = async (
@@ -61,12 +60,7 @@ export function useActionConfirm() {
     try {
       return await $authFetch<ConfirmDialog>(url);
     } catch (error) {
-      toast.add({
-        color: Color.error,
-        icon: "i-ph-warning-circle",
-        title: t("dms.form.error_title"),
-        description: resolveActionError(error, t),
-      });
+      presentError(error, { fallbackKey: "dms.action_error.generic" });
       return undefined;
     }
   };

package/frontend-vue/layers/dms-ui/app/build/composables/data-types/defaultPrimitiveTypes.ts

@@ -37,16 +37,14 @@ function renderBoolean(value: CellValue) {
   ]);
 }
 
+function dateBoundsOf(value: CellValue): [unknown, unknown] {
+  const bounds: { start?: unknown; end?: unknown } = value ?? {};
+  return [bounds.start, bounds.end];
+}
+
 function formatDateBetween(value: CellValue, locale: string): string {
   const { t } = getAppTranslation();
-  const [rawStart, rawEnd] = Array.isArray(value)
-    ? value
-    : [
-        // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- The open formatter value has no date-range schema; preserve optional start access on the original input.
-        (value as { start?: unknown })?.start,
-        // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- The open formatter value has no date-range schema; preserve optional end access on the original input.
-        (value as { end?: unknown })?.end,
-      ];
+  const [rawStart, rawEnd] = Array.isArray(value) ? value : dateBoundsOf(value);
   const start = formatDate(rawStart, locale) ?? t("dms.date.undefined");
   const end = formatDate(rawEnd, locale) ?? t("dms.date.undefined");
   return `${start} - ${end}`;

package/frontend-vue/layers/dms-ui/app/build/composables/form/formState.ts

@@ -16,7 +16,6 @@ import {
 } from "../../utils/urlVariables";
 import { apiErrorStatus } from "#dms-core/app/composables/useFieldErrors";
 import { HTTP_NOT_FOUND } from "#dms-core/app/utils/http-status";
-import { isString } from "#dms-core/app/utils/type-check";
 import { sameFormValue } from "../unsaved-changes/formValue";
 import {
   type FieldValueComparer,
@@ -135,12 +134,11 @@ function createFormState(props: FormProps) {
 /** @internal */
 export function createFormFields(props: FormProps) {
   const context = createFormState(props);
+  const { presentError } = useApiErrorPresenter();
   const {
-    toast,
     $authFetch,
     getDataType,
     processI18n,
-    processApiMessage,
     route,
     initialValues,
     disabledFields,
@@ -205,15 +203,7 @@ export function createFormFields(props: FormProps) {
   };
 
   const showFetchErrorToast = (error: Parameters<typeof apiErrorStatus>[0]) => {
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Rejections are arbitrary; keep direct data access, primitive boxing and nullish throws rather than treating this unchecked error projection as validated.
-    const err = error as Error & { data?: string };
-    toast.add({
-      title: processI18n("$dms.form.fetch_error_title"),
-      description: isString(err.data)
-        ? processApiMessage(err.data)
-        : processI18n("$dms.form.fetch_error_unknown"),
-      color: Color.error,
-    });
+    presentError(error, { fallbackKey: "dms.form.fetch_error_unknown" });
   };
 
   const baseSchema = createBaseValidationSchema(props.schema);

package/frontend-vue/layers/dms-ui/app/build/composables/page/blockAnchors.ts

@@ -1,4 +1,4 @@
-import type { ComponentPublicInstance, VNode } from "vue";
+import { isVNode, type ComponentPublicInstance, type VNode } from "vue";
 
 const blocks = new Map<string, ComponentPublicInstance>();
 
@@ -28,8 +28,7 @@ function firstElementOf(vnode: VNode | null | undefined): Element | null {
   if (vnode.component) return firstElementOf(vnode.component.subTree);
   if (!Array.isArray(vnode.children)) return null;
   for (const child of vnode.children) {
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- VNode child representations can include scalars and arrays; retain the unchecked recursive projection and null fallback.
-    const element = firstElementOf(child as VNode);
+    const element = isVNode(child) ? firstElementOf(child) : null;
     if (element) return element;
   }
   return null;

package/frontend-vue/layers/dms-ui/app/build/composables/table/useTableConfigClipboard.ts

@@ -51,6 +51,7 @@ export const useTableConfigClipboard = <T extends Data>() => {
     injectLocal<ShallowRef<TableSharedData<T>>>("tableSharedData");
   const toast = useToast();
   const { t } = useI18n();
+  const { presentError } = useApiErrorPresenter();
 
   const buildConfig = (): SerializedTableConfig | null => {
     const data = tableSharedData?.value;
@@ -97,11 +98,9 @@ export const useTableConfigClipboard = <T extends Data>() => {
         title: t("dms.table.export_config_copied"),
         duration: TOAST_DURATION_MS,
       });
-    } catch {
-      toast.add({
-        color: "error",
-        title: t("dms.table.export_config_failed"),
-        description: code,
+    } catch (error) {
+      presentError(error, {
+        fallbackKey: "dms.table.export_config_failed",
       });
     }
   };
@@ -117,11 +116,9 @@ export const useTableConfigClipboard = <T extends Data>() => {
         duration: TOAST_DURATION_MS,
       });
       return true;
-    } catch {
-      toast.add({
-        color: "error",
-        title: t("dms.table.import_config_invalid"),
-        duration: TOAST_DURATION_MS,
+    } catch (error) {
+      presentError(error, {
+        fallbackKey: "dms.table.import_config_invalid",
       });
       return false;
     }

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/tableRowActionBulkRequests.ts

@@ -17,9 +17,8 @@ import {
   type ConfirmPartialOutcome,
 } from "../../../composables/confirm/types";
 import { getErrorPayload } from "./tableRowActionValues";
-import type { describeTableWriteError } from "./utils/writeError";
 export type TableRowActionErrorHandler = (
-  error: Parameters<typeof describeTableWriteError>[0],
+  error: unknown,
   title?: string,
 ) => void;
 const createBulkRequest = (config: TableRowActionsConfig) => {
@@ -92,7 +91,8 @@ export const createTableRowBulkOutcomes = (
   services: TableRowActionServices,
   handleApiError: TableRowActionErrorHandler,
 ) => {
-  const { toast, t } = services;
+  const { t } = services;
+  const { presentError } = useApiErrorPresenter();
   const requestBulkAction = createBulkRequest(config);
   const reportBulkSuccess = createBulkReporter(config, services);
   /**
@@ -112,7 +112,10 @@ export const createTableRowBulkOutcomes = (
       const outcome = await requestBulkAction(ids, bulkConfig, values);
       const shortfall = bulkActionShortfall(bulkConfig.kind, outcome, t);
       if (outcome.processed === 0 && shortfall) {
-        throw new ConfirmActionError(shortfall);
+        throw new ConfirmActionError({
+          fallbackKey: `dms.table.bulk_refused.${bulkConfig.kind}`,
+          params: { count: outcome.skipped },
+        });
       }
       reportBulkSuccess(outcome.processed, actionConfig, bulkConfig);
       if (shortfall) return { partial: shortfall };
@@ -131,16 +134,14 @@ export const createTableRowBulkOutcomes = (
     try {
       outcome = await requestBulkAction(ids, bulkConfig);
     } catch (error) {
-      handleApiError(error, t(bulkConfig.errorKey));
+      handleApiError(error, bulkConfig.errorKey);
       return false;
     }
     const shortfall = bulkActionShortfall(bulkConfig.kind, outcome, t);
     if (outcome.processed === 0) {
-      toast.add({
-        color: Color.error,
-        icon: "i-ph-warning-circle",
-        title: shortfall?.title ?? t(bulkConfig.errorKey),
-        description: shortfall?.description,
+      presentError(null, {
+        fallbackKey: `dms.table.bulk_refused.${bulkConfig.kind}`,
+        params: { count: outcome.skipped },
       });
       return false;
     }

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/tableRowActionValues.ts

@@ -1,5 +1,4 @@
 import { get } from "@nuxt/ui/runtime/utils/index.js";
-import type { describeTableWriteError } from "./utils/writeError";
 export const DEFAULT_ROW_ID_KEY = "_id";
 
 export const getItemId = (
@@ -9,9 +8,7 @@ export const getItemId = (
   return get(item, idKey) ?? item._id ?? item.id;
 };
 
-export const getErrorPayload = (
-  error: Parameters<typeof describeTableWriteError>[0],
-) => {
+export const getErrorPayload = (error: unknown) => {
   // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Rejections may be arbitrary JavaScript values, not EventError instances. Its owner describes only the fields forwarded here; inference cannot prove them, and validation would change primitive and malformed-error payloads.
   const err = error as EventError;
   return err?.data || err?.message;

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/tableViewGrouping.ts

@@ -3,7 +3,7 @@ import {
   CARDS_DISPLAY_ID,
 } from "../../../composables/table-view/types";
 import { KANBAN_DISPLAY_BRIDGE_KEY } from "../../../composables/table-view/kanban";
-import { describeTableWriteError } from "./utils/writeError";
+import { tableWriteErrorOptions } from "./utils/writeError";
 import { buildTableQuery, isFilterEffective } from "./utils/tableQuery";
 import { useGroupedRows } from "./useGroupedRows";
 import { useTableReorder } from "./useTableReorder";
@@ -32,9 +32,9 @@ export function useTableViewReorder<T extends Data>(
   const { effectiveColumnFilters, effectiveGlobalFilter } = scope.querySorting;
   const { activeTabFilters, t } = scope.tabs;
   const { activeDisplayId } = scope.displayOptions;
-  const { toast } = scope.sortRecovery;
   const { processI18n } = scope.arrival;
   const { props } = scope;
+  const { presentError } = useApiErrorPresenter();
   const ORDERED_DISPLAY_IDS = new Set([TABLE_DISPLAY_ID, CARDS_DISPLAY_ID]);
   const { reorderState } = useTableReorder<T>({
     reorder: reorderConfig,
@@ -53,18 +53,18 @@ export function useTableViewReorder<T extends Data>(
       ORDERED_DISPLAY_IDS.has(activeDisplayId.value),
     ),
     refresh: () => refresh(),
-    onError: (failure) =>
-      toast.add({
-        title: t("dms.table.reorder.error"),
-        description: describeTableWriteError(
+    onError: (failure) => {
+      presentError(
+        failure,
+        tableWriteErrorOptions(
           failure,
           t,
           allColumns,
           processI18n,
+          "dms.table.reorder.error",
         ),
-        color: Color.error,
-        icon: "i-ph-warning-circle",
-      }),
+      );
+    },
   });
   return { reorderState };
 }

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useExpandedRowDetails.ts

@@ -18,6 +18,7 @@ export function useExpandedRowDetails<T>(
   getRow: (id: string) => Promise<T | undefined>,
 ) {
   const entries = ref<Record<string, ExpandedRowDetailEntry<T>>>({});
+  const { presentError } = useApiErrorPresenter();
   let generation = 0;
 
   const setEntry = (id: string, entry: ExpandedRowDetailEntry<T>) => {
@@ -30,7 +31,9 @@ export function useExpandedRowDetails<T>(
     let row: T | undefined;
     try {
       row = await getRow(id);
-    } catch {
+    } catch (error) {
+      if (loadedFor !== generation) return;
+      presentError(error, { fallbackKey: "dms.table.load_error_title" });
       row = undefined;
     }
     if (loadedFor !== generation) return;

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableRecordLink.ts

@@ -49,18 +49,23 @@ export function useTableRecordLink<T>(
   options: TableRecordLinkOptions<T>,
 ): TableRecordLink {
   const { action, urlScope } = options;
+  const { presentError } = useApiErrorPresenter();
 
   let linkedId: string | undefined;
 
   const settle = async (id: string) => {
     const found = await options.resolve(id);
     const outcome = deepLinkOutcome(found, action);
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- deepLinkOutcome returns a string rather than a row type predicate. DeepLinkedRow keeps row optional; the open outcome guarantees it operationally but neither inference nor its owner expresses that relation.
-    if (outcome === "open") return options.open(found.row as T);
+    if (outcome === "open") {
+      if (found.row) options.open(found.row);
+      return;
+    }
     if (outcome === "missingPanel") return options.showMissing(id);
     writeRecordId(urlScope);
     if (linkedId === id) linkedId = undefined;
-    options.notify(outcome);
+    if (outcome === "notifyFailed")
+      presentError(found.error, { fallbackKey: "dms.table.load_error_title" });
+    else options.notify(outcome);
   };
 
   const follow = (query: LocationQuery) => {

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableRows.ts

@@ -1,5 +1,6 @@
 import { get } from "@nuxt/ui/runtime/utils/index.js";
 import { computed } from "vue";
+import { stringifyQuery, withQuery } from "ufo";
 import { interpolateUrl } from "#dms-core/app/utils/url-interpolation";
 import { isString } from "#dms-core/app/utils/type-check";
 import type {
@@ -58,6 +59,48 @@ const DESCENDING = "desc";
  */
 export const LIVE_HELD_AT_QUERY_KEY = "liveHeldAt";
 const NO_ROUTE_VALUES: ReplaceUrlVariablesContext = { routeQuery: {} };
+const MAX_BATCH_COUNT_QUERIES = 50;
+const MAX_BATCH_COUNT_TARGET_BYTES = 8_192;
+
+function encodeCountQuery({ id, query }: TableCountQuery): string {
+  const values = Object.fromEntries(
+    Object.entries(query)
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.map(String) : String(value),
+      ]),
+  );
+  return `${encodeURIComponent(id)}?${stringifyQuery(values)}`;
+}
+
+function countBatchTargetBytes(location: string, entries: string[]): number {
+  const url = new URL(location, "http://dms.invalid");
+  const target = withQuery(url.pathname + url.search, { query: entries });
+  return new TextEncoder().encode(target).byteLength;
+}
+
+function packCountQueries(
+  location: string,
+  queries: TableCountQuery[],
+): string[][] {
+  const batches: string[][] = [];
+  let batch: string[] = [];
+  for (const entry of queries.map(encodeCountQuery)) {
+    if (
+      batch.length > 0 &&
+      (batch.length >= MAX_BATCH_COUNT_QUERIES ||
+        countBatchTargetBytes(location, [...batch, entry]) >
+          MAX_BATCH_COUNT_TARGET_BYTES)
+    ) {
+      batches.push(batch);
+      batch = [];
+    }
+    batch.push(entry);
+  }
+  batches.push(batch);
+  return batches;
+}
 
 type SourceCapabilities = TableViewSourceConfig["capabilities"];
 
@@ -347,11 +390,16 @@ export function useTableRows<T extends Record<string, unknown>>(
     signal?: AbortSignal,
   ): Promise<Record<string, number>> => {
     if (!source) {
-      return api<Record<string, number>>(`${location}/count/batch`, {
-        method: "POST",
-        body: { queries },
-        signal,
-      });
+      const endpoint = `${location}/count/batch`;
+      const counts = await Promise.all(
+        packCountQueries(endpoint, queries).map((entries) =>
+          api<Record<string, number>>(endpoint, {
+            query: { query: entries },
+            signal,
+          }),
+        ),
+      );
+      return Object.assign({}, ...counts);
     }
     const totals = await Promise.all(
       queries.map(async ({ id, query }) => {

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableViewRowActions.ts

@@ -1,6 +1,6 @@
 import { useActionConfirm } from "../confirm/useActionConfirm";
 import { useActionTargets } from "../actions/useActionTargets";
-import { describeTableWriteError } from "./utils/writeError";
+import { tableWriteErrorOptions } from "./utils/writeError";
 import type {
   TableRowActionsConfig,
   TableRowActionServices,
@@ -14,6 +14,7 @@ export const useTableRowActions = <T extends Data>(
   config: TableRowActionsConfig,
 ) => {
   const toast = useToast();
+  const { presentError } = useApiErrorPresenter();
   const { t, locale } = useI18n();
   const { confirm } = useConfirm();
   const { confirmAction } = useActionConfirm();
@@ -38,21 +39,11 @@ export const useTableRowActions = <T extends Data>(
    * what failed, the description is the server's message when it is meant
    * for users, else a translated fallback (never a raw error line).
    */
-  const handleApiError = (
-    error: Parameters<typeof describeTableWriteError>[0],
-    title?: string,
-  ) => {
-    toast.add({
-      color: Color.error,
-      icon: "i-ph-warning-circle",
-      title: title || t("dms.form.error_title"),
-      description: describeTableWriteError(
-        error,
-        t,
-        config.columns,
-        processI18n,
-      ),
-    });
+  const handleApiError = (error: unknown, title?: string) => {
+    presentError(
+      error,
+      tableWriteErrorOptions(error, t, config.columns, processI18n, title),
+    );
   };
 
   const createFormContainer = createTableRowFormContainer<T>(config, services);

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/utils/recordLink.ts

@@ -106,6 +106,8 @@ export interface DeepLinkedRow<T> {
    * error): the row may still exist, the link just could not be followed.
    */
   isFailed?: boolean;
+  /** Original request failure retained for presentation. */
+  error?: unknown;
 }
 
 /**
@@ -125,7 +127,7 @@ export async function resolveDeepLinkedRow<T>(
     return { row: row ?? undefined, isMissing: false };
   } catch (error: unknown) {
     if (readFetchNotFound(error) !== null) return { isMissing: true };
-    return { isMissing: false, isFailed: true };
+    return { isMissing: false, isFailed: true, error };
   }
 }