@pantheon-systems/create-p1-starter-kit 0.12.0 → 0.13.0

package/README.md

@@ -45,12 +45,12 @@ After scaffolding:
 
    | Variable | Purpose |
    | --- | --- |
-   | `PCC_SITE_ID` | Content Cloud site ID |
-   | `PCC_TOKEN` | API token for your site |
-   | `NEXT_PUBLIC_CSS_BASE_URL` | CSS API base URL |
    | `NEXT_PUBLIC_CSS_SITE_ID` | Site identifier (UUID) |
    | `CSS_API_KEY` | Server-side API key |
 
+   Everything else in `.env.example` is commented out and optional, including the
+   `PCC_SITE_ID`/`PCC_TOKEN` pair for Content Publisher.
+
 2. **Start the dev server:**
 
    ```bash

package/lib/cli.js

@@ -7,31 +7,80 @@ import { copyTemplate } from './copy-template.js';
 import { detectPackageManager, isPackageManagerAvailable, installDependencies } from './install-deps.js';
 import { showWelcome, showSuccess, showInstallHelp, showError } from './messages.js';
 
+const PROJECT_NAME_RULE =
+  'Project name must be lowercase and can only contain letters, numbers, hyphens, and underscores';
+
+function validateProjectName(value) {
+  if (!value) return 'Please enter a project name';
+  if (!/^[a-z0-9-_]+$/.test(value)) return PROJECT_NAME_RULE;
+  return undefined;
+}
+
+const PACKAGE_MANAGERS = new Set(['pnpm', 'npm', 'yarn']);
+
+export function parseArgs(args) {
+  const parsed = { projectName: undefined, yes: false, pm: undefined, git: undefined, install: undefined };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--yes' || arg === '-y') {
+      parsed.yes = true;
+    } else if (arg === '--pm' || arg.startsWith('--pm=')) {
+      const value = arg === '--pm' ? args[++i] : arg.slice('--pm='.length);
+      if (!PACKAGE_MANAGERS.has(value)) {
+        throw new Error(`--pm must be one of: ${[...PACKAGE_MANAGERS].join(', ')}`);
+      }
+      parsed.pm = value;
+    } else if (arg === '--git' || arg === '--no-git') {
+      parsed.git = arg === '--git';
+    } else if (arg === '--install' || arg === '--no-install') {
+      parsed.install = arg === '--install';
+    } else if (arg.startsWith('-')) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else if (parsed.projectName === undefined) {
+      parsed.projectName = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  return parsed;
+}
+
 export async function runCLI() {
   showWelcome();
 
-  const args = process.argv.slice(2);
-  const targetDirArg = args[0];
+  let parsed;
+  try {
+    parsed = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    showError(error.message);
+    process.exit(1);
+  }
 
   clack.intro(pc.bgCyan(pc.black(' P1 Starter Kit Setup ')));
 
   // Get project name
-  const projectName = await clack.text({
-    message: 'What is your project named?',
-    placeholder: 'my-p1-app',
-    initialValue: targetDirArg || 'my-p1-app',
-    validate: (value) => {
-      if (!value) return 'Please enter a project name';
-      if (!/^[a-z0-9-_]+$/.test(value)) {
-        return 'Project name must be lowercase and can only contain letters, numbers, hyphens, and underscores';
-      }
-      return undefined;
-    },
-  });
-
-  if (clack.isCancel(projectName)) {
-    clack.cancel('Operation cancelled');
-    process.exit(0);
+  let projectName;
+  if (parsed.yes) {
+    projectName = parsed.projectName || 'my-p1-app';
+    const problem = validateProjectName(projectName);
+    if (problem) {
+      showError(problem);
+      process.exit(1);
+    }
+  } else {
+    projectName = await clack.text({
+      message: 'What is your project named?',
+      placeholder: 'my-p1-app',
+      initialValue: parsed.projectName || 'my-p1-app',
+      validate: validateProjectName,
+    });
+
+    if (clack.isCancel(projectName)) {
+      clack.cancel('Operation cancelled');
+      process.exit(0);
+    }
   }
 
   const targetDir = path.resolve(process.cwd(), projectName);
@@ -44,47 +93,67 @@ export async function runCLI() {
 
   // Detect package manager
   const detectedPM = detectPackageManager();
-  const packageManager = await clack.select({
-    message: 'Which package manager do you want to use?',
-    options: [
-      { value: 'pnpm', label: 'pnpm', hint: detectedPM === 'pnpm' ? 'detected' : '' },
-      { value: 'npm', label: 'npm', hint: detectedPM === 'npm' ? 'detected' : '' },
-      { value: 'yarn', label: 'yarn', hint: detectedPM === 'yarn' ? 'detected' : '' },
-    ],
-    initialValue: detectedPM,
-  });
-
-  if (clack.isCancel(packageManager)) {
-    clack.cancel('Operation cancelled');
-    process.exit(0);
-  }
-
-  // Check if package manager is available
-  if (!isPackageManagerAvailable(packageManager)) {
-    showError(`${packageManager} is not installed. Please install it first or choose a different package manager.`);
-    process.exit(1);
+  let packageManager;
+  if (parsed.pm) {
+    packageManager = parsed.pm;
+  } else if (parsed.yes) {
+    packageManager = detectedPM;
+  } else {
+    packageManager = await clack.select({
+      message: 'Which package manager do you want to use?',
+      options: [
+        { value: 'pnpm', label: 'pnpm', hint: detectedPM === 'pnpm' ? 'detected' : '' },
+        { value: 'npm', label: 'npm', hint: detectedPM === 'npm' ? 'detected' : '' },
+        { value: 'yarn', label: 'yarn', hint: detectedPM === 'yarn' ? 'detected' : '' },
+      ],
+      initialValue: detectedPM,
+    });
+
+    if (clack.isCancel(packageManager)) {
+      clack.cancel('Operation cancelled');
+      process.exit(0);
+    }
   }
 
   // Git init?
-  const shouldInitGit = await clack.confirm({
-    message: 'Initialize a git repository?',
-    initialValue: true,
-  });
-
-  if (clack.isCancel(shouldInitGit)) {
-    clack.cancel('Operation cancelled');
-    process.exit(0);
+  let shouldInitGit;
+  if (parsed.git !== undefined) {
+    shouldInitGit = parsed.git;
+  } else if (parsed.yes) {
+    shouldInitGit = true;
+  } else {
+    shouldInitGit = await clack.confirm({
+      message: 'Initialize a git repository?',
+      initialValue: true,
+    });
+
+    if (clack.isCancel(shouldInitGit)) {
+      clack.cancel('Operation cancelled');
+      process.exit(0);
+    }
   }
 
   // Install deps?
-  const shouldInstall = await clack.confirm({
-    message: 'Install dependencies now?',
-    initialValue: true,
-  });
-
-  if (clack.isCancel(shouldInstall)) {
-    clack.cancel('Operation cancelled');
-    process.exit(0);
+  let shouldInstall;
+  if (parsed.install !== undefined) {
+    shouldInstall = parsed.install;
+  } else if (parsed.yes) {
+    shouldInstall = true;
+  } else {
+    shouldInstall = await clack.confirm({
+      message: 'Install dependencies now?',
+      initialValue: true,
+    });
+
+    if (clack.isCancel(shouldInstall)) {
+      clack.cancel('Operation cancelled');
+      process.exit(0);
+    }
+  }
+
+  if (shouldInstall && !isPackageManagerAvailable(packageManager)) {
+    showError(`${packageManager} is not installed. Please install it first or choose a different package manager.`);
+    process.exit(1);
   }
 
   const s = clack.spinner();

package/lib/cli.test.js

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { parseArgs } from './cli.js';
+
+describe('parseArgs', () => {
+  it('treats the first bare argument as the project name', () => {
+    expect(parseArgs(['my-app'])).toMatchObject({ projectName: 'my-app', yes: false });
+  });
+
+  it('defaults every choice to undefined so prompts still run', () => {
+    expect(parseArgs([])).toEqual({
+      projectName: undefined,
+      yes: false,
+      pm: undefined,
+      git: undefined,
+      install: undefined,
+    });
+  });
+
+  it('accepts --yes and -y', () => {
+    expect(parseArgs(['--yes']).yes).toBe(true);
+    expect(parseArgs(['-y']).yes).toBe(true);
+  });
+
+  it('accepts --pm as a separate value or with =', () => {
+    expect(parseArgs(['--pm', 'pnpm']).pm).toBe('pnpm');
+    expect(parseArgs(['--pm=npm']).pm).toBe('npm');
+  });
+
+  it('rejects an unknown package manager', () => {
+    expect(() => parseArgs(['--pm', 'bun'])).toThrow(/--pm must be one of/);
+    expect(() => parseArgs(['--pm'])).toThrow(/--pm must be one of/);
+  });
+
+  it('parses git and install toggles', () => {
+    expect(parseArgs(['--git']).git).toBe(true);
+    expect(parseArgs(['--no-git']).git).toBe(false);
+    expect(parseArgs(['--install']).install).toBe(true);
+    expect(parseArgs(['--no-install']).install).toBe(false);
+  });
+
+  it('rejects unknown options and extra positionals', () => {
+    expect(() => parseArgs(['--frobnicate'])).toThrow(/Unknown option/);
+    expect(() => parseArgs(['app-one', 'app-two'])).toThrow(/Unexpected argument/);
+  });
+
+  it('parses a full non-interactive invocation', () => {
+    expect(parseArgs(['my-app', '--yes', '--pm', 'pnpm', '--no-git', '--no-install'])).toEqual({
+      projectName: 'my-app',
+      yes: true,
+      pm: 'pnpm',
+      git: false,
+      install: false,
+    });
+  });
+});

package/lib/copy-template.js

@@ -14,6 +14,40 @@ export function getScaffolderVersion() {
   return JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;
 }
 
+// npm strips files named `.gitignore` from published tarballs, so the template
+// ships it undotted (see scripts/build-template.js) and the name is restored here
+// — before the CLI's initial `git add -A`.
+const GITIGNORE_TEMPLATE_NAME = 'gitignore';
+const PROJECT_NAME_PLACEHOLDER = 'PLACEHOLDER_PROJECT_NAME';
+
+// Acted on directly rather than guarded by an existsSync: a check-then-use pair
+// is a file-system race, and the failure it would catch is exactly what the
+// rename already reports.
+export function restoreGitignore(targetDir) {
+  try {
+    fs.renameSync(
+      path.join(targetDir, GITIGNORE_TEMPLATE_NAME),
+      path.join(targetDir, '.gitignore')
+    );
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    throw new Error(
+      `Template is missing ${GITIGNORE_TEMPLATE_NAME}; scaffolding without it would commit node_modules.`
+    );
+  }
+}
+
+function stampProjectName(filePath, projectName) {
+  let contents;
+  try {
+    contents = fs.readFileSync(filePath, 'utf-8');
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    throw new Error(`Template is missing ${path.basename(filePath)}.`);
+  }
+  fs.writeFileSync(filePath, contents.replaceAll(PROJECT_NAME_PLACEHOLDER, projectName));
+}
+
 export function copyTemplate(targetDir, projectName) {
   const templatePath = getTemplatePath();
 
@@ -22,6 +56,9 @@ export function copyTemplate(targetDir, projectName) {
   }
 
   copyRecursive(templatePath, targetDir);
+  restoreGitignore(targetDir);
+
+  stampProjectName(path.join(targetDir, 'README.md'), projectName);
 
   // Stamp the project name and scaffolder version into package.json
   const packageJsonPath = path.join(targetDir, 'package.json');

package/lib/copy-template.test.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { copyTemplate, getScaffolderVersion } from './copy-template.js';
+import { copyTemplate, getScaffolderVersion, restoreGitignore } from './copy-template.js';
 
 describe('copyTemplate', () => {
   let targetDir;
@@ -32,3 +32,44 @@ describe('getScaffolderVersion', () => {
     expect(getScaffolderVersion()).toBe(manifest.version);
   });
 });
+
+describe('gitignore', () => {
+  let targetDir;
+
+  beforeEach(() => {
+    targetDir = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'scaffold-')), 'my-app');
+  });
+
+  afterEach(() => {
+    fs.rmSync(path.dirname(targetDir), { recursive: true, force: true });
+  });
+
+  it('restores the dotted name so the initial commit excludes node_modules', () => {
+    copyTemplate(targetDir, 'my-app');
+
+    expect(fs.existsSync(path.join(targetDir, 'gitignore'))).toBe(false);
+    expect(fs.readFileSync(path.join(targetDir, '.gitignore'), 'utf-8')).toContain('/node_modules');
+  });
+
+  it('refuses to scaffold from a template with no gitignore', () => {
+    const stripped = fs.mkdtempSync(path.join(os.tmpdir(), 'no-gitignore-'));
+
+    expect(() => restoreGitignore(stripped)).toThrow(/missing gitignore/);
+
+    fs.rmSync(stripped, { recursive: true, force: true });
+  });
+});
+
+describe('README', () => {
+  it('stamps the project name into the scaffolded README', () => {
+    const targetDir = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'scaffold-')), 'acme-site');
+
+    copyTemplate(targetDir, 'acme-site');
+    const readme = fs.readFileSync(path.join(targetDir, 'README.md'), 'utf-8');
+
+    expect(readme).toContain('# acme-site');
+    expect(readme).not.toContain('PLACEHOLDER_PROJECT_NAME');
+
+    fs.rmSync(path.dirname(targetDir), { recursive: true, force: true });
+  });
+});

package/lib/messages.js

@@ -12,7 +12,7 @@ export function showSuccess(projectName, _projectPath, packageManager) {
   console.log(`  ${pc.cyan('cd')} ${projectName}`);
   console.log(`  ${pc.dim('# Copy .env.example to .env and fill in your credentials:')}`);
   console.log(`  ${pc.cyan('cp')} .env.example .env`);
-  console.log(`  ${pc.dim('# Edit .env with your PCC_SITE_ID and PCC_TOKEN')}\n`);
+  console.log(`  ${pc.dim('# Edit .env with your NEXT_PUBLIC_CSS_SITE_ID and CSS_API_KEY')}\n`);
   const devCmd = packageManager === 'npm' ? 'npm run dev' : `${packageManager} dev`;
   console.log(`  ${pc.dim('# Start the dev server:')}`);
   console.log(`  ${pc.cyan(devCmd)}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pantheon-systems/create-p1-starter-kit",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Scaffold a new P1 starter project",
   "type": "module",
   "bin": {
@@ -38,9 +38,9 @@
     "isomorphic-dompurify": "^3.18.0",
     "react": "^19.2.5",
     "vitest": "^4.1.5",
-    "@pantheon-systems/css-client": "0.12.0",
+    "@pantheon-systems/css-client": "0.13.0",
     "@pantheon-systems/eslint-config": "0.1.0",
-    "@pantheon-systems/puck-css": "0.12.0"
+    "@pantheon-systems/puck-css": "0.13.0"
   },
   "dependencies": {
     "@clack/prompts": "^1.5.1",
@@ -53,6 +53,7 @@
     "clean": "rm -rf template node_modules/.vite",
     "lint": "eslint index.js lib scripts",
     "lint:fix": "eslint index.js lib scripts --fix",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:scaffold": "node scripts/validate-scaffold.js"
   }
 }

