create-nwire 0.12.1 → 0.13.1

package/templates/mcp/app/app.ts

@@ -0,0 +1,24 @@
+/**
+ * App — the composition root.
+ *
+ * `createApp` constructs the container and wires all MCP tools in this
+ * module body. The exported `app` is COMPLETE on import — no caller needs
+ * to wire or start it. No ports are bound here; that is `main.ts`'s job.
+ *
+ * Tests import `{ app }` from this file and drive it with `mcpAdapter()`
+ * directly — never import `main.ts` from tests, it owns the stdio loop
+ * and will hang the runner.
+ *
+ * Graduate: add `@nwire/mongo` or `@nwire/drizzle` as a plugin here when
+ * the in-memory store outgrows its welcome. The tool handlers keep calling
+ * `ctx.resolve("db")`; nothing else changes.
+ */
+
+import { createApp } from "@nwire/app";
+import { tools } from "./tools";
+
+export const app = createApp({ appName: "{{PROJECT_NAME}}" });
+
+for (const { binding, handler } of tools) {
+  app.wire(binding, handler);
+}

package/templates/mcp/app/main.ts

@@ -0,0 +1,197 @@
+/**
+ * Entry — the only file that owns side effects.
+ *
+ * Boots the nwire app under the MCP adapter, then runs the JSON-RPC
+ * framing loop so AI clients (Claude, Cursor, IDE plugins) can drive this
+ * server over stdio.
+ *
+ * ┌─ STDOUT IS THE JSON-RPC CHANNEL ─────────────────────────────────┐
+ * │                                                                    │
+ * │  Every byte written to stdout MUST be a complete, newline-framed  │
+ * │  JSON-RPC message. Non-JSON noise (console.log, banners, debug    │
+ * │  text) breaks every MCP client silently.                           │
+ * │                                                                    │
+ * │  Log to stderr:  console.error("msg") or process.stderr.write()   │
+ * │  NEVER:          console.log()  process.stdout.write(plain text)   │
+ * └────────────────────────────────────────────────────────────────────┘
+ *
+ * The mcpAdapter boots the nwire runtime so tools run through the normal
+ * dispatch path (validation, DI, observability). The stdio loop below
+ * translates JSON-RPC calls into adapter invocations.
+ *
+ * Tests import `{ app }` from `./app` and bypass this file entirely.
+ * Never import `main.ts` from a test — the stdio loop holds the process
+ * open and hangs the runner.
+ */
+
+import { endpoint } from "@nwire/endpoint";
+import { mcpAdapter } from "@nwire/mcp";
+import { appConfig } from "../config/app";
+import { app } from "./app";
+
+const cfg = appConfig();
+
+const mcp = mcpAdapter();
+
+await endpoint(cfg.name, { banner: false, probes: { enabled: false } })
+  .use(mcp)
+  .mount(app)
+  .run();
+
+// ─── JSON-RPC 2.0 stdio framing ─────────────────────────────────────
+
+const SERVER_NAME = cfg.name;
+const SERVER_VERSION = "0.0.0";
+
+type JsonRpcResponse = {
+  jsonrpc: "2.0";
+  id: string | number | null;
+  result?: unknown;
+  error?: { code: number; message: string };
+};
+
+const send = (msg: JsonRpcResponse): void => {
+  process.stdout.write(JSON.stringify(msg) + "\n");
+};
+
+const log = (text: string): void => {
+  process.stderr.write(`[${SERVER_NAME}] ${text}\n`);
+};
+
+log("MCP server ready");
+
+let buffer = "";
+
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk: string) => {
+  buffer += chunk;
+  const lines = buffer.split(/\r?\n/);
+  buffer = lines.pop() ?? "";
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    void handleLine(line);
+  }
+});
+
+process.stdin.on("end", () => {
+  log("stdin closed — exiting");
+  process.exit(0);
+});
+
+async function handleLine(line: string): Promise<void> {
+  let req: { jsonrpc: string; id?: unknown; method: string; params?: Record<string, unknown> };
+  try {
+    req = JSON.parse(line) as typeof req;
+  } catch {
+    send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+    return;
+  }
+
+  // Notifications (no id, or notifications/* methods) must not be answered.
+  const isNotification = req.id === undefined || String(req.method).startsWith("notifications/");
+  if (isNotification) return;
+
+  const id = (req.id as string | number | null) ?? null;
+
+  try {
+    switch (req.method) {
+      case "initialize":
+        send({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+            capabilities: { tools: { listChanged: false } },
+          },
+        });
+        break;
+
+      case "tools/list": {
+        const listed = mcp.list().map((t) => ({
+          name: t.name,
+          description: t.description ?? "",
+          inputSchema: t.inputSchema
+            ? zodToJsonSchema(t.inputSchema)
+            : { type: "object", properties: {}, additionalProperties: false },
+        }));
+        send({ jsonrpc: "2.0", id, result: { tools: listed } });
+        break;
+      }
+
+      case "tools/call": {
+        const name = req.params?.name as string | undefined;
+        const args = (req.params?.arguments ?? {}) as Record<string, unknown>;
+        if (!name) {
+          send({
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "tools/call requires `name`" },
+          });
+          break;
+        }
+        try {
+          const result = await mcp.call(name, args);
+          send({
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{ type: "text", text: JSON.stringify(result) }],
+              isError: false,
+            },
+          });
+        } catch (err) {
+          send({
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{ type: "text", text: (err as Error).message }],
+              isError: true,
+            },
+          });
+        }
+        break;
+      }
+
+      default:
+        send({
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32601, message: `unknown method "${req.method}"` },
+        });
+    }
+  } catch (err) {
+    send({ jsonrpc: "2.0", id, error: { code: -32603, message: (err as Error).message } });
+  }
+}
+
+/**
+ * Minimal Zod v4 → JSON Schema converter for the tools/list response.
+ * Handles the shapes the MCP tools in this template actually use —
+ * object with string/number properties. Extend as you add new types.
+ *
+ * Zod v4 uses `_def.type` (not `_def.typeName`) and `_def.shape` is a
+ * plain object (not a getter function).
+ */
+function zodToJsonSchema(schema: { _def?: unknown }): unknown {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const def = (schema as any)._def;
+  if (!def) return { type: "object", additionalProperties: true };
+
+  if (def.type === "object") {
+    const props: Record<string, unknown> = {};
+    const required: string[] = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    for (const [k, v] of Object.entries(def.shape as Record<string, any>)) {
+      props[k] = zodToJsonSchema(v);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if ((v as any)._def?.type !== "optional") required.push(k);
+    }
+    return { type: "object", properties: props, required, additionalProperties: false };
+  }
+  if (def.type === "string") return { type: "string" };
+  if (def.type === "number") return { type: "number" };
+  if (def.type === "boolean") return { type: "boolean" };
+  if (def.type === "optional") return zodToJsonSchema(def.innerType);
+  return { type: "object", additionalProperties: true };
+}

