@antelopejs/dms 0.12.0 → 0.13.0

package/frontend-vue/layers/dms-core/app/build/composables/api-error.ts

@@ -0,0 +1,145 @@
+import { toRaw } from "vue";
+import { z } from "zod";
+import type {
+  ApiErrorParams,
+  ApiErrorSeverity,
+} from "../../composables/useApiErrorPresenter";
+
+const MAX_DEPTH = 8;
+const HTTP_FAILURE_MIN = 400;
+const HTTP_CLIENT_MAX = 499;
+const HTTP_STATUS_MAX = 599;
+const statusSchema = z
+  .number()
+  .int()
+  .min(HTTP_FAILURE_MIN)
+  .max(HTTP_STATUS_MAX);
+const severitySchema = z.enum(["info", "warning", "error"]);
+const paramsSchema = z.record(z.union([z.string(), z.number(), z.boolean()]));
+const recordSchema = z.object({
+  cause: z.unknown().optional(),
+  response: z.unknown().optional(),
+  data: z.unknown().optional(),
+  _data: z.unknown().optional(),
+  message: z.unknown().optional(),
+  name: z.unknown().optional(),
+  severity: z.unknown().optional(),
+  params: z.unknown().optional(),
+  status: z.unknown().optional(),
+  statusCode: z.unknown().optional(),
+  body: z.unknown().optional(),
+});
+
+interface DecodedBody {
+  key?: string;
+  params?: ApiErrorParams;
+  severity?: ApiErrorSeverity;
+  status?: number;
+}
+
+/** @internal */
+export interface DecodedApiFailure {
+  cancelled: boolean;
+  identity: object | null;
+  key?: string;
+  params?: ApiErrorParams;
+  severity: ApiErrorSeverity;
+}
+
+function record(value: unknown) {
+  return recordSchema.safeParse(value).data;
+}
+
+function decodeBody(input: unknown): DecodedBody {
+  let value = input;
+  let status: number | undefined;
+  const seen = new Set<unknown>();
+  for (let depth = 0; depth < MAX_DEPTH; depth++) {
+    if (seen.has(value)) return { status };
+    seen.add(value);
+    if (typeof value === "string") {
+      const text = value;
+      try {
+        const parsed: unknown = JSON.parse(text);
+        value = parsed;
+        continue;
+      } catch {
+        return { key: text, status };
+      }
+    }
+    const body = record(value);
+    if (!body) return { status };
+    const envelopeStatus = statusSchema.safeParse(body.status).data;
+    if (envelopeStatus !== undefined && body.body !== undefined) {
+      status ??= envelopeStatus;
+      value = body.body;
+      continue;
+    }
+    return {
+      key: z.string().safeParse(body.message).data,
+      severity: severitySchema.safeParse(body.severity).data,
+      params: paramsSchema.safeParse(body.params).data,
+      status,
+    };
+  }
+  return { status };
+}
+
+/** @internal */
+export function decodeApiFailure(error: unknown): DecodedApiFailure {
+  let current = error;
+  let identity: object | null = null;
+  let request: DecodedBody | undefined;
+  let local: unknown = error;
+  let status: number | undefined;
+  let cancelled = false;
+  let hasFailedResponse = false;
+  let params: ApiErrorParams | undefined;
+  const seen = new Set<unknown>();
+  for (let depth = 0; depth < MAX_DEPTH && !seen.has(current); depth++) {
+    seen.add(current);
+    const entry = record(current);
+    if (!entry) {
+      local = current;
+      break;
+    }
+    if (current !== null && typeof current === "object")
+      identity = toRaw(current);
+    local = entry.message;
+    params ??= paramsSchema.safeParse(entry.params).data;
+    cancelled ||= entry.name === "AbortError";
+    const response = record(entry.response);
+    const responseStatus = statusSchema.safeParse(response?.status).data;
+    const entryStatus =
+      responseStatus ??
+      statusSchema.safeParse(entry.statusCode ?? entry.status).data;
+    if (
+      entry.response &&
+      responseStatus !== undefined &&
+      typeof entry.response === "object"
+    ) {
+      identity = toRaw(entry.response);
+      request = decodeBody(entry.data ?? response?._data);
+      status = responseStatus;
+      hasFailedResponse = true;
+      break;
+    }
+    if (entry.data !== undefined || entryStatus !== undefined) {
+      request = decodeBody(entry.data);
+      status = entryStatus;
+    }
+    if (entry.cause === undefined) break;
+    current = entry.cause;
+  }
+  const body = request ?? decodeBody(local);
+  status ??= body.status;
+  return {
+    cancelled: cancelled && !hasFailedResponse,
+    identity,
+    key: body.key,
+    params: { ...params, ...body.params },
+    severity:
+      body.severity ??
+      (status !== undefined && status <= HTTP_CLIENT_MAX ? "warning" : "error"),
+  };
+}

