@dxos/client-services 0.10.0 → 0.11.1

package/dist/lib/index.mjs

@@ -0,0 +1,731 @@
+import { $ as CredentialServerExtension, A as orderObjJsonFields, At as subscribeToSwarmInfo, B as SigningContextProviderService, C as IdentityProviderService, Ct as DevtoolsHostEvents, D as SpaceArchiveWriter, Dt as subscribeToNetworkStatus, E as SpacesServiceImpl, Et as getNetworkPeers, F as detectSpaceArchiveFormat, G as SpaceManagerLayer, H as DataSpace, I as DataSpaceManager, J as MOCK_AUTH_PROVIDER, K as SpaceManagerService, L as DataSpaceManagerLayer, M as buildDatabaseDirectoryFromObjects, Mt as subscribeToFeeds, N as objJsonToObjectStructure, Nt as __exportAll, O as extractSpaceArchive, Ot as subscribeToNetworkTopics, P as readSerializedSpaceArchive, Pt as __reExport, Q as CredentialRetrieverExtension, R as DataSpaceManagerService, S as IdentityManagerService, St as createDiagnostics, T as Identity, Tt as subscribeToSpaces, U as EdgeFeedReplicator, V as createSigningContextProvider, W as SpaceManager, X as SpaceProtocol, Y as MOCK_AUTH_VERIFIER, Z as SpaceProtocolSession, _ as EdgeAgentManagerService, _t as DeviceInvitationProtocol, a as ServiceContextLayer, at as InvitationsManagerService, b as IdentityManager, bt as diagnostics_exports, c as FeedSyncer, ct as IMetadataStoreService, d as CrossDeviceSpaceSynchronizerLayer, dt as SpaceInvitationProtocol, et as Space, f as CrossDeviceSpaceSynchronizerService, ft as InvitationsServiceImpl, g as EdgeAgentManagerLayer, gt as createAdmissionKeypair, h as EdgeAgentManager, ht as InvitationsHandlerService, i as layerClientServicesHost, it as InvitationsManagerLayer, j as writeSerializedSpaceArchive, jt as subscribeToFeedBlocks, k as objectStructureToObjJson, kt as subscribeToSignal, l as FeedSyncerLayer, lt as MetadataStore, m as EdgeAgentServiceImpl, mt as InvitationsHandlerLayer, n as ClientServicesHost, nt as AuthExtension, o as StorageMigrationService, ot as SqliteMetadataStore, p as createCrossDeviceSpaceSynchronizer, pt as InvitationsHandler, q as AuthStatus, r as ClientServicesHostService, rt as InvitationsManager, st as SqliteMetadataStoreLayer, t as ClientServicesRpcLayer, u as FeedSyncerService, ut as hasInvitationExpired, v as locks_exports, vt as TrustedKeySetAuthVerifier, w as identityProviderFromManager, wt as DevtoolsServiceImpl, x as IdentityManagerLayer, xt as DiagnosticsCollector, y as IdentityServiceImpl, yt as createAuthProvider, z as SigningContextProviderLayer } from "./chunk-client-services-layer.mjs";
+import { t as __decorate } from "./chunk-decorate.mjs";
+import * as Effect from "effect/Effect";
+import { Trigger } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { PublicKey } from "@dxos/keys";
+import { log, logInfo } from "@dxos/log";
+import { Callback, arrayToBuffer, isNode } from "@dxos/util";
+import { invariant } from "@dxos/invariant";
+import { InvalidConfigError, ProfileArchiveEntryType, makeInProcessClient } from "@dxos/protocols";
+import { ClientRpcServer, DX_DATA, PROXY_CONNECTION_TIMEOUT, makeBridgeServiceClientOverProtocol } from "@dxos/client-protocol";
+import { cbor } from "@automerge/automerge-repo";
+import * as Context_ from "effect/Context";
+import * as Layer from "effect/Layer";
+import { RtcTransportProxyFactory } from "@dxos/network-manager";
+import { EffectEx } from "@dxos/effect";
+import { DevicesService, IdentityService } from "@dxos/protocols/rpc";
+import * as Exit from "effect/Exit";
+import * as Scope from "effect/Scope";
+import { MemorySignalManager, MemorySignalManagerContext, setIdentityTags } from "@dxos/messaging";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import * as SqlExport from "@dxos/sql-sqlite/SqlExport";
+import { StorageType, createStorage } from "@dxos/random-access-storage";
+import { Runtime } from "@dxos/protocols/proto/dxos/config";
+import path from "@dxos/node-std/path";
+import * as Reactivity from "@effect/experimental/Reactivity";
+import * as SqliteClient from "@dxos/sql-sqlite/SqliteClient";
+import * as SqlTransaction from "@dxos/sql-sqlite/SqlTransaction";
+export * from "#diagnostics-broadcast";
+export * from "#locks-platform";
+//#region src/packlets/storage/util.ts
+var getRootPath = (config) => {
+	const { dataRoot = isNode() ? DX_DATA : "dxos/storage" } = config ?? {};
+	return `${dataRoot}/`;
+};
+var isPersistent = (config) => {
+	const { persistent = false } = config ?? {};
+	return config.dataStore !== void 0 && config.dataStore !== Runtime.Client.Storage.StorageDriver.RAM || persistent;
+};
+//#endregion
+//#region src/packlets/storage/storage.ts
+var StorageDriver = Runtime.Client.Storage.StorageDriver;
+var createStorageObjects = (config) => {
+	const { persistent = false, keyStore, dataStore } = config ?? {};
+	if (persistent && dataStore === StorageDriver.RAM) throw new InvalidConfigError({ message: "RAM storage cannot be used in persistent mode." });
+	if (!persistent && dataStore !== void 0 && dataStore !== StorageDriver.RAM) throw new InvalidConfigError({ message: "Cannot use a persistent storage in not persistent mode." });
+	if (persistent && keyStore === StorageDriver.RAM) throw new InvalidConfigError({ message: "RAM key storage cannot be used in persistent mode." });
+	if (!persistent && keyStore !== StorageDriver.RAM && keyStore !== void 0) throw new InvalidConfigError({ message: "Cannot use a persistent key storage in not persistent mode." });
+	return { storage: createStorage({
+		type: persistent ? toStorageType(dataStore) : StorageType.RAM,
+		root: getRootPath(config)
+	}) };
+};
+var toStorageType = (type) => {
+	switch (type) {
+		case void 0: return;
+		case StorageDriver.RAM: return StorageType.RAM;
+		case StorageDriver.CHROME: return StorageType.CHROME;
+		case StorageDriver.FIREFOX: return StorageType.FIREFOX;
+		case StorageDriver.IDB: return StorageType.IDB;
+		case StorageDriver.NODE: return StorageType.NODE;
+		case StorageDriver.WEBFS: return StorageType.WEBFS;
+		default: throw new Error(`Invalid storage type: ${StorageDriver[type]}`);
+	}
+};
+//#endregion
+//#region src/packlets/storage/level.ts
+var createLevel = async (config) => {
+	const { createLevel: createKV } = await import("@dxos/kv-store/level");
+	const level = createKV(isPersistent(config) ? path.join(getRootPath(config), "level") : `/tmp/dxos-${PublicKey.random().toHex()}`);
+	await level.open();
+	return level;
+};
+//#endregion
+//#region src/packlets/storage/profile-archive.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/sdk/client-services/src/packlets/storage/profile-archive.ts";
+var encodeProfileArchive = (profile) => cbor.encode(profile);
+var decodeProfileArchive = (data) => cbor.decode(data);
+var exportProfileData = async ({ storage, level }) => {
+	const archive = {
+		storage: [],
+		meta: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+	};
+	{
+		const directory = await storage.createDirectory();
+		const files = await directory.list();
+		log.info("begin exporting files", { count: files.length }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 31,
+			S: void 0
+		});
+		for (const filename of files) {
+			const file = await directory.getOrCreateFile(filename);
+			const { size } = await file.stat();
+			const data = await file.read(0, size);
+			archive.storage.push({
+				type: ProfileArchiveEntryType.FILE,
+				key: filename,
+				value: data
+			});
+		}
+		log.info("done exporting files", { count: files.length }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 42,
+			S: void 0
+		});
+	}
+	{
+		log.info("begin exporting kv pairs", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 46,
+			S: void 0
+		});
+		const iter = await level.iterator({
+			keyEncoding: "binary",
+			valueEncoding: "binary"
+		});
+		let count = 0;
+		for await (const [key, value] of iter) {
+			archive.storage.push({
+				type: ProfileArchiveEntryType.KEY_VALUE,
+				key,
+				value
+			});
+			count++;
+		}
+		log.info("done exporting kv pairs", { count }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 57,
+			S: void 0
+		});
+	}
+	return archive;
+};
+var importProfileData = async ({ storage, level }, archive) => {
+	let batch = level.batch();
+	let count = 0;
+	for (const entry of archive.storage) {
+		switch (entry.type) {
+			case ProfileArchiveEntryType.FILE: {
+				const directory = await storage.createDirectory();
+				invariant(typeof entry.key === "string", "Invalid key type", {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 80,
+					S: void 0,
+					A: ["typeof entry.key === 'string'", "'Invalid key type'"]
+				});
+				const file = await directory.getOrCreateFile(entry.key);
+				invariant(entry.value instanceof Uint8Array, "Invalid value type", {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 82,
+					S: void 0,
+					A: ["entry.value instanceof Uint8Array", "'Invalid value type'"]
+				});
+				await file.write(0, arrayToBuffer(entry.value));
+				await file.close();
+				break;
+			}
+			case ProfileArchiveEntryType.KEY_VALUE:
+				invariant(entry.key instanceof Uint8Array, "Invalid key type", {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 88,
+					S: void 0,
+					A: ["entry.key instanceof Uint8Array", "'Invalid key type'"]
+				});
+				invariant(entry.value instanceof Uint8Array, "Invalid value type", {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 89,
+					S: void 0,
+					A: ["entry.value instanceof Uint8Array", "'Invalid value type'"]
+				});
+				batch.put(entry.key, entry.value, {
+					keyEncoding: "binary",
+					valueEncoding: "binary"
+				});
+				break;
+			case ProfileArchiveEntryType.SQLITE_DATABASE:
+				log.warn("Skipping SQLITE_DATABASE entry (import via OPFS recovery API)", { key: entry.key }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$2,
+					L: 94,
+					S: void 0
+				});
+				break;
+			default: throw new Error(`Invalid entry type: ${entry.type}`);
+		}
+		if (++count % 1e3 === 0) {
+			await batch.write();
+			batch = level.batch();
+			log.info("importing", {
+				count,
+				total: archive.storage.length,
+				progress: `${(count / archive.storage.length * 100).toFixed()}%`
+			}, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$2,
+				L: 105,
+				S: void 0
+			});
+		}
+	}
+	log.info("committing changes..", void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$2,
+		L: 113,
+		S: void 0
+	});
+	await batch.write();
+};
+//#endregion
+//#region src/packlets/storage/profile-archive-sqlite.ts
+/** Default OPFS SQLite database name used by Composer recovery and the OPFS worker. */
+var OPFS_SQLITE_DB_FILENAME = "DXOS";
+var SQLITE_MAGIC = new TextEncoder().encode("SQLite format 3\0");
+/**
+* Returns true when `bytes` begins with the SQLite 3 file header.
+*/
+var isValidSqliteDatabase = (bytes) => {
+	if (bytes.byteLength < SQLITE_MAGIC.byteLength) return false;
+	for (let index = 0; index < SQLITE_MAGIC.byteLength; index++) if (bytes[index] !== SQLITE_MAGIC[index]) return false;
+	return true;
+};
+var coerceToUint8Array = (value) => {
+	if (value instanceof Uint8Array) return value;
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	if (Array.isArray(value)) return new Uint8Array(value);
+};
+/**
+* Build a profile archive containing a single validated SQLITE_DATABASE entry.
+*/
+var createSqliteProfileArchive = (opfsFilename, database, options) => {
+	if (!isValidSqliteDatabase(database)) throw new Error("Invalid SQLite database (missing SQLite format 3 header)");
+	return {
+		meta: {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...options?.origin ? { origin: options.origin } : {}
+		},
+		storage: [{
+			type: ProfileArchiveEntryType.SQLITE_DATABASE,
+			key: opfsFilename,
+			value: database
+		}]
+	};
+};
+/**
+* Extract validated SQLITE_DATABASE entries from a profile archive.
+*/
+var getSqliteProfileEntries = (archive) => {
+	const entries = [];
+	for (const entry of archive.storage) {
+		if (entry.type !== ProfileArchiveEntryType.SQLITE_DATABASE) continue;
+		if (typeof entry.key !== "string") continue;
+		const database = coerceToUint8Array(entry.value);
+		if (!database || !isValidSqliteDatabase(database)) continue;
+		entries.push({
+			opfsFilename: entry.key,
+			database
+		});
+	}
+	return entries;
+};
+//#endregion
+//#region src/packlets/worker/worker-session.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-session.ts";
+/**
+* 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.
+*/
+var WorkerSession = class {
+	_clientRpc;
+	_shellClientRpc;
+	_startTrigger = new Trigger();
+	_serviceHost;
+	_systemProtocol;
+	#closeBridge;
+	onClose = new Callback();
+	origin;
+	lockKey;
+	bridgeService;
+	#workerServiceHandlers = {
+		"WorkerService.start": (payload) => Effect.sync(() => {
+			this.origin = payload.origin;
+			this.lockKey = payload.lockKey;
+			this._startTrigger.wake();
+		}),
+		"WorkerService.stop": () => Effect.forkDaemon(Effect.gen(this, function* () {
+			yield* Effect.async((resume) => {
+				setTimeout(() => resume(Effect.void));
+			});
+			yield* this.close();
+		}).pipe(Effect.tapErrorCause((cause) => Effect.sync(() => log.catch(cause, void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 77,
+			S: this
+		}))))).pipe(Effect.asVoid)
+	};
+	constructor({ serviceHost, systemProtocol, appProtocol, shellPort, readySignal }) {
+		this._serviceHost = serviceHost;
+		this._systemProtocol = systemProtocol;
+		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({
+			services,
+			protocol: appProtocol,
+			onRequest
+		});
+		this._shellClientRpc = shellPort ? new ClientRpcServer({
+			services,
+			port: shellPort,
+			onRequest
+		}) : void 0;
+	}
+	open() {
+		return Effect.gen(this, function* () {
+			log("opening...", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 115,
+				S: this
+			});
+			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()]));
+			yield* Effect.promise(() => this._startTrigger.wait({ timeout: PROXY_CONNECTION_TIMEOUT }));
+			if (this.lockKey) this._afterLockReleases(this.lockKey, () => EffectEx.runPromise(this.close()).catch((err) => log.catch(err, void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 131,
+				S: this
+			})));
+			log("opened", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 135,
+				S: this
+			});
+		});
+	}
+	close() {
+		return Effect.gen(this, function* () {
+			log.debug("closing...", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 141,
+				S: this
+			});
+			yield* Effect.promise(async () => {
+				try {
+					await this.onClose.callIfSet();
+				} catch (err) {
+					log.catch(err, void 0, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 146,
+						S: this
+					});
+				}
+			});
+			yield* Effect.promise(() => Promise.all([
+				this._clientRpc.close(),
+				this._shellClientRpc?.close(),
+				this.#closeBridge?.()
+			]));
+			this.bridgeService = void 0;
+			this.#closeBridge = void 0;
+			log.debug("closed", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 155,
+				S: this
+			});
+		});
+	}
+	async _maybeOpenShell() {
+		try {
+			this._shellClientRpc && await this._shellClientRpc.open();
+		} catch {
+			log.info("No shell connected.", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 163,
+				S: this
+			});
+		}
+	}
+	_afterLockReleases(lockKey, callback) {
+		return navigator.locks.request(lockKey, () => {}).then(callback);
+	}
+};
+__decorate([logInfo], WorkerSession.prototype, "origin", void 0);
+__decorate([logInfo], WorkerSession.prototype, "lockKey", void 0);
+//#endregion
+//#region src/packlets/worker/worker-runtime.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/sdk/client-services/src/packlets/worker/worker-runtime.ts";
+/**
+* Context tag for the dedicated-worker runtime service. Provided by {@link layerWorkerRuntime}.
+*/
+var WorkerRuntime = class extends Context_.Tag("@dxos/client-services/WorkerRuntime")() {};
+/**
+* Constructs the {@link WorkerRuntimeService}. The SQLite {@link ManagedRuntime} and
+* {@link ClientServicesHost} are built eagerly; the async open sequence runs in {@link start}.
+*/
+var makeWorkerRuntime = ({ configProvider, acquireLock, releaseLock, onStop, automaticallyConnectWebrtc = true, sqliteLayer }) => {
+	const transportFactory = new RtcTransportProxyFactory();
+	const ready = new Trigger();
+	const sessions = /* @__PURE__ */ new Set();
+	const signalMetadataTags = { runtime: "worker-runtime" };
+	let stopped = false;
+	let sessionForNetworking;
+	let config;
+	let serviceScope;
+	if (sqliteLayer) log.warn("Using testing SQLite layer", void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 113,
+		S: void 0
+	});
+	const runtime = ManagedRuntime.make(SqlTransaction.layer.pipe(Layer.provideMerge(sqliteLayer ?? LocalSqliteOpfsLayer), Layer.provideMerge(Reactivity.layer)).pipe(Layer.orDie));
+	const stop = () => Effect.promise(async () => {
+		if (stopped) return;
+		stopped = true;
+		releaseLock();
+		try {
+			await clientServices.close(Context.default(void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 133
+			}));
+			if (serviceScope) {
+				await EffectEx.runPromise(Scope.close(serviceScope, Exit.void));
+				serviceScope = void 0;
+			}
+		} finally {
+			await runtime.dispose();
+			await onStop?.();
+		}
+	});
+	const clientServices = new ClientServicesHost({
+		callbacks: { onReset: async () => {
+			await EffectEx.runPromise(stop());
+		} },
+		runtime: runtime.runtimeEffect,
+		runtimeProps: { autoActivateSpaces: true }
+	});
+	const connectBridge = (session) => {
+		sessionForNetworking = session;
+		transportFactory.setBridgeService(session?.bridgeService);
+	};
+	const reconnectWebrtc = Effect.sync(() => {
+		log("reconnecting webrtc...", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 164,
+			S: void 0
+		});
+		if (sessionForNetworking && !sessions.has(sessionForNetworking)) sessionForNetworking = void 0;
+		if (!sessionForNetworking) connectBridge(Array.from(sessions).find((session) => session.bridgeService));
+	});
+	const start = () => Effect.promise(async () => {
+		log("starting...", void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 176,
+			S: void 0
+		});
+		try {
+			log("worker-runtime: acquiring storage lock", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 178,
+				S: void 0
+			});
+			await acquireLock();
+			log("worker-runtime: storage lock acquired, resolving config", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 180,
+				S: void 0
+			});
+			config = await configProvider();
+			log("worker-runtime: config resolved", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 182,
+				S: void 0
+			});
+			const observabilityGroup = config.get("runtime.client.observabilityGroup");
+			if (observabilityGroup) signalMetadataTags.group = observabilityGroup;
+			log("worker-runtime: initializing client services host", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 187,
+				S: void 0
+			});
+			clientServices.initialize({
+				config,
+				signalManager: config.get("runtime.client.edgeFeatures")?.signaling ? void 0 : new MemorySignalManager(new MemorySignalManagerContext()),
+				transportFactory
+			});
+			log("worker-runtime: client services host initialized, opening", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 197,
+				S: void 0
+			});
+			await clientServices.open(new Context(void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 199
+			}));
+			log("worker-runtime: client services host opened, signalling ready", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 200,
+				S: void 0
+			});
+			ready.wake(void 0);
+			log("started", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 202,
+				S: void 0
+			});
+			serviceScope = Effect.runSync(Scope.make());
+			const { IdentityService: identityHandlers, DevicesService: devicesHandlers } = clientServices.services;
+			invariant(identityHandlers, "IdentityService handler not available", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 206,
+				S: void 0,
+				A: ["identityHandlers", "'IdentityService handler not available'"]
+			});
+			invariant(devicesHandlers, "DevicesService handler not available", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 207,
+				S: void 0,
+				A: ["devicesHandlers", "'DevicesService handler not available'"]
+			});
+			const [identityService, devicesService] = await EffectEx.runPromise(Effect.all([makeInProcessClient(IdentityService.Rpcs, identityHandlers), makeInProcessClient(DevicesService.Rpcs, devicesHandlers)]).pipe(Effect.provideService(Scope.Scope, serviceScope)));
+			setIdentityTags({
+				identityService,
+				devicesService,
+				setTag: (key, value) => {
+					signalMetadataTags[key] = value;
+				}
+			});
+		} catch (err) {
+			ready.wake(err);
+			log.error("starting", err, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 223,
+				S: void 0
+			});
+		}
+	});
+	const createSession = ({ appProtocol, systemProtocol, shellPort, onClose }) => Effect.gen(function* () {
+		const session = new WorkerSession({
+			serviceHost: clientServices,
+			appProtocol,
+			systemProtocol,
+			shellPort,
+			readySignal: ready
+		});
+		session.onClose.set(async () => {
+			await EffectEx.runPromise(Effect.gen(function* () {
+				sessions.delete(session);
+				if (sessions.size === 0) yield* stop();
+				else if (automaticallyConnectWebrtc) yield* reconnectWebrtc;
+			}));
+			await onClose?.();
+		});
+		yield* session.open();
+		invariant(!signalMetadataTags.origin || signalMetadataTags.origin === session.origin, `worker origin changed from ${signalMetadataTags.origin} to ${session.origin}?`, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file,
+			L: 260,
+			S: this,
+			A: ["!signalMetadataTags.origin || signalMetadataTags.origin === session.origin", "`worker origin changed from ${signalMetadataTags.origin} to ${session.origin}?`"]
+		});
+		signalMetadataTags.origin = session.origin;
+		sessions.add(session);
+		if (automaticallyConnectWebrtc) yield* reconnectWebrtc;
+		return session;
+	});
+	return {
+		host: clientServices,
+		start,
+		stop,
+		createSession,
+		connectWebrtcBridge: (session) => Effect.sync(() => connectBridge(session))
+	};
+};
+/**
+* Layer providing the {@link WorkerRuntime} service. The service is constructed synchronously;
+* callers drive `start` / `stop` explicitly (see {@link WorkerRuntimeService}).
+*/
+var layerWorkerRuntime = (options) => Layer.sync(WorkerRuntime, () => makeWorkerRuntime(options));
+/**
+* Local SQLite layer for the worker.
+* Uses in-process OPFS via {@link SqliteClient.layerOpfs} (no MessagePort).
+* NOTE: Only usable within a worker.
+*/
+var LocalSqliteOpfsLayer = Layer.effect(SqlExport.SqlExport, Effect.gen(function* () {
+	return { export: (yield* SqliteClient.SqliteClient).export };
+})).pipe(Layer.provideMerge(SqliteClient.layerOpfs({ dbName: "DXOS" })), Layer.provideMerge(Reactivity.layer));
+//#endregion
+//#region src/index.ts
+var src_exports = /* @__PURE__ */ __exportAll({
+	AuthExtension: () => AuthExtension,
+	AuthStatus: () => AuthStatus,
+	ClientServicesHost: () => ClientServicesHost,
+	ClientServicesHostService: () => ClientServicesHostService,
+	ClientServicesRpcLayer: () => ClientServicesRpcLayer,
+	CredentialRetrieverExtension: () => CredentialRetrieverExtension,
+	CredentialServerExtension: () => CredentialServerExtension,
+	CrossDeviceSpaceSynchronizerLayer: () => CrossDeviceSpaceSynchronizerLayer,
+	CrossDeviceSpaceSynchronizerService: () => CrossDeviceSpaceSynchronizerService,
+	DataSpace: () => DataSpace,
+	DataSpaceManager: () => DataSpaceManager,
+	DataSpaceManagerLayer: () => DataSpaceManagerLayer,
+	DataSpaceManagerService: () => DataSpaceManagerService,
+	DeviceInvitationProtocol: () => DeviceInvitationProtocol,
+	DevtoolsHostEvents: () => DevtoolsHostEvents,
+	DevtoolsServiceImpl: () => DevtoolsServiceImpl,
+	DiagnosticsCollector: () => DiagnosticsCollector,
+	EdgeAgentManager: () => EdgeAgentManager,
+	EdgeAgentManagerLayer: () => EdgeAgentManagerLayer,
+	EdgeAgentManagerService: () => EdgeAgentManagerService,
+	EdgeAgentServiceImpl: () => EdgeAgentServiceImpl,
+	EdgeFeedReplicator: () => EdgeFeedReplicator,
+	FeedSyncer: () => FeedSyncer,
+	FeedSyncerLayer: () => FeedSyncerLayer,
+	FeedSyncerService: () => FeedSyncerService,
+	IMetadataStoreService: () => IMetadataStoreService,
+	Identity: () => Identity,
+	IdentityManager: () => IdentityManager,
+	IdentityManagerLayer: () => IdentityManagerLayer,
+	IdentityManagerService: () => IdentityManagerService,
+	IdentityProviderService: () => IdentityProviderService,
+	IdentityServiceImpl: () => IdentityServiceImpl,
+	InvitationsHandler: () => InvitationsHandler,
+	InvitationsHandlerLayer: () => InvitationsHandlerLayer,
+	InvitationsHandlerService: () => InvitationsHandlerService,
+	InvitationsManager: () => InvitationsManager,
+	InvitationsManagerLayer: () => InvitationsManagerLayer,
+	InvitationsManagerService: () => InvitationsManagerService,
+	InvitationsServiceImpl: () => InvitationsServiceImpl,
+	MOCK_AUTH_PROVIDER: () => MOCK_AUTH_PROVIDER,
+	MOCK_AUTH_VERIFIER: () => MOCK_AUTH_VERIFIER,
+	MetadataStore: () => MetadataStore,
+	OPFS_SQLITE_DB_FILENAME: () => OPFS_SQLITE_DB_FILENAME,
+	ServiceContextLayer: () => ServiceContextLayer,
+	SigningContextProviderLayer: () => SigningContextProviderLayer,
+	SigningContextProviderService: () => SigningContextProviderService,
+	Space: () => Space,
+	SpaceArchiveWriter: () => SpaceArchiveWriter,
+	SpaceInvitationProtocol: () => SpaceInvitationProtocol,
+	SpaceManager: () => SpaceManager,
+	SpaceManagerLayer: () => SpaceManagerLayer,
+	SpaceManagerService: () => SpaceManagerService,
+	SpaceProtocol: () => SpaceProtocol,
+	SpaceProtocolSession: () => SpaceProtocolSession,
+	SpacesServiceImpl: () => SpacesServiceImpl,
+	SqliteMetadataStore: () => SqliteMetadataStore,
+	SqliteMetadataStoreLayer: () => SqliteMetadataStoreLayer,
+	StorageMigrationService: () => StorageMigrationService,
+	TrustedKeySetAuthVerifier: () => TrustedKeySetAuthVerifier,
+	WorkerRuntime: () => WorkerRuntime,
+	WorkerSession: () => WorkerSession,
+	buildDatabaseDirectoryFromObjects: () => buildDatabaseDirectoryFromObjects,
+	createAdmissionKeypair: () => createAdmissionKeypair,
+	createAuthProvider: () => createAuthProvider,
+	createCrossDeviceSpaceSynchronizer: () => createCrossDeviceSpaceSynchronizer,
+	createDiagnostics: () => createDiagnostics,
+	createLevel: () => createLevel,
+	createSigningContextProvider: () => createSigningContextProvider,
+	createSqliteProfileArchive: () => createSqliteProfileArchive,
+	createStorageObjects: () => createStorageObjects,
+	decodeProfileArchive: () => decodeProfileArchive,
+	detectSpaceArchiveFormat: () => detectSpaceArchiveFormat,
+	encodeProfileArchive: () => encodeProfileArchive,
+	exportProfileData: () => exportProfileData,
+	extractSpaceArchive: () => extractSpaceArchive,
+	getNetworkPeers: () => getNetworkPeers,
+	getSqliteProfileEntries: () => getSqliteProfileEntries,
+	hasInvitationExpired: () => hasInvitationExpired,
+	identityProviderFromManager: () => identityProviderFromManager,
+	importProfileData: () => importProfileData,
+	isValidSqliteDatabase: () => isValidSqliteDatabase,
+	layerClientServicesHost: () => layerClientServicesHost,
+	layerWorkerRuntime: () => layerWorkerRuntime,
+	makeWorkerRuntime: () => makeWorkerRuntime,
+	objJsonToObjectStructure: () => objJsonToObjectStructure,
+	objectStructureToObjJson: () => objectStructureToObjJson,
+	orderObjJsonFields: () => orderObjJsonFields,
+	readSerializedSpaceArchive: () => readSerializedSpaceArchive,
+	subscribeToFeedBlocks: () => subscribeToFeedBlocks,
+	subscribeToFeeds: () => subscribeToFeeds,
+	subscribeToNetworkStatus: () => subscribeToNetworkStatus,
+	subscribeToNetworkTopics: () => subscribeToNetworkTopics,
+	subscribeToSignal: () => subscribeToSignal,
+	subscribeToSpaces: () => subscribeToSpaces,
+	subscribeToSwarmInfo: () => subscribeToSwarmInfo,
+	writeSerializedSpaceArchive: () => writeSerializedSpaceArchive
+});
+__reExport(src_exports, diagnostics_exports);
+__reExport(src_exports, locks_exports);
+//#endregion
+export { AuthExtension, AuthStatus, ClientServicesHost, ClientServicesHostService, ClientServicesRpcLayer, CredentialRetrieverExtension, CredentialServerExtension, CrossDeviceSpaceSynchronizerLayer, CrossDeviceSpaceSynchronizerService, DataSpace, DataSpaceManager, DataSpaceManagerLayer, DataSpaceManagerService, DeviceInvitationProtocol, DevtoolsHostEvents, DevtoolsServiceImpl, DiagnosticsCollector, EdgeAgentManager, EdgeAgentManagerLayer, EdgeAgentManagerService, EdgeAgentServiceImpl, EdgeFeedReplicator, FeedSyncer, FeedSyncerLayer, FeedSyncerService, IMetadataStoreService, Identity, IdentityManager, IdentityManagerLayer, IdentityManagerService, IdentityProviderService, IdentityServiceImpl, InvitationsHandler, InvitationsHandlerLayer, InvitationsHandlerService, InvitationsManager, InvitationsManagerLayer, InvitationsManagerService, InvitationsServiceImpl, MOCK_AUTH_PROVIDER, MOCK_AUTH_VERIFIER, MetadataStore, OPFS_SQLITE_DB_FILENAME, ServiceContextLayer, SigningContextProviderLayer, SigningContextProviderService, Space, SpaceArchiveWriter, SpaceInvitationProtocol, SpaceManager, SpaceManagerLayer, SpaceManagerService, SpaceProtocol, SpaceProtocolSession, SpacesServiceImpl, SqliteMetadataStore, SqliteMetadataStoreLayer, StorageMigrationService, TrustedKeySetAuthVerifier, WorkerRuntime, WorkerSession, buildDatabaseDirectoryFromObjects, createAdmissionKeypair, createAuthProvider, createCrossDeviceSpaceSynchronizer, createDiagnostics, createLevel, createSigningContextProvider, createSqliteProfileArchive, createStorageObjects, decodeProfileArchive, detectSpaceArchiveFormat, encodeProfileArchive, exportProfileData, extractSpaceArchive, getNetworkPeers, getSqliteProfileEntries, hasInvitationExpired, identityProviderFromManager, importProfileData, isValidSqliteDatabase, layerClientServicesHost, layerWorkerRuntime, makeWorkerRuntime, objJsonToObjectStructure, objectStructureToObjJson, orderObjJsonFields, readSerializedSpaceArchive, subscribeToFeedBlocks, subscribeToFeeds, subscribeToNetworkStatus, subscribeToNetworkTopics, subscribeToSignal, subscribeToSpaces, subscribeToSwarmInfo, writeSerializedSpaceArchive };
+
+//# sourceMappingURL=index.mjs.map