@dxos/protocols 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

package/src/errors/base-errors.ts

@@ -6,37 +6,21 @@
  * NOTE: Messages should be sentences (Start with a capital letter and end with a period).
  * Errors can optionally include a JSON context object.
  */
-export class BaseError extends Error {
-  constructor(
-    readonly code: string,
-    message?: string,
-    readonly context?: Record<string, any>,
-  ) {
-    // TODO(dmaretskyi): Error.cause.
-    super(message ?? code);
-    this.name = code;
-    // NOTE: Restores prototype chain (https://stackoverflow.com/a/48342359).
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-}
-
-// TODO(dmaretskyi): Consider common error classes with error codes:
-// throw new SystemError(ERROR_CODE_OUT_OF_MEMORY, 'Out of memory', { a: 1, b: 2 });
+import { BaseError } from '@dxos/errors';
 
 /**
  * User facing API Errors.
  * E.g., something was misconfigured.
  */
-export class ApiError extends BaseError {}
+export class ApiError extends BaseError.extend('ApiError') {}
 
 /**
  * Internal system errors.
  * E.g., unexpected/unrecoverable runtime error.
  */
-export class SystemError extends BaseError {}
+export class SystemError extends BaseError.extend('SystemError') {}
 
 /**
  * Database errors.
  */
-// TODO(wittjosiah): Same as ApiError?
-export class DatabaseError extends BaseError {}
+export class DatabaseError extends BaseError.extend('DatabaseError') {}

package/src/errors/encoding.ts

@@ -2,8 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import { reconstructError } from './helpers.js';
-import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.js';
+import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.ts';
+
+import { reconstructError } from './helpers.ts';
 
 export const encodeError = (err: any): SerializedErrorProto => {
   if (typeof err === 'object' && err?.message) {

package/src/errors/errors.test.ts

@@ -4,12 +4,12 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { ApiError } from './base-errors.js';
+import { ApiError } from './base-errors.ts';
 
 describe('Errors', () => {
   test('test', async () => {
     const runTest = async () => {
-      throw new ApiError('Test error');
+      throw new ApiError({ message: 'Test error' });
     };
 
     await expect(runTest()).rejects.toThrowError('Test error');

package/src/errors/errors.ts

@@ -2,207 +2,142 @@
 // Copyright 2021 DXOS.org
 //
 
+import { BaseError } from '@dxos/errors';
 import { PublicKey } from '@dxos/keys';
 
-import { ApiError, BaseError, DatabaseError, SystemError } from './base-errors.js';
-import { registerError, registerErrorMessageContext, registerErrorNoArgs } from './helpers.js';
-import type { ObjectId } from '../types.js';
+import type { ObjectId } from '../types.ts';
+
+import { registerError, registerErrorMessageContext, registerErrorNoArgs } from './helpers.ts';
 
 /**
  * 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(
+  'RpcClosedError',
+  'Request was terminated because the RPC endpoint is closed.',
+) {}
 
-registerErrorNoArgs('RPC_CLOSED', RpcClosedError);
+registerErrorNoArgs('RpcClosedError', 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('RpcNotOpenError', 'RPC has not been opened.') {}
 
-registerErrorNoArgs('RPC_NOT_OPEN', RpcNotOpenError);
+registerErrorNoArgs('RpcNotOpenError', RpcNotOpenError);
 
-export class CancelledError extends SystemError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('CANCELLED', message, context);
-  }
-}
+export class CancelledError extends BaseError.extend('CancelledError') {}
 
-registerErrorMessageContext('CANCELLED', CancelledError);
+registerErrorMessageContext('CancelledError', CancelledError);
 
-export class InvalidConfigError extends ApiError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('INVALID_CONFIG', message, context);
-  }
-}
+export class InvalidConfigError extends BaseError.extend('InvalidConfigError') {}
 
-registerErrorMessageContext('INVALID_CONFIG', InvalidConfigError);
+registerErrorMessageContext('InvalidConfigError', 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('RemoteServiceConnectionError') {}
 
-registerErrorMessageContext('REMOTE_SERVICE_CONNECTION_ERROR', RemoteServiceConnectionError);
+registerErrorMessageContext('RemoteServiceConnectionError', 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('RemoteServiceConnectionTimeout') {}
 
-registerErrorMessageContext('REMOTE_SERVICE_CONNECTION_TIMEOUT', RemoteServiceConnectionTimeout);
+registerErrorMessageContext('RemoteServiceConnectionTimeout', RemoteServiceConnectionTimeout);
 
-export class DataCorruptionError extends SystemError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('DATA_CORRUPTION', message, context);
-  }
-}
+export class DataCorruptionError extends BaseError.extend('DataCorruptionError') {}
 
-registerErrorMessageContext('DATA_CORRUPTION', DataCorruptionError);
+registerErrorMessageContext('DataCorruptionError', 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('InvalidInvitationExtensionRoleError') {}
 
-registerErrorMessageContext('INVALID_INVITATION_EXTENSION_ROLE', InvalidInvitationExtensionRoleError);
+registerErrorMessageContext('InvalidInvitationExtensionRoleError', 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('IdentityNotInitializedError') {}
 
-registerErrorMessageContext('IDENTITY_NOT_INITIALIZED', IdentityNotInitializedError);
+registerErrorMessageContext('IdentityNotInitializedError', IdentityNotInitializedError);
 
-export class InvalidInvitationError extends DatabaseError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('INVALID_INVITATION', message, context);
-  }
-}
+export class InvalidInvitationError extends BaseError.extend('InvalidInvitationError') {}
 
-registerErrorMessageContext('INVALID_INVITATION', InvalidInvitationError);
+registerErrorMessageContext('InvalidInvitationError', InvalidInvitationError);
 
-export class AlreadyJoinedError extends DatabaseError {
-  constructor(message?: string, context?: Record<string, any>) {
-    super('ALREADY_JOINED', message, context);
-  }
-}
+export class AlreadyJoinedError extends BaseError.extend('AlreadyJoinedError') {}
 
-registerErrorMessageContext('ALREADY_JOINED', AlreadyJoinedError);
+registerErrorMessageContext('AlreadyJoinedError', AlreadyJoinedError);
 
-export class ConnectionResetError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('CONNECTION_RESET', message, context);
-  }
-}
+export class ConnectionResetError extends BaseError.extend('ConnectionResetError') {}
 
-registerErrorMessageContext('CONNECTION_RESET', ConnectionResetError);
+registerErrorMessageContext('ConnectionResetError', ConnectionResetError);
 
-export class TimeoutError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('TIMEOUT', message, context);
-  }
-}
+export class TimeoutError extends BaseError.extend('TimeoutError') {}
 
-registerErrorMessageContext('TIMEOUT', TimeoutError);
+registerErrorMessageContext('TimeoutError', 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('ProtocolError') {}
 
-registerErrorMessageContext('PROTOCOL_ERROR', ProtocolError);
+registerErrorMessageContext(ProtocolError.name, 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('ConnectivityError') {}
 
-registerErrorMessageContext('CONNECTIVITY_ERROR', ConnectivityError);
+registerErrorMessageContext('ConnectivityError', ConnectivityError);
 
-export class RateLimitExceededError extends BaseError {
-  constructor(message?: string, context?: any) {
-    super('RATE_LIMIT_EXCEEDED', message, context);
-  }
-}
+export class RateLimitExceededError extends BaseError.extend('RateLimitExceededError') {}
 
-registerErrorMessageContext('RATE_LIMIT_EXCEEDED', RateLimitExceededError);
+registerErrorMessageContext('RateLimitExceededError', 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('UnknownProtocolError') {}
 
-registerErrorMessageContext('UNKNOWN_PROTOCOL_ERROR', UnknownProtocolError);
+registerError(UnknownProtocolError.name, (message, context) => new UnknownProtocolError({ message, context }));
 
-export class InvalidStorageVersionError extends DatabaseError {
+export class InvalidStorageVersionError extends BaseError.extend(
+  'InvalidStorageVersionError',
+  'Invalid storage version.',
+) {
   constructor(expected: number, actual: number) {
-    super('INVALID_STORAGE_VERSION', 'Invalid storage version.', { expected, actual });
+    super({ context: { expected, actual } });
   }
 }
 
-registerError('INVALID_STORAGE_VERSION', (_, context) => {
+registerError('InvalidStorageVersionError', (_, context) => {
   return new InvalidStorageVersionError(context.expected ?? NaN, context.actual ?? NaN);
 });
 
-export class SpaceNotFoundError extends DatabaseError {
+export class SpaceNotFoundError extends BaseError.extend('SpaceNotFoundError', 'Space not found.') {
   constructor(spaceKey: PublicKey) {
-    super('SPACE_NOT_FOUND', 'Space not found.', { spaceKey });
+    super({ context: { spaceKey } });
   }
 }
 
-registerError('SPACE_NOT_FOUND', (_, context) => {
+registerError('SpaceNotFoundError', (_, context) => {
   return new SpaceNotFoundError(PublicKey.safeFrom(context.spaceKey) ?? PublicKey.from('00'));
 });
 
-export class EntityNotFoundError extends DatabaseError {
+export class EntityNotFoundError extends BaseError.extend('EntityNotFoundError', 'Item not found.') {
   constructor(entityId: ObjectId) {
-    super('ITEM_NOT_FOUND', 'Item not found.', { entityId });
+    super({ context: { entityId } });
   }
 }
 
-registerError('ITEM_NOT_FOUND', (_, context) => {
+registerError('EntityNotFoundError', (_, context) => {
   return new EntityNotFoundError(context.entityId);
 });
 
-export class UnknownModelError extends DatabaseError {
+export class UnknownModelError extends BaseError.extend('UnknownModelError', 'Unknown model.') {
   constructor(model: string) {
-    super('UNKNOWN_MODEL', 'Unknown model.', { model });
+    super({ context: { model } });
   }
 }
 
-registerError('UNKNOWN_MODEL', (_, context) => {
+registerError('UnknownModelError', (_, 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('AuthorizationError') {}
 
-registerErrorMessageContext('AUTHORIZATION_ERROR', AuthorizationError);
+registerErrorMessageContext('AuthorizationError', AuthorizationError);

package/src/errors/helpers.ts

@@ -2,10 +2,10 @@
 // Copyright 2023 DXOS.org
 //
 
+import { BaseError } from '@dxos/errors';
 import { invariant } from '@dxos/invariant';
 
-import { SystemError } from './base-errors.js';
-import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.js';
+import { type Error as SerializedErrorProto } from '../proto/gen/dxos/error.ts';
 
 export const reconstructError = (error: SerializedErrorProto) => {
   const { name, message, context } = error;
@@ -19,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/errors/index.ts

@@ -2,8 +2,8 @@
 // Copyright 2022 DXOS.org
 //
 
-export * from './encoding.js';
-export * from './errors.js';
-export * from './helpers.js';
-export * from './base-errors.js';
-export * from './parameter.js';
+export * from './encoding.ts';
+export * from './errors.ts';
+export * from './helpers.ts';
+export * from './base-errors.ts';
+export * from './parameter.ts';

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,15 @@
 // Copyright 2021 DXOS.org
 //
 
-export * from './errors/index.js';
-export * from './indexing.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 * from './automerge.ts';
+export * from './edge/index.ts';
+export * from './errors/index.ts';
+export * from './indexing.ts';
+export * from './messenger.ts';
+export * from './profile-archive.ts';
+export * from './space-archive.ts';
+export * from './storage.ts';
+export * from './tracing.ts';
+export type * from './types.ts';
+export * as FunctionProtocol from './FunctionProtocol.ts';
+export * as FeedProtocol from './FeedProtocol.ts';

package/src/indexing.test.ts

@@ -4,7 +4,7 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { ObjectPointerVersion, objectPointerCodec } from './indexing.js';
+import { ObjectPointerVersion, objectPointerCodec } from './indexing.ts';
 
 describe('Indexing object pointer codec', () => {
   test('getVersion', async () => {

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/queue.proto

@@ -0,0 +1,78 @@
+syntax = "proto3";
+
+package dxos.client.services;
+
+import "google/protobuf/struct.proto";
+import "google/protobuf/empty.proto";
+
+
+message QueueQuery {
+  string space_id = 1;
+
+  optional string queues_namespace = 2;
+
+  /// Queries the whole space if missing.
+  repeated string queue_ids = 3;
+
+  /// Filter items after this cursor. Exclusive.
+  optional string after = 4;
+
+  /// Filter items before this cursor. Exclusive.
+  optional string before = 5;
+
+  /// Filter items after this position. Inclusive.
+  optional int64 begin_position = 6;
+
+  /// Filter items before this position. Exclusive.
+  optional int64 end_position = 7;
+
+  optional int32 limit = 8;
+  optional bool reverse = 9;
+
+  // TODO(dmaretskyi): Remove this field -- raw queues dont index object IDs anymore.
+  repeated string object_ids = 100;
+}
+
+message QueueQueryResult {
+  repeated google.protobuf.Struct objects = 1;
+
+  /// Cursor to query the next items. Can be passed to `after` in query to keep querying. 
+  string next_cursor = 2;
+
+  string prev_cursor = 3;
+}
+
+message QueryQueueRequest {
+  QueueQuery query = 1;
+}
+
+message InsertIntoQueueRequest {
+  string subspace_tag = 1;
+  string space_id = 2;
+  string queue_id = 3;
+  repeated google.protobuf.Struct objects = 4;
+}
+
+message DeleteFromQueueRequest {
+  string subspace_tag = 1;
+  string space_id = 2;
+  string queue_id = 3;
+  repeated string object_ids = 4;
+}
+
+message SyncQueueRequest {
+  string subspace_tag = 1;
+  string space_id = 2;
+  string queue_id = 3;
+  /// Whether to push local changes to the server. Defaults to true.
+  optional bool should_push = 4;
+  /// Whether to pull remote changes from the server. Defaults to true.
+  optional bool should_pull = 5;
+}
+
+service QueueService {
+  rpc QueryQueue(QueryQueueRequest) returns (QueueQueryResult);
+  rpc InsertIntoQueue(InsertIntoQueueRequest) returns (google.protobuf.Empty);
+  rpc DeleteFromQueue(DeleteFromQueueRequest) returns (google.protobuf.Empty);
+  rpc SyncQueue(SyncQueueRequest) returns (google.protobuf.Empty);
+}

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

@@ -72,6 +72,7 @@ message Platform {
     BROWSER = 0;
     SHARED_WORKER = 1;
     NODE = 2;
+    DEDICATED_WORKER = 3;
   }
 
   PLATFORM_TYPE type = 1;
@@ -331,6 +332,8 @@ message Space {
   optional PipelineState pipeline = 3;
   optional dxos.error.Error error = 4;
   optional dxos.echo.metadata.EdgeReplicationSetting edge_replication = 6;
+  repeated string tags = 7;
+  dxos.halo.credentials.MembershipPolicy membership_policy = 8;
 
   repeated SpaceMember members = 10;
   optional dxos.keys.PublicKey creator = 11;
@@ -341,6 +344,11 @@ message Space {
 
 // TODO(burdon): Create type for epoch?
 
+message CreateSpaceRequest {
+  repeated string tags = 1;
+  dxos.halo.credentials.MembershipPolicy membership_policy = 2;
+}
+
 message UpdateSpaceRequest {
   dxos.keys.PublicKey space_key = 1;
 
@@ -457,7 +465,7 @@ message ImportSpaceResponse {
 }
 
 service SpacesService {
-  rpc CreateSpace(google.protobuf.Empty) returns (Space);
+  rpc CreateSpace(CreateSpaceRequest) returns (Space);
   rpc UpdateSpace(UpdateSpaceRequest) returns (google.protobuf.Empty);
   rpc QuerySpaces(google.protobuf.Empty) returns (stream QuerySpacesResponse);
 
@@ -596,9 +604,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 {