@nocobase/app-template-default 1.0.0-beta.88 → 1.0.0-beta.90

package/tests/playwright/dialog-footer.test.ts

@@ -0,0 +1,227 @@
+/// <reference lib="dom" />
+import { expect, test, type Locator, type Page } from '@playwright/test';
+import path from 'node:path';
+
+const applicationUrl = process.env.APP_URL;
+test.skip(!applicationUrl, 'Set APP_URL to the running application entry.');
+const fixture = `${applicationUrl?.replace(/\/$/, '')}/tests/fixtures/dialog-footer.html`;
+
+async function geometry(page: Page) {
+  return page.getByTestId('cancel').evaluate((cancel) => {
+    const submit = document.querySelector('[data-testid=submit]')!;
+    const footer = cancel.parentElement!;
+    const panel = cancel.closest('[role=dialog], [role=alertdialog]')!;
+    const measure = (element: Element) => {
+      const rect = element.getBoundingClientRect();
+      const css = getComputedStyle(element);
+      return {
+        x: rect.x,
+        y: rect.y,
+        right: rect.right,
+        bottom: rect.bottom,
+        height: rect.height,
+        width: rect.width,
+        paddingLeft: css.paddingLeft,
+        paddingRight: css.paddingRight,
+        paddingTop: css.paddingTop,
+        paddingBottom: css.paddingBottom,
+        minHeight: parseFloat(css.minHeight),
+        overflow: element.scrollWidth > element.clientWidth + 1,
+      };
+    };
+    return {
+      cancel: measure(cancel),
+      submit: measure(submit),
+      footer: measure(footer),
+      panel: measure(panel),
+      horizontal:
+        getComputedStyle(footer).flexDirection === 'row' ||
+        getComputedStyle(footer).display === 'grid',
+    };
+  });
+}
+
+async function checkGeometry(page: Page) {
+  await expect(page.getByTestId('cancel')).toBeVisible();
+  let previous = '';
+  await expect
+    .poll(async () => {
+      const current = JSON.stringify(await geometry(page));
+      const stable = current === previous;
+      previous = current;
+      return stable;
+    })
+    .toBe(true);
+  const result = await geometry(page);
+  const { cancel, submit, footer, panel, horizontal } = result;
+  expect(cancel.height).toBeGreaterThanOrEqual(cancel.minHeight - 1);
+  expect(submit.height).toBeGreaterThanOrEqual(submit.minHeight - 1);
+  expect(cancel.paddingLeft).toBe(submit.paddingLeft);
+  expect(cancel.paddingRight).toBe(submit.paddingRight);
+  expect(cancel.paddingTop).toBe(submit.paddingTop);
+  expect(cancel.paddingBottom).toBe(submit.paddingBottom);
+  if (horizontal) {
+    expect(Math.abs(cancel.y - submit.y)).toBeLessThan(1);
+    expect(Math.abs(cancel.bottom - submit.bottom)).toBeLessThan(1);
+    expect(cancel.right).toBeLessThanOrEqual(submit.x + 1);
+  } else {
+    expect(submit.bottom).toBeLessThanOrEqual(cancel.y + 1);
+  }
+  for (const button of [cancel, submit]) {
+    expect(button.overflow).toBe(false);
+    expect(button.x).toBeGreaterThanOrEqual(panel.x);
+    expect(button.right).toBeLessThanOrEqual(panel.right + 1);
+    expect(button.y).toBeGreaterThanOrEqual(footer.y);
+    expect(button.bottom).toBeLessThanOrEqual(panel.bottom + 1);
+    expect(button.bottom).toBeLessThanOrEqual(page.viewportSize()!.height);
+  }
+  expect(panel.x).toBeGreaterThanOrEqual(0);
+  expect(panel.right).toBeLessThanOrEqual(page.viewportSize()!.width);
+  expect(panel.overflow).toBe(false);
+  return result;
+}
+
+async function screenshot(page: Page, name: string) {
+  if (process.env.DIALOG_EVIDENCE_DIR) {
+    await page.screenshot({
+      path: path.join(process.env.DIALOG_EVIDENCE_DIR, `${name}.png`),
+    });
+  }
+}
+
+for (const kind of [
+  'dialog',
+  'dialog-close',
+  'alert',
+  'alert-small',
+  'route',
+  'drawer',
+]) {
+  for (const preset of ['compact', 'default']) {
+    for (const width of [1440, 375]) {
+      test(`${kind}, ${preset}, ${width}: semantic actions align and keep their padding`, async ({
+        page,
+      }) => {
+        await page.setViewportSize({ width, height: 900 });
+        await page.goto(`${fixture}?kind=${kind}&preset=${preset}`);
+        const result = await checkGeometry(page);
+        expect(result.cancel.height).toBeCloseTo(result.submit.height, 0);
+        expect(result.cancel.minHeight).toBe(preset === 'compact' ? 36 : 40);
+        expect(result.cancel.paddingLeft).toBe(
+          preset === 'compact' ? '14.4px' : '16px',
+        );
+        if (width > 640 && kind !== 'alert-small')
+          expect(result.cancel.width).toBeLessThan(result.submit.width);
+        if (preset === 'default') await screenshot(page, `${kind}-${width}-en`);
+      });
+    }
+  }
+
+  for (const language of ['english', 'chinese']) {
+    test(`${kind}: long ${language} labels remain visible on a short phone viewport`, async ({
+      page,
+    }) => {
+      await page.setViewportSize({ width: 375, height: 667 });
+      await page.goto(
+        `${fixture}?kind=${kind}&long&${language === 'chinese' ? 'chinese&' : ''}dark`,
+      );
+      await checkGeometry(page);
+      await screenshot(page, `${kind}-375-long-${language}`);
+    });
+  }
+
+  test(`${kind}: disabled and submitting actions retain geometry`, async ({
+    page,
+  }) => {
+    await page.setViewportSize({ width: 375, height: 900 });
+    await page.goto(`${fixture}?kind=${kind}&pending`);
+    await checkGeometry(page);
+    await expect(page.getByTestId('cancel')).toBeDisabled();
+    await expect(page.getByTestId('submit')).toBeDisabled();
+    await expect(page.getByTestId('submit')).toHaveAttribute(
+      'aria-busy',
+      'true',
+    );
+    await page.keyboard.press('Escape');
+    await expect(page.getByTestId('submit')).toBeVisible();
+  });
+}
+
+for (const kind of ['dialog', 'alert']) {
+  test(`${kind}: a phone row wraps long labels without overflowing`, async ({
+    page,
+  }) => {
+    await page.setViewportSize({ width: 375, height: 667 });
+    await page.goto(`${fixture}?kind=${kind}&horizontal&chinese`);
+    await checkGeometry(page);
+  });
+}
+
+async function expectKeyboardFocus(action: Locator) {
+  await action.focus();
+  await expect(action).toBeFocused();
+  expect(
+    await action.evaluate(
+      (element) =>
+        getComputedStyle(element).outlineStyle !== 'none' ||
+        getComputedStyle(element).boxShadow !== 'none',
+    ),
+  ).toBe(true);
+}
+
+for (const kind of ['dialog', 'route', 'drawer']) {
+  test(`${kind}: link cancel and native form submit remain independent`, async ({
+    page,
+  }) => {
+    await page.goto(`${fixture}?kind=${kind}`);
+    await checkGeometry(page);
+    const cancel = page.getByTestId('cancel');
+    await expect(cancel).toHaveAttribute('href', '/instances?filter=recent');
+    expect(await cancel.evaluate((element) => element.tagName)).toBe('A');
+    await expectKeyboardFocus(cancel);
+    await page.keyboard.press('Enter');
+    await expect(page.getByTestId('location')).toHaveText(
+      '/instances?filter=recent',
+    );
+    await expect(page.getByTestId('submit')).toHaveCount(0);
+    await page.goto(`${fixture}?kind=${kind}`);
+    await checkGeometry(page);
+    await page.getByLabel('Instance name').fill('New customer portal');
+    await expectKeyboardFocus(page.getByTestId('submit'));
+    await page.keyboard.press('Enter');
+    await expect(page.getByTestId('location')).toHaveText(
+      '/instances?created=1',
+    );
+  });
+}
+
+test('route footer stays visible when the body scrolls', async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 667 });
+  await page.goto(`${fixture}?kind=route&long`);
+  const before = await checkGeometry(page);
+  await page.locator('[data-slot=route-overlay-body]').evaluate((element) => {
+    element.scrollTop = element.scrollHeight;
+  });
+  await expect
+    .poll(() =>
+      page
+        .locator('[data-slot=route-overlay-body]')
+        .evaluate((element) => element.scrollTop),
+    )
+    .toBeGreaterThan(0);
+  const after = await checkGeometry(page);
+  expect(after.footer.y).toBe(before.footer.y);
+  await page.getByTestId('cancel').click();
+  await expect(page.getByTestId('location')).toHaveText(
+    '/instances?filter=recent',
+  );
+});
+
+// DialogClose replaces Button's semantic slot just as AlertDialog's actions do.
+test('DialogClose cancels without submitting the form', async ({ page }) => {
+  await page.goto(`${fixture}?kind=dialog-close`);
+  await checkGeometry(page);
+  await page.getByTestId('cancel').click();
+  await expect(page.getByTestId('submit')).toHaveCount(0);
+  await expect(page.getByTestId('location')).toHaveText('Instance list');
+});

