@enbox/api 0.3.1 → 0.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@enbox/api",
-  "version": "0.3.1",
-  "description": "SDK for accessing the features and capabilities of Web5",
+  "version": "0.4.0",
+  "description": "Enbox SDK — high-level API for Decentralized Web Nodes, DIDs, and Verifiable Credentials",
   "type": "module",
   "main": "./dist/esm/index.js",
   "module": "./dist/esm/index.js",
@@ -71,8 +71,8 @@
     "DID",
     "sdk",
     "verifiable-credentials",
-    "web5",
-    "web5-sdk"
+    "enbox",
+    "enbox-sdk"
   ],
   "publishConfig": {
     "access": "public"
@@ -81,15 +81,16 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
-    "@enbox/agent": "0.2.1",
-    "@enbox/common": "0.0.6",
-    "@enbox/dwn-clients": "0.0.8"
+    "@enbox/agent": "0.3.0",
+    "@enbox/auth": "0.2.0",
+    "@enbox/common": "0.0.7",
+    "@enbox/dwn-clients": "0.1.0"
   },
   "devDependencies": {
-    "@enbox/crypto": "0.0.7",
-    "@enbox/dids": "0.0.8",
-    "@enbox/dwn-sdk-js": "0.1.1",
-    "@enbox/protocols": "0.2.8",
+    "@enbox/crypto": "0.0.8",
+    "@enbox/dids": "0.0.9",
+    "@enbox/dwn-sdk-js": "0.1.2",
+    "@enbox/protocols": "0.2.10",
     "@types/node": "20.14.8",
     "@types/sinon": "17.0.3",
     "@typescript-eslint/eslint-plugin": "8.32.1",

package/src/advanced.ts

@@ -2,7 +2,7 @@
  * Advanced API surface for power users who need direct access to
  * the underlying {@link DwnApi}.
  *
- * Most applications should use `web5.using(protocol)` instead.
+ * Most applications should use `enbox.using(protocol)` instead.
  * Import from `@enbox/api/advanced` to access these exports.
  *
  * @packageDocumentation

package/src/define-protocol.ts

@@ -2,7 +2,7 @@
  * Factory function for creating typed protocol definitions.
  *
  * `defineProtocol()` wraps a standard {@link ProtocolDefinition} with
- * compile-time type metadata so that {@link TypedWeb5} can provide
+ * compile-time type metadata so that {@link TypedEnbox} can provide
  * path autocompletion, data-shape inference, and tag type safety.
  */
 
@@ -17,7 +17,7 @@ import type { SchemaMap, TypedProtocol } from './protocol-types.js';
  *
  * The `definition` argument is returned as-is (no cloning). The schema map
  * is a phantom type parameter — it exists only at compile time to thread
- * type information through to `TypedWeb5`.
+ * type information through to `TypedEnbox`.
  *
  * @param definition - A standard `ProtocolDefinition` object.
  * @param _schemaMap - A phantom value (e.g. `{} as MySchemaMap`) that carries
@@ -32,7 +32,7 @@ import type { SchemaMap, TypedProtocol } from './protocol-types.js';
  * });
  *
  * // socialGraph.definition is the raw ProtocolDefinition
