@picked/client 0.0.70-next.6 → 0.0.71-next.1

package/dist/docs/api/error-handling.md

@@ -2,13 +2,16 @@
 layout: docs
 ---
 
-# Error handling
+# Errors
 
-The Picked API returns errors using the standard GraphQL error format. This guide covers the error response shape, all error codes, and practical strategies for handling errors.
+The Picked API returns an error in the standard GraphQL format. This guide covers the
+shape of an error response, every error code, and what your code must do with each
+one.
 
 ## Error response shape
 
-When an operation fails, the API returns an `errors` array in the response body. Each error object contains:
+When an operation fails, the API returns an `errors` array in the response body. Each
+error object holds these fields:
 
 ```json
 {
@@ -27,29 +30,31 @@ When an operation fails, the API returns an `errors` array in the response body.
 
 | Field | Description |
 |-------|-------------|
-| `message` | A human-readable error description. Suitable for logging but not for programmatic handling. |
-| `path` | The path to the field in the query that caused the error. |
-| `extensions.code` | A machine-readable error code. Use this for programmatic error handling. |
+| `message` | A description of the error that a person can read. Put it in your log. Do not write code against it. |
+| `path` | The path to the field in the query that made the error. |
+| `extensions.code` | An error code that a machine can read. Write your code against this field. |
 
-Multiple errors may appear in a single response. The `data` field may be `null` if the entire operation failed, or it may contain partial data if only some fields failed.
+One response can hold more than one error. The `data` field is `null` when the whole
+operation failed. It holds part of the data when only some fields failed.
 
 ## Authentication error codes
 
-These errors relate to session creation, account management, OAuth, magic links, password operations, and MFA. They map to the `AuthErrorCode` enum in the schema.
+These errors come from a session, an account, OAuth, a magic link, a password
+operation, or MFA. They match the `AuthErrorCode` enum in the schema.
 
 | Code | Description |
 |------|-------------|
-| `INVALID_CREDENTIALS` | The email/password combination is incorrect. |
-| `EMAIL_NOT_CONFIRMED` | The account exists but the email address has not been verified. See [Authentication](/api/authentication#email-verification). |
-| `USER_NOT_FOUND` | No account exists with the provided email address. |
-| `USER_ALREADY_EXISTS` | An account with this email already exists. Returned during account creation. |
-| `WEAK_PASSWORD` | The provided password does not meet strength requirements. |
-| `INVALID_TOKEN` | The token (verification, reset, or magic link) is invalid or malformed. |
-| `TOKEN_EXPIRED` | The token has expired. The caller should request a new one. |
-| `MFA_CHALLENGE_FAILED` | The MFA verification code is incorrect. |
-| `MFA_FACTOR_NOT_FOUND` | The specified MFA factor does not exist or does not belong to the caller. |
-| `OAUTH_PROVIDER_ERROR` | An error occurred communicating with the OAuth provider (e.g., Google). |
-| `RATE_LIMITED` | Too many requests in a short period. The caller should wait and retry. |
+| `INVALID_CREDENTIALS` | The email address and the password do not match. |
+| `EMAIL_NOT_CONFIRMED` | The account is there, but nobody verified the email address. See [Authentication](/api/authentication#verify-an-email-address). |
+| `USER_NOT_FOUND` | There is no account with that email address. |
+| `USER_ALREADY_EXISTS` | An account with that email address is there already. The API returns this when you create an account. |
+| `WEAK_PASSWORD` | The password is not strong enough. |
+| `INVALID_TOKEN` | The token is invalid or malformed. This covers a verification token, a reset token, and a magic link token. |
+| `TOKEN_EXPIRED` | The token expired. Ask for a new one. |
+| `MFA_CHALLENGE_FAILED` | The MFA verification code is not correct. |
+| `MFA_FACTOR_NOT_FOUND` | That MFA factor is not there, or it belongs to another caller. |
+| `OAUTH_PROVIDER_ERROR` | The exchange with the OAuth provider, such as Google, failed. |
+| `RATE_LIMITED` | Too many requests in a short period. Wait, then try again. |
 
 ### Example: invalid credentials
 
@@ -76,16 +81,18 @@ These errors relate to session creation, account management, OAuth, magic links,
 
 ## Authorization error codes
 
-Authorization errors occur when the caller lacks the required [scope](./authorization-and-scopes.md) for an operation.
+An authorization error happens when the caller does not hold the
+[scope](./authorization-and-scopes.md) that an operation needs.
 
 | Code | Description |
 |------|-------------|
-| `UNAUTHORIZED` | No valid authentication was provided. The request is missing the `Authorization` header or the `x-api-key` header, or the token/key is invalid. |
-| `FORBIDDEN` | The caller is authenticated but does not have the required scope for the operation. |
+| `UNAUTHORIZED` | The request carries no valid authentication. It has no `Authorization` header and no `x-api-key` header, or the token is invalid. |
+| `FORBIDDEN` | The caller is authenticated, but it does not hold the scope that the operation needs. |
 
-### Example: insufficient scope
+### Example: the scope is not enough
 
-A caller with only `organization/read` attempting to delete an organization receives:
+A caller that holds `organization/read` only tries to delete an organization. It
+receives this:
 
 ```json
 {
@@ -106,52 +113,53 @@ A caller with only `organization/read` attempting to delete an organization rece
 
 ## Organization, member, and invitation error codes
 
-These errors relate to organization management, member operations, and invitation workflows. They map to the `ErrorCode` enum in the schema.
+These errors come from an organization, a member operation, or an invitation. They
+match the `ErrorCode` enum in the schema.
 
 ### Organization errors
 
 | Code | Description |
 |------|-------------|
-| `ORGANIZATION_NOT_FOUND` | The specified organization does not exist or the caller does not have access to it. |
-| `ORGANIZATION_ALREADY_EXISTS` | An organization with this name already exists. |
-| `SLUG_ALREADY_EXISTS` | The requested slug is already in use by another organization. |
-| `INVALID_SLUG` | The slug contains invalid characters. Slugs must be lowercase alphanumeric with hyphens. |
+| `ORGANIZATION_NOT_FOUND` | That organization is not there, or the caller cannot reach it. |
+| `ORGANIZATION_ALREADY_EXISTS` | An organization with that name is there already. |
+| `SLUG_ALREADY_EXISTS` | Another organization uses that slug already. |
+| `INVALID_SLUG` | The slug holds an invalid character. A slug takes lowercase letters, digits, and hyphens only. |
 
 ### Member errors
 
 | Code | Description |
 |------|-------------|
-| `MEMBER_NOT_FOUND` | The specified user is not a member of the organization. |
-| `MEMBER_ALREADY_EXISTS` | The user is already a member of the organization. |
-| `CANNOT_REMOVE_PRIMARY_OWNER` | The primary owner of an organization cannot be removed. |
-| `CANNOT_CHANGE_OWN_ROLE` | A member cannot change their own role. Another owner must perform this action. |
+| `MEMBER_NOT_FOUND` | That user is not a member of the organization. |
+| `MEMBER_ALREADY_EXISTS` | The user is a member of the organization already. |
+| `CANNOT_REMOVE_PRIMARY_OWNER` | You cannot remove the primary owner of an organization. |
+| `CANNOT_CHANGE_OWN_ROLE` | A member cannot change the role of that same member. Another owner must do it. |
 
 ### Invitation errors
 
 | Code | Description |
 |------|-------------|
-| `INVITATION_NOT_FOUND` | The specified invitation does not exist. |
-| `INVITATION_EXPIRED` | The invitation has expired and can no longer be accepted. |
-| `INVITATION_ALREADY_ACCEPTED` | The invitation has already been accepted. |
+| `INVITATION_NOT_FOUND` | That invitation is not there. |
+| `INVITATION_EXPIRED` | The invitation expired. Nobody can accept it now. |
+| `INVITATION_ALREADY_ACCEPTED` | Somebody accepted the invitation already. |
 
 ### Project errors
 
 | Code | Description |
 |------|-------------|
-| `PROJECT_NOT_FOUND` | The specified project does not exist or the caller does not have access. |
+| `PROJECT_NOT_FOUND` | That project is not there, or the caller cannot reach it. |
 
 ### General errors
 
 | Code | Description |
 |------|-------------|
-| `VALIDATION_ERROR` | The input failed validation. Check the `message` field for details about which field is invalid. |
-| `INTERNAL_ERROR` | An unexpected server error occurred. Retry the request or contact support if the issue persists. |
+| `VALIDATION_ERROR` | The input failed a validation rule. Read the `message` field to learn which field is invalid. |
+| `INTERNAL_ERROR` | The server met an unexpected error. Try the request again. Contact support when the error continues. |
 
-## Handling errors in practice
+## What your code must do
 
-### Check for errors first
+### Look for an error first
 
-Every response should be checked for the presence of an `errors` array before processing `data`:
+Check every response for an `errors` array before you read `data`:
 
 ```javascript
 const response = await fetch('/graphql', {
@@ -171,41 +179,49 @@ if (result.errors) {
 
     switch (code) {
       case 'UNAUTHORIZED':
-        // Redirect to login
+        // Send the user to the sign-in page.
         break;
       case 'FORBIDDEN':
-        // Show a permissions error
+        // Show a permissions error.
         break;
       case 'RATE_LIMITED':
-        // Wait and retry
+        // Wait, then try again.
         break;
       default:
-        // Log or display the error message
+        // Put the message in the log, or show it.
         console.error(error.message);
     }
   }
 }
 ```
 
-### Refresh expired tokens
+### Refresh a token that expired
 
-If a request returns `UNAUTHORIZED` and the caller has a refresh token, attempt a [session refresh](/api/authentication#session-refresh) before treating it as a login failure:
+A request can return `UNAUTHORIZED` while the caller holds a refresh token. Try a
+[session refresh](/api/authentication#refresh-a-session) first. Do not treat it as a
+failure to sign in:
 
 ```javascript
 if (code === 'UNAUTHORIZED' && refreshToken) {
   const refreshResult = await sessionRefresh(refreshToken);
   if (refreshResult.session) {
-    // Retry the original request with the new access token
+    // Try the first request again with the new access token.
   } else {
-    // Redirect to login
+    // Send the user to the sign-in page.
   }
 }
 ```
 
-### Handle partial data
+### Read data that is only part complete
 
-GraphQL can return partial data alongside errors. For example, a query that fetches an organization and its members might succeed for the organization but fail for the members if the caller lacks `organization_members/read`. In this case, the response contains both `data` (with the organization) and `errors` (for the members field). Always check both.
+GraphQL can return part of the data together with an error. Take a query that reads
+an organization and its members. It can succeed for the organization and fail for the
+members, when the caller does not hold `organization_members/read`. The response then
+holds `data` with the organization, and `errors` for the members field. Always read
+both.
 
-### Retry transient failures
+### Try again after a transient failure
 
-`INTERNAL_ERROR` and `RATE_LIMITED` are transient. For `RATE_LIMITED`, implement exponential backoff before retrying. For `INTERNAL_ERROR`, a single retry is usually sufficient.
+`INTERNAL_ERROR` and `RATE_LIMITED` are both transient. For `RATE_LIMITED`, use an
+exponential backoff before you try again. For `INTERNAL_ERROR`, one more try is
+usually enough.

package/dist/docs/api/index.md

@@ -2,17 +2,21 @@
 layout: docs
 ---
 
-# Getting started
+# Start here
 
-This guide walks you through your first interactions with the Picked GraphQL API, from sending a simple ping to making authenticated queries and mutations.
+This guide takes you through your first calls to the Picked GraphQL API. It starts
+with a ping and ends with an authenticated query and mutation.
 
 :::note
-This reference covers the authenticated GraphQL management API. To serve your published config and page content to your app, use the public, read-only [Delivery API](/delivery-api) instead.
+This reference covers the GraphQL API that needs authentication. To serve your
+published options and page content to your application, use the public
+[Delivery API](/delivery-api), which is read-only.
 :::
 
 ## Playground
 
-Explore the API and run queries interactively in the [GraphQL Playground](https://api.picked.app/api/graphql).
+Read the API and run a query in the
+[GraphQL Playground](https://api.picked.app/api/graphql).
 
 ## API endpoint
 
@@ -22,7 +26,8 @@ All requests go to a single endpoint:
 POST https://api.picked.app/api/graphql
 ```
 
-Every request must use the `POST` method with a JSON body containing a `query` field and an optional `variables` field:
+Every request must use the `POST` method. The JSON body must hold a `query` field,
+and it can also hold a `variables` field:
 
 ```json
 {
@@ -41,7 +46,8 @@ curl -X POST https://api.picked.app/api/graphql \
 
 ## Ping the API
 
-Verify that the API is reachable with the `ping` query. This query does not require authentication.
+Check that the API is reachable with the `ping` query. This query needs no
+authentication.
 
 ```graphql
 query {
@@ -59,11 +65,12 @@ Response:
 }
 ```
 
-If you receive this response, the API is up and ready.
+This response means that the API is ready.
 
 ## Authenticate
 
-Most operations require an access token. You obtain one by creating a session with your email and password.
+Most operations need an access token. To get one, create a session with your email
+address and your password.
 
 ```graphql
 mutation {
@@ -81,7 +88,8 @@ mutation {
 }
 ```
 
-A successful response returns a `Session` containing an `accessToken` and a `refreshToken`:
+A successful response returns a `Session` with an `accessToken` and a
+`refreshToken`:
 
 ```json
 {
@@ -98,9 +106,12 @@ A successful response returns a `Session` containing an `accessToken` and a `ref
 }
 ```
 
-If `requiresMfa` is `true`, you need to complete the MFA challenge before receiving a session. See the [Authentication](./authentication.md) guide for details.
+When `requiresMfa` is `true`, you must complete the MFA challenge before you receive
+a session. See the [Authentication](./authentication.md) guide.
 
-For server-to-server integrations, prefer [API key authentication](/api/authentication#api-key-authentication) over session tokens.
+For a server-to-server integration, use
+[API key authentication](/api/authentication#api-key-authentication) and not a
+session token.
 
 ## Make an authenticated query
 
@@ -110,7 +121,8 @@ Pass the access token in the `Authorization` header as a Bearer token:
 Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
 ```
 
-Now you can query resources that require authentication. For example, fetch your user profile:
+You can now query a resource that needs authentication. This example reads your user
+profile:
 
 ```graphql
 query {
@@ -132,7 +144,8 @@ query {
 
 ## Make a mutation
 
-Mutations follow the same pattern: send a `POST` request with the `Authorization` header. For example, create an organization:
+A mutation follows the same pattern. Send a `POST` request with the `Authorization`
+header. This example creates an organization:
 
 ```graphql
 mutation {
@@ -165,11 +178,14 @@ Response:
 }
 ```
 
-Every mutation accepts an `input` argument and returns a payload object. The payload contains the created or updated resource on success, or errors in the top-level `errors` array on failure.
+Every mutation takes an `input` argument and returns a payload object. On success the
+payload holds the resource that the mutation created or updated. On failure the
+`errors` array at the top level holds the errors.
 
-## Error handling basics
+## Errors
 
-When something goes wrong, the API returns errors in the standard GraphQL `errors` array:
+When something goes wrong, the API returns the errors in the standard GraphQL
+`errors` array:
 
 ```json
 {
@@ -185,13 +201,16 @@ When something goes wrong, the API returns errors in the standard GraphQL `error
 }
 ```
 
-Check the `extensions.code` field for a machine-readable error code you can use to handle specific failures programmatically. See the [Error Handling](./error-handling.md) guide for the full list of error codes.
+Read the `extensions.code` field. It holds an error code that your code can act on.
+See the [Errors](./error-handling.md) guide for the full list of codes.
 
 ## Next steps
 
-Now that you can authenticate and make requests, explore these guides to go deeper:
+You can now authenticate and make a request. These guides go into more detail:
 
-- [Authentication](./authentication.md) — email/password, OAuth, magic links, MFA, API keys, and session management
-- [Authorization and Scopes](./authorization-and-scopes.md) — understand what each role can access and how scopes control permissions
-- [Pagination](./pagination.md) — navigate large result sets with cursor-based pagination
-- [Error Handling](./error-handling.md) — handle every error code the API can return
+- [Authentication](./authentication.md) — an email address and a password, OAuth,
+  magic links, MFA, API keys, and how to control a session.
+- [Authorization and Scopes](./authorization-and-scopes.md) — what each role can
+  reach, and how a scope controls a permission.
+- [Pagination](./pagination.md) — how to move through a large result with a cursor.
+- [Errors](./error-handling.md) — every error code that the API can return.

package/dist/docs/api/pagination.md

@@ -4,11 +4,13 @@ layout: docs
 
 # Pagination
 
-The Picked API uses Relay-style cursor-based pagination for all list fields that may return large result sets. This guide explains the connection pattern and demonstrates how to paginate through results.
+The Picked API paginates every list field that can return a large result. It uses a
+cursor, in the Relay-style pattern. This guide covers the connection pattern and
+shows how to move through a result.
 
 ## Connection pattern
 
-Paginated fields return a **connection** object with the following shape:
+A paginated field returns a **connection** object with this shape:
 
 ```graphql
 type ExampleConnection {
@@ -32,20 +34,21 @@ type PageInfo {
 
 | Field | Description |
 |-------|-------------|
-| `edges` | An ordered list of edges, each containing a `cursor` and a `node` (the actual data object) |
-| `pageInfo.hasNextPage` | `true` if more results exist after the last edge |
-| `pageInfo.hasPreviousPage` | `true` if results exist before the first edge |
-| `pageInfo.startCursor` | Cursor of the first edge in the current page |
-| `pageInfo.endCursor` | Cursor of the last edge in the current page |
-| `totalCount` | Total number of items across all pages |
+| `edges` | An ordered list of edges. Each edge holds a `cursor` and a `node`, and the `node` holds the data. |
+| `pageInfo.hasNextPage` | `true` when more results come after the last edge |
+| `pageInfo.hasPreviousPage` | `true` when results come before the first edge |
+| `pageInfo.startCursor` | The cursor of the first edge on the current page |
+| `pageInfo.endCursor` | The cursor of the last edge on the current page |
+| `totalCount` | The number of items on every page together |
 
 ## Forward pagination with `first` and `after`
 
-To paginate forward through results, use the `first` argument to specify the page size and the `after` argument to specify the cursor to start after.
+To move forward through the results, use two arguments. The `first` argument gives
+the page size. The `after` argument gives the cursor to start after.
 
 ### First page
 
-Omit the `after` argument to fetch the first page:
+Leave the `after` argument out to read the first page:
 
 ```graphql
 query {
@@ -89,16 +92,17 @@ query {
 }
 ```
 
-## Checking for more pages
+## Check for more pages
 
-Before requesting the next page, check the `hasNextPage` field:
+Read the `hasNextPage` field before you ask for the next page:
 
-- `hasNextPage: true` — more results are available; pass `endCursor` to the next request's `after` argument
-- `hasNextPage: false` — all results have been fetched; stop paginating
+- `hasNextPage: true` — more results are available. Pass `endCursor` as the `after`
+  argument of the next request.
+- `hasNextPage: false` — you read every result. Stop here.
 
 ## Full paginated query example
 
-The following example fetches all members of an organization, page by page:
+This example reads every member of an organization, one page at a time:
 
 ```graphql
 # Page 1
@@ -154,7 +158,8 @@ Continue until `hasNextPage` returns `false`.
 
 ## Paginated fields
 
-The following fields in the schema return connection types and support `first`/`after` pagination:
+These fields in the schema return a connection type. They all take the `first` and
+`after` arguments:
 
 | Parent Type | Field | Connection Type |
 |------------|-------|----------------|
@@ -170,7 +175,12 @@ All of these fields accept the same `first` and `after` arguments and return the
 
 ## Tips
 
-- **Default page size** — if `first` is omitted, the API applies a default limit. Explicitly setting `first` ensures predictable page sizes.
-- **Cursors are opaque** — cursor strings should be treated as opaque tokens. Do not parse, construct, or modify them. Pass them exactly as received from the API.
-- **Stable ordering** — results within a connection are returned in a stable order. The same cursor always refers to the same position in the result set.
-- **Combine with other fields** — pagination arguments can be used alongside other query fields. For example, fetching an organization and its first page of members in a single request is common and efficient.
+- **The default page size** — the API applies a default limit when you leave `first`
+  out. Set `first` yourself to make sure that each page has the size you expect.
+- **A cursor is opaque** — treat a cursor string as an opaque token. Do not parse it,
+  build it, or change it. Pass it back exactly as the API gave it.
+- **The order is stable** — a connection returns its results in a stable order. The
+  same cursor always points at the same position in the result.
+- **Use them with other fields** — you can use the pagination arguments together with
+  other query fields. One request that reads an organization and the first page of
+  its members is common, and it is efficient.

package/dist/docs/api-keys.mdx

@@ -6,7 +6,8 @@ import { Screenshot } from '../../components/Screenshot'
 
 # API keys
 
-API keys let you access Picked's API programmatically. Use them for server-side integrations or CI/CD workflows.
+An API key lets your code reach the Picked API. Use one for a server-side integration
+or for a CI/CD workflow.
 
 <Screenshot
   route="/{orgSlug}/api-keys"
@@ -21,11 +22,12 @@ API keys let you access Picked's API programmatically. Use them for server-side
 4. Enter a description.
 5. Click **Create**.
 
-Copy the key immediately — it won't be shown again.
+Copy the key immediately. The dashboard does not show it again.
 
-## Using an API key
+## Use an API key
 
-Include your API key in the `Authorization` header when making requests to the [Picked API](/api).
+Put your API key in the `Authorization` header of each request to the
+[Picked API](/api).
 
 ```
 Authorization: Bearer your-api-key
@@ -33,8 +35,11 @@ Authorization: Bearer your-api-key
 
 ## Scopes
 
-API keys can be scoped to limit what they can access. When creating a key, select the scopes that match your integration's needs. A key can only perform actions allowed by its assigned scopes.
+An API key carries scopes, and the scopes limit what the key can reach. Choose the
+scopes that your integration needs when you create the key. A key can do only the
+operations that its scopes permit.
 
 ## Revoke a key
 
-Revoke a key at any time from the API keys list. Click the revoke button next to the key you want to disable. Revoked keys stop working immediately.
+You can revoke a key at any time from the API keys list. Click the revoke button next
+to the key. A revoked key stops work immediately.

package/dist/docs/chrome-extension.md

@@ -4,17 +4,21 @@ layout: docs
 
 # Chrome Extension
 
-The Picked Developer Tools extension adds a Picked panel to Chrome DevTools for inspecting and debugging your Picked integration on any page running the SDK.
+The extension for the Picked Developer Tools adds a Picked panel to Chrome DevTools.
+Use the panel to check and debug your Picked integration on any page that runs the
+SDK.
 
 ![Picked Developer Tools](/chrome-extension-screenshot.jpg)
 
 ## Installation
 
-Install from the [Chrome Web Store](https://chromewebstore.google.com/detail/picked-developer-tools/nimmdamgnhlhdpngnalkpmnleebngidh).
+Install the extension from the
+[Chrome Web Store](https://chromewebstore.google.com/detail/picked-developer-tools/nimmdamgnhlhdpngnalkpmnleebngidh).
 
 ## Setup
 
-Add the `svelteDevtoolsPlugin` to your Picked client so the extension can connect to the SDK.
+Add the `svelteDevtoolsPlugin` to your Picked client. The extension then connects to
+the SDK.
 
 ```typescript
 import { createPicked } from '@picked/client'
@@ -30,7 +34,16 @@ const picked = createPicked({
 
 ## Custom Tools
 
-You can extend the Developer Tools with your own project-specific tools, surfaced under a **Custom Tools** tab. Each tool is a framework-adapted component — authored with the same `adaptReactComponent` / `adaptSvelteComponent` helpers you already use — so you can build it in your app's framework and it receives the live Picked client exactly like an experience component does (React: `usePicked()`; Svelte: `getPicked()`). Tools can both read client state and call client methods.
+You can extend the Developer Tools with your own tools for one project. They appear
+under a **Custom Tools** tab.
+
+Each tool is a framework-adapted component. Write it with the same
+`adaptReactComponent` or `adaptSvelteComponent` helper that you already use. You can
+therefore build the tool in the framework of your application.
+
+The tool receives the live Picked client, exactly as an experience component does. In
+React, use `usePicked()`. In Svelte, use `getPicked()`. A tool can read client state
+and call client methods.
 
 ```typescript
 import { createPicked } from '@picked/client'
@@ -48,4 +61,8 @@ const picked = createPicked({
 })
 ```
 
-The Developer Tools shell is rendered with Svelte, so a tool's framework must also be registered on the client. A React app needs `reactFrameworkPlugin` (for the tool) alongside the Svelte framework and `svelteDevtoolsPlugin` (for the shell). If a tool's framework isn't registered, its tab shows a warning instead of rendering.
+Svelte renders the Developer Tools shell, so you must also register the framework of
+your tool on the client. A React application needs `reactFrameworkPlugin` for the
+tool, together with the Svelte framework and `svelteDevtoolsPlugin` for the shell.
+When the framework of a tool is not registered, the tab of that tool shows a warning
+and no content.