@dxos/client-protocol 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/dist/lib/index.mjs

@@ -1,31 +1,30 @@
 import { SpaceProperties, SpacePropertiesSchema } from "./types.mjs";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
 import * as Layer from "effect/Layer";
-import * as Scope from "effect/Scope";
-import * as RpcClient from "effect/unstable/rpc/RpcClient";
-import { EffectEx } from "@dxos/effect";
-import { BridgeService, ContactsService, DataService, DevicesService, DevtoolsHost, EdgeAgentService, FeedService, IdentityService, InvitationsService, LoggingService, NetworkService, QueryService, SpacesService, SystemService, WorkerService } from "@dxos/protocols/rpc";
+import * as RpcClient from "effect/rpc/RpcClient";
+import { makeInProcessClient, normalizeHandlers, runServiceCall, toServiceError } from "@dxos/protocols";
+import { ContactsService, DataService, DevicesService, DevtoolsHost, EdgeAgentService, FeedService, IdentityService, InboxService, InvitationsService, LoggingService, NetworkService, QueryService, RTCService, SpacesService, SqlService, SystemService } from "@dxos/protocols/rpc";
 import * as BrowserWorker from "@effect/platform-browser/BrowserWorker";
 import * as BrowserWorkerRunner from "@effect/platform-browser/BrowserWorkerRunner";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
 import * as ManagedRuntime from "effect/ManagedRuntime";
-import * as RpcServer from "effect/unstable/rpc/RpcServer";
+import * as RpcMiddleware from "effect/rpc/RpcMiddleware";
+import * as RpcServer from "effect/rpc/RpcServer";
+import { log } from "@dxos/log";
+import { RpcRouter, layerProtocolRpcPortClient, layerProtocolRpcPortServer } from "@dxos/rpc";
 import { RpcTiming } from "@dxos/worker-framework";
-import * as Cause from "effect/Cause";
-import * as Stream$1 from "effect/Stream";
-import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
-import * as RpcSchema from "effect/unstable/rpc/RpcSchema";
-import * as RpcTest from "effect/unstable/rpc/RpcTest";
+import { InvitationSchema, Invitation_AuthMethod, Invitation_Kind, Invitation_State, Invitation_Type } from "@dxos/protocols/buf/dxos/client/invitation_pb";
+import base from "base-x";
+import { buf, bufWkt } from "@dxos/protocols/buf";
 import { MulticastObservable, Stream } from "@dxos/async";
 import { invariant } from "@dxos/invariant";
-import { log } from "@dxos/log";
-import { runServiceCall } from "@dxos/protocols";
-import { layerProtocolRpcPortClient, layerProtocolRpcPortServer } from "@dxos/rpc";
+import { getBufService } from "@dxos/protocols/buf-service";
+import * as RpcGroup from "effect/rpc/RpcGroup";
+import * as RpcSchema from "effect/rpc/RpcSchema";
+import * as RpcTest from "effect/rpc/RpcTest";
+import * as Stream$1 from "effect/Stream";
+import * as EffectEx from "@dxos/effect/EffectEx";
 import { createIFramePort } from "@dxos/rpc-tunnel";
-import base from "base-x";
-import { schema } from "@dxos/protocols/proto";
-import { Invitation } from "@dxos/protocols/proto/dxos/client/services";
 import * as Schema from "effect/Schema";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -44,10 +43,34 @@ var Rpc_exports = /* @__PURE__ */ __exportAll({
 	makeClient: () => makeClient,
 	makeClientOverProtocol: () => makeClientOverProtocol,
 	serve: () => serve,
-	serveOverProtocol: () => serveOverProtocol
+	serveOnRouter: () => serveOnRouter,
+	serveOverProtocol: () => serveOverProtocol,
+	serveRouterOnPort: () => serveRouterOnPort,
+	serverLayer: () => serverLayer
 });
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/sdk/client-protocol/src/Rpc.ts";
 var WORKER_CLIENT_CONCURRENCY = Number.MAX_SAFE_INTEGER;
 var asRpcGroup = (group) => group;