package/templates/mcp/app/store/facts-store.ts

@@ -0,0 +1,17 @@
+/**
+ * In-memory knowledge base — a simple mutable array that all tool handlers
+ * share within the process. Replace this with `@nwire/drizzle` or
+ * `@nwire/mongo` when you need persistence across restarts.
+ */
+
+export interface Fact {
+  id: number;
+  topic: string;
+  body: string;
+}
+
+/** Seed data — something concrete so `list-facts` returns content on first run. */
+export const facts: Fact[] = [
+  { id: 1, topic: "nwire", body: "One handler, every transport." },
+  { id: 2, topic: "mcp", body: "Model Context Protocol — AI clients call tools over JSON-RPC." },
+];

package/templates/mcp/app/tools/add-fact.ts

@@ -0,0 +1,27 @@
+/**
+ * add-fact — store a new fact in the knowledge base.
+ *
+ * The AI client supplies a topic and body; the tool persists it so future
+ * `lookup-fact` calls can surface it. Duplicate topics are allowed —
+ * the knowledge base treats each entry as an independent note.
+ */
+
+import { z } from "zod";
+import { tool } from "@nwire/wires/mcp";
+import { facts } from "../store/facts-store";
+
+const AddFactInput = z.object({
+  topic: z.string().min(1).max(100).describe("Short label for this fact"),
+  body: z.string().min(1).max(1000).describe("The fact content"),
+});
+
+export const addFactTool = tool("add-fact", {
+  description: "Add a new fact to the knowledge base. Returns the stored entry.",
+  input: AddFactInput,
+});
+
+export const addFactHandler = async (input: z.infer<typeof AddFactInput>) => {
+  const entry = { id: facts.length + 1, topic: input.topic, body: input.body };
+  facts.push(entry);
+  return { stored: entry, total: facts.length };
+};

package/templates/mcp/app/tools/list-facts.ts

@@ -0,0 +1,17 @@
+/**
+ * list-facts — enumerate every fact in the knowledge base.
+ *
+ * Useful when the AI client wants a full picture of what is stored before
+ * deciding which facts to update or which lookup term to use.
+ */
+
+import { tool } from "@nwire/wires/mcp";
+import { facts } from "../store/facts-store";
+
+export const listFactsTool = tool("list-facts", {
+  description: "Return all facts currently stored in the knowledge base.",
+});
+
+export const listFactsHandler = async () => {
+  return { count: facts.length, facts };
+};

