@powerhousedao/connect 6.0.0-dev.17 → 6.0.0-dev.171

package/dist/reactor-DOl6niiA.js

@@ -0,0 +1,714 @@
+import { i as phGlobalConfigFromEnv, t as connectConfig } from "./connect.config-DDu1QWU1.js";
+import { t as toast } from "./toast-iD-70hL8.js";
+import { BrowserLocalStorage, ChannelScheme, DocumentCache, DocumentChangeType, ReactorBuilder, ReactorClientBuilder, RegistryClient, addPHEventHandlers, addRemoteDrive, createAnalyticsStore, extractDriveSlugFromPath, extractNodeSlugFromPath, getDrives, login, refreshReactorDataClient, setDefaultPHGlobalConfig, setDocumentCache, setDrives, setFeatures, setPHToast, setPackageDiscoveryService, setReactorClient, setReactorClientModule, setRenown, setSelectedDrive, setSelectedNode, setVetraPackageManager } from "@powerhousedao/reactor-browser";
+import { ConsoleLogger, logger, setLogLevel as setLogLevel$1 } from "document-model";
+import { PGlite } from "@electric-sql/pglite";
+import { BrowserKeyStorage, RenownBuilder, RenownCryptoBuilder, createSignatureVerifier } from "@renown/sdk";
+import { Kysely } from "kysely";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { live } from "@electric-sql/pglite/live";
+import { PGliteWorker } from "@electric-sql/pglite/worker";
+import { createRelationalDb } from "@powerhousedao/shared/processors";
+import { OpenFeature } from "@openfeature/web-sdk";
+import * as common from "@powerhousedao/powerhouse-vetra-packages";
+import * as vetra from "@powerhousedao/vetra";
+//#region src/utils/reactor.ts
+/**
+* Creates a Reactor that plugs into legacy storage but syncs through the new
+* Reactor GQL API.
+*/
+async function createBrowserReactor(documentModelModules, upgradeManifests, renown, documentModelLoader) {
+	const signerConfig = {
+		signer: renown.signer,
+		verifier: createSignatureVerifier()
+	};
+	const jwtHandler = async (url) => {
+		if (!renown.user) return;
+		return renown.getBearerToken({
+			expiresIn: 10,
+			aud: url
+		});
+	};
+	const pg = new PGlite("idb://reactor", { relaxedDurability: true });
+	const logger = new ConsoleLogger(["reactor-client"]);
+	const builder = new ReactorClientBuilder().withLogger(logger).withSigner(signerConfig).withReactorBuilder(new ReactorBuilder().withDocumentModels(documentModelModules).withUpgradeManifests(upgradeManifests).withChannelScheme(ChannelScheme.CONNECT).withJwtHandler(jwtHandler).withKysely(new Kysely({ dialect: new PGliteDialect(pg) })));
+	if (documentModelLoader) builder.withDocumentModelLoader(documentModelLoader);
+	return {
+		...await builder.buildModule(),
+		pg
+	};
+}
+/**
+* Parse default drives from environment variable.
+* Returns an array of drive REST endpoint URLs (e.g., "https://example.com/d/powerhouse").
+*/
+function getDefaultDrivesFromEnv() {
+	const envValue = import.meta.env.PH_CONNECT_DEFAULT_DRIVES_URL;
+	if (!envValue) return [];
+	return envValue.split(",").filter((url) => url.trim().length > 0);
+}
+/**
+* Add default drives for the new reactor via sync manager.
+* @param defaultDriveUrls - Array of drive REST endpoint URLs (e.g., "https://example.com/d/powerhouse")
+*/
+async function addDefaultDrivesForNewReactor(defaultDriveUrls) {
+	for (const url of defaultDriveUrls) try {
+		await addRemoteDrive(url);
+	} catch (error) {
+		console.error(`Failed to add default drive ${url}:`, error);
+	}
+}
+//#endregion
+//#region src/feature-flags.ts
+/**
+* QueryParamProvider reads feature flags from URL query parameters.
+*
+* Usage:
+*   const params = new URLSearchParams(window.location.search);
+*   const provider = new QueryParamProvider(params);
+*   await OpenFeature.setProviderAndWait(provider);
+*
+* Query parameter format:
+*   ?FEATURE_DUAL_ACTION_CREATE_ENABLED=true&FEATURE_FOO=false
+*/
+var QueryParamProvider = class {
+	runsOn = "client";
+	metadata = { name: "QueryParamProvider" };
+	flags;
+	constructor(searchParams) {
+		this.flags = /* @__PURE__ */ new Map();
+		for (const [key, value] of searchParams.entries()) this.flags.set(key, value);
+	}
+	resolveBooleanEvaluation(flagKey, defaultValue) {
+		const value = this.flags.get(flagKey);
+		if (value === void 0) return {
+			value: defaultValue,
+			reason: "DEFAULT"
+		};
+		return {
+			value: value.toLowerCase() === "true" || value === "1",
+			reason: "STATIC",
+			variant: value
+		};
+	}
+	resolveStringEvaluation(flagKey, defaultValue) {
+		const value = this.flags.get(flagKey);
+		if (value === void 0) return {
+			value: defaultValue,
+			reason: "DEFAULT"
+		};
+		return {
+			value,
+			reason: "STATIC",
+			variant: value
+		};
+	}
+	resolveNumberEvaluation(flagKey, defaultValue) {
+		const value = this.flags.get(flagKey);
+		if (value === void 0) return {
+			value: defaultValue,
+			reason: "DEFAULT"
+		};
+		const numValue = Number(value);
+		if (isNaN(numValue)) return {
+			value: defaultValue,
+			reason: "ERROR",
+			errorCode: "PARSE_ERROR",
+			errorMessage: `Failed to parse "${value}" as a number`
+		};
+		return {
+			value: numValue,
+			reason: "STATIC",
+			variant: value
+		};
+	}
+	resolveObjectEvaluation(flagKey, defaultValue) {
+		const value = this.flags.get(flagKey);
+		if (value === void 0) return {
+			value: defaultValue,
+			reason: "DEFAULT"
+		};
+		try {
+			return {
+				value: JSON.parse(value),
+				reason: "STATIC",
+				variant: value
+			};
+		} catch (error) {
+			return {
+				value: defaultValue,
+				reason: "ERROR",
+				errorCode: "PARSE_ERROR",
+				errorMessage: `Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+	}
+};
+/**
+* Initialize OpenFeature with the QueryParamProvider.
+* Reads feature flags from query parameters.
+*/
+async function initFeatureFlags(searchParams) {
+	const params = searchParams ?? (typeof window !== "undefined" ? new URLSearchParams(window.location.search) : new URLSearchParams());
+	const provider = new QueryParamProvider(params);
+	await OpenFeature.setProviderAndWait(provider);
+	const features = /* @__PURE__ */ new Map();
+	const client = OpenFeature.getClient();
+	const inspectorEnabled = params.has(FEATURE_INSPECTOR_ENABLED) ? client.getBooleanValue(FEATURE_INSPECTOR_ENABLED, FEATURE_INSPECTOR_ENABLED_DEFAULT) : connectConfig.content.inspectorEnabled;
+	features.set(FEATURE_INSPECTOR_ENABLED, inspectorEnabled);
+	const logLevelParam = params.get("LOG_LEVEL");
+	if (logLevelParam) {
+		const validLogLevels = [
+			"verbose",
+			"debug",
+			"info",
+			"warn",
+			"error"
+		];
+		if (validLogLevels.includes(logLevelParam.toLowerCase())) {
+			setLogLevel$1(logLevelParam.toLowerCase());
+			logger.info("Log level set to @level via query param", logLevelParam.toLowerCase());
+		} else logger.warn("Invalid LOG_LEVEL query param: @param. Valid values: @validLevels", logLevelParam, validLogLevels.join(", "));
+	}
+	return features;
+}
+const FEATURE_INSPECTOR_ENABLED = "FEATURE_INSPECTOR_ENABLED";
+const FEATURE_INSPECTOR_ENABLED_DEFAULT = false;
+//#endregion
+//#region src/package-discovery.ts
+var PackageDiscoveryService = class {
+	#packageManager;
+	#registryClient;
+	#mode;
+	#deferred = /* @__PURE__ */ new Map();
+	#pending = /* @__PURE__ */ new Map();
+	#pendingMemo = [];
+	#pendingSubscribers = /* @__PURE__ */ new Set();
+	#eventSubscribers = /* @__PURE__ */ new Set();
+	#dismissedStorage;
+	#discoveredTypes = /* @__PURE__ */ new Map();
+	constructor(packageManager, registryClient, options) {
+		this.#packageManager = packageManager;
+		this.#registryClient = registryClient;
+		this.#mode = options.mode;
+		this.#dismissedStorage = new BrowserLocalStorage(options.storageKey + ":PH_DISMISSED_TYPES");
+	}
+	load(documentType) {
+		const existing = this.#findModuleInLoadedPackages(documentType);
+		if (existing) return Promise.resolve(existing);
+		if (this.#dismissedStorage.has(documentType)) return Promise.reject(/* @__PURE__ */ new Error(`Document type "${documentType}" was dismissed`));
+		const tracked = this.#deferred.get(documentType);
+		if (tracked) return tracked.promise;
+		return this.#discover(documentType);
+	}
+	promptInstallation(documentType) {
+		const packageNames = this.#discoveredTypes.get(documentType);
+		if (!packageNames) return;
+		if (this.#pending.has(documentType)) return;
+		this.#discoveredTypes.delete(documentType);
+		this.#addToPending(documentType, packageNames);
+	}
+	async approveInstallation(packageName) {
+		const affectedTypes = this.#findTypesByPackage(packageName);
+		if (affectedTypes.length === 0) return;
+		const result = await this.#packageManager.addPackage(packageName);
+		if (result.type === "error") {
+			this.#emitEvent({
+				type: "installation-failed",
+				packageName,
+				error: result.error
+			});
+			for (const documentType of affectedTypes) {
+				const entry = this.#deferred.get(documentType);
+				if (entry) {
+					entry.reject(result.error);
+					this.#deferred.delete(documentType);
+					this.#pending.delete(documentType);
+				}
+			}
+			this.#notifyPendingChanged();
+			return;
+		}
+		this.#emitEvent({
+			type: "installation-approved",
+			packageName,
+			documentTypes: affectedTypes
+		});
+		for (const documentType of affectedTypes) {
+			const entry = this.#deferred.get(documentType);
+			if (!entry) continue;
+			const module = this.#findModuleInLoadedPackages(documentType);
+			if (module) entry.resolve(module);
+			else entry.reject(/* @__PURE__ */ new Error(`Package "${packageName}" installed but module for "${documentType}" not found`));
+			this.#deferred.delete(documentType);
+			this.#pending.delete(documentType);
+		}
+		this.#notifyPendingChanged();
+	}
+	dismissInstallation(packageName) {
+		const affectedTypes = this.#findTypesByPackage(packageName);
+		if (affectedTypes.length === 0) return;
+		for (const documentType of affectedTypes) {
+			this.#dismissedStorage.set(documentType, true);
+			const entry = this.#deferred.get(documentType);
+			if (entry) entry.reject(/* @__PURE__ */ new Error(`Document type "${documentType}" was dismissed`));
+			this.#deferred.delete(documentType);
+			this.#pending.delete(documentType);
+			this.#discoveredTypes.delete(documentType);
+		}
+		this.#emitEvent({
+			type: "installation-dismissed",
+			packageName,
+			documentTypes: affectedTypes
+		});
+		this.#notifyPendingChanged();
+	}
+	getPendingInstallations() {
+		return this.#pendingMemo;
+	}
+	subscribePending(listener) {
+		this.#pendingSubscribers.add(listener);
+		return () => {
+			this.#pendingSubscribers.delete(listener);
+		};
+	}
+	subscribeEvents(listener) {
+		this.#eventSubscribers.add(listener);
+		return () => {
+			this.#eventSubscribers.delete(listener);
+		};
+	}
+	async #discover(documentType) {
+		let packageNames;
+		try {
+			packageNames = await this.#registryClient.getPackagesByDocumentType(documentType);
+		} catch (error) {
+			this.#emitEvent({
+				type: "registry-query-failed",
+				documentType,
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+			return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+		}
+		if (packageNames.length === 0) return Promise.reject(/* @__PURE__ */ new Error(`No packages found for document type "${documentType}"`));
+		const entry = this.#createDeferredEntry(documentType, packageNames);
+		this.#emitEvent({
+			type: "type-discovered",
+			documentType,
+			packageNames
+		});
+		if (this.#mode === "immediate") this.#addToPending(documentType, packageNames);
+		else this.#discoveredTypes.set(documentType, packageNames);
+		return entry.promise;
+	}
+	#createDeferredEntry(documentType, packageNames) {
+		let resolve;
+		let reject;
+		const promise = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		const entry = {
+			packageNames,
+			resolve,
+			reject,
+			promise
+		};
+		this.#deferred.set(documentType, entry);
+		return entry;
+	}
+	#addToPending(documentType, packageNames) {
+		const installation = {
+			documentType,
+			packageNames
+		};
+		this.#pending.set(documentType, installation);
+		this.#emitEvent({
+			type: "installation-prompted",
+			documentType,
+			packageNames
+		});
+		this.#notifyPendingChanged();
+	}
+	#findModuleInLoadedPackages(documentType) {
+		return this.#packageManager.packages.flatMap((p) => p.documentModels).find((m) => m.documentModel.global.id === documentType);
+	}
+	#findTypesByPackage(packageName) {
+		const types = [];
+		for (const [documentType, entry] of this.#deferred) if (entry.packageNames.includes(packageName)) types.push(documentType);
+		return types;
+	}
+	#notifyPendingChanged() {
+		this.#pendingMemo = Array.from(this.#pending.values());
+		for (const listener of this.#pendingSubscribers) listener();
+	}
+	#emitEvent(event) {
+		for (const listener of this.#eventSubscribers) listener(event);
+	}
+};
+//#endregion
+//#region src/package-manager.ts
+const LOCAL_PACKAGE_NAME = "Local";
+const LOCAL_PACKAGES = [
+	LOCAL_PACKAGE_NAME,
+	"Common",
+	"@powerhousedao/vetra"
+];
+var BrowserPackageManager = class {
+	registryUrl;
+	#storage;
+	#packages = /* @__PURE__ */ new Map();
+	#subscribers = /* @__PURE__ */ new Set();
+	#packagesMemo = [];
+	#stylesheets = /* @__PURE__ */ new Map();
+	#localPackage;
+	#cdnUrl;
+	constructor(namespace, registryUrl) {
+		this.#storage = new BrowserLocalStorage(namespace + ":PH_PACKAGES");
+		this.registryUrl = registryUrl;
+		this.#cdnUrl = registryUrl !== null ? this.#toCdnUrl(registryUrl) : null;
+	}
+	#toCdnUrl(baseUrl) {
+		if (baseUrl.includes("/-/cdn")) return baseUrl;
+		return `${baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl}/-/cdn`;
+	}
+	async init(localPackage) {
+		const commonPackageWithMeta = this.#loadCommonPackage();
+		this.#registerPackage(commonPackageWithMeta);
+		const vetraPackageWithMeta = this.#loadVetraPackage();
+		this.#registerPackage(vetraPackageWithMeta);
+		if (localPackage) this.updateLocalPackage(localPackage);
+		for (const packageName of this.#storage.keys()) await this.addPackage(packageName);
+	}
+	updateLocalPackage(pkg) {
+		console.debug("Updating local package:", pkg);
+		this.#localPackage = pkg;
+		this.#registerPackage({
+			name: LOCAL_PACKAGE_NAME,
+			stylesheetUrl: null,
+			importUrl: null,
+			loadedPackage: pkg
+		});
+	}
+	get packages() {
+		return this.#packagesMemo;
+	}
+	get cdnUrl() {
+		return this.#cdnUrl;
+	}
+	getPackageSource(packageName) {
+		if (LOCAL_PACKAGES.includes(packageName)) return "common";
+		if (packageName === this.#localPackage?.manifest.name) return "project";
+		const packageMeta = this.#storage.get(packageName);
+		if (!packageMeta) return null;
+		if (packageMeta.importUrl === `/node_modules/${packageName}`) return "local-install";
+		return "registry-install";
+	}
+	async addPackage(packageName) {
+		const existingPackage = this.#packages.get(packageName);
+		if (existingPackage) return {
+			type: "success",
+			package: existingPackage
+		};
+		try {
+			const packageWithMeta = await this.#loadPackage(packageName);
+			this.#registerPackage(packageWithMeta);
+			return {
+				type: "success",
+				package: packageWithMeta.loadedPackage
+			};
+		} catch (error) {
+			return {
+				type: "error",
+				error: error instanceof Error ? error : new Error(String(error))
+			};
+		}
+	}
+	async addPackages(packageNames) {
+		const results = [];
+		for (const packageName of packageNames) {
+			const result = await this.addPackage(packageName);
+			results.push(result);
+		}
+		return results;
+	}
+	removePackage(name) {
+		this.#packages.delete(name);
+		this.#storage.delete(name);
+		this.#unmountStylesheet(name);
+		this.#notifyPackagesChanged();
+	}
+	subscribe(handler) {
+		this.#subscribers.add(handler);
+		return () => {
+			this.#subscribers.delete(handler);
+		};
+	}
+	load(documentType) {
+		const documentModelModule = Array.from(this.#packages.values().flatMap((p) => p.documentModels)).find((m) => m.documentModel.global.id === documentType);
+		if (documentModelModule) return Promise.resolve(documentModelModule);
+		return Promise.reject(/* @__PURE__ */ new Error("Model not available"));
+	}
+	#loadCommonPackage() {
+		return {
+			name: common.manifest.name,
+			importUrl: null,
+			stylesheetUrl: null,
+			loadedPackage: common
+		};
+	}
+	#loadVetraPackage() {
+		return {
+			name: vetra.manifest.name,
+			importUrl: null,
+			stylesheetUrl: null,
+			loadedPackage: vetra
+		};
+	}
+	async #loadPackageFromNodeModules(name) {
+		const importUrl = `/node_modules/${name}/browser/index.js`;
+		const stylesheetUrl = `/node_modules/${name}/style.css`;
+		return await this.#importPackage({
+			name,
+			importUrl,
+			stylesheetUrl
+		});
+	}
+	async #loadPackageFromRegistry(name) {
+		const importUrl = `${this.#cdnUrl}/${name}/browser/index.js`;
+		const stylesheetUrl = `${this.#cdnUrl}/${name}/style.css`;
+		return await this.#importPackage({
+			name,
+			importUrl,
+			stylesheetUrl
+		});
+	}
+	async #importPackage(packageMeta) {
+		const { name, importUrl, stylesheetUrl } = packageMeta;
+		if (!importUrl) throw new Error(`Import url not defined for package "${name}".`);
+		return {
+			name,
+			loadedPackage: await import(
+				/* @vite-ignore */
+				importUrl
+),
+			importUrl,
+			stylesheetUrl
+		};
+	}
+	async #loadPackage(packageName) {
+		if (LOCAL_PACKAGES.includes(packageName)) throw new Error(`Package "${packageName}" is a local package and cannot be loaded dynamically.`);
+		if (!import.meta.env.PROD) try {
+			return await this.#loadPackageFromNodeModules(packageName);
+		} catch (error) {
+			console.warn(`Failed to load package "${packageName}" from node_modules:`, error);
+		}
+		if (!this.registryUrl) throw new Error("Registry url not defined.");
+		return await this.#loadPackageFromRegistry(packageName);
+	}
+	#registerPackage(packageWithMeta) {
+		const { name, loadedPackage, importUrl, stylesheetUrl } = packageWithMeta;
+		if (stylesheetUrl !== null) this.#mountStylesheet(name, stylesheetUrl);
+		this.#packages.set(name, loadedPackage);
+		this.#storage.set(name, {
+			name,
+			importUrl,
+			stylesheetUrl
+		});
+		this.#notifyPackagesChanged();
+	}
+	#mountStylesheet(name, href) {
+		const existing = this.#stylesheets.get(name);
+		if (existing) return existing;
+		const link = document.createElement("link");
+		link.rel = "stylesheet";
+		link.href = href;
+		document.head.appendChild(link);
+		this.#stylesheets.set(name, link);
+	}
+	#unmountStylesheet(name) {
+		const link = this.#stylesheets.get(name);
+		if (!link) return;
+		link.remove();
+		this.#stylesheets.delete(name);
+	}
+	#notifyPackagesChanged() {
+		this.#packagesMemo = Array.from(this.#packages.values());
+		const packages = this.packages;
+		this.#subscribers.forEach((handler) => {
+			handler({ packages });
+		});
+	}
+};
+//#endregion
+//#region src/packages.config.ts
+function assertPackagesConfig(value) {
+	if (typeof value !== "object" || value === null) throw new Error("ph-packages.json must be a JSON object");
+	const obj = value;
+	if (!Array.isArray(obj.packages)) throw new Error("ph-packages.json: 'packages' must be an array");
+	if (!obj.packages.every((item) => typeof item === "string")) throw new Error("ph-packages.json: 'packages' must be an array of strings");
+}
+let cached;
+async function loadPackagesConfig() {
+	if (cached) return cached;
+	const url = `${import.meta.env.BASE_URL ?? "/"}ph-packages.json`;
+	const json = await (await fetch(url)).json();
+	assertPackagesConfig(json);
+	cached = json;
+	return cached;
+}
+//#endregion
+//#region src/pglite.db.ts
+async function getDb() {
+	const worker = new Worker(new URL("./pglite.worker.js", import.meta.url), { type: "module" });
+	const pgLite = await PGliteWorker.create(worker, { extensions: { live } });
+	return {
+		pgLite,
+		relationalDb: createRelationalDb(new Kysely({ dialect: new PGliteDialect(pgLite) }))
+	};
+}
+//#endregion
+//#region src/store/processor-host-module.ts
+async function createProcessorHostModule(reactorClient, readModels) {
+	try {
+		const { pgLite, relationalDb } = await getDb();
+		const { store: analyticsStore } = await createAnalyticsStore({ pgLite });
+		return {
+			relationalDb,
+			analyticsStore,
+			processorApp: "connect",
+			dispatch: { async execute(docId, branch, actions, signal) {
+				const jobInfo = await reactorClient.executeAsync(docId, branch, actions, signal);
+				return {
+					id: jobInfo.id,
+					status: jobInfo.status
+				};
+			} },
+			getReadModel(name) {
+				const model = readModels.find((m) => m.name === name);
+				if (!model) throw new Error(`Read model "${name}" not found`);
+				return model;
+			}
+		};
+	} catch (error) {
+		console.error(`Failed to initialize processor host module:`);
+		console.error(error);
+	}
+}
+//#endregion
+//#region src/store/reactor.ts
+async function clearReactorStorage() {
+	await window.ph?.reactorClientModule?.pg?.close();
+	const targets = (await indexedDB.databases()).map((d) => d.name).filter((n) => !!n && /pglite|reactor/i.test(n));
+	await Promise.all(targets.map((name) => new Promise((resolve) => {
+		const req = indexedDB.deleteDatabase(name);
+		req.onsuccess = req.onerror = req.onblocked = () => resolve();
+	})));
+}
+async function createReactor(localPackage) {
+	if (!window.ph) window.ph = {};
+	if (window.ph.loading) return;
+	window.ph.loading = true;
+	addPHEventHandlers();
+	setPHToast(toast);
+	const features = await initFeatureFlags();
+	logger.info("Features: @features", JSON.stringify(Object.fromEntries(features), null, 2));
+	const keyPairStorage = await BrowserKeyStorage.create();
+	const renownCrypto = await new RenownCryptoBuilder().withKeyPairStorage(keyPairStorage).build();
+	const renown = await new RenownBuilder("connect", {
+		basename: phGlobalConfigFromEnv.routerBasename,
+		baseUrl: phGlobalConfigFromEnv.renownUrl
+	}).withCrypto(renownCrypto).build();
+	const packagesConfig = await loadPackagesConfig();
+	const packageManager = new BrowserPackageManager(phGlobalConfigFromEnv.routerBasename ?? "", PH_PACKAGE_REGISTRY_URL);
+	setVetraPackageManager(packageManager);
+	await packageManager.init(localPackage);
+	(await packageManager.addPackages(packagesConfig.packages)).map((r) => {
+		if (r.type === "error") console.error(r.error);
+	});
+	const documentModelModules = packageManager.packages.flatMap((pkg) => pkg.documentModels).filter((module, index, modules) => modules.findIndex((m) => m.documentModel.global.id === module.documentModel.global.id && m.version === module.version) === index);
+	const upgradeManifests = packageManager.packages.flatMap((pkg) => pkg.upgradeManifests).filter((manifest, index, manifests) => manifest !== void 0 && manifests.findIndex((m) => m && m.documentType === manifest.documentType) === index);
+	const discoveryService = packageManager.cdnUrl !== null ? new PackageDiscoveryService(packageManager, new RegistryClient(packageManager.cdnUrl), {
+		mode: "immediate",
+		storageKey: phGlobalConfigFromEnv.routerBasename ?? ""
+	}) : void 0;
+	if (discoveryService) setPackageDiscoveryService(discoveryService);
+	const reactorClientModule = await createBrowserReactor(documentModelModules, upgradeManifests, renown, discoveryService);
+	const drives = await getDrives(reactorClientModule.client);
+	const path = window.location.pathname;
+	const driveSlug = extractDriveSlugFromPath(path);
+	const nodeSlug = extractNodeSlugFromPath(path);
+	await login(getDidFromUrl(), renown);
+	const documentCache = new DocumentCache(reactorClientModule.client);
+	setDefaultPHGlobalConfig(phGlobalConfigFromEnv);
+	setReactorClientModule(reactorClientModule);
+	setReactorClient(reactorClientModule.client);
+	setDocumentCache(documentCache);
+	setRenown(renown);
+	setDrives(drives);
+	setSelectedDrive(driveSlug);
+	setSelectedNode(nodeSlug);
+	setFeatures(features);
+	const defaultDrivesConfig = getDefaultDrivesFromEnv();
+	if (defaultDrivesConfig.length > 0) await addDefaultDrivesForNewReactor(defaultDrivesConfig);
+	const remoteUrl = getDriveUrl();
+	if (remoteUrl) try {
+		await addRemoteDrive(remoteUrl);
+	} catch (error) {
+		console.error(`Failed to add remote drive from ${remoteUrl}:`, error);
+	}
+	const reactorClient = reactorClientModule.client;
+	reactorClient.subscribe({ type: "powerhouse/document-drive" }, (event) => {
+		logger.verbose("ReactorClient subscription event: @event", event);
+		refreshReactorDataClient(reactorClientModule.client).catch((e) => logger.error("@error", e));
+	});
+	reactorClient.subscribe({}, (event) => {
+		if (event.type !== DocumentChangeType.Deleted) return;
+		const deletedId = event.context?.childId;
+		if (!deletedId) return;
+		const selectedDriveId = window.ph?.selectedDriveId;
+		const selectedNodeId = window.ph?.selectedNodeId;
+		if (selectedDriveId && deletedId === selectedDriveId) {
+			setSelectedDrive(void 0);
+			toast("The drive you were viewing has been deleted");
+			return;
+		}
+		if (selectedNodeId && deletedId === selectedNodeId) {
+			setSelectedNode(void 0);
+			toast("The document you were editing has been deleted");
+		}
+	});
+	await refreshReactorDataClient(reactorClientModule.client);
+	const packagesWithProcessorFactories = packageManager.packages.filter((pkg) => pkg.processorFactory !== void 0);
+	if (packagesWithProcessorFactories.length > 0) {
+		const readModels = reactorClientModule.reactorModule?.readModelCoordinator?.readModels ?? [];
+		const processorHostModule = await createProcessorHostModule(reactorClientModule.client, readModels);
+		if (processorHostModule !== void 0) await Promise.all(packagesWithProcessorFactories.map(async (pkg) => {
+			const { manifest, processorFactory } = pkg;
+			const name = manifest.name;
+			const id = manifest.name;
+			logger.info("Loading processor factory: @name", name);
+			try {
+				const factory = await processorFactory?.(processorHostModule);
+				if (!factory) return;
+				await reactorClientModule.reactorModule?.processorManager.registerFactory(id, factory);
+			} catch (error) {
+				logger.error(`Error registering processor: @name`, name);
+				logger.error("@error", error);
+			}
+		}));
+	}
+	window.ph.loading = false;
+}
+function getDidFromUrl() {
+	const didComponent = new URLSearchParams(window.location.search).get("user");
+	return didComponent ? decodeURIComponent(didComponent) : void 0;
+}
+function getDriveUrl() {
+	const driveUrl = new URLSearchParams(window.location.search).get("driveUrl");
+	return driveUrl ? decodeURIComponent(driveUrl) : void 0;
+}
+//#endregion
+export { createReactor as n, clearReactorStorage as t };
+
+//# sourceMappingURL=reactor-DOl6niiA.js.map