@terreno/mcp 58.0.0 → 58.0.2

package/dist/docs/versioned/58.0.0/testing/e2e/jobs.md

@@ -0,0 +1,58 @@
+# @terreno/jobs e2e tests
+
+Run the jobs smoke after a compile:
+
+```bash
+bun run compile && bun run --cwd jobs smoke   # or, from the root: bun run smoke jobs
+```
+
+## Test tiers
+
+| Tier | What it covers | Command |
+| --- | --- | --- |
+| Unit and integration | The `Job` and `JobSchedule` models, enqueue with delay and idempotency keys, claim leases, retries and backoff, cron schedules, worker start and stop, the GCP Cloud Tasks and Vercel Queues runners through injected client seams, and every admin and execute route through supertest against in-memory Mongo (`src/tests/*.test.ts`) | `bun run --cwd jobs test` |
+| Smoke | A job enqueued by one process and completed by the compiled `MongoJobRunner` in a separate worker process | `bun run --cwd jobs smoke` |
+| E2E | None yet. example-backend registers `JobsApp` and runs a worker in the API process or through `bun run jobs:worker`; its unit tests cover that wiring | none |
+| Manual regression | Cases in `docs/regression/` | none |
+
+## The smoke
+
+[`jobs/e2e/smoke.ts`](https://github.com/TerrenoLabs/terreno/blob/master/jobs/e2e/smoke.ts)
+runs at the `http` layer: it waits on the worker's health URL, then checks job state in Mongo,
+because a worker has no API to call. It re-runs itself with a `worker` argument to start a child
+process shaped like a dedicated jobs entrypoint: it imports the compiled `@terreno/jobs`,
+connects to `smokeMongoUri()`, defines a handler that records the job id and its own pid in a
+`jobsSmokeRuns` collection, and calls `startWorker()` with the default `MongoJobRunner` polling
+every 100 ms. Once the poll loop is running it answers `/health` with 200 (503 while the worker is inactive) on a `freePort()`, and SIGTERM
+stops the worker before the process exits. The parent waits for `/health` with
+`spawnUntilReady`, then acts as the enqueuing process:
+
+1. It registers its own `JobsApp` with the same job name (on a bare Express app, which mounts
+   the admin routes and makes `getJobsService()` available), never starts a worker, and
+   enqueues one job with a run id in the payload. The job is stored as `pending`. Its handler
+   throws, as a backstop: the parent never polls, so it never claims the job.
+2. Within 15 s the job's status becomes `completed`.
+3. The handler ran exactly once, in the worker's pid, with the enqueued run id. This check is
+   the proof that the job crossed processes.
+
+Each check prints one `✅` line. The smoke exits 1 on the first failure, after printing the
+worker's output. Rows are looked up by job id, so runs one after another against the shared CI
+Mongo do not collide. Two runs at once against the same Mongo could claim each other's jobs and
+fail the pid check; `bun run smoke` runs smokes one at a time.
+
+**Measured time:** 8–13 s against a running replica-set Mongo (`TERRENO_TEST_MONGODB_URI`),
+excluding the compile. Most of it is the worker importing the compiled `@terreno/api` (about
+4 s here) and the pollers settling. Without `TERRENO_TEST_MONGODB_URI`, starting the in-memory
+replica set took several minutes in a slow-I/O sandbox, and under heavy load the worker can miss
+its 20 s readiness window, the same as the other server smokes. Budget: 30 s.
+
+## Add an e2e test
+
+- **New jobs behavior** (a runner, a retry rule, a schedule option, an admin route): add a unit
+  test in `jobs/src/tests/`. The smoke stays one happy path; do not add edge cases to it.
+- **The smoke's happy path changed** (for example, `startWorker()` or the default runner's
+  claim flow): update the checks in `jobs/e2e/smoke.ts` and keep it within 30 s.
+- **A user-visible jobs flow** (the admin Jobs dashboard: list, retry, requeue, cancel): add a
+  Playwright spec in `example-frontend/e2e/`, following
+  [Write a Playwright spec](../e2e.md#write-a-playwright-spec). example-backend already
+  registers `JobsApp` and contributes the admin Jobs screen.

package/dist/docs/versioned/58.0.0/testing/e2e/mcp-server.md

@@ -0,0 +1,62 @@
+# @terreno/mcp e2e tests
+
+Run the mcp smoke after a compile:
+
+```bash
+bun run compile && bun run --cwd mcp-server smoke
+```
+
+## Test tiers
+
+| Tier | What it covers | Command |
+| --- | --- | --- |
+| Unit and integration | Tools, prompts, resources, doc search, upgrade notes, and the local server's tools over an in-memory MCP transport (`src/**/*.test.ts`, `src/local/localServer.e2e.test.ts`) | `bun run --cwd mcp-server test` |
+| Smoke | Both compiled binaries, each started as a child process and driven by the real MCP client over its own transport | `bun run --cwd mcp-server smoke` |
+| E2E | None. Agents are the only client, and the smoke already uses the real client and transports | none |
+| Manual regression | Cases in `docs/regression/` | none |
+
+## The smoke
+
+[`mcp-server/e2e/smoke.ts`](https://github.com/TerrenoLabs/terreno/blob/master/mcp-server/e2e/smoke.ts)
+drives each binary with the `Client` from `@modelcontextprotocol/client`. The package ships two
+binaries on two transports, so the smoke checks each one: the stdio binary at the `process`
+layer (it talks MCP over stdin and stdout instead of exiting, so the transport owns the child,
+not `runBin`) and the HTTP binary at the `http` layer.
+
+1. **`terreno-mcp-local` over stdio.** `StdioClientTransport` starts `dist/local/index.js`
+   with Bun. The client completes `initialize`, the server reports its name as
+   `terreno-mcp-local`, and `tools/list` returns at least one tool, including `browser`.
+2. **`terreno-mcp` over Streamable HTTP.** `terreno-mcp` is the hosted docs server and serves
+   HTTP, not stdio. `spawnUntilReady` starts `dist/index.js` on a `freePort()` bound to
+   `127.0.0.1`, with `SENTRY_DSN` unset, and waits for `GET /` to answer. The client connects
+   to `/mcp`, completes `initialize`, the server reports `terreno-mcp`, and `tools/list`
+   returns at least one tool, including `terreno_search_docs`.
+
+It prints one `✅` line per check and exits 1 on the first failure, after printing the
+server's stderr or output. Each MCP request times out after 15 s instead of the SDK's 60 s
+default, so a hung server fails inside the budget. The smoke kills the stdio child by pid on
+the way out, because after a failed `initialize` the SDK signals it only seconds later, after
+the smoke has exited.
+
+`bun run compile` type-checks and emits `dist/` but does not copy `src/docs` into
+`dist/docs`; only `bun run build` does. Without docs, `terreno-mcp` crashes at startup reading
+`resources/overview.md`. The smoke therefore starts it with `TERRENO_MCP_DOCS_DIR` set to
+`mcp-server/src/docs`, the override the [mcp reference](../../reference/mcp-server.md#resources)
+documents, so it runs after the CI `smoke` job's plain compile.
+
+The smoke needs no MongoDB: listing tools touches no database.
+
+**Measured time:** 5.5–6 s in three root `bun run smoke` runs (the [guide's](../e2e.md#package-pages) figure), excluding the compile. Single runs on a loaded
+4-CPU container took 9–24 s. About 10 s of that is
+the hosted server reading its docs at startup. Budget: 30 s.
+
+## Add an e2e test
+
+- **New tool, prompt, or resource:** add a test in `mcp-server/src/`, next to the code. The
+  smoke stays one happy path per binary; do not add per-tool checks to it.
+- **A transport or startup change** (for example, a new endpoint path, a new binary in `bin`,
+  or a new required environment variable): update `mcp-server/e2e/smoke.ts` and keep it
+  within 30 s.
+
+See [the mcp reference](../../reference/mcp-server.md) for the tools and transports and
+[the `@terreno/test` reference](../../reference/test.md#smoke-helpers) for the smoke helpers.

package/dist/docs/versioned/58.0.0/testing/e2e/rtk.md

@@ -0,0 +1,80 @@
+# @terreno/rtk e2e tests
+
+Run the rtk smoke after a compile:
+
+```bash
+bun run compile && bun run --cwd rtk smoke   # or, from the root: bun run smoke rtk
+```
+
+## Test tiers
+
+| Tier | What it covers | Command |
+| --- | --- | --- |
+| Unit and integration | The JWT and Better Auth slices, the Better Auth client factory (cookie and web bearer modes, cookie-jar repair, OAuth handoff), the base query's token-source and refresh paths, sockets, offline middleware, feature-flag and upgrade hooks, with `@better-auth/expo/client` and other modules mocked per file (`src/**/*.test.ts`) | `bun run --cwd rtk test` |
+| Smoke | The compiled package's Better Auth client, slice, and base query against a real example-backend | `bun run --cwd rtk smoke` |
+| E2E | Sign-in, session, and SDK queries seen by a user, through example-frontend's Playwright suite against example-backend | `bun run frontend:e2e` |
+| Manual regression | Cases in `docs/regression/` | none |
+
+## The smoke
+
+[`rtk/e2e/smoke.ts`](https://github.com/TerrenoLabs/terreno/blob/master/rtk/e2e/smoke.ts)
+runs at the `http` layer. It starts example-backend with `spawnExampleBackend()` against
+`smokeMongoUri()` (Better Auth is the backend's default provider), sets `EXPO_PUBLIC_API_URL` to
+the backend's URL, and then imports the compiled `@terreno/rtk` in the smoke's own Bun process.
+It builds a store the way a web app in bearer mode does:
+
+- `createBetterAuthClient({webAuth: "bearer"})` with an in-memory `bearerStorage`, because Bun
+  has no `window.localStorage`.
+- `setTokenSource(betterAuthAdapter(bridgeBetterAuthReactClient(client), {getBearerToken}))`,
+  the adapter from example-frontend's `store/syncdb.ts`, registered as in its `store/index.ts`.
+- `generateBetterAuthSlice` and `emptySplitApi` with one injected `getMe` query on `/auth/me`.
+
+Then it checks:
+
+1. A new user signs up and signs in through the Better Auth client, and the client stores the
+   bearer token from the sign-in response.
+2. `syncSession` puts that user in the `betterAuth` slice (`isAuthenticated`, matching email).
+3. The `getMe` query, sent by rtk's base query with the registered token source, returns the
+   signed-in user's email from `/auth/me`. Without `setTokenSource` this check fails.
+
+Each check prints one `✅` line. The smoke exits 1 on the first failure, after printing the
+backend's output. The email carries the run's timestamp, so runs against the shared CI Mongo do
+not collide.
+
+### Native-module shims
+
+rtk targets React Native, and its package root loads modules that cannot run in Bun. The smoke
+runs in Bun anyway, with `mock.module` shims installed before it imports the package:
+
+- [`rtk/test-preload.ts`](https://github.com/TerrenoLabs/terreno/blob/master/rtk/test-preload.ts),
+  the shims rtk's unit tests already use: `react-native` (`Platform.OS` is `"web"`, plus
+  `AppState`, `Linking`, `StyleSheet`), `expo-secure-store`,
+  `@react-native-async-storage/async-storage`, `expo-constants`, and `expo-network`.
+- `@terreno/ui`, a `useToast` stub: `socket.ts` imports it, and the smoke never calls it.
+- `expo-linking`, a `createURL` stub: the real `@better-auth/expo/client` plugin imports it for
+  social sign-in deep links. The unit tests mock that plugin whole; the smoke runs it.
+
+Because `Platform.OS` is `"web"`, the smoke proves the web bearer path, not the native
+SecureStore cookie-jar path. Native sign-in stays covered by the unit tests and example-frontend
+on a device.
+
+**Measured time:** 15–18 s in three root `bun run smoke` runs (the [guide's](../e2e.md#package-pages) figure), against a running replica-set Mongo
+(`TERRENO_TEST_MONGODB_URI`), excluding the compile. Single runs on a loaded container took up
+to 50 s. Almost all of it is example-backend booting until `/health` answers 200;
+the rtk checks take under a second. The first boot against a fresh database also runs
+example-backend's startup work and took about 70 s in a slow-I/O sandbox, so the smoke allows
+120 s for readiness. Budget: 30 s. A warm boot fits it; a slow or cold boot goes over, and the
+overage is `spawnExampleBackend()` readiness, which the other client smokes (syncdb,
+admin-frontend) share. The rtk checks themselves are not the cost.
+
+## Add an e2e test
+
+- **New rtk behavior** (a slice action, a base-query rule, a client option): add a unit test in
+  `rtk/src/`. The smoke stays one happy path; do not add edge cases to it.
+- **The smoke's happy path changed** (for example, `createBetterAuthClient`, `setTokenSource`, or
+  the base query's token-source path): update the checks in `rtk/e2e/smoke.ts` and keep it
+  within 30 s.
+- **The package root loads a new native module:** add its shim to the smoke's `loadRtk`, or to
+  `test-preload.ts` when the unit tests need it too, and list it above.
+- **A user-visible auth or SDK flow:** add a Playwright spec in `example-frontend/e2e/`, following
+  [Write a Playwright spec](../e2e.md#write-a-playwright-spec).

package/dist/docs/versioned/58.0.0/testing/e2e/syncdb.md

@@ -0,0 +1,79 @@
+# @terreno/syncdb e2e tests
+
+Run the syncdb smoke after a compile:
+
+```bash
+bun run compile && bun run --cwd syncdb smoke   # or, from the root: bun run smoke syncdb
+```
+
+## Test tiers
+
+| Tier | What it covers | Command |
+| --- | --- | --- |
+| Unit and integration | The TinyBase store, outbox, replay, conflicts, delta applier, snapshot bootstrap, query windows, persisters, encryption codecs, the Better Auth adapter, and the React hooks, against `createFakeTransport` and fake IndexedDB (`src/**/*.test.ts`). The real socket and HTTP protocol against an in-process server is covered by `api/src/sync/integration.test.ts` | `bun run --cwd syncdb test` |
+| Smoke | Two clients built from the compiled package sync one todo through a real example-backend child process | `bun run --cwd syncdb smoke` |
+| E2E | The synced todos screens in Chromium (offline outbox, conflicts, storage, chaos, load) through example-frontend's `syncdb-*.spec.ts` Playwright suite against example-backend | `bun run frontend:e2e` |
+| Manual regression | Cases in `docs/regression/` | none |
+
+## The smoke
+
+[`syncdb/e2e/smoke.ts`](https://github.com/TerrenoLabs/terreno/blob/master/syncdb/e2e/smoke.ts)
+runs at the `http` and websocket layer. It starts example-backend with `spawnExampleBackend()`
+against `smokeMongoUri()`, so it never imports `@terreno/api`. It imports `@terreno/syncdb` by
+package name, which resolves to `dist/`. Then it:
+
+1. Signs a new user up through `POST /api/auth/sign-up/email`, then signs the same user in
+   again through `POST /api/auth/sign-in/email`, giving two Better Auth sessions, as two devices
+   would have.
+2. Builds client A and client B with `createSyncDb` for the `todos` collection. Each uses the
+   default socket transport and HTTP channel, the memory persister, `debug: true`, and
+   `betterAuthAdapter` over a small client that reads `GET /api/auth/get-session` with its own
+   bearer token.
+3. Starts both clients and waits until each one settles: its debug log has a
+   `subscribe catch-up` pass for its `todos|owner:{userId}` stream, and `isSyncing` is false.
+4. Client A calls `mutate()` to create a todo, and the smoke waits until the server acks it: the
+   local row has a server `seq` and no pending mutation.
+5. Within 5 s of client A's write, client B's debug log has a `delta` event for that todo, and
+   B's local store holds it with its title and a server `seq`.
+
+It prints one `✅` line per check and exits 1 on the first failure, after printing the backend's
+output. Settling first means B's startup reconcile and subscribe catch-up are done before the
+write, and the periodic reconcile is off (`reconcileIntervalMs: 0`). The `delta` event is
+recorded only when a socket delta is applied, so step 5 fails if B gets the todo from an HTTP
+snapshot page instead. A client B signed in as a different user never receives the todo and
+also fails at step 5; that case proves owner scoping, not the socket path. Each run uses a new
+email and todo title, so reruns against a shared `TERRENO_TEST_MONGODB_URI` never collide.
+
+**Measured time:** 14–16 s against an external replica set on an idle container (passing runs
+took 13.8, 14.5 and 15.9 s), excluding the compile. Booting example-backend takes most of it.
+Settling takes about 0.5 s, and delivery from A to B took 110–720 ms. On a 4-core container
+shared with other builds and type checks, passing runs took 38–60 s, and two runs missed
+`spawnExampleBackend()`'s 60 s readiness timeout before the backend answered `/health`. The
+in-memory replica set did not start within 60 s on that container. Budget: 30 s.
+
+If the in-memory replica set times out waiting for a primary, point the smoke at a running
+replica set the way CI does:
+
+```bash
+TERRENO_TEST_MONGODB_URI="mongodb://127.0.0.1:27017/?replicaSet=rs0" bun run --cwd syncdb smoke
+```
+
+A mongod with less than 500 MB of free disk refuses example-backend's index builds
+(`available disk space ... is less than required minimum`). Free disk space, or lower
+`indexBuildMinAvailableDiskSpaceMB` on a scratch mongod.
+
+## Add an e2e test
+
+- **New store, outbox, conflict, or query behavior:** add a test in `syncdb/src/` against
+  `createFakeTransport`. The smoke stays one happy path; do not add edge cases to it.
+- **The sync protocol changed** (socket events, `/sync/snapshot`, ack shape, or stream keys):
+  add a case to `api/src/sync/integration.test.ts`, and update the checks in
+  `syncdb/e2e/smoke.ts` if the two-client path changed. Keep it within 30 s.
+- **A user-visible sync flow:** add a Playwright spec next to the `syncdb-*.spec.ts` files in
+  `example-frontend/e2e/`, following [Write a Playwright spec](../e2e.md#write-a-playwright-spec).
+  Open the screen with `openSyncTodos(page)` and call `allowSyncDbNoise(consoleGuard)` from
+  `e2e/helpers/syncdbSuite.ts`.
+
+See [the syncdb reference](../../reference/syncdb.md) for the client API,
+[Local-first data](../../explanation/local-first-data.md) for the design, and
+[the `@terreno/test` reference](../../reference/test.md#smoke-helpers) for the smoke helpers.

package/dist/docs/versioned/58.0.0/testing/e2e/test.md

@@ -0,0 +1,51 @@
+# E2E testing `@terreno/test`
+
+`@terreno/test` is the helper package every other package's smoke imports, so its own e2e test
+is one real-process smoke that proves those helpers work outside `bun test`.
+
+## Run it
+
+```bash
+bun run compile                # builds test/dist, which the smoke imports
+bun run --cwd test smoke       # or, from the root: bun run smoke test
+```
+
+It takes 2.5–3 s in three root `bun run smoke` runs (the [guide's](../e2e.md#package-pages) figure), and about 12 s as a single warm run that loads the package
+cold. The first run on a machine also downloads or unpacks the
+`mongod` binary for the in-memory replica set, which can add 20 s or more.
+
+## What it proves
+
+`test/e2e/smoke.ts` imports `@terreno/test` by package name, so it runs against the built
+`dist/` output, not the sources. It checks, in order:
+
+1. **Replica set.** `smokeMongoUri({databaseName: "testSmoke"})` returns a URI for that
+   database. A Mongoose connection to it opens a change stream filtered to one marker value,
+   inserts a document with that marker, and receives the insert as a change event within 10 s. Change streams need a
+   replica set, so a standalone `mongod` fails here.
+2. **Readiness.** `spawnUntilReady` starts a child process (the same file re-run with
+   `serve`) that runs a plain `Bun.serve` HTTP server. The child answers its first three
+   `/ready` requests with 503, then answers 200 with its pid and how many 503s it served. The
+   smoke checks that the child served all three 503s (so `spawnUntilReady` kept polling past
+   them), that a follow-up `GET /ready` answers 200, and that the answering pid is the
+   `pid` that `spawnUntilReady` returned.
+3. **Teardown.** After `stop()`, the child no longer answers on its port.
+
+The smoke exits 0 when every check passes. It exits 1 on the first failure and prints the
+child's output when the child was involved.
+
+## In CI
+
+Set `TERRENO_TEST_MONGODB_URI` to a replica-set URI (the CI Mongo sidecar) and the smoke uses
+it instead of starting an in-memory replica set. With a standalone (non-replica-set) Mongo
+there, check 1 fails, which is the intended signal.
+
+## Changing it
+
+- Keep the smoke on the package's public exports from `@terreno/test`. Testing an internal
+  module belongs in `test/src/smoke/smoke.test.ts`.
+- When a new smoke helper is added to `@terreno/test`, add a check for it here only if other
+  packages' smokes depend on it outside a server (for example a new process or database
+  helper).
+
+See [the `@terreno/test` reference](../../reference/test.md#smoke-helpers) for the helper APIs.

package/dist/docs/versioned/58.0.0/testing/e2e/ui.md

@@ -0,0 +1,68 @@
+# @terreno/ui e2e tests
+
+Run the ui smoke after a compile and the demo web export, with Playwright's Chromium installed:
+
+```bash
+bun run compile && bun run --cwd demo export && bun run --cwd ui smoke
+```
+
+## Test tiers
+
+| Tier | What it covers | Command |
+| --- | --- | --- |
+| Unit and integration | Components, hooks, and theming with `@testing-library/react-native` (`src/**/*.test.tsx`) | `bun run --cwd ui test:ci` |
+| Chart snapshots | Rendered chart PNGs compared with the committed snapshots in `demo/rendered-snapshots/` | `bun run ui:charts:compare` |
+| Smoke | The compiled components, bundled into the demo web export, responding to input in Chromium | `bun run --cwd ui smoke` |
+| E2E (web flows) | Maestro web flows against the served demo export (`.maestro/flows/demo/`) | `bun run maestro:demo` |
+| Manual regression | Cases in `docs/regression/` | none |
+
+## The smoke
+
+[`ui/e2e/smoke.spec.ts`](https://github.com/TerrenoLabs/terreno/blob/master/ui/e2e/smoke.spec.ts)
+runs at the `browser` layer. @terreno/ui ships components, not a server or a binary, so the
+smoke drives them where they render on the web: the demo's static export (`demo/dist/`), which
+bundles the compiled package. The one file has two roles.
+
+Run with Bun (`bun e2e/smoke.spec.ts`), it is the driver:
+
+1. It exits 1 at once when `demo/dist/index.html` is missing and asks for `bun run --cwd demo
+   export`. It does not check that the export is newer than `ui/dist`, so re-export after each
+   compile, as the command above does.
+2. It re-runs itself with a `serve` argument through `spawnUntilReady()`. That child is a static
+   file server for `demo/dist/` on a `freePort()`, with clean URLs (`/dev/Button` serves
+   `dev/Button.html`) and no SPA rewrite, as the deployed demo is served.
+3. It runs the root-locked Playwright CLI on Node against this same file, passing the server URL
+   in `UI_SMOKE_BASE_URL`. There is no Playwright config, so the default Chromium project runs
+   only this spec. Traces and screenshots go to a temp dir that the driver deletes.
+
+Loaded by Playwright, the file defines one test. It opens three single-story routes
+(`/dev/<component>?story=<story>`) and waits for each one's `demo-preview-root`:
+
+| Component | Story | What the test does |
+| --- | --- | --- |
+| Button | `Button` → `Loading` | Presses `button-loading-async`, whose `onClick` returns a 2 s promise. The button's spinner (`progressbar`) appears, then goes once the promise settles. |
+| TextField | `Text field` → `Text Field with Helper Text` | Types into `demo-text-field` key by key and checks that the controlled input holds the text. |
+| Modal | `Modal` → `Modals` | Presses `modal-demo-open-default`. `modal-demo.title` appears; pressing `modal-demo.primary` dismisses the modal. |
+
+The driver prints one `✅` line per step and exits 1 on the first failure, after printing the
+static server's output and Playwright's report.
+
+The smoke needs Chromium (`bunx playwright install chromium`) but no backend, database, or
+secrets.
+
+**Measured time:** 8.5–9 s across three runs on a 4-CPU container, excluding the compile and
+the demo export. The CircleCI `smoke` job prints each package's time on every run. Budget: 30 s.
+
+## Add an e2e test
+
+- **A component's behavior changed:** add a unit test next to it in `ui/src/`. The smoke stays
+  one happy path; do not add edge cases to it.
+- **Button, TextField, or Modal changed what a press, a keystroke, or a dismiss shows:** update
+  the assertions in `ui/e2e/smoke.spec.ts` and keep it within 30 s.
+- **A story the smoke uses changed:** keep the testIDs above on the story in `demo/stories/`
+  (`Button.stories.tsx`, `TextField.stories.tsx`, `Modal.stories.tsx`), or move the smoke to a
+  story that has them.
+- **A web flow across several components:** add a Maestro flow to `.maestro/flows/demo/`. Follow
+  [Write a Maestro flow](../e2e.md#write-a-maestro-flow).
+
+See [the `@terreno/test` reference](../../reference/test.md#smoke-helpers) for the smoke helpers.