create-stitchkit 0.1.1 → 0.3.0

package/CHANGELOG.md

@@ -6,6 +6,89 @@ is declared in the template root catalog.
 
 ## [Unreleased]
 
+## [0.3.0] — 2026-08-10
+
+### ⚠️ Breaking changes
+
+- **Generated projects ship no `.env`.** The single environment source is
+  `.env.example`; `bun run env:ensure` (and every tooling entry point,
+  self-healing before validation) renders `.env` with the application-derived
+  database name. A clone and a post-generation rename now produce the same
+  database, and the second-developer path (`runtime:smoke`, `e2e`) works
+  unaided.
+  `// before: scaffold writes .env with a neutral database name` →
+  `// after:  .env is rendered on first run from .env.example`
+
+- **Starter-owned LAN HTTPS is removed.** Generated applications no longer ship
+  `dev:lan`, certificate generation, onboarding routes or `DEV_HTTPS_*` settings.
+  Applications that need a trusted device-testing origin should own certificate
+  creation and pass TLS files through Stitchkit's documented `bun.tls` boundary.
+
+### Changed
+
+- **Surface conformance is anchored and total.** The declared surface is
+  compared against a committed `surface.snapshot.json` (with schema-shape
+  digests, regenerated deliberately via `bun run surface:snapshot`), the CLI is
+  observed by spawning the real process, missing `x-stitchkit-*` metadata is an
+  error unless a standard-document mode is declared explicitly, and the starter
+  lane sweeps generated trees for neutral-identity leaks against a committed
+  allowlist.
+- **The template targets Stitchkit 0.46.** The error-code map covers
+  `REALTIME_CONTRACT_VIOLATION` and conformance validates the operation
+  metadata 0.46 emits.
+- **Scaffold identity is rendered from one config.** The generated
+  `app.config.json` drives runtime identity and database naming; only the root
+  package manifest is structurally projected, with no global text search or
+  inert lockfile rewrite.
+- **Development is explicit and portable.** `bun run dev` validates PM2 and
+  external PostgreSQL requirements before side effects. The removed LAN HTTPS
+  mode is documented as application-owned framework configuration instead of a
+  starter subsystem.
+
+### Fixed
+
+- **Fresh clones bootstrap in the right order.** The starter materializes its
+  local environment before Prisma/type gates and reports a missing or placeholder
+  `DATABASE_URL` directly.
+- **Every executable source is checked.** Root TypeScript coverage includes
+  scripts and browser E2E; the authored-source guard scans CJS and reports the
+  real offending line.
+- **Runtime and browser gates prove the backend.** Surface conformance compares
+  HTTP/OpenAPI, MCP, Agent and CLI identities and schemas; browser E2E performs
+  a contract call and realtime cache update.
+- **Repository example uses the canonical realtime contract.** Shared Zod event
+  definitions drive backend emission, browser subscriptions and cache bridging
+  without handwritten event maps.
+
+### Removed
+
+- **Starter-owned LAN HTTPS.** `dev:lan`, certificate generation, onboarding
+  transport and `DEV_HTTPS_*` settings are gone; trusted local TLS remains an
+  application-owned adapter choice documented by Stitchkit.
+
+## [0.2.0] — 2026-08-10
+
+### ⚠️ Breaking changes
+
+- **The default scaffold is now domain-free.** The repository example is explicit
+  so a new product does not need to dismantle demo code.
+  `bun create stitchkit my-app` now creates the blank base; use
+  `bun create stitchkit my-app --example repository` for the previous runnable example.
+
+### Added
+
+- **One generated application identity.** A validated `app.config.json` now drives
+  package, PM2, MCP, OpenAPI, CLI, SEO and theme identity from one edit point.
+- **Contract-derived surface conformance.** Generated runtime smoke compares the
+  registered HTTP and tool manifest with live OpenAPI and MCP discovery, while
+  explicit typed probes remain application-owned.
+- **Optional trusted LAN HTTPS.** `bun run dev:lan` uses mkcert, exact-origin CORS
+  and a development-only onboarding route for secure-context testing on physical
+  devices without changing ordinary development or production behavior.
+- **Agent-first extension guide.** Generated applications include an application-
+  scoped `AGENTS.md` and a complete schema-to-runtime feature workflow in
+  `docs/ADDING_A_FEATURE.md`.
+
 ## [0.1.1] — 2026-08-10
 
 ### Changed