- * // TypedWeb5 infers paths like 'friend' | 'friend/message' and
+ * // TypedEnbox infers paths like 'friend' | 'friend/message' and
  * // data types from the schema map.
  * ```
  */

package/src/did-api.ts

@@ -1,4 +1,4 @@
-import type { DidCreateParams, DidMessageResult, DidResolveParams, ResponseStatus, Web5Agent } from '@enbox/agent';
+import type { DidCreateParams, DidMessageResult, DidResolveParams, EnboxAgent, ResponseStatus } from '@enbox/agent';
 
 import { DidInterface } from '@enbox/agent';
 
@@ -37,15 +37,15 @@ export type DidResolveResponse = DidMessageResult[DidInterface.Resolve];
  */
 export class DidApi {
   /**
-   * Holds the instance of a {@link Web5Agent} that represents the current execution context for
+   * Holds the instance of a {@link EnboxAgent} that represents the current execution context for
    * the `DidApi`. This agent is used to process DID requests.
    */
-  private agent: Web5Agent;
+  private agent: EnboxAgent;
 
   /** The DID of the tenant under which DID operations are being performed. */
   private connectedDid: string;
 
-  constructor(options: { agent: Web5Agent, connectedDid: string }) {
+  constructor(options: { agent: EnboxAgent, connectedDid: string }) {
     this.agent = options.agent;
     this.connectedDid = options.connectedDid;
   }
@@ -54,7 +54,7 @@ export class DidApi {
    * Initiates the creation of a Decentralized Identifier (DID) using the specified method, options,
    * and storage preference.
    *
-   * This method sends a request to the Web5 Agent to create a new DID based on the provided method,
+   * This method sends a request to the Enbox Agent to create a new DID based on the provided method,
    * with method-specific options. It also specifies whether the newly created DID should be stored.
    *
    * @param request - The request parameters for creating a DID, including the method, options, and

package/src/dwn-api.ts

@@ -12,10 +12,10 @@ import type {
   DwnPaginationCursor,
   DwnResponse,
   DwnResponseStatus,
+  EnboxAgent,
   FetchPermissionRequestParams,
   FetchPermissionsParams,
-  ProcessDwnRequest,
-  Web5Agent } from '@enbox/agent';
+  ProcessDwnRequest } from '@enbox/agent';
 
 import type { DwnSubscriptionMessage } from '@enbox/dwn-clients';
 
@@ -161,10 +161,13 @@ export type RecordsReadRequest = Omit<DwnMessageParams[DwnInterface.RecordsRead]
 /**
  * Encapsulates the response from a record read operation, combining the general operation status
  * with the specific record that was retrieved.
+ *
+ * When the status code is not in the 2xx range (e.g. 401, 404), `record` will be `undefined`.
+ * Always check `status.code` before accessing the record.
  */
 export type RecordsReadResponse = DwnResponseStatus & {
-  /** The record retrieved by the read operation. */
-  record: Record;
+  /** The record retrieved by the read operation, or `undefined` if the request failed. */
+  record?: Record;
 };
 
 /**
@@ -223,9 +226,11 @@ export type RecordsWriteRequest = Omit<Partial<DwnMessageParams[DwnInterface.Rec
 export type RecordsWriteResponse = DwnResponseStatus & {
   /**
    * The `Record` instance representing the record that was successfully written to the
-   * DWN as a result of the write operation.
+   * DWN as a result of the write operation, or `undefined` if the write failed.
+   *
+   * Always check `status.code` before accessing the record.
    */
-  record: Record;
+  record?: Record;
 };
 
 /**
@@ -233,10 +238,10 @@ export type RecordsWriteResponse = DwnResponseStatus & {
  */
 export class DwnApi {
   /**
-   * Holds the instance of a {@link Web5Agent} that represents the current execution context for
+   * Holds the instance of a {@link EnboxAgent} that represents the current execution context for
    * the `DwnApi`. This agent is used to process DWN requests.
    */
-  private agent: Web5Agent;
+  private agent: EnboxAgent;
 
   /** The DID of the DWN tenant under which operations are being performed. */
   private connectedDid: string;
@@ -247,7 +252,7 @@ export class DwnApi {
   /** Holds the instance of {@link AgentPermissionsApi} that helps when dealing with permissions protocol records */
   private permissionsApi: AgentPermissionsApi;
 
-  constructor(options: { agent: Web5Agent, connectedDid: string, delegateDid?: string }) {
+  constructor(options: { agent: EnboxAgent, connectedDid: string, delegateDid?: string }) {
     this.agent = options.agent;
     this.connectedDid = options.connectedDid;
     this.delegateDid = options.delegateDid;
@@ -491,7 +496,7 @@ export class DwnApi {
 
         const agentRequest: ProcessDwnRequest<DwnInterface.RecordsDelete> = {
           /**
-           * The `author` is the DID that will sign the message and must be the DID the Web5 app is
+           * The `author` is the DID that will sign the message and must be the DID the Enbox app is
            * connected with and is authorized to access the signing private key of.
            */
           author      : this.connectedDid,
@@ -543,7 +548,7 @@ export class DwnApi {
 
         const agentRequest: ProcessDwnRequest<DwnInterface.RecordsQuery> = {
           /**
-           * The `author` is the DID that will sign the message and must be the DID the Web5 app is
+           * The `author` is the DID that will sign the message and must be the DID the Enbox app is
            * connected with and is authorized to access the signing private key of.
            */
           author      : this.connectedDid,
@@ -562,7 +567,7 @@ export class DwnApi {
           // if we don't find a delegated grant, we will attempt to query signing as the delegated DID
           // This is to allow the API caller to query public records without needing to impersonate the delegate.
           //
-          // NOTE: For anonymous/public queries without explicit permissions, callers can use `DwnReaderApi` via `Web5.anonymous()`.
+          // NOTE: For anonymous/public queries without explicit permissions, callers can use `DwnReaderApi` via `Enbox.anonymous()`.
           // See: https://github.com/enboxorg/enbox/issues/898
           try {
             const { message: delegatedGrant } = await this.permissionsApi.getPermissionForRequest({
@@ -635,7 +640,7 @@ export class DwnApi {
 
         const agentRequest: ProcessDwnRequest<DwnInterface.RecordsRead> = {
           /**
-           * The `author` is the DID that will sign the message and must be the DID the Web5 app is
+           * The `author` is the DID that will sign the message and must be the DID the Enbox app is
            * connected with and is authorized to access the signing private key of.
            */
           author      : this.connectedDid,
@@ -654,7 +659,7 @@ export class DwnApi {
           // if we don't find a delegated grant, we will attempt to read signing as the delegated DID
           // This is to allow the API caller to read public records without needing to impersonate the delegate.
           //
-          // NOTE: For anonymous/public reads without explicit permissions, callers can use `DwnReaderApi` via `Web5.anonymous()`.
+          // NOTE: For anonymous/public reads without explicit permissions, callers can use `DwnReaderApi` via `Enbox.anonymous()`.
           // See: https://github.com/enboxorg/enbox/issues/898
 
           try {
@@ -688,7 +693,7 @@ export class DwnApi {
 
         const { reply: { entry, status } } = agentResponse;
 
-        let record: Record;
+        let record: Record | undefined;
         if (200 <= status.code && status.code <= 299) {
           const recordOptions = {
             /**
@@ -785,7 +790,7 @@ export class DwnApi {
           // if we don't find a delegated grant, we will attempt to subscribe signing as the delegated DID
           // This is to allow the API caller to subscribe to public records without needing to impersonate the delegate.
           //
-          // NOTE: For anonymous/public subscriptions without explicit permissions, callers can use `DwnReaderApi` via `Web5.anonymous()`.
+          // NOTE: For anonymous/public subscriptions without explicit permissions, callers can use `DwnReaderApi` via `Enbox.anonymous()`.
           // See: https://github.com/enboxorg/enbox/issues/898
           try {
             const { message: delegatedGrant } = await this.permissionsApi.getPermissionForRequest({
@@ -883,7 +888,7 @@ export class DwnApi {
 
         const { message: responseMessage, reply: { status } } = agentResponse;
 
-        let record: Record;
+        let record: Record | undefined;
         if (200 <= status.code && status.code <= 299) {
           const recordOptions = {
             /**

package/src/dwn-reader-api.ts

@@ -129,11 +129,11 @@ export type ReaderProtocolsQueryResponse = DwnResponseStatus & {
  * on every call (remote-only). All messages are unsigned, so only published
  * records and protocols are accessible.
  *
- * Obtain an instance via {@link Web5.anonymous | `Web5.anonymous()`}.
+ * Obtain an instance via {@link Enbox.anonymous | `Enbox.anonymous()`}.
  *
  * @example
  * ```ts