+var DefectLogMiddleware = class extends RpcMiddleware.Service()("DxosRpcDefectLogMiddleware") {};
+var defectLogLayer = Layer.succeed(DefectLogMiddleware, (handler, { rpc }) => Effect.tapCause(handler, (cause) => Cause.hasDies(cause) ? Effect.sync(() => log.error("rpc handler defect", {
+	rpc: rpc._tag,
+	cause: Cause.pretty(cause)
+}, {
+	"~LogMeta": "~LogMeta",
+	F: __dxlog_file$2,
+	L: 51,
+	S: void 0
+})) : Effect.void));
+var makeServerLayer = (group, handlers, options) => {
+	const timingEnabled = RpcTiming.isEnabled(options?.timing);
+	const rpcGroup = asRpcGroup(timingEnabled ? RpcTiming.applyMiddleware(asRpcGroup(group)) : asRpcGroup(group)).middleware(DefectLogMiddleware);
+	const handlersLayer = timingEnabled ? Layer.mergeAll(handlers, defectLogLayer, RpcTiming.serverLayer(RpcTiming.resolveOptions(options?.timing))) : Layer.merge(handlers, defectLogLayer);
+	return RpcServer.layer(asRpcGroup(rpcGroup), {
+		disableTracing: options?.disableTracing ?? true,
+		concurrency: options?.concurrency ?? "unbounded",
+		disableFatalDefects: true
+	}).pipe(Layer.provide(handlersLayer));
+};
 /**
 * Builds an effect-native RPC client over a caller-supplied {@link RpcClient.Protocol} layer.
 * Transport-agnostic: consumers provide the Worker-platform protocol (see {@link makeClient}) or a
@@ -69,56 +92,45 @@ var makeClient = (port, group, options) => makeClientOverProtocol(RpcClient.laye
 	concurrency: WORKER_CLIENT_CONCURRENCY
 }).pipe(Layer.provide(BrowserWorker.layer(() => port))), group, options);
 /**
-* Serves an {@link RpcGroup} on a {@link MessagePort} via the native Worker runner protocol.
+* Effect-native server for an {@link RpcGroup}: a layer that serves `group` with `handlers` over the
+* ambient {@link RpcServer.Protocol} for the life of the layer.
 */
