@dxos/protocols 0.8.4-main.5ea62a8 → 0.8.4-main.66e292d

package/src/errors/errors.ts

@@ -2,167 +2,105 @@
 // Copyright 2021 DXOS.org
 //
 
+import { BaseError } from '@dxos/errors';
 import { PublicKey } from '@dxos/keys';
 
 import type { ObjectId } from '../types.js';
 
-import { ApiError, BaseError, DatabaseError, SystemError } from './base-errors.js';
 import { registerError, registerErrorMessageContext, registerErrorNoArgs } from './helpers.js';
 
 /**
  * Thrown when request was terminated because the RPC endpoint has been closed.
  */
-export class RpcClosedError extends SystemError {
-  constructor() {
-    super('RPC_CLOSED', 'Request was terminated because the RPC endpoint is closed.');
-  }
-}
+export class RpcClosedError extends BaseError.extend(
+  'RPC_CLOSED',
+  'Request was terminated because the RPC endpoint is closed.',
+) {}
 
 registerErrorNoArgs('RPC_CLOSED', RpcClosedError);
 
 /**
  * Thrown when `request` is called when RPC has not been opened.
  */
-export class RpcNotOpenError extends SystemError {
-  constructor() {
-    super('RPC_NOT_OPEN', 'RPC has not been opened.');
-  }
-}
+export class RpcNotOpenError extends BaseError.extend('RPC_NOT_OPEN', 'RPC has not been opened.') {}
 
 registerErrorNoArgs('RPC_NOT_OPEN', RpcNotOpenError);
 
-export class CancelledError extends SystemError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('CANCELLED', message, context);
-  }
-}
+export class CancelledError extends BaseError.extend('CANCELLED') {}
 
 registerErrorMessageContext('CANCELLED', CancelledError);
 
-export class InvalidConfigError extends ApiError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('INVALID_CONFIG', message, context);
-  }
-}
+export class InvalidConfigError extends BaseError.extend('INVALID_CONFIG') {}
 
 registerErrorMessageContext('INVALID_CONFIG', InvalidConfigError);
 
 /**
  * Explicit failure to connect with remote client services.
  */
-export class RemoteServiceConnectionError extends ApiError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('REMOTE_SERVICE_CONNECTION_ERROR', message, context);
-  }
-}
+export class RemoteServiceConnectionError extends BaseError.extend('REMOTE_SERVICE_CONNECTION_ERROR') {}
 
 registerErrorMessageContext('REMOTE_SERVICE_CONNECTION_ERROR', RemoteServiceConnectionError);
 
 /**
  * Failed to open a connection to remote client services.
  */
-export class RemoteServiceConnectionTimeout extends ApiError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('REMOTE_SERVICE_CONNECTION_TIMEOUT', message, context);
-  }
-}
+export class RemoteServiceConnectionTimeout extends BaseError.extend('REMOTE_SERVICE_CONNECTION_TIMEOUT') {}
 
 registerErrorMessageContext('REMOTE_SERVICE_CONNECTION_TIMEOUT', RemoteServiceConnectionTimeout);
 
-export class DataCorruptionError extends SystemError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('DATA_CORRUPTION', message, context);
-  }
-}
+export class DataCorruptionError extends BaseError.extend('DATA_CORRUPTION') {}
 
 registerErrorMessageContext('DATA_CORRUPTION', DataCorruptionError);
 
-export class InvalidInvitationExtensionRoleError extends SystemError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('INVALID_INVITATION_EXTENSION_ROLE', message, context);
-  }
-}
+export class InvalidInvitationExtensionRoleError extends BaseError.extend('INVALID_INVITATION_EXTENSION_ROLE') {}
 
 registerErrorMessageContext('INVALID_INVITATION_EXTENSION_ROLE', InvalidInvitationExtensionRoleError);
 