package/frontend-vue/layers/dms-core/app/build/composables/auth/usePermissionPreview.ts

@@ -155,6 +155,7 @@ function createPreviewSharing() {
  */
 export function usePermissionPreview() {
   const state = usePreviewState();
+  const { presentError } = useApiErrorPresenter();
   const isActive = computed(() => state.session.value !== null);
   const hiddenEntries = computed(
     () => new Set(state.result.value?.hiddenEntries ?? []),
@@ -249,9 +250,12 @@ export function usePermissionPreview() {
       if (current !== refreshGeneration) return;
       state.result.value = result;
       state.failed.value = false;
-    } catch {
+    } catch (error) {
       if (current !== refreshGeneration) return;
       state.failed.value = true;
+      presentError(error, {
+        fallbackKey: "page.settings.roles.preview.failed",
+      });
     } finally {
       if (current === refreshGeneration) state.loading.value = false;
     }

package/frontend-vue/layers/dms-core/app/composables/auth/useAuthFetch.ts

@@ -126,12 +126,12 @@ export const useAuthFetch = () => {
       ...defaults,
       ...options,
     });
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- The wrapper forwards each call to baseFetch, whose generic response correlation inference loses; raw, native and create are attached below before it is returned.
+    // SAFETY: retryingFetch resolves with the response baseFetch gives for the same request, of the same response type, so the wrapper answers as AuthFetch's call signature does; raw, native and create are attached below before it is returned.
     const authFetch = ((
       request: AuthFetchArgs[0],
       options?: AuthFetchArgs[1],
     ) => retryingFetch(request, optionsOf(options))) as AuthFetch;
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- The raw wrapper preserves the owner's generic overloads through forwarding; inference loses their response-type correlation.
+    // SAFETY: retryingRaw resolves with the response baseFetch.raw gives for the same request, of the same response type, so the wrapper answers as AuthFetch['raw'] does.
     authFetch.raw = ((request: AuthFetchArgs[0], options?: AuthFetchArgs[1]) =>
       retryingRaw(request, optionsOf(options))) as AuthFetch["raw"];
     authFetch.native = baseFetch.native;

package/frontend-vue/layers/dms-core/app/composables/page/useSiteLayout.ts

@@ -209,18 +209,19 @@ const useSiteLayoutRequests = () => {
   const { pageLayoutPromises, loadingPromise } =
     useSiteLayoutRequestsInFlight();
 
-  const SITE_LAYOUT_ERROR_MESSAGE = "Error loading siteLayout";
-  const UNKNOWN_SITE_LAYOUT_ERROR = "Unknown error loading siteLayout";
+  const { resolveError } = useApiErrorPresenter();
   const HTTP_INTERNAL_ERROR = 500;
 
   // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Fetch rejection values have no shared owner schema; an Error-only input would exclude malformed thrown values that intentionally use the fallback message.
   const handleSiteLayoutError = (error: unknown) => {
-    const errorMessage =
-      error instanceof Error ? error.message : UNKNOWN_SITE_LAYOUT_ERROR;
+    const errorMessage = resolveError(error, {
+      fallbackKey: "error.500.description",
+    })?.message;
+    if (!errorMessage) return;
     loadingError.value = errorMessage;
     showDmsError({
       statusCode: HTTP_INTERNAL_ERROR,
-      statusMessage: SITE_LAYOUT_ERROR_MESSAGE,
+      statusMessage: errorMessage,
       message: errorMessage,
     });
   };

package/frontend-vue/layers/dms-core/app/composables/useApiError.ts

@@ -69,19 +69,12 @@ export function resolveApiErrorMessage(
   return isApiError(error) ? resolveDescription(error) : FALLBACK_ERROR_KEY;
 }
 
+/** @deprecated Capture useApiErrorPresenter during setup instead. */
 export function useApiError(
   error: Parameters<typeof resolveApiErrorTitle>[0],
   options?: Options,
 ) {
-  const toast = useToast();
-  const { processApiMessage } = getAppTranslation();
-
-  const title = options?.title || resolveApiErrorTitle(error);
-  const description = options?.description || resolveApiErrorMessage(error);
-
-  toast.add({
-    title: processApiMessage(title),
-    description: processApiMessage(description),
-    color: "error",
+  useApiErrorPresenter().presentError(error, {
+    fallbackKey: options?.description || options?.title || FALLBACK_ERROR_KEY,
   });
 }

package/frontend-vue/layers/dms-core/app/composables/useApiErrorPresenter.ts

@@ -0,0 +1,159 @@
+import { decodeApiFailure } from "../build/composables/api-error";
+
+/** The supported tones for request failures. */
+export type ApiErrorSeverity = "info" | "warning" | "error";
+
+/** Localized text and tone for an inline error. */
+export interface ApiErrorNotice {
+  readonly message: string;
+  readonly severity: ApiErrorSeverity;
+}
+
+/** Placeholder values accepted by error translations. */
+export type ApiErrorParams = Readonly<
+  Record<string, string | number | boolean>
+>;
+
+/** Keys are resolved against loaded catalogs and never displayed verbatim. */
+export interface ResolveApiErrorOptions {
+  readonly fallbackKey: string;
+  readonly params?: ApiErrorParams;
+}
+
+/** A contextual action whose label is also a loaded translation key. */
+export interface ApiErrorAction {
+  readonly labelKey: string;
+  readonly onSelect: () => void | Promise<void>;
+}
+
+/** An existing progress notification, not the identity of a failure. */
+export type ApiErrorToastId = string | number;
+
+/** Toast presentation never overrides the server's translated reason or tone. */
+export interface PresentApiErrorOptions extends ResolveApiErrorOptions {
+  readonly actions?: readonly ApiErrorAction[];
+  readonly replaceToastId?: ApiErrorToastId;
+}
+
+/** Captured during setup and callable after awaits. */
+export interface ApiErrorPresenter {
+  resolveError(
+    error: unknown,
+    options: ResolveApiErrorOptions,
+  ): ApiErrorNotice | null;
+  presentError(error: unknown, options: PresentApiErrorOptions): void;
+}
+
+const GENERIC_KEY = "error.500.description";
+const PRESENTED_STATE_KEY = "dms.apiErrors.presentedResponses";
+const FAILURE_DURATION_MS = 5000;
+const ICONS: Record<ApiErrorSeverity, string> = {
+  info: "i-ph-info",
+  warning: "i-ph-warning",
+  error: "i-ph-warning-circle",
+};
+
+function isCompiledMessage(value: unknown): boolean {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    (("type" in value && value.type === 0) || ("t" in value && value.t === 0))
+  );
+}
+
+/**
+ * Resolves errors without side effects and presents at most one toast per failed
+ * Response in this app. Aborts without a failed response are silent.
+ */
+export function useApiErrorPresenter(): ApiErrorPresenter {
+  const toast = useToast();
+  const { i18n } = getPluginI18n();
+  const presented = useDmsState(
+    PRESENTED_STATE_KEY,
+    () => new WeakMap<object, ApiErrorToastId | null>(),
+  );
+
+  function lookup(
+    key: string | undefined,
+    params: ApiErrorParams = {},
+  ): string | null {
+    if (!key) return null;
+    try {
+      const message = i18n.tm(key.startsWith("$") ? key.slice(1) : key);
+      if (
+        typeof message !== "string" &&
+        typeof message !== "function" &&
+        !isCompiledMessage(message)
+      )
+        return null;
+      return i18n.rt(message, params);
+    } catch {
+      return null;
+    }
+  }
+
+  function noticeOf(
+    failure: ReturnType<typeof decodeApiFailure>,
+    options: ResolveApiErrorOptions,
+  ): ApiErrorNotice | null {
+    if (failure.cancelled) return null;
+    const params = { ...failure.params, ...options.params };
+    const message =
+      lookup(failure.key, params) ??
+      lookup(options.fallbackKey, params) ??
+      lookup(GENERIC_KEY);
+    if (message === null)
+      throw new Error(
+        "The core error.500.description translation must be loaded",
+      );
+    return { message, severity: failure.severity };
+  }
+
+  function resolveError(
+    error: unknown,
+    options: ResolveApiErrorOptions,
+  ): ApiErrorNotice | null {
+    return noticeOf(decodeApiFailure(error), options);
+  }
+
+  function presentError(error: unknown, options: PresentApiErrorOptions): void {
+    const failure = decodeApiFailure(error);
+    const notice = noticeOf(failure, options);
+    if (import.meta.env.SSR) return;
+    const replacement = options.replaceToastId;
+    const identity = failure.identity;
+    if (!notice || (identity && presented.value.has(identity))) {
+      if (
+        replacement !== undefined &&
+        (!identity || presented.value.get(identity) !== replacement)
+      )
+        toast.remove(replacement);
+      return;
+    }
+    const payload = {
+      title: notice.message,
+      description: undefined,
+      color: notice.severity,
+      icon: ICONS[notice.severity],
+      duration: FAILURE_DURATION_MS,
+      progress: true,
+      actions: options.actions?.flatMap((action) => {
+        const label = lookup(action.labelKey);
+        return label === null ? [] : [{ label, onClick: action.onSelect }];
+      }),
+    };
+    if (identity) presented.value.set(identity, replacement ?? null);
+    try {
+      if (replacement !== undefined) toast.update(replacement, payload);
+      else {
+        const added = toast.add(payload);
+        if (identity) presented.value.set(identity, added.id);
+      }
+    } catch (error) {
+      if (identity) presented.value.delete(identity);
+      throw error;
+    }
+  }
+
+  return { presentError, resolveError };
+}

package/frontend-vue/layers/dms-core/app/composables/useFieldErrors.ts

@@ -1,8 +1,5 @@
 import { nextTick, reactive } from "vue";
-import {
-  type I18nTranslate,
-  resolveApiMessage,
-} from "./translation/useTranslation";
+import { type I18nTranslate } from "./translation/useTranslation";
 import { resolveApiErrorMessage } from "./useApiError";
 import { isBoolean, isNumber, isObject, isString } from "../utils/type-check";
 
@@ -19,11 +16,10 @@ import { isBoolean, isNumber, isObject, isString } from "../utils/type-check";
 export interface ApiFieldError {
   /** Id of the field, as the form names it (the request body key). */
   field: string;
-  /**
-   * What to show under the field: an i18n key (bare `error.xxx` or `$key`)
-   * or prose, resolved with `resolveApiMessage`.
-   */
+  /** Server translation key, resolved by the API error presenter. */
   message: string;
+  /** Caller key used only when the server's message is not translated. */
+  fallbackKey?: string;
   /** The values of the field the error names (addresses of a list…). */
   values?: string[];
   /**
@@ -325,7 +321,7 @@ function lookupCode<F extends string>(
   if (!entry) return undefined;
   return isString(entry)
     ? { field: entry, message: code }
-    : { field: entry.field, message: entry.message };
+    : { field: entry.field, message: code, fallbackKey: entry.message };
 }
 
 function fromBody(body: ReturnType<typeof bodyOf>): ApiFieldError[] {
@@ -489,10 +485,7 @@ export interface HandleApiErrorOptions {
 export function useFieldErrors<F extends string>(
   options: UseFieldErrorsOptions<F>,
 ) {
-  const { t } = useI18n();
-  const toast = useToast();
-  const translate = (key: string, params: Parameters<I18nTranslate>[1] = {}) =>
-    t(key, params);
+  const { presentError, resolveError } = useApiErrorPresenter();
   const fieldIds = Object.keys(options.fields) as F[];
   const errors: Partial<Record<F, string>> = reactive({});
 
@@ -548,21 +541,20 @@ export function useFieldErrors<F extends string>(
   async function applyApiError(
     error: Parameters<typeof resolveApiErrorMessage>[0],
   ): Promise<boolean> {
-    const { fields } = resolveFieldErrors(error, {
+    const { fields, hasUnmatched } = resolveFieldErrors(error, {
       fields: fieldIds,
       codes: options.codes,
     });
     if (fields.length === 0) return false;
     clear();
     for (const entry of fields) {
-      errors[entry.field as F] = resolveApiMessage(
-        translate,
-        entry.message,
-        entry.params,
-      );
+      errors[entry.field as F] = resolveError(entry.message, {
+        fallbackKey: entry.fallbackKey ?? "dms.field_errors.invalid",
+        params: entry.params,
+      })?.message;
     }
     await focus(fields[0]!.field as F);
-    return true;
+    return !hasUnmatched;
   }
   /* oxlint-enable anti-slop/require-safety-comment-for-type-assertion */
 
@@ -571,12 +563,8 @@ export function useFieldErrors<F extends string>(
     error: Parameters<typeof resolveApiErrorMessage>[0],
     toastOptions: HandleApiErrorOptions,
   ) {
-    toast.add({
-      title: t(toastOptions.toastTitle),
-      description: toastOptions.toastDescription
-        ? t(toastOptions.toastDescription)
-        : resolveApiMessage(translate, describeApiError(error)),
-      color: "error",
+    presentError(error, {
+      fallbackKey: toastOptions.toastDescription ?? toastOptions.toastTitle,
     });
   }
 

package/frontend-vue/layers/dms-core/app/utils/composedText.ts

@@ -48,10 +48,17 @@ type ParamFormatter<Param extends ComposedTextTypedParam> = (
   context: ComposedTextContext,
 ) => string;
 
+type ParamOfType<Type extends ComposedTextParamType> =
+  ComposedTextTypedParam extends infer Param
+    ? Param extends { type: infer Types }
+      ? Type extends Types
+        ? Param
+        : never
+      : never
+    : never;
+
 type ParamFormatters = {
-  [Type in ComposedTextParamType]: ParamFormatter<
-    Extract<ComposedTextTypedParam, { type: Type }>
-  >;
+  [Type in ComposedTextParamType]: ParamFormatter<ParamOfType<Type>>;
 };
 
 const DEFAULT_MINOR_DIGITS = 2;
@@ -162,7 +169,7 @@ function formatParam(
     return String(formatNumber(param, context.locale));
   }
   if (isComposedText(param)) return composeText(param, context);
-  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- ParamFormatters preserves the nominal discriminator correlation, which indexed union inference loses. A switch would change legacy lookup behavior for malformed and inherited type keys.
+  // SAFETY: ParamFormatters types each entry as the formatter of the variants whose type includes that key, so for a param typed ComposedTextTypedParam the entry under param.type accepts it; the indexed union loses that correlation.
   const formatter = PARAM_FORMATTERS[param.type] as
     | ParamFormatter<ComposedTextTypedParam>
     | undefined;

package/frontend-vue/layers/dms-core/app/utils/row-action-rule-evaluator.ts

@@ -2,11 +2,7 @@ import { isBoolean } from "./type-check";
 import type { DataTypeFormatter } from "../composables/data-types/useDataType";
 import { get } from "@nuxt/ui/runtime/utils/index.js";
 import type { RowActionRule, RowActionConfig } from "../types/row-action";
-import {
-  FIELD_KEY,
-  FIELD_OPERATORS,
-  LOGICAL_OPERATOR_KEYS,
-} from "../types/row-action-operators";
+import { FIELD_KEY, FIELD_OPERATORS } from "../types/row-action-operators";
 
 type RuleEvaluator = (
   rule: RowActionRule,
@@ -18,39 +14,15 @@ type RuleDictionary = Record<
   Parameters<typeof FIELD_OPERATORS.equals.compare>[0]
 >;
 
-const createLogicalEvaluators = (evaluate: RuleEvaluator) => ({
-  and: (val: RuleDictionary[string], row: Parameters<RuleEvaluator>[1]) =>
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Operator presence does not validate its payload. Owner rule types cannot prove dynamically indexed values; retain the unchecked every call and its existing failures.
-    (val as RowActionRule[]).every((r) => evaluate(r, row)),
-  or: (val: RuleDictionary[string], row: Parameters<RuleEvaluator>[1]) =>
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- The existing rule contract assumes an array here without checking it. Inference cannot prove that assumption and guards would change malformed-input failures.
-    (val as RowActionRule[]).some((r) => evaluate(r, row)),
-  not: (val: RuleDictionary[string], row: Parameters<RuleEvaluator>[1]) =>
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Payload is not runtime-validated. Owner types cannot prove this dynamic value; preserve recursive evaluation's existing behavior.
-    !evaluate(val as RowActionRule, row),
-});
-
-let cachedLogicalEvaluators: ReturnType<typeof createLogicalEvaluators>;
-const getLogicalEvaluators = () => {
-  if (!cachedLogicalEvaluators) {
-    cachedLogicalEvaluators = createLogicalEvaluators(evaluateRowActionRule);
-  }
-  return cachedLogicalEvaluators;
-};
-
 export const evaluateRowActionRule: RuleEvaluator = (rule, row) => {
-  const ruleObj: RuleDictionary = rule;
-  const logicalEvaluators = getLogicalEvaluators();
-
-  for (const operator of LOGICAL_OPERATOR_KEYS) {
-    if (operator in ruleObj) {
-      return logicalEvaluators[operator](ruleObj[operator], row);
-    }
-  }
+  if ("and" in rule)
+    return rule.and.every((r) => evaluateRowActionRule(r, row));
+  if ("or" in rule) return rule.or.some((r) => evaluateRowActionRule(r, row));
+  if ("not" in rule) return !evaluateRowActionRule(rule.not, row);
 
-  if (FIELD_KEY in ruleObj) {
-    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- Presence does not validate the field path. Inference leaves it unknown; adding validation would alter get's existing malformed-input behavior.
-    const fieldValue = get(row, ruleObj[FIELD_KEY] as string);
+  if (FIELD_KEY in rule) {
+    const ruleObj: RuleDictionary = rule;
+    const fieldValue = get(row, rule.field);
     for (const [operator, def] of Object.entries(FIELD_OPERATORS)) {
       if (operator in ruleObj) {
         const compare = def.compare;

package/frontend-vue/layers/dms-core/i18n/locales/core-en-GB.json

@@ -17,6 +17,7 @@
     }
   },
   "error": {
+    "read_only_demo": "Read-only demo, changes are not saved",
     "401": {
       "title": "Access denied",
       "description": "You don't have permission to access this page."

package/frontend-vue/layers/dms-core/i18n/locales/core-fr-FR.json

@@ -17,6 +17,7 @@
     }
   },
   "error": {
+    "read_only_demo": "Démo en lecture seule, les modifications ne sont pas enregistrées",
     "401": {
       "title": "Accès refusé",
       "description": "Vous n'avez pas la permission d'accéder à cette page."

package/frontend-vue/layers/dms-core/shared/types/runtime-config.d.ts

@@ -4,9 +4,15 @@ interface DmsOAuthProviderDescriptor {
   icon: string;
 }
 
+interface DmsLoginPrefillConfig {
+  email: string;
+  password: string;
+}
+
 interface DmsPublicConfig {
   baseURL: string;
   homepage?: string;
+  loginPrefill?: DmsLoginPrefillConfig;
   mustValidateEmail?: boolean;
   clientBaseUrl?: string;
   /**

package/frontend-vue/layers/dms-layout/app/build/components/layout/DashboardSidePanel.vue

@@ -56,8 +56,9 @@ function closeSheetOnEscape(event: KeyboardEvent): void {
 }
 
 function startHandleDrag(event: PointerEvent): void {
-  // SAFETY: The template binds this listener directly to the resize handle div, so currentTarget is that HTMLElement during dispatch.
-  (event.currentTarget as HTMLElement).setPointerCapture(event.pointerId);
+  const handle = event.currentTarget;
+  if (!(handle instanceof HTMLElement)) return;
+  handle.setPointerCapture(event.pointerId);
   const renderedWidth = panelEl.value?.getBoundingClientRect().width;
   startDrag(event, renderedWidth || width.value);
 }

package/frontend-vue/layers/dms-layout/app/build/components/layout/Footer.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import type { SelectItem } from "@nuxt/ui";
+import { GITHUB_REPOSITORY_URL } from "../../utils/github-repository";
 
 const EXTERNAL_LINK_PATTERN = /^https?:\/\//;
 const DEFAULT_COPYRIGHT = "Antelope";
@@ -65,6 +66,19 @@ async function onLocaleChange(code: Parameters<typeof changeLanguage>[0]) {
       </DmsLink>
     </template>
 
+    <a
+      :href="GITHUB_REPOSITORY_URL"
+      target="_blank"
+      rel="noopener noreferrer"
+      :aria-label="t('empty_layout.footer.github_star_label')"
+      :title="t('empty_layout.footer.github_star_label')"
+      class="border-default text-muted hover:text-highlighted hover:border-accented hover:bg-elevated inline-flex h-6 items-center gap-1.5 rounded-md border px-2 font-medium transition-colors max-sm:h-8"
+    >
+      <UIcon name="i-ph-github-logo" class="size-3.5" aria-hidden="true" />
+      <UIcon name="i-ph-star" class="size-3" aria-hidden="true" />
+      {{ t("empty_layout.footer.github_star") }}
+    </a>
+
     <USelect
       v-if="showsLocaleSwitcher"
       :model-value="locale"

package/frontend-vue/layers/dms-layout/app/build/components/layout/PageHeaderActionBar.vue

@@ -75,13 +75,15 @@ const { quickActions } = siteLayout;
 const route = useDmsRoute();
 const router = useDmsRouter();
 const { $authFetch } = useAuthFetch();
+const { presentError } = useApiErrorPresenter();
 
 const { handleCustomButton } = useActionTargets({
   api: $authFetch,
   componentId: "page-header",
   pageId: siteLayout.findMatchingRoute(route.path)?.metadata?.fullId ?? "page",
   refreshCallback: refreshPageBlocks,
-  handleApiError: (error, title) => useApiError(error, { title }),
+  handleApiError: (error, title) =>
+    presentError(error, { fallbackKey: title ?? "error.500.description" }),
 });
 
 function pressComponentButton(componentId: string, buttonId?: string) {