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

package/dist/lib/index.mjs

@@ -0,0 +1,590 @@
+import { SpaceProperties, SpacePropertiesSchema } from "./types.mjs";
+import * as RpcClient from "@effect/rpc/RpcClient";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Runtime from "effect/Runtime";
+import * as Scope from "effect/Scope";
+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 BrowserWorker from "@effect/platform-browser/BrowserWorker";
+import * as BrowserWorkerRunner from "@effect/platform-browser/BrowserWorkerRunner";
+import * as RpcServer from "@effect/rpc/RpcServer";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import { RpcTiming } from "@dxos/worker-framework";
+import * as RpcGroup from "@effect/rpc/RpcGroup";
+import * as RpcSchema from "@effect/rpc/RpcSchema";
+import * as RpcTest from "@effect/rpc/RpcTest";
+import * as Cause from "effect/Cause";
+import * as Stream$1 from "effect/Stream";
+import { Stream } from "@dxos/codec-protobuf/stream";
+import { invariant } from "@dxos/invariant";
+import { runServiceCall } from "@dxos/protocols";
+import { layerProtocolRpcPortClient, layerProtocolRpcPortServer } from "@dxos/rpc";
+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 { MulticastObservable } from "@dxos/async";
+import * as Schema from "effect/Schema";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/Rpc.ts
+var Rpc_exports = /* @__PURE__ */ __exportAll({
+	makeClient: () => makeClient,
+	makeClientOverProtocol: () => makeClientOverProtocol,
+	serve: () => serve,
+	serveOverProtocol: () => serveOverProtocol
+});
+var WORKER_CLIENT_CONCURRENCY = Number.MAX_SAFE_INTEGER;
+var asRpcGroup = (group) => group;
+/**
+* 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
+* byte protocol over a legacy transport (e.g. `@dxos/rpc`'s RpcPort layer for iframe/devtools bridges).
+*/
+var makeClientOverProtocol = (protocol, group, options) => Effect.gen(function* () {
+	const timingEnabled = RpcTiming.isEnabled(options?.timing);
+	const rpcGroup = timingEnabled ? RpcTiming.applyMiddleware(asRpcGroup(group)) : asRpcGroup(group);
+	const protocolLayer = timingEnabled ? protocol.pipe(Layer.provideMerge(RpcTiming.clientLayer())) : protocol;
+	const context = yield* Layer.build(protocolLayer);
+	return yield* RpcClient.make(asRpcGroup(rpcGroup), { disableTracing: options?.disableTracing ?? true }).pipe(Effect.provide(context));
+}).pipe(Effect.orDie);
+/**
+* Builds an effect-native RPC client over a {@link MessagePort} using the native Worker platform
+* protocol (structured-clone frames, transferables supported).
+*/
+var makeClient = (port, group, options) => makeClientOverProtocol(RpcClient.layerProtocolWorker({
+	size: 1,
+	concurrency: WORKER_CLIENT_CONCURRENCY
+}).pipe(Layer.provide(BrowserWorker.layerPlatform(() => port))), group, options);
+/**
+* Serves an {@link RpcGroup} on a {@link MessagePort} via the native Worker runner protocol.
+*/
+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();
+		}
+	};
+};
+/**
+* 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) => {
+	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);
+				try {
+					await current.runPromise(Effect.void);
+				} catch (error) {
+					openPromise = void 0;
+					await current.dispose();
+					throw error;
+				}
+				runtime = current;
+			})();
+			return openPromise;
+		},
+		async close() {
+			if (openPromise) {
+				await openPromise.catch(() => {});
+				openPromise = void 0;
+			}
+			const current = runtime;
+			runtime = void 0;
+			await current?.dispose();
+		}
+	};
+};
+//#endregion
+//#region src/config.ts
+var DEFAULT_CLIENT_CHANNEL = "dxos:app";
+var DEFAULT_INTERNAL_CHANNEL = "dxos:vault";
+var DEFAULT_SHELL_CHANNEL = "dxos:shell";
+/**
+* @deprecated
+*/
+var DEFAULT_VAULT_URL = "https://halo.dxos.org/vault.html";
+/**
+* @deprecated
+*/
+var DEFAULT_PROFILE = "default";
+var EXPECTED_CONFIG_VERSION = 1;
+var defaultConfig = { version: 1 };
+var HOME = typeof process !== "undefined" ? process?.env?.HOME ?? "" : "";
+var DX_CONFIG = `${HOME}/.config/dx`;
+var DX_CACHE = `${HOME}/.cache/dx`;
+var DX_DATA = `${HOME}/.local/share/dx`;
+var DX_STATE = `${HOME}/.local/state/dx`;
+var DX_RUNTIME = "/tmp/dx/run";
+var DXEnv = /* @__PURE__ */ function(DXEnv) {
+	DXEnv["CONFIG"] = "DX_CONFIG";
+	DXEnv["DEBUG"] = "DX_DEBUG";
+	DXEnv["NO_AGENT"] = "DX_NO_AGENT";
+	DXEnv["PROFILE"] = "DX_PROFILE";
+	return DXEnv;
+}({});
+(function(_DXEnv) {
+	function get(variable, defaultValue) {
+		return process.env[variable] ?? defaultValue;
+	}
+	_DXEnv.get = get;
+})(DXEnv || (DXEnv = {}));
+var getProfilePath = (root, profile, file) => `${root}/profile/${profile}` + (file ? `/${file}` : "");
+/** Path to the profile config file (profile/<name>.yml). */
+var getProfileConfigPath = (root, profile) => `${getProfilePath(root, profile)}.yml`;
+//#endregion
+//#region src/service-rpc.ts
+var __dxlog_file$1 = "/__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 isVoidSchema = (schema) => schema.ast._tag === "VoidKeyword";
+/** Splits an rpc tag into the {@link ClientServices} key and the service method name. */
+var parseTag = (tag) => {
+	const index = tag.indexOf(".");
+	return [tag.slice(0, index), tag.slice(index + 1)];
+};
+/** Resolves a bound service method from a services provider, throwing if the service/method is absent. */
+var resolveServiceMethod = (services, serviceKey, methodName, tag) => {
+	const service = services[serviceKey];
+	if (!service) throw new Error(`Service not available: ${serviceKey}`);
+	const method = service[methodName];
+	if (typeof method !== "function") throw new Error(`Method not available: ${tag}`);
+	return method.bind(service);
+};
+/**
+* Serves {@link ClientServices} implementations over a {@link MessagePort} via effect-rpc.
+*/
+var ClientRpcServer = class {
+	#params;
+	#server;
+	constructor(params) {
+		this.#params = params;
+	}
+	async open() {
+		if (this.#server) return;
+		const handlers = makeClientServicesHandlers(this.#params);
+		const options = {
+			disableTracing: true,
+			concurrency: "unbounded"
+		};
+		if (this.#params.protocol) this.#server = serveOverProtocol(Layer.succeed(RpcServer.Protocol, this.#params.protocol), ClientServicesRpcs, handlers, options);
+		else {
+			invariant(this.#params.port, "ClientRpcServer requires a port or a protocol.", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 182,
+				S: this,
+				A: ["this.#params.port", "'ClientRpcServer requires a port or a protocol.'"]
+			});
+			this.#server = serve(this.#params.port, ClientServicesRpcs, handlers, options);
+		}
+		await this.#server.open();
+	}
+	async close() {
+		const server = this.#server;
+		this.#server = void 0;
+		await server?.close();
+	}
+};
+/**
+* Serves {@link ClientServices} to a child iframe (e.g. the shell) over the effect-rpc byte protocol
+* and opens the connection. The iframe uses a byte {@link RpcPort} transport (not a `MessagePort`),
+* matching the shell's {@link ClientServicesProxy} consumer, so this serves over
+* {@link layerProtocolRpcPortServer} rather than the Worker-runner protocol used by
+* {@link ClientRpcServer}. Kept here — alongside the rpc definitions — so the `RpcPort` binding is
+* resolved in this package's type universe rather than in `@dxos/client`, whose merged-with-`main`
+* build resolves `ClientRpcServer.port` as a `MessagePort`.
+*/
+var serveClientServicesOverIFrame = async ({ iframe, origin, channel = DEFAULT_CLIENT_CHANNEL, services }) => {
+	const server = serveOverProtocol(layerProtocolRpcPortServer(createIFramePort({
+		channel,
+		iframe,
+		origin
+	})), ClientServicesRpcs, makeClientServicesHandlers({ services }), {
+		disableTracing: true,
+		concurrency: "unbounded"
+	});
+	await server.open();
+	return server;
+};
+/**
+* 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
+	}) : Effect.void;
+	const handlers = {};
+	for (const [tag, rpc] of ClientServicesRpcs.requests) {
+		const [serviceKey] = parseTag(tag);
+		const invoke = (payload) => {
+			const service = services()[serviceKey];
+			const handler = service?.[tag];
+			if (typeof handler !== "function") throw new Error(`Service handler not available: ${tag}`);
+			return handler.call(service, payload);
+		};
+		if (RpcSchema.isStreamSchema(rpc.successSchema)) handlers[tag] = (payload) => gate.pipe(Effect.map(() => invoke(payload)), Stream$1.unwrap);
+		else handlers[tag] = (payload) => gate.pipe(Effect.flatMap(() => invoke(payload)));
+	}
+	return ClientServicesRpcs.toLayer(handlers);
+};
+/**
+* Builds the effect-native {@link ClientServicesRpc} over a {@link MessagePort}.
+* The returned scope owns the connection; closing it releases the transport.
+*/
+var makeClientServicesRpc = (port) => ("send" in port ? makeClientOverProtocol(layerProtocolRpcPortClient(port), ClientServicesRpcs, { disableTracing: true }) : makeClient(port, ClientServicesRpcs, { disableTracing: true })).pipe(Effect.map((client) => client));
+/**
+* Builds an in-process {@link ClientServicesRpc} backed directly by host {@link ClientServicesHandlers}
+* (no wire hop or serialization). Used by host-internal consumers (diagnostics, devtools) that need
+* the client surface without a transport.
+*/
+var makeInProcessClientServicesRpc = (services) => RpcTest.makeClient(ClientServicesRpcs).pipe(Effect.provide(makeClientServicesHandlers({ services })));
+/**
+* Derives host {@link ClientServicesHandlers} from an effect-native {@link ClientServicesRpc}, so a
+* client-side rpc surface can be re-served (e.g. the devtools bridge). Each handler delegates to the
+* corresponding client method.
+*/
+var makeHandlersFromRpc = (rpc) => {
+	const rpcRecord = rpc;
+	const handlers = {};
+	for (const [tag] of ClientServicesRpcs.requests) {
+		const [serviceKey, methodName] = parseTag(tag);
+		const service = handlers[serviceKey] ??= {};
+		service[tag] = (payload) => rpcRecord[serviceKey][methodName](payload);
+	}
+	return handlers;
+};
+/**
+* Derives the Promise/{@link PbStream} shaped {@link ClientServices} from an effect-native
+* {@link ClientServicesRpc}. Retained for consumers not yet migrated to the effect surface.
+*/
+var makeServicesFromRpc = (rpc, runtime) => {
+	const rpcRecord = rpc;
+	const services = {};
+	for (const [tag, rpcDef] of ClientServicesRpcs.requests) {
+		const [serviceKey, methodName] = parseTag(tag);
+		const service = services[serviceKey] ??= {};
+		const hasPayload = !isVoidSchema(rpcDef.payloadSchema);
+		const invoke = (request) => rpcRecord[serviceKey][methodName](hasPayload ? request ?? {} : void 0);
+		if (RpcSchema.isStreamSchema(rpcDef.successSchema)) service[methodName] = (request) => streamToPbStream(runtime, invoke(request));
+		else service[methodName] = (request, options) => runServiceCall(runtime, invoke(request), {
+			timeout: options?.timeout,
+			label: tag
+		});
+	}
+	return services;
+};
+/**
+* Builds an effect-native {@link ClientServicesRpc} from Promise/{@link PbStream} shaped
+* {@link ClientServices} implementations, without a wire hop. Used by in-process providers
+* (e.g. `LocalClientServices`) so their consumers use the same effect surface as remote proxies.
+*/
+var makeRpcFromServices = (services) => {
+	const rpc = {};
+	for (const [tag, rpcDef] of ClientServicesRpcs.requests) {
+		const [serviceKey, methodName] = parseTag(tag);
+		const service = rpc[serviceKey] ??= {};
+		const resolveMethod = () => resolveServiceMethod(services(), serviceKey, methodName, tag);
+		if (RpcSchema.isStreamSchema(rpcDef.successSchema)) service[methodName] = (request) => pbStreamToStream(() => resolveMethod()(request));
+		else service[methodName] = (request) => Effect.tryPromise({
+			try: async () => resolveMethod()(request),
+			catch: toError$1
+		});
+	}
+	return rpc;
+};
+/**
+* Adapts a protobuf service stream to an effect stream.
+* Unbounded buffering matches the push semantics of the source stream.
+*/
+var pbStreamToStream = (open) => Stream$1.asyncScoped((emit) => Effect.acquireRelease(Effect.try({
+	try: open,
+	catch: toError$1
+}), (stream) => Effect.promise(async () => stream.close())).pipe(Effect.tap((stream) => Effect.sync(() => {
+	stream.subscribe((data) => void emit.single(data), (err) => void (err ? emit.fail(toError$1(err)) : emit.end()));
+}))), "unbounded");
+/**
+* Adapts an effect stream to a protobuf service stream.
+* Consumer close interrupts the underlying rpc subscription.
+*/
+var streamToPbStream = (runtime, stream) => 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(() => close(Cause.isInterruptedOnly(cause) ? void 0 : toError$1(Cause.squash(cause)))),
+		onSuccess: () => Effect.sync(() => close())
+	}), Runtime.runFork(runtime));
+	return () => {
+		fiber.unsafeInterruptAsFork(fiber.id());
+	};
+});
+//#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.extend(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.extend(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 bridge = (await EffectEx.runPromise(makeClient(scope))).BridgeService;
+	return {
+		bridgeService: {
+			open: (request) => streamToPbStream(Runtime.defaultRuntime, bridge.open(request)),
+			sendSignal: (request) => EffectEx.runPromise(bridge.sendSignal(request)),
+			sendData: (request) => EffectEx.runPromise(bridge.sendData(request)),
+			close: (request) => EffectEx.runPromise(bridge.close(request)),
+			getDetails: (request) => EffectEx.runPromise(bridge.getDetails(request)),
+			getStats: (request) => EffectEx.runPromise(bridge.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 = 3 * 6e4;
+/**
+* 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;
+var SpaceSchema = Schema.Any.pipe(Schema.filter((space) => isSpace(space)), Schema.annotations({ title: "Space" }));
+//#endregion
+//#region src/timeouts.ts
+/**
+* Timeout for making rpc connections from remote proxies.
+*/
+var PROXY_CONNECTION_TIMEOUT = 3e4;
+/**
+* Timeout for the device to be added to the trusted set during auth.
+*/
+var AUTH_TIMEOUT = 3e4;
+/**
+* Timeout for how long the remote client will wait before assuming the connection is lost.
+*/
+var STATUS_TIMEOUT = 1e4;
+/**
+* Timeout for waiting before stealing resource lock.
+*/
+var RESOURCE_LOCK_TIMEOUT = 3e3;
+/**
+* Timeout for space properties to be loaded in the set of tracked items.
+* Accounts for latency between SpaceService reporting the space as READY and DataService streaming the item states.
+*/
+var LOAD_PROPERTIES_TIMEOUT = 3e3;
+/**
+* Timeout for creating new spaces.
+*/
+var CREATE_SPACE_TIMEOUT = 5e3;
+/**
+* Timeout for creating new spaces.
+*/
+var IMPORT_SPACE_TIMEOUT = 3e4;
+/**
+* Timeout for loading of control feeds.
+*/
+var LOAD_CONTROL_FEEDS_TIMEOUT = 3e3;
+//#endregion
+export { AUTHENTICATION_CODE_LENGTH, AUTH_TIMEOUT, AuthenticatingInvitation, CREATE_SPACE_TIMEOUT, CancellableInvitation, ClientRpcServer, ClientServicesRpcs, DEFAULT_CLIENT_CHANNEL, DEFAULT_INTERNAL_CHANNEL, DEFAULT_PROFILE, DEFAULT_SHELL_CHANNEL, DEFAULT_VAULT_URL, DXEnv, DX_CACHE, DX_CONFIG, DX_DATA, DX_RUNTIME, DX_STATE, EXPECTED_CONFIG_VERSION, IMPORT_SPACE_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 };
+
+//# sourceMappingURL=index.mjs.map