@nzila/sdk 0.1.0 → 0.1.3

package/README.md

@@ -11,6 +11,21 @@ npm install @nzila/sdk
 # Vitest projects also need vitest as a peer
 ```
 
+## CLI (onboarding)
+
+`npx @nzila/sdk` opens the [Nzila dashboard](https://nzila-kappa.vercel.app) and prints setup commands. No separate CLI package.
+
+```bash
+npx @nzila/sdk              # open app + help
+npx @nzila/sdk login
+npx @nzila/sdk link --api-key <key> --project-id <uuid>
+npx @nzila/sdk doctor
+```
+
+Also available as `npx nzila` after install. Override platform with `NZILA_APP_URL` or `--endpoint`.
+
+After you sign in on [nzila-kappa.vercel.app](https://nzila-kappa.vercel.app), the dashboard runs a **first-visit tour** per section (localized). Use **Guide** in the header to replay.
+
 ## Exports
 
 | Path | Purpose |
@@ -67,4 +82,15 @@ const nzila = traceNzilaFeature("Checkout");
 await nzila.runApi("charge", () => charge());
 ```
 
-See JSDoc on each export in `src/` and the monorepo guide [examples/COMPLEX-USAGE.md](../../examples/COMPLEX-USAGE.md).
+## Examples (included in this package)
+
+After install, open **`node_modules/@nzila/sdk/examples/`**:
+
+- **[INDEX.md](./examples/INDEX.md)** — map of all samples
+- **[COMPLEX-USAGE.md](./examples/COMPLEX-USAGE.md)** — every feature (Vitest, runtime, `mapFeature`, webhooks)
+- **[RUNTIME-TRACE.md](./examples/RUNTIME-TRACE.md)** — React + backend live tracing
+- **[TRACING-FAILURES.md](./examples/TRACING-FAILURES.md)** — tests → dashboard
+- Config: `vitest.config.example.ts`, `jest.config.example.cjs`, `mocharc.nzila.example.cjs`
+- Code: `backend/`, `frontend/`, `complex/`, `react/checkout-feature.example.tsx`
+
+All example imports use `@nzila/sdk` (same as your app).

package/dist/cli/constants.d.ts