-var serve = (port, group, handlers, options) => {
-	let runtime;
-	return {
-		async open() {
-			if (runtime) return;
-			const timingEnabled = RpcTiming.isEnabled(options?.timing);
-			const rpcGroup = timingEnabled ? RpcTiming.applyMiddleware(asRpcGroup(group)) : asRpcGroup(group);
-			const handlersLayer = timingEnabled ? Layer.merge(handlers, RpcTiming.serverLayer(RpcTiming.resolveOptions(options?.timing))) : handlers;
-			const serverLayer = RpcServer.layer(asRpcGroup(rpcGroup), {
-				disableTracing: options?.disableTracing ?? true,
-				concurrency: options?.concurrency ?? "unbounded"
-			}).pipe(Layer.provide(handlersLayer), Layer.provide(RpcServer.layerProtocolWorkerRunner.pipe(Layer.provide(BrowserWorkerRunner.layerMessagePort(port)))), Layer.orDie);
-			const current = ManagedRuntime.make(serverLayer);
-			try {
-				await current.runPromise(Effect.void);
-			} catch (error) {
-				await current.dispose();
-				throw error;
-			}
-			runtime = current;
-		},
-		async close() {
-			const current = runtime;
-			runtime = void 0;
-			await current?.dispose();
-		}
-	};
+var serverLayer = (group, handlers, options) => makeServerLayer(group, handlers, options);
+/**
+* Serves `group` with `handlers` over the ambient {@link RpcRouter.RpcRouter} for the current scope,
+* under the standard server middleware. Registration is per group, so nothing has to enumerate the
+* services a transport carries; {@link RpcRouter.layerTransport} serves whatever is registered.
+*/
+var serveOnRouter = (prefix, group, handlers, options) => {
+	const served = RpcTiming.applyMiddleware(group).middleware(DefectLogMiddleware);
+	return RpcRouter.serve(prefix, served, {
+		disableTracing: options?.disableTracing ?? true,
+		concurrency: options?.concurrency ?? "unbounded",
+		disableFatalDefects: true,
+		inProcessClient: options?.inProcessClient
+	}).pipe(Effect.provide(Layer.mergeAll(handlerLayer(group, handlers), defectLogLayer, RpcTiming.serverLayer(RpcTiming.resolveOptions(options?.timing)))));
 };
 /**
-* Serves an {@link RpcGroup} over a caller-supplied {@link RpcServer.Protocol} layer.
-* Transport-agnostic counterpart to {@link makeClientOverProtocol}: consumers provide a byte
-* protocol over a legacy transport (e.g. `@dxos/rpc`'s RpcPort layer for iframe/devtools bridges).
+* `group`'s handlers as the handlers of {@link Served} — the same group under middleware.
+*
+* `Rpc.ToHandler` keys off an rpc's `_tag` alone and `AddMiddleware` preserves it, so both are the
+* same services; a middleware only widens what a handler MAY require. TypeScript cannot reduce
+* `AddMiddleware` through a generic parameter, so the equality is stated rather than inferred.
+*/
+var handlerLayer = (group, handlers) => group.toLayer(handlers);
+/**
+* Wraps a server layer in the open/close lifecycle every transport server shares. The in-flight
+* open is cached so concurrent opens share one runtime and a close during startup disposes the
+* runtime that startup created rather than leaking it.
 */
-var serveOverProtocol = (protocol, group, handlers, options) => {
+var makeGroupServer = (buildLayer) => {
 	let runtime;
 	let openPromise;
 	return {
 		async open() {
 			if (openPromise) return openPromise;
 			openPromise = (async () => {
-				const timingEnabled = RpcTiming.isEnabled(options?.timing);
-				const rpcGroup = timingEnabled ? RpcTiming.applyMiddleware(asRpcGroup(group)) : asRpcGroup(group);
-				const handlersLayer = timingEnabled ? Layer.merge(handlers, RpcTiming.serverLayer(RpcTiming.resolveOptions(options?.timing))) : handlers;
-				const serverLayer = RpcServer.layer(asRpcGroup(rpcGroup), {
-					disableTracing: options?.disableTracing ?? true,
-					concurrency: options?.concurrency ?? "unbounded"
-				}).pipe(Layer.provide(handlersLayer), Layer.provide(protocol), Layer.orDie);
-				const current = ManagedRuntime.make(serverLayer);
+				const current = ManagedRuntime.make(buildLayer());
 				try {
 					await current.runPromise(Effect.void);
 				} catch (error) {
@@ -141,6 +153,42 @@ var serveOverProtocol = (protocol, group, handlers, options) => {
 		}
 	};
 };
+/**
+* Serves an {@link RpcGroup} on a {@link MessagePort} via the native Worker runner protocol.
+*/
+var serve = (port, group, handlers, options) => makeGroupServer(() => makeServerLayer(group, handlers, options).pipe(Layer.provide(RpcServer.layerProtocolWorkerRunner.pipe(Layer.provide(BrowserWorkerRunner.layerMessagePort(port)))), Layer.orDie));
+/**
+* Serves whatever is registered with the ambient router on a {@link MessagePort} via the native
+* Worker runner protocol — the transport half of a worker session, without the stack around it.
+* The router is resolved on `open`, so a host that builds its stack later can be served.
+*/
+var serveRouterOnPort = (router, port) => makeGroupServer(() => RpcRouter.layerTransport.pipe(Layer.provide(Layer.succeed(RpcRouter.RpcRouter, router())), Layer.provide(RpcServer.layerProtocolWorkerRunner.pipe(Layer.provide(BrowserWorkerRunner.layerMessagePort(port)))), Layer.orDie));
+/**
+* Serves an {@link RpcGroup} over a caller-supplied {@link RpcServer.Protocol} layer.
+* Transport-agnostic counterpart to {@link makeClientOverProtocol}: consumers provide a byte
+* protocol over a legacy transport (e.g. `@dxos/rpc`'s RpcPort layer for iframe/devtools bridges).
+*/
+var serveOverProtocol = (protocol, group, handlers, options) => makeGroupServer(() => makeServerLayer(group, handlers, options).pipe(Layer.provide(protocol), Layer.orDie));
+//#endregion
+//#region src/rtc-rpc.ts
+/**
+* The system channel runs the WebRTC {@link RTCService} in the worker→tab direction: the worker asks
+* the tab to establish a peer connection, and the tab transfers the resulting `RTCDataChannel` back
+* over the same {@link MessagePort} (the reverse of the app port). Only signalling and the handover
+* itself cross the boundary.
+*/
+/** Serves the tab's {@link RTCService} implementation (`RtcService`) to the worker over a {@link MessagePort}. */
+var serveRtcService = (port, service) => serve(port, RTCService.Rpcs, RTCService.Rpcs.toLayer(normalizeHandlers(RTCService.Rpcs, service)), {
+	disableTracing: true,
+	concurrency: "unbounded"
+});
+/** Builds the worker's {@link RTCService} client for the tab's implementation, over a {@link MessagePort}. */
+var makeRtcServiceClient = (port) => makeClient(port, RTCService.Rpcs);
+/**
+* Builds the worker's client over a pre-built {@link RpcClient.Protocol} — the value the tag resolves
+* to, e.g. the worker→client protocol handed to a worker-framework session via effect context.
+*/
+var makeRtcServiceClientOverProtocol = (protocol) => makeClientOverProtocol(Layer.succeed(RpcClient.Protocol, protocol), RTCService.Rpcs);
 //#endregion
 //#region src/config.ts
 var DEFAULT_CLIENT_CHANNEL = "dxos:app";
@@ -187,19 +235,139 @@ var getProfilePath = (root, profile, file) => `${root}/profile/${profile}` + (fi
 /** Path to the profile config file (profile/<name>.yml). */
 var getProfileConfigPath = (root, profile) => `${getProfilePath(root, profile)}.yml`;
 //#endregion
+//#region src/events.ts
+/**
+* The trace events the client and its services emit on `trace.events` from `@dxos/tracing`. Space creation and
+* invitation `create` come from the client; `admit` and `accept` from the services of the host and guest peers, which
+* see every success exactly once however the invitation started.
+*/
+var ClientTraceEvents = {
+	spaceCreate: "client.space.create",
+	invitationCreate: "client.invitation.create",
+	invitationAdmit: "client.invitation.admit",
+	invitationAccept: "client.invitation.accept"
+};
+/** What an invitation trace event reports about the invitation: never its keys, secrets or guest identity. */
+var invitationEventAttributes = (invitation) => ({
+	kind: invitation.kind === Invitation_Kind.DEVICE ? "device" : "space",
+	spaceId: invitation.spaceId,
+	authMethod: Invitation_AuthMethod[invitation.authMethod]?.toLowerCase(),
+	multiUse: invitation.multiUse ?? false
+});
+//#endregion
+//#region src/invitations/encoder.ts
+var base62 = base("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+/**
+* Encodes and decodes an invitation proto into/from alphanumeric chars.
+*/
+var InvitationEncoder = class {
+	static decode(text) {
+		const decodedInvitation = buf.fromBinary(InvitationSchema, base62.decode(text));
+		if (decodedInvitation.type === Invitation_Type.MULTIUSE) {
+			decodedInvitation.type = Invitation_Type.INTERACTIVE;
+			decodedInvitation.multiUse = true;
+		}
+		return decodedInvitation;
+	}
+	static encode(invitation) {
+		return base62.encode(buf.toBinary(InvitationSchema, buf.create(InvitationSchema, {
+			invitationId: invitation.invitationId,
+			type: invitation.type,
+			kind: invitation.kind,
+			authMethod: invitation.authMethod,
+			swarmKey: invitation.swarmKey,
+			state: invitation.state,
+			timeout: invitation.timeout,
+			guestKeypair: invitation.guestKeypair,
+			spaceId: invitation.spaceId,
+			lifetime: invitation.lifetime,
+			created: invitation.created,
+			...invitation.spaceKey ? { spaceKey: invitation.spaceKey } : {},
+			...invitation.target ? { target: invitation.target } : {}
+		})));
+	}
+};
+//#endregion
+//#region src/invitations/invitations.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/sdk/client-protocol/src/invitations/invitations.ts";
+var AUTHENTICATION_CODE_LENGTH = 6;
+var INVITATION_TIMEOUT = 18e4;
+/**
+* Base class for all invitation observables and providers.
+*/
+var CancellableInvitation = class extends MulticastObservable {
+	_onCancel;
+	constructor({ subscriber, initialInvitation, onCancel }) {
+		super(subscriber, initialInvitation);
+		this._onCancel = onCancel;
+	}
+	cancel() {
+		return this._onCancel();
+	}
+	get expired() {
+		const expiration = getExpirationTime(this.get());
+		return expiration && expiration.getTime() < Date.now();
+	}
+	get expiry() {
+		return getExpirationTime(this.get());
+	}
+};
+/**
+* Cancelable observer that relays authentication requests.
+*/
+var AuthenticatingInvitation = class extends CancellableInvitation {
+	_onAuthenticate;
+	constructor({ subscriber, initialInvitation, onCancel, onAuthenticate }) {
+		super({
+			subscriber,
+			initialInvitation,
+			onCancel
+		});
+		this._onAuthenticate = onAuthenticate;
+	}
+	async authenticate(authCode) {
+		return this._onAuthenticate(authCode);
+	}
+};
+/**
+* Testing util to wrap non-authenticating observable with promise.
+* Don't use this in production code.
+* @deprecated
+*/
+var wrapObservable = async (observable) => {
+	return new Promise((resolve, reject) => {
+		const subscription = observable.subscribe((invitation) => {
+			invariant(invitation?.state === Invitation_State.SUCCESS, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 91,
+				S: void 0,
+				A: ["invitation?.state === Invitation_State.SUCCESS", ""]
+			});
+			subscription.unsubscribe();
+			resolve(invitation);
+		}, (err) => {
+			subscription.unsubscribe();
+			reject(err);
+		});
+	});
+};
+var getExpirationTime = (invitation) => {
+	if (!(invitation.created && invitation.lifetime)) return;
+	return new Date(Number(bufWkt.timestampMs(invitation.created)) + invitation.lifetime * 1e3);
+};
+//#endregion
+//#region src/service.ts
+var appServiceBundle = { AppService: getBufService("dxos.iframe.AppService") };
+var shellServiceBundle = { ShellService: getBufService("dxos.iframe.ShellService") };
+//#endregion
 //#region src/service-rpc.ts
-var __dxlog_file$1 = "/__w/dxos/dxos/packages/sdk/client-protocol/src/service-rpc.ts";
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/client-protocol/src/service-rpc.ts";
 /**
 * All client service RPCs served over a single connection.
 * Rpc tags are prefixed with the {@link ClientServices} key (e.g. `DataService.subscribe`).
-*
-* {@link WorkerService} (the tab→worker control channel: `start`/`stop`) is merged in here rather
-* than served over a second port: it runs in the same tab→worker direction as the service RPCs, so
-* it multiplexes over the same app {@link MessagePort}. Only the reverse-direction `BridgeService`
-* (worker→tab) needs its own port.
 */
-var ClientServicesRpcs = class extends RpcGroup.make().merge(SystemService.Rpcs, NetworkService.Rpcs, LoggingService.Rpcs, IdentityService.Rpcs, InvitationsService.Rpcs, DevicesService.Rpcs, SpacesService.Rpcs, DataService.Rpcs, QueryService.Rpcs, FeedService.Rpcs, ContactsService.Rpcs, EdgeAgentService.Rpcs, DevtoolsHost.Rpcs, WorkerService.Rpcs) {};
-var toError$1 = (cause) => cause instanceof Error ? cause : new Error(String(cause));
+var ClientServicesRpcs = class extends RpcGroup.make().merge(SystemService.Rpcs, NetworkService.Rpcs, LoggingService.Rpcs, IdentityService.Rpcs, InvitationsService.Rpcs, DevicesService.Rpcs, SpacesService.Rpcs, DataService.Rpcs, QueryService.Rpcs, FeedService.Rpcs, ContactsService.Rpcs, InboxService.Rpcs, EdgeAgentService.Rpcs, SqlService.Rpcs, DevtoolsHost.Rpcs) {};
 var isVoidSchema = (schema) => schema.ast._tag === "Void";
 /** Splits an rpc tag into the {@link ClientServices} key and the service method name. */
 var parseTag = (tag) => {
@@ -235,8 +403,8 @@ var ClientRpcServer = class {
 		else {
 			invariant(this.#params.port, "ClientRpcServer requires a port or a protocol.", {
 				"~LogMeta": "~LogMeta",
-				F: __dxlog_file$1,
-				L: 189,
+				F: __dxlog_file,
+				L: 184,
 				S: this,
 				A: ["this.#params.port", "'ClientRpcServer requires a port or a protocol.'"]
 			});
@@ -272,13 +440,51 @@ var serveClientServicesOverIFrame = async ({ iframe, origin, channel = DEFAULT_C
 	return server;
 };
 /**
+* The rpc tag prefix a group was defined with (e.g. `DataService.`), read off its requests so a
+* registration carries no second copy of the service name.
+*/
+var servicePrefix = (group) => {
+	const [tag] = [...group.requests.keys()];
+	invariant(tag, "rpc group has no requests", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 235,
+		S: void 0,
+		A: ["tag", "'rpc group has no requests'"]
+	});
+	const index = tag.indexOf(".");
+	invariant(index > 0, `rpc tag is not service-prefixed: ${tag}`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 237,
+		S: void 0,
+		A: ["index > 0", "`rpc tag is not service-prefixed: ${tag}`"]
+	});
+	return tag.slice(0, index + 1);
+};
+/**
+* Registers a service's handlers with the stack's {@link RpcRouter.RpcRouter}, which serves them
+* over every attached transport (and in-process) for the life of the layer. Handler creation and
+* registration stay separate layers: a provider merges this with the layer that supplies its tag,
+* and no list of services is needed anywhere else.
+*/
+var RegisterService = (rpc, tag) => Layer.effectDiscard(Effect.gen(function* () {
+	const handlers = normalizeHandlers(rpc, yield* tag);
+	yield* serveOnRouter(servicePrefix(rpc), rpc, handlers, { inProcessClient: makeInProcessClient(rpc, handlers) });
+}));
+/**
+* The whole in-process {@link ClientServicesRpc}, sourced from the services registered with the
+* router rather than from an enumerated handler map.
+*/
+var makeClientServicesRpcFromRouter = RpcRouter.client.pipe(Effect.map((client) => client));
+/**
 * Builds handler layers for every client service RPC, dispatching to the service implementations
 * resolved from `services` on each call.
 */
 var makeClientServicesHandlers = ({ services, onRequest }) => {
 	const gate = onRequest ? Effect.tryPromise({
 		try: onRequest,
-		catch: toError$1
+		catch: toServiceError
 	}) : Effect.void;
 	const handlers = {};
 	for (const [tag, rpc] of ClientServicesRpcs.requests) {
@@ -366,7 +572,7 @@ var makeRpcFromServices = (services) => {
 		if (RpcSchema.isStreamSchema(rpcDef.successSchema)) service[methodName] = (request) => pbStreamToStream(() => resolveMethod()(request));
 		else service[methodName] = (request) => Effect.tryPromise({
 			try: async () => resolveMethod()(request),
-			catch: toError$1
+			catch: toServiceError
 		});
 	}
 	return rpc;
@@ -380,10 +586,10 @@ var pbStreamToStream = (open) => EffectEx.streamFromEmitter((emit) => {
 	try {
 		source = open();
 	} catch (err) {
-		emit.fail(toError$1(err));
+		emit.fail(toServiceError(err));
 		return;
 	}
-	source.subscribe((data) => void emit.single(data), (err) => void (err ? emit.fail(toError$1(err)) : emit.end()));
+	source.subscribe((data) => void emit.single(data), (err) => void (err ? emit.fail(toServiceError(err)) : emit.end()));
 	return Effect.promise(async () => source.close());
 });
 /**
@@ -393,7 +599,7 @@ var pbStreamToStream = (open) => EffectEx.streamFromEmitter((emit) => {
 var streamToPbStream = (runtime, stream, label) => new Stream(({ ready, next, close }) => {
 	const fiber = stream.pipe(Stream$1.onStart(Effect.sync(ready)), Stream$1.runForEach((item) => Effect.sync(() => next(item))), Effect.matchCauseEffect({
 		onFailure: (cause) => Effect.sync(() => {
-			const error = toError$1(Cause.squash(cause));
+			const error = toServiceError(Cause.squash(cause));
 			if (Cause.hasInterruptsOnly(cause)) {
 				close();
 				return;
@@ -403,8 +609,8 @@ var streamToPbStream = (runtime, stream, label) => new Stream(({ ready, next, cl
 				error: String(error)
 			}, {
 				"~LogMeta": "~LogMeta",
-				F: __dxlog_file$1,
-				L: 467,
+				F: __dxlog_file,
+				L: 509,
 				S: void 0
 			});
 			close(error);
@@ -416,177 +622,6 @@ var streamToPbStream = (runtime, stream, label) => new Stream(({ ready, next, cl
 	};
 });
 //#endregion
-//#region src/bridge-rpc.ts
-/**
-* The system channel runs the WebRTC {@link BridgeServiceRpc} in the worker→tab direction: the worker
-* calls the tab's network stack to proxy RTC connections. It is served over its own {@link MessagePort}
-* (the reverse of the app port) via effect-rpc, replacing the legacy protobuf duplex peer.
-*
-* `BridgeServiceRpc` is the proto-shaped interface (`Promise`/{@link PbStream}) that
-* `RtcTransportService` implements and `RtcTransportProxyFactory` consumes; the helpers below adapt
-* it to and from the effect-rpc surface.
-*/
-var toError = (cause) => cause instanceof Error ? cause : new Error(String(cause));
-/**
-* Serves a proto-shaped {@link BridgeServiceRpc} (the tab's `RtcTransportService`) over a
-* {@link MessagePort} via effect-rpc. The worker consumes it with {@link makeBridgeServiceClient}.
-*/
-var serveBridgeService = (port, service) => {
-	const unary = (method) => (payload) => Effect.tryPromise({
-		try: () => method(payload),
-		catch: toError
-	});
-	const handlers = {
-		"BridgeService.open": (payload) => pbStreamToStream(() => service.open(payload)),
-		"BridgeService.sendSignal": unary((request) => service.sendSignal(request)),
-		"BridgeService.sendData": unary((request) => service.sendData(request)),
-		"BridgeService.close": unary((request) => service.close(request)),
-		"BridgeService.getDetails": unary((request) => service.getDetails(request)),
-		"BridgeService.getStats": unary((request) => service.getStats(request))
-	};
-	return serve(port, BridgeService.Rpcs, BridgeService.Rpcs.toLayer(handlers), {
-		disableTracing: true,
-		concurrency: "unbounded"
-	});
-};
-/**
-* Builds a proto-shaped {@link BridgeServiceRpc} backed by an effect-rpc client over a
-* {@link MessagePort}. Used in the worker to hand `RtcTransportProxyFactory` a bridge that proxies to
-* the tab. The returned `close` releases the transport scope.
-*/
-var makeBridgeServiceClient = async (port) => bridgeServiceClientFromEffect((scope) => makeClient(port, BridgeService.Rpcs).pipe(Scope.provide(scope)));
-/**
-* Builds a proto-shaped {@link BridgeServiceRpc} over a pre-built {@link RpcClient.Protocol} (the
-* value the tag resolves to — e.g. the worker→client protocol handed to a worker-framework session
-* via effect context) rather than a raw {@link MessagePort}.
-*/
-var makeBridgeServiceClientOverProtocol = async (protocol) => bridgeServiceClientFromEffect((scope) => makeClientOverProtocol(Layer.succeed(RpcClient.Protocol, protocol), BridgeService.Rpcs).pipe(Scope.provide(scope)));
-/** Adapts an effect-rpc {@link BridgeService.Client} (built by the caller) to the proto-shaped surface. */
-var bridgeServiceClientFromEffect = async (makeClient) => {
-	const scope = Effect.runSync(Scope.make());
-	const client = await EffectEx.runPromise(makeClient(scope));
-	return {
-		bridgeService: {
-			open: (request) => streamToPbStream(Context.empty(), client["BridgeService.open"](request)),
-			sendSignal: (request) => EffectEx.runPromise(client["BridgeService.sendSignal"](request)),
-			sendData: (request) => EffectEx.runPromise(client["BridgeService.sendData"](request)),
-			close: (request) => EffectEx.runPromise(client["BridgeService.close"](request)),
-			getDetails: (request) => EffectEx.runPromise(client["BridgeService.getDetails"](request)),
-			getStats: (request) => EffectEx.runPromise(client["BridgeService.getStats"](request))
-		},
-		close: async () => {
-			await EffectEx.runPromise(Scope.close(scope, Exit.void));
-		}
-	};
-};
-//#endregion
-//#region src/invitations/encoder.ts
-var base62 = base("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
-var codec = schema.getCodecForType("dxos.client.services.Invitation");
-/**
-* Encodes and decodes an invitation proto into/from alphanumeric chars.
-*/
-var InvitationEncoder = class {
-	static decode(text) {
-		const decodedInvitation = codec.decode(base62.decode(text));
-		if (decodedInvitation.type === Invitation.Type.MULTIUSE) {
-			decodedInvitation.type = Invitation.Type.INTERACTIVE;
-			decodedInvitation.multiUse = true;
-		}
-		return decodedInvitation;
-	}
-	static encode(invitation) {
-		return base62.encode(codec.encode({
-			invitationId: invitation.invitationId,
-			type: invitation.type,
-			kind: invitation.kind,
-			authMethod: invitation.authMethod,
-			swarmKey: invitation.swarmKey,
-			state: invitation.state,
-			timeout: invitation.timeout,
-			guestKeypair: invitation.guestKeypair,
-			spaceId: invitation.spaceId,
-			lifetime: invitation.lifetime,
-			created: invitation.created,
-			...invitation.spaceKey ? { spaceKey: invitation.spaceKey } : {},
-			...invitation.target ? { target: invitation.target } : {}
-		}));
-	}
-};
-//#endregion
-//#region src/invitations/invitations.ts
-var __dxlog_file = "/__w/dxos/dxos/packages/sdk/client-protocol/src/invitations/invitations.ts";
-var AUTHENTICATION_CODE_LENGTH = 6;
-var INVITATION_TIMEOUT = 18e4;
-/**
-* Base class for all invitation observables and providers.
-*/
-var CancellableInvitation = class extends MulticastObservable {
-	_onCancel;
-	constructor({ subscriber, initialInvitation, onCancel }) {
-		super(subscriber, initialInvitation);
-		this._onCancel = onCancel;
-	}
-	cancel() {
-		return this._onCancel();
-	}
-	get expired() {
-		const expiration = getExpirationTime(this.get());
-		return expiration && expiration.getTime() < Date.now();
-	}
-	get expiry() {
-		return getExpirationTime(this.get());
-	}
-};
-/**
-* Cancelable observer that relays authentication requests.
-*/
-var AuthenticatingInvitation = class extends CancellableInvitation {
-	_onAuthenticate;
-	constructor({ subscriber, initialInvitation, onCancel, onAuthenticate }) {
-		super({
-			subscriber,
-			initialInvitation,
-			onCancel
-		});
-		this._onAuthenticate = onAuthenticate;
-	}
-	async authenticate(authCode) {
-		return this._onAuthenticate(authCode);
-	}
-};
-/**
-* Testing util to wrap non-authenticating observable with promise.
-* Don't use this in production code.
-* @deprecated
-*/
-var wrapObservable = async (observable) => {
-	return new Promise((resolve, reject) => {
-		const subscription = observable.subscribe((invitation) => {
-			invariant(invitation?.state === Invitation.State.SUCCESS, void 0, {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file,
-				L: 90,
-				S: void 0,
-				A: ["invitation?.state === Invitation.State.SUCCESS", ""]
-			});
-			subscription.unsubscribe();
-			resolve(invitation);
-		}, (err) => {
-			subscription.unsubscribe();
-			reject(err);
-		});
-	});
-};
-var getExpirationTime = (invitation) => {
-	if (!(invitation.created && invitation.lifetime)) return;
-	return new Date(invitation.created.getTime() + invitation.lifetime * 1e3);
-};
-//#endregion
-//#region src/service.ts
-var appServiceBundle = { AppService: schema.getService("dxos.iframe.AppService") };
-var shellServiceBundle = { ShellService: schema.getService("dxos.iframe.ShellService") };
-//#endregion
 //#region src/space.ts
 var SPACE_TAG = Symbol("dxos.client.protocol.Space");
 var isSpace = (object) => typeof object === "object" && object != null && object[SPACE_TAG] === true;
@@ -619,11 +654,7 @@ var RESOURCE_LOCK_TIMEOUT = 3e3;
 */
 var LOAD_PROPERTIES_TIMEOUT = 3e3;
 /**
-* Timeout for creating new spaces.
-*/
-var CREATE_SPACE_TIMEOUT = 5e3;
-/**
-* Timeout for creating new spaces.
+* Timeout for importing a space.
 */
 var IMPORT_SPACE_TIMEOUT = 3e4;
 /**
@@ -631,6 +662,6 @@ var IMPORT_SPACE_TIMEOUT = 3e4;
 */
 var LOAD_CONTROL_FEEDS_TIMEOUT = 3e3;
 //#endregion
-export { AUTHENTICATION_CODE_LENGTH, AUTH_TIMEOUT, AuthenticatingInvitation, CREATE_SPACE_TIMEOUT, CancellableInvitation, ClientRpcServer, ClientServicesRpcs, DEFAULT_AUTH_URL, DEFAULT_CLIENT_CHANNEL, DEFAULT_HUB_URL, DEFAULT_INTERNAL_CHANNEL, DEFAULT_PROFILE, DEFAULT_SHELL_CHANNEL, DXEnv, DX_CACHE, DX_CONFIG, DX_DATA, DX_RUNTIME, DX_STATE, EXPECTED_CONFIG_VERSION, IMPORT_SPACE_TIMEOUT, INITIALIZE_TIMEOUT, INVITATION_TIMEOUT, InvitationEncoder, LOAD_CONTROL_FEEDS_TIMEOUT, LOAD_PROPERTIES_TIMEOUT, PROXY_CONNECTION_TIMEOUT, RESOURCE_LOCK_TIMEOUT, Rpc_exports as Rpc, SPACE_TAG, STATUS_TIMEOUT, SpaceProperties, SpacePropertiesSchema, SpaceSchema, appServiceBundle, defaultConfig, getExpirationTime, getProfileConfigPath, getProfilePath, isSpace, makeBridgeServiceClient, makeBridgeServiceClientOverProtocol, makeClientServicesHandlers, makeClientServicesRpc, makeHandlersFromRpc, makeInProcessClientServicesRpc, makeRpcFromServices, makeServicesFromRpc, pbStreamToStream, serveBridgeService, serveClientServicesOverIFrame, shellServiceBundle, streamToPbStream, wrapObservable };
+export { AUTHENTICATION_CODE_LENGTH, AUTH_TIMEOUT, AuthenticatingInvitation, CancellableInvitation, ClientRpcServer, ClientServicesRpcs, ClientTraceEvents, DEFAULT_AUTH_URL, DEFAULT_CLIENT_CHANNEL, DEFAULT_HUB_URL, DEFAULT_INTERNAL_CHANNEL, DEFAULT_PROFILE, DEFAULT_SHELL_CHANNEL, DXEnv, DX_CACHE, DX_CONFIG, DX_DATA, DX_RUNTIME, DX_STATE, EXPECTED_CONFIG_VERSION, IMPORT_SPACE_TIMEOUT, INITIALIZE_TIMEOUT, INVITATION_TIMEOUT, InvitationEncoder, LOAD_CONTROL_FEEDS_TIMEOUT, LOAD_PROPERTIES_TIMEOUT, PROXY_CONNECTION_TIMEOUT, RESOURCE_LOCK_TIMEOUT, RegisterService, Rpc_exports as Rpc, SPACE_TAG, STATUS_TIMEOUT, SpaceProperties, SpacePropertiesSchema, SpaceSchema, appServiceBundle, defaultConfig, getExpirationTime, getProfileConfigPath, getProfilePath, invitationEventAttributes, isSpace, makeClientServicesHandlers, makeClientServicesRpc, makeClientServicesRpcFromRouter, makeHandlersFromRpc, makeInProcessClientServicesRpc, makeRpcFromServices, makeRtcServiceClient, makeRtcServiceClientOverProtocol, makeServicesFromRpc, pbStreamToStream, serveClientServicesOverIFrame, serveRtcService, shellServiceBundle, streamToPbStream, wrapObservable };
 
 //# sourceMappingURL=index.mjs.map