package/README.md

@@ -14,11 +14,18 @@ API, Prisma/PostgreSQL, typed shared contracts, Socket.IO, MCP, CLI tools and a
 complete production UI system.
 
 It uses one conventional `packages/*` namespace: `backend`, `frontend`,
-`config`, `db` and `shared`. The copied application keeps the neutral
-`stitchkit-starter` identity until its owner explicitly renames it.
+`config`, `db` and `shared`. The destination name becomes the generated slug;
+`--display-name` sets the human title. Both are recorded once in
+`app.config.json` and drive package, process, transport, UI and SEO identity.
 
-Its runnable example is the Stitchkit Starter: one configurable GitHub repository
-is persisted through a server-side PostgreSQL cache, including a Prisma-backed
+The default scaffold is domain-free. To add the runnable repository example:
+
+```bash
+bun create stitchkit my-app --example repository
+```
+
+The optional example uses one configurable GitHub repository persisted through a
+server-side PostgreSQL cache, including a Prisma-backed
 visibility enum that flows through the shared schema and typed client. `/en/ui`
 presents every reusable primitive and composition. Every public page ships with
 localized metadata, canonical and language alternatives, sitemap coverage and a

package/dist/cli.js

@@ -2,17 +2,19 @@
 // @bun
 
 // src/cli.ts
