@antelopejs/dms 0.8.3 → 0.9.1

package/frontend-vue/layers/dms-ui/app/composables/useFileReadUrls.ts

@@ -1,105 +1,17 @@
-import { FORM_CONTENT_LANGUAGE_KEY } from "./form/types/content-language";
-
-interface FileMetadataUrlResponse {
-  url: string;
-  expiresAt?: number;
-}
-
-type CachedFileReadUrl = FileMetadataUrlResponse;
-
-const URL_REFRESH_LEAD_MS = 5000;
-const RETRY_DELAY_MS = 5000;
+import { useFileMetadata } from "../build/composables/files/useFileMetadata";
 
 /**
  * Resolves stored file resource keys to read URLs through
- * `/api/files/metadata`. Expiring URLs refresh while visible, and failed
- * lookups remain retryable instead of permanently hiding the file.
+ * `/api/files/metadata`. A key resolved during the setup (an immediate
+ * watcher) is read with the page, the server render included; expiring URLs
+ * refresh while visible, and failed lookups that may heal are retried
+ * instead of permanently hiding the file.
  */
 export function useFileReadUrls(storage?: string) {
-  const { $authFetch } = useAuthFetch();
-  const contentLanguage = inject(FORM_CONTENT_LANGUAGE_KEY, undefined);
-  const urls = ref<Map<string, CachedFileReadUrl>>(new Map());
-  const pendingKeys = new Set<string>();
-  const refreshTimers = new Map<string, ReturnType<typeof setTimeout>>();
-  let isDisposed = false;
-
-  function isFresh(metadata: CachedFileReadUrl): boolean {
-    return (
-      metadata.expiresAt === undefined ||
-      metadata.expiresAt - URL_REFRESH_LEAD_MS > Date.now()
-    );
-  }
-
-  function scheduleRefresh(key: string, expiresAt?: number): void {
-    if (isDisposed || import.meta.env.SSR) return;
-    const currentTimer = refreshTimers.get(key);
-    if (currentTimer) clearTimeout(currentTimer);
-    if (expiresAt === undefined) return;
-    const remaining = Math.max(expiresAt - Date.now(), 0);
-    const refreshLead = Math.min(URL_REFRESH_LEAD_MS, remaining / 2);
-    const delay = Math.max(remaining - refreshLead, 0);
-    refreshTimers.set(
-      key,
-      setTimeout(() => resolve(key, true), delay),
-    );
-  }
-
-  async function resolve(key: string, force = false): Promise<void> {
-    if (isDisposed) return;
-    const cached = urls.value.get(key);
-    if (!force && cached && isFresh(cached)) return;
-    if (pendingKeys.has(key)) return;
-
-    pendingKeys.add(key);
-    try {
-      const metadata = await $authFetch<FileMetadataUrlResponse>(
-        "/api/files/metadata",
-        {
-          query: { resourceKey: key, storage },
-          headers: contentLanguage
-            ? { [CONTENT_LANGUAGE_HEADER]: contentLanguage }
-            : undefined,
-        },
-      );
-      if (isDisposed) return;
-      urls.value.set(key, metadata);
-      scheduleRefresh(key, metadata.expiresAt);
-    } catch {
-      if (isDisposed) return;
-      if (cached?.expiresAt !== undefined && cached.expiresAt <= Date.now()) {
-        urls.value.delete(key);
-      } else if (cached?.expiresAt !== undefined) {
-        scheduleRefresh(key, cached.expiresAt);
-      }
-      if (
-        !import.meta.env.SSR &&
-        (!cached ||
-          (cached.expiresAt !== undefined && cached.expiresAt <= Date.now()))
-      ) {
-        refreshTimers.set(
-          key,
-          setTimeout(() => resolve(key, true), RETRY_DELAY_MS),
-        );
-      }
-    }
-    pendingKeys.delete(key);
-  }
-
-  function getUrl(key: string): string | undefined {
-    const metadata = urls.value.get(key);
-    if (
-      !metadata ||
-      (metadata.expiresAt !== undefined && metadata.expiresAt <= Date.now())
-    ) {
-      return undefined;
-    }
-    return metadata.url;
-  }
-
-  onScopeDispose(() => {
-    isDisposed = true;
-    refreshTimers.forEach(clearTimeout);
-  });
-
-  return { getUrl, resolve };
+  const files = useFileMetadata(storage);
+  return {
+    /** The URL to show `key` with, until it expires; undefined until read. */
+    getUrl: (key: string): string | undefined => files.metadata(key)?.url,
+    resolve: (key: string): Promise<void> => files.resolve(key),
+  };
 }

