@antelopejs/dms 0.11.0 → 0.12.0

package/frontend-vue/layers/dms-layout/app/composables/layout/usePageHeaderActions.ts

@@ -1,189 +1 @@
-import {
-  defineComponent,
-  inject,
-  onBeforeMount,
-  onBeforeUnmount,
-  onErrorCaptured,
-  onServerPrefetch,
-  provide,
-  readonly,
-  ref,
-  shallowRef,
-  type Component,
-  type InjectionKey,
-  type Ref,
-  type ShallowRef,
-  type VNodeChild,
-} from "vue";
-
-/** Renders the actions shown on the right of the page header. */
-export type PageHeaderActionsRender = () => VNodeChild;
-
-/** Where the actions of `usePageHeaderActions` go in the page header. */
-export interface PageHeaderActionsOptions {
-  /**
-   * Place among the buttons the page layout serves (`headerActions`, each
-   * with its own `order`), smallest first; defaults to `0`. At an equal
-   * order the served buttons come first, so `-1` puts these actions before
-   * every served button left at the default.
-   */
-  order?: number;
-}
-
-/** The order of actions that do not name one, and of served buttons. */
-export const DEFAULT_PAGE_HEADER_ACTIONS_ORDER = 0;
-
-/**
- * What a layout rendering a page header shares with the page in its slot.
- *
- * The header renders before the page, yet its actions come from the page.
- * On the server, the header's outlet defers its render (a server prefetch)
- * until the page has set up, so the actions are in the server-rendered
- * markup. In the browser, the outlet keeps that markup as it is until the
- * page has set up again, then renders the live actions over it: no pop-in,
- * no hydration mismatch.
- */
-export interface PageHeaderActionsHost {
-  /** The render function the page asked for, if any. */
-  actions: ShallowRef<PageHeaderActionsRender | null>;
-  /** The `order` the page gave its actions. */
-  actionsOrder: Readonly<Ref<number>>;
-  /** Places the page's actions among the served buttons. */
-  setActionsOrder: (order: number) => void;
-  /** Once the page in the slot has set up and set its actions. */
-  isReady: Readonly<Ref<boolean>>;
-  /** Called right after the page in the slot rendered (its sync setup ran). */
-  markSlotRendered: () => void;
-  /** A page announces its actions; the returned callback says they are set. */
-  expect: () => () => void;
-  /** Settles with `isReady`. */
-  whenReady: () => Promise<void>;
-}
-
-const PAGE_HEADER_ACTIONS_KEY: InjectionKey<PageHeaderActionsHost> = Symbol(
-  "dms:page-header-actions",
-);
-
-// A server render must never hang on a page that announced actions and then
-// failed in a way no error hook saw: past this delay the header renders
-// without them.
-const SERVER_READY_TIMEOUT_MS = 5000;
-
-/**
- * Called by a layout that renders a page header: shares the actions state
- * with the page in its slot.
- */
-export const providePageHeaderActions = (): PageHeaderActionsHost => {
-  const actions = shallowRef<PageHeaderActionsRender | null>(null);
-  const actionsOrder = ref(DEFAULT_PAGE_HEADER_ACTIONS_ORDER);
-  const isReady = ref(false);
-  let slotRendered = false;
-  let pending = 0;
-  let resolveReady: () => void = () => {};
-  const ready = new Promise<void>((resolve) => {
-    resolveReady = resolve;
-  });
-  const markReady = () => {
-    isReady.value = true;
-    resolveReady();
-  };
-  const settle = () => {
-    if (slotRendered && pending === 0) markReady();
-  };
-  if (import.meta.env.SSR) setTimeout(markReady, SERVER_READY_TIMEOUT_MS);
-  // A page whose setup throws never sets its actions: stop waiting for it.
-  onErrorCaptured(() => {
-    pending = 0;
-    settle();
-  });
-  const host: PageHeaderActionsHost = {
-    actions,
-    actionsOrder: readonly(actionsOrder),
-    setActionsOrder: (order) => {
-      actionsOrder.value = order;
-    },
-    isReady: readonly(isReady),
-    markSlotRendered: () => {
-      slotRendered = true;
-      settle();
-    },
-    expect: () => {
-      pending++;
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        pending = Math.max(0, pending - 1);
-        settle();
-      };
-    },
-    whenReady: () => ready,
-  };
-  provide(PAGE_HEADER_ACTIONS_KEY, host);
-  return host;
-};
-
-/** The actions state of the enclosing layout, if any (for its outlet). */
-export const injectPageHeaderActionsHost = (): PageHeaderActionsHost | null =>
-  inject(PAGE_HEADER_ACTIONS_KEY, null);
-
-/**
- * Holds the header actions back while an async part of the page (a page
- * whose setup awaits before rendering its blocks) has not rendered yet: a
- * block in it may still ask for actions. Call it before the setup's first
- * await, and render the returned marker after the content it holds for.
- *
- * @returns The marker component to render after the held content
- */
-export const holdPageHeaderActions = (): Component => {
-  const host = inject(PAGE_HEADER_ACTIONS_KEY, null);
-  const release = host?.expect() ?? (() => {});
-  onBeforeUnmount(release);
-  return defineComponent({
-    name: "DmsPageContentRendered",
-    setup() {
-      release();
-      return () => null;
-    },
-  });
-};
-
-/**
- * Puts actions in the page header (a primary button, a status pill…) from a
- * page rendered inside a layout. The actions show once the page has set up
- * (so the render function may read anything the setup declares) and are
- * removed when the page unmounts. Outside such a layout the call does
- * nothing.
- *
- * Call it before the first `await` of the setup: the header then renders
- * the actions in the server pass, with the page.
- *
- * They come after the buttons the page layout serves (`headerActions`)
- * unless `options.order` places them among those.
- *
- * @param render Render function of the actions, e.g. `() => h(UButton, …)`
- * @param options Where the actions go among the served buttons
- */
-export const usePageHeaderActions = (
-  render: PageHeaderActionsRender,
-  options: PageHeaderActionsOptions = {},
-): void => {
-  const host = inject(PAGE_HEADER_ACTIONS_KEY, null);
-  if (!host) return;
-  const release = host.expect();
-  const show = () => {
-    host.setActionsOrder(options.order ?? DEFAULT_PAGE_HEADER_ACTIONS_ORDER);
-    host.actions.value = render;
-    release();
-  };
-  // Both hooks on both sides: each only ever fires on its own side, and a
-  // server prefetch hook marks the component as an async boundary, which
-  // `useId` counts. Registered on one side only, every id rendered after
-  // the page would differ between the server and the browser.
-  onServerPrefetch(show);
-  onBeforeMount(show);
-  onBeforeUnmount(() => {
-    release();
-    if (host.actions.value === render) host.actions.value = null;
-  });
-};
+export * from "#dms-ui/app/composables/layout/usePageHeaderActions";

