create-nwire 0.12.0 → 0.13.0

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.0",
+    "@nwire/endpoint": "^0.13.0",
+    "@nwire/mcp": "^0.13.0",
+    "@nwire/wires": "^0.13.0",
+    "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

@@ -0,0 +1,37 @@
+# AGENTS.md — working in this nwire app
+
+This is a **minimal nwire** backend. You write logic once as a **handler**
+(a plain typed function) and wire it to a **transport** (here, HTTP). The
+handler never knows which transport called it.
+
+## The shape (`app/main.ts`)
+
+```ts
+import { createApp } from "@nwire/app";
+import { endpoint } from "@nwire/endpoint";
+import { get } from "@nwire/wires/http";
+import { httpKoa } from "@nwire/koa";
+
+const app = createApp({ appName: "app" });
+app.wire(get("/hello"), async () => ({ message: "hello" }));
+await endpoint("app", { port: 3000 }).use(httpKoa()).mount(app).run();
+```
+
+## What's installed (don't import beyond these)
+
+| Primitive                        | Package             |
+| -------------------------------- | ------------------- |
+| `createApp`, `definePlugin`      | `@nwire/app`        |
+| `endpoint`                       | `@nwire/endpoint`   |
+| `get` `post` `put` `patch` `del` | `@nwire/wires/http` |
+| `httpKoa`                        | `@nwire/koa`        |
+
+This tier is HTTP-only. Add capabilities by installing the package first:
+`@nwire/handler` for `defineResource`/`defineError`, `@nwire/messages` for
+`defineEvent`, `@nwire/forge` for actions/actors/projections/workflows.
+**Don't import a primitive from a package that isn't in `package.json`.**
+
+## Commands
+
+- `pnpm dev` — run the app (HTTP on :3000). `pnpm test` — tests.
+- `pnpm doctor` — health-check the setup. `pnpm studio` — trace console.

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/_npmrc

@@ -0,0 +1,4 @@
+# nwire dev runs via vite-node (esbuild). pnpm 11 defers esbuild's build
+# script and then fails the pre-run deps check; skip that check so
+# `pnpm dev` runs clean right after install.
+verify-deps-before-run=false

package/templates/minimal/_pnpm-workspace.yaml

@@ -0,0 +1,6 @@
+# pnpm 11 reads build-allow + run settings here (not the package.json
+# "pnpm" field). esbuild backs vite-node; allow its build, and skip the
+# pre-run deps check so `pnpm dev` runs clean right after install.
+onlyBuiltDependencies:
+  - esbuild
+verifyDepsBeforeRun: 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,35 +1,21 @@
 /**
- * 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
  *
- * 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:3000/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;
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const app = buildApp();
-  await endpoint("{{PROJECT_NAME}}", { port: 3000 }).use(httpKoa()).mount(app).run();
-}
+await endpoint("{{PROJECT_NAME}}", { 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,20 +4,23 @@
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "vite-node app/main.ts",
-    "test": "vitest run"
+    "dev": "nwire dev",
+    "test": "vitest run",
+    "doctor": "nwire doctor",
+    "studio": "nwire studio",
+    "cache": "nwire cache"
   },
   "dependencies": {
-    "@nwire/app": "^0.12.0",
-    "@nwire/endpoint": "^0.12.0",
-    "@nwire/koa": "^0.12.0",
-    "@nwire/wires": "^0.12.0",
+    "@nwire/app": "^0.13.0",
+    "@nwire/endpoint": "^0.13.0",
+    "@nwire/koa": "^0.13.0",
+    "@nwire/wires": "^0.13.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {
+    "@nwire/cli": "^0.13.0",
     "@types/node": "^22.19.9",
     "typescript": "^5.9.0",
-    "vite-node": "^3.2.4",
     "vitest": "^4.0.18"
   }
 }

package/templates/service/AGENTS.md

@@ -0,0 +1,64 @@
+# AGENTS.md — working in this nwire app
+
+This is an **nwire** backend. The one idea: you write logic once as a
+**handler** (a plain typed function) and wire it to a **transport** (an
+HTTP route, a queue, cron, an MCP tool). The handler never knows which
+transport called it.
+
+## The shape
+
+```ts
+import { createApp } from "@nwire/app";
+import { endpoint } from "@nwire/endpoint";
+import { post } from "@nwire/wires/http";
+import { httpKoa } from "@nwire/koa";
+
+const app = createApp({ appName: "svc" });
+app.wire(post("/things", { body: z.object({ name: z.string() }) }), async (input) => ({
+  ok: input.name,
+}));
+await endpoint("svc", { port: 3000 }).use(httpKoa()).mount(app).run();
+```
+
+`app/main.ts` builds and runs the app. Routes live in `app/routes/`,
+their request shapes in `app/resources/`, errors in `app/errors/`.
+
+## Import map — DO NOT GUESS THESE
+
+The single most common mistake is importing a primitive from the wrong
+package. Use exactly:
+
+| Primitive                                                                                                       | Package             |
+| --------------------------------------------------------------------------------------------------------------- | ------------------- |
+| `createApp`, `appCompose`, `definePlugin`                                                                       | `@nwire/app`        |
+| `endpoint`                                                                                                      | `@nwire/endpoint`   |
+| `get` `post` `put` `patch` `del`                                                                                | `@nwire/wires/http` |
+| `httpKoa`                                                                                                       | `@nwire/koa`        |
+| `defineHandler`, `defineResource`, `defineError`, `Unauthorized`/`Forbidden`/`NotFound`/`Conflict`/`BadRequest` | `@nwire/handler`    |
+| `defineEvent`                                                                                                   | `@nwire/messages`   |
+| `defineAction`, `defineActor`, `defineProjection`, `defineQuery`, `defineWorkflow`, `forgePlugins`              | `@nwire/forge`      |
+
+`defineResource` and `defineError` are in **`@nwire/handler`**, not
+`@nwire/forge`. This service template does not depend on `@nwire/forge` —
+don't import from it unless you add it to `package.json` first.
+
+## Adding a route
+
+1. A binding + handler: `app/routes/<verb>-<noun>.ts` exports a route
+   (`post("/path", { body })`) and a handler `(input, ctx) => result`.
+2. Register it in `app/api.ts`'s wire list (or `app.wire(route, handler)`).
+3. Throw a typed `defineError` for failures; return a plain object or a
+   `defineResource` projection for success.
+
+## Verbs
+
+`.wire(binding, handler)` binds a transport. `.use(adapter)` mounts a
+transport on the endpoint. To react to events, use `when(Event, fn)` in a
+listener file (not `on` — `on` is for lifecycle hooks).
+
+## Commands
+
+- `pnpm dev` — run the app (HTTP on :3000).
+- `pnpm test` — run the test suite.
+- `pnpm doctor` — health-check the project setup.
+- `pnpm studio` — open the live trace/inspect console.