create-ailk 0.3.0 → 0.5.0

package/templates/apps/mcp/__tests__/tools/{scaffold.test.ts → create_project.test.ts}

@@ -1,16 +1,16 @@
 /**
- * Tests for the ailkScaffold MCP tool handler.
+ * Tests for the ailkCreateProject MCP tool handler.
  *
  * Acceptance criteria verified here:
  * - scaffoldInputSchema validates correct inputs
  * - scaffoldInputSchema rejects invalid inputs (empty projectName, missing targetDir)
- * - ailkScaffold scaffolds into a tmp dir: package.json + ≥1 file created
- * - ailkScaffold fails cleanly when targetDir is non-empty (rejects with Error)
+ * - ailkCreateProject scaffolds into a tmp dir: package.json + ≥1 file created
+ * - ailkCreateProject fails cleanly when targetDir is non-empty (rejects with Error)
  * - Output validates against scaffoldOutputSchema
  * - No direct create-ailk import in apps/mcp (architectural guard)
  *
  * Hermetic: uses os.tmpdir() + unique subdir. No network calls.
- * Integration tests pass CLI_PATH explicitly to ailkScaffold (second arg)
+ * Integration tests pass CLI_PATH explicitly to ailkCreateProject (second arg)
  * so they don't depend on process.cwd() being the repo root in Jest.
  */
 
@@ -26,7 +26,7 @@ import { join, resolve } from "node:path";
 
 import { scaffoldInputSchema, scaffoldOutputSchema } from "@working-theory/validation";
 
-import { ailkScaffold } from "../../src/tools/scaffold.js";
+import { ailkCreateProject } from "../../src/tools/create_project.js";
 
 // ── Input schema tests ────────────────────────────────────────────────────────
 