package/frontend-vue/layers/dms-layout/app/composables/layout/useServedHeaderActions.ts

@@ -7,14 +7,14 @@ import {
 } from "vue";
 import { onPageBlocksRefresh } from "#dms-ui/app/utils/blockRefresh";
 import type { LayoutHeaderAction } from "../../build/components/layout/PageHeaderActionBar.vue";
-import type { PageLayout } from "../../types/page";
+import type { PageLayout } from "#dms-core/app/types/page";
 import {
   isSamePageQuery,
   isSameRouteParams,
   fillRouteParams,
   layoutUrlWithQuery,
   pageQueryValues,
-} from "../../utils/pageQuery";
+} from "#dms-core/app/utils/pageQuery";
 
 interface ServedHeaderActionsOptions {
   /** The buttons the page layout was served with. */
@@ -56,24 +56,23 @@ export function useServedHeaderActions({
   async function askFor(url: string, query: Record<string, string>) {
     const request = ++latestRequest;
     const { $authFetch } = useAuthFetch();
+    // prettier-ignore
     try {
       const layout = await $authFetch<PageLayout>(
         layoutUrlWithQuery(url, query),
       );
       if (request !== latestRequest) return;
-      const options = layout.layout.options as
-        | { headerActions?: LayoutHeaderAction[] }
-        | undefined;
+      const options: { headerActions?: LayoutHeaderAction[] } | undefined =
+        layout.layout.options;
       refreshed.value = options?.headerActions ?? [];
     } catch {
-      // The buttons resolved for the previous query stay: the operation
-      // behind each one still refuses on its own.
+      // eslint-disable-line no-empty -- A failed refresh retains prior buttons; availability is not authorization, so target operations must enforce their own access checks.
     }
   }
 
   function follow() {
     const served = servedQuery();
-    const current = pageQueryValues(route.query as Record<string, unknown>);
+    const current = pageQueryValues(route.query);
     const match = pageRoute();
     const layoutUrl = match?.metadata?.layoutUrl;
     const params = match?.params ?? {};
@@ -96,7 +95,7 @@ export function useServedHeaderActions({
     if (!servedQuery() || !layoutUrl) return;
     void askFor(
       fillRouteParams(layoutUrl, pageRoute()?.params ?? {}),
-      pageQueryValues(route.query as Record<string, unknown>),
+      pageQueryValues(route.query),
     );
   }
 

package/frontend-vue/layers/dms-layout/app/composables/notification/useNotifications.ts

@@ -54,17 +54,7 @@ const NOTIFICATIONS_PAGE_SIZE = 20;
 const buildListUrl = (offset: number) =>
   `${API_BASE}/list?limit=${NOTIFICATIONS_PAGE_SIZE}&offset=${offset}`;
 
-/**
- * Shared notification state of the header bell (unread count and tone,
- * popover feed) and of the settings navigation; the settings inbox is a
- * table view of its own (`dms:inbox`), which lists the feed again when these
- * counts change.
- *
- * The bell and the Notifications entry show the same badge: `unreadCount`,
- * the whole feed's unread total, in `unreadTone`. Opening the bell changes
- * neither; a notification leaves the count once opened or marked read.
- */
-export const useNotifications = () => {
+const useNotificationFeed = () => {
   const { $authFetch } = useAuthFetch();
   const { sendComponentEvent } = useComponentEvent();
   const unreadCount = useDmsState<number>(
@@ -75,8 +65,7 @@ export const useNotifications = () => {
     "notifications-unread-tone",
     () => undefined,
   );
-  // Whether the counts have been asked once, answered or not: until then,
-  // a 0 unread is not known to be true.
+
   const areCountsLoaded = useDmsState<boolean>(
     "notifications-counts-loaded",
     () => false,
@@ -170,6 +159,96 @@ export const useNotifications = () => {
     else await fetchBellCounts();
   };
 
+  return {
+    $authFetch,
+    sendComponentEvent,
+    unreadCount,
+    unreadTone,
+    areCountsLoaded,
+    unreadPreview,
+    notifications,
+    offset,
+    hasMore,
+    setReadState,
+    setAllRead,
+    removeFromLists,
+    emitRead,
+    emitCount,
+    fetchBellCounts,
+    readBellCounts,
+    applyBellCounts,
+    takeWriteCounts,
+  };
+};
+
+function createRemoteFeedHandlers(
+  feed: ReturnType<typeof useNotificationFeed>,
+) {
+  const {
+    setReadState,
+    unreadPreview,
+    takeWriteCounts,
+    emitRead,
+    emitCount,
+    setAllRead,
+  } = feed;
+
+  const handleRemoteRead = async (ids: string[], counts?: FeedCounts) => {
+    if (ids.length === 0) return;
+    setReadState(ids, true);
+    unreadPreview.value = unreadPreview.value.filter((n) => !n.isRead);
+    await takeWriteCounts(counts);
+    emitRead(ids);
+  };
+
+  const handleRemoteUnread = async (ids: string[], counts?: FeedCounts) => {
+    if (ids.length === 0) return;
+    setReadState(ids, false);
+    await takeWriteCounts(counts);
+    emitCount();
+  };
+
+  const handleRemoteAllRead = async (counts?: FeedCounts) => {
+    setAllRead();
+    await takeWriteCounts(counts);
+    emitCount();
+  };
+
+  return { handleRemoteRead, handleRemoteUnread, handleRemoteAllRead };
+}
+
+/**
+ * Shared notification state of the header bell (unread count and tone,
+ * popover feed) and of the settings navigation; the settings inbox is a
+ * table view of its own (`dms:inbox`), which lists the feed again when these
+ * counts change.
+ *
+ * The bell and the Notifications entry show the same badge: `unreadCount`,
+ * the whole feed's unread total, in `unreadTone`. Opening the bell changes
+ * neither; a notification leaves the count once opened or marked read.
+ */
+export const useNotifications = () => {
+  const feed = useNotificationFeed();
+  const {
+    $authFetch,
+    sendComponentEvent,
+    unreadCount,
+    unreadTone,
+    areCountsLoaded,
+    unreadPreview,
+    notifications,
+    offset,
+    hasMore,
+    setReadState,
+    removeFromLists,
+    emitRead,
+    emitCount,
+    fetchBellCounts,
+    readBellCounts,
+    applyBellCounts,
+    takeWriteCounts,
+  } = feed;
+
   const fetchUnreadPreview = async () => {
     const data = await $authFetch<UserNotification[]>(
       `${API_BASE}/unread-preview`,
@@ -233,28 +312,8 @@ export const useNotifications = () => {
     );
   };
 
-  // The realtime events of the user's feed, this tab's own writes included:
-  // each carries the feed's counts after it.
-  const handleRemoteRead = async (ids: string[], counts?: FeedCounts) => {
-    if (ids.length === 0) return;
-    setReadState(ids, true);
-    unreadPreview.value = unreadPreview.value.filter((n) => !n.isRead);
-    await takeWriteCounts(counts);
-    emitRead(ids);
-  };
-
-  const handleRemoteUnread = async (ids: string[], counts?: FeedCounts) => {
-    if (ids.length === 0) return;
-    setReadState(ids, false);
-    await takeWriteCounts(counts);
-    emitCount();
-  };
-
-  const handleRemoteAllRead = async (counts?: FeedCounts) => {
-    setAllRead();
-    await takeWriteCounts(counts);
-    emitCount();
-  };
+  const { handleRemoteRead, handleRemoteUnread, handleRemoteAllRead } =
+    createRemoteFeedHandlers(feed);
 
   /**
    * A notification pushed in real time: listed first, counted unread, and its
@@ -324,8 +383,7 @@ export function useRenderedBellCounts(): void {
       return counts;
     },
   );
-  // A client navigation into the dashboard mounts the bell before this read
-  // answers: the bell waits for it instead of reading the counts again.
+
   if (!import.meta.env.SSR)
     renderedBellCountsRead = Promise.resolve(read).then(
       () => undefined,

package/frontend-vue/layers/dms-layout/app/composables/page/useFirstAccessiblePage.ts

@@ -1,7 +1,3 @@
-// Pass 1 hides the sidebar's own exclusions (settings + module trees). Pass 2
-// re-includes `settings` as a last resort but still hides modules: module pages
-// have their own routing/context and are never a redirect target (module roots
-// are skipped below, matching the sidebar).
 const SIDEBAR_EXCLUDED_TOP_LEVEL_IDS = new Set(["settings", "modules"]);
 const LAST_RESORT_EXCLUDED_TOP_LEVEL_IDS = new Set(["modules"]);
 
@@ -9,10 +5,6 @@ interface FirstAccessiblePageOptions {
   excludedTopLevelIds: Set<string>;
 }
 
-// A landing target must be a real, directly reachable page: it needs a layout,
-// a concrete slug (no `:id` placeholder), and must not be `hidden` — hidden
-// pages include the table-view `new`/`edit` sub-pages, which are not valid
-// destinations to drop a user on.
 function isNavigablePage(node: SiteLayoutTree): boolean {
   return (
     !!node.layoutUrl &&
@@ -22,9 +14,6 @@ function isNavigablePage(node: SiteLayoutTree): boolean {
   );
 }
 
-// A category whose own `hasAccess` is false can still hold accessible pages,
-// so only leaf pages are filtered on `hasAccess`; containers are always
-// traversed. Module roots are skipped entirely (never descended into).
 function findFirstAccessiblePage(
   node: SiteLayoutTree,
   options: FirstAccessiblePageOptions,

package/frontend-vue/layers/dms-layout/app/composables/page/useModuleHistory.ts

@@ -1,5 +1,10 @@
+import {
+  isObject,
+  isString,
+  isNumber,
+} from "../../../../dms-core/app/utils/type-check";
 const MODULE_HISTORY_COOKIE = "dms-module-history";
-// Kept for a year and bounded, so the cookie stays small on every request.
+
 const MODULE_HISTORY_MAX_AGE_SECONDS = 60 * 60 * 24 * 365;
 const MODULE_HISTORY_MAX_ENTRIES = 12;
 const MODULE_HISTORY_MAX_PATH_LENGTH = 300;
@@ -23,21 +28,22 @@ interface StoredVisit {
   at: number;
 }
 
-type StoredHistory = Record<string, StoredVisit>;
+type StoredHistory = Record<ModuleHistoryEntry["moduleId"], StoredVisit>;
 
 /**
  * Reads whatever the cookie holds into a clean history, dropping anything
  * malformed: a hand-edited cookie or an older shape must never break the
  * modules page or the command palette.
  */
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- Cookie normalization accepts malformed and old data. A cookie happy-path type would hide the validation boundary.
 function normalizeHistory(raw: unknown): StoredHistory {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  if (!raw || !isObject(raw) || Array.isArray(raw)) return {};
   const result: StoredHistory = {};
   for (const [moduleId, value] of Object.entries(raw)) {
-    if (!value || typeof value !== "object") continue;
-    const { path, at } = value as Partial<StoredVisit>;
-    if (typeof path !== "string" || !path.startsWith("/")) continue;
-    result[moduleId] = { path, at: typeof at === "number" ? at : 0 };
+    if (!value || !isObject(value)) continue;
+    const { path, at } = value;
+    if (!isString(path) || !path.startsWith("/")) continue;
+    result[moduleId] = { path, at: isNumber(at) ? at : 0 };
   }
   return result;
 }
@@ -61,10 +67,7 @@ export const useModuleHistory = (): ModuleHistoryApi => {
     if (!moduleId || !path || path.length > MODULE_HISTORY_MAX_PATH_LENGTH) {
       return;
     }
-    // Re-insert the key so a revisited module moves to the end: a plain
-    // spread would keep its first-visit position and break the
-    // oldest-to-newest ordering `entries` guarantees. The oldest visits
-    // fall off once the history is full.
+
     const { [moduleId]: _previous, ...others } = history.value;
     const kept = Object.entries(others).slice(
       -(MODULE_HISTORY_MAX_ENTRIES - 1),

package/frontend-vue/layers/dms-layout/app/composables/page/useModuleStore.ts

@@ -3,7 +3,7 @@ import type {
   StoreListing,
   StoreListingEntry,
   StoreOperationKind,
-} from "../../types/module-store";
+} from "#dms-core/app/types/module-store";
 import { isAwaitingFrontend } from "../../build/utils/module-store-catalog";
 
 export const ENDPOINT_STORE_LISTING = "/dms/store/listing";
@@ -22,16 +22,13 @@ const FOLLOW_INTERVAL_MS = 1000;
  * never move once mounted.
  */
 export const useModuleStore = () => {
-  // Taken once, in setup: the follow-up reads the listing from a timer,
-  // outside any component context.
   const { $authFetch } = useAuthFetch();
   const isOwner = useIsOwner();
-  // Platform owners only: a member's read would be refused.
+
   const initial = useApiData<StoreListing>(() =>
     isOwner.value ? ENDPOINT_STORE_LISTING : null,
   );
-  // The follow-up reads write into the same data, so a later visit shows
-  // the latest listing at once.
+
   const listing = computed<StoreListing | undefined>({
     get: () => initial.data.value ?? undefined,
     set: (value) => {

package/frontend-vue/layers/dms-layout/app/composables/page/useModuleStoreActions.ts

@@ -1,3 +1,4 @@
+import { isString } from "../../../../dms-core/app/utils/type-check";
 import type { Ref, VNode } from "vue";
 import ModuleStoreDependencyPicker from "../../build/components/pages/modules/ModuleStoreDependencyPicker.vue";
 import {
@@ -18,7 +19,7 @@ import {
 import type {
   StoreActionBody,
   StoreOperationKind,
-} from "../../types/module-store";
+} from "#dms-core/app/types/module-store";
 import type { useModuleStore } from "./useModuleStore";
 
 /** What a refused store request carries: the server's error key, if any. */
@@ -35,6 +36,23 @@ export interface StoreFrontendNotice {
 
 type ModuleStore = ReturnType<typeof useModuleStore>;
 
+function renderDependencyPicker(
+  entry: ModuleStoreEntry,
+  drafts: Ref<DependencyDraft[]>,
+  showErrors: boolean,
+): VNode {
+  return h(ModuleStoreDependencyPicker, {
+    missing: entry.missingInterfaces,
+    drafts: drafts.value,
+    showErrors,
+    onUpdate: (index: number, patch: Partial<DependencyDraft>) => {
+      drafts.value = drafts.value.map((draft, position) =>
+        position === index ? { ...draft, ...patch } : draft,
+      );
+    },
+  });
+}
+
 /**
  * The store's actions as both Modules views run them: the confirmations,
  * the install dialog that picks the modules for missing interfaces, and a
@@ -50,9 +68,11 @@ export const useModuleStoreActions = (
   const toast = useToast();
   const { confirm } = useConfirm();
 
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Store requests can reject with arbitrary JavaScript values; the store's Promise contract has no rejection owner type.
   function resolveStoreError(error: unknown): string {
+    // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- This existing unchecked optional-property view is not validation of a StoreRequestError; inference cannot establish that rejected values have this shape, and parsing would change malformed-error behavior.
     const details = error as StoreRequestError | undefined;
-    const key = typeof details?.data === "string" ? details.data : undefined;
+    const key = isString(details?.data) ? details.data : undefined;
     if (!key) return details?.message ?? "";
     return t(`modules.store.errors.${key.replace("error.", "")}`);
   }
@@ -81,23 +101,6 @@ export const useModuleStoreActions = (
   /** What the owner last picked in a module's install dialog, for a retry. */
   const lastDependencyDrafts = new Map<string, DependencyDraft[]>();
 
-  function renderDependencyPicker(
-    entry: ModuleStoreEntry,
-    drafts: Ref<DependencyDraft[]>,
-    showErrors: boolean,
-  ): VNode {
-    return h(ModuleStoreDependencyPicker, {
-      missing: entry.missingInterfaces,
-      drafts: drafts.value,
-      showErrors,
-      onUpdate: (index: number, patch: Partial<DependencyDraft>) => {
-        drafts.value = drafts.value.map((draft, position) =>
-          position === index ? { ...draft, ...patch } : draft,
-        );
-      },
-    });
-  }
-
   /**
    * Asks which modules implement the interfaces the release misses, then
    * installs them with it. A refusal shows in the dialog, kept open.

package/frontend-vue/layers/dms-layout/app/composables/page/useModulesListing.ts

@@ -1,4 +1,4 @@
-import type { ModuleCatalogEntry } from "../../types/page";
+import type { ModuleCatalogEntry } from "#dms-core/app/types/page";
 
 /**
  * Why the catalog could not be loaded: `forbidden` when the server refused
@@ -12,13 +12,16 @@ export interface ModulesListingError {
 
 export const ENDPOINT_MODULES_LISTING = "/dms/modules-listing";
 
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- API failures can be any thrown value. Inference is unavailable here and the parsed ModulesListingError owner would exclude malformed and network failures.
 function readStatus(error: unknown): number | undefined {
+  // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- This legacy projection does not validate status fields. Deriving from the fetch error cannot prove arbitrary thrown values; adding validation would change malformed-input behavior.
   const details = error as
     | { response?: { status?: number }; statusCode?: number; status?: number }
     | undefined;
   return details?.response?.status ?? details?.statusCode ?? details?.status;
 }
 
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- This boundary maps arbitrary API failures. The parsed result type cannot describe rejection reasons, and inference provides no parameter contract.
 function toListingError(error: unknown): ModulesListingError {
   const status = readStatus(error);
   if (status === HTTP_FORBIDDEN) return { kind: "forbidden", status };
@@ -39,7 +42,7 @@ export const useModulesListing = () => {
   const loadingError = computed<ModulesListingError | null>(() =>
     listing.error.value ? toListingError(listing.error.value) : null,
   );
-  // A failed read replaces the modules with the error.
+
   const modules = computed<ModuleCatalogEntry[] | undefined>(() =>
     loadingError.value ? undefined : (listing.data.value ?? undefined),
   );

package/frontend-vue/layers/dms-layout/app/composables/page/usePageComponentPreload.ts

@@ -1,3 +1,5 @@
+import type { AsyncComponentLoader } from "vue";
+
 function collectFromComponentInfo(
   info: ComponentInfo | undefined,
   names: Set<string>,
@@ -33,25 +35,22 @@ export function collectPageLayoutComponentNames(
   return [...names];
 }
 
-interface AsyncComponentLoader {
-  __asyncLoader?: () => Promise<unknown>;
+interface AsyncComponentWithLoader {
+  __asyncLoader?: AsyncComponentLoader;
 }
 
-function loadPageLayoutComponents(
-  layout: PageLayout | null | undefined,
-): Promise<unknown> {
+function loadPageLayoutComponents(layout: PageLayout | null | undefined) {
   return Promise.all(
-    collectPageLayoutComponentNames(layout).map((name) =>
-      (
-        resolveDmsComponent(name) as AsyncComponentLoader | undefined
-      )?.__asyncLoader?.(),
-    ),
+    collectPageLayoutComponentNames(layout).map((name) => {
+      // oxlint-disable-next-line anti-slop/require-safety-comment-for-type-assertion -- resolveDmsComponent exposes Vue's public Component union, not its optional internal loader; the loader's callable type comes from Vue and access remains unchecked for custom components.
+      const component = resolveDmsComponent(name) as
+        | AsyncComponentWithLoader
+        | undefined;
+      return component?.__asyncLoader?.();
+    }),
   );
 }
 
-// How long a navigation waits for the chunks of the page's blocks: on any
-// usable network they land well within it, and one that hangs does not hold
-// the page for long (its block then loads as it renders).
 export const PAGE_COMPONENTS_WAIT_MS = 3_000;
 
 /**