@dxos/client-services 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

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

@@ -0,0 +1,340 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Encoder, decode as cborDecode } from 'cbor-x';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as ManagedRuntime from 'effect/ManagedRuntime';
+import { describe, expect, onTestFinished, test, vi } from 'vitest';
+
+import { Event } from '@dxos/async';
+import { Context } from '@dxos/context';
+import { type EdgeConnection, MessageSchema } from '@dxos/edge-client';
+import { RuntimeProvider } from '@dxos/effect';
+import { FeedStore, SyncServer } from '@dxos/feed';
+import { ObjectId, 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 { EdgeStatus } from '@dxos/protocols/proto/dxos/client/services';
+import { SqlTransaction } from '@dxos/sql-sqlite';
+import { layerMemory } from '@dxos/sql-sqlite/platform';
+import { bufferToArray } from '@dxos/util';
+
+import { FeedSyncer } from './feed-syncer';
+
+type ProtocolMessage = FeedProtocol.ProtocolMessage;
+
+const encoder = new Encoder({ tagUint8Array: false, useRecords: false });
+const syncNamespace = FeedProtocol.WellKnownNamespaces.data;
+const syncNamespaces = [FeedProtocol.WellKnownNamespaces.data, FeedProtocol.WellKnownNamespaces.trace];
+
+const createRuntime = () => {
+  const baseLayer = layerMemory;
+  const transactionLayer = SqlTransaction.layer.pipe(Layer.provide(baseLayer));
+  return ManagedRuntime.make(Layer.merge(baseLayer, transactionLayer).pipe(Layer.orDie));
+};
+
+const createFeedStore = (localActorId: string, assignPositions: boolean) =>
+  new FeedStore({ localActorId, assignPositions });
+
+const createEdgeConnection = ({
+  syncServer,
+  serverRuntime,
+  messageListeners,
+}: {
+  syncServer: SyncServer;
+  serverRuntime: ReturnType<typeof createRuntime>;
+  messageListeners: Set<(message: RouterMessage) => void>;
+}): EdgeConnection => {
+  const reconnectListeners = new Set<() => void>();
+
+  return {
+    statusChanged: new Event<any>(),
+    info: {},
+    identityKey: 'client-identity',
+    peerKey: 'client-peer',
+    isOpen: true,
+    status: {
+      state: EdgeStatus.ConnectionState.CONNECTED,
+      rtt: 0,
+      uptime: 0,
+      rateBytesUp: 0,
+      rateBytesDown: 0,
+      messagesSent: 0,
+      messagesReceived: 0,
+    },
+    setIdentity: () => {},
+    open: async () => {},
+    close: async () => {},
+    send: async (ctx, routerMessage: RouterMessage) => {
+      const decoded = cborDecode(routerMessage.payload!.value) as ProtocolMessage;
+      await syncServer.handleMessage(ctx, decoded).pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+    },
+    onMessage: (listener: (message: RouterMessage) => void) => {
+      messageListeners.add(listener);
+      return () => messageListeners.delete(listener);
+    },
+    onReconnected: (listener: () => void) => {
+      reconnectListeners.add(listener);
+      return () => reconnectListeners.delete(listener);
+    },
+  };
+};
+
+const createFeedSyncHarness = async ({
+  spaceId,
+  pollingInterval,
+  syncNamespaces: namespaces = [syncNamespace],
+}: {
+  spaceId: SpaceId;
+  pollingInterval?: number;
+  syncNamespaces?: string[];
+}) => {
+  const serverRuntime = createRuntime();
+  const clientRuntime = createRuntime();
+  const serverFeedStore = createFeedStore('server', true);
+  const clientFeedStore = createFeedStore('client', false);
+
+  await serverFeedStore.migrate().pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+  await clientFeedStore.migrate().pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+  const messageListeners = new Set<(message: RouterMessage) => void>();
+  const syncServer = new SyncServer({
+    peerId: 'server',
+    feedStore: serverFeedStore,
+    sendMessage: (_ctx, message) =>
+      Effect.promise(async () => {
+        const routerMessage = createBuf(MessageSchema, {
+          source: {
+            identityKey: 'server-identity',
+            peerKey: 'server-peer',
+          },
+          serviceId: `${EdgeService.QUEUE_REPLICATOR}:test`,
+          payload: { value: bufferToArray(encoder.encode(message)) },
+        });
+
+        for (const listener of messageListeners) {
+          listener(routerMessage);
+        }
+      }),
+  });
+
+  const edgeClient = createEdgeConnection({ syncServer, serverRuntime, messageListeners });
+
+  const syncer = new FeedSyncer({
+    runtime: clientRuntime.runtimeEffect,
+    feedStore: clientFeedStore,
+    edgeClient: edgeClient as any,
+    peerId: 'client',
+    getSpaceIds: () => [spaceId],
+    syncNamespaces: namespaces,
+    pollingInterval,
+  });
+
+  const close = async () => {
+    await syncer.close();
+    await clientRuntime.dispose();
+    await serverRuntime.dispose();
+  };
+
+  onTestFinished(close);
+
+  return { serverRuntime, clientRuntime, serverFeedStore, clientFeedStore, syncer, close };
+};
+
+describe('FeedSyncer', () => {
+  test('syncs mixed pull and push traffic', async () => {
+    const spaceId = SpaceId.random();
+    const { serverRuntime, clientRuntime, serverFeedStore, clientFeedStore, syncer } = await createFeedSyncHarness({
+      spaceId,
+    });
+    const serverFeedId = ObjectId.random();
+    const clientFeedId = ObjectId.random();
+
+    await serverFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: serverFeedId,
+          feedNamespace: syncNamespace,
+          data: new Uint8Array([1, 2, 3]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+    await syncer.open(new Context());
+
+    await vi.waitFor(async () => {
+      const { blocks } = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [serverFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].data).toEqual(new Uint8Array([1, 2, 3]));
+      expect(blocks[0].position).toBeDefined();
+    });
+
+    await clientFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: clientFeedId,
+          feedNamespace: syncNamespace,
+          data: new Uint8Array([9, 8, 7]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+    await vi.waitFor(async () => {
+      const { blocks } = await serverFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [clientFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].data).toEqual(new Uint8Array([9, 8, 7]));
+      expect(blocks[0].position).toBeDefined();
+    });
+  });
+
+  test('requestPoll triggers best-effort pull for a space', async () => {
+    const spaceId = SpaceId.random();
+    const { serverRuntime, clientRuntime, serverFeedStore, clientFeedStore, syncer } = await createFeedSyncHarness({
+      spaceId,
+      pollingInterval: 60_000,
+    });
+    const serverFeedId = ObjectId.random();
+
+    await serverFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: serverFeedId,
+          feedNamespace: syncNamespace,
+          data: new Uint8Array([1, 2, 3]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+    await syncer.open(new Context());
+
+    await vi.waitFor(async () => {
+      const { blocks } = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [serverFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0].data).toEqual(new Uint8Array([1, 2, 3]));
+    });
+
+    await serverFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: serverFeedId,
+          feedNamespace: syncNamespace,
+          data: new Uint8Array([4, 5, 6]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    {
+      const { blocks } = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [serverFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+      expect(blocks).toHaveLength(1);
+    }
+
+    syncer.schedulePoll();
+
+    await vi.waitFor(async () => {
+      const { blocks } = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: syncNamespace,
+          position: -1,
+          query: { feedIds: [serverFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+      expect(blocks).toHaveLength(2);
+      expect(blocks[1].data).toEqual(new Uint8Array([4, 5, 6]));
+    });
+  });
+
+  test('syncs all configured namespaces', async () => {
+    const spaceId = SpaceId.random();
+    const { serverRuntime, clientRuntime, serverFeedStore, clientFeedStore, syncer } = await createFeedSyncHarness({
+      spaceId,
+      syncNamespaces,
+    });
+    const serverDataFeedId = ObjectId.random();
+    const serverTraceFeedId = ObjectId.random();
+
+    await serverFeedStore
+      .appendLocal([
+        {
+          spaceId,
+          feedId: serverDataFeedId,
+          feedNamespace: FeedProtocol.WellKnownNamespaces.data,
+          data: new Uint8Array([1, 2, 3]),
+        },
+        {
+          spaceId,
+          feedId: serverTraceFeedId,
+          feedNamespace: FeedProtocol.WellKnownNamespaces.trace,
+          data: new Uint8Array([7, 8, 9]),
+        },
+      ])
+      .pipe(RuntimeProvider.runPromise(serverRuntime.runtimeEffect));
+
+    await syncer.open(new Context());
+
+    await vi.waitFor(async () => {
+      const dataResult = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: FeedProtocol.WellKnownNamespaces.data,
+          position: -1,
+          query: { feedIds: [serverDataFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+      const traceResult = await clientFeedStore
+        .query({
+          spaceId,
+          feedNamespace: FeedProtocol.WellKnownNamespaces.trace,
+          position: -1,
+          query: { feedIds: [serverTraceFeedId] },
+        })
+        .pipe(RuntimeProvider.runPromise(clientRuntime.runtimeEffect));
+
+      expect(dataResult.blocks).toHaveLength(1);
+      expect(traceResult.blocks).toHaveLength(1);
+      expect(dataResult.blocks[0].data).toEqual(new Uint8Array([1, 2, 3]));
+      expect(traceResult.blocks[0].data).toEqual(new Uint8Array([7, 8, 9]));
+    });
+  });
+});

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

@@ -0,0 +1,337 @@
+//
+// 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 { Context, 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 { invariant } from '@dxos/invariant';
+import { 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 = 5_000;
+const DEFAULT_POLL_REQUEST_THROTTLE_MS = 250;
+const MAX_BLOCKING_SYNC_ITERATIONS = 100;
+
+interface FeedSyncerOptions {
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient | SqlTransaction.SqlTransaction>;
+  feedStore: FeedStore;
+  edgeClient: EdgeConnection;
+  peerId: string;
+  getSpaceIds: () => SpaceId[];
+
+  /**
+   * Namespaces to sync.
+   */
+  syncNamespaces: 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;
+
+  /**
+   * Minimum delay between externally requested best-effort polls.
+   * @default 250 ms
+   */
+  pollRequestThrottleMs?: number;
+}
+
+export class FeedSyncer extends Resource {
+  readonly #syncNamespaces: string[];
+  readonly #messageBlocksLimit: number;
+  readonly #syncConcurrency: number;
+  readonly #pollingInterval: number;
+  readonly #pollRequestThrottleMs: 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;
+  #throttledPollScheduled = false;
+  #lastRequestedPollAt: 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.#syncNamespaces = options.syncNamespaces;
+    this.#messageBlocksLimit = options.messageBlocksLimit ?? DEFAULT_MESSAGE_BLOCKS_LIMIT;
+    this.#syncConcurrency = options.syncConcurrency ?? DEFAULT_SYNC_CONCURRENCY;
+    this.#pollingInterval = options.pollingInterval ?? DEFAULT_POLLING_INTERVAL;
+    this.#pollRequestThrottleMs = options.pollRequestThrottleMs ?? DEFAULT_POLL_REQUEST_THROTTLE_MS;
+  }
+
+  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.validate(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();
+    this.#pollTask.schedule();
+  }
+
+  protected override async _close(): Promise<void> {
+    await this.#pollTask.close();
+    await this.#pushTask.close();
+  }
+
+  /**
+   * Schedules a best-effort pull without blocking the caller.
+   */
+  schedulePoll(): void {
+    this.#resetSpacesToPoll();
+    if (this.#throttledPollScheduled) {
+      return;
+    }
+
+    const now = Date.now();
+    const delay =
+      this.#lastRequestedPollAt == null
+        ? 0
+        : Math.max(this.#pollRequestThrottleMs - (now - this.#lastRequestedPollAt), 0);
+    this.#throttledPollScheduled = true;
+    scheduleTask(
+      this._ctx,
+      () => {
+        this.#throttledPollScheduled = false;
+        this.#lastRequestedPollAt = Date.now();
+        this.#pollTask.schedule();
+      },
+      delay,
+    );
+  }
+
+  /**
+   * Performs queue sync and blocks until there are no pending sync batches.
+   */
+  async syncBlocking(
+    ctx: Context,
+    {
+      spaceId,
+      subspaceTag,
+      shouldPush = true,
+      shouldPull = true,
+    }: {
+      spaceId: SpaceId;
+      subspaceTag: string;
+      shouldPush?: boolean;
+      shouldPull?: boolean;
+    },
+  ): Promise<void> {
+    invariant(SpaceId.isValid(spaceId));
+    invariant(FeedProtocol.isWellKnownNamespace(subspaceTag));
+    if (!shouldPush && !shouldPull) {
+      return;
+    }
+
+    await RuntimeProvider.runPromise(this.#runtime)(
+      Effect.gen(this, function* () {
+        let done = false;
+        let iterations = 0;
+        while (!done) {
+          done = true;
+          if (shouldPull) {
+            const pullResult = yield* this.#syncClient.pull(ctx, {
+              spaceId,
+              feedNamespace: subspaceTag,
+              limit: this.#messageBlocksLimit,
+            });
+            done &&= pullResult.done;
+          }
+
+          if (shouldPush) {
+            const pushResult = yield* this.#syncClient.push(ctx, {
+              spaceId,
+              feedNamespace: subspaceTag,
+              limit: this.#messageBlocksLimit,
+            });
+            done &&= pushResult.done;
+          }
+          iterations++;
+          if (iterations > MAX_BLOCKING_SYNC_ITERATIONS) {
+            throw new Error('Blocking sync exceeded max iterations.');
+          }
+        }
+      }),
+    );
+  }
+
+  #resetSpacesToPoll(): void {
+    this.#spacesToPoll.clear();
+    this.#getSpaceIds().forEach((spaceId) => {
+      this.#spacesToPoll.add(spaceId);
+    });
+    this.#lastFullPoll = Date.now();
+  }
+
+  #sendMessage(
+    ctx: Context,
+    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(
+          ctx,
+          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* () {
+            let doneForAllNamespaces = true;
+            for (const feedNamespace of this.#syncNamespaces) {
+              const { done } = yield* this.#syncClient.pull(this._ctx, {
+                spaceId,
+                feedNamespace,
+                limit: this.#messageBlocksLimit,
+              });
+              if (!done) {
+                doneForAllNamespaces = false;
+              }
+            }
+            if (doneForAllNamespaces) {
+              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* () {
+            let doneForAllNamespaces = true;
+            for (const feedNamespace of this.#syncNamespaces) {
+              const { done } = yield* this.#syncClient.push(this._ctx, {
+                spaceId,
+                feedNamespace,
+                limit: this.#messageBlocksLimit,
+              });
+              if (!done) {
+                doneForAllNamespaces = false;
+              }
+            }
+            if (!doneForAllNamespaces) {
+              // 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.