@tempoxyz/auth 0.0.0-pr-61.sha-1a0da9d → 0.0.0-pr-62.sha-8ef1ef2

package/README.md

@@ -1,29 +1,29 @@
 # @tempoxyz/auth
 
-Sign users in to Tempo through Tempo Auth, and get back their tokens for Tempo APIs and a [viem](https://viem.sh) access key account on their Tempo Account.
+Signs users in to Tempo through [Tempo Auth](../../docs/README.md), and returns their tokens for Tempo APIs and a [Viem](https://viem.sh) access key account on their Tempo Account.
 
-Every sign-in returns the same `Authorization`. Send transactions with its `account` through viem, and call Tempo APIs with its `accessToken`.
+## Overview
 
 ```ts
 import { Actions, Auth } from '@tempoxyz/auth'
 import { createClient, Expiry, Scopes } from 'viem/tempo'
-import { tempo, tempoTestnet } from 'viem/tempo/chains'
 import * as Tokens from 'viem/tokens'
 
-// OUSD has its mainnet address on every Tempo chain.
-const ousd = Tokens.ousd(tempo.id).address
+const client = createClient()
+const ousd = Tokens.ousd(client.chain.id).address
 
 const auth = Auth.create({
-  chainId: tempoTestnet.id,
+  chainId: client.chain.id,
   clientId: 'client_…',
-  url: 'https://auth.tempo.xyz',
-})
-const client = createClient({
-  chain: tempoTestnet,
-  feeToken: ousd,
 })
 
-const authorization = await Actions.authorize(auth, {
+// 1. Email the user a sign-in code.
+await Actions.email.sendCode(auth, { email: 'user@example.com' })
+
+// 2. Sign in with the code, and authorize an access key.
+const result = await Actions.email.signIn(auth, {
+  code: '123456',
+  email: 'user@example.com',
   permissions: {
     expiry: Expiry.days(1),
     limits: [{ limit: 10_000_000n, token: ousd }],
@@ -31,264 +31,28 @@ const authorization = await Actions.authorize(auth, {
   },
 })
 
-await client.token.transferSync({
-  account: authorization!.account,
-  amount: 10_000n,
-  to: '0x…',
-  token: ousd,
-})
-```
-
-## Install
-
-```bash
-pnpm add @tempoxyz/auth viem
-```
-
-## Before you start
-
-- **Register the app.** Create a WorkOS Connect app in the Tempo Issuer environment, and register every redirect URI it uses. Its `client_id` is the `clientId` that `Auth.create` takes. An app with a backend also receives a client secret.
-- **Allow the app's origin.** Tempo Auth allows the origins of every first-party Connect app's `http(s)` redirect URIs, within about three minutes of a change. A mobile app has no origin, and registers its custom scheme as its redirect URI instead.
-
-The CLI device grant needs neither. It signs in as Tempo Auth's own `tempo-cli` app.
-
-## Access keys
-
-Each sign-in creates a key for the app and requests that Tempo Auth authorize it on the user's Tempo Account. The optional `permissions` option specifies what the key may do, with viem's `Expiry` and `Scopes` helpers. Tempo Auth fills every field it leaves out with the headless ceiling:
-
-| Field     | Meaning                                                                                                     |
-| --------- | ----------------------------------------------------------------------------------------------------------- |
-| `chainId` | The chain the key acts on. Defaults to the instance's `chainId`                                             |
-| `expiry`  | When the key expires, in Unix seconds, such as `Expiry.days(1)`. Defaults to a year                         |
-| `limits`  | One-time spending limits per token, such as `[{ limit: 10_000_000n, token }]`. Defaults to about $1,000 of each token the `scopes` call, or of OUSD |
-| `scopes`  | The calls the key may make, such as `[Scopes.tip20(token).transfer()]`. Defaults to transfers of each token the key limits |
-
-In a browser, the key is a non-extractable WebCrypto P256 key, so no script can read its private key. A CLI, a native app, or a backend uses a secp256k1 key, which it stores as a string.
-
-To authorize a key the app already holds, pass it as `accessKey`, a viem account. The library never reads its private key. Its `access` names the Tempo Account, which defaults to the user's first:
-
-```ts
-const accessKey = Account.fromWebCryptoP256(keyPair, { access: tempoAccount })
-await Actions.authorize(auth, { accessKey })
-```
-
-Flows without a Tempo Auth page (`authorize`, `email.signIn`) must stay within Tempo Auth's ceiling: about $1,000 per token, for at most a year. [Permissions](../../docs/permissions.md) explains the defaults and the bounds on each flow. Flows with a page (`redirect.start`, `redirect.createUrl`, `device.authorize`) show the limits to the user, who approves them, so they may go beyond it.
-
-The returned `account` attaches the key's authorization to its first transaction, which registers the key on chain.
-
-## Flows
-
-### Your own sign-in UI
-
-For a browser app that renders its own email form. The page calls Tempo Auth with the user's Tempo Auth session, so it works across every app on the same site.
-
-```ts
-// A user already signed in to Tempo Auth, from any app, needs no form.
-const authorization = await Actions.authorize(auth)
-
-// Otherwise, sign in with an emailed code.
-await Actions.email.sendCode(auth, { email })
-const result = await Actions.email.signIn(auth, { code, email })
-
-// An address that requires SSO continues at its connection, and returns to this page.
+// 3. Send a transaction with the access key. An address that requires SSO
+//    returns a `step` instead, which continues at its connection.
 if ('step' in result) Actions.provider.signIn(auth, { url: result.step.url })
-```
-
-To offer OAuth providers such as Google, list the ones Tempo Auth enables and send the browser to one. It returns to the current page signed in, where `authorize` finishes.
-
-```ts
-const providers = await Actions.provider.list(auth) // [{ id: 'google', name: 'Google' }]
-Actions.provider.signIn(auth, { provider: 'google' })
-```
-
-### Tempo Auth's pages
-
-For a browser app without its own sign-in UI. The browser leaves for Tempo Auth's sign-in page, which shows the key's limits, and returns with a code.
-
-```ts
-await Actions.redirect.start(auth)
-
-// On the page the browser returns to, and on every load:
-const authorization = await Actions.redirect.complete(auth)
-```
-
-`redirect.start` keeps its state, with the new key, in IndexedDB until the browser returns. Pass `storage` to `Auth.create` to keep it elsewhere. An app that supplies `accessKey` passes it to `redirect.complete` too.
-
-### A mobile app
-
-For a React Native or Expo app. It calls the same actions as a browser app, with no `Origin`, and opens Tempo Auth's pages in the system browser, which returns to the app's custom scheme. Import `react-native-get-random-values` first, since keys need `crypto.getRandomValues`.
-
-```ts
-import * as WebBrowser from 'expo-web-browser'
-
-const auth = Auth.create({
-  clientId: 'client_…',
-  redirectUri: 'my-app://callback',
-  url: 'https://auth.tempo.xyz',
-})
-
-// Your own sign-in UI, as in a browser.
-await Actions.email.sendCode(auth, { email })
-const result = await Actions.email.signIn(auth, { code, email })
-
-// Or Tempo Auth's pages, which also offer Google and SSO.
-const { pending, url } = await Actions.redirect.createUrl(auth)
-const session = await WebBrowser.openAuthSessionAsync(url, auth.redirectUri)
-if (session.type === 'success')
-  authorization = await Actions.redirect.handleCallback(auth, {
-    pending,
-    url: session.url,
+else
+  await client.token.transferSync({
+    account: result.account,
+    amount: 10_000n,
+    to: '0x…',
+    token: ousd,
   })
 ```
 
-Keep the authorization in the device's secure store, as [Keep a sign-in](#keep-a-sign-in) describes.
+Every sign-in returns the same `Authorization`. Its `account` sends transactions through Viem, and its `accessToken` calls Tempo APIs.
 
-### A backend
-
-For an app whose server holds a client secret. The server builds the URL, keeps the pending state until the callback, and redeems the code itself.
-
-```ts
-const auth = Auth.create({ clientId, clientSecret, url })
-
-// GET /auth/start
-const { pending, url } = await Actions.redirect.createUrl(auth, {
-  redirectUri: 'https://app.example/auth/callback',
-})
-// Keep `pending` in an encrypted, HttpOnly cookie, then redirect to `url`.
-
-// GET /auth/callback
-const authorization = await Actions.redirect.handleCallback(auth, {
-  pending,
-  url: request.url,
-})
-```
-
-### A CLI
-
-For a command-line tool. The user approves a code in any browser, and the CLI waits.
-
-```ts
-const device = await Actions.device.authorize(auth, {
-  device: os.hostname(),
-})
-console.log(
-  `Open ${device.verificationUriComplete} and confirm ${device.userCode}.`,
-)
-const authorization = await device.wait()
-```
-
-## More Tempo Accounts
-
-A user starts with one Tempo Account and can have more. Add one, then name it in the `access` of the key the app authorizes:
-
-```ts
-const tempoAccount = await Actions.tempoAccount.create(auth)
-const accounts = await Actions.tempoAccount.list(auth) // the default first
-
-await Actions.authorize(auth, {
-  accessKey: Account.fromWebCryptoP256(keyPair, {
-    access: tempoAccount.address,
-  }),
-})
-```
-
-## Keep a sign-in
-
-`Authorization.key` is the app's key as data: the Tempo Account, the signed authorization, and the key the library created. Store it with the tokens, and rebuild the account later with `Key.toAccount`.
-
-- **Browser:** the key is a `CryptoKey` pair, which IndexedDB stores without exporting it.
-- **Elsewhere:** the key is a secp256k1 private key, as JSON. Store it as securely as a session.
-- **Supplied key:** the key holds no material. Pass the `accessKey` again, as `Key.toAccount(saved.key, { accessKey })`.
-
-```ts
-import { Actions, Key } from '@tempoxyz/auth'
-
-if (Key.expired(saved.key)) signInAgain()
-
-const account = Key.toAccount(saved.key)
-const tokens = await Actions.refresh(auth, {
-  refreshToken: saved.refreshToken,
-})
-```
-
-Refresh tokens rotate, so save the new tokens over the old ones after each refresh, such as `{ ...saved, ...tokens }`.
-
-## Errors
-
-A request Tempo Auth refuses throws `Auth.RequestError`. It carries the OAuth error code as `code`, and `message` states the fault and its fix. `reason`, `field`, and `meta` let an app branch on the refusal and read the values it compared. [Errors](../../docs/errors.md) lists every `reason`.
-
-```ts
-try {
-  await Actions.authorize(auth, { permissions })
-} catch (error) {
-  if (error instanceof Auth.RequestError && error.reason === 'limit_exceeds_maximum')
-    showMaximum(error.meta?.maximum) // in base units
-}
-```
-
-## Reference
-
-### `Auth.create(options)`
-
-| Option         | Meaning                                                                                         |
-| -------------- | ----------------------------------------------------------------------------------------------- |
-| `clientId`     | The app's Connect client ID. Required                                                           |
-| `chainId`      | The chain the app's keys act on, such as `tempoTestnet.id`. Defaults to Tempo mainnet           |
-| `url`          | Where Tempo Auth runs, such as `https://auth.tempo.xyz`. Required                               |
-| `clientSecret` | The app's client secret. Only a backend holds one                                               |
-| `redirectUri`  | Where Tempo Auth redirects back to. Defaults to the page's origin                               |
-| `scope`        | Scopes beyond `openid` and `email`, which every instance includes. Defaults to `offline_access` |
-| `storage`      | Where `redirect.start` keeps its state, without serializing it. Defaults to IndexedDB           |
-| `fetch`        | Calls Tempo Auth. Defaults to the global `fetch`                                                |
-
-The actions call version 1 of Tempo Auth's JSON API, under `/v1`. [API versions](../../docs/versioning.md) describes versions and compatibility.
-
-### `Actions`
-
-Each sign-in flow has its own namespace. The actions every flow shares sit at the top level. Every action that creates a key also takes optional `accessKey` and `permissions`.
-
-| Action                                                   | Returns                                                                    |
-| -------------------------------------------------------- | -------------------------------------------------------------------------- |
-| `authorize(auth)`                                        | An `Authorization` for a user already signed in, or `undefined`            |
-| `refresh(auth, { refreshToken })`                        | New `Tokens`                                                               |
-| `signOut(auth)`                                          | Nothing. The user's Tempo Auth session ends                                |
-| `device.authorize(auth, { device })`                     | The code to show and a `wait()` that resolves with an `Authorization`      |
-| `email.sendCode(auth, { email })`                        | Nothing. Tempo Auth emails a code                                          |
-| `email.signIn(auth, { code, email })`                    | An `Authorization`, or the `step` the address requires first               |
-| `provider.list(auth)`                                    | The OAuth providers Tempo Auth offers, as `{ id, name }`                   |
-| `provider.signIn(auth, { provider } \| { url })`         | Nothing. The browser leaves for the provider or SSO connection             |
-| `redirect.complete(auth, { accessKey })`                 | The `Authorization` when the page is a redirect's callback, or `undefined` |
-| `redirect.createUrl(auth, { redirectUri })`              | The `url` to send the browser to, and the `pending` state to keep          |
-| `redirect.handleCallback(auth, { pending, url })`        | The `Authorization` for a redirect's callback                              |
-| `redirect.start(auth)`                                   | Nothing. The browser leaves for Tempo Auth's pages                         |
-| `tempoAccount.create(auth)`                              | Another Tempo Account for the signed-in user                               |
-| `tempoAccount.list(auth)`                                | The signed-in user's Tempo Accounts, the default first                     |
-
-### `Authorization`
-
-| Field          | Meaning                                                                          |
-| -------------- | -------------------------------------------------------------------------------- |
-| `account`      | The user's Tempo Account, as a viem account that signs with the app's access key |
-| `key`          | The same key as data, for `Key.toAccount`                                        |
-| `accessToken`  | The Bearer token Tempo APIs accept                                               |
-| `expiresAt`    | When the access token expires, in milliseconds                                   |
-| `idToken`      | Optional: the OIDC ID token, which names the user                                |
-| `refreshToken` | Optional: exchanges for new tokens through `refresh`. It rotates each time       |
-| `user`         | The user's `email` and `id`, the `sub` of every token                            |
-
-### Types
-
-Each type an action takes or returns lives in its own module, exported beside `Actions`: `Authorization`, `Key`, `Pending`, `Permissions`, `Provider`, `Step`, `Storage`, `TempoAccount`, `Tokens`, and `User`. Each module's `from` builds a value of its type:
-
-```ts
-import { Permissions } from '@tempoxyz/auth'
+## Install
 
-const permissions = Permissions.from({ expiry: Expiry.days(1), limits, scopes })
+```bash
+pnpm add @tempoxyz/auth viem
 ```
 
-### `Key`
+## Documentation
 
-| Function                        | Returns                                                                         |
-| ------------------------------- | ------------------------------------------------------------------------------- |
-| `toAccount(key, { accessKey })` | The key as a viem access key account. `accessKey` is for a key the app supplied |
-| `expired(key)`                  | Whether the key's authorization has expired                                     |
+- [Guides](docs/guides/README.md): each sign-in flow, access keys, sessions, errors, and Viem.
+- [API reference](docs/api/README.md): every action, function, and type.
+- [Tempo Auth](../../docs/README.md): the service the package calls, over HTTP.

package/dist/Actions.d.ts

@@ -28,7 +28,7 @@ export declare function authorize(auth: Auth, options?: authorize.Options): Prom
 export declare namespace authorize {
     type Options = {
         /**
-         * The key to authorize, as a viem account. Its `access` names the Tempo Account, which
+         * The key to authorize, as a Viem account. Its `access` names the Tempo Account, which
          * defaults to the user's first. Defaults to a new key.
          */
         accessKey?: Account.Account | undefined;

package/dist/Auth.d.ts

@@ -1,3 +1,31 @@
+/**
+ * A Tempo Auth instance, which every action takes. Create one with {@link create}, then pass it
+ * to each action in `Actions`. Every sign-in returns an `Authorization`: the user's tokens and a
+ * Viem access key account.
+ *
+ * @example
+ * ```ts
+ * import { Actions, Auth } from '@tempoxyz/auth'
+ * import { Expiry, Scopes } from 'viem/tempo'
+ * import { tempo } from 'viem/tempo/chains'
+ * import * as Tokens from 'viem/tokens'
+ *
+ * // OUSD has its mainnet address on every Tempo chain.
+ * const ousd = Tokens.ousd(tempo.id).address
+ *
+ * const auth = Auth.create({ clientId: 'client_…', testnet: true })
+ *
+ * const authorization = await Actions.authorize(auth, {
+ *   permissions: {
+ *     expiry: Expiry.days(1),
+ *     limits: [{ limit: 10_000_000n, token: ousd }],
+ *     scopes: [Scopes.tip20(ousd).transfer()],
+ *   },
+ * })
+ * ```
+ * @module
+ */
+import type { OneOf } from 'viem';
 import type { Storage } from './Storage.ts';
 /** A Tempo Auth instance, which every action takes. */
 export type Auth = {
@@ -18,7 +46,7 @@ export type Auth = {
      * objects as they are, since a browser key is a `CryptoKey`. Defaults to IndexedDB.
      */
     storage?: Storage | undefined;
-    /** Where Tempo Auth runs, such as `https://auth.tempo.xyz`. */
+    /** Where Tempo Auth runs, such as `https://auth.tech.dev`. */
     url: string;
 };
 /** A request Tempo Auth refused, with its status and message. */
@@ -56,18 +84,24 @@ export declare namespace RequestError {
  *
  * @example
  * ```ts
- * const auth = Auth.create({ clientId: 'client_…', url: 'https://auth.tempo.xyz' })
+ * const auth = Auth.create({ clientId: 'client_…' })
  * ```
  */
 export declare function create(options: create.Options): Auth;
 export declare namespace create {
-    type Options = Omit<Auth, 'chainId' | 'scope'> & {
-        /** The chain the app's keys act on, such as `tempoTestnet.id`. Defaults to Tempo mainnet. */
-        chainId?: number | undefined;
+    type Options = Omit<Auth, 'chainId' | 'scope' | 'url'> & {
         /**
          * Scopes the app's tokens carry beyond `openid` and `email`, which every instance includes.
          * Defaults to `offline_access`, for a refresh token.
          */
         scope?: string | undefined;
-    };
+        /** Where Tempo Auth runs. Defaults to `https://auth.tech.dev`. */
+        url?: string | undefined;
+    } & OneOf<{
+        /** The chain the app's keys act on, such as `client.chain.id`. Defaults to Tempo mainnet. */
+        chainId?: number | undefined;
+    } | {
+        /** Whether the app's keys act on Tempo testnet instead of Tempo mainnet. Defaults to `false`. */
+        testnet?: boolean | undefined;
+    }>;
 }

package/dist/Auth.js

@@ -1,34 +1,4 @@
-/**
- * A Tempo Auth instance, which every action takes. Create one with {@link create}, then pass it
- * to each action in `Actions`. Every sign-in returns an `Authorization`: the user's tokens and a
- * viem access key account.
- *
- * @example
- * ```ts
- * import { Actions, Auth } from '@tempoxyz/auth'
- * import { Expiry, Scopes } from 'viem/tempo'
- * import { tempo, tempoTestnet } from 'viem/tempo/chains'
- * import * as Tokens from 'viem/tokens'
- *
- * const ousd = Tokens.ousd(tempo.id).address
- *
- * const auth = Auth.create({
- *   chainId: tempoTestnet.id,
- *   clientId: 'client_…',
- *   url: 'https://auth.tempo.xyz',
- * })
- *
- * const authorization = await Actions.authorize(auth, {
- *   permissions: {
- *     expiry: Expiry.days(1),
- *     limits: [{ limit: 10_000_000n, token: ousd }],
- *     scopes: [Scopes.tip20(ousd).transfer()],
- *   },
- * })
- * ```
- * @module
- */
-import { tempo } from 'viem/tempo/chains';
+import { tempo, tempoTestnet } from 'viem/tempo/chains';
 /** A request Tempo Auth refused, with its status and message. */
 export class RequestError extends Error {
     name = 'Auth.RequestError';
@@ -59,15 +29,19 @@ export class RequestError extends Error {
  *
  * @example
  * ```ts
- * const auth = Auth.create({ clientId: 'client_…', url: 'https://auth.tempo.xyz' })
+ * const auth = Auth.create({ clientId: 'client_…' })
  * ```
  */
 export function create(options) {
+    const { chainId, scope = 'offline_access', testnet, url, ...rest } = options;
     // Every authorization reads the user from the ID token, which needs `openid` and `email`.
-    const scopes = (options.scope ?? 'offline_access').split(' ').filter(Boolean);
+    const scopes = scope.split(' ').filter(Boolean);
     return {
-        ...options,
-        chainId: options.chainId ?? tempo.id,
+        ...rest,
+        chainId: chainId ?? (testnet ? tempoTestnet.id : tempo.id),
         scope: [...new Set(['openid', 'email', ...scopes])].join(' '),
+        url: url ?? defaultUrl,
     };
 }
+/** Where Tempo Auth runs unless `create` receives a `url`. */
+const defaultUrl = 'https://auth.tech.dev';

package/dist/Authorization.d.ts

@@ -7,7 +7,7 @@ import type { Tokens } from './Tokens.ts';
 import type { User } from './User.ts';
 /** What every sign-in returns: the app's tokens for Tempo APIs, with its access key and the user. */
 export type Authorization = Tokens & {
-    /** The user's Tempo Account, as a viem account that signs with the app's access key. */
+    /** The user's Tempo Account, as a Viem account that signs with the app's access key. */
     account: ReturnType<typeof Key.toAccount>;
     /** The same key as data, for apps that store it and rebuild it with `Key.toAccount`. */
     key: Key.Key;

package/dist/Key.d.ts

@@ -50,7 +50,7 @@ export declare function expired(key: Key): boolean;
  */
 export declare function from(value: Key): Key;
 /**
- * Returns the key as a viem access key account acting for its Tempo Account. viem attaches the
+ * Returns the key as a Viem access key account acting for its Tempo Account. Viem attaches the
  * authorization to transactions until the chain registers the key. A key the app supplied signs
  * with that `accessKey`. Throws {@link AccessKeyRequiredError} when neither holds key material.
  *

package/dist/Key.js

@@ -37,7 +37,7 @@ export function from(value) {
     return value;
 }
 /**
- * Returns the key as a viem access key account acting for its Tempo Account. viem attaches the
+ * Returns the key as a Viem access key account acting for its Tempo Account. Viem attaches the
  * authorization to transactions until the chain registers the key. A key the app supplied signs
  * with that `accessKey`. Throws {@link AccessKeyRequiredError} when neither holds key material.
  *

package/dist/Permissions.d.ts

@@ -4,13 +4,13 @@
  */
 import type { KeyAuthorization } from 'ox/tempo';
 /**
- * What an app's access key may do, as viem's `accessKey.authorize` takes it. Tempo Auth fills what
+ * What an app's access key may do, as Viem's `accessKey.authorize` takes it. Tempo Auth fills what
  * it leaves out with the headless ceiling.
  */
 export type Permissions = {
     /** The chain the key acts on, such as `tempoTestnet.id`. Defaults to the instance's `chainId`. */
     chainId?: number | undefined;
-    /** Unix seconds. viem's `Expiry` builds one, such as `Expiry.days(1)`. Defaults to a year from now. */
+    /** Unix seconds. Viem's `Expiry` builds one, such as `Expiry.days(1)`. Defaults to a year from now. */
     expiry?: number | undefined;
     /** How much of each token the key may spend. Defaults to about $1,000 of each token it calls, or of OUSD. */
     limits?: KeyAuthorization.KeyAuthorization['limits'];

package/dist/actions/device.d.ts

@@ -17,7 +17,7 @@ export declare function authorize(auth: Auth, options: authorize.Options): Promi
 export declare namespace authorize {
     type Options = {
         /**
-         * The key to authorize, as a viem account. Its `access` names the Tempo Account, which
+         * The key to authorize, as a Viem account. Its `access` names the Tempo Account, which
          * defaults to the user's first. Defaults to a new key.
          */
         accessKey?: Account.Account | undefined;

package/dist/actions/email.d.ts

@@ -36,7 +36,7 @@ export declare function signIn(auth: Auth, options: signIn.Options): Promise<sig
 export declare namespace signIn {
     type Options = {
         /**
-         * The key to authorize, as a viem account. Its `access` names the Tempo Account, which
+         * The key to authorize, as a Viem account. Its `access` names the Tempo Account, which
          * defaults to the user's first. Defaults to a new key.
          */
         accessKey?: Account.Account | undefined;

package/dist/actions/redirect.d.ts

@@ -41,7 +41,7 @@ export declare function createUrl(auth: Auth, options?: createUrl.Options): Prom
 export declare namespace createUrl {
     type Options = {
         /**
-         * The key to authorize, as a viem account. Its `access` names the Tempo Account, which
+         * The key to authorize, as a Viem account. Its `access` names the Tempo Account, which
          * defaults to the user's first. Defaults to a new key, whose material `pending` keeps.
          */
         accessKey?: Account.Account | undefined;
@@ -93,7 +93,7 @@ export declare function start(auth: Auth, options?: start.Options): Promise<void
 export declare namespace start {
     type Options = {
         /**
-         * The key to authorize, as a viem account. Pass it to {@link complete} too. Defaults to a new
+         * The key to authorize, as a Viem account. Pass it to {@link complete} too. Defaults to a new
          * key, which `storage` keeps until the browser returns.
          */
         accessKey?: Account.Account | undefined;

package/dist/internal/accessKey.d.ts

@@ -7,7 +7,7 @@ import type * as Key from '../Key.ts';
 export declare function resolve(accessKey: Account.Account | undefined): Promise<resolve.ReturnType>;
 export declare namespace resolve {
     type ReturnType = {
-        /** The key, as a viem account that signs with it. */
+        /** The key, as a Viem account that signs with it. */
         accessKey: Account.Account;
         /** What the authorization keeps to rebuild the key. Empty for a key the app supplied. */
         material: Key.Material;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tempoxyz/auth",
-  "version": "0.0.0-pr-61.sha-1a0da9d",
-  "description": "Signs users in to Tempo through Tempo Auth, and returns viem access key accounts on their Tempo Accounts.",
+  "version": "0.0.0-pr-62.sha-8ef1ef2",
+  "description": "Signs users in to Tempo through Tempo Auth, and returns Viem access key accounts on their Tempo Accounts.",
   "type": "module",
   "exports": {
     ".": {