-export class IdentityNotInitializedError extends DatabaseError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('IDENTITY_NOT_INITIALIZED', message, context);
-  }
-}
+export class IdentityNotInitializedError extends BaseError.extend('IDENTITY_NOT_INITIALIZED') {}
 
 registerErrorMessageContext('IDENTITY_NOT_INITIALIZED', IdentityNotInitializedError);
 
-export class InvalidInvitationError extends DatabaseError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('INVALID_INVITATION', message, context);
-  }
-}
+export class InvalidInvitationError extends BaseError.extend('INVALID_INVITATION') {}
 
 registerErrorMessageContext('INVALID_INVITATION', InvalidInvitationError);
 
-export class AlreadyJoinedError extends DatabaseError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('ALREADY_JOINED', message, context);
-  }
-}
+export class AlreadyJoinedError extends BaseError.extend('ALREADY_JOINED') {}
 
 registerErrorMessageContext('ALREADY_JOINED', AlreadyJoinedError);
 
-export class ConnectionResetError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('CONNECTION_RESET', message, context);
-  }
-}
+export class ConnectionResetError extends BaseError.extend('CONNECTION_RESET') {}
 
 registerErrorMessageContext('CONNECTION_RESET', ConnectionResetError);
 
-export class TimeoutError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('TIMEOUT', message, context);
-  }
-}
+export class TimeoutError extends BaseError.extend('TIMEOUT') {}
 
 registerErrorMessageContext('TIMEOUT', TimeoutError);
 
 // General protocol error.
-export class ProtocolError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('PROTOCOL_ERROR', message, context);
-  }
-}
+export class ProtocolError extends BaseError.extend('PROTOCOL_ERROR') {}
 
-registerErrorMessageContext('PROTOCOL_ERROR', ProtocolError);
+registerErrorMessageContext(ProtocolError.code, ProtocolError);
 
 // General connectivity errors.
-export class ConnectivityError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('CONNECTIVITY_ERROR', message, context);
-  }
-}
+export class ConnectivityError extends BaseError.extend('CONNECTIVITY_ERROR') {}
 
 registerErrorMessageContext('CONNECTIVITY_ERROR', ConnectivityError);
 
-export class RateLimitExceededError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('RATE_LIMIT_EXCEEDED', message, context);
-  }
-}
+export class RateLimitExceededError extends BaseError.extend('RATE_LIMIT_EXCEEDED') {}
 
 registerErrorMessageContext('RATE_LIMIT_EXCEEDED', RateLimitExceededError);
 
 // TODO(nf): Rename? the protocol isn't what's unknown...
-export class UnknownProtocolError extends BaseError {
-  constructor(message?: string, innerError?: Error) {
-    super('UNKNOWN_PROTOCOL_ERROR', message, innerError);
-  }
-}
+export class UnknownProtocolError extends BaseError.extend('UNKNOWN_PROTOCOL_ERROR') {}
 
-registerErrorMessageContext('UNKNOWN_PROTOCOL_ERROR', UnknownProtocolError);
+registerError(UnknownProtocolError.code, (message, context) => new UnknownProtocolError({ message, context }));
 