@@ -0,0 +1,13 @@
+/** Hosted Nzila dashboard — override with NZILA_APP_URL or --endpoint */
+export declare const NZILA_PLATFORM_URL = "https://nzila-kappa.vercel.app";
+export declare function resolvePlatformUrl(): string;
+export declare function platformPaths(base: string): {
+    home: string;
+    login: string;
+    register: string;
+    docs: string;
+    keys: string;
+    webhook: string;
+    signals: string;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/cli/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/cli/constants.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,eAAO,MAAM,kBAAkB,mCAAmC,CAAC;AAEnE,wBAAgB,kBAAkB,IAAI,MAAM,CAM3C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM;;;;;;;;EAWzC"}

package/dist/cli/constants.js

@@ -0,0 +1,20 @@
+/** Hosted Nzila dashboard — override with NZILA_APP_URL or --endpoint */
+export const NZILA_PLATFORM_URL = "https://nzila-kappa.vercel.app";
+export function resolvePlatformUrl() {
+    const raw = process.env.NZILA_APP_URL?.trim() ||
+        process.env.NZILA_ENDPOINT?.trim() ||
+        NZILA_PLATFORM_URL;
+    return raw.replace(/\/$/, "");
+}
+export function platformPaths(base) {
+    const root = base.replace(/\/$/, "");
+    return {
+        home: `${root}/en`,
+        login: `${root}/en/login`,
+        register: `${root}/en/register`,
+        docs: `${root}/en/docs`,
+        keys: `${root}/en/keys`,
+        webhook: `${root}/api/webhooks/tests`,
+        signals: `${root}/api/signals/runtime`,
+    };
+}

package/dist/cli/main.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/cli/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":""}

package/dist/cli/main.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { platformPaths, resolvePlatformUrl } from "./constants.js";
+import { openBrowser } from "./open-browser.js";
+const PKG = "@nzila/sdk";
+const CONFIG_FILE = "nzila.config.ts";
+function defaultEndpoint() {
+    return resolvePlatformUrl();
+}
+async function loadConfig(cwd) {
+    const file = path.join(cwd, CONFIG_FILE);
+    if (!existsSync(file))
+        return null;
+    const source = await readFile(file, "utf8");
+    const match = source.match(/apiKey:\s*["']([^"']+)["']/);
+    const projectMatch = source.match(/projectId:\s*["']([^"']+)["']/);
+    const endpointMatch = source.match(/endpoint:\s*["']([^"']+)["']/);
+    const frameworkMatch = source.match(/framework:\s*["']([^"']+)["']/);
+    if (!match?.[1] || !projectMatch?.[1])
+        return null;
+    return {
+        apiKey: match[1],
+        projectId: projectMatch[1],
+        endpoint: endpointMatch?.[1] ?? defaultEndpoint(),
+        framework: frameworkMatch?.[1] ?? "vitest",
+    };
+}
+async function writeConfig(cwd, config) {
+    const body = `/** Generated by ${PKG} — do not commit secrets to public repos */
+export default {
+  apiKey: "${config.apiKey}",
+  projectId: "${config.projectId}",
+  endpoint: "${config.endpoint.replace(/"/g, '\\"')}",
+  framework: "${config.framework}",
+} as const;
+`;
+    await writeFile(path.join(cwd, CONFIG_FILE), body, "utf8");
+}
+function detectFramework(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (deps["@playwright/test"] || deps.playwright)
+                return "playwright";
+            if (deps.jest)
+                return "jest";
+            if (deps.vitest)
+                return "vitest";
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    if (existsSync(path.join(cwd, "vitest.config.ts")) || existsSync(path.join(cwd, "vitest.config.mts"))) {
+        return "vitest";
+    }
+    if (existsSync(path.join(cwd, "jest.config.js")) || existsSync(path.join(cwd, "jest.config.ts"))) {
+        return "jest";
+    }
+    if (existsSync(path.join(cwd, "playwright.config.ts")))
+        return "playwright";
+    return "vitest";
+}
+function printEnvSnippet(endpoint) {
+    const paths = platformPaths(endpoint);
+    console.log("");
+    console.log("Add to your project .env.local:");
+    console.log(`NZILA_WEBHOOK_URL=${paths.webhook}`);
+    console.log(`NZILA_SIGNALS_URL=${paths.signals}`);
+    console.log("NZILA_API_KEY=<from dashboard → API Keys>");
+    console.log("");
+    console.log(`SDK already installed via ${PKG}; add Vitest reporter from docs.`);
+    console.log(`Docs: ${paths.docs}`);
+}
+async function tryOpen(url, quiet = false) {
+    try {
+        await openBrowser(url);
+        if (!quiet)
+            console.log(`Opened ${url}`);
+    }
+    catch {
+        if (!quiet)
+            console.log(`Open in your browser: ${url}`);
+    }
+}
+async function cmdOpen(flags) {
+    const base = String(flags.endpoint ?? defaultEndpoint()).replace(/\/$/, "");
+    const paths = platformPaths(base);
+    const target = flags.register ? paths.register : flags.login ? paths.login : paths.home;
+    await tryOpen(target);
+}
+async function cmdInit(flags) {
+    const cwd = process.cwd();
+    const framework = detectFramework(cwd);
+    const base = defaultEndpoint();
+    const paths = platformPaths(base);
+    console.log(`Nzila — platform: ${base}`);
+    console.log(`Detected test framework: ${framework}`);
+    console.log("");
+    console.log("Quick start:");
+    console.log(`  1. npx ${PKG} login     → sign in (opens browser)`);
+    console.log("  2. Create a project + API key in the dashboard");
+    console.log(`  3. npx ${PKG} link --api-key nzl_… --project-id <uuid>`);
+    console.log("  4. Wire @nzila/sdk/vitest and run tests");
+    printEnvSnippet(base);
+    if (flags.open !== false) {
+        await tryOpen(paths.register, true);
+    }
+}
+async function cmdLogin(flags) {
+    const base = String(flags.endpoint ?? defaultEndpoint()).replace(/\/$/, "");
+    const loginUrl = `${platformPaths(base).login}?cli=1`;
+    console.log(`Nzila platform: ${base}`);
+    console.log("Sign in, then create an API key:");
+    console.log(`  ${platformPaths(base).keys}`);
+    console.log("");
+    console.log("Then link this repo:");
+    console.log(`  npx ${PKG} link --api-key <key> --project-id <uuid>`);
+    await tryOpen(loginUrl);
+}
+async function cmdLink(flags) {
+    const apiKey = String(flags["api-key"] ?? flags.apiKey ?? "");
+    const projectId = String(flags["project-id"] ?? flags.projectId ?? "");
+    const endpoint = String(flags.endpoint ?? defaultEndpoint()).replace(/\/$/, "");
+    if (!apiKey || !projectId) {
+        console.error(`Usage: npx ${PKG} link --api-key <token> --project-id <uuid> [--endpoint <url>]`);
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const framework = detectFramework(cwd);
+    await writeConfig(cwd, { apiKey, projectId, endpoint, framework });
+    console.log(`Wrote ${CONFIG_FILE} (endpoint: ${endpoint})`);
+    printEnvSnippet(endpoint);
+}
+async function cmdDoctor() {
+    const cwd = process.cwd();
+    const config = await loadConfig(cwd);
+    if (!config) {
+        console.log(`No nzila.config.ts — run \`npx ${PKG} link\` first.`);
+        process.exit(1);
+    }
+    const paths = platformPaths(config.endpoint);
+    console.log("Config OK:", {
+        projectId: config.projectId,
+        endpoint: config.endpoint,
+        framework: config.framework,
+    });
+    console.log("Webhook URL:", paths.webhook);
+}
+function printHelp(base) {
+    const paths = platformPaths(base);
+    console.log(`Nzila (${PKG}) — ${base}
+
+Commands:
+  open       Open the dashboard in your browser (default)
+  init       Detect framework + show setup steps
+  login      Open sign-in and linking instructions
+  link       Write nzila.config.ts (--api-key, --project-id)
+  doctor     Validate nzila.config.ts
+
+Examples:
+  npx ${PKG}
+  npx ${PKG} login
+  npx ${PKG} link --api-key nzl_… --project-id <uuid>
+
+Docs: ${paths.docs}
+`);
+}
+function parseArgs(argv) {
+    const [command, ...rest] = argv;
+    const flags = {};
+    for (let i = 0; i < rest.length; i++) {
+        const token = rest[i];
+        if (token.startsWith("--")) {
+            const key = token.slice(2);
+            const next = rest[i + 1];
+            if (next && !next.startsWith("--")) {
+                flags[key] = next;
+                i++;
+            }
+            else {
+                flags[key] = true;
+            }
+        }
+    }
+    return { command: command ?? "", flags };
+}
+async function main() {
+    const { command, flags } = parseArgs(process.argv.slice(2));
+    const base = defaultEndpoint();
+    if (!command || command === "open" || command === "start") {
+        if (!command)
+            await tryOpen(platformPaths(base).home);
+        else
+            await cmdOpen(flags);
+        if (!command)
+            printHelp(base);
+        return;
+    }
+    if (command === "init")
+        return cmdInit(flags);
+    if (command === "login")
+        return cmdLogin(flags);
+    if (command === "link")
+        return cmdLink(flags);
+    if (command === "doctor")
+        return cmdDoctor();
+    if (command === "help" || command === "-h" || command === "--help") {
+        printHelp(base);
+        return;
+    }
+    console.error(`Unknown command: ${command}`);
+    printHelp(base);
+    process.exit(1);
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/cli/open-browser.d.ts

@@ -0,0 +1,2 @@
+export declare function openBrowser(url: string): Promise<void>;
+//# sourceMappingURL=open-browser.d.ts.map

package/dist/cli/open-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-browser.d.ts","sourceRoot":"","sources":["../../src/cli/open-browser.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBtD"}

package/dist/cli/open-browser.js

@@ -0,0 +1,26 @@
+import { execFile } from "node:child_process";
+export function openBrowser(url) {
+    return new Promise((resolve, reject) => {
+        const platform = process.platform;
+        let command;
+        let args;
+        if (platform === "win32") {
+            command = "cmd";
+            args = ["/c", "start", "", url];
+        }
+        else if (platform === "darwin") {
+            command = "open";
+            args = [url];
+        }
+        else {
+            command = "xdg-open";
+            args = [url];
+        }
+        execFile(command, args, (err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+}

package/examples/COMPLEX-USAGE.md

@@ -0,0 +1,113 @@
+# Complex usage — all Nzila SDK features
+
+This guide ties together **test webhooks**, **runtime signals**, **mapFeature**, and **manual error reporting** in one flow. Use it after the quick starts in [README.md](README.md), [TRACING-FAILURES.md](TRACING-FAILURES.md), and [RUNTIME-TRACE.md](RUNTIME-TRACE.md).
+
+## Feature matrix
+
+| Capability | API | When to use |
+|------------|-----|-------------|
+| CI test run | `NzilaVitestReporter` / `NzilaJestReporter` / Mocha | Every `vitest run` / Jest / Mocha finish |
+| Manual run POST | `sendNzilaRun(payload, { webhookUrl, apiKey })` | Custom runners, replay payloads |
+| Feature naming | `mapFeature(describePath, testName)` | Suite title ≠ dashboard feature |
+| Backend handler | `traceNzilaFeature("Checkout")` | First line of route/service |
+| React screen | `useNzilaFeature("Checkout")` | Top of component matching tests |
+| HTTP wrapper | `nzila.runApi("label", () => fetch…)` | Auto `api` success/failure |
+| Handled errors | `nzila.captureError(err, { … })` | `catch`, validation, business rules |
+| No handle in scope | `reportFeatureError("Checkout", err)` | Deep helper, fire-and-forget |
+| API failure label | `nzila.captureApiError(err, "payment.charge")` | After failed call outside `runApi` |
+| UI issues | `nzila.reportUi("custom_banner", { … })` | Non-throwing UX problems |
+| Render errors | `NzilaFeatureBoundary` + `useNzilaFeature` | Child tree throws |
+| Static demo payload | `shared/send-webhook.mjs` | No Vitest installed |
+
+Use the **same feature strings** everywhere (e.g. `"Checkout"`, `"Inventory"`) so test failures and runtime signals land on one dashboard row.
+
+## 1. Complex Vitest run (multi-feature, pass + fail)
+
+**Files:** `complex/full-platform.demo.test.ts`, `vitest.complex.config.ts`, `shared/feature-map.ts`
+
+- Three describe roots: `Checkout UI`, `Inventory`, `Authentication`
+- `mapFeature` maps UI vs API names via `resolveFrontendFeature` / `resolveBackendFeature`
+- Several tests **fail on purpose** so Nzila shows failure analysis
+
+```bash
+# .env.local: NZILA_API_KEY, NZILA_WEBHOOK_URL
+# Optional: NZILA_COMPLEX_APP_NAME=checkout-api (must exist in dashboard)
+npm run example:test:complex
+```
+
+Open **Runs** → latest run → failures grouped by feature.
+
+## 2. Complex backend runtime (runApi + capture + reportFeatureError)
+
+**File:** `complex/api-services.demo.ts`
+
+Demonstrates:
+
+1. `initNzilaRuntime({ signalsUrl, apiKey })`
+2. `traceNzilaFeature("Checkout")` with `runApi` for inventory + payment
+3. `captureError` for handled business failure (409)
+4. `captureApiError` for pipeline failure
+5. Second feature `Inventory` with `reportFeatureError` in a job
+
+```bash
+npm run example:runtime:complex
+```
+
+Wait ~1s for batched flush, then check **Feature health** / runtime signals for `Checkout` and `Inventory`.
+
+## 3. Tracing-only Vitest (focused failure fingerprints)
+
+```bash
+npm run example:test:tracing:all
+npm run example:webhook:tracing
+npm run example:webhook:tracing:frontend
+```
+
+## 4. React runtime (monorepo)
+
+See [RUNTIME-TRACE.md](RUNTIME-TRACE.md). Pattern:
+
+```tsx
+initNzilaRuntime({ signalsUrl, apiKey });
+
+function CheckoutPage() {
+  const nzila = useNzilaFeature("Checkout");
+  async function pay() {
+    try {
+      await nzila.runApi("checkout.submit", () =>
+        fetch("/api/checkout", { method: "POST" }),
+      );
+    } catch (e) {
+      nzila.captureError(e, { step: "submit" });
+    }
+  }
+  return (
+    <NzilaFeatureBoundary feature="Checkout" nzila={nzila}>
+      {/* children */}
+    </NzilaFeatureBoundary>
+  );
+}
+```
+
+## 5. Jest and Mocha
+
+- Jest: copy `jest.config.example.cjs` → wire `NzilaJestReporter` with same env vars as Vitest.
+- Mocha: `mocharc.nzila.example.cjs` — register reporter, call `sendNzilaRun` on `end` if you roll your own.
+
+## 6. End-to-end local checklist
+
+1. `npm run dev` + `npm run worker`
+2. Create app(s): `checkout-api`, `checkout-web` (or your `NZILA_COMPLEX_APP_NAME`)
+3. API key in `.env.local`
+4. `npm run example:test:complex` → webhook run
+5. `npm run example:runtime:complex` → runtime signals
+6. Dashboard: **Runs**, **Failures**, **Feature health** — same feature names
+
+## Environment reference
+
+| Variable | Used by |
+|----------|---------|
+| `NZILA_API_KEY` | Webhook + runtime |
+| `NZILA_WEBHOOK_URL` | Vitest/Jest reporters, `sendNzilaRun` |
+| `NZILA_SIGNALS_URL` | `initNzilaRuntime` (default `http://localhost:3000/api/signals/runtime`) |
+| `NZILA_COMPLEX_APP_NAME` | Complex Vitest config only |

package/examples/INDEX.md

@@ -0,0 +1,27 @@
+# @nzila/sdk examples
+
+These files ship inside the npm package under `node_modules/@nzila/sdk/examples/`.
+
+| Topic | Files |
+|-------|--------|
+| Overview | [README from monorepo](./README.md) |
+| All features walkthrough | [COMPLEX-USAGE.md](./COMPLEX-USAGE.md) |
+| Live app tracing | [RUNTIME-TRACE.md](./RUNTIME-TRACE.md) |
+| Test → dashboard mapping | [TRACING-FAILURES.md](./TRACING-FAILURES.md) |
+| Vitest | [vitest.config.example.ts](./vitest.config.example.ts), [complex/](./complex/) |
+| Jest | [jest.config.example.cjs](./jest.config.example.cjs) |
+| Mocha | [mocharc.nzila.example.cjs](./mocharc.nzila.example.cjs) |
+| Backend runtime | [backend/runtime-trace.example.ts](./backend/runtime-trace.example.ts), [complex/api-services.demo.ts](./complex/api-services.demo.ts) |
+| React | [react/checkout-feature.example.tsx](./react/checkout-feature.example.tsx) |
+| Manual webhook | [send-run-manual.mjs](./send-run-manual.mjs), [shared/send-webhook.mjs](./shared/send-webhook.mjs) |
+| Sample payloads | [backend/sample-payload.json](./backend/sample-payload.json), [frontend/sample-payload.json](./frontend/sample-payload.json) |
+
+## Environment
+
+```env
+NZILA_API_KEY=nzl_...
+NZILA_WEBHOOK_URL=https://your-host/api/webhooks/tests
+NZILA_SIGNALS_URL=https://your-host/api/signals/runtime
+```
+
+Imports in these files use `@nzila/sdk` — the same as in your application after `npm install @nzila/sdk`.

package/examples/README.md

@@ -0,0 +1,94 @@
+> **npm:** Start with [INDEX.md](./INDEX.md). Imports use `@nzila/sdk`.
+
+# Nzila integration examples
+
+End-to-end samples for **backend (API)** and **frontend (UI)** test flows.
+
+## Prerequisites
+
+1. `npm run dev` and `npm run worker` (with `QUEUE_DRIVER` and DB migrated).
+2. Register, create an API key at `/en/keys`.
+3. In **`.env.local`**:
+
+```env
+NZILA_API_KEY=nzl_...
+NZILA_WEBHOOK_URL=http://localhost:3000/api/webhooks/tests
+HF_API_TOKEN=hf_...          # optional, for AI summaries
+```
+
+The same examples are published inside **`@nzila/sdk`** at `node_modules/@nzila/sdk/examples/` (see `INDEX.md` there).
+
+## Layout
+
+| Path | Purpose |
+|------|---------|
+| `backend/` | API-style unit tests (pricing, inventory, auth) |
+| `frontend/` | UI logic tests (checkout form, product card) |
+| `shared/send-webhook.mjs` | POST static JSON payloads (CI / manual) |
+| `vitest.config.ts` | Vitest + Nzila reporter (fires webhook on finish) |
+| `jest.config.example.cjs` | Jest + NzilaJestReporter |
+| `mocharc.nzila.example.cjs` | Mocha reporter setup notes |
+| `@nzila/sdk` | Installed npm package (you are reading its `examples/` folder) |
+
+Each suite includes **passing and failing** tests so the dashboard shows real failure analysis.
+
+## Trace failures (tests → dashboard)
+
+See **[TRACING-FAILURES.md](TRACING-FAILURES.md)** for how `describe()` paths, fingerprints, and `errors[]` map to **Runs**, **Failures**, and **Feature health**.
+
+## Complex usage (all features)
+
+See **[COMPLEX-USAGE.md](COMPLEX-USAGE.md)** for a single walkthrough: multi-feature Vitest, `mapFeature`, runtime `runApi` / `captureError`, Jest/Mocha, and env vars.
+
+```bash
+npm run example:test:complex      # Vitest: Checkout UI + Inventory + Auth (pass/fail)
+npm run example:runtime:complex   # Backend: traceNzilaFeature + reportFeatureError
+```
+
+## Runtime trace (live app → Feature health)
+
+See **[RUNTIME-TRACE.md](RUNTIME-TRACE.md)** for `useNzilaFeature` (React), `traceNzilaFeature` (backend), and **`captureError` / `reportFeatureError`** when you handle errors yourself.
+
+Example backend handler: `backend/runtime-trace.example.ts`. Heavier demo: `complex/api-services.demo.ts`.
+
+Quick demo (Vitest only):
+
+```bash
+npm run example:test:tracing      # Vitest → webhook
+npm run example:webhook:tracing   # static JSON payload
+```
+
+## Run Vitest (sends one webhook per run)
+
+```bash
+# All examples (mixed app name: nzila-demo)
+npm run example:test
+
+# Backend only → app name checkout-api
+npm run example:test:backend
+
+# Frontend only → app name checkout-web
+npm run example:test:frontend
+```
+
+## Send sample payloads (no Vitest)
+
+```bash
+npm run example:webhook:backend
+npm run example:webhook:frontend
+npm run example:webhook          # both
+```
+
+## Full local demo
+
+```bash
+npm run example:all              # vitest + both webhooks (needs dev + worker up)
+```
+
+## Server-side client
+
+Use `frontend-webhook-client.ts` from a Route Handler or CI job — not from browser bundles.
+
+## Payload contract
+
+See `backend/sample-payload.json`, `frontend/sample-payload.json`, and `src/lib/webhook-schema.ts`.