@querykitjs/web 3.1.0 → 4.1.0

package/README.en.md

@@ -46,21 +46,40 @@ function UsersPage() {
 - **Registry** — configure `adapter` + defaults once; `resource<T>()` gives entity-typed, adapter-aware builders/filters/schema/keys/parsers.
 - **Two filter styles** — `f.eq()...` builder (operators typed per field) AND object/array (`{key, operation, value}`). Fully compatible with legacy `IFilter[]`.
 - **3 pagination modes** — offset (`list`), infinite (`infinite`), cursor/keyset (`cursor`); each has its own `parse*` to camelCase the meta.
-- **Adapter-aware `with`** — only **wire-safe** (JSON) per-relation options are suggested for `mongoose`/`drizzle-pg`/`drizzle-sqlite`/`prisma-pg`; function/SQL forms are never offered.
+- **Adapter-aware `with`** — only **wire-safe** (JSON) per-relation options are suggested for `mongoose`/`drizzle-pg`/`drizzle-sqlite`/`prisma-pg`; function/SQL forms are never offered. `mongodb` has no `with` — load relations with a second request.
 - **Declarative schema** — `resource.schema` / `defineListSchema` maps URL params → filter; kills the per-page hand-building.
-- **React hooks** — `useListParams` (react-router-dom inside), `useListParamsBase` (router-agnostic). Framework-agnostic core — Vue can bind the same core.
+- **React hooks, Vue composables and Angular signals** — `useListParams` (react-router / vue-router inside) and `useListParamsBase` (router-agnostic) in `/react` and `/vue`; `injectListParams` and `injectListParamsBase` in `/angular`. `createListState` — the same logic, framework-free.
 - **SSR** — `resource.fromSearchParams(sp, {schema})` builds a payload straight from `URLSearchParams`, no hook.
 - **Query keys** — `resource.keys` gives stable keys for TanStack/SWR.
-- **Zero dependency** — no axios/react-query/dayjs. `react` (+ `react-router-dom` for the hook) are optional peers.
+- **Zero dependency** — no axios/react-query/dayjs. `react` (+ `react-router` for the hook) `vue` (+ `vue-router`) and `@angular/core` (+ `@angular/router`, `rxjs`) are optional peers.
 
 ## Install
 
 ```bash
 bun add @querykitjs/web
-# React hook: react (peer). `useListParams` also peers react-router-dom.
-# The router-agnostic `useListParamsBase` needs no react-router-dom.
+# React hook: react (peer). `useListParams` also peers react-router.
+# The router-agnostic `useListParamsBase` needs no react-router.
+# Vue composable: vue (peer). `useListParams` also peers vue-router.
+# Angular: @angular/core and rxjs (peers). `injectListParams` also peers @angular/router.
 ```
 
+### Requirements
+
+|                                                            | Version              | Tested (`bun run test:matrix`) |
+| ---------------------------------------------------------- | -------------------- | ------------------------------ |
+| Node.js                                                    | `>=22.12`            | 24                             |
+| `react` (optional peer)                                    | `^18.3 \|\| ^19.2.7` | 18.3.1, 19.3.1                 |
+| `react-router` (optional peer, `useListParams` only)       | `^7.0 \|\| ^8.0`     | 7.18.5, 8.5.1                  |
+| `vue` (optional peer)                                      | `^3.5`               | 3.5.0, 3.5.44                  |
+| `vue-router` (optional peer, `useListParams` only)         | `^4.6 \|\| ^5`       | 4.6.4, 5.4.0                   |
+| `@angular/core` (optional peer)                            | `^21 \|\| ^22`       | 21.2.26, 22.2.4                |
+| `@angular/router` (optional peer, `injectListParams` only) | `^21 \|\| ^22`       | 21.2.26, 22.2.4                |
+| `rxjs` (optional peer, Angular's own)                      | `^7.8`               | 7.8.2                          |
+
+Node 20 is no longer supported (`engines`: `>=22.12`). Peer ranges cover the last two majors; both ends are tested. Vue has one supported major: its range starts at 3.5, the oldest minor vue-router 4.6 accepts.
+
+**`react-router-dom` → `react-router`.** `useListParams` now imports from `react-router` (v7 and v8 both export `useSearchParams`). A project that has `react-router-dom` installs `react-router` too — on v7 it is already a dependency of `react-router-dom`: `npm i react-router`.
+
 ## Two ways to use it
 
 ```ts
@@ -77,25 +96,27 @@ Use (A) when you want defaults in one place, autocomplete, adapter `with`, query
 
 ```ts
 export const qk = createRegistry({
-  adapter: "mongoose", // "mongoose" | "drizzle-pg" | "drizzle-sqlite" | "prisma-pg"
+  adapter: "mongoose", // "mongoose" | "mongodb" | "drizzle-pg" | "drizzle-sqlite" | "prisma-pg"
   defaults: {
     perPage: 20, // list (offset) page size
     limit: 20, // infinite + cursor page size
     sort: ["-createdAt"], // list + infinite ordering (leading "-" = desc)
     cursor: { order: "asc" }, // cursor-only key traversal order
   },
+  timestamps: { createdAt: "created_at" }, // same as the backend registry; the default sort is this field, desc
   pruneEmpty: true, // drop empty filter values (""/null/undefined/[]); keep 0/false
 });
 ```
 
-| Config                  | Meaning                                                                             |
-| ----------------------- | ----------------------------------------------------------------------------------- |
-| `adapter`               | Target backend — tailors `with` typing (intellisense only).                         |
-| `defaults.perPage`      | Default `perPage` for `list`.                                                       |
-| `defaults.limit`        | Default `limit` for `infinite` and `cursor`.                                        |
-| `defaults.sort`         | Default sort for `list`/`infinite` — `[{key,direction}]` or `["-field"]` shorthand. |
-| `defaults.cursor.order` | Default cursor traversal order (`"asc"`/`"desc"`).                                  |
-| `pruneEmpty`            | Auto-drop empty filter conditions built from form inputs (default `true`).          |
+| Config                  | Meaning                                                                                                                                                    |
+| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `adapter`               | Target backend — tailors `with` typing (intellisense only).                                                                                                |
+| `defaults.perPage`      | Default `perPage` for `list`.                                                                                                                              |
+| `defaults.limit`        | Default `limit` for `infinite` and `cursor`.                                                                                                               |
+| `defaults.sort`         | Default sort for `list`/`infinite` — `[{key,direction}]` or `["-field"]` shorthand.                                                                        |
+| `defaults.cursor.order` | Default cursor traversal order (`"asc"`/`"desc"`).                                                                                                         |
+| `timestamps.createdAt`  | Same as the backend `timestamps.createdAt`; without `defaults.sort` the default sort is `[{ key: createdAt, direction: "desc" }]` (default `"createdAt"`). |
+| `pruneEmpty`            | Auto-drop empty filter conditions built from form inputs (default `true`).                                                                                 |
 
 Every default is overridable per call.
 
@@ -106,19 +127,19 @@ import type { IUser } from "@my/api-types";
 export const users = qk.resource<IUser>("users"); // "users" = cache-key namespace (required, unique)
 ```
 
-| Member                                                        | What it is                                                           |
-| ------------------------------------------------------------- | -------------------------------------------------------------------- |
-| `users.list(input)`                                           | build an offset (page) payload                                       |
-| `users.infinite(input)`                                       | build an infinite (limit/offset) payload                             |
-| `users.cursor(input)`                                         | build a cursor (keyset) payload                                      |
-| `users.params(input)`                                         | build a paginationless payload (filter/sort/columns/with)            |
-| `users.f`                                                     | `createFilters<IUser>()` — field-typed builder                       |
-| `users.search(term, fields)`                                  | OR-of-`contains` preset across `fields`                              |
-| `users.schema(desc)`                                          | `defineListSchema` bound (URL ↔ filter)                              |
-| `users.fromSearchParams(sp, {schema})`                        | build a list payload straight from `URLSearchParams` (SSR / no hook) |
-| `users.keys`                                                  | stable query keys for TanStack/SWR                                   |
-| `users.parseList / parseInfinite / parseCursor`               | map response meta snake→camel                                        |
-| `ListResult<T> / InfiniteResult<T> / CursorResult<T>` (types) | `parse*` return types                                                |
+| Member                                                        | What it is                                                                  |
+| ------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| `users.list(input)`                                           | build an offset (page) payload                                              |
+| `users.infinite(input)`                                       | build an infinite (limit/offset) payload                                    |
+| `users.cursor(input)`                                         | build a cursor (keyset) payload                                             |
+| `users.params(input)`                                         | build a paginationless payload (filter/sort/columns/with)                   |
+| `users.f`                                                     | `createFilters<IUser>()` — field-typed builder                              |
+| `users.search(term, fields, { operation? })`                  | OR preset across `fields` (`contains` by default, `startsWith`, `endsWith`) |
+| `users.schema(desc)`                                          | `defineListSchema` bound (URL ↔ filter)                                     |
+| `users.fromSearchParams(sp, {schema})`                        | build a list payload straight from `URLSearchParams` (SSR / no hook)        |
+| `users.keys`                                                  | stable query keys for TanStack/SWR                                          |
+| `users.parseList / parseInfinite / parseCursor`               | map response meta snake→camel                                               |
+| `ListResult<T> / InfiniteResult<T> / CursorResult<T>` (types) | `parse*` return types                                                       |
 
 All builders inherit the registry's `defaults` + `pruneEmpty`; all types are driven by `IUser` and the `adapter`.
 
@@ -155,8 +176,13 @@ f.contains("age", "x"); // ✗ compile error — `contains` is string-only
 ```ts
 users.search("ali", ["buyerName", "email"]);
 // → or(contains("buyerName","ali"), contains("email","ali"))
+users.search("ali", ["buyerName"], { operation: "startsWith" });
+// → or(startsWith("buyerName","ali")) — can use an index
 ```
 
+- `contains` is expensive: `%ali%` cannot use a B-tree index (a full scan on Postgres, a regex on MongoDB). On a large table prefer `startsWith` (`ali%`) or full-text search.
+- Every field must be `filterable` on the server with that operator (`{ buyerName: ["%_%"] }` or `["%_"]`); otherwise the server answers 400 with `forbidden-key` / `forbidden-operator`.
+
 An untyped `f` is also exported: `import { f } from "@querykitjs/web"` (no field-type checks, quick use).
 
 ## Sort — always `[{ key, direction }]` (multi-field)
@@ -219,6 +245,15 @@ users.parseInfinite(res.data); // { data, meta: { hasMore, nextOffset, … } }
 users.parseCursor(res.data); // { data, meta: { nextCursor, hasNext, … } }
 ```
 
+**`withTotal: false`** — when you do not need the total (an infinite-like list, a "next" button), the server skips the count query:
+
+```ts
+const body = users.list({ page, perPage: 20, withTotal: false }); // the payload carries withTotal: false (absent when not given)
+const { meta } = users.parseList(res.data); // meta.totalCount === null, meta.totalPages === null; hasNext still works
+```
+
+`Meta.totalCount` / `Meta.totalPages` are typed `number | null`: `null` means no count ran; a field the server did not send at all is `0` as before. zod (`makeOffsetParamsSchema`) and class-validator (`makeOffsetParamsDto`) accept `withTotal`.
+
 `parse*` exists at two levels (one shared implementation — meta is entity-agnostic):
 `qk.parseList/...` (registry, `data: unknown[]`) when you don't have a `resource`; `users.parseList/...` (entity-typed).
 
@@ -226,11 +261,12 @@ users.parseCursor(res.data); // { data, meta: { nextCursor, hasNext, … } }
 
 The registry types `with` per adapter — **serializable options only**:
 
-| adapter                         | `with[rel]` intellisense                                           | Hidden (not offered)                              |
-| ------------------------------- | ------------------------------------------------------------------ | ------------------------------------------------- |
-| `mongoose`                      | `boolean \| { select?, populate?, match?, options? }`              | —                                                 |
-| `drizzle-pg` / `drizzle-sqlite` | `boolean \| { columns?, with?, limit?, offset? }`                  | `where:(f,op)=>…`, `orderBy:(f,op)=>…`, raw `sql` |
-| `prisma-pg`                     | `boolean \| { select?, include?, where?, orderBy?, take?, skip? }` | function forms                                    |
+| adapter                         | `with[rel]` intellisense                                           | Hidden (not offered)                                      |
+| ------------------------------- | ------------------------------------------------------------------ | --------------------------------------------------------- |
+| `mongoose`                      | `boolean \| { select?, populate?, match?, options? }`              | —                                                         |
+| `mongodb`                       | no `with` — load relations with a second request                   | any `with` (TS error; the server answers `forbidden-key`) |
+| `drizzle-pg` / `drizzle-sqlite` | `boolean \| { columns?, with?, limit?, offset? }`                  | `where:(f,op)=>…`, `orderBy:(f,op)=>…`, raw `sql`         |
+| `prisma-pg`                     | `boolean \| { select?, include?, where?, orderBy?, take?, skip? }` | function forms                                            |
 
 ```ts
 // adapter: "mongoose"
@@ -276,7 +312,7 @@ Empty/**absent** params are pruned; `default` fills only when the param is **abs
 ## React hook
 
 ```tsx
-import { useListParams } from "@querykitjs/web/react"; // uses react-router-dom internally
+import { useListParams } from "@querykitjs/web/react"; // uses react-router internally
 import { qk } from "@/lib/query";
 
 const users = qk.resource<IUser>("users");
@@ -299,15 +335,90 @@ function UsersListPage() {
 }
 ```
 
+The hook also returns `clamped: boolean` — the URL's `page` or `sort` was past a limit and was cut (see «Limits» below). To fix the URL: `if (clamped) setPage(params.page)`.
+
 An input/sort/page change mutates the URL → `params` changes → `queryKey` changes → TanStack refetches (and caches each combo).
 
-**Router-agnostic** (Next.js, TanStack Router) — pass `searchParams` to the base hook (no react-router-dom):
+**Router-agnostic** (Next.js, TanStack Router) — pass `searchParams` to the base hook (no react-router):
 
 ```tsx
 import { useListParamsBase } from "@querykitjs/web/react";
 const { params, setPage } = useListParamsBase(users, { schema: usersSchema, searchParams, setSearchParams });
 ```
 
+## Vue composable
+
+```ts
+import { useListParams } from "@querykitjs/web/vue"; // uses vue-router internally
+import { useQuery } from "@tanstack/vue-query";
+import { computed } from "vue";
+
+const users = qk.resource<IUser>("users");
+const usersSchema = users.schema({ name: { operation: "%_%", trim: true }, status: { operation: "=" } });
+
+// inside <script setup>
+const { params, clamped, setParam, setPage, setSort, reset } = useListParams(users, { schema: usersSchema });
+
+const q = useQuery({
+  queryKey: computed(() => users.keys.list(params.value)),
+  queryFn: async () => users.parseList((await axios.post("/users/list", params.value)).data),
+});
+// setParam("status", "active") → router.push({ query }) (a new history entry), page reset
+```
+
+The same reads, clamping and setters as the React hook — `params`, `clamped` and `searchParams` are computed refs.
+A repeated key (`?status=a&status=b`) is kept; `?q` (no `=`) reads as an empty value. Works under SSR (Nuxt): no `window` access.
+
+**Router-agnostic** — pass `searchParams` (a ref, a getter or a value) to the base composable:
+
+```ts
+import { useListParamsBase } from "@querykitjs/web/vue";
+const { params, setPage } = useListParamsBase(users, { schema: usersSchema, searchParams: () => currentSearchParams.value, setSearchParams });
+```
+
+## Angular
+
+```ts
+import { Component, computed } from "@angular/core";
+import { injectListParams } from "@querykitjs/web/angular"; // uses the Angular Router
+
+const users = qk.resource<IUser>("users");
+const usersSchema = users.schema({ name: { operation: "%_%", trim: true }, status: { operation: "=" } });
+
+@Component({
+  selector: "app-users",
+  template: `<button (click)="list.setPage(2)">{{ list.params().page }}</button>`,
+})
+export class UsersPage {
+  readonly list = injectListParams(users, { schema: usersSchema });
+  readonly queryKey = computed(() => users.keys.list(this.list.params()));
+  // list.setParam("status", "active") → router.navigate (a new history entry), page reset
+}
+```
+
+The same reads, clamping and setters as the React and Vue versions — `params`, `clamped` and `searchParams` are signals. Call it in an injection context (a field initializer or a constructor); elsewhere Angular throws `NG0203`. A plain ESM entry: no decorator and no Angular package format, it builds with `@angular/build`.
+
+**Router-agnostic** — pass your own `searchParams` signal to the base function:
+
+```ts
+import { injectListParamsBase } from "@querykitjs/web/angular";
+const searchParams = signal(new URLSearchParams());
+const list = injectListParamsBase(users, { schema: usersSchema, searchParams, setSearchParams: next => searchParams.set(next) });
+```
+
+## Any framework — `createListState`
+
+The logic behind all of them, framework-free (Svelte, Solid, vanilla). Pure: it reads search params and returns the next ones; you navigate.
+
+```ts
+import { createListState } from "@querykitjs/web";
+
+const list = createListState(users, { schema: usersSchema });
+const { params, clamped } = list.read(new URLSearchParams(location.search));
+const next = list.actions(new URLSearchParams(location.search)).setPage(2); // a new URLSearchParams
+history.pushState(null, "", `?${next}`);
+```
+
 ## SSR — `fromSearchParams` (no hook)
 
 For server components / `getServerSideProps` — a payload straight from the URL:
@@ -357,6 +468,8 @@ const cur = users.parseCursor(curRes.data); // cur.meta.nextCursor, cur.meta.has
 
 ### TanStack `useQuery` (offset)
 
+> Ready-made options: [`@querykitjs/tanstack-query`](../tanstack-query/README.en.md) builds these objects for you — `listOptions`, `infiniteOptions`, `cursorOptions` (key, fetch, meta parsing, page params).
+
 ```tsx
 import { useQuery } from "@tanstack/react-query";
 const users = qk.resource<IUser>("users");
@@ -465,6 +578,59 @@ createRegistry({ adapter: "drizzle-pg", defaults: { maxPerPage: 50, maxLimit: 25
 createQuery({ maxPerPage: Infinity });
 ```
 
+## Limits
+
+`perPage`/`limit` are clamped (above), but **page depth** and the **number of sort fields** are not — the builder throws an `Error`, because silently cutting them would change what the request means (another page, another order). The values come from `@querykitjs/core`, the same as in zod and class-validator.
+
+| Limit           | Default  | What counts                                          | Past it                                                               |
+| --------------- | -------- | ---------------------------------------------------- | --------------------------------------------------------------------- |
+| `maxOffset`     | `10 000` | `list`: `(page - 1) × perPage`; `infinite`: `offset` | `Error: querykit: page 502 × perPage 20 exceeds maxOffset (10000); …` |
+| `maxSortFields` | `3`      | `sort` fields after normalization                    | `Error: querykit: sort with 4 fields exceeds maxSortFields (3)`       |
+
+```ts
+buildListParams({ page: 501, perPage: 20 }); // ✅ offset 10 000
+buildListParams({ page: 502, perPage: 20 }); // ❌ Error — use buildCursorParams for deeper pages
+
+createQuery({ maxOffset: 50_000, maxSortFields: 4 });
+createRegistry({ adapter: "drizzle-pg", defaults: { maxOffset: 50_000 } });
+```
+
+- Filter limits (depth, conditions, `in` items, string length) are **not** checked in web — the server (zod / class-validator) rejects them with a 400.
+- **The URL readers clamp.** The URL is in the user's hands, so `readListParams`, `searchParamsToPayload`, `resource.fromSearchParams` and the hooks (`useListParams`, `useListParamsBase`) never throw: `page` becomes the last allowed page (`floor(maxOffset / perPage) + 1`), `sort` keeps its first `maxSortFields` fields, and the result has `clamped: true`. `?page=9999&size=20` → `page: 501`, `clamped: true`; `?sortType=a,b,c,d` → 3 fields, `clamped: true`. Through a registry, the registry's `defaults` limits apply.
+
+```ts
+const read = readListParams(schema, new URLSearchParams("page=9999&size=20")); // { page: 501, perPage: 20, clamped: true, … }
+const body = users.fromSearchParams(sp, { schema }); // body.clamped === true
+JSON.stringify(body); // no clamped — it is non-enumerable on the payload and never reaches the server
+const { params, clamped } = useListParams(users, { schema }); // no error during render
+```
+
+Builders the developer calls directly (`buildListParams`, `resource.list`, …) still throw an `Error`.
+
+## Migrating (limits)
+
+- `buildListParams` / `buildInfiniteParams` / `createQuery` / registry `list`/`infinite` now throw for an offset deeper than 10 000 or more than 3 sort fields (they used to build the payload and the server accepted it). Use a cursor for deep pages; raise `maxOffset` / `maxSortFields` where you must (and raise the same limit on the server).
+
+- `Meta.totalCount` / `Meta.totalPages` are now `number | null` (`null` in a `withTotal: false` response). Code like `meta.totalCount + 1` needs a `null` check in TS; in an app that never sends `withTotal` the value is a number as before.
+- A deep `page` read from the URL is now clamped (`clamped: true`), not an error — no error boundary or manual check needed.
+
+## Errors — `isQueryKitError`
+
+When the server rejects a request (`forbidden-key`, `forbidden-operator`, `limit-exceeded`, `empty-filter`, …), the backend may return `QueryKitError.info` in its 400 response. The envelope is the project's own; web only types the `info` shape:
+
+```ts
+import { isQueryKitError, type QueryKitErrorBody } from "@querykitjs/web";
+
+// backend: catch (e) { if (e instanceof QueryKitError) return res.status(400).json({ error: e.info }); }
+const body = error.response?.data?.error;
+if (isQueryKitError(body)) {
+  // body: { reason, site, key, source?, operation? }
+  if (body.reason === "forbidden-key" && body.site === "filter") showFieldError(body.key);
+}
+```
+
+`isQueryKitError` checks `reason` and `site` against the core lists and `key` is a string; any other object (e.g. `{ statusCode: 400, message }`) → `false`.
+
 ## You send the request yourself
 
 The library works only **up to the request**. No transport:
@@ -486,7 +652,7 @@ const { data, meta } = users.parseList(await res.json());
 | `registry.resource<T>(name)`                                                      | entity-typed builders/filters/schema/keys/parsers       |
 | `resource.list/infinite/cursor/params(input)`                                     | build a payload (offset/infinite/cursor/paginationless) |
 | `resource.f` / `createFilters<T>()` / `f`                                         | typed filter builder / typed / untyped                  |
-| `resource.search(term, fields)`                                                   | OR-of-contains preset                                   |
+| `resource.search(term, fields, { operation? })`                                   | OR preset (`contains` / `startsWith` / `endsWith`)      |
 | `resource.schema(desc)` / `defineListSchema(desc)`                                | URL param → filter descriptor                           |
 | `resource.fromSearchParams(sp, {schema})`                                         | searchParams → list payload (SSR)                       |
 | `resource.keys`                                                                   | TanStack/SWR query keys                                 |
@@ -495,12 +661,16 @@ const { data, meta } = users.parseList(await res.json());
 | `buildParams / buildListParams / buildInfiniteParams / buildCursorParams`         | standalone builders                                     |
 | `createQuery(config)`                                                             | builder without a registry (defaults/pruneEmpty)        |
 | `schemaToFilter(schema, sp)`                                                      | searchParams → `FieldCondition[]`                       |
-| `searchParamsToPayload(schema, sp)`                                               | searchParams → full payload                             |
-| `readListParams(schema, sp)`                                                      | searchParams → `ListParams`                             |
+| `searchParamsToPayload(schema, sp)`                                               | searchParams → full payload (clamped, `clamped`)        |
+| `readListParams(schema, sp, url?, limits?)`                                       | searchParams → `ListParams` + `clamped`                 |
+| `isQueryKitError(body)` / `QueryKitErrorBody`                                     | recognise a querykit error in a 400 response            |
 | `setParam/setPage/setSize/setSort/resetParams`                                    | write URL (immutable, page-reset)                       |
 | `encodeSort/decodeSort`                                                           | `[{key,direction}]` ↔ `"-createdAt,id"` (multi-field)   |
-| `useListParams(resource, {schema})` (`/react`)                                    | URL-sync hook (react-router-dom)                        |
+| `useListParams(resource, {schema})` (`/react`)                                    | URL-sync hook (react-router)                            |
 | `useListParamsBase(resource, {schema, searchParams, setSearchParams})` (`/react`) | router-agnostic hook                                    |
+| `useListParams` / `useListParamsBase` (`/vue`)                                    | the same as Vue composables (computed refs)             |
+| `injectListParams` / `injectListParamsBase` (`/angular`)                          | the same as Angular signals                             |
+| `createListState(resource, {schema, url?, with?})`                                | framework-free `read(sp)` / `actions(sp)`               |
 
 ## Development