@enbox/api 0.3.2 → 0.4.1

package/src/permission-request.ts

@@ -3,8 +3,8 @@ import type {
   DwnPermissionConditions,
   DwnPermissionScope,
   DwnResponseStatus,
+  EnboxAgent,
   SendDwnRequest,
-  Web5Agent,
 } from '@enbox/agent';
 
 import { Convert } from '@enbox/common';
@@ -86,7 +86,7 @@ export class PermissionRequest implements PermissionRequestModel {
   /** parses the request given an agent, connectedDid and data encoded records write message  */
   static parse({ connectedDid, agent, message }:{
     connectedDid: string;
-    agent: Web5Agent;
+    agent: EnboxAgent;
     message: DwnDataEncodedRecordsWriteMessage;
   }): PermissionRequest {
     const request = DwnPermissionRequest.parse(message);
@@ -95,7 +95,7 @@ export class PermissionRequest implements PermissionRequestModel {
   }
 
   /** The agent to use for this instantiation of the request */
-  private get agent(): Web5Agent {
+  private get agent(): EnboxAgent {
     return this._permissions.agent;
   }
 

package/src/protocol-types.ts

@@ -133,7 +133,7 @@ export type TagKeys<Tags extends ProtocolTagsDefinition> = Exclude<
 /**
  * A mapping from protocol type names to their TypeScript data shapes.
  *
- * Used as a type parameter to `defineProtocol()` and `TypedWeb5` so that
+ * Used as a type parameter to `defineProtocol()` and `TypedEnbox` so that
  * the protocol definition JSON stays JSON-compatible while TypeScript types
  * are tracked separately.
  *
@@ -154,7 +154,7 @@ export type SchemaMap = Record<string, unknown>;
 /**
  * The return type of `defineProtocol()`. Bundles the raw protocol definition
  * with its inferred path strings and schema type map for downstream use
- * by `TypedWeb5`.
+ * by `TypedEnbox`.
  */
 export type TypedProtocol<
   D extends ProtocolDefinition = ProtocolDefinition,

package/src/protocol.ts

@@ -4,7 +4,7 @@
  */
 /// <reference types="@enbox/dwn-sdk-js" />
 
-import type { DwnMessage, DwnResponseStatus, Web5Agent } from '@enbox/agent';
+import type { DwnMessage, DwnResponseStatus, EnboxAgent } from '@enbox/agent';
 
 import { DwnInterface } from '@enbox/agent';
 
@@ -26,27 +26,27 @@ export type ProtocolMetadata = {
 /**
  * Encapsulates a DWN Protocol with its associated metadata and configuration.
  *
- * This class primarly exists to provide developers with a convenient way to configure/install
+ * This class primarily exists to provide developers with a convenient way to configure/install
  * protocols on remote DWNs.
  */
 export class Protocol {
-  /** The {@link Web5Agent} instance that handles DWNs requests. */
-  private _agent: Web5Agent;
+  /** The {@link EnboxAgent} instance that handles DWNs requests. */
+  private _agent: EnboxAgent;
 
-  /** The ProtocolsConfigureMessage containing the detailed configuration for the protocol. */
+  /** Metadata associated with the protocol, including the author and optional message CID. */
   private _metadata: ProtocolMetadata;
 
-  /** Metadata associated with the protocol, including the author and optional message CID. */
+  /** The ProtocolsConfigureMessage containing the detailed configuration for the protocol. */
   private _protocolsConfigureMessage: DwnMessage[DwnInterface.ProtocolsConfigure];
 
   /**
    * Constructs a new instance of the Protocol class.
    *
-   * @param agent - The Web5Agent instance used for network interactions.
+   * @param agent - The EnboxAgent instance used for network interactions.
    * @param protocolsConfigureMessage - The configuration message containing the protocol details.
    * @param metadata - Metadata associated with the protocol, including the author and optional message CID.
    */
-  constructor(agent: Web5Agent, protocolsConfigureMessage: DwnMessage[DwnInterface.ProtocolsConfigure], metadata: ProtocolMetadata) {
+  constructor(agent: EnboxAgent, protocolsConfigureMessage: DwnMessage[DwnInterface.ProtocolsConfigure], metadata: ProtocolMetadata) {
     this._agent = agent;
     this._metadata = metadata;
     this._protocolsConfigureMessage = protocolsConfigureMessage;

package/src/record-data.ts

@@ -5,6 +5,10 @@
  * evaluated `stream()` function with convenience accessors that mirror the
  * Fetch `Response` API (`blob()`, `bytes()`, `json()`, `text()`).
  *
+ * Data is **cached after first read** so that subsequent calls to any accessor
+ * return the same data without re-fetching. Concurrent calls are safe — only
+ * one fetch is performed and all callers share the result.
+ *
  * Extracted from `record.ts` so the convenience-method boilerplate lives in
  * its own module while the stream-resolution logic (which is tightly coupled
  * to `Record` internals) stays inside the `Record` class.
@@ -14,6 +18,13 @@
 
 import { Stream } from '@enbox/common';
 
+/**
+ * Maximum data size (in bytes) that will be cached in-memory after the first
+ * read. Payloads larger than this threshold are not cached and will be
+ * re-fetched on every access.
+ */
+const DATA_CACHE_LIMIT = 10 * 1024 * 1024; // 10 MB
+
 /**
  * A thenable data accessor returned by {@link Record.data}.
  *
@@ -21,6 +32,10 @@ import { Stream } from '@enbox/common';
  * formats, plus `then`/`catch` so the object can be awaited directly to
  * obtain the underlying `ReadableStream`.
  *
+ * Data is cached after the first read so that repeated calls (e.g.,
+ * `data.json()` followed by `data.text()`) do not trigger redundant
+ * network requests.
+ *
  * @beta
  */
 export type RecordData = {
@@ -46,6 +61,15 @@ export type RecordData = {
 /**
  * Create a {@link RecordData} wrapper around a `stream` provider function.
  *
+ * The first call to any accessor (`blob`, `bytes`, `json`, `text`, `stream`)
+ * consumes the underlying stream and caches the raw bytes (up to
+ * {@link DATA_CACHE_LIMIT}). Subsequent calls reconstruct a fresh stream
+ * from the cache, preventing the common footgun of stale data after stream
+ * consumption.
+ *
+ * Concurrent calls are safe: if multiple accessors are called simultaneously,
+ * only one stream fetch is performed and all callers share the result.
+ *
  * @param streamFn   - A function that returns a `Promise<ReadableStream>` for the record data.
  * @param dataFormat - The MIME type used when constructing Blobs.
  * @returns A {@link RecordData} object with convenience accessors.
@@ -53,6 +77,46 @@ export type RecordData = {
  * @beta
  */
 export function createRecordData(streamFn: () => Promise<ReadableStream>, dataFormat: string | undefined): RecordData {
+  // In-memory byte cache. Populated after the first successful read.
+  let cachedBytes: Uint8Array | undefined;
+  // In-flight read promise. Ensures concurrent callers share a single fetch.
+  let inflight: Promise<Uint8Array> | undefined;
+
+  /**
+   * Returns the record data as raw bytes, using the cache when available.
+   * If a read is already in-flight, waits for it instead of starting a new one.
+   */
+  async function getBytes(): Promise<Uint8Array> {
+    // Fast path: cache hit.
+    if (cachedBytes) {
+      return cachedBytes;
+    }
+
+    // If another call is already fetching, wait for it.
+    if (inflight) {
+      return inflight;
+    }
+
+    // Start a new fetch and share the promise.
+    inflight = (async (): Promise<Uint8Array> => {
+      const readableStream = await streamFn();
+      const bytes = await Stream.consumeToBytes({ readableStream });
+
+      // Cache only if within the size limit.
+      if (bytes.byteLength <= DATA_CACHE_LIMIT) {
+        cachedBytes = bytes;
+      }
+
+      return bytes;
+    })();
+
+    try {
+      return await inflight;
+    } finally {
+      inflight = undefined;
+    }
+  }
+
   const dataObj: RecordData = {
 
     /**
@@ -64,7 +128,7 @@ export function createRecordData(streamFn: () => Promise<ReadableStream>, dataFo
      * @beta
      */
     async blob(): Promise<Blob> {
-      return new Blob([await Stream.consumeToBytes({ readableStream: await this.stream() })], { type: dataFormat });
+      return new Blob([await getBytes()], { type: dataFormat });
     },
 
     /**
@@ -76,7 +140,7 @@ export function createRecordData(streamFn: () => Promise<ReadableStream>, dataFo
      * @beta
      */
     async bytes(): Promise<Uint8Array> {
-      return await Stream.consumeToBytes({ readableStream: await this.stream() });
+      return await getBytes();
     },
 
     /**
@@ -88,7 +152,8 @@ export function createRecordData(streamFn: () => Promise<ReadableStream>, dataFo
      * @beta
      */
     async json<T = unknown>(): Promise<T> {
-      return await Stream.consumeToJson({ readableStream: await this.stream() }) as T;
+      const bytes = await getBytes();
+      return JSON.parse(new TextDecoder().decode(bytes)) as T;
     },
 
     /**
@@ -100,7 +165,8 @@ export function createRecordData(streamFn: () => Promise<ReadableStream>, dataFo
      * @beta
      */
     async text(): Promise<string> {
-      return await Stream.consumeToText({ readableStream: await this.stream() });
+      const bytes = await getBytes();
+      return new TextDecoder().decode(bytes);
     },
 
     /**
@@ -109,12 +175,27 @@ export function createRecordData(streamFn: () => Promise<ReadableStream>, dataFo
      * Uses the standard Web Streams API for cross-platform compatibility across
      * browsers, Node.js, Bun, and Deno.
      *
+     * If the data has already been read and cached, returns a fresh stream
+     * reconstructed from the cache.
+     *
      * @returns A promise that resolves to a Web `ReadableStream` of the record's data.
      * @throws If the record data is not available in-memory and cannot be fetched.
      *
      * @beta
      */
-    stream: streamFn,
+    async stream(): Promise<ReadableStream> {
+      // If we have cached bytes, reconstruct a fresh stream from them.
+      if (cachedBytes) {
+        return new ReadableStream({
+          start(controller): void {
+            controller.enqueue(cachedBytes);
+            controller.close();
+          },
+        });
+      }
+      // Otherwise delegate to the original stream provider.
+      return streamFn();
+    },
 
     /**
      * Attaches callbacks for the resolution and/or rejection of the `Promise` returned by

package/src/record.ts

@@ -11,10 +11,10 @@ import type {
   DwnMessageParams,
   DwnPaginationCursor,
   DwnResponseStatus,
+  EnboxAgent,
   PermissionsApi,
   ProcessDwnRequest,
   SendDwnRequest,
-  Web5Agent,
 } from '@enbox/agent';
 
 import type {
@@ -94,8 +94,8 @@ export class Record implements RecordModel {
 
   // Record instance metadata.
 
-  /** The {@link Web5Agent} instance that handles DWNs requests. */
-  private _agent: Web5Agent;
+  /** The {@link EnboxAgent} instance that handles DWNs requests. */
+  private _agent: EnboxAgent;
   /** The DID of the DWN tenant under which operations are being performed. */
   private _connectedDid: string;
   /** The optional DID that is delegated to act on behalf of the connectedDid */
@@ -215,10 +215,10 @@ export class Record implements RecordModel {
   /** Record's encryption */
   get encryption(): DwnMessage[DwnInterface.RecordsWrite]['encryption'] { return this._encryption; }
 
-  /** Record's signatures attestation */
+  /** Record's authorization signature(s). */
   get authorization(): DwnMessage[DwnInterface.RecordsWrite | DwnInterface.RecordsDelete]['authorization'] { return this._authorization; }
 
-  /** Record's signatures attestation */
+  /** Record's attestation signature. */
   get attestation(): DwnMessage[DwnInterface.RecordsWrite]['attestation'] | undefined { return this._attestation; }
 
   /** Role under which the author is writing the record */
@@ -264,7 +264,7 @@ export class Record implements RecordModel {
     return message;
   }
 
-  constructor(agent: Web5Agent, options: RecordOptions, permissionsApi?: PermissionsApi) {
+  constructor(agent: EnboxAgent, options: RecordOptions, permissionsApi?: PermissionsApi) {
 
     this._agent = agent;
 
@@ -324,7 +324,7 @@ export class Record implements RecordModel {
   get data(): RecordData {
     return createRecordData(async (): Promise<ReadableStream> => {
       if (this.deleted) {
-        throw new Error('404: Not Found');
+        throw new Error('Cannot access data of a deleted record.');
       }
 
       if (this._encodedData) {
@@ -381,15 +381,18 @@ export class Record implements RecordModel {
   }
 
   /**
-   * Send the current record to a remote DWN by specifying their DID
+   * Send the current record to a remote DWN by specifying their DID.
    * If no DID is specified, the target is assumed to be the owner (connectedDID).
    *
-   * If an initial write is present and the Record class send cache has no awareness of it, the initial write is sent first
-   * (vs waiting for the regular DWN sync)
+   * If the record is in a deleted state, a `RecordsDelete` message is sent
+   * so the remote DWN reflects the deletion.
+   *
+   * If an initial write is present and the Record class send cache has no
+   * awareness of it, the initial write is sent first (vs waiting for the
+   * regular DWN sync).
    *
    * @param target - the optional DID to send the record to, if none is set it is sent to the connectedDid
    * @returns the status of the send record request
-   * @throws `Error` if the record has already been deleted.
    *
    * @beta
    */
@@ -506,8 +509,14 @@ export class Record implements RecordModel {
 
   /**
    * Update the current record on the DWN.
+   *
+   * On success, **both** a new `Record` instance is returned *and* the
+   * current instance (`this`) is mutated in-place to reflect the updated
+   * state. This means callers can safely continue using the original
+   * reference after an update without capturing the returned record.
+   *
    * @param params - Parameters to update the record.
-   * @returns the status of the update request
+   * @returns the status of the update request and the updated Record
    * @throws `Error` if the record has already been deleted.
    *
    * @beta
@@ -600,11 +609,33 @@ export class Record implements RecordModel {
       ...responseMessage as DwnMessage[DwnInterface.RecordsWrite],
     }, this._permissionsApi);
 
+    // Also mutate *this* record's internal state so that the caller's
+    // original reference reflects the update without having to capture
+    // the returned record. This eliminates the common footgun where
+    // `await record.update({ data }); await record.data.json()` returns
+    // stale data because `update()` historically only returned a *new* Record.
+    const msg = responseMessage as DwnMessage[DwnInterface.RecordsWrite];
+    this._descriptor = msg.descriptor;
+    this._attestation = msg.attestation;
+    this._authorization = msg.authorization;
+    this._encryption = msg.encryption;
+    this._contextId = msg.contextId;
+    this._initialWrite = initialWrite;
+    this._protocolRole = protocolRole ?? this._protocolRole;
+    this._encodedData = data !== undefined ? dataBlob : this._encodedData;
+    this._readableStream = undefined; // Invalidate any consumed stream.
+    this._rawMessageDirty = true; // Force rawMessage cache rebuild.
+
     return { status, record: updatedRecord };
   }
 
   /**
    * Delete the current record on the DWN.
+   *
+   * On success, **both** a new `Record` instance is returned *and* the
+   * current instance (`this`) is mutated in-place to reflect the deleted
+   * state (the {@link Record.deleted | deleted} getter will return `true`).
+   *
    * @param params - Parameters to delete the record.
    * @returns the status and a new Record instance reflecting the deleted state
    */
@@ -675,6 +706,16 @@ export class Record implements RecordModel {
       ...message as DwnMessage[DwnInterface.RecordsDelete],
     }, this._permissionsApi);
 
+    // Also mutate *this* record so the caller's original reference reflects
+    // the deletion without having to capture the returned record.
+    const deleteMsg = message as DwnMessage[DwnInterface.RecordsDelete];
+    this._descriptor = deleteMsg.descriptor;
+    this._authorization = deleteMsg.authorization;
+    this._protocolRole = deleteParams?.protocolRole ?? this._protocolRole;
+    this._encodedData = undefined;
+    this._readableStream = undefined;
+    this._rawMessageDirty = true;
+
     return { status, record: deletedRecord };
   }
 
@@ -799,7 +840,7 @@ export class Record implements RecordModel {
       // When reading the data as a delegate, if we don't find a grant we will attempt to read it with the delegate DID as the author.
       // This allows users to read publicly available data without needing explicit grants.
       //
-      // NOTE: For anonymous/public record data access, callers can use `ReadOnlyRecord` via `Web5.anonymous()`.
+      // NOTE: For anonymous/public record data access, callers can use `ReadOnlyRecord` via `Enbox.anonymous()`.
       // See: https://github.com/enboxorg/enbox/issues/898
       try {
         await this.applyDelegateGrant(readRequest);

package/src/repository-types.ts

@@ -18,7 +18,7 @@ import type {
   TypedCreateRequest,
   TypedQueryRequest,
   TypedSubscribeRequest,
-} from './typed-web5.js';
+} from './typed-enbox.js';
 import type { DwnPaginationCursor, DwnResponseStatus } from '@enbox/agent';
 import type { ProtocolDefinition, ProtocolRuleSet } from '@enbox/dwn-sdk-js';
 
@@ -108,9 +108,12 @@ export type CollectionCRUD<
   M extends SchemaMap,
   Path extends string,
 > = {
-  create(options: CollectionCreateOptions<D, M, Path>): Promise<DwnResponseStatus & { record: TypedRecord<DataAt<D, M, Path>> }>;
+  create(options: CollectionCreateOptions<D, M, Path>): Promise<
+    | (DwnResponseStatus & { record: TypedRecord<DataAt<D, M, Path>> })
+    | (DwnResponseStatus & { record: undefined })
+  >;
   query(options?: TypedQueryRequest): Promise<DwnResponseStatus & { records: TypedRecord<DataAt<D, M, Path>>[]; cursor?: DwnPaginationCursor }>;
-  get(recordId: string): Promise<TypedRecord<DataAt<D, M, Path>>>;
+  get(recordId: string): Promise<TypedRecord<DataAt<D, M, Path>> | undefined>;
   delete(recordId: string): Promise<DwnResponseStatus>;
   subscribe(options?: TypedSubscribeRequest): Promise<TypedLiveQuery<DataAt<D, M, Path>> | undefined>;
 };
@@ -121,7 +124,10 @@ export type SingletonCRUD<
   M extends SchemaMap,
   Path extends string,
 > = {
-  set(options: SingletonSetOptions<D, M, Path>): Promise<DwnResponseStatus & { record: TypedRecord<DataAt<D, M, Path>> }>;
+  set(options: SingletonSetOptions<D, M, Path>): Promise<
+    | (DwnResponseStatus & { record: TypedRecord<DataAt<D, M, Path>> })
+    | (DwnResponseStatus & { record: undefined })
+  >;
   get(): Promise<TypedRecord<DataAt<D, M, Path>> | undefined>;
   delete(recordId: string): Promise<DwnResponseStatus>;
 };
@@ -135,12 +141,15 @@ export type NestedCollectionCRUD<
   create(
     parentContextId: string,
     options: CollectionCreateOptions<D, M, Path>,
-  ): Promise<DwnResponseStatus & { record: TypedRecord<DataAt<D, M, Path>> }>;
+  ): Promise<
+    | (DwnResponseStatus & { record: TypedRecord<DataAt<D, M, Path>> })
+    | (DwnResponseStatus & { record: undefined })
+  >;
   query(
     parentContextId: string,
     options?: TypedQueryRequest,
   ): Promise<DwnResponseStatus & { records: TypedRecord<DataAt<D, M, Path>>[]; cursor?: DwnPaginationCursor }>;
-  get(recordId: string): Promise<TypedRecord<DataAt<D, M, Path>>>;
+  get(recordId: string): Promise<TypedRecord<DataAt<D, M, Path>> | undefined>;
   delete(recordId: string): Promise<DwnResponseStatus>;
   subscribe(
     parentContextId: string,
@@ -157,7 +166,10 @@ export type NestedSingletonCRUD<
   set(
     parentContextId: string,
     options: SingletonSetOptions<D, M, Path>,
-  ): Promise<DwnResponseStatus & { record: TypedRecord<DataAt<D, M, Path>> }>;
+  ): Promise<
+    | (DwnResponseStatus & { record: TypedRecord<DataAt<D, M, Path>> })
+    | (DwnResponseStatus & { record: undefined })
+  >;
   get(parentContextId: string): Promise<TypedRecord<DataAt<D, M, Path>> | undefined>;
   delete(recordId: string): Promise<DwnResponseStatus>;
 };

package/src/repository.ts

@@ -1,7 +1,7 @@
 /**
  * Protocol-aware repository factory.
  *
- * `repository()` takes a `TypedWeb5` instance and returns a Proxy-backed
+ * `repository()` takes a `TypedEnbox` instance and returns a Proxy-backed
  * object whose shape mirrors the protocol's `structure` tree with
  * ergonomic CRUD methods on each node.
  *
@@ -12,7 +12,7 @@
  *
  * @example
  * ```ts
- * const social = repository(web5.using(SocialGraphProtocol));
+ * const social = repository(enbox.using(SocialGraphProtocol));
  * await social.configure();
  *
  * // Root collection
@@ -30,7 +30,7 @@
 import type { DwnResponseStatus } from '@enbox/agent';
 import type { Repository } from './repository-types.js';
 import type { SchemaMap } from './protocol-types.js';
-import type { TypedWeb5 } from './typed-web5.js';
+import type { TypedEnbox } from './typed-enbox.js';
 import type { ProtocolDefinition, ProtocolRuleSet } from '@enbox/dwn-sdk-js';
 
 // ---------------------------------------------------------------------------
@@ -92,7 +92,7 @@ function getChildKeys(definition: ProtocolDefinition, path: string): string[] {
  * Build collection CRUD methods for a root-level path.
  */
 function buildRootCollectionMethods(
-  typed: TypedWeb5<ProtocolDefinition, SchemaMap>,
+  typed: TypedEnbox<ProtocolDefinition, SchemaMap>,
   path: string,
 ): Record<string, Function> {
   return {
@@ -110,7 +110,7 @@ function buildRootCollectionMethods(
       const { record } = await typed.records.read(path, {
         filter: { recordId },
       });
-      return record;
+      return record; // undefined when the read fails (e.g. 404)
     },
 
     async delete(recordId: string): Promise<DwnResponseStatus> {
@@ -133,7 +133,7 @@ function buildRootCollectionMethods(
  * in query-then-create/update.
  */
 function buildRootSingletonMethods(
-  typed: TypedWeb5<ProtocolDefinition, SchemaMap>,
+  typed: TypedEnbox<ProtocolDefinition, SchemaMap>,
   path: string,
 ): Record<string, Function> {
   return {
@@ -171,7 +171,7 @@ function buildRootSingletonMethods(
  * Build collection CRUD methods for a nested path.
  */
 function buildNestedCollectionMethods(
-  typed: TypedWeb5<ProtocolDefinition, SchemaMap>,
+  typed: TypedEnbox<ProtocolDefinition, SchemaMap>,
   path: string,
 ): Record<string, Function> {
   return {
@@ -198,7 +198,7 @@ function buildNestedCollectionMethods(
       const { record } = await typed.records.read(path, {
         filter: { recordId },
       });
-      return record;
+      return record; // undefined when the read fails (e.g. 404)
     },
 
     async delete(recordId: string): Promise<DwnResponseStatus> {
@@ -225,7 +225,7 @@ function buildNestedCollectionMethods(
  * conditions between concurrent set() calls.
  */
 function buildNestedSingletonMethods(
-  typed: TypedWeb5<ProtocolDefinition, SchemaMap>,
+  typed: TypedEnbox<ProtocolDefinition, SchemaMap>,
   path: string,
 ): Record<string, Function> {
   return {
@@ -276,7 +276,7 @@ function buildNestedSingletonMethods(
  * and Proxy-based child nodes.
  */
 function buildNode(
-  typed: TypedWeb5<ProtocolDefinition, SchemaMap>,
+  typed: TypedEnbox<ProtocolDefinition, SchemaMap>,
   definition: ProtocolDefinition,
   path: string,
   isNested: boolean,
@@ -324,7 +324,7 @@ function buildNode(
 // ---------------------------------------------------------------------------
 
 /**
- * Creates a protocol-aware repository from a `TypedWeb5` instance.
+ * Creates a protocol-aware repository from a `TypedEnbox` instance.
  *
  * The returned object provides domain-specific CRUD methods that mirror
  * the protocol's structure tree:
@@ -334,12 +334,12 @@ function buildNode(
  * - Singletons: `repo.profile.set()`, `repo.profile.get()`
  * - Protocol install: `repo.configure()`
  *
- * @param typed - A `TypedWeb5` instance from `web5.using(protocol)`.
+ * @param typed - A `TypedEnbox` instance from `enbox.using(protocol)`.
  * @returns A typed repository object.
  *
  * @example
  * ```ts
- * const social = repository(web5.using(SocialGraphProtocol));
+ * const social = repository(enbox.using(SocialGraphProtocol));
  * await social.configure();
  *
  * const rec = await social.friend.create({
@@ -351,7 +351,7 @@ function buildNode(
 export function repository<
   D extends ProtocolDefinition,
   M extends SchemaMap,
->(typed: TypedWeb5<D, M>): Repository<D, M> {
+>(typed: TypedEnbox<D, M>): Repository<D, M> {
   const definition = typed.definition as ProtocolDefinition;
 
   // Get root-level type keys from the structure
@@ -374,7 +374,7 @@ export function repository<
       if (rootKeys.includes(prop)) {
         if (!(prop in nodeCache)) {
           nodeCache[prop] = buildNode(
-            typed as unknown as TypedWeb5<ProtocolDefinition, SchemaMap>,
+            typed as unknown as TypedEnbox<ProtocolDefinition, SchemaMap>,
             definition,
             prop,
             false,