package/template/README.md

@@ -0,0 +1,82 @@
+# PLACEHOLDER_PROJECT_NAME
+
+A Next.js site built on Pantheon's Content Publisher — a Puck-based visual page editor with
+server-side datasource resolution, so authors build dynamic pages without writing code.
+
+Scaffolded with [`@pantheon-systems/create-p1-starter-kit`](https://www.npmjs.com/package/@pantheon-systems/create-p1-starter-kit).
+
+## Getting started
+
+1. Copy the environment file and fill in your credentials:
+
+   ```bash
+   cp .env.example .env
+   ```
+
+   Two variables are required:
+
+   | Variable                  | Description                                                          |
+   | ------------------------- | -------------------------------------------------------------------- |
+   | `NEXT_PUBLIC_CSS_SITE_ID` | The Pantheon Site ID (Next.js, etc.) for this P1 site                |
+   | `CSS_API_KEY`             | The P1 API Token generated by the P1 platform to access your P1 site |
+
+   `.env.example` documents the optional ones inline — the backend URL
+   (`NEXT_PUBLIC_CSS_BASE_URL`) for staging or local backends.
+
+2. Install dependencies and start the dev server:
+
+   ```bash
+   npm install
+   npm run dev
+   ```
+
+3. Open http://localhost:3000 for the site, or http://localhost:3000/p1 for the page dashboard.
+
+   Additional step-by-step details are in the [P1 developer guide](https://live-p1-docs.pantheonsite.io/dev-guide/dev-guide-getting-started).
+
+## Scripts
+
+| Script                  | What it does                                    |
+| ----------------------- | ----------------------------------------------- |
+| `npm run dev`           | Start the Next.js dev server                    |
+| `npm run build`         | Production build                                |
+| `npm start`             | Serve the production build                      |
+| `npm test`              | Run the Vitest suite                            |
+| `npm run lint`          | Lint with the bundled flat ESLint config        |
+| `npm run typecheck`     | Type-check without emitting                     |
+| `npm run sync:registry` | Push the Puck component registry to the backend |
+
+## Project structure
+
+```
+app/
+  page.tsx                      # Site root (renders via Puck)
+  layout.tsx                    # Root layout
+  styles.css                    # Tailwind entry point
+  [...puckPath]/                # Catch-all route for published pages
+  p1/
+    (editor)/[[...p1]]/         # Dashboard at /p1, editor at /p1/<path>
+    api/[...p1]/route.ts        # API handler for page data
+    auth/[...action]/route.ts   # Login / logout callbacks
+    merge/                      # Branch merge review UI
+components/puck/                # Block definitions (Heading, Paragraph, Image, …)
+lib/remote-datasources.ts       # Datasource registry (REMOTE_DATASOURCE_REGISTRY)
+lib/remote-datasource-fetchers.ts  # Fetchers backing those datasources
+puck.config.tsx                 # Puck editor configuration — block registry & categories
+```
+
+## Customizing
+
+- **Add a block** — create a component in `components/puck/`, then register it in
+  `puck.config.tsx`.
+- **Add a datasource** — add an entry to `REMOTE_DATASOURCE_REGISTRY` in
+  `lib/remote-datasources.ts`, with its fetcher in `lib/remote-datasource-fetchers.ts`, to make
+  external data available to block fields through `{{ datasource.field }}` expressions.
+- **Change styling** — the project uses Tailwind CSS v4; edit `app/styles.css` or the individual
+  block components.
+
+## Updating
+
+The scaffolder records the version it generated from under `p1.templateVersion` in
+`package.json`. Compare it against the latest published `@pantheon-systems/create-p1-starter-kit`
+to see whether newer starter-kit changes are available.

package/template/__tests__/auth-route.test.ts

@@ -14,7 +14,7 @@ describe("auth route does not force re-authentication on every login", () => {
 
   it("does not hardcode an OAuth prompt override", () => {
     // prompt: 'login' forces Google's full re-auth screen on every broker
-    // login, even with a live Google session — see PCC-3391.
+    // login, even with a live Google session.
     expect(content).not.toMatch(/prompt\s*:\s*['"]login['"]/);
   });
 

package/template/__tests__/seo-metadata.test.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { buildPageMetadata } from "../lib/seo-metadata";
 
 /**
- * PCC-3407: buildPageMetadata maps the head metadata inputs (client-derived
+ * buildPageMetadata maps the head metadata inputs (client-derived
  * title/description/canonical plus the backend-supplied siteName) onto the
  * Next.js Metadata object that renders the per-page <head> tags. Next replaces
  * (not deep-merges) a page's openGraph over the layout's, so og:type and the

package/template/__tests__/styles-canvas-scope.test.ts

@@ -6,7 +6,7 @@ import { describe, expect, it } from "vitest";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const appDir = resolve(__dirname, "..");
 
-// PCC-3499 / PCC-3513: Puck's collectStyles() copies every parent
+// Puck's collectStyles() copies every parent
 // <style>/<link> element into the canvas-preview iframe verbatim (there is
 // no exclusion API), and separately its CopyHostStyles helper syncs this
 // document's <body> attributes (including `class`) onto the iframe's own

package/template/__tests__/widget-logout.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+import type { LogoutOutcome } from "@pantheon-systems/puck-css";
+import { runWidgetLogout } from "../app/[...puckPath]/widget-logout";
+
+// Records the effects in order, so each test asserts the whole sequence a
+// logout attempt produces rather than one call in isolation.
+function recorder(logout: () => Promise<LogoutOutcome>) {
+  const calls: string[] = [];
+  return {
+    calls,
+    fx: {
+      logout,
+      navigate: (url: string) => calls.push(`navigate:${url}`),
+      reload: () => calls.push("reload"),
+      setBusy: (busy: boolean) => calls.push(`busy:${busy}`),
+      setError: (message: string | null) =>
+        calls.push(`error:${message ?? "cleared"}`),
+    },
+  };
+}
+
+const LOGOUT_URL = "https://example.auth0.com/v2/logout?client_id=abc";
+
+describe("runWidgetLogout", () => {
+  it("navigates to the Auth0 logout URL when the session ended", async () => {
+    const { calls, fx } = recorder(async () => ({
+      status: "signed_out",
+      logoutUrl: LOGOUT_URL,
+    }));
+
+    await runWidgetLogout(fx);
+
+    // Stays busy: the navigation replaces the page, so releasing the button
+    // would only flash it back to "Log out" on the way out.
+    expect(calls).toEqual([
+      "busy:true",
+      "error:cleared",
+      `navigate:${LOGOUT_URL}`,
+    ]);
+  });
+
+  it("keeps the menu open and shows why when logout failed", async () => {
+    const { calls, fx } = recorder(async () => ({
+      status: "error",
+      message: "Broker logout failed (503)",
+    }));
+
+    await runWidgetLogout(fx);
+
+    // Still signed in and retryable, so the button must come back.
+    expect(calls).toEqual([
+      "busy:true",
+      "error:cleared",
+      "error:Broker logout failed (503)",
+      "busy:false",
+    ]);
+  });
+
+  it("reloads when there was no session to end", async () => {
+    const { calls, fx } = recorder(async () => ({ status: "no_session" }));
+
+    await runWidgetLogout(fx);
+
+    expect(calls).toEqual(["busy:true", "error:cleared", "reload"]);
+  });
+
+  it("reports a thrown error instead of leaving the button stuck", async () => {
+    const { calls, fx } = recorder(async () => {
+      throw new Error("Failed to fetch");
+    });
+
+    await runWidgetLogout(fx);
+
+    expect(calls).toEqual([
+      "busy:true",
+      "error:cleared",
+      "error:Failed to fetch",
+      "busy:false",
+    ]);
+  });
+
+  it("falls back to a generic message when something non-Error is thrown", async () => {
+    const { calls, fx } = recorder(async () => {
+      throw "socket closed";
+    });
+
+    await runWidgetLogout(fx);
+
+    expect(calls).toEqual([
+      "busy:true",
+      "error:cleared",
+      "error:Logout failed",
+      "busy:false",
+    ]);
+  });
+
+  it("clears a previous failure before retrying", async () => {
+    const { calls, fx } = recorder(async () => ({
+      status: "signed_out",
+      logoutUrl: LOGOUT_URL,
+    }));
+
+    await runWidgetLogout(fx);
+    await runWidgetLogout(fx);
+
+    // The second attempt clears the slot again; a stale message must not sit
+    // under a logout that is now succeeding.
+    expect(calls.slice(3)).toEqual([
+      "busy:true",
+      "error:cleared",
+      `navigate:${LOGOUT_URL}`,
+    ]);
+  });
+});