package/tests/project/bootstrap-loading.test.ts

@@ -0,0 +1,60 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const html = readFileSync(
+  fileURLToPath(new URL('../../index.html', import.meta.url)),
+  'utf8',
+);
+
+/** The markup the browser paints before the client script has started and the visitor's language is known. */
+function bootstrapRoot(): string {
+  const match = /<div id="root">([\s\S]*?)<\/div>\s*<script/u.exec(html);
+  if (!match) throw new Error('index.html has no #root placeholder.');
+  return match[1].replace(/<!--[\s\S]*?-->/gu, '');
+}
+
+/** The opening tag of the placeholder element, which carries its accessible semantics. */
+function placeholderTag(): string {
+  const tag = /<div\s+class="app-bootstrap-loading"[^>]*>/u.exec(
+    bootstrapRoot(),
+  );
+  if (!tag) throw new Error('index.html has no bootstrap loading placeholder.');
+  return tag[0].replace(/\s+/gu, ' ');
+}
+
+describe('bootstrap loading in index.html', () => {
+  it('shows no text in any language before the client starts', () => {
+    const text = bootstrapRoot()
+      .replace(/<[^>]*>/gu, '')
+      .trim();
+
+    expect(text).toBe('');
+  });
+
+  it('is perceivable as loading without words in a language', () => {
+    const tag = placeholderTag();
+    const title = /<title>([^<]*)<\/title>/u.exec(html)?.[1];
+
+    // An indeterminate progress bar: the screen reader announces the role in its own language.
+    expect(tag).toContain('role="progressbar"');
+    expect(tag).not.toMatch(/aria-valuenow|aria-valuetext/u);
+    // Its name is the brand, which reads the same in every language and matches the document title.
+    expect(title).toBeTruthy();
+    expect(tag).toContain(`aria-label="${title}"`);
+    expect(bootstrapRoot()).toMatch(/<svg[^>]*aria-hidden="true"/u);
+  });
+
+  it('leaves announcing the loading to the localized status of the client', () => {
+    // A live region here would be announced, then announced again by the client's localized status.
+    expect(bootstrapRoot()).not.toMatch(
+      /role="status"|role="alert"|aria-live/u,
+    );
+  });
+
+  it('keeps the brand mark still for reduced motion', () => {
+    expect(html).toMatch(
+      /prefers-reduced-motion: reduce\)\s*\{\s*\.app-bootstrap-loading \.nocobase-loading-orbit\s*\{\s*animation: none;/u,
+    );
+  });
+});

package/tests/server/app-server.test.ts

@@ -1170,12 +1170,14 @@ interface CreateTestAppOptions {
 function createTestQueueConfig(): AppQueueConfig {
   return {
     default: 'memory',
-    memory: {
-      adapter: 'inMemory',
-      persistence: {
-        path: mkdtempSync(
-          path.join(tmpdir(), 'nocobase-app-template-default-queue-'),
-        ),
+    backends: {
+      memory: {
+        adapter: 'inMemory',
+        persistence: {
+          path: mkdtempSync(
+            path.join(tmpdir(), 'nocobase-app-template-default-queue-'),
+          ),
+        },
       },
     },
   };
@@ -1537,17 +1539,21 @@ async function writeRuntimeTestConfig(
       // another suite may be using at the same time.
       jobs: {
         default: 'memory',
-        memory: {
-          adapter: 'memory',
-          persistence: { path: path.join(directory, 'jobs') },
+        backends: {
+          memory: {
+            adapter: 'memory',
+            persistence: { path: path.join(directory, 'jobs') },
+          },
         },
       },
       // Queue state files likewise stay beside the test database.
       queue: {
         default: 'memory',
-        memory: {
-          adapter: 'inMemory',
-          persistence: { path: path.join(directory, 'queue') },
+        backends: {
+          memory: {
+            adapter: 'inMemory',
+            persistence: { path: path.join(directory, 'queue') },
+          },
         },
       },
       database: {

package/tests/server/auth-email-config.test.ts

@@ -111,3 +111,24 @@ it('accepts an entirely environment-configured shared sender without enabling re
     },
   });
 });
+
+it('loads the direct password-reset reference from the inherited environment mapping', async () => {
+  const config = new AppConfig();
+  await config.loadAll();
+  const defaults = defaultAppConfigs({ auth, mailers });
+  config.mergeDefaults(defaults({} as never));
+  config.defineSections(defaults.sections!);
+  await config.loadSectionEnvironment({
+    AUTH_PASSWORD_RESET_MAILER: 'system',
+    MAILERS_SYSTEM_PROVIDER: 'smtp',
+    MAILERS_SYSTEM_HOST: 'localhost',
+    MAILERS_SYSTEM_PORT: '2525',
+  });
+  expect(await config.validate()).toEqual([]);
+  expect(config.get('auth.passwordReset.mailer')).toBe('system');
+  expect(config.get('auth.passwordReset.enabled')).toBeUndefined();
+  expect(config.environmentVariableMappings()).toMatchObject({
+    AUTH_PASSWORD_RESET_MAILER: { path: 'auth.passwordReset.mailer' },
+  });
+  expect(config.publicValues()).not.toHaveProperty('auth.passwordReset');
+});

package/tests/server/backends-config.test.ts

@@ -0,0 +1,118 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterEach, describe, expect, it } from 'vitest';
+import { resolveStandaloneAppRuntime } from '@nocobase/app-server/node';
+import { createJobExecutorService } from '@nocobase/jobs';
+import { createQueueService } from '@nocobase/queue';
+import appRuntime from '../../server/runtime.ts';
+
+const directories: string[] = [];
+afterEach(async () => {
+  for (const directory of directories.splice(0))
+    await rm(directory, { recursive: true, force: true });
+});
+async function runtime(yaml: string) {
+  const root = await mkdtemp(path.join(tmpdir(), 'backends-template-'));
+  directories.push(root);
+  const configPath = path.join(root, 'config.yml');
+  await writeFile(configPath, yaml);
+  return resolveStandaloneAppRuntime(appRuntime, {
+    rootDir: fileURLToPath(new URL('../..', import.meta.url)),
+    configPath,
+    env: { AUTH_SECRET: 'test-auth-secret-at-least-32-characters' },
+  });
+}
+describe('merged backend configuration in the real template', () => {
+  it('keeps local defaults without additional user configuration', async () => {
+    const resolved = await runtime('{}');
+    expect(resolved.config.get('concurrency.default')).toBe('memory');
+    expect(resolved.config.get('concurrency.backends.memory')).toEqual({
+      adapter: 'mutex',
+    });
+    expect(resolved.config.get('jobs.default')).toBeUndefined();
+    expect(resolved.config.get('queue.default')).toBeUndefined();
+    expect(resolved.config.get('jobs.backends.memory')).toEqual({
+      adapter: 'memory',
+      persistence: { path: resolved.paths.storage('jobs') },
+    });
+    expect(resolved.config.get('queue.backends.memory')).toEqual({
+      adapter: 'inMemory',
+      persistence: { path: resolved.paths.storage('queue') },
+    });
+    const issues = await resolved.config.validate();
+    expect(
+      issues.filter((issue) =>
+        /^(concurrency|jobs|queue)(\.|$)/u.test(issue.path),
+      ),
+    ).toEqual([]);
+    const jobs = createJobExecutorService(resolved.config.get('jobs'), {
+      appName: 'app',
+      storagePath: resolved.paths.storage('jobs'),
+    });
+    const queue = createQueueService(resolved.config.get('queue'), {
+      appName: 'app',
+      storagePath: resolved.paths.storage('queue'),
+    });
+    try {
+      expect(jobs.getJobExecutor('scope')).toBeDefined();
+      await queue.setup();
+    } finally {
+      await jobs.shutdown();
+      await queue.shutdown();
+    }
+  });
+  it.each(['concurrency', 'jobs', 'queue'])(
+    'rejects old user YAML merged over new %s defaults, selected or not',
+    async (section) => {
+      const adapter =
+        section === 'concurrency'
+          ? 'mutex'
+          : section === 'queue'
+            ? 'inMemory'
+            : 'memory';
+      for (const selector of [
+        '',
+        '  default: memory\n',
+        '  default: legacy\n',
+      ]) {
+        const resolved = await runtime(
+          `${section}:\n${selector}  legacy:\n    adapter: ${adapter}\n`,
+        );
+        const issues = await resolved.config.validate();
+        expect(issues).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              level: 'error',
+              message: expect.stringContaining('old configuration format'),
+            }),
+          ]),
+        );
+        expect(JSON.stringify(issues)).toContain(`${section}.backends.legacy`);
+      }
+    },
+  );
+  it.each(['concurrency', 'jobs', 'queue'])(
+    'rejects same-name legacy overrides for %s',
+    async (section) => {
+      const adapter =
+        section === 'concurrency'
+          ? 'mutex'
+          : section === 'queue'
+            ? 'inMemory'
+            : 'memory';
+      const resolved = await runtime(
+        `${section}:\n  default: memory\n  memory:\n    adapter: ${adapter}\n`,
+      );
+      expect(await resolved.config.validate()).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            level: 'error',
+            message: expect.stringContaining(`${section}.backends.memory`),
+          }),
+        ]),
+      );
+    },
+  );
+});

package/tests/server/concurrency.test.ts

@@ -81,7 +81,7 @@ test('the real default composition supplies one memory lock domain to two busine
   const second = new BusinessConsumer(service);
   expect(app.config.get('concurrency')).toEqual({
     default: 'memory',
-    memory: { adapter: 'mutex' },
+    backends: { memory: { adapter: 'mutex' } },
   });
   const [left, right] = await Promise.all([first.manager(), second.manager()]);
   expect(left).toBe(right);

package/tests/server/config.test.ts

@@ -52,14 +52,16 @@ describe('application config', () => {
     });
 
     expect(runtime.config.get<AppJobsConfig>('jobs')).toEqual({
-      memory: {
-        adapter: 'memory',
-        persistence: { path: runtime.paths.storage('jobs') },
-      },
       default: 'redis',
-      redis: {
-        adapter: 'redis',
-        connection: { host: '127.0.0.1', port: 6379 },
+      backends: {
+        memory: {
+          adapter: 'memory',
+          persistence: { path: runtime.paths.storage('jobs') },
+        },
+        redis: {
+          adapter: 'redis',
+          connection: { host: '127.0.0.1', port: 6379 },
+        },
       },
     });
   });
@@ -103,15 +105,19 @@ describe('application config', () => {
     expect(runtime.config.get('logging.file.name')).toBe('app');
     // No default: queues run on the built-in memory configuration until one is named.
     expect(runtime.config.get<AppQueueConfig>('queue')).toEqual({
-      memory: {
-        adapter: 'inMemory',
-        persistence: { path: runtime.paths.storage('queue') },
+      backends: {
+        memory: {
+          adapter: 'inMemory',
+          persistence: { path: runtime.paths.storage('queue') },
+        },
       },
     });
     expect(runtime.config.get<AppJobsConfig>('jobs')).toEqual({
-      memory: {
-        adapter: 'memory',
-        persistence: { path: runtime.paths.storage('jobs') },
+      backends: {
+        memory: {
+          adapter: 'memory',
+          persistence: { path: runtime.paths.storage('jobs') },
+        },
       },
     });
     expect(runtime.config.get<AppSessionConfigInput>('session')!.default).toBe(
@@ -203,7 +209,9 @@ describe('application config', () => {
     expect(runtime.config.get('server.port')).toBe(14001);
     expect(runtime.config.get('server.startLog')).toBe(false);
     expect(runtime.config.get('queue.redis')).toBeUndefined();
-    expect(runtime.config.get('queue.memory.adapter')).toBe('inMemory');
+    expect(runtime.config.get('queue.backends.memory.adapter')).toBe(
+      'inMemory',
+    );
     expect(runtime.config.get('session.stores.redis.host')).toBe('127.0.0.1');
     expect(runtime.config.get('logging.console.pretty')).toBe(false);
     expect(runtime.config.get('session.cookie.secure')).toBe(true);

package/tests/server/lifecycle.test.ts

@@ -51,7 +51,7 @@ describe('app service providers', () => {
         },
         queue: {
           default: 'memory',
-          memory: { adapter: 'inMemory' },
+          backends: { memory: { adapter: 'inMemory' } },
         },
         session: createNullSessionConfig(),
         snowflake: {
@@ -142,7 +142,7 @@ describe('app service providers', () => {
     } as unknown as DatabaseManager;
     const queueConfig = {
       default: 'test',
-      test: { adapter: 'inMemory' as const },
+      backends: { test: { adapter: 'inMemory' as const } },
     };
     const app = createProviderApplication(
       {

package/tests/server/realtime-config.test.ts

@@ -0,0 +1,114 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterAll, beforeAll, expect, it } from 'vitest';
+import { resolveStandaloneAppRuntime } from '@nocobase/app-server/node';
+import {
+  createRealtimeBrokerRegistry,
+  realtimeServiceOptions,
+  type AppRealtimeConfig,
+} from '@nocobase/app-server/realtime';
+import { createInMemoryBroker } from '@nocobase/realtime/server';
+import appRuntime from '../../server/runtime.js';
+
+let root: string;
+beforeAll(async () => {
+  root = await mkdtemp(path.join(os.tmpdir(), 'realtime-config-'));
+});
+afterAll(async () => {
+  await rm(root, { recursive: true, force: true });
+});
+
+async function load(yaml: string) {
+  const configPath = path.join(root, `${crypto.randomUUID()}.yml`);
+  await writeFile(configPath, yaml);
+  const runtime = await resolveStandaloneAppRuntime(appRuntime, {
+    rootDir: path.resolve(import.meta.dirname, '../..'),
+    configPath,
+    env: { AUTH_SECRET: 'test-auth-secret-at-least-32-characters' },
+  });
+  const issues = (await runtime.config.validate()).filter(
+    (issue) => issue.path === 'realtime' || issue.path.startsWith('realtime.'),
+  );
+  if (issues.length)
+    throw new Error(
+      issues.map((issue) => `${issue.path} ${issue.message}`).join(' '),
+    );
+  return runtime;
+}
+
+it('loads the actual commented Redis example through the application runtime without exposing credentials', async () => {
+  const source = await readFile(
+    new URL('../../config.example.yml', import.meta.url),
+    'utf8',
+  );
+  const example = source.match(/^# realtime:\n(?:#(?: {2,}.*)?\n)*/m)?.[0];
+  expect(example).toBeDefined();
+  const runtime = await load(
+    source.replace(example!, example!.replace(/^# ?/gm, '')),
+  );
+  const config = runtime.config.get<AppRealtimeConfig>('realtime');
+  expect(config).toMatchObject({
+    namespace: 'my-app',
+    authorizationTimeoutMs: 5000,
+    sessionCheckIntervalMs: 30000,
+    broker: {
+      adapter: 'redis',
+      setupTimeoutMs: 5000,
+      connection: { host: '127.0.0.1', port: 6379, commandTimeout: 5000 },
+    },
+    limits: { maxConnections: 10000 },
+  });
+  expect(
+    (await runtime.config.validate()).filter((issue) =>
+      issue.path.startsWith('realtime'),
+    ),
+  ).toEqual([]);
+  expect(
+    runtime.config.publicPaths().some((p) => p.startsWith('realtime')),
+  ).toBe(false);
+  // Configuration loads without commercial dependencies, but Redis selection still requires registration.
+  expect(() => realtimeServiceOptions(config)).toThrow(/not registered/u);
+  const registry = createRealtimeBrokerRegistry();
+  registry.register('redis', (context) => {
+    expect(context.config).toBe(config);
+    expect(context.namespace).toBe('my-app');
+    return createInMemoryBroker();
+  });
+  await realtimeServiceOptions(
+    config,
+    'application',
+    registry,
+  ).broker?.shutdown();
+});
+
+it.each([
+  '{}',
+  'realtime:\n  limits:\n    maxConnections: 10',
+  'realtime:\n  broker:\n    adapter: inMemory',
+])('keeps local operation for %s', async (yaml) => {
+  const runtime = await load(yaml);
+  const config = runtime.config.get<AppRealtimeConfig>('realtime');
+  expect(config?.broker?.adapter).not.toBe('redis');
+  const options = realtimeServiceOptions(config);
+  await options.broker?.shutdown();
+});
+
+it.each(['{}', 'null', '[]', 'redis', '{ adapter: "" }', '{ adapter: 12 }'])(
+  'does not fill in a missing adapter for explicit broker %s',
+  async (broker) => {
+    await expect(
+      load(`realtime:\n  broker: ${broker}`).then(() => undefined),
+    ).rejects.toThrow(/realtime.broker/u);
+  },
+);
+
+it.each([
+  'adapter: inMemory',
+  'redis: {}',
+  'adapter: redis\n  broker: { adapter: redis }',
+])('rejects legacy fields in runtime configuration: %s', async (legacy) => {
+  await expect(
+    load(`realtime:\n  ${legacy}`).then(() => undefined),
+  ).rejects.toThrow(/old configuration format/u);
+});