@@ -103,13 +103,13 @@ describe("scaffoldOutputSchema", () => {
 const REPO_ROOT = resolve(__dirname, "../../../..");
 const CLI_PATH = join(REPO_ROOT, "packages/create-ailk/dist/cli.js");
 
-describe("ailkScaffold handler", () => {
+describe("ailkCreateProject handler", () => {
   let scratch: string;
 
   beforeAll(() => {
     if (!existsSync(CLI_PATH)) {
       console.warn(
-        `[scaffold.test] create-ailk CLI not built: ${CLI_PATH} missing. ` +
+        `[create_project.test] create-ailk CLI not built: ${CLI_PATH} missing. ` +
           "Run `pnpm --filter create-ailk build` first.",
       );
     }
@@ -125,11 +125,11 @@ describe("ailkScaffold handler", () => {
 
   it("scaffolds at least one file into a fresh tmp dir and reports targetDir", async () => {
     if (!existsSync(CLI_PATH)) {
-      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      console.warn("[create_project.test] skipping integration test — CLI not built");
       return;
     }
     const target = join(scratch, "my-site");
-    const output = await ailkScaffold(
+    const output = await ailkCreateProject(
       { targetDir: target, projectName: "my-site" },
       CLI_PATH,
     );
@@ -139,37 +139,37 @@ describe("ailkScaffold handler", () => {
 
   it("scaffolds package.json when full templates are built (build-templates required)", async () => {
     if (!existsSync(CLI_PATH)) {
-      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      console.warn("[create_project.test] skipping integration test — CLI not built");
       return;
     }
     const TEMPLATES_DIR = join(REPO_ROOT, "packages/create-ailk/templates");
     const PKG_JSON_IN_TEMPLATES = join(TEMPLATES_DIR, "package.json");
     if (!existsSync(PKG_JSON_IN_TEMPLATES)) {
       console.warn(
-        "[scaffold.test] skipping package.json assertion — run `pnpm --filter create-ailk run build-templates` first",
+        "[create_project.test] skipping package.json assertion — run `pnpm --filter create-ailk run build-templates` first",
       );
       return;
     }
     const target = join(scratch, "my-site");
-    await ailkScaffold({ targetDir: target, projectName: "my-site" }, CLI_PATH);
+    await ailkCreateProject({ targetDir: target, projectName: "my-site" }, CLI_PATH);
     expect(existsSync(join(target, "package.json"))).toBe(true);
   });
 
   it("scaffolds app dir when full templates are built (build-templates required)", async () => {
     if (!existsSync(CLI_PATH)) {
-      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      console.warn("[create_project.test] skipping integration test — CLI not built");
       return;
     }
     const TEMPLATES_DIR = join(REPO_ROOT, "packages/create-ailk/templates");
     const PKG_JSON_IN_TEMPLATES = join(TEMPLATES_DIR, "package.json");
     if (!existsSync(PKG_JSON_IN_TEMPLATES)) {
       console.warn(
-        "[scaffold.test] skipping app dir assertion — run `pnpm --filter create-ailk run build-templates` first",
+        "[create_project.test] skipping app dir assertion — run `pnpm --filter create-ailk run build-templates` first",
       );
       return;
     }
     const target = join(scratch, "my-site");
-    await ailkScaffold({ targetDir: target, projectName: "my-site" }, CLI_PATH);
+    await ailkCreateProject({ targetDir: target, projectName: "my-site" }, CLI_PATH);
     // The template produces apps/web/app/ from the monorepo template snapshot.
     const hasApp =
       existsSync(join(target, "app")) ||
@@ -179,22 +179,22 @@ describe("ailkScaffold handler", () => {
 
   it("returns at least one file (schema-typed page seed or README.md)", async () => {
     if (!existsSync(CLI_PATH)) {
-      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      console.warn("[create_project.test] skipping integration test — CLI not built");
       return;
     }
     const target = join(scratch, "my-site");
-    await ailkScaffold({ targetDir: target, projectName: "my-site" }, CLI_PATH);
+    await ailkCreateProject({ targetDir: target, projectName: "my-site" }, CLI_PATH);
     // At minimum README.md is always emitted by the template.
     expect(existsSync(join(target, "README.md"))).toBe(true);
   });
 
   it("returns output conforming to scaffoldOutputSchema", async () => {
     if (!existsSync(CLI_PATH)) {
-      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      console.warn("[create_project.test] skipping integration test — CLI not built");
       return;
     }
     const target = join(scratch, "my-site");
-    const output = await ailkScaffold(
+    const output = await ailkCreateProject(
       { targetDir: target, projectName: "my-site" },
       CLI_PATH,
     );
@@ -204,7 +204,7 @@ describe("ailkScaffold handler", () => {
 
   it("rejects with a clear error when targetDir is non-empty", async () => {
     if (!existsSync(CLI_PATH)) {
-      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      console.warn("[create_project.test] skipping integration test — CLI not built");
       return;
     }
     const target = join(scratch, "populated");
@@ -215,7 +215,7 @@ describe("ailkScaffold handler", () => {
     // the target exists and is non-empty. The MCP handler rejects with a
     // descriptive Error whose message matches the CLI stderr output.
     await expect(
-      ailkScaffold({ targetDir: target, projectName: "populated" }, CLI_PATH),
+      ailkCreateProject({ targetDir: target, projectName: "populated" }, CLI_PATH),
     ).rejects.toThrow(/non-empty|exists/i);
   });
 });
@@ -223,11 +223,11 @@ describe("ailkScaffold handler", () => {
 // ── Architectural guard ───────────────────────────────────────────────────────
 
 describe("architectural guard — no create-ailk direct import", () => {
-  it("apps/mcp/src/tools/scaffold.ts does not import create-ailk directly", async () => {
+  it("apps/mcp/src/tools/create_project.ts does not import create-ailk directly", async () => {
     const { readFileSync } = await import("node:fs");
     const { resolve: res } = await import("node:path");
     const src = readFileSync(
-      res(__dirname, "../../src/tools/scaffold.ts"),
+      res(__dirname, "../../src/tools/create_project.ts"),
       "utf-8",
     );
     // Must not have a static import of create-ailk or its dist

package/templates/apps/mcp/eslint.config.mjs

@@ -0,0 +1,69 @@
+// Self-contained ESLint flat config for this scaffolded package.
+//
+// It deliberately does NOT depend on @working-theory/eslint-config — that
+// package is internal to the AI Launch Kit monorepo and is not published, so
+// it cannot be a dependency of a scaffolded starter. Everything below comes
+// from public npm packages already pinned as devDependencies (see
+// package.json): @eslint/js, globals and typescript-eslint.
+//
+// Source file name (#5556): this file is checked in as `_eslint.config.mjs`,
+// not `eslint.config.mjs` — build-templates.mjs renames it at snapshot time
+// (renameScaffoldLintConfigs()). A file literally named `eslint.config.mjs`
+// anywhere under this monorepo (even one this repo's own root eslint.config.ts
+// lists in its `ignores`) is auto-discovered by ESLint's flat-config nested
+// resolution as a competing config root, which breaks the monorepo's own
+// lint runs (verified live: typescript-eslint's "multiple candidate
+// TSConfigRootDirs" parser error across unrelated packages/create-ailk
+// files). The underscore prefix keeps it invisible to that discovery while
+// it lives in this checkout; only the snapshot in templates/ — which ships
+// to the customer, not this repo — gets the real filename.
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  {
+    ignores: [
+      "**/.next/**",
+      "**/dist/**",
+      "**/generated/**",
+      "**/node_modules/**",
+    ],
+  },
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.browser,
+        ...globals.jest,
+      },
+      // Explicit, self-contained root — this scaffold config is never meant
+      // to combine with any sibling scaffold package's config (each ships
+      // standalone), and leaving it unset makes typescript-eslint's
+      // candidate-root disambiguation ambiguous the moment more than one
+      // scaffold package's config resolves in the same ESLint process (e.g.
+      // this monorepo's own `templates/` build, where all four exist
+      // side by side; a real customer scaffold never has that problem,
+      // since it only ever ships and lints ONE of these four at a time).
+      parserOptions: {
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    rules: {
+      // Downgraded rather than off, so both stay visible without failing a
+      // fresh scaffold's lint:
+      //   - unused-vars: most of the source follows the underscore-prefix
+      //     convention for intentionally-unused bindings, which this rule's
+      //     default options don't recognize; a handful of test fixtures also
+      //     carry genuinely-unused locals this minimal config doesn't try to
+      //     triage file-by-file.
+      //   - require-imports: CommonJS require() is the correct form in Jest
+      //     config/mock files and in a few test-only dynamic re-require
+      //     patterns.
+      "@typescript-eslint/no-unused-vars": "warn",
+      "@typescript-eslint/no-require-imports": "warn",
+    },
+  },
+);

package/templates/apps/mcp/package.json

@@ -6,7 +6,7 @@
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
-    "lint": "tsx ../../scripts/lint-package.ts",
+    "lint": "eslint .",
     "build": "tsc -b",
     "type-check": "tsc --noEmit",
     "dev": "node --experimental-vm-modules dist/index.js",
@@ -34,6 +34,10 @@
     "@types/node": "^22.20.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "eslint": "^10.6.0",
+    "@eslint/js": "^10.0.1",
+    "globals": "^17.7.0",
+    "typescript-eslint": "^8.62.1"
   }
 }

package/templates/apps/mcp/src/server.ts

@@ -18,6 +18,7 @@ import { getMcpToolRegistrations, OSS_DISABLED_TOOLS } from "@working-theory/met
 import { isModuleEnabled } from "./config/modules.js";
 import { ailkAudit } from "./tools/audit.js";
 import { ailkCaptureLead } from "./tools/capture_lead.js";
+import { ailkCreateProject } from "./tools/create_project.js";
 import { ailkGetBusinessHours } from "./tools/get_business_hours.js";
 import { ailkGetFaq } from "./tools/get_faq.js";
 import { ailkGetLocations } from "./tools/get_locations.js";
@@ -28,7 +29,6 @@ import { ailkListPages } from "./tools/list_pages.js";
 import { ailkPurchase } from "./tools/purchase.js";
 import { ailkReadContent } from "./tools/read_content.js";
 import { ailkRequestCallback } from "./tools/request_callback.js";
-import { ailkScaffold } from "./tools/scaffold.js";
 import { ailkSearchContent } from "./tools/search_content.js";
 import { ailkSubscribeNewsletter } from "./tools/subscribe_newsletter.js";
 
@@ -62,7 +62,7 @@ const HANDLERS: Record<string, (input: unknown) => Promise<unknown>> = {
   capture_lead: (input) => ailkCaptureLead(input as never),
   subscribe_newsletter: (input) => ailkSubscribeNewsletter(input as never),
   request_callback: (input) => ailkRequestCallback(input as never),
-  scaffold: (input) => ailkScaffold(input as never),
+  create_project: (input) => ailkCreateProject(input as never),
 };
 
 type ToolHandler = (input: unknown) => Promise<unknown>;

package/templates/apps/mcp/src/tools/{scaffold.ts → create_project.ts}

@@ -1,5 +1,5 @@
 /**
- * scaffold — creates an AI Launch Kit starter project via create-ailk.
+ * create_project — creates an AI Launch Kit starter project via create-ailk.
  *
  * Agent-only: no web Server Action equivalent. Scaffolding is an
  * orchestration-layer action that only makes sense for an agent driving a
@@ -76,7 +76,7 @@ function countFiles(dir: string): number {
 }
 
 /**
- * ailkScaffold handler.
+ * ailkCreateProject handler.
  *
  * Spawns the create-ailk CLI binary to scaffold a starter project into
  * targetDir. The binary must be pre-built (`pnpm --filter create-ailk build`).
@@ -84,7 +84,7 @@ function countFiles(dir: string): number {
  * Accepts an optional `cliBin` override for testing (mirrors the contentRoot
  * override pattern in ailkAudit).
  */
-export async function ailkScaffold(
+export async function ailkCreateProject(
   input: ScaffoldInput,
   cliBin?: string,
 ): Promise<ScaffoldOutput> {

package/templates/apps/mcp/src/tools/index.ts

@@ -119,10 +119,10 @@ export {
 export {
   scaffoldInputSchema,
   scaffoldOutputSchema,
-  ailkScaffold,
+  ailkCreateProject,
   type ScaffoldInput,
   type ScaffoldOutput,
-} from "./scaffold.js";
+} from "./create_project.js";
 
 // The scheduling tools (list_availability, get_event_meta, create_booking),
 // the content-write tools (create_page, update_page, delete_page), and the

package/templates/apps/web/.env.example

@@ -77,12 +77,12 @@ CONTENT_BACKEND=mdx
 # =============================================================================
 # Scheduling — the scheduling module's booking page (#4633)
 # =============================================================================
-# Which event `/schedule` books, as "<owner>/<event-slug>" — the path of the
+# Which event `/meet` books, as "<owner>/<event-slug>" — the path of the
 # provider's own public booking page. Read server-side in
-# app/[locale]/schedule/page.tsx and handed to the `booker` section, which
+# app/[locale]/meet/page.tsx and handed to the `booker` section, which
 # sends it back to apps/api's /v1/schedule/* routes to name the event.
 #
-# Unset is a supported state: `/schedule` 404s, exactly as if the scheduling
+# Unset is a supported state: `/meet` 404s, exactly as if the scheduling
 # module were not installed.
 #
 # NOT a credential, and deliberately NOT a NEXT_PUBLIC_ variable — the API key

package/templates/apps/web/CLAUDE.md

@@ -31,6 +31,8 @@ MDX file → content adapter parses frontmatter → adapter emits `ContentPage`
 
 Use `@working-theory/ui` components for content patterns. See `content/CLAUDE.md` for the full vocabulary — it's identical across page types because the rule is about the component, not the page. For the per-page-type editorial map, see `packages/schema/CLAUDE.md` § `@working-theory/ui` component map.
 
+Site-local components that aren't generic enough for `@working-theory/ui` live in `apps/web/components/` — the one component folder for this app.
+
 Raw HTML is allowed only when no `@working-theory/ui` component fits. Flag it in PR review when you add raw HTML.
 
 ## Theme & styling

package/templates/apps/web/app/[locale]/(authed)/account/page.tsx

@@ -12,12 +12,10 @@
  * email unverified — the profile row already says so) is skipped, never
  * thrown; every other error rethrows to the route error boundary.
  *
- * Chrome: `PortalShell` hard-codes its /portal nav and accepts only
- * `siteName` + `children`, so this composes `AppShell` + `SidebarNav`
- * directly — the same structure PortalShell itself uses — with this page's
- * own three in-page anchors. The page renders inside the locale layout
- * (which owns the marketing Nav/Footer) — the operator's decision; there is
- * no second MarketingShell here.
+ * Chrome: this page composes `AppShell` + `SidebarNav` directly, with this
+ * page's own three in-page anchors. The page renders inside the locale
+ * layout (which owns the marketing Nav/Footer) — the operator's decision;
+ * there is no second MarketingShell here.
  */
 
 import {

package/templates/apps/web/app/[locale]/(authed)/layout.tsx

@@ -2,7 +2,7 @@
  * (authed) segment layout — the operator-dashboard session guard (#4665 D9).
  *
  * RSC: reads the active Better Auth session via `auth.api.getSession`
- * (mirrors `apps-paid/workspace/app/(authed)/layout.tsx`). With no session it
+ * (mirrors `apps-paid/admin/app/(authed)/layout.tsx`). With no session it
  * renders `SignInGate` — the dashboard's own front door — rather than
  * redirecting (a `redirect("/sign-in")` would render the visitor's requested
  * path only as a query param; rendering the gate in place keeps the URL, and

package/templates/apps/web/app/[locale]/(authed)/leads/__tests__/page.test.tsx

@@ -0,0 +1,181 @@
+/**
+ * Tests for the signed-in owner's lead inbox (#5678 Deliverable 2).
+ *
+ * Covers:
+ *   1. Renders one row per lead, with a `null` name shown as the
+ *      "unavailable" sentinel rather than blank.
+ *   2. Renders the forward-only "next" link when `nextCursor` is present, and
+ *      omits it when it is `null`.
+ *   3. Forwards `?cursor=` from `searchParams` to the api-client call.
+ *   4. Renders an EmptyState — not a headerless table — for an empty page.
+ *   5. Renders ForbiddenState on a 401/403; falls back to the first page
+ *      when a supplied `?cursor=` 400s; rethrows every other error.
+ */
+import { render, screen } from "@testing-library/react";
+
+jest.mock("next-intl/server", () => ({
+  __esModule: true,
+  getTranslations: jest.fn().mockImplementation(async () => (key: string, values?: Record<string, unknown>) =>
+    values ? `copy:${key}:${JSON.stringify(values)}` : `copy:${key}`,
+  ),
+}));
+
+jest.mock("next/headers", () => ({
+  __esModule: true,
+  headers: jest.fn().mockResolvedValue(new Headers()),
+  cookies: jest.fn().mockResolvedValue({ toString: () => "session=abc" }),
+}));
+
+const mockList = jest.fn();
+jest.mock("@working-theory/api-client", () => ({
+  __esModule: true,
+  leads: { list: (...args: unknown[]) => mockList(...args) },
+}));
+
+import Page from "../page";
+
+const FIXTURE_PAGE = {
+  items: [
+    {
+      id: "lead_1",
+      name: "Ada Lovelace",
+      email: "ada@example.com",
+      source: "web",
+      createdAt: "2026-09-01T10:00:00.000Z",
+    },
+    {
+      id: "lead_2",
+      name: null,
+      email: "anon@example.com",
+      source: "conversational-intake",
+      createdAt: "2026-08-31T09:00:00.000Z",
+    },
+  ],
+  nextCursor: null as string | null,
+};
+
+function renderPage(cursor?: string) {
+  return Page({
+    params: Promise.resolve({ locale: "en" }),
+    searchParams: Promise.resolve(cursor ? { cursor } : {}),
+  });
+}
+
+describe("LeadsInboxPage", () => {
+  beforeEach(() => {
+    mockList.mockReset();
+  });
+
+  it("renders one row per lead, with email and source", async () => {
+    mockList.mockResolvedValue({ ok: true, body: FIXTURE_PAGE });
+    render(await renderPage());
+
+    expect(screen.getByTestId("leads-inbox-page")).toBeInTheDocument();
+    const first = screen.getByTestId("leads-table-row-lead_1");
+    expect(first).toHaveTextContent("Ada Lovelace");
+    expect(first).toHaveTextContent("ada@example.com");
+    expect(first).toHaveTextContent("web");
+    expect(screen.getByTestId("leads-table-row-lead_2")).toHaveTextContent(
+      "conversational-intake",
+    );
+    expect(screen.getAllByTestId(/^leads-table-row-/)).toHaveLength(2);
+  });
+
+  it("renders a null name as the unavailable sentinel", async () => {
+    mockList.mockResolvedValue({ ok: true, body: FIXTURE_PAGE });
+    render(await renderPage());
+
+    expect(screen.getByTestId("leads-table-row-lead_2")).toHaveTextContent(
+      "copy:table.unavailable",
+    );
+  });
+
+  it("omits the next link when nextCursor is null", async () => {
+    mockList.mockResolvedValue({ ok: true, body: FIXTURE_PAGE });
+    render(await renderPage());
+
+    expect(screen.queryByTestId("leads-table-next")).not.toBeInTheDocument();
+  });
+
+  it("renders the next link pointing at the next cursor", async () => {
+    mockList.mockResolvedValue({
+      ok: true,
+      body: { ...FIXTURE_PAGE, nextCursor: "lead_2" },
+    });
+    render(await renderPage());
+
+    const next = screen.getByTestId("leads-table-next");
+    expect(next).toBeInTheDocument();
+    expect(next).toHaveAttribute("href", "/en/leads?cursor=lead_2");
+  });
+
+  it("forwards ?cursor= to the api-client call", async () => {
+    mockList.mockResolvedValue({ ok: true, body: FIXTURE_PAGE });
+    render(await renderPage("lead_9"));
+
+    expect(mockList).toHaveBeenCalledWith(
+      { cursor: "lead_9" },
+      expect.objectContaining({ headers: expect.objectContaining({ cookie: "session=abc" }) }),
+    );
+  });
+
+  it("renders an EmptyState when the owner has no leads", async () => {
+    mockList.mockResolvedValue({ ok: true, body: { items: [], nextCursor: null } });
+    render(await renderPage());
+
+    expect(screen.getByTestId("leads-table-empty")).toBeInTheDocument();
+    expect(screen.queryByTestId("leads-table")).not.toBeInTheDocument();
+  });
+
+  it("renders ForbiddenState on a 401 rather than throwing", async () => {
+    mockList.mockResolvedValue({
+      ok: false,
+      status: 401,
+      body: { error: { code: "unauthorized", message: "Unauthorized" } },
+    });
+    render(await renderPage());
+
+    expect(screen.getByTestId("waitlist-forbidden")).toBeInTheDocument();
+  });
+
+  it("rethrows a non-401/403 error", async () => {
+    mockList.mockResolvedValue({
+      ok: false,
+      status: 500,
+      body: { error: { code: "internal_error", message: "Boom" } },
+    });
+    await expect(renderPage()).rejects.toThrow();
+  });
+
+  // PR #5705 security review, finding 3.
+  it("falls back to the first page when a supplied ?cursor= 400s", async () => {
+    mockList
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 400,
+        body: {
+          error: {
+            code: "validation_failed",
+            message: "cursor does not resolve within this scope",
+          },
+        },
+      })
+      .mockResolvedValueOnce({ ok: true, body: FIXTURE_PAGE });
+
+    render(await renderPage("lead_gone"));
+
+    expect(screen.getByTestId("leads-table")).toBeInTheDocument();
+    expect(mockList).toHaveBeenNthCalledWith(1, { cursor: "lead_gone" }, expect.anything());
+    expect(mockList).toHaveBeenNthCalledWith(2, {}, expect.anything());
+  });
+
+  it("rethrows a 400 on the FIRST page — there is no cursor to blame", async () => {
+    mockList.mockResolvedValue({
+      ok: false,
+      status: 400,
+      body: { error: { code: "validation_failed", message: "Invalid query parameters" } },
+    });
+    await expect(renderPage()).rejects.toThrow();
+    expect(mockList).toHaveBeenCalledTimes(1);
+  });
+});