package/templates/mcp/app/tools/lookup-fact.ts

@@ -0,0 +1,28 @@
+/**
+ * lookup-fact — find a fact by keyword from the in-memory knowledge base.
+ *
+ * The AI client submits a search term; the tool scans all stored facts
+ * for matches and returns the hits. Zero results is a valid (empty) answer,
+ * not an error.
+ */
+
+import { z } from "zod";
+import { tool } from "@nwire/wires/mcp";
+import { facts } from "../store/facts-store";
+
+const LookupInput = z.object({
+  query: z.string().min(1).describe("Keyword or phrase to search for"),
+});
+
+export const lookupFactTool = tool("lookup-fact", {
+  description: "Search the knowledge base by keyword and return matching facts.",
+  input: LookupInput,
+});
+
+export const lookupFactHandler = async (input: z.infer<typeof LookupInput>) => {
+  const term = input.query.toLowerCase();
+  const matches = facts.filter(
+    (f) => f.topic.toLowerCase().includes(term) || f.body.toLowerCase().includes(term),
+  );
+  return { query: input.query, count: matches.length, results: matches };
+};

package/templates/mcp/app/tools.ts

@@ -0,0 +1,19 @@
+/**
+ * Tools — the MCP surface this app exposes.
+ *
+ * Each tool file under `./tools/` exports a `{name}Tool` (binding) +
+ * `{name}Handler` (function). `tools` is the flat array fed into
+ * `app.wire(...)` in `app.ts`.
+ *
+ * Adding a tool = one new file + one entry in this array.
+ */
+
+import { lookupFactTool, lookupFactHandler } from "./tools/lookup-fact";
+import { addFactTool, addFactHandler } from "./tools/add-fact";
+import { listFactsTool, listFactsHandler } from "./tools/list-facts";
+
+export const tools = [
+  { binding: lookupFactTool, handler: lookupFactHandler },
+  { binding: addFactTool, handler: addFactHandler },
+  { binding: listFactsTool, handler: listFactsHandler },
+] as const;

package/templates/mcp/config/app.ts

@@ -0,0 +1,16 @@
+/**
+ * App-level settings — the process identity and lifecycle budgets the
+ * endpoint owns. A function of the typed `env`, so the same config file
+ * reads differently per environment without an `if` in sight.
+ */
+
+import { env, type Env } from "./env";
+
+export const appConfig = (e: Env = env) => ({
+  /** Endpoint + app name — shows in logs and telemetry. */
+  name: "{{PROJECT_NAME}}",
+  /** Print the boot banner outside of tests. */
+  banner: e.NODE_ENV !== "test",
+});
+
+export type AppConfig = ReturnType<typeof appConfig>;

package/templates/mcp/config/env.ts