- * const { dwn } = Web5.anonymous();
+ * const { dwn } = Enbox.anonymous();
  *
  * const { records } = await dwn.records.query({
  *   from: 'did:dht:alice...',

package/src/enbox.ts

@@ -0,0 +1,281 @@
+/**
+ * NOTE: Added reference types here to avoid a `pnpm` bug during build.
+ * https://github.com/enboxorg/enbox/pull/507
+ */
+/// <reference types="@enbox/dwn-sdk-js" />
+
+import type { AuthSession } from '@enbox/auth';
+import type { DidMethodResolver } from '@enbox/dids';
+import type { EnboxAgent } from '@enbox/agent';
+import type { ProtocolDefinition } from '@enbox/dwn-sdk-js';
+
+import type { SchemaMap, TypedProtocol } from './protocol-types.js';
+
+import { AnonymousDwnApi } from '@enbox/agent';
+import { EnboxRpcClient } from '@enbox/dwn-clients';
+import { DidDht, DidJwk, DidKey, DidResolverCacheMemory, DidWeb, UniversalResolver } from '@enbox/dids';
+
+import { DidApi } from './did-api.js';
+import { DwnApi } from './dwn-api.js';
+import { DwnReaderApi } from './dwn-reader-api.js';
+import { TypedEnbox } from './typed-enbox.js';
+import { VcApi } from './vc-api.js';
+
+/**
+ * Options for creating an anonymous (read-only) Enbox instance via {@link Enbox.anonymous}.
+ *
+ * @beta
+ */
+export type EnboxAnonymousOptions = {
+  /** Override the default DID method resolvers. Defaults to `[DidDht, DidJwk, DidKey, DidWeb]`. */
+  didResolvers?: DidMethodResolver[];
+};
+
+/**
+ * The result of calling {@link Enbox.anonymous}.
+ *
+ * Contains only a read-only `dwn` property — no `did`, `vc`, or `agent`.
+ *
+ * @beta
+ */
+export type EnboxAnonymousApi = {
+  /** A read-only DWN API for querying public data on remote DWNs. */
+  dwn: DwnReaderApi;
+};
+
+/**
+ * Parameters for constructing an {@link Enbox} instance.
+ *
+ * These are the minimal primitives needed to interact with the DWN network.
+ * Typically obtained from an {@link AuthSession} via `@enbox/auth`.
+ */
+export type EnboxParams = {
+  /**
+   * A {@link EnboxAgent} instance that handles DIDs, DWNs and VCs requests. The agent manages the
+   * user keys and identities, and is responsible to sign and verify messages.
+   */
+  agent: EnboxAgent;
+
+  /** The DID of the tenant under which all DID, DWN, and VC requests are being performed. */
+  connectedDid: string;
+
+  /** The DID that will be signing messages using grants from the connectedDid. */
+  delegateDid?: string;
+};
+
+/**
+ * The main Enbox API interface. It provides protocol-scoped access to
+ * Decentralized Web Nodes (DWNs), Decentralized Identifiers (DIDs),
+ * and Verifiable Credentials (VCs).
+ *
+ * Authentication and identity management are handled externally by
+ * `@enbox/auth`. Use {@link Enbox.connect} to create an instance from
+ * an {@link AuthSession} or raw parameters.
+ *
+ * @example
+ * ```ts
+ * import { AuthManager } from '@enbox/auth';
+ * import { Enbox } from '@enbox/api';
+ *
+ * const auth = await AuthManager.create({ sync: '15s' });
+ * const session = await auth.connect();
+ *
+ * const enbox = Enbox.connect({ session });
+ * const social = enbox.using(SocialProtocol);
+ * ```
+ */
+export class Enbox {
+  /**
+   * A {@link EnboxAgent} instance that handles DIDs, DWNs and VCs requests. The agent manages the
+   * user keys and identities, and is responsible to sign and verify messages.
+   */
+  public agent: EnboxAgent;
+
+  /** Exposed instance to the DID APIs, allow users to create and resolve DIDs. */
+  public did: DidApi;
+
+  /** Internal DWN API instance. Use {@link Enbox.using} for protocol-scoped access. */
+  private _dwn: DwnApi;
+
+  /**
+   * Cache of {@link TypedEnbox} instances keyed by protocol URI.
+   *
+   * Ensures that `enbox.using(Protocol)` returns the **same** `TypedEnbox`
+   * instance for a given protocol across multiple call sites, avoiding
+   * redundant protocol installations and duplicated internal state.
+   */
+  private _typedInstances = new Map<string, TypedEnbox<ProtocolDefinition, SchemaMap>>();
+
+  /** Exposed instance to the VC APIs, allow users to issue, present and verify VCs. */
+  public vc: VcApi;
+
+  constructor({ agent, connectedDid, delegateDid }: EnboxParams) {
+    this.agent = agent;
+    this.did = new DidApi({ agent, connectedDid });
+    this._dwn = new DwnApi({ agent, connectedDid, delegateDid });
+    this.vc = new VcApi({ agent, connectedDid });
+  }
+
+  /**
+   * Returns a {@link TypedEnbox} instance scoped to the given protocol.
+   *
+   * This is the **primary developer interface** for interacting with
+   * protocol-backed records. It auto-injects the protocol URI, protocolPath,
+   * and schema into every operation, and provides compile-time path
+   * autocompletion plus typed data payloads via the schema map.
+   *
+   * Instances are **cached by protocol URI** — calling `using()` multiple
+   * times with the same protocol returns the same `TypedEnbox` instance,
+   * so auto-configure only runs once and all call sites share state.
+   *
+   * @param protocol - A typed protocol created via `defineProtocol()`.
+   * @returns A `TypedEnbox` instance bound to the given protocol.
+   *
+   * @example
+   * ```ts
+   * const social = enbox.using(SocialProtocol);
+   *
+   * await social.configure();
+   *
+   * const { record } = await social.records.write('friend', {
+   *   data: { did: 'did:example:alice', alias: 'Alice' },
+   * });
+   *
+   * const { records } = await social.records.query('friend');
+   * ```
+   */
+  public using<D extends ProtocolDefinition, M extends SchemaMap>(
+    protocol: TypedProtocol<D, M>,
+  ): TypedEnbox<D, M> {
+    const uri = protocol.definition.protocol;
+    const cached = this._typedInstances.get(uri);
+
+    if (cached) {
+      // The map stores a type-erased instance; restore the caller's generics.
+      return cached as unknown as TypedEnbox<D, M>;
+    }
+
+    const instance = new TypedEnbox<D, M>(this._dwn, protocol);
+    // Store with erased generics so the map value type stays uniform.
+    this._typedInstances.set(uri, instance as unknown as TypedEnbox<ProtocolDefinition, SchemaMap>);
+    return instance;
+  }
+
+  /**
+   * Stops DWN sync and clears the cached {@link TypedEnbox} instances.
+   *
+   * Call this when the application is shutting down or the user is
+   * disconnecting to cleanly release background resources. After calling
+   * `disconnect()`, the `Enbox` instance should not be reused.
+   *
+   * @param timeout - Maximum milliseconds to wait for an in-progress sync
+   *   cycle to finish before force-stopping. Defaults to `2000`.
+   *
+   * @example
+   * ```ts
+   * await enbox.disconnect();
+   * ```
+   *
+   * @beta
+   */
+  public async disconnect(timeout?: number): Promise<void> {
+    // Stop any active sync.
+    if ('sync' in this.agent && typeof (this.agent as any).sync?.stopSync === 'function') {
+      await (this.agent as any).sync.stopSync(timeout);
+    }
+
+    // Clear cached TypedEnbox instances so they are not accidentally reused.
+    this._typedInstances.clear();
+  }
+
+  /**
+   * Creates a lightweight, read-only Enbox instance for querying public DWN data.
+   *
+   * No identity, vault, password, or signing keys are required. The returned
+   * API supports querying and reading published records and protocols from any
+   * remote DWN, using **unsigned** (anonymous) DWN messages.
+   *
+   * @param options - Optional configuration overrides.
+   * @returns An {@link EnboxAnonymousApi} with a read-only `dwn` property.
+   *
+   * @example
+   * ```ts
+   * const { dwn } = Enbox.anonymous();
+   *
+   * const { records } = await dwn.records.query({
+   *   from: 'did:dht:alice...',
+   *   filter: { protocol: 'https://social.example/posts', protocolPath: 'post' },
+   * });
+   *
+   * for (const record of records) {
+   *   console.log(record.id, await record.data.text());
+   * }
+   * ```
+   *
+   * @beta
+   */
+  public static anonymous(options?: EnboxAnonymousOptions): EnboxAnonymousApi {
+    const didResolver = new UniversalResolver({
+      didResolvers : options?.didResolvers ?? [DidDht, DidJwk, DidKey, DidWeb],
+      cache        : new DidResolverCacheMemory(),
+    });
+
+    const rpcClient = new EnboxRpcClient();
+    const anonymousDwn = new AnonymousDwnApi({ didResolver, rpcClient });
+
+    return {
+      dwn: new DwnReaderApi(anonymousDwn),
+    };
+  }
+
+  /**
+   * Creates an {@link Enbox} instance from an {@link AuthSession} or raw parameters.
+   *
+   * This is a thin factory — all authentication, identity management, vault
+   * initialization, DWN registration, and sync setup are handled externally
+   * by `@enbox/auth` via {@link AuthSession}.
+   *
+   * @param params - Either `{ session }` with an {@link AuthSession} from
+   *   `@enbox/auth`, or raw `{ agent, connectedDid, delegateDid? }` parameters.
+   * @returns A new {@link Enbox} instance ready for use.
+   *
+   * @example
+   * ```ts
+   * // Using an AuthSession from @enbox/auth
+   * import { AuthManager } from '@enbox/auth';
+   * const auth = await AuthManager.create({ sync: '15s' });
+   * const session = await auth.connect();
+   * const enbox = Enbox.connect({ session });
+   *
+   * // Using raw parameters
+   * const enbox = Enbox.connect({ agent, connectedDid: did });
+   * ```
+   */
+  public static connect(params: { session: AuthSession } | EnboxParams): Enbox {
+    if ('session' in params) {
+      const { session } = params;
+      return new Enbox({
+        agent        : session.agent,
+        connectedDid : session.did,
+        delegateDid  : session.delegateDid,
+      });
+    }
+    return new Enbox(params);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Deprecated aliases — migration aid
+// ---------------------------------------------------------------------------
+
+/** @deprecated Use {@link Enbox} instead. Will be removed in a future version. */
+export const Web5 = Enbox;
+
+/** @deprecated Use {@link EnboxParams} instead. */
+export type Web5Params = EnboxParams;
+
+/** @deprecated Use {@link EnboxAnonymousOptions} instead. */
+export type Web5AnonymousOptions = EnboxAnonymousOptions;
+
+/** @deprecated Use {@link EnboxAnonymousApi} instead. */
+export type Web5AnonymousApi = EnboxAnonymousApi;

package/src/grant-revocation.ts

@@ -1,4 +1,4 @@
-import type { DwnDataEncodedRecordsWriteMessage, DwnResponseStatus, SendDwnRequest, Web5Agent } from '@enbox/agent';
+import type { DwnDataEncodedRecordsWriteMessage, DwnResponseStatus, EnboxAgent, SendDwnRequest } from '@enbox/agent';
 
 import { Convert } from '@enbox/common';
 import { AgentPermissionsApi, DwnInterface, getRecordAuthor } from '@enbox/agent';
@@ -53,7 +53,7 @@ export class PermissionGrantRevocation implements GrantRevocationModel {
   /** parses the grant revocation given am agent, connectedDid and data encoded records write message  */
   static async parse({ connectedDid, agent, message }:{
     connectedDid: string;
-    agent: Web5Agent;
+    agent: EnboxAgent;
     message: DwnDataEncodedRecordsWriteMessage;
   }): Promise<PermissionGrantRevocation> {
     const permissions = new AgentPermissionsApi({ agent });
@@ -61,7 +61,7 @@ export class PermissionGrantRevocation implements GrantRevocationModel {
   }
 
   /** The agent to use for this instantiation of the grant revocation */
-  private get agent(): Web5Agent {
+  private get agent(): EnboxAgent {
     return this._permissions.agent;
   }
 

package/src/index.ts

@@ -1,20 +1,20 @@
 /**
- * Making developing with Web5 components at least 5 times easier to work with.
+ * Enbox SDK — high-level API for Decentralized Web Nodes, DIDs, and VCs.
  *
- * Web5 consists of the following components:
- * - Decentralized Identifiers
- * - Verifiable Credentials
- * - DWeb Node personal datastores
+ * The SDK provides protocol-scoped access to DWN records with compile-time
+ * type safety, DID management, and Verifiable Credential operations.
  *
- * The SDK sets out to gather the most oft used functionality from all three of
- * these pillar technologies to provide a simple library that is as close to
- * effortless as possible.
+ * Authentication and identity management are handled by `@enbox/auth`.
  *
- * The SDK is currently still under active development, but having entered the
- * Tech Preview phase there is now a drive to avoid unnecessary changes unless
- * backwards compatibility is provided. Additional functionality will be added
- * in the lead up to 1.0 final, and modifications will be made to address
- * issues and community feedback.
+ * @example
+ * ```ts
+ * import { AuthManager } from '@enbox/auth';
+ * import { Enbox } from '@enbox/api';
+ *
+ * const auth = await AuthManager.create({ sync: '15s' });
+ * const session = await auth.connect();
+ * const enbox = Enbox.connect({ session });
+ * ```
  *
  * [Link to GitHub Repo](https://github.com/enboxorg/enbox)
  *
@@ -24,6 +24,7 @@
 export * from './define-protocol.js';
 export * from './did-api.js';
 export * from './dwn-reader-api.js';
+export * from './enbox.js';
 export * from './grant-revocation.js';
 export * from './live-query.js';
 export * from './permission-grant.js';
@@ -36,11 +37,11 @@ export * from './record-data.js';
 export * from './record-types.js';
 export * from './repository.js';
 export * from './repository-types.js';
+export * from './typed-enbox.js';
 export * from './typed-live-query.js';
 export * from './typed-record.js';
-export * from './typed-web5.js';
 export * from './vc-api.js';
-export * from './web5.js';
 
 import * as utils from './utils.js';
-export { utils };
+export { utils };
+export { isOk } from './utils.js';

package/src/live-query.ts

@@ -1,4 +1,4 @@
-import type { DwnMessageSubscription, PermissionsApi, Web5Agent } from '@enbox/agent';
+import type { DwnMessageSubscription, EnboxAgent, PermissionsApi } from '@enbox/agent';
 import type { PaginationCursor, RecordsQueryReplyEntry } from '@enbox/dwn-sdk-js';
 
 import { getRecordAuthor } from '@enbox/agent';
@@ -40,7 +40,7 @@ export class RecordChangeEvent extends CustomEvent<RecordChange> {
  */
 export type LiveQueryOptions = {
   /** The agent instance used to construct Record objects. */
-  agent: Web5Agent;
+  agent: EnboxAgent;
 
   /** The DID of the connected user. */
   connectedDid: string;

package/src/permission-grant.ts

@@ -3,8 +3,8 @@ import type {
   DwnPermissionConditions,
   DwnPermissionScope,
   DwnResponseStatus,
-  SendDwnRequest,
-  Web5Agent
+  EnboxAgent,
+  SendDwnRequest
 } from '@enbox/agent';
 
 import { Convert } from '@enbox/common';
@@ -80,7 +80,7 @@ export interface PermissionGrantOptions {
   /** The underlying DWN `RecordsWrite` message along with encoded data that represent the grant */
   message: DwnDataEncodedRecordsWriteMessage;
   /** The agent to use when interacting with the underlying DWN record representing the grant */
-  agent: Web5Agent;
+  agent: EnboxAgent;
 }
 
 /**
@@ -127,7 +127,7 @@ export class PermissionGrant implements PermissionGrantModel {
   }
 
   /** The agent to use for this instantiation of the grant */
-  private get agent(): Web5Agent {
+  private get agent(): EnboxAgent {
     return this._permissions.agent;
   }