-import { basename as basename2, resolve as resolve2 } from "path";
+import { basename as basename3, resolve as resolve2 } from "path";
 var {spawn } = globalThis.Bun;
 
 // src/options.ts
 var HELP = `Create a production-shaped Stitchkit application.
 
 Usage:
-  bun create stitchkit <directory> [--no-install]
+  bun create stitchkit <directory> [--display-name "Product Name"] [--example repository] [--no-install]
 
 Options:
   --no-install  Generate files without installing dependencies
+  --example     Add an isolated runnable example (supported: repository)
+  --display-name  Set the initial public application name
   --help        Show this help
 `;
 function helpText() {
@@ -21,11 +23,26 @@ function helpText() {
 function parseOptions(args) {
   if (args.includes("--help") || args.includes("-h"))
     return "help";
-  const unknown = args.filter((arg) => arg.startsWith("-") && arg !== "--no-install");
+  const unknown = args.filter((arg) => arg.startsWith("-") && arg !== "--no-install" && arg !== "--example" && arg !== "--display-name");
   if (unknown.length > 0) {
     throw new Error(`Unknown option: ${unknown[0]}`);
   }
-  const positionals = args.filter((arg) => !arg.startsWith("-"));
+  const exampleFlagIndex = args.indexOf("--example");
+  const example = exampleFlagIndex === -1 ? undefined : args[exampleFlagIndex + 1];
+  if (exampleFlagIndex !== -1 && example === undefined) {
+    throw new Error("--example requires a value");
+  }
+  if (example !== undefined && example !== "repository") {
+    throw new Error(`Unknown example: ${example}`);
+  }
+  const displayNameFlagIndex = args.indexOf("--display-name");
+  const displayName = displayNameFlagIndex === -1 ? undefined : args[displayNameFlagIndex + 1];
+  if (displayNameFlagIndex !== -1 && displayName === undefined) {
+    throw new Error("--display-name requires a value");
+  }
+  const consumedExampleIndex = exampleFlagIndex === -1 ? -1 : exampleFlagIndex + 1;
+  const consumedDisplayNameIndex = displayNameFlagIndex === -1 ? -1 : displayNameFlagIndex + 1;
+  const positionals = args.filter((arg, index) => !arg.startsWith("-") && index !== consumedExampleIndex && index !== consumedDisplayNameIndex);
   if (positionals.length !== 1) {
     throw new Error("Exactly one destination directory is required");
   }
@@ -34,14 +51,49 @@ function parseOptions(args) {
     throw new Error("Destination directory is required");
   return {
     destination,
-    install: !args.includes("--no-install")
+    install: !args.includes("--no-install"),
+    ...example && { example },
+    ...displayName && { displayName }
   };
 }
 
 // src/scaffold.ts
 import { lstat, mkdir, readdir, readFile, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
-import { basename, dirname, join, parse, relative, resolve, sep } from "path";
+import { basename as basename2, dirname, extname, join, parse, relative, resolve, sep } from "path";
+import { z as z2 } from "zod";
+
+// src/identity.ts
+import { basename } from "path";
+import { z } from "zod";
+var ApplicationSlugSchema = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Use lowercase letters, numbers and single hyphens (for example: talk-control)");
+var ApplicationIdentitySchema = z.object({
+  slug: ApplicationSlugSchema,
+  name: z.string().trim().min(1).max(80),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, "Use a semantic version such as 0.1.0"),
+  description: z.object({
+    en: z.string().trim().min(1),
+    ru: z.string().trim().min(1)
+  })
+});
+function displayNameFromSlug(slug) {
+  return slug.split("-").map((part) => `${part[0]?.toUpperCase()}${part.slice(1)}`).join(" ");
+}
+function createApplicationIdentity(destination, displayName) {
+  const slug = ApplicationSlugSchema.parse(basename(destination));
+  const name = displayName?.trim() || displayNameFromSlug(slug);
+  return ApplicationIdentitySchema.parse({
+    slug,
+    name,
+    version: "0.1.0",
+    description: {
+      en: `${name} is a production application built with Stitchkit.`,
+      ru: `${name} \u2014 production-\u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u0435 \u043D\u0430 Stitchkit.`
+    }
+  });
+}
+
+// src/scaffold.ts
 var TEXT_EXTENSIONS = new Set([
   ".cjs",
   ".css",
@@ -61,10 +113,11 @@ var TEXT_EXTENSIONS = new Set([
   ".yml"
 ]);
 var TEMPLATE_RENAMES = new Map([
-  ["_env", ".env"],
   ["_env.example", ".env.example"],
+  ["_env.example.append", ".env.example"],
   ["_gitignore", ".gitignore"]
 ]);
+var RootManifestSchema = z2.looseObject({ name: z2.string().min(1) });
 var IGNORED_DIRECTORIES = new Set([
   ".next",
   "coverage",
@@ -82,7 +135,7 @@ function isTemplateSourcePathIncluded(sourcePath) {
     return false;
   if (normalized === "packages/db/src/generated" || normalized.startsWith("packages/db/src/generated/"))
     return false;
-  const name = basename(normalized);
+  const name = basename2(normalized);
   return name !== ".env" && name !== "next-env.d.ts" && !name.endsWith(".log") && !name.endsWith(".tsbuildinfo");
 }
 function shouldIncludeTemplatePath(templateDirectory, sourcePath) {
@@ -136,13 +189,14 @@ async function collectMaterialisedFiles(templateDirectory, directory, files) {
     const targetName = TEMPLATE_RENAMES.get(entry.name);
     const sourceRelativePath = relative(templateDirectory, sourcePath);
     const outputRelativePath = targetName ? join(dirname(sourceRelativePath), targetName) : sourceRelativePath;
-    const extension = targetName?.includes(".") ? targetName.slice(targetName.indexOf(".")) : "";
-    const fileExtension = extension || sourcePath.slice(sourcePath.lastIndexOf("."));
+    const materialisedName = outputRelativePath.endsWith(".append") ? outputRelativePath.slice(0, -".append".length) : outputRelativePath;
+    const fileExtension = extname(materialisedName);
     const content = TEXT_EXTENSIONS.has(fileExtension) || targetName ? await readFile(sourcePath, "utf8") : await readFile(sourcePath);
     files.push({
       sourcePath: portablePath(sourceRelativePath),
       outputPath: portablePath(outputRelativePath),
-      content
+      content,
+      append: entry.name.endsWith(".append")
     });
   }
 }
@@ -155,15 +209,34 @@ async function writeMaterialisedFiles(destination, files) {
   for (const file of files) {
     const targetPath = join(destination, file.outputPath);
     await mkdir(dirname(targetPath), { recursive: true });
-    await writeFile(targetPath, file.content);
+    if (file.append) {
+      if (typeof file.content !== "string") {
+        throw new Error(`Append template entries must contain text: ${file.sourcePath}`);
+      }
+      const existing = await readFile(targetPath, "utf8");
+      await writeFile(targetPath, `${existing.trimEnd()}
+${file.content.trimStart()}`);
+    } else {
+      await writeFile(targetPath, file.content);
+    }
   }
 }
-async function scaffoldProject(templateDirectory, destination) {
+async function scaffoldProject(templateDirectory, destination, options = {}) {
   const resolvedDestination = resolve(destination);
+  const identity = createApplicationIdentity(resolvedDestination, options.displayName);
   const destinationExisted = await assertDestinationAvailable(resolvedDestination);
   await mkdir(resolvedDestination, { recursive: true });
   try {
     await writeMaterialisedFiles(resolvedDestination, await materialiseTemplateFiles(templateDirectory));
+    if (options.overlayDirectory) {
+      await writeMaterialisedFiles(resolvedDestination, await materialiseTemplateFiles(options.overlayDirectory));
+    }
+    await writeFile(join(resolvedDestination, "app.config.json"), `${JSON.stringify(identity, undefined, 2)}
+`);
+    const manifestPath = join(resolvedDestination, "package.json");
+    const manifest = RootManifestSchema.parse(JSON.parse(await readFile(manifestPath, "utf8")));
+    await writeFile(manifestPath, `${JSON.stringify({ ...manifest, name: identity.slug }, undefined, 2)}
+`);
   } catch (error) {
     if (!destinationExisted) {
       await rm(resolvedDestination, { recursive: true, force: true });
@@ -185,7 +258,11 @@ async function run(args) {
     }
     const destination = resolve2(options.destination);
     const templateDirectory = resolve2(import.meta.dir, "../template");
-    await scaffoldProject(templateDirectory, destination);
+    const overlayDirectory = options.example ? resolve2(import.meta.dir, `../examples/${options.example}`) : undefined;
+    await scaffoldProject(templateDirectory, destination, {
+      ...overlayDirectory && { overlayDirectory },
+      ...options.displayName && { displayName: options.displayName }
+    });
     if (options.install) {
       const install = spawn(["bun", "install"], {
         cwd: destination,
@@ -197,8 +274,9 @@ async function run(args) {
       if (exitCode !== 0)
         throw new Error(`bun install failed with exit code ${exitCode}`);
     }
+    const mode = options.example ? ` with the ${options.example} example` : "";
     process.stdout.write(`
-Created Stitchkit Starter in ${basename2(destination)}
+Created ${options.displayName ?? basename3(destination)}${mode}
 
 `);
     process.stdout.write(`  cd ${options.destination}

package/examples/repository/_env.example.append

@@ -0,0 +1,4 @@
+GITHUB_REPOSITORY=max-listov/stitchkit
+GITHUB_CACHE_TTL_SECONDS=900
+# Optional. Authenticated conditional requests have a higher GitHub rate limit.
+# GITHUB_TOKEN=github_pat_...

package/examples/repository/e2e/repository.spec.ts

@@ -0,0 +1,69 @@
+import { expect, test } from '@playwright/test';
+
+test('prefetched data hydrates without a loading flash or a client refetch', async ({
+  page,
+  request,
+}) => {
+  // The SSR document itself carries the prefetched repository data — the
+  // dehydration envelope is not empty.
+  const document = await request.get('/en');
+  expect(await document.text()).toContain('max-listov/stitchkit');
+
+  // Block the browser-side read entirely: the page must still render the data
+  // from the hydration envelope — never refetching, never flashing a loader.
+  let clientReads = 0;
+  await page.route('**/api/repository', async (route) => {
+    if (route.request().method() === 'GET') {
+      clientReads += 1;
+      await route.abort();
+      return;
+    }
+    await route.continue();
+  });
+  await page.goto('/en');
+  await expect(page.getByText('max-listov/stitchkit')).toBeVisible();
+  expect(clientReads).toBe(0);
+});
+
+test('a server realtime event updates the TanStack cache without a client refetch', async ({
+  page,
+}) => {
+  await page.goto('/en');
+  const summary = page.getByTestId('repository-summary');
+  await expect(summary).toBeVisible();
+  const before = await summary.getAttribute('data-fetched-at');
+  expect(before).not.toBeNull();
+
+  // Sever the refetch path completely: the refresh mutation invalidates the
+  // query, but its refetch is aborted here — so the ONLY way the summary can
+  // carry a new snapshot is the Socket.IO event through the cache bridge.
+  await page.route('**/api/repository', async (route) => {
+    if (route.request().method() === 'GET') {
+      await route.abort();
+      return;
+    }
+    await route.continue();
+  });
+  await page.getByRole('button', { name: 'Refresh repository data' }).click();
+  await expect(summary).not.toHaveAttribute('data-fetched-at', before ?? '', {
+    timeout: 10_000,
+  });
+});
+
+test('renders and refreshes the repository example', async ({ page }) => {
+  await page.route('**/api/repository/refresh', async (route) => {
+    await new Promise((resolve) => setTimeout(resolve, 750));
+    await route.continue();
+  });
+  await page.goto('/en');
+  await expect(page.getByText('max-listov/stitchkit')).toBeVisible();
+
+  const refresh = page.getByRole('button', { name: 'Refresh repository data' });
+  await expect(refresh).toHaveCSS('height', '32px');
+  await expect(refresh).toHaveCSS('width', '32px');
+  await expect(refresh.locator('.tabler-icon-refresh')).toHaveCount(1);
+  await refresh.click();
+  await expect(refresh).toHaveAttribute('aria-busy', 'true');
+  await expect(refresh.locator('svg')).toHaveCount(1);
+  await expect(refresh.locator('.tabler-icon-refresh')).toHaveClass(/animate-spin/);
+});

package/{template → examples/repository}/packages/backend/src/domain/repository/github-cache.test.ts

@@ -1,4 +1,6 @@
 import { describe, expect, test } from 'bun:test';
+import { RepositoryVisibility } from '@app/db';
+import { RepositoryVisibilitySchema } from '@app/shared';
 import {
   GitHubRepositoryCache,
   type RepositorySnapshotStore,
@@ -39,6 +41,12 @@ function commitsResponse(): Response {
 }
 
 describe('GitHubRepositoryCache', () => {
+  test('keeps the shared wire enum aligned with the database enum', () => {
+    expect([...RepositoryVisibilitySchema.options].sort()).toEqual(
+      Object.values(RepositoryVisibility).sort(),
+    );
+  });
+
   test('deduplicates refreshes and persists an exact repository snapshot', async () => {
     const requests: URL[] = [];
     const fetcher = async (url: URL) => {

package/{template → examples/repository}/packages/backend/src/domain/repository/github-cache.ts

@@ -1,4 +1,5 @@
 import { env } from '@app/config';
+import { appIdentity } from '@app/config/identity';
 import { RepositoryVisibility } from '@app/db';
 import type { RepositorySnapshot } from '@app/shared';
 import { z } from 'zod';
@@ -80,7 +81,7 @@ const snapshotStore: RepositorySnapshotStore = {
 function githubHeaders(): Headers {
   const headers = new Headers({
     Accept: 'application/vnd.github+json',
-    'User-Agent': 'stitchkit-starter',
+    'User-Agent': appIdentity.slug,
     'X-GitHub-Api-Version': '2026-03-10',
   });
   if (env.GITHUB_TOKEN) headers.set('Authorization', `Bearer ${env.GITHUB_TOKEN}`);

package/examples/repository/packages/backend/src/surface.snapshot.json

@@ -0,0 +1,58 @@
+[
+  {
+    "service": "repository",
+    "action": "read",
+    "scope": "public",
+    "hasInput": false,
+    "hasOutput": true,
+    "inputShape": null,
+    "outputShape": "49c1f81a53ca82ad",
+    "http": [
+      {
+        "method": "GET",
+        "path": "/api/repository"
+      }
+    ],
+    "tools": {
+      "MCP": "repository_read",
+      "AGENT": "repository_read",
+      "CLI": "repository_read"
+    }
+  },
+  {
+    "service": "repository",
+    "action": "refresh",
+    "scope": "public",
+    "hasInput": false,
+    "hasOutput": true,
+    "inputShape": null,
+    "outputShape": "49c1f81a53ca82ad",
+    "http": [
+      {
+        "method": "POST",
+        "path": "/api/repository/refresh"
+      }
+    ],
+    "tools": {
+      "MCP": "repository_refresh",
+      "AGENT": "repository_refresh",
+      "CLI": "repository_refresh"
+    }
+  },
+  {
+    "service": "system",
+    "action": "status",
+    "scope": "public",
+    "hasInput": false,
+    "hasOutput": true,
+    "inputShape": null,
+    "outputShape": "58b078ade3ee6167",
+    "http": [
+      {
+        "method": "GET",
+        "path": "/api/system/status"
+      }
+    ],
+    "tools": {}
+  }
+]

package/examples/repository/packages/backend/src/surface.ts

@@ -0,0 +1,16 @@
+import { env } from '@app/config';
+import { repositoryRealtimeContract } from '@app/shared';
+import { bindRealtimeServer, createSocketIOServer } from 'stitchkit/server';
+import { createRepositoryService } from './transport/repository-service';
+import { createSystemService } from './transport/system-service';
+
+export async function createSurface() {
+  const socket = await createSocketIOServer({
+    cors: { origin: env.CORS_ORIGIN },
+  });
+  const realtime = bindRealtimeServer(repositoryRealtimeContract, socket);
+  const repositoryService = createRepositoryService((snapshot) =>
+    realtime.emit('repository:refreshed', snapshot),
+  );
+  return { socket, services: [createSystemService(), repositoryService] };
+}

package/examples/repository/packages/config/src/features.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const featureServerSchema = {
+  GITHUB_REPOSITORY: z.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/),
+  GITHUB_CACHE_TTL_SECONDS: z.coerce.number().int().positive().default(900),
+  GITHUB_TOKEN: z.string().min(1).optional(),
+};

package/examples/repository/packages/db/schema.prisma

@@ -0,0 +1,31 @@
+generator client {
+  provider = "prisma-client"
+  output   = "./src/generated"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+enum RepositoryVisibility {
+  PUBLIC
+  PRIVATE
+  INTERNAL
+}
+
+model RepositorySnapshot {
+  fullName            String   @id
+  description         String?
+  htmlUrl             String
+  language            String?
+  visibility          RepositoryVisibility @default(PUBLIC)
+  stars               Int
+  forks               Int
+  openIssues          Int
+  commitCount         Int
+  latestCommitSha     String?
+  latestCommitMessage String?
+  latestCommittedAt   DateTime?
+  fetchedAt           DateTime
+  expiresAt           DateTime
+}

package/examples/repository/packages/frontend/src/app/[locale]/page.tsx

@@ -0,0 +1,45 @@
+import { appIdentity } from '@app/config/identity';
+import { dehydrate, HydrationBoundary } from '@tanstack/react-query';
+import type { Metadata } from 'next';
+import { getTranslations } from 'next-intl/server';
+import { LocaleSchema } from '@/i18n/locales';
+import { createServerRepositoryApi } from '@/lib/api/client';
+import { useRepository } from '@/lib/api/queries';
+import { getQueryClient } from '@/lib/query-client';
+import { createPageMetadata } from '@/lib/seo/metadata';
+import { StarterPage } from './starter-page';
+
+export const dynamic = 'force-dynamic';
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ locale: string }>;
+}): Promise<Metadata> {
+  const { locale } = await params;
+  return createPageMetadata('home', LocaleSchema.parse(locale));
+}
+
+export default async function Page({ params }: { params: Promise<{ locale: string }> }) {
+  const { locale } = await params;
+  const appLocale = LocaleSchema.parse(locale);
+  const queryClient = getQueryClient();
+  const api = createServerRepositoryApi();
+  const t = await getTranslations('App');
+  await queryClient.prefetchQuery({
+    queryKey: useRepository.getKey(),
+    queryFn: () => api.read(),
+  });
+
+  return (
+    <HydrationBoundary state={dehydrate(queryClient)}>
+      <StarterPage
+        applicationName={appIdentity.name}
+        applicationDescription={appIdentity.description[appLocale]}
+        heroTitle={t('heroTitle')}
+        catalogueLabel={t('ui')}
+        locale={appLocale}
+      />
+    </HydrationBoundary>
+  );
+}