@@ -0,0 +1,27 @@
+/**
+ * Typed environment — read `process.env` once, through a schema, and never
+ * touch it again from app code. Missing or malformed values fail loudly at
+ * boot with a readable message, not three layers deep at first request.
+ */
+
+import { z } from "zod";
+
+const EnvSchema = z.object({
+  NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
+});
+
+export type Env = z.output<typeof EnvSchema>;
+
+export function loadEnv(source: NodeJS.ProcessEnv = process.env): Env {
+  const parsed = EnvSchema.safeParse(source);
+  if (!parsed.success) {
+    const summary = parsed.error.issues
+      .map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`)
+      .join("\n");
+    throw new Error(`Invalid environment:\n${summary}`);
+  }
+  return parsed.data;
+}
+
+/** The validated environment, loaded once. */
+export const env: Env = loadEnv();

package/templates/mcp/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.6","results":[[":__tests__/mcp-server.test.ts",{"duration":316.55000000000007,"failed":false}]]}

package/templates/mcp/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "node --import tsx/esm app/main.ts",
+    "dev": "node --import tsx/esm --watch app/main.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@nwire/app": "^0.13.1",
+    "@nwire/endpoint": "^0.13.1",
+    "@nwire/mcp": "^0.13.1",
+    "@nwire/wires": "^0.13.1",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.9",
+    "tsx": "^4.19.4",
+    "typescript": "^5.9.0",
+    "vitest": "^4.0.18"
+  }
+}

package/templates/mcp/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["app/**/*", "config/**/*", "__tests__/**/*"]
+}

package/templates/mcp/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["__tests__/**/*.{test,spec}.ts"],
+  },
+});

package/templates/minimal/AGENTS.md

@@ -9,22 +9,29 @@ handler never knows which transport called it.
 ```ts
 import { createApp } from "@nwire/app";
 import { endpoint } from "@nwire/endpoint";
-import { get } from "@nwire/wires/http";
+import { post } from "@nwire/wires/http";
 import { httpKoa } from "@nwire/koa";
+import { z } from "zod";
 
 const app = createApp({ appName: "app" });
-app.wire(get("/hello"), async () => ({ message: "hello" }));
-await endpoint("app", { port: 3000 }).use(httpKoa()).mount(app).run();
+// The route declares its schema; the handler receives the validated input.
+app.wire(post("/hello", { body: z.object({ name: z.string().min(1) }) }), async (input) => ({
+  message: `Hello, ${input.name}!`,
+}));
+await endpoint("app", { port: Number(process.env.PORT) || 3000 })
+  .use(httpKoa())
+  .mount(app)
+  .run();
 ```
 
 ## What's installed (don't import beyond these)
 
-| Primitive | Package |
-|---|---|
-| `createApp`, `definePlugin` | `@nwire/app` |
-| `endpoint` | `@nwire/endpoint` |
+| Primitive                        | Package             |
+| -------------------------------- | ------------------- |
+| `createApp`, `definePlugin`      | `@nwire/app`        |
+| `endpoint`                       | `@nwire/endpoint`   |
 | `get` `post` `put` `patch` `del` | `@nwire/wires/http` |
-| `httpKoa` | `@nwire/koa` |
+| `httpKoa`                        | `@nwire/koa`        |
 
 This tier is HTTP-only. Add capabilities by installing the package first:
 `@nwire/handler` for `defineResource`/`defineError`, `@nwire/messages` for
@@ -33,5 +40,5 @@ This tier is HTTP-only. Add capabilities by installing the package first:
 
 ## Commands
 
-- `pnpm dev` — run the app (HTTP on :3000). `pnpm test` — tests.
+- `pnpm dev` — wire + Studio on http://localhost:4000. `pnpm test` — tests.
 - `pnpm doctor` — health-check the setup. `pnpm studio` — trace console.

package/templates/minimal/README.md

@@ -16,8 +16,10 @@ pnpm dev
 
 ## Try
 
+`pnpm dev` serves the wire + Studio on http://localhost:4000.
+
 ```bash
-curl -X POST http://localhost:3000/hello \
+curl -X POST http://localhost:4000/hello \
   -H "content-type: application/json" \
   -d '{"name":"Alice"}'
 ```
@@ -33,8 +35,9 @@ pnpm test
 ```
 {{PROJECT_NAME}}/
 ├── app/
-│   ├── main.ts            ← endpoint().serve(api).run()
-│   ├── api.ts             ← httpInterface().wire(route, handler)
+│   ├── main.ts            ← endpoint().use(httpKoa()).mount(app).run()
+│   ├── app.ts             ← createApp().wire(...) — the app value
+│   ├── api.ts             ← wires[] (route + handler pairs)
 │   └── routes/
 │       └── hello.ts       ← POST /hello — route + handler pair
 └── __tests__/
@@ -51,13 +54,20 @@ pnpm test
 
 ## What you get free
 
-| Feature                                | Comes from        |
-| -------------------------------------- | ----------------- |
-| Zod request validation                 | `@nwire/http`     |
-| OpenAPI schema (visit `/openapi.json`) | `@nwire/http`     |
-| Scalar UI docs (visit `/docs`)         | `@nwire/http`     |
-| Graceful SIGTERM drain                 | `@nwire/endpoint` |
-| K8s probes on port 9400                | `@nwire/endpoint` |
+| Feature                              | Comes from        |
+| ------------------------------------ | ----------------- |
+| Zod request validation               | `@nwire/koa`      |
+| Graceful SIGTERM drain               | `@nwire/endpoint` |
+| K8s probes (port 9400/`$PROBE_PORT`) | `@nwire/endpoint` |
+
+OpenAPI + Scalar docs are one opt-in away — pass them to the transport:
+
+```ts
+endpoint("{{PROJECT_NAME}}")
+  .use(httpKoa({ openapi: { auto: true }, docs: true })) // /openapi.json + /docs
+  .mount(app)
+  .run();
+```
 
 ## Grow up
 

package/templates/minimal/__tests__/hello.test.ts

@@ -3,19 +3,19 @@
  * empty `name` is rejected with a structured validation error.
  *
  * Boots the app through endpoint + httpKoa on an ephemeral port.
+ * Imports `{ app }` from `../app/app` (the pure value). Never imports
+ * `main.ts` — that file boots a real server and hangs the test runner.
  */
 
 import { describe, it, expect, beforeAll, afterAll } from "vitest";
 import { endpoint } from "@nwire/endpoint";
 import { httpKoa } from "@nwire/koa";
-import { buildApp } from "../app/main";
+import { app } from "../app/app";
 
 let running: Awaited<ReturnType<ReturnType<typeof endpoint>["run"]>>;
-let app: ReturnType<typeof buildApp>;
 let url: string;
 
 beforeAll(async () => {
-  app = buildApp();
   const koa = httpKoa({ port: 0 });
   running = await endpoint("hello-test", {
     exitOnShutdown: false,

package/templates/minimal/app/app.ts

@@ -0,0 +1,21 @@
+/**
+ * App — the composition root.
+ *
+ * `createApp` constructs the container and wires all routes in this module
+ * body. The exported `app` is COMPLETE on import — no caller needs to wire
+ * or start it. No ports are bound here; that is `main.ts`'s job.
+ *
+ * Tests import `{ app }` from this file and build an isolated endpoint.
+ * Never import `main.ts` from tests: it boots a server and hangs the runner.
+ */
+
+import { createApp } from "@nwire/app";
+import { wires } from "./api";
+
+const _app = createApp({ appName: "{{PROJECT_NAME}}" });
+
+for (const { binding, handler } of wires) {
+  _app.wire(binding, handler);
+}
+
+export const app = _app;

package/templates/minimal/app/main.ts

@@ -1,33 +1,24 @@
 /**
- * Entry — boot the app under HTTP.
+ * Entry — the only file that boots a real HTTP server.
  *
- *   createApp(...)        — the bounded context (container + wires)
- *   app.wire(...)         — pair a binding with its handler
- *   endpoint().use(...)   — install a transport adapter (HTTP, queue, MCP, …)
- *   .mount(app).run()     — boot the app under the adapters; ready for traffic
+ *   pnpm dev   # wire + Studio on http://localhost:4000
  *
- * The minimal shape: no DI, no forge, no domain primitives. Two packages
- * and three files. Graduate to `service` when you need a container, store,
- * or structured errors.
+ *   curl -X POST http://localhost:4000/hello \
+ *        -H "content-type: application/json" \
+ *        -d '{"name":"Alice"}'
  *
- * Run:    pnpm dev
- * Try:    curl -X POST http://localhost:3000/hello \
- *               -H "content-type: application/json" \
- *               -d '{"name":"Alice"}'
+ * `app` is a pure value (no side effects on import — see `./app`). This
+ * file adds the one side effect: binding a port and serving traffic.
+ * Tests import `{ app }` from `./app` and build their own ephemeral
+ * endpoint — never import this file from tests or it boots a server and
+ * hangs the runner.
  */
 
-import { createApp } from "@nwire/app";
 import { endpoint } from "@nwire/endpoint";
 import { httpKoa } from "@nwire/koa";
-import { wires } from "./api";
+import { app } from "./app";
 
-export function buildApp() {
-  const app = createApp({ appName: "{{PROJECT_NAME}}" });
-  for (const { binding, handler } of wires) {
-    app.wire(binding, handler);
-  }
-  return app;
-}
-
-const app = buildApp();
-await endpoint("{{PROJECT_NAME}}", { port: 3000 }).use(httpKoa()).mount(app).run();
+await endpoint("{{PROJECT_NAME}}", { port: Number(process.env.PORT) || 3000 })
+  .use(httpKoa())
+  .mount(app)
+  .run();

package/templates/minimal/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.6","results":[[":__tests__/hello.test.ts",{"duration":38.90391699999998,"failed":false}]]}

package/templates/minimal/package.json

@@ -4,24 +4,23 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "vite-node app/main.ts",
+    "dev": "nwire dev",
     "test": "vitest run",
     "doctor": "nwire doctor",
     "studio": "nwire studio",
     "cache": "nwire cache"
   },
   "dependencies": {
-    "@nwire/app": "^0.12.1",
-    "@nwire/endpoint": "^0.12.1",
-    "@nwire/koa": "^0.12.1",
-    "@nwire/wires": "^0.12.1",
+    "@nwire/app": "^0.13.1",
+    "@nwire/endpoint": "^0.13.1",
+    "@nwire/koa": "^0.13.1",
+    "@nwire/wires": "^0.13.1",
     "zod": "^4.0.0"
   },
   "devDependencies": {
+    "@nwire/cli": "^0.13.1",
     "@types/node": "^22.19.9",
     "typescript": "^5.9.0",
-    "vite-node": "^3.2.4",
-    "vitest": "^4.0.18",
-    "@nwire/cli": "^0.12.1"
+    "vitest": "^4.0.18"
   }
 }