-export class InvalidStorageVersionError extends DatabaseError {
+export class InvalidStorageVersionError extends BaseError.extend(
+  'INVALID_STORAGE_VERSION',
+  'Invalid storage version.',
+) {
   constructor(expected: number, actual: number) {
-    super('INVALID_STORAGE_VERSION', 'Invalid storage version.', { expected, actual });
+    super({ context: { expected, actual } });
   }
 }
 
@@ -170,9 +108,9 @@ registerError('INVALID_STORAGE_VERSION', (_, context) => {
   return new InvalidStorageVersionError(context.expected ?? NaN, context.actual ?? NaN);
 });
 
-export class SpaceNotFoundError extends DatabaseError {
+export class SpaceNotFoundError extends BaseError.extend('SPACE_NOT_FOUND', 'Space not found.') {
   constructor(spaceKey: PublicKey) {
-    super('SPACE_NOT_FOUND', 'Space not found.', { spaceKey });
+    super({ context: { spaceKey } });
   }
 }
 
@@ -180,9 +118,9 @@ registerError('SPACE_NOT_FOUND', (_, context) => {
   return new SpaceNotFoundError(PublicKey.safeFrom(context.spaceKey) ?? PublicKey.from('00'));
 });
 
-export class EntityNotFoundError extends DatabaseError {
+export class EntityNotFoundError extends BaseError.extend('ITEM_NOT_FOUND', 'Item not found.') {
   constructor(entityId: ObjectId) {
-    super('ITEM_NOT_FOUND', 'Item not found.', { entityId });
+    super({ context: { entityId } });
   }
 }
 
@@ -190,9 +128,9 @@ registerError('ITEM_NOT_FOUND', (_, context) => {
   return new EntityNotFoundError(context.entityId);
 });
 
-export class UnknownModelError extends DatabaseError {
+export class UnknownModelError extends BaseError.extend('UNKNOWN_MODEL', 'Unknown model.') {
   constructor(model: string) {
-    super('UNKNOWN_MODEL', 'Unknown model.', { model });
+    super({ context: { model } });
   }
 }
 
@@ -200,10 +138,6 @@ registerError('UNKNOWN_MODEL', (_, context) => {
   return new UnknownModelError(context.model);
 });
 
-export class AuthorizationError extends ApiError {
-  constructor(message?: string, context?: any) {
-    super('AUTHORIZATION_ERROR', message, context);
-  }
-}
+export class AuthorizationError extends BaseError.extend('AUTHORIZATION_ERROR') {}
 
 registerErrorMessageContext('AUTHORIZATION_ERROR', AuthorizationError);

package/src/errors/helpers.ts

@@ -2,12 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
+import { BaseError } from '@dxos/errors';
 import { invariant } from '@dxos/invariant';
 
 import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.js';
 
-import { SystemError } from './base-errors.js';
-
 export const reconstructError = (error: SerializedErrorProto) => {
   const { name, message, context } = error;
   return errorFromCode(name, message, context);
@@ -20,21 +19,21 @@ export const registerError = (code: string, make: (message?: string, context?: a
   errorRegistry.set(code, make);
 };
 
-export const registerErrorNoArgs = (code: string, Constructor: { new (): Error }) => {
+export const registerErrorNoArgs = (code: string, Constructor: { new (options?: any): Error }) => {
   registerError(code, () => new Constructor());
 };
 
 export const registerErrorMessageContext = (
   code: string,
-  Constructor: { new (message?: string, context?: any): Error },
+  Constructor: { new (options?: { message?: string; context?: any }): Error },
 ) => {
-  registerError(code, (message?: string, context?: string) => new Constructor(message, context));
+  registerError(code, (message?: string, context?: any) => new Constructor({ message, context }));
 };
 
 export const errorFromCode = (code?: string, message?: string, context?: any) => {
   if (code && errorRegistry.has(code)) {
     return errorRegistry.get(code)!(message, context);
   } else {
-    return new SystemError(code ?? 'Error', message, context);
+    return new BaseError(code ?? 'Error', { message, context });
   }
 };

package/src/feed-replication.ts

@@ -12,6 +12,7 @@ export type FeedBlock = {
   }[];
   signature: Uint8Array;
 };
+
 export type GetMetadataProtocolMessage = {
   type: 'get-metadata';
   feedKey: string;

package/src/index.ts

@@ -2,15 +2,18 @@
 // Copyright 2021 DXOS.org
 //
 
+// TODO(burdon): Why export .js?
+
+export * from './automerge.js';
+export * from './edge/index.js';
 export * from './errors/index.js';
 export * from './indexing.js';
+export * from './messenger.js';
+export * from './profile-archive.js';
+export * from './query.js';
+export * from './queue.js';
+export * from './space-archive.js';
 export * from './storage.js';
 export * from './tracing.js';
 export type * from './types.js';
-export * from './query.js';
-export * from './profile-archive.js';
-export * from './automerge.js';
-export * from './edge.js';
-export type * from './queue.js';
-export * from './space-archive.js';
-export * from './edge-error.js';
+export * as FunctionProtocol from './FunctionProtocol.js';

package/src/indexing.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 export type ObjectPointerDecoded = {
   spaceKey: string | undefined;

package/src/invitation.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { ParamKeyAnnotation } from '@dxos/effect';
 

package/src/messenger.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type CleanupFn } from '@dxos/async';
+
+import { type GossipMessage } from './proto/gen/dxos/mesh/teleport/gossip';
+
+/**
+ * Message passing abstraction.
+ */
+export interface Messenger {
+  /**
+   * Register channel listener.
+   */
+  listen: (channel: string, callback: (message: GossipMessage) => void) => CleanupFn;
+
+  /**
+   * Send message to channel.
+   */
+  postMessage: (channel: string, message: any) => Promise<void>;
+}

package/src/proto/dxos/client/services.proto

@@ -596,9 +596,26 @@ service EdgeAgentService {
   rpc QueryAgentStatus(google.protobuf.Empty) returns (stream QueryAgentStatusResponse);
 }
 
-enum EdgeStatus {
-  NOT_CONNECTED = 0;
-  CONNECTED = 1;
+message EdgeStatus {
+  enum ConnectionState {
+    NOT_CONNECTED = 0;
+    CONNECTED = 1;
+  }
+
+  ConnectionState state = 1;
+  /** Latency in ms */
+  int32 rtt = 2;
+
+  /** How long the connection has been up */
+  int32 uptime = 3;
+
+  /** Upload rate in bytes per second */
+  int32 rate_bytes_up = 4;
+  /** Download rate in bytes per second */
+  int32 rate_bytes_down = 5;
+
+  int32 messages_sent = 6;
+  int32 messages_received = 7;
 }
 
 message QueryEdgeStatusResponse {

package/src/proto/dxos/echo/service.proto

@@ -128,6 +128,17 @@ message SpaceSyncState {
      * Total number of documents on the remote peer.
      */
     int32 remote_document_count = 14;
+
+    /**
+     * Total number of documents across this peer and the remote peer.
+     */
+    int32 total_document_count = 15;
+
+    /**
+    * Total number of documents that are not synced.
+    * Includes documents that are present only locally, only on the remote peer, or whether the peers have different versions.
+    */
+    int32 unsynced_document_count = 16;
   }
 
   repeated PeerState peers = 1;

package/src/proto/gen/dxos/client/services.ts

@@ -1399,9 +1399,36 @@ export interface EdgeAgentService {
  * Defined in:
  *   {@link file://./../../../dxos/client/services.proto}
  */
-export enum EdgeStatus {
-    NOT_CONNECTED = 0,
-    CONNECTED = 1
+export interface EdgeStatus {
+    state: EdgeStatus.ConnectionState;
+    /**
+     * Latency in ms
+     */
+    rtt: number;
+    /**
+     * How long the connection has been up
+     */
+    uptime: number;
+    /**
+     * Upload rate in bytes per second
+     */
+    rateBytesUp: number;
+    /**
+     * Download rate in bytes per second
+     */
+    rateBytesDown: number;
+    messagesSent: number;
+    messagesReceived: number;
+}
+export namespace EdgeStatus {
+    /**
+     * Defined in:
+     *   {@link file://./../../../dxos/client/services.proto}
+     */
+    export enum ConnectionState {
+        NOT_CONNECTED = 0,
+        CONNECTED = 1
+    }
 }
 /**
  * Defined in:

package/src/proto/gen/dxos/echo/service.ts

@@ -228,6 +228,15 @@ export namespace SpaceSyncState {
          * Total number of documents on the remote peer.
          */
         remoteDocumentCount: number;
+        /**
+         * Total number of documents across this peer and the remote peer.
+         */
+        totalDocumentCount: number;
+        /**
+         * Total number of documents that are not synced.
+         * Includes documents that are present only locally, only on the remote peer, or whether the peers have different versions.
+         */
+        unsyncedDocumentCount: number;
     }
 }
 /**