package/frontend-vue/layers/dms-ui/app/utils/blockRefresh.ts

@@ -11,6 +11,15 @@ export const BLOCK_REFRESH_EVENT = "DmsComponent.Block.Refresh";
  */
 export const LIVE_BLOCK_REFRESH_EVENT = "DmsComponent.Block.LiveRefresh";
 
+/**
+ * The detail of a `refreshPageBlocks()` event: a listener whose refresh
+ * takes time hands its promise to `waitUntil`, and the call resolves once
+ * every one settled.
+ */
+export interface PageBlocksRefreshDetail {
+  waitUntil(work: Promise<unknown>): void;
+}
+
 /** The watch functions every block can name (see interface-dms). */
 export const BlockFunctions = {
   REFRESH_PAGE: "DmsComponent.Block.RefreshPage",
@@ -23,10 +32,30 @@ export const BlockFunctions = {
  * through `BlockFunctions.REFRESH_PAGE` once it saved. A user action always
  * refreshes: on a page declared with `live` it reads even while paused, and
  * the blocks it reads no longer count what they had missed.
+ *
+ * @returns Resolves once the page's data refresh (its `useApiData` reads)
+ *   is done, failed reads included: they keep their `error`
  */
-export function refreshPageBlocks(): void {
-  if (typeof window === "undefined") return;
-  window.dispatchEvent(new CustomEvent(BLOCK_REFRESH_EVENT));
+export function refreshPageBlocks(): Promise<void> {
+  if (typeof window === "undefined") return Promise.resolve();
+  const pending: Array<Promise<unknown>> = [];
+  const detail: PageBlocksRefreshDetail = {
+    waitUntil: (work) => void pending.push(work),
+  };
+  window.dispatchEvent(new CustomEvent(BLOCK_REFRESH_EVENT, { detail }));
+  return Promise.allSettled(pending).then(() => undefined);
+}
+
+/**
+ * Has `refreshPageBlocks()` wait for `work` too, when `event` is one of its
+ * events.
+ */
+export function waitForPageBlocksRefresh(
+  event: Event,
+  work: Promise<unknown>,
+): void {
+  const detail = (event as CustomEvent<PageBlocksRefreshDetail | null>).detail;
+  detail?.waitUntil(work);
 }
 
 /**

package/frontend-vue/package.json

@@ -11,7 +11,7 @@
   "license": "Apache-2.0",
   "packageManager": "pnpm@10.6.5",
   "engines": {
-    "@antelopejs/dms-frontend": ">=0.5.2 <0.6.0"
+    "@antelopejs/dms-frontend": ">=0.6.1 <0.7.0"
   },
   "scripts": {
     "typecheck": "ajs dms verify-source --layer \"$PWD\" --local-package @antelopejs/dms=.. --local-package @antelopejs/interface-dms=../../interface-dms",
@@ -73,8 +73,8 @@
     "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@antelopejs/core": ">=1.13.4 <2",
-    "@antelopejs/dms-frontend": ">=0.5.6 <0.6.0",
+    "@antelopejs/core": ">=1.15.0 <2",
+    "@antelopejs/dms-frontend": ">=0.6.1 <0.7.0",
     "@eslint/js": "^8.57.0",
     "@inertiajs/vue3": "^3.7.0",
     "@nuxt/ui": "4.10.0",

package/frontend-vue/pnpm-lock.yaml

@@ -157,11 +157,11 @@ importers:
         version: 3.25.76
     devDependencies:
       '@antelopejs/core':
-        specifier: '>=1.13.4 <2'
-        version: 1.13.5
+        specifier: '>=1.15.0 <2'
+        version: 1.15.0
       '@antelopejs/dms-frontend':
-        specifier: '>=0.5.6 <0.6.0'
-        version: 0.5.6(@antelopejs/core@1.13.5)
+        specifier: '>=0.6.1 <0.7.0'
+        version: 0.6.1(@antelopejs/core@1.15.0)
       '@eslint/js':
         specifier: ^8.57.0
         version: 8.57.0
@@ -232,20 +232,20 @@ packages:
     resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==}
     engines: {node: '>=10'}
 
-  '@antelopejs/core@1.13.5':
-    resolution: {integrity: sha512-a1Apu8dUvC18j7r7zK4WNpyjRy+xPlL/2bTG1PArrs/b4iWp2UI2ALDJfefJlSa7VNftDevHx7PqVWDl7pX0jg==}
+  '@antelopejs/core@1.15.0':
+    resolution: {integrity: sha512-QpcZqnzwq8uZz4rY0DBZB4OTqWXAGP5MqKXKdbgUbSeirW/ZeBMtCnCfpexKVS+MoJnFJ3RtVJvQcslOMD+8Bw==}
     engines: {node: '>=20.19'}
     hasBin: true
 
-  '@antelopejs/dms-frontend@0.5.6':
-    resolution: {integrity: sha512-bO7kacKMF1rVsIjS208rhPUoIxRYss6ZuQCdQ1Kpq5D3pG0qSvF2pNsi+WecvxTOKM8d6AQAoLl5facu5tyHFQ==}
+  '@antelopejs/dms-frontend@0.6.1':
+    resolution: {integrity: sha512-Dii4YhtlMsfJTjHWCvYdcJmoo7PoMOfW9MVAutNJGNIIMJ4zmF37vZVA2OskpaWFZGI+WdsgI2e2MMOm/8x9QQ==}
     engines: {node: '>=20.12.0'}
     hasBin: true
     peerDependencies:
       '@antelopejs/core': '>=1.13.2 <2'
 
-  '@antelopejs/interface-core@0.1.1':
-    resolution: {integrity: sha512-nGxElt51KGWIwGsUcFdGT7ikQEqDB+mLj4NQ/eFL/DI1+j65GJqq9PdkVT4x3/YKchNA48iMbzXyW7bKUsQ8Iw==}
+  '@antelopejs/interface-core@0.2.1':
+    resolution: {integrity: sha512-yVUov8QS1mnbKlU1GTpCXoB/0UkHFLHIPpowBu8LrR8xG1sEmyjitlRdxT/ClTRmQtF2Acf38LdwHj4I9JB7pA==}
 
   '@antfu/install-pkg@1.1.0':
     resolution: {integrity: sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ==}
@@ -2689,10 +2689,6 @@ packages:
     engines: {node: '>=10.0.0'}
     hasBin: true
 
-  jiti@2.6.1:
-    resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
-    hasBin: true
-
   jiti@2.7.0:
     resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==}
     hasBin: true
@@ -4193,9 +4189,9 @@ snapshots:
 
   '@alloc/quick-lru@5.2.0': {}
 
-  '@antelopejs/core@1.13.5':
+  '@antelopejs/core@1.15.0':
     dependencies:
-      '@antelopejs/interface-core': 0.1.1
+      '@antelopejs/interface-core': 0.2.1
       '@clack/prompts': 1.8.1
       '@types/proper-lockfile': 4.1.4
       commander: 13.1.0
@@ -4208,9 +4204,9 @@ snapshots:
       semver: 7.8.5
       typescript: 5.9.3
 
-  '@antelopejs/dms-frontend@0.5.6(@antelopejs/core@1.13.5)':
+  '@antelopejs/dms-frontend@0.6.1(@antelopejs/core@1.15.0)':
     dependencies:
-      '@antelopejs/core': 1.13.5
+      '@antelopejs/core': 1.15.0
       chokidar: 4.0.3
       commander: 13.1.0
       ignore: 7.0.6
@@ -4223,7 +4219,7 @@ snapshots:
       '@oxc-parser/binding-linux-x64-gnu': 0.95.0
       '@oxc-parser/binding-win32-x64-msvc': 0.95.0
 
-  '@antelopejs/interface-core@0.1.1':
+  '@antelopejs/interface-core@0.2.1':
     dependencies:
       reflect-metadata: 0.2.2
 
@@ -6533,7 +6529,7 @@ snapshots:
       defu: 6.1.7
       esbuild: 0.27.7
       fontaine: 0.8.0
-      jiti: 2.6.1
+      jiti: 2.7.0
       lightningcss: 1.30.2
       magic-string: 0.30.21
       ohash: 2.0.11
@@ -6796,8 +6792,6 @@ snapshots:
       tar-stream: 2.2.0
       try-to-catch: 3.0.1
 
-  jiti@2.6.1: {}
-
   jiti@2.7.0: {}
 
   js-tokens@10.0.0: {}

package/frontend-vue/server/private-options.ts

@@ -0,0 +1,27 @@
+import type { DmsServerEvent } from "#dms/server";
+
+/**
+ * A secret of the DMS's private options, as the frontend server hands them
+ * to its routes. The manifest's value wins; the environment variable of the
+ * same secret is the fallback, read only when the manifest holds none. A
+ * frontend built without the bootstrap credential gets no private options at
+ * all, so the environment variable alone configures it there.
+ *
+ * @param event The route's event
+ * @param section The private options' section (`htmlRender`, `oauth`)
+ * @param key The secret's key in it
+ * @param variable The environment variable that configures it
+ */
+export function privateSecret(
+  event: DmsServerEvent,
+  section: string,
+  key: string,
+  variable: string,
+): string | undefined {
+  const options = event.module.privateOptions[section] as
+    | Record<string, unknown>
+    | undefined;
+  const value = options?.[key];
+  if (typeof value === "string" && value) return value;
+  return process.env[variable] || undefined;
+}

package/frontend-vue/tests/async-data-scope.test.ts

@@ -0,0 +1,121 @@
+// @vitest-environment jsdom
+/**
+ * Every key of the async data lives in the scope of the session's account and
+ * workspace: the browser finds what the server transferred under the same
+ * scope, and a switch of account or workspace drops the previous session's
+ * data instead of showing it under the new one.
+ */
+import {
+  type App,
+  createApp,
+  createSSRApp,
+  defineComponent,
+  h,
+  nextTick,
+  Suspense,
+} from "vue";
+import { renderToString } from "vue/server-renderer";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { DmsFrontendRuntime } from "#dms/frontend-module";
+import { asyncDataScopeOf } from "../layers/dms-core/app/build/utils/asyncDataScope";
+
+const engine = await import("#dms/frontend-module");
+const { default: asyncDataScopePlugin } = await import(
+  "../layers/dms-core/app/plugins/async-data-scope"
+);
+
+const ACCOUNT_A = { accountId: "account-a", activeTenantId: "tenant-1" };
+const ACCOUNT_B = { accountId: "account-b", activeTenantId: "tenant-1" };
+
+const handler = vi.fn(async () => "orders of account A");
+
+const Page = defineComponent({
+  async setup() {
+    const { data } = await engine.useDmsAsyncData("orders", handler);
+    return () => h("p", data.value ?? "none");
+  },
+});
+
+const Root = defineComponent({
+  setup: () => () => h(Suspense, null, { default: () => h(Page) }),
+});
+
+const mounted: App[] = [];
+
+function start(app: App, runtime: DmsFrontendRuntime, session: object) {
+  engine.provideDmsFrontendRuntime(app, runtime);
+  app.runWithContext(() => {
+    engine.useDmsState("dms-session", () => null).value = session;
+    void asyncDataScopePlugin({} as never);
+  });
+}
+
+async function settle(): Promise<void> {
+  await nextTick();
+  await new Promise((done) => setTimeout(done, 0));
+}
+
+beforeEach(async () => {
+  handler.mockClear();
+  await engine.setupFrontendModules([]);
+});
+
+afterEach(() => {
+  mounted.splice(0).forEach((app) => app.unmount());
+});
+
+describe("the async data scope", () => {
+  it("is a digest of the account and the workspace, none when signed out", () => {
+    const scope = asyncDataScopeOf(ACCOUNT_A);
+    expect(scope).toMatch(/^[0-9a-z]+$/);
+    expect(scope).not.toContain("account-a");
+    expect(asyncDataScopeOf({ ...ACCOUNT_A })).toBe(scope);
+    expect(asyncDataScopeOf(ACCOUNT_B)).not.toBe(scope);
+    expect(
+      asyncDataScopeOf({ ...ACCOUNT_A, activeTenantId: "tenant-2" }),
+    ).not.toBe(scope);
+    expect(asyncDataScopeOf(null)).toBeUndefined();
+    expect(asyncDataScopeOf({})).toBeUndefined();
+  });
+
+  it("hands the server's data to the browser under the same session", async () => {
+    const server = engine.createDmsFrontendRuntime(undefined, {}, true);
+    const serverApp = createSSRApp(Root);
+    start(serverApp, server, ACCOUNT_A);
+    expect(await renderToString(serverApp)).toBe("<p>orders of account A</p>");
+    const payload = structuredClone(engine.serializeDmsPayload(server));
+    expect(JSON.stringify(payload)).not.toContain("account-a");
+
+    handler.mockClear();
+    const browser = engine.createDmsFrontendRuntime(undefined, {});
+    const browserApp = createApp(Root);
+    start(browserApp, browser, ACCOUNT_A);
+    engine.restoreDmsPayload(browser, payload);
+    const host = document.createElement("div");
+    browserApp.mount(host);
+    mounted.push(browserApp);
+    await settle();
+
+    expect(handler).not.toHaveBeenCalled();
+    expect(host.textContent).toBe("orders of account A");
+  });
+
+  it("drops the previous account's data once the session switches", async () => {
+    const browser = engine.createDmsFrontendRuntime(undefined, {});
+    const browserApp = createApp(Root);
+    start(browserApp, browser, ACCOUNT_A);
+    const host = document.createElement("div");
+    browserApp.mount(host);
+    mounted.push(browserApp);
+    await settle();
+    expect(host.textContent).toBe("orders of account A");
+
+    browserApp.runWithContext(() => {
+      engine.useDmsState("dms-session", () => null).value = ACCOUNT_B;
+    });
+    await settle();
+
+    expect(browser.asyncData.size).toBe(0);
+    expect(host.textContent).toBe("none");
+  });
+});

package/frontend-vue/tests/auth-middleware-error.test.ts

@@ -8,14 +8,14 @@ const navigateDms = vi.fn();
 beforeEach(() => {
   vi.resetModules();
   vi.stubGlobal("defineDmsMiddleware", (handler: Middleware) => handler);
-  vi.stubGlobal("useError", () => pageError);
-  vi.stubGlobal("abortNavigation", () => false);
+  vi.stubGlobal("useDmsError", () => pageError);
+  vi.stubGlobal("abortDmsNavigation", () => false);
   vi.stubGlobal("navigateDms", navigateDms);
   vi.stubGlobal("useSiteLayout", () => ({
     siteLayout: { value: {} },
     findMatchingRoute: () => ({ metadata: {} }),
   }));
-  vi.stubGlobal("useUserSession", () => ({ loggedIn: { value: false } }));
+  vi.stubGlobal("useDmsUserSession", () => ({ loggedIn: { value: false } }));
 });
 
 afterEach(() => {

package/frontend-vue/tests/banner-block-fetch.test.ts

@@ -7,6 +7,7 @@
  */
 import { createApp, defineComponent, h, reactive, ref } from "vue";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import { refreshPageBlocks } from "../layers/dms-ui/app/utils/blockRefresh";
 
 const requests: string[] = [];
@@ -93,6 +94,8 @@ function mountBanner(props: Record<string, unknown>) {
   };
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   requests.length = 0;
   pressed.length = 0;

package/frontend-vue/tests/block-fetch-options-forwarding.test.ts

@@ -6,6 +6,7 @@
 import { type Component, createSSRApp, defineComponent, h, ref } from "vue";
 import { renderToString } from "vue/server-renderer";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import type { UseChartFetchOptions } from "../layers/dms-ui/app/composables/chart/useChartFetch";
 
 const fetchOptions: Array<UseChartFetchOptions<unknown>> = [];
@@ -78,6 +79,8 @@ async function render(block: Component): Promise<void> {
   await renderToString(app);
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   fetchOptions.length = 0;
   vi.stubGlobal("useI18n", () => ({ locale: ref("en-GB"), t: String }));

package/frontend-vue/tests/block-items-period-realtime.test.ts

@@ -7,6 +7,7 @@
  */
 import { createApp, defineComponent, h, nextTick, reactive, ref } from "vue";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import type { RealtimeTopicHandler } from "../layers/dms-core/app/composables/realtime/useUserRealtime";
 
 const requests: string[] = [];
@@ -106,6 +107,8 @@ function mountRealtimeBlock(probe: ItemsProbe) {
   mounted.push(app);
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   requests.length = 0;
   revision = 1;

package/frontend-vue/tests/block-not-found.test.ts

@@ -16,6 +16,7 @@ import {
   ref,
 } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import { readFetchNotFound } from "../layers/dms-ui/app/build/utils/fetchNotFound";
 
 interface FetchFailure extends Error {
@@ -92,6 +93,8 @@ function mount(component: Component): HTMLElement {
   return host;
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   answers.clear();
   route.query = { workspace: "web" };
@@ -157,12 +160,23 @@ describe("useChartFetch on a 404", () => {
     );
   });
 
-  it("keeps them on any other failure", async () => {
+  it("keeps them when a read of the same request fails otherwise", async () => {
     const state = mountFetch();
     await settle();
-    await switchWorkspace("down");
+    answers.set("/api/kpis?workspace=web", failure(500));
+    await state.refresh?.();
+    await settle();
     expect(state.data?.value).toEqual({ items: [{ label: "web" }] });
   });
+
+  it("never shows a record's values for another request that failed", async () => {
+    // They belong to another workspace: the card shows its failure instead.
+    const state = mountFetch();
+    await settle();
+    await switchWorkspace("down");
+    expect(state.data?.value).toBeNull();
+    expect(state.error?.value).toBeTruthy();
+  });
 });
 
 describe("useBlockItems on a 404", () => {

package/frontend-vue/tests/block-page-refresh.test.ts

@@ -7,6 +7,7 @@
  */
 import { createApp, defineComponent, h, ref } from "vue";
 import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import {
   BlockFunctions,
   refreshPageBlocks,
@@ -64,6 +65,8 @@ function mountBlock(fetchUrl: string) {
 
 const apps: Array<() => void> = [];
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   requests.length = 0;
   answer = 1;

package/frontend-vue/tests/block-route-params.test.ts

@@ -15,6 +15,7 @@ import {
   ref,
 } from "vue";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useRealDataEngine } from "./fixtures/dataEngine";
 import {
   replaceUrlVariables,
   resolveTextVariables,
@@ -59,6 +60,8 @@ function mount(component: Component) {
   mounted.push(app);
 }
 
+beforeEach(() => useRealDataEngine());
+
 beforeEach(() => {
   requests.length = 0;
   route.query = {};

package/frontend-vue/tests/branding-defaults.test.ts

@@ -0,0 +1,34 @@
+import { defu } from "defu";
+import { describe, expect, it } from "vitest";
+import appConfig from "../layers/dms-layout/app/app.config";
+
+const ANTELOPE_ICON = "/images/antelope-logo/icon.svg";
+
+describe("branding defaults", () => {
+  it("hold the palettes and logos the layout ships", () => {
+    expect(appConfig.branding.defaults).toEqual({
+      colors: appConfig.ui.colors,
+      logo: appConfig.branding.logo,
+    });
+    expect(appConfig.branding.defaults.colors.primary).toBe("dms");
+    expect(appConfig.branding.logo.favicon).toEqual({
+      light: ANTELOPE_ICON,
+      dark: ANTELOPE_ICON,
+    });
+  });
+
+  it("survive a live edit of the merged palette and logos", () => {
+    // A clone keeps any object shared between the two places, like the
+    // loader's merge keeps the objects no layer overrides.
+    const merged = defu(
+      { branding: { footer: { githubStar: false } } },
+      structuredClone(appConfig),
+    );
+
+    merged.ui.colors.primary = "violet";
+    merged.branding.logo.favicon!.light = "/branding/icon.png";
+
+    expect(merged.branding.defaults.colors.primary).toBe("dms");
+    expect(merged.branding.defaults.logo.favicon?.light).toBe(ANTELOPE_ICON);
+  });
+});