@dxos/client-services 0.8.3 → 0.8.4-main.1068cf700f

package/src/packlets/invitations/invitations-handler.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { type PushStream, scheduleTask, TimeoutError, type Trigger } from '@dxos/async';
+import { type PushStream, TimeoutError, type Trigger, scheduleTask } from '@dxos/async';
 import { INVITATION_TIMEOUT, getExpirationTime } from '@dxos/client-protocol';
 import { type Context, ContextDisposedError } from '@dxos/context';
 import { createKeyPair, sign } from '@dxos/crypto';
@@ -10,19 +10,19 @@ import { type EdgeHttpClient } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { createTeleportProtocolFactory, type SwarmNetworkManager, type SwarmConnection } from '@dxos/network-manager';
+import { type SwarmConnection, type SwarmNetworkManager, createTeleportProtocolFactory } from '@dxos/network-manager';
 import { InvalidInvitationError, InvalidInvitationExtensionRoleError, trace } from '@dxos/protocols';
 import { type AdmissionKeypair, Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { AuthenticationResponse, type IntroductionResponse } from '@dxos/protocols/proto/dxos/halo/invitations';
 import { InvitationOptions } from '@dxos/protocols/proto/dxos/halo/invitations';
-import { type ExtensionContext, type TeleportExtension, type TeleportParams } from '@dxos/teleport';
+import { type ExtensionContext, type TeleportExtension, type TeleportProps } from '@dxos/teleport';
 import { trace as _trace } from '@dxos/tracing';
 import { ComplexSet } from '@dxos/util';
 
 import { type EdgeInvitationConfig, EdgeInvitationHandler } from './edge-invitation-handler';
 import { InvitationGuestExtension } from './invitation-guest-extenstion';
-import { InvitationHostExtension, isAuthenticationRequired, MAX_OTP_ATTEMPTS } from './invitation-host-extension';
+import { InvitationHostExtension, MAX_OTP_ATTEMPTS, isAuthenticationRequired } from './invitation-host-extension';
 import { type InvitationProtocol } from './invitation-protocol';
 import { createGuardedInvitationState } from './invitation-state';
 import { InvitationTopology } from './invitation-topology';
@@ -31,8 +31,8 @@ const metrics = _trace.metrics;
 
 const MAX_DELEGATED_INVITATION_HOST_TRIES = 3;
 
-export type InvitationConnectionParams = {
-  teleport: Partial<TeleportParams>;
+export type InvitationConnectionProps = {
+  teleport: Partial<TeleportProps>;
   edgeInvitations?: EdgeInvitationConfig;
 };
 
@@ -71,7 +71,7 @@ export class InvitationsHandler {
   constructor(
     private readonly _networkManager: SwarmNetworkManager,
     private readonly _edgeClient?: EdgeHttpClient,
-    private readonly _connectionParams?: InvitationConnectionParams,
+    private readonly _connectionProps?: InvitationConnectionProps,
   ) {}
 
   handleInvitationFlow(
@@ -388,7 +388,7 @@ export class InvitationsHandler {
       return extension;
     };
 
-    const edgeInvitationHandler = new EdgeInvitationHandler(this._connectionParams?.edgeInvitations, this._edgeClient, {
+    const edgeInvitationHandler = new EdgeInvitationHandler(this._connectionProps?.edgeInvitations, this._edgeClient, {
       onInvitationSuccess: async (admissionResponse, admissionRequest) => {
         const result = await protocol.accept(admissionResponse, admissionRequest);
         log.info('admitted by edge', { ...protocol.toJSON() });
@@ -440,7 +440,7 @@ export class InvitationsHandler {
       topic: invitation.swarmKey,
       protocolProvider: createTeleportProtocolFactory(async (teleport) => {
         teleport.addExtension('dxos.halo.invitations', extensionFactory());
-      }, this._connectionParams?.teleport),
+      }, this._connectionProps?.teleport),
       topology: new InvitationTopology(role),
       label,
     });
@@ -503,7 +503,7 @@ export class InvitationsHandler {
 const checkInvitation = (protocol: InvitationProtocol, invitation: Partial<Invitation>) => {
   const expiresOn = getExpirationTime(invitation);
   if (expiresOn && expiresOn.getTime() < Date.now()) {
-    return new InvalidInvitationError('Invitation already expired.');
+    return new InvalidInvitationError({ message: 'Invitation already expired.' });
   }
   return protocol.checkInvitation(invitation);
 };

package/src/packlets/invitations/invitations-manager.ts

@@ -4,14 +4,14 @@
 
 import { Event, PushStream, TimeoutError, Trigger } from '@dxos/async';
 import {
-  AuthenticatingInvitation,
   AUTHENTICATION_CODE_LENGTH,
+  AuthenticatingInvitation,
   CancellableInvitation,
   INVITATION_TIMEOUT,
 } from '@dxos/client-protocol';
 import { Context } from '@dxos/context';
 import { generatePasscode } from '@dxos/credentials';
-import { hasInvitationExpired, type MetadataStore } from '@dxos/echo-pipeline';
+import { type MetadataStore, hasInvitationExpired } from '@dxos/echo-pipeline';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -23,7 +23,7 @@ import {
 import { SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 
 import type { InvitationProtocol } from './invitation-protocol';
-import { createAdmissionKeypair, type InvitationsHandler } from './invitations-handler';
+import { type InvitationsHandler, createAdmissionKeypair } from './invitations-handler';
 
 /**
  * Entry point for creating and accepting invitations, keeps track of existing invitation set and

package/src/packlets/invitations/invitations-service.ts

@@ -4,8 +4,8 @@
 
 import { Stream } from '@dxos/codec-protobuf/stream';
 import {
-  type AuthenticationRequest,
   type AcceptInvitationRequest,
+  type AuthenticationRequest,
   type Invitation,
   type InvitationsService,
   QueryInvitationsResponse,

package/src/packlets/invitations/space-invitation-protocol.test.ts

@@ -2,9 +2,9 @@
 // Copyright 2022 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
-import { asyncChain, Trigger } from '@dxos/async';
+import { Trigger, chain } from '@dxos/async';
 import { raise } from '@dxos/debug';
 import { AlreadyJoinedError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
@@ -22,7 +22,7 @@ const closeAfterTest = async (peer: ServiceContext) => {
 
 describe('services/space-invitations-protocol', () => {
   test('genesis', async () => {
-    const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
+    const [peer] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
 
     const space = await peer.dataSpaceManager!.createSpace();
     expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
@@ -31,7 +31,7 @@ describe('services/space-invitations-protocol', () => {
   });
 
   test('genesis & ready', async () => {
-    const [peer] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
+    const [peer] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(1));
 
     const space = await peer.dataSpaceManager!.createSpace();
     expect(peer.dataSpaceManager!.spaces.has(space.key)).to.be.true;
@@ -41,7 +41,7 @@ describe('services/space-invitations-protocol', () => {
   });
 
   test('invitation with no auth', async () => {
-    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+    const [host, guest] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
     const space1 = await host.dataSpaceManager!.createSpace();
     const spaceKey = space1.key;
@@ -65,7 +65,7 @@ describe('services/space-invitations-protocol', () => {
   });
 
   test('invitation when already joined', async () => {
-    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+    const [host, guest] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
     const space1 = await host.dataSpaceManager!.createSpace();
     const spaceKey = space1.key;
@@ -92,7 +92,7 @@ describe('services/space-invitations-protocol', () => {
   });
 
   test('creates and accepts invitation with retry', async () => {
-    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+    const [host, guest] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
     let attempt = 0;
 
@@ -153,7 +153,7 @@ describe('services/space-invitations-protocol', () => {
   });
 
   test('timeout', async () => {
-    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+    const [host, guest] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
     const space = await host.dataSpaceManager!.createSpace();
     const hostInvitation = await createInvitation(host, {
       kind: Invitation.Kind.SPACE,
@@ -175,7 +175,7 @@ describe('services/space-invitations-protocol', () => {
   });
 
   test('cancels invitation', async () => {
-    const [host, guest] = await asyncChain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
+    const [host, guest] = await chain<ServiceContext>([createIdentity, closeAfterTest])(createPeers(2));
 
     const hostConnected = new Trigger<Invitation>();
     const guestConnected = new Trigger<Invitation>();

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -12,24 +12,19 @@ import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import {
-  AlreadyJoinedError,
-  type ApiError,
-  AuthorizationError,
-  InvalidInvitationError,
-  SpaceNotFoundError,
-} from '@dxos/protocols';
+import { AlreadyJoinedError, AuthorizationError, InvalidInvitationError, SpaceNotFoundError } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
-import { SpaceMember, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type ProfileDocument, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   type AdmissionRequest,
   type AdmissionResponse,
   type IntroductionRequest,
 } from '@dxos/protocols/proto/dxos/halo/invitations';
 
+import { type DataSpaceManager, type SigningContext } from '../spaces';
+
 import { type InvitationProtocol } from './invitation-protocol';
 import { computeExpirationTime } from './utils';
-import { type DataSpaceManager, type SigningContext } from '../spaces';
 
 export class SpaceInvitationProtocol implements InvitationProtocol {
   constructor(
@@ -47,16 +42,16 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  checkCanInviteNewMembers(): ApiError | undefined {
+  checkCanInviteNewMembers(): Error | undefined {
     if (this._spaceKey == null) {
-      return new InvalidInvitationError('No spaceKey was provided for a space invitation.');
+      return new InvalidInvitationError({ message: 'No spaceKey was provided for a space invitation.' });
     }
     const space = this._spaceManager.spaces.get(this._spaceKey);
     if (space == null) {
       return new SpaceNotFoundError(this._spaceKey);
     }
     if (!space?.inner.spaceState.hasMembershipManagementPermission(this._signingContext.identityKey)) {
-      return new AuthorizationError('No member management permission.');
+      return new AuthorizationError({ message: 'No member management permission.' });
     }
     return undefined;
   }
@@ -147,10 +142,10 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
 
   checkInvitation(invitation: Partial<Invitation>): InvalidInvitationError | AlreadyJoinedError | undefined {
     if (invitation.spaceKey == null) {
-      return new InvalidInvitationError('No spaceKey was provided for a space invitation.');
+      return new InvalidInvitationError({ message: 'No spaceKey was provided for a space invitation.' });
     }
     if (this._spaceManager.spaces.has(invitation.spaceKey)) {
-      return new AlreadyJoinedError('Already joined space.');
+      return new AlreadyJoinedError({ message: 'Already joined space.' });
     }
   }
 
@@ -183,7 +178,7 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     invariant(credential.subject.id.equals(this._signingContext.identityKey));
 
     if (this._spaceManager.spaces.has(assertion.spaceKey)) {
-      throw new AlreadyJoinedError('Already joined space.');
+      throw new AlreadyJoinedError({ message: 'Already joined space.' });
     }
 
     // Create local space.

package/src/packlets/invitations/utils.ts

@@ -3,7 +3,7 @@
 //
 
 import { type Mutex, type MutexGuard } from '@dxos/async';
-import { cancelWithContext, type Context, ContextDisposedError } from '@dxos/context';
+import { type Context, ContextDisposedError, cancelWithContext } from '@dxos/context';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 
 export const stateToString = (state: Invitation.State): string => {

package/src/packlets/locks/browser.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { asyncTimeout, Trigger } from '@dxos/async';
+import { Trigger, asyncTimeout } from '@dxos/async';
 import { RESOURCE_LOCK_TIMEOUT } from '@dxos/client-protocol';
 import { log, logInfo } from '@dxos/log';
 

package/src/packlets/locks/index.ts

@@ -2,5 +2,5 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './resource-lock';
-export * from './node';
+export type * from './resource-lock';
+export * from '#locks-platform';

package/src/packlets/logging/logging-service.ts

@@ -13,12 +13,12 @@ import {
   log,
 } from '@dxos/log';
 import {
+  type ControlMetricsRequest,
+  type ControlMetricsResponse,
   type LogEntry,
   type LoggingService,
   type Metrics,
   QueryLogsRequest,
-  type ControlMetricsRequest,
-  type ControlMetricsResponse,
   type QueryMetricsRequest,
   type QueryMetricsResponse,
 } from '@dxos/protocols/proto/dxos/client/services';
@@ -26,6 +26,10 @@ import { getDebugName, jsonify, numericalValues, tracer } from '@dxos/util';
 
 /**
  * Logging service used to spy on logs of the host.
+ *
+ * @deprecated This was created so that logs from the shared worker (WorkerClientServices) could be
+ * seen in the main window console without opening the shared worker DevTools. Shared worker client
+ * services is deprecated; dedicated worker logs already show in the main window console.
  */
 export class LoggingServiceImpl implements LoggingService {
   private readonly _logs = new Event<NaturalLogEntry>();
@@ -37,7 +41,7 @@ export class LoggingServiceImpl implements LoggingService {
   }
 
   async close(): Promise<void> {
-    const index = log.runtimeConfig.processors.findIndex((processor) => processor === this._logProcessor);
+    const index = log.runtimeConfig.processors.findIndex((processor: LogProcessor) => processor === this._logProcessor);
     log.runtimeConfig.processors.splice(index, 1);
   }
 
@@ -112,6 +116,7 @@ export class LoggingServiceImpl implements LoggingService {
 
         const record: LogEntry = {
           ...entry,
+          message: entry.message ?? (entry.error ? (entry.error.message ?? String(entry.error)) : ''),
           context: jsonify(getContextFromEntry(entry)),
           timestamp: new Date(),
           meta: {

package/src/packlets/logging/logging.test.ts

@@ -5,7 +5,7 @@
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
-import { log, LogLevel } from '@dxos/log';
+import { LogLevel, log } from '@dxos/log';
 import { type LogEntry } from '@dxos/protocols/proto/dxos/client/services';
 
 import { LoggingServiceImpl } from './logging-service';

package/src/packlets/network/network-service.test.ts

@@ -2,16 +2,17 @@
 // Copyright 2023 DXOS.org
 //
 
-import { afterEach, onTestFinished, beforeEach, describe, expect, test } from 'vitest';
+import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
-import { type NetworkService, ConnectionState } from '@dxos/protocols/proto/dxos/client/services';
+import { ConnectionState, type NetworkService } from '@dxos/protocols/proto/dxos/client/services';
 
-import { NetworkServiceImpl } from './network-service';
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
 
+import { NetworkServiceImpl } from './network-service';
+
 describe('NetworkService', () => {
   let serviceContext: ServiceContext;
   let networkService: NetworkService;

package/src/packlets/network/network-service.ts

@@ -7,15 +7,15 @@ import { type EdgeConnection } from '@dxos/edge-client';
 import { type SignalManager } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
 import {
-  type SubscribeSwarmStateRequest,
   type NetworkService,
   type NetworkStatus,
+  type SubscribeSwarmStateRequest,
   type UpdateConfigRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Peer, type SwarmResponse } from '@dxos/protocols/proto/dxos/edge/messenger';
 import {
-  type LeaveRequest,
   type JoinRequest,
+  type LeaveRequest,
   type Message,
   type QueryRequest,
 } from '@dxos/protocols/proto/dxos/edge/signal';

package/src/packlets/services/client-rpc-server.ts

@@ -5,13 +5,13 @@
 import { type ClientServices } from '@dxos/client-protocol';
 import { type Any, type ServiceHandler, Stream } from '@dxos/codec-protobuf';
 import { raise } from '@dxos/debug';
-import { parseMethodName, RpcPeer, type RpcPeerOptions, type ServiceBundle } from '@dxos/rpc';
+import { RpcPeer, type RpcPeerOptions, type ServiceBundle, parseMethodName } from '@dxos/rpc';
 import { MapCounter, trace } from '@dxos/tracing';
 import { type MaybePromise } from '@dxos/util';
 
 import { type ServiceRegistry } from './service-registry';
 
-export type ClientRpcServerParams = {
+export type ClientRpcServerProps = {
   serviceRegistry: ServiceRegistry<ClientServices>;
   handleCall?: (
     method: string,
@@ -30,8 +30,8 @@ export class ClientRpcServer {
   private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
   private readonly _rpcPeer: RpcPeer;
   private readonly _handlerCache = new Map<string, ServiceHandler<any>>();
-  private readonly _handleCall: ClientRpcServerParams['handleCall'];
-  private readonly _handleStream: ClientRpcServerParams['handleStream'];
+  private readonly _handleCall: ClientRpcServerProps['handleCall'];
+  private readonly _handleStream: ClientRpcServerProps['handleStream'];
 
   @trace.metricsCounter()
   private readonly _callMetrics = new MapCounter();
@@ -41,7 +41,7 @@ export class ClientRpcServer {
     return Object.keys(this._serviceRegistry.services);
   }
 
-  constructor(params: ClientRpcServerParams) {
+  constructor(params: ClientRpcServerProps) {
     const { serviceRegistry, handleCall, handleStream, ...rpcOptions } = params;
     this._handleCall = handleCall;
     this._handleStream = handleStream;

package/src/packlets/services/feed-syncer.ts

@@ -0,0 +1,227 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as SqlClient from '@effect/sql/SqlClient';
+import { Encoder, decode as cborXdecode } from 'cbor-x';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { AsyncTask, scheduleTask } from '@dxos/async';
+import { Resource } from '@dxos/context';
+import { type EdgeConnection, MessageSchema } from '@dxos/edge-client';
+import { RuntimeProvider } from '@dxos/effect';
+import { type FeedStore, SyncClient } from '@dxos/feed';
+import { type SpaceId } from '@dxos/keys';
+import { FeedProtocol } from '@dxos/protocols';
+import { EdgeService } from '@dxos/protocols';
+import { createBuf } from '@dxos/protocols/buf';
+import { type Message as RouterMessage } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import type { SqlTransaction } from '@dxos/sql-sqlite';
+import { bufferToArray } from '@dxos/util';
+
+const encoder = new Encoder({ tagUint8Array: false, useRecords: false });
+
+const DEFAULT_MESSAGE_BLOCKS_LIMIT = 50;
+const DEFAULT_SYNC_CONCURRENCY = 5;
+const DEFAULT_POLLING_INTERVAL = 10_000;
+
+interface FeedSyncerOptions {
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransaction.SqlTransaction>;
+  feedStore: FeedStore;
+  edgeClient: EdgeConnection;
+  peerId: string;
+  getSpaceIds: () => SpaceId[];
+
+  /**
+   * Namespace to sync.
+   */
+  // TODO(dmaretskyi): Syncing only one namespace is supported.
+  syncNamespace: string;
+
+  /**
+   * Maximum number of blocks to sync in a single message.
+   * @default 50
+   */
+  messageBlocksLimit?: number;
+
+  /**
+   * Maximum number of spaces to sync concurrently.
+   * @default 5
+   */
+  syncConcurrency?: number;
+
+  /**
+   * Interval between full polls.
+   * @default 10 seconds
+   */
+  pollingInterval?: number;
+}
+
+export class FeedSyncer extends Resource {
+  readonly #syncNamespace: string;
+  readonly #messageBlocksLimit: number;
+  readonly #syncConcurrency: number;
+  readonly #pollingInterval: number;
+
+  readonly #runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransaction.SqlTransaction>;
+  readonly #feedStore: FeedStore;
+  readonly #edgeClient: EdgeConnection;
+  readonly #syncClient: SyncClient;
+  readonly #getSpaceIds: () => SpaceId[];
+
+  #spacesToPoll = new Set<SpaceId>();
+  /** Last time full poll was completed. */
+  #lastFullPoll: number | null = null;
+
+  constructor(options: FeedSyncerOptions) {
+    super();
+    this.#runtime = options.runtime;
+    this.#feedStore = options.feedStore;
+    this.#edgeClient = options.edgeClient;
+    this.#syncClient = new SyncClient({
+      peerId: options.peerId,
+      feedStore: options.feedStore,
+      sendMessage: this.#sendMessage.bind(this),
+    });
+    this.#getSpaceIds = options.getSpaceIds;
+    this.#syncNamespace = options.syncNamespace;
+    this.#messageBlocksLimit = options.messageBlocksLimit ?? DEFAULT_MESSAGE_BLOCKS_LIMIT;
+    this.#syncConcurrency = options.syncConcurrency ?? DEFAULT_SYNC_CONCURRENCY;
+    this.#pollingInterval = options.pollingInterval ?? DEFAULT_POLLING_INTERVAL;
+  }
+
+  protected override async _open(): Promise<void> {
+    this._ctx.onDispose(
+      this.#edgeClient.onMessage((msg: RouterMessage) => {
+        if (!msg.serviceId) {
+          return;
+        }
+        const service = msg.serviceId.split(':')[0];
+        if (service !== EdgeService.QUEUE_REPLICATOR) {
+          return;
+        }
+        const handleMessageEffect = Effect.gen(this, function* () {
+          const decoded = yield* Effect.try({
+            try: () => cborXdecode(msg.payload!.value),
+            catch: (error) => new Error(`Failed to decode feed sync message: ${error}`),
+          });
+          const payload = yield* Schema.decodeUnknown(FeedProtocol.ProtocolMessage)(decoded);
+          yield* this.#syncClient.handleMessage(payload);
+        });
+
+        void RuntimeProvider.runPromise(this.#runtime)(handleMessageEffect);
+      }),
+    );
+
+    this._ctx.onDispose(
+      // NOTE: This will fire immediately if the connection is already open.
+      this.#edgeClient.onReconnected(async () => {}),
+    );
+
+    this.#feedStore.onNewBlocks.on(this._ctx, () => {
+      this.#pushTask.schedule();
+    });
+
+    await this.#pollTask.open();
+    await this.#pushTask.open();
+
+    this.#resetSpacesToPoll();
+  }
+
+  protected override async _close(): Promise<void> {
+    await this.#pollTask.close();
+    await this.#pushTask.close();
+  }
+
+  #resetSpacesToPoll(): void {
+    this.#spacesToPoll.clear();
+    this.#getSpaceIds().forEach((spaceId) => {
+      this.#spacesToPoll.add(spaceId);
+    });
+    this.#lastFullPoll = Date.now();
+  }
+
+  #sendMessage(message: FeedProtocol.QueryRequest | FeedProtocol.AppendRequest): Effect.Effect<void, unknown, never> {
+    return Effect.gen(this, function* () {
+      const encoded = encoder.encode(message);
+      yield* Effect.tryPromise(async () =>
+        this.#edgeClient.send(
+          createBuf(MessageSchema, {
+            source: {
+              identityKey: this.#edgeClient.identityKey,
+              peerKey: this.#edgeClient.peerKey,
+            },
+            serviceId: this.#getTargetServiceId(message),
+            payload: { value: bufferToArray(encoded) },
+          }),
+        ),
+      );
+    });
+  }
+
+  #getTargetServiceId(message: FeedProtocol.QueryRequest | FeedProtocol.AppendRequest): string {
+    // TODO(dmaretskyi): Perhaps in the future we will want to include the queue namespace here as well.
+    //                   This would require putting it at the top level of the message.
+    //                   For now, we let the edge router handle it.
+    return FeedProtocol.encodeServiceId(message.feedNamespace, message.spaceId as SpaceId);
+  }
+
+  readonly #pollTask = new AsyncTask(async () =>
+    Effect.gen(this, function* () {
+      yield* Effect.forEach(
+        this.#spacesToPoll,
+        (spaceId) =>
+          Effect.gen(this, function* () {
+            const { done } = yield* this.#syncClient.pull({
+              spaceId,
+              feedNamespace: this.#syncNamespace,
+              limit: this.#messageBlocksLimit,
+            });
+            if (done) {
+              this.#spacesToPoll.delete(spaceId);
+            }
+          }),
+        { concurrency: this.#syncConcurrency },
+      );
+
+      // If its time to do a full poll, reset the spaces to poll and schedule the next poll immediately.
+      if (this.#lastFullPoll == null || Date.now() - this.#lastFullPoll > this.#pollingInterval) {
+        this.#resetSpacesToPoll();
+        this.#pollTask.schedule();
+      } else if (this.#spacesToPoll.size > 0) {
+        // If there are some spaces still syncing, poll them immediately.
+        this.#pollTask.schedule();
+      } else {
+        // All spaces sync, and there's time before the next full poll, schedule it later.
+        this.#resetSpacesToPoll();
+        scheduleTask(
+          this._ctx,
+          () => this.#pollTask.schedule(),
+          Math.max(this.#pollingInterval - (Date.now() - (this.#lastFullPoll ?? 0)), 0),
+        );
+      }
+    }).pipe(RuntimeProvider.runPromise(this.#runtime)),
+  );
+
+  readonly #pushTask = new AsyncTask(async () =>
+    Effect.gen(this, function* () {
+      yield* Effect.forEach(
+        this.#getSpaceIds(),
+        (spaceId) =>
+          Effect.gen(this, function* () {
+            const { done } = yield* this.#syncClient.push({
+              spaceId,
+              feedNamespace: this.#syncNamespace,
+              limit: this.#messageBlocksLimit,
+            });
+            if (!done) {
+              // Keep pushing until all blocks are pushed.
+              this.#pushTask.schedule();
+            }
+          }),
+        { concurrency: this.#syncConcurrency },
+      );
+    }).pipe(RuntimeProvider.runPromise(this.#runtime)),
+  );
+}

package/src/packlets/services/platform.ts

@@ -14,12 +14,18 @@ export const getPlatform = (): Platform => {
         userAgent,
         uptime: Math.floor((Date.now() - window.performance.timeOrigin) / 1_000),
       };
-    } else {
+    } else if (typeof SharedWorkerGlobalScope !== 'undefined') {
       // Shared worker.
       return {
         type: Platform.PLATFORM_TYPE.SHARED_WORKER,
         uptime: Math.floor((Date.now() - performance.timeOrigin) / 1_000),
       };
+    } else {
+      // Dedicated worker.
+      return {
+        type: Platform.PLATFORM_TYPE.DEDICATED_WORKER,
+        uptime: Math.floor((Date.now() - performance.timeOrigin) / 1_000),
+      };
     }
   } else {
     // Node.