@dxos/client-services 0.9.1-staging.ee54ba693a → 0.11.0

package/src/packlets/worker/worker-session.ts

@@ -2,39 +2,49 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Trigger, asyncTimeout } from '@dxos/async';
-import {
-  type IframeServiceBundle,
-  PROXY_CONNECTION_TIMEOUT,
-  iframeServiceBundle,
-  workerServiceBundle,
-} from '@dxos/client-protocol';
-import { invariant } from '@dxos/invariant';
+import type * as RpcClient from '@effect/rpc/RpcClient';
+import type * as RpcServer from '@effect/rpc/RpcServer';
+import * as Effect from 'effect/Effect';
+
+import { Trigger } from '@dxos/async';
+import { ClientRpcServer, PROXY_CONNECTION_TIMEOUT, makeBridgeServiceClientOverProtocol } from '@dxos/client-protocol';
+import { EffectEx } from '@dxos/effect';
 import { log, logInfo } from '@dxos/log';
 import { type BridgeService } from '@dxos/protocols/proto/dxos/mesh/bridge';
-import { type ProtoRpcPeer, type RpcPort, createProtoRpcPeer } from '@dxos/rpc';
+import { type WorkerService } from '@dxos/protocols/rpc';
 import { Callback, type MaybePromise } from '@dxos/util';
 
-import { ClientRpcServer, type ClientRpcServerProps, type ClientServicesHost } from '../services';
+import { type ClientServicesHost } from '../services';
 
 export type WorkerSessionProps = {
   serviceHost: ClientServicesHost;
-  systemPort: RpcPort;
-  appPort: RpcPort;
+  /**
+   * Reverse-direction (worker→tab) protocol serving the tab's {@link BridgeService} (WebRTC transport)
+   * over effect-rpc. The worker is the client; the tab is the runner.
+   */
+  systemProtocol: RpcClient.Protocol['Type'];
+  /**
+   * Forward-direction (tab→worker) protocol over which the worker serves the client services.
+   */
+  appProtocol: RpcServer.Protocol['Type'];
   // TODO(wittjosiah): Remove shellPort.
-  shellPort?: RpcPort;
+  shellPort?: MessagePort;
   readySignal: Trigger<Error | undefined>;
 };
 
 /**
  * Represents a tab connection within the worker.
+ *
+ * The session holds imperative per-connection transport state (RPC servers, the WebRTC bridge client);
+ * its lifecycle is driven by {@link WorkerRuntime} through the {@link open} / {@link close} Effects.
  */
 export class WorkerSession {
   private readonly _clientRpc: ClientRpcServer;
   private readonly _shellClientRpc?: ClientRpcServer;
-  private readonly _iframeRpc: ProtoRpcPeer<IframeServiceBundle>;
   private readonly _startTrigger = new Trigger();
   private readonly _serviceHost: ClientServicesHost;
+  private readonly _systemProtocol: RpcClient.Protocol['Type'];
+  #closeBridge?: () => Promise<void>;
 
   public readonly onClose = new Callback<() => Promise<void>>();
 
@@ -46,102 +56,109 @@ export class WorkerSession {
 
   public bridgeService?: BridgeService;
 
-  constructor({ serviceHost, systemPort, appPort, shellPort, readySignal }: WorkerSessionProps) {
-    invariant(serviceHost);
+  // Per-session `WorkerService` control handlers, served over the app port alongside the client
+  // services (both run tab→worker). `start` conveys the tab origin / liveness lock and releases the
+  // gate below; `stop` tears the session down.
+  readonly #workerServiceHandlers: WorkerService.Handlers = {
+    'WorkerService.start': (payload) =>
+      Effect.sync(() => {
+        this.origin = payload.origin;
+        this.lockKey = payload.lockKey;
+        this._startTrigger.wake();
+      }),
+    'WorkerService.stop': () =>
+      // Close on the next tick (forked) so the RPC response is delivered before the transport tears down.
+      Effect.forkDaemon(
+        Effect.gen(this, function* () {
+          yield* Effect.async<void>((resume) => {
+            setTimeout(() => resume(Effect.void));
+          });
+          yield* this.close();
+        }).pipe(Effect.tapErrorCause((cause) => Effect.sync(() => log.catch(cause)))),
+      ).pipe(Effect.asVoid),
+  };
+
+  constructor({ serviceHost, systemProtocol, appProtocol, shellPort, readySignal }: WorkerSessionProps) {
     this._serviceHost = serviceHost;
-
-    const middleware: Pick<ClientRpcServerProps, 'handleCall' | 'handleStream'> = {
-      handleCall: async (method, params, handler, options) => {
-        const error = await readySignal.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
-        if (error) {
-          throw error;
-        }
-
-        return handler(method, params, options);
-      },
-      handleStream: async (method, params, handler, options) => {
-        const error = await readySignal.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
-        if (error) {
-          throw error;
-        }
-
-        return handler(method, params, options);
-      },
+    this._systemProtocol = systemProtocol;
+
+    // Hold requests until the worker runtime is ready; propagate startup errors to callers.
+    const onRequest = async () => {
+      const error = await readySignal.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
+      if (error) {
+        throw error;
+      }
     };
 
+    const services = () => ({
+      ...this._serviceHost.services,
+      WorkerService: this.#workerServiceHandlers,
+    });
+
     this._clientRpc = new ClientRpcServer({
-      serviceRegistry: this._serviceHost.serviceRegistry,
-      port: appPort,
-      ...middleware,
+      services,
+      protocol: appProtocol,
+      onRequest,
     });
 
     this._shellClientRpc = shellPort
       ? new ClientRpcServer({
-          serviceRegistry: this._serviceHost.serviceRegistry,
+          services,
           port: shellPort,
-          ...middleware,
+          onRequest,
         })
       : undefined;
-
-    this._iframeRpc = createProtoRpcPeer({
-      requested: iframeServiceBundle,
-      exposed: workerServiceBundle,
-      handlers: {
-        WorkerService: {
-          start: async (request) => {
-            this.origin = request.origin;
-            this.lockKey = request.lockKey;
-            this._startTrigger.wake();
-          },
-
-          stop: async () => {
-            setTimeout(async () => {
-              try {
-                await this.close();
-              } catch (err: any) {
-                log.catch(err);
-              }
-            });
-          },
-        },
-      },
-      port: systemPort,
-      timeout: 1_000, // With low timeout heartbeat may fail if the tab's thread is saturated.
-    });
-
-    this.bridgeService = this._iframeRpc.rpc.BridgeService;
   }
 
-  async open(): Promise<void> {
-    log('opening...');
-    await Promise.all([this._clientRpc.open(), this._iframeRpc.open(), this._maybeOpenShell()]);
-
-    // Wait until the worker's RPC service has started.
-    await this._startTrigger.wait({ timeout: PROXY_CONNECTION_TIMEOUT });
-
-    // TODO(burdon): Comment required.
-    if (this.lockKey) {
-      void this._afterLockReleases(this.lockKey, () => this.close());
-    }
-
-    log('opened');
+  open(): Effect.Effect<void> {
+    return Effect.gen(this, function* () {
+      log('opening...');
+      // The tab serves the WebRTC `BridgeService` on the reverse channel; build a client the worker's
+      // network stack can proxy through.
+      const { bridgeService, close } = yield* Effect.promise(() =>
+        makeBridgeServiceClientOverProtocol(this._systemProtocol),
+      );
+      this.bridgeService = bridgeService;
+      this.#closeBridge = close;
+
+      yield* Effect.promise(() => Promise.all([this._clientRpc.open(), this._maybeOpenShell()]));
+
+      // Wait until the tab calls `WorkerService.start` (conveys origin + liveness lock).
+      yield* Effect.promise(() => this._startTrigger.wait({ timeout: PROXY_CONNECTION_TIMEOUT }));
+
+      if (this.lockKey) {
+        void this._afterLockReleases(this.lockKey, () =>
+          EffectEx.runPromise(this.close()).catch((err) => log.catch(err)),
+        );
+      }
+
+      log('opened');
+    });
   }
 
-  async close(): Promise<void> {
-    log.debug('closing...');
-    try {
-      await this.onClose.callIfSet();
-    } catch (err: any) {
-      log.catch(err);
-    }
-
-    await Promise.all([this._clientRpc.close(), this._iframeRpc.close()]);
-    log.debug('closed');
+  close(): Effect.Effect<void> {
+    return Effect.gen(this, function* () {
+      log.debug('closing...');
+      yield* Effect.promise(async () => {
+        try {
+          await this.onClose.callIfSet();
+        } catch (err: any) {
+          log.catch(err);
+        }
+      });
+
+      yield* Effect.promise(() =>
+        Promise.all([this._clientRpc.close(), this._shellClientRpc?.close(), this.#closeBridge?.()]),
+      );
+      this.bridgeService = undefined;
+      this.#closeBridge = undefined;
+      log.debug('closed');
+    });
   }
 
   private async _maybeOpenShell(): Promise<void> {
     try {
-      this._shellClientRpc && (await asyncTimeout(this._shellClientRpc.open(), 1_000));
+      this._shellClientRpc && (await this._shellClientRpc.open());
     } catch {
       log.info('No shell connected.');
     }

package/src/testing/index.ts

@@ -2,4 +2,5 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from '../packlets/space/testing';
 export * from '../packlets/testing';

package/src/version.ts

@@ -1 +1,5 @@
-export const DXOS_VERSION = "0.9.1-staging.ee54ba693a";
+//
+// Copyright 2023 DXOS.org
+//
+
+export const DXOS_VERSION = '0.11.0';

package/dist/lib/browser/chunk-QCWEHHJW.mjs

@@ -1,24 +0,0 @@
-import "@dxos/node-std/globals";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-export {
-  __export,
-  __reExport
-};
-//# sourceMappingURL=chunk-QCWEHHJW.mjs.map

package/dist/lib/browser/chunk-QCWEHHJW.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
-}