@powerhousedao/connect 6.0.0-dev.25 → 6.0.0-dev.251

package/dist/reactor-DFuRedvV.js

@@ -0,0 +1,913 @@
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="21506f07-3c8e-5e4e-9317-9b57a4c695bc")}catch(e){}}();
+import { i as phGlobalConfigFromEnv } from "./connect.config-Cuh0hj_Q.js";
+import { n as toast } from "./toast-DnODOv28.js";
+import { n as loadPackagesConfig } from "./packages.config-CiH8KJVN.js";
+import { a as loadPGliteModule, n as detectRelationalPgMajor, s as resolvePgMajorForRuntime, t as detectReactorPgMajor } from "./pglite-runtime-Btp8ZXVH.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 { createRelationalDb } from "@powerhousedao/shared/processors";
+import { BrowserKeyStorage, RenownBuilder, RenownCryptoBuilder, createSignatureVerifier } from "@renown/sdk";
+import { Kysely } from "kysely";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { OpenFeature } from "@openfeature/web-sdk";
+import * as common from "@powerhousedao/powerhouse-vetra-packages";
+import commonPkg from "@powerhousedao/powerhouse-vetra-packages/package.json" with { type: "json" };
+import * as vetra from "@powerhousedao/vetra";
+import vetraPkg from "@powerhousedao/vetra/package.json" with { type: "json" };
+//#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 major = resolvePgMajorForRuntime(await detectReactorPgMajor());
+	if (major !== 17) console.warn(`[reactor] Running against legacy PGlite data dir (Postgres ${major}). Migrate to PG17 from the banner or the Inspector → Debug tab.`);
+	const { PGlite } = await loadPGliteModule(major);
+	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.
+*
+* Retries with linear backoff to handle the common race where Connect's
+* dev server is ready before the switchboard has finished binding its port.
+*
+* @param defaultDriveUrls - Array of drive REST endpoint URLs (e.g., "https://example.com/d/powerhouse")
+*/
+async function addDefaultDrivesForNewReactor(defaultDriveUrls) {
+	const MAX_ATTEMPTS = 3;
+	const BACKOFF_MS = 2e3;
+	for (const url of defaultDriveUrls) for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) try {
+		await addRemoteDrive(url);
+		break;
+	} catch (error) {
+		if (attempt === MAX_ATTEMPTS) console.error(`Failed to add default drive ${url} after ${MAX_ATTEMPTS} attempts:`, error);
+		else {
+			const delay = BACKOFF_MS * attempt;
+			console.warn(`Default drive ${url} not reachable (attempt ${attempt}/${MAX_ATTEMPTS}), retrying in ${delay}ms...`);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+	}
+}
+//#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 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;
+}
+//#endregion
+//#region src/no-registry-discovery.ts
+/**
+* Discovery service used when no package registry is configured. Every load
+* for an unknown document type is recorded as a failure with reason
+* "no-registry" so the UI can surface the issue; the modal install flow is a
+* no-op because there is no registry to query.
+*/
+var NoRegistryDiscoveryService = class {
+	#packageManager;
+	#failed = /* @__PURE__ */ new Map();
+	#failedMemo = [];
+	#failedSubscribers = /* @__PURE__ */ new Set();
+	#eventSubscribers = /* @__PURE__ */ new Set();
+	constructor(packageManager) {
+		this.#packageManager = packageManager;
+	}
+	load(documentType) {
+		const existing = this.#findModuleInLoadedPackages(documentType);
+		if (existing) {
+			this.#clearFailed(documentType);
+			return Promise.resolve(existing);
+		}
+		this.#recordFailure(documentType);
+		return Promise.reject(/* @__PURE__ */ new Error(`No package registry configured; cannot resolve "${documentType}"`));
+	}
+	promptInstallation() {}
+	approveInstallation() {
+		return Promise.resolve();
+	}
+	dismissInstallation() {}
+	getPendingInstallations() {
+		return [];
+	}
+	subscribePending() {
+		return () => {};
+	}
+	getFailedInstallations() {
+		return this.#failedMemo;
+	}
+	subscribeFailed(listener) {
+		this.#failedSubscribers.add(listener);
+		return () => {
+			this.#failedSubscribers.delete(listener);
+		};
+	}
+	subscribeEvents(listener) {
+		this.#eventSubscribers.add(listener);
+		return () => {
+			this.#eventSubscribers.delete(listener);
+		};
+	}
+	retryInstallation(documentType) {
+		this.#recordFailure(documentType);
+		return Promise.resolve();
+	}
+	#findModuleInLoadedPackages(documentType) {
+		return this.#packageManager.packages.flatMap((p) => p.documentModels).find((m) => m.documentModel.global.id === documentType);
+	}
+	#recordFailure(documentType) {
+		this.#failed.set(documentType, {
+			documentType,
+			reason: "no-registry",
+			packageNames: [],
+			error: null
+		});
+		this.#emitEvent({
+			type: "load-failed",
+			documentType,
+			reason: "no-registry"
+		});
+		this.#notifyFailedChanged();
+	}
+	#clearFailed(documentType) {
+		if (this.#failed.delete(documentType)) this.#notifyFailedChanged();
+	}
+	#notifyFailedChanged() {
+		this.#failedMemo = Array.from(this.#failed.values());
+		for (const listener of this.#failedSubscribers) listener();
+	}
+	#emitEvent(event) {
+		for (const listener of this.#eventSubscribers) listener(event);
+	}
+};
+//#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();
+	#failed = /* @__PURE__ */ new Map();
+	#failedMemo = [];
+	#failedSubscribers = /* @__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) {
+			this.#clearFailed(documentType);
+			return Promise.resolve(existing);
+		}
+		if (this.#dismissedStorage.has(documentType)) {
+			this.#recordFailure(documentType, "dismissed", [], null);
+			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.#recordFailure(documentType, "install-failed", [packageName], result.error);
+			}
+			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);
+				this.#clearFailed(documentType);
+			} else {
+				const error = /* @__PURE__ */ new Error(`Package "${packageName}" installed but module for "${documentType}" not found`);
+				entry.reject(error);
+				this.#recordFailure(documentType, "install-failed", [packageName], error);
+			}
+			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.#recordFailure(documentType, "dismissed", [packageName], null);
+		}
+		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);
+		};
+	}
+	getFailedInstallations() {
+		return this.#failedMemo;
+	}
+	subscribeFailed(listener) {
+		this.#failedSubscribers.add(listener);
+		return () => {
+			this.#failedSubscribers.delete(listener);
+		};
+	}
+	subscribeEvents(listener) {
+		this.#eventSubscribers.add(listener);
+		return () => {
+			this.#eventSubscribers.delete(listener);
+		};
+	}
+	async retryInstallation(documentType) {
+		this.#dismissedStorage.delete(documentType);
+		this.#clearFailed(documentType);
+		try {
+			await this.#discover(documentType);
+		} catch {}
+	}
+	async #discover(documentType) {
+		let packageNames;
+		try {
+			packageNames = await this.#registryClient.getPackagesByDocumentType(documentType);
+		} catch (error) {
+			const normalized = error instanceof Error ? error : new Error(String(error));
+			this.#emitEvent({
+				type: "registry-query-failed",
+				documentType,
+				error: normalized
+			});
+			this.#recordFailure(documentType, "registry-error", [], normalized);
+			return Promise.reject(normalized);
+		}
+		if (packageNames.length === 0) {
+			this.#recordFailure(documentType, "not-in-registry", [], null);
+			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();
+	}
+	#notifyFailedChanged() {
+		this.#failedMemo = Array.from(this.#failed.values());
+		for (const listener of this.#failedSubscribers) listener();
+	}
+	#recordFailure(documentType, reason, packageNames, error) {
+		this.#failed.set(documentType, {
+			documentType,
+			reason,
+			packageNames,
+			error
+		});
+		this.#emitEvent({
+			type: "load-failed",
+			documentType,
+			reason
+		});
+		this.#notifyFailedChanged();
+	}
+	#clearFailed(documentType) {
+		if (this.#failed.delete(documentType)) this.#notifyFailedChanged();
+	}
+	#emitEvent(event) {
+		for (const listener of this.#eventSubscribers) listener(event);
+	}
+};
+//#endregion
+//#region src/package-manager.ts
+/**
+* Strip any `@tag` / `@version` suffix from a package spec, returning the bare
+* package name. Mirrors `parsePackageSpec` on the UI side.
+*/
+function parseBareName(spec) {
+	const trimmed = spec.trim();
+	const at = trimmed.startsWith("@") ? trimmed.lastIndexOf("@") : trimmed.indexOf("@");
+	return at > 0 ? trimmed.slice(0, at) : trimmed;
+}
+async function fetchPackageJsonVersion(baseUrl) {
+	try {
+		const res = await fetch(baseUrl);
+		if (!res.ok) return void 0;
+		const pkg = await res.json();
+		return typeof pkg.version === "string" ? pkg.version : void 0;
+	} catch {
+		return;
+	}
+}
+const LOCAL_PACKAGE_NAME = "Local";
+var BrowserPackageManager = class {
+	registryUrl;
+	#storage;
+	#packages = /* @__PURE__ */ new Map();
+	#subscribers = /* @__PURE__ */ new Set();
+	#packagesMemo = [];
+	#stylesheets = /* @__PURE__ */ new Map();
+	#localPackage;
+	#cdnUrl;
+	#localPackageVersion;
+	#localPackageNames = new Set([LOCAL_PACKAGE_NAME]);
+	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, localPackageVersion) {
+		this.addLocalPackage(common.manifest.name, common, commonPkg.version);
+		this.addLocalPackage(vetra.manifest.name, vetra, vetraPkg.version);
+		if (localPackage) this.updateLocalPackage(localPackage, localPackageVersion);
+		for (const packageName of this.#storage.keys()) {
+			const specForReload = this.#storage.get(packageName)?.spec ?? packageName;
+			console.debug(`[Connect][PackageManager] Rehydrating "${packageName}" via spec "${specForReload}"`);
+			if ((await this.addPackage(specForReload)).type === "error") this.#storage.delete(packageName);
+		}
+	}
+	addLocalPackage(name, loadedPackage, version) {
+		this.#localPackageNames.add(name);
+		this.#registerPackage({
+			name,
+			importUrl: null,
+			stylesheetUrl: null,
+			loadedPackage,
+			version
+		});
+	}
+	updateLocalPackage(pkg, version) {
+		console.debug("Updating local package:", pkg);
+		this.#localPackage = pkg;
+		this.#registerPackage({
+			name: LOCAL_PACKAGE_NAME,
+			stylesheetUrl: null,
+			importUrl: null,
+			loadedPackage: pkg
+		});
+		if (version) {
+			this.#localPackageVersion = version;
+			this.#notifyPackagesChanged();
+			return;
+		}
+		fetchPackageJsonVersion("/package.json").then((fetchedVersion) => {
+			this.#localPackageVersion = fetchedVersion;
+			if (fetchedVersion) this.#notifyPackagesChanged();
+		}).catch(() => {});
+	}
+	get packages() {
+		return this.#packagesMemo;
+	}
+	get cdnUrl() {
+		return this.#cdnUrl;
+	}
+	getPackageSource(packageName) {
+		if (this.#localPackageNames.has(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";
+	}
+	getPackageVersion(packageName) {
+		if (packageName === this.#localPackage?.manifest.name) return this.#localPackageVersion;
+		return this.#storage.get(packageName)?.version;
+	}
+	async addPackage(packageSpec) {
+		const bareName = parseBareName(packageSpec);
+		const hasTagOrVersion = bareName !== packageSpec;
+		console.debug(`[Connect][PackageManager] addPackage spec="${packageSpec}" bareName="${bareName}"`);
+		const existingPackage = this.#packages.get(bareName);
+		if (existingPackage) {
+			console.debug(`[Connect][PackageManager] "${bareName}" already loaded; skipping re-fetch`);
+			return {
+				type: "success",
+				package: existingPackage
+			};
+		}
+		try {
+			const packageWithMeta = await this.#loadPackage(packageSpec);
+			packageWithMeta.name = bareName;
+			if (hasTagOrVersion) packageWithMeta.spec = packageSpec;
+			this.#registerPackage(packageWithMeta);
+			return {
+				type: "success",
+				package: packageWithMeta.loadedPackage
+			};
+		} catch (error) {
+			const normalized = error instanceof Error ? error : new Error(String(error));
+			console.error(`[Connect][PackageManager] Failed to install package "${packageSpec}": ${normalized.message}`, normalized);
+			return {
+				type: "error",
+				error: normalized
+			};
+		}
+	}
+	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"));
+	}
+	async #loadPackageFromNodeModules(name) {
+		const importUrl = `/node_modules/${name}/browser/index.js`;
+		const stylesheetUrl = `/node_modules/${name}/style.css`;
+		const packageWithMeta = await this.#importPackage({
+			name,
+			importUrl,
+			stylesheetUrl
+		});
+		packageWithMeta.version = await fetchPackageJsonVersion(`/node_modules/${name}/package.json`);
+		return packageWithMeta;
+	}
+	async #loadPackageFromRegistry(name) {
+		const importUrl = `${this.#cdnUrl}/${name}/browser/index.js`;
+		const stylesheetUrl = `${this.#cdnUrl}/${name}/style.css`;
+		const packageWithMeta = await this.#importPackage({
+			name,
+			importUrl,
+			stylesheetUrl
+		});
+		packageWithMeta.version = await fetchPackageJsonVersion(`${this.#cdnUrl}/${name}/package.json`);
+		return packageWithMeta;
+	}
+	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 (this.#localPackageNames.has(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, version, spec } = packageWithMeta;
+		if (stylesheetUrl !== null) this.#mountStylesheet(name, stylesheetUrl);
+		this.#packages.set(name, loadedPackage);
+		this.#storage.set(name, {
+			name,
+			importUrl,
+			stylesheetUrl,
+			version,
+			...spec ? { spec } : {}
+		});
+		console.debug(`[Connect][PackageManager] Registered "${name}" (version=${version ?? "?"}, spec=${spec ?? "—"})`);
+		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/pglite.db.ts
+async function createPGliteWorkerForMajor(major) {
+	if (major === 16) {
+		const [legacyWorker, legacyLive] = await Promise.all([import("pglite-legacy-02/worker"), import("pglite-legacy-02/live")]);
+		const worker = new Worker(new URL("./pglite.worker.legacy.js", import.meta.url), { type: "module" });
+		return legacyWorker.PGliteWorker.create(worker, { extensions: { live: legacyLive.live } });
+	}
+	const [{ PGliteWorker }, { live }] = await Promise.all([import("@electric-sql/pglite/worker"), import("@electric-sql/pglite/live")]);
+	const worker = new Worker(new URL("./pglite.worker.js", import.meta.url), { type: "module" });
+	return PGliteWorker.create(worker, { extensions: { live } });
+}
+async function getDb() {
+	const major = resolvePgMajorForRuntime(await detectRelationalPgMajor());
+	if (major !== 17) console.warn(`[reactor] Relational worker is opening legacy Postgres ${major} data dir. Migrate to PG17 from the banner or the Inspector → Debug tab.`);
+	const pgLite = await createPGliteWorkerForMajor(major);
+	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 && !n.startsWith("ph-pglite-backup::") && /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 ?? "", packagesConfig.registryUrl ?? null);
+	setVetraPackageManager(packageManager);
+	await packageManager.init(localPackage, packagesConfig.localPackage?.version);
+	try {
+		const { default: registerBundledPackages } = await import("ph-bundled-packages-virtual");
+		registerBundledPackages(packageManager);
+	} catch {}
+	(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 ?? ""
+	}) : new NoRegistryDiscoveryService(packageManager);
+	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;
+			const version = packageManager.getPackageVersion(name);
+			const label = version ? `${name}@${version}` : name;
+			logger.info("Loading processor factory: @label", label);
+			try {
+				const factory = await processorFactory?.(processorHostModule);
+				if (!factory) return;
+				await reactorClientModule.reactorModule?.processorManager.registerFactory(id, factory);
+			} catch (error) {
+				logger.error(`Error registering processor: @label`, label);
+				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-DFuRedvV.js.map
+//# debugId=21506f07-3c8e-5e4e-9317-9b57a4c695bc