@nocobase/app-template-default 1.0.0-beta.89 → 1.0.0-beta.91

package/tests/client/settings-navigation.test.ts

@@ -228,3 +228,23 @@ describe('System settings navigation', () => {
     ).toEqual(['home', 'settingsHome']);
   });
 });
+
+it('keeps database browsing accessible by route without adding a System settings card', () => {
+  const routes = resolveAppClientContributions([
+    {
+      packageName: app,
+      source: 'application',
+      routes: createApplicationRoutes({}),
+    },
+  ]).routes;
+  const page = find(routes, 'databaseExplorer');
+  expect(page.path).toBe('/settings/database-explorer');
+  expect(page.auth).toBe('required');
+  expect(page.authz).toEqual({
+    resource: { type: 'page', id: 'database-explorer' },
+    action: 'access',
+  });
+  expect(page.navigation).toBeUndefined();
+  expect(catalog(routes)).toEqual([]);
+  expect(catalog(routes, new Set([routeKey(page)]))).toEqual([]);
+});

package/tests/helpers/authenticated-client.tsx

@@ -89,6 +89,13 @@ export async function renderAuthenticatedClient(
 function createClientTestServer() {
   return createTestApp({
     createServer: createStandaloneServer,
+    // Local preview origins must not change test cookie security or trusted origins.
+    server: {
+      env: {
+        APP_PUBLIC_ORIGIN: 'http://localhost',
+        BETTER_AUTH_TRUSTED_ORIGINS: 'http://localhost',
+      },
+    },
     connections: ['main'],
     config: {
       logging: { enabled: false },

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);
+});

package/client/pages/home/capabilities.ts

@@ -1,62 +0,0 @@
-import {
-  Bell,
-  CalendarClock,
-  Database,
-  KeyRound,
-  Languages,
-  Mail,
-  Palette,
-  Paperclip,
-  ShieldCheck,
-  Workflow,
-  type LucideIcon,
-} from 'lucide-react';
-
-/**
- * A built-in capability the homepage introduces. Its title, description and prompts live in the locale files under
- * `home.capabilities.<id>`, one `prompts.<promptId>.label` and `prompts.<promptId>.text` per prompt, so the wording is
- * translated and reworded there rather than here.
- */
-export interface Capability {
-  readonly id: string;
-  readonly icon: LucideIcon;
-  readonly prompts: readonly string[];
-}
-
-// The default prompts follow the examples in the documentation's Capabilities chapter, in the order of its sidebar.
-export const CAPABILITIES: readonly Capability[] = [
-  {
-    id: 'auth',
-    icon: KeyRound,
-    prompts: ['disableSignUp', 'companySso', 'apiKeys'],
-  },
-  {
-    id: 'dataSources',
-    icon: Database,
-    prompts: ['postgres', 'externalDatabase'],
-  },
-  {
-    id: 'authorization',
-    icon: ShieldCheck,
-    prompts: ['jobs', 'dataScopes', 'restrictions'],
-  },
-  {
-    id: 'workflow',
-    icon: Workflow,
-    prompts: ['stages', 'backgroundExport', 'history'],
-  },
-  { id: 'file', icon: Paperclip, prompts: ['attachments', 'avatar'] },
-  { id: 'i18n', icon: Languages, prompts: ['addLanguage', 'defaultLanguage'] },
-  { id: 'theme', icon: Palette, prompts: ['changeTheme', 'newTheme'] },
-  { id: 'notification', icon: Bell, prompts: ['inApp', 'email'] },
-  {
-    id: 'scheduler',
-    icon: CalendarClock,
-    prompts: ['reminder', 'weeklyReport'],
-  },
-  {
-    id: 'mail',
-    icon: Mail,
-    prompts: ['providers', 'mailCenter', 'correspondence'],
-  },
-];

package/client/pages/home/prompt-dialog.tsx

@@ -1,122 +0,0 @@
-import { useTranslation } from '@nocobase/i18n/client';
-import { CheckIcon, CopyIcon, RotateCcwIcon } from 'lucide-react';
-import { type ReactElement, useState } from 'react';
-
-import { Button } from '#components/ui/button';
-import {
-  Dialog,
-  DialogClose,
-  DialogContent,
-  DialogDescription,
-  DialogFooter,
-  DialogHeader,
-  DialogTitle,
-} from '#components/ui/dialog';
-import { Tabs, TabsList, TabsTrigger } from '#components/ui/tabs';
-import { Textarea } from '#components/ui/textarea';
-
-import type { Capability } from './capabilities.js';
-import { useCopy } from './use-copy.js';
-
-export interface PromptDialogProps {
-  readonly capability: Capability;
-  readonly open: boolean;
-  readonly onOpenChange: (open: boolean) => void;
-}
-
-/**
- * The prompts of one capability, ready to hand to a coding agent. Each prompt can be edited before copying. Edits are
- * not saved: the page mounts a new dialog each time one is opened, so it starts from the default wording again.
- */
-export function PromptDialog({
-  capability,
-  open,
-  onOpenChange,
-}: PromptDialogProps): ReactElement {
-  const { t } = useTranslation();
-  const { copied, copy } = useCopy();
-  const [current, setCurrent] = useState(capability.prompts[0]);
-  // Edited text per prompt id; a prompt without an entry shows its default wording.
-  const [edits, setEdits] = useState<Readonly<Record<string, string>>>({});
-
-  const prefix = `home.capabilities.${capability.id}`;
-  const defaultText = t(`${prefix}.prompts.${current}.text`);
-  const text = edits[current] ?? defaultText;
-  const Icon = capability.icon;
-
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className='gap-5 sm:max-w-2xl'>
-        <DialogHeader className='flex-row items-center gap-3 pr-8'>
-          <span className='flex size-10 shrink-0 items-center justify-center rounded-lg bg-primary/5 text-primary'>
-            <Icon className='size-5' aria-hidden />
-          </span>
-          <div className='flex min-w-0 flex-col gap-1.5'>
-            <DialogTitle>{t(`${prefix}.title`)}</DialogTitle>
-            <DialogDescription>{t(`${prefix}.description`)}</DialogDescription>
-          </div>
-        </DialogHeader>
-        <div className='flex flex-col gap-3'>
-          {capability.prompts.length > 1 ? (
-            <Tabs
-              value={current}
-              onValueChange={(value) => {
-                if (typeof value === 'string') setCurrent(value);
-              }}
-            >
-              <TabsList className='w-full'>
-                {capability.prompts.map((id) => (
-                  <TabsTrigger key={id} value={id}>
-                    {t(`${prefix}.prompts.${id}.label`)}
-                  </TabsTrigger>
-                ))}
-              </TabsList>
-            </Tabs>
-          ) : null}
-          <Textarea
-            aria-label={t('home.prompt.label')}
-            className='field-sizing-fixed h-60 max-h-[50dvh] resize-none leading-6'
-            value={text}
-            onChange={(event) =>
-              setEdits((previous) => ({
-                ...previous,
-                [current]: event.target.value,
-              }))
-            }
-          />
-          <p className='text-xs text-muted-foreground'>
-            {t('home.prompt.hint')}
-          </p>
-        </div>
-        <DialogFooter className='sm:items-center'>
-          <Button
-            variant='ghost'
-            className='sm:mr-auto'
-            disabled={text === defaultText}
-            onClick={() =>
-              setEdits((previous) => {
-                const rest = { ...previous };
-                delete rest[current];
-                return rest;
-              })
-            }
-          >
-            <RotateCcwIcon data-icon='inline-start' />
-            {t('home.prompt.reset')}
-          </Button>
-          <DialogClose render={<Button variant='outline' />}>
-            {t('actions.close')}
-          </DialogClose>
-          <Button disabled={text.trim() === ''} onClick={() => void copy(text)}>
-            {copied ? (
-              <CheckIcon data-icon='inline-start' />
-            ) : (
-              <CopyIcon data-icon='inline-start' />
-            )}
-            {copied ? t('home.prompt.copiedShort') : t('home.prompt.copy')}
-          </Button>
-        </DialogFooter>
-      </DialogContent>
-    </Dialog>
-  );
-}