@powerhousedao/connect 6.2.1 → 6.2.2-dev.1

package/dist/{reactor-DWY9_ifj.js → reactor-Bo6Lut7c.js}

@@ -1,46 +1,67 @@
 
-!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]="e4ac466f-3b1a-588d-9c21-2041c2992b7e")}catch(e){}}();
+!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]="a1393f51-b593-56ea-8200-57f565bcd3ca")}catch(e){}}();
 import { n as getRuntimeConfig } from "./runtime-config-DL3QjcfM.js";
-import { n as buildPHGlobalConfig, o as phGlobalConfig } from "./connect.config-BDYNejx3.js";
-import { i as loadPGliteModule, m as REACTOR_PGLITE_NAME, o as resolvePgMajorForRuntime, t as detectReactorPgMajor } from "./pglite-runtime-CHa5UyCw.js";
-import { n as toast } from "./toast-BEy42aYx.js";
+import { a as resolvePgMajorForRuntime, r as loadPGliteModule } from "./pglite-major-B39aOEiE.js";
+import { r as getVersion, t as getGitSha } from "./build-info-D0TYDOtW.js";
+import { n as buildPHGlobalConfig, o as phGlobalConfig } from "./connect.config-vgUeFoNp.js";
+import { a as detectReactorPgMajor, h as RELATIONAL_PGLITE_NAME, m as REACTOR_PGLITE_NAME, n as setWorkerConnectionStatus, o as detectRelationalPgMajor, p as REACTOR_INSTANCE_NAMESPACE } from "./connection-state-DO_2lAEJ.js";
+import { n as toast } from "./toast-4t-VimvD.js";
 import { createRelationalDb } from "@powerhousedao/shared/processors";
-import { BrowserLocalStorage, ChannelScheme, DRIVE_DOCUMENT_TYPES, DocumentCache, DocumentChangeType, ReactorBuilder, ReactorClientBuilder, RegistryClient, addPHEventHandlers, addRemoteDrive, createAnalyticsStore, extractDriveSlugFromPath, extractNodeSlugFromPath, getDrives, isDriveAuthError, login, refreshReactorDataClient, setAttachmentService, setDefaultPHGlobalConfig, setDocumentCache, setDriveMetadata, setDrives, setFeatures, setPHToast, setPackageDiscoveryService, setReactorClient, setReactorClientModule, setRenown, setSelectedDrive, setSelectedNode, setVetraPackageManager, waitForDocumentReady } from "@powerhousedao/reactor-browser";
-import { ConsoleLogger, logger, setLogLevel as setLogLevel$1 } from "document-model";
-import { BrowserKeyStorage, RenownBuilder, RenownCryptoBuilder, createSignatureVerifier } from "@renown/sdk";
+import { DocumentModelRegistry, DocumentModelResolver, ReactorEventTypes } from "@powerhousedao/reactor";
+import { MessageRouter, RPC_PROTOCOL_VERSION, SyncManagerProxy, connectReactorClient, createInspectorProxy, createPortTransport, createReactorEventBusProxy, createRelationalPgliteProxy, createWorkerAdminClient, postReactorIdentity } from "@powerhousedao/reactor-browser/rpc";
 import { Kysely } from "kysely";
 import { PGliteDialect } from "kysely-pglite-dialect";
+import { BrowserLocalStorage, ChannelScheme as ChannelScheme$1, DRIVE_DOCUMENT_TYPES, DocumentCache, DocumentChangeType, ReactorBuilder as ReactorBuilder$1, ReactorClientBuilder as ReactorClientBuilder$1, RegistryClient, addPHEventHandlers, addRemoteDrive, createAnalyticsStore, extractDriveSlugFromPath, extractNodeSlugFromPath, getDrives, isDriveAuthError, login, refreshReactorDataClient, setAttachmentService, setDefaultPHGlobalConfig, setDocumentCache, setDriveMetadata, setDrives, setFeatures, setPGliteDB, setPHToast, setPackageDiscoveryService, setReactorClient, setReactorClientModule, setRenown, setSelectedDrive, setSelectedNode, setVetraPackageManager, waitForDocumentReady } from "@powerhousedao/reactor-browser";
+import { ConsoleLogger, logger, setLogLevel as setLogLevel$1 } from "document-model";
+import { BrowserKeyStorage, RenownBuilder, RenownCryptoBuilder, createSignatureVerifier } from "@renown/sdk";
 import { createAttachmentClient, createRemoteAttachmentService } from "@powerhousedao/reactor-attachments/client";
 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/pglite.db.ts
-async function createMainThreadPGlite(major) {
+async function createMainThreadPGlite(major, dbName) {
 	const { PGlite } = await loadPGliteModule(major);
 	const { live } = major === 16 ? await import("pglite-legacy-02/live") : await import("@electric-sql/pglite/live");
-	return new PGlite(`idb://${REACTOR_PGLITE_NAME}`, {
+	return new PGlite(`idb://${dbName}`, {
 		relaxedDurability: true,
 		extensions: { live }
 	});
 }
-let sharedPGlite;
-function getSharedPGlite() {
-	if (sharedPGlite) return sharedPGlite;
-	const pending = (async () => {
-		const major = resolvePgMajorForRuntime(await detectReactorPgMajor());
-		if (major !== 17) console.warn(`[reactor] Opening legacy Postgres ${major} data dir. Migrate to PG17 from the banner or the Inspector → Debug tab.`);
-		return createMainThreadPGlite(major);
-	})();
-	sharedPGlite = pending;
-	pending.catch(() => {
-		if (sharedPGlite === pending) sharedPGlite = void 0;
-	});
+let bootChain = Promise.resolve();
+function chainedCreate(create) {
+	const pending = bootChain.then(create, create);
+	bootChain = pending.catch(() => void 0);
 	return pending;
 }
+function pgliteSingleton(opts) {
+	let cached;
+	return function getPGlite() {
+		if (cached) return cached;
+		const pending = chainedCreate(async () => {
+			const major = resolvePgMajorForRuntime(await opts.detectMajor());
+			if (major !== 17) console.warn(`[${opts.label}] Opening legacy Postgres ${major} data dir. Migrate to PG17 from the banner or the Inspector → Debug tab.`);
+			return createMainThreadPGlite(major, opts.dbName);
+		});
+		cached = pending;
+		pending.catch(() => {
+			if (cached === pending) cached = void 0;
+		});
+		return pending;
+	};
+}
+const getReactorPGlite = pgliteSingleton({
+	dbName: REACTOR_PGLITE_NAME,
+	detectMajor: detectReactorPgMajor,
+	label: "reactor"
+});
+const getRelationalPGlite = pgliteSingleton({
+	dbName: RELATIONAL_PGLITE_NAME,
+	detectMajor: detectRelationalPgMajor,
+	label: "relational"
+});
 async function getDb() {
-	const pgLite = await getSharedPGlite();
+	const pgLite = await getRelationalPGlite();
 	return {
 		pgLite,
 		relationalDb: createRelationalDb(new Kysely({ dialect: new PGliteDialect(pgLite) }))
@@ -61,13 +82,18 @@ async function createBrowserReactor(documentModelModules, upgradeManifests, reno
 		if (!renown.user) return;
 		return renown.getBearerToken({ expiresIn: 10 });
 	};
-	const pg = await getSharedPGlite();
+	const pg = await getReactorPGlite();
 	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) })));
+	const builder = new ReactorClientBuilder$1().withLogger(logger).withSigner(signerConfig).withReactorBuilder(new ReactorBuilder$1().withDocumentModels(documentModelModules).withUpgradeManifests(upgradeManifests).withChannelScheme(ChannelScheme$1.CONNECT).withJwtHandler(jwtHandler).withKysely(new Kysely({ dialect: new PGliteDialect(pg) })));
 	if (documentModelLoader) builder.withDocumentModelLoader(documentModelLoader);
+	const module = await builder.buildModule();
 	return {
-		...await builder.buildModule(),
-		pg
+		...module,
+		kind: "browser",
+		reactorModule: module.reactorModule ? {
+			...module.reactorModule,
+			pg
+		} : void 0
 	};
 }
 function getDefaultDrives(runtimeConfig) {
@@ -584,9 +610,12 @@ var BrowserPackageManager = class {
 		if (baseUrl.includes("/-/cdn")) return baseUrl;
 		return `${baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl}/-/cdn`;
 	}
-	async init(localPackage, localPackageVersion) {
+	async init(localPackage, localPackageVersion, studioMode) {
 		this.addLocalPackage(common.manifest.name, common, commonPkg.version);
-		this.addLocalPackage(vetra.manifest.name, vetra, vetraPkg.version);
+		if (studioMode) {
+			const vetra = await import("@powerhousedao/vetra");
+			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;
@@ -803,6 +832,167 @@ var BrowserPackageManager = class {
 	}
 };
 //#endregion
+//#region src/reactor-worker-name.ts
+const GEN_KEY_PREFIX = "ph-reactor-gen:";
+function reactorWorkerName(namespace) {
+	const gen = readWorkerGen(namespace);
+	return gen ? `ph-reactor:${namespace}#${gen}` : `ph-reactor:${namespace}`;
+}
+function readWorkerGen(namespace) {
+	try {
+		return localStorage.getItem(GEN_KEY_PREFIX + namespace);
+	} catch {
+		return null;
+	}
+}
+function bumpWorkerGen(namespace, gen) {
+	try {
+		localStorage.setItem(GEN_KEY_PREFIX + namespace, gen);
+	} catch {}
+}
+//#endregion
+//#region src/reactor-worker-client.ts
+const PING_INTERVAL_MS = 2e3;
+const PING_DEADLINE_MS = 3e3;
+const MAX_MISSED_PINGS = 2;
+function toReactorIdentity(user) {
+	if (!user) return null;
+	return {
+		address: user.address,
+		chainId: user.chainId,
+		networkId: user.networkId
+	};
+}
+function createWorkerReactorClientModule(args) {
+	const workerUrl = new URL("./reactor.worker.js", import.meta.url);
+	console.info(`[reactor-worker] constructing SharedWorker ${reactorWorkerName(args.namespace)} from ${workerUrl.href}`);
+	const worker = new SharedWorker(workerUrl, {
+		name: reactorWorkerName(args.namespace),
+		type: "module"
+	});
+	worker.addEventListener("error", (event) => {
+		console.error(`[reactor-worker] SharedWorker failed to load from ${workerUrl.href}`, event.message || event);
+	});
+	worker.port.onmessageerror = (event) => {
+		console.error("[reactor-worker] port message could not be deserialized", event);
+	};
+	const transport = createPortTransport(worker.port);
+	const router = new MessageRouter();
+	router.attach(transport);
+	const documentModelRegistry = new DocumentModelRegistry();
+	documentModelRegistry.registerModules(...args.documentModelModules);
+	documentModelRegistry.registerUpgradeManifests(...args.upgradeManifests);
+	const gitSha = getGitSha();
+	const clientProxy = connectReactorClient(router, {
+		version: {
+			appBuildId: gitSha !== "unknown" ? gitSha : getVersion(),
+			rpcProtocolVersion: RPC_PROTOCOL_VERSION,
+			models: args.documentModelModules.map((m) => ({
+				id: m.documentModel.global.id,
+				version: m.version ?? 1
+			}))
+		},
+		construct: {
+			namespace: args.namespace,
+			relationalNamespace: args.relationalNamespace,
+			cdnUrl: args.cdnUrl,
+			packageSpecs: args.packageSpecs,
+			studioMode: args.studioMode
+		},
+		packages: args.packageSpecs
+	}, args.onReload, documentModelRegistry);
+	const busProxy = createReactorEventBusProxy(router);
+	const syncManagerProxy = new SyncManagerProxy(router, busProxy);
+	const modelResolver = new DocumentModelResolver(documentModelRegistry, args.documentModelLoader);
+	busProxy.subscribe(ReactorEventTypes.MODEL_LOADED, (_type, event) => {
+		const { documentType } = event;
+		modelResolver.ensureModelLoaded(documentType).catch((error) => {
+			console.error(`Failed to load model "${documentType}" into tab registry`, error);
+		});
+	});
+	setPGliteDB({
+		db: createRelationalPgliteProxy(router),
+		isLoading: false,
+		error: null
+	});
+	postReactorIdentity(router, toReactorIdentity(args.renown.user));
+	args.renown.on("user", (user) => postReactorIdentity(router, toReactorIdentity(user)));
+	const reactorClientModule = {
+		kind: "worker",
+		client: clientProxy,
+		adminClient: createWorkerAdminClient(router),
+		inspector: createInspectorProxy(router),
+		reactorModule: {
+			documentModelRegistry,
+			syncModule: { syncManager: syncManagerProxy },
+			eventBus: busProxy
+		}
+	};
+	let pingCounter = 0;
+	let missedPings = 0;
+	const pingDeadlines = /* @__PURE__ */ new Map();
+	router.on("pong", (msg) => {
+		const timer = pingDeadlines.get(msg.id);
+		if (timer === void 0) return;
+		clearTimeout(timer);
+		pingDeadlines.delete(msg.id);
+		missedPings = 0;
+		setWorkerConnectionStatus("connected");
+	});
+	const pingInterval = setInterval(() => {
+		const id = `ping${++pingCounter}`;
+		const timer = setTimeout(() => {
+			pingDeadlines.delete(id);
+			missedPings += 1;
+			if (missedPings >= MAX_MISSED_PINGS) setWorkerConnectionStatus("lost");
+		}, PING_DEADLINE_MS);
+		pingDeadlines.set(id, timer);
+		router.post({
+			k: "ping",
+			id
+		});
+	}, PING_INTERVAL_MS);
+	const dispose = () => {
+		clearInterval(pingInterval);
+		for (const timer of pingDeadlines.values()) clearTimeout(timer);
+		pingDeadlines.clear();
+	};
+	return {
+		reactorClientModule,
+		syncManagerProxy,
+		dispose
+	};
+}
+//#endregion
+//#region src/utils/reactor-worker-flag.ts
+const REACTOR_WORKER_QUERY_KEY = "reactorWorker";
+const REACTOR_WORKER_STORAGE_KEY = "ph:reactorWorker";
+function resolveReactorWorkerEnabled(input) {
+	const fromQuery = parseFlag(input.queryParam);
+	if (fromQuery !== void 0) return fromQuery;
+	const fromStore = parseFlag(input.storedValue);
+	if (fromStore !== void 0) return fromStore;
+	return input.configFlag;
+}
+function isReactorWorkerEnabled() {
+	const configFlag = getRuntimeConfig().connect.instance?.reactorWorker ?? false;
+	if (typeof window === "undefined") return configFlag;
+	const queryParam = new URLSearchParams(window.location.search).get(REACTOR_WORKER_QUERY_KEY);
+	const enabled = resolveReactorWorkerEnabled({
+		configFlag,
+		queryParam,
+		storedValue: window.localStorage.getItem(REACTOR_WORKER_STORAGE_KEY)
+	});
+	if (parseFlag(queryParam) !== void 0) window.localStorage.setItem(REACTOR_WORKER_STORAGE_KEY, enabled ? "true" : "false");
+	return enabled;
+}
+function parseFlag(value) {
+	if (value === null || value === void 0) return;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true" || normalized === "1") return true;
+	if (normalized === "false" || normalized === "0") return false;
+}
+//#endregion
 //#region src/store/processor-host-module.ts
 var NullAttachmentService = class {
 	reserve() {
@@ -910,7 +1100,12 @@ function subscribeToPackagesChannel(packageManager) {
 	source.addEventListener("error", () => {});
 }
 async function clearReactorStorage() {
-	await window.ph?.reactorClientModule?.pg?.close();
+	const module = window.ph?.reactorClientModule;
+	if (module?.kind === "worker") {
+		await module.adminClient.clearStorage();
+		return;
+	}
+	if (module?.kind === "browser") await module.reactorModule?.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);
@@ -934,7 +1129,7 @@ async function createReactor(localPackage) {
 	const runtimeConfig = getRuntimeConfig();
 	const packageManager = new BrowserPackageManager(phGlobalConfig.routerBasename ?? "", runtimeConfig.packageRegistryUrl ?? null);
 	setVetraPackageManager(packageManager);
-	await packageManager.init(localPackage, runtimeConfig.localPackage?.version);
+	await packageManager.init(localPackage, runtimeConfig.localPackage?.version, phGlobalConfig.studioMode);
 	try {
 		const { default: registerBundledPackages } = await import("ph-bundled-packages-virtual");
 		registerBundledPackages(packageManager);
@@ -951,7 +1146,44 @@ async function createReactor(localPackage) {
 		storageKey: phGlobalConfig.routerBasename ?? ""
 	}) : new NoRegistryDiscoveryService(packageManager);
 	setPackageDiscoveryService(discoveryService);
-	const reactorClientModule = await createBrowserReactor(documentModelModules, upgradeManifests, renown, discoveryService);
+	let reactorClientModule;
+	if (isReactorWorkerEnabled()) {
+		const packageSpecs = packageManager.getRegistryPackages().map((p) => p.version ? `${p.name}@${p.version}` : p.name);
+		const registryClient = new RegistryClient(packageManager.cdnUrl ?? "");
+		const workerClient = createWorkerReactorClientModule({
+			namespace: REACTOR_INSTANCE_NAMESPACE,
+			relationalNamespace: RELATIONAL_PGLITE_NAME,
+			cdnUrl: packageManager.cdnUrl ?? "",
+			packageSpecs,
+			studioMode: phGlobalConfig.studioMode,
+			documentModelModules,
+			upgradeManifests,
+			documentModelLoader: { async load(documentType) {
+				const names = packageManager.cdnUrl ? await registryClient.getPackagesByDocumentType(documentType) : [];
+				for (const name of names) {
+					const result = await packageManager.addPackage(name);
+					if (result.type === "error") throw new Error(`Failed to install package "${name}" for document model: ${documentType}`, { cause: result.error });
+				}
+				const module = packageManager.packages.flatMap((p) => p.documentModels).find((m) => m.documentModel.global.id === documentType);
+				if (!module) throw new Error(names.length > 0 ? `Installed [${names.join(", ")}] but document model not available: ${documentType}` : `No package found for document model: ${documentType} (cdnUrl: ${packageManager.cdnUrl ?? "none"})`);
+				return module;
+			} },
+			renown,
+			onReload: (reason, workerGen) => {
+				logger.warn("Reactor worker requested reload: @reason", reason);
+				if (workerGen) bumpWorkerGen(REACTOR_INSTANCE_NAMESPACE, workerGen);
+				window.location.reload();
+			}
+		});
+		reactorClientModule = workerClient.reactorClientModule;
+		try {
+			await workerClient.syncManagerProxy.startup();
+		} catch (error) {
+			window.ph.loading = false;
+			logger.error("Reactor worker failed to start: @error", error);
+			throw error;
+		}
+	} else reactorClientModule = await createBrowserReactor(documentModelModules, upgradeManifests, renown, discoveryService);
 	const drives = await getDrives(reactorClientModule.client);
 	await login(getDidFromUrl(), renown);
 	const documentCache = new DocumentCache(reactorClientModule.client);
@@ -1011,8 +1243,10 @@ async function createReactor(localPackage) {
 	});
 	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 reactorModule = reactorClientModule.kind === "browser" ? reactorClientModule.reactorModule : void 0;
+	if (packagesWithProcessorFactories.length > 0 && !reactorModule) for (const pkg of packagesWithProcessorFactories) logger.warn("Skipping processor factory @name: processors are not supported on the worker reactor path yet", pkg.manifest.name);
+	else if (packagesWithProcessorFactories.length > 0 && reactorModule) {
+		const readModels = reactorModule.readModelCoordinator.readModels;
 		const processorHostModule = await createProcessorHostModule(reactorClientModule.client, readModels, window.ph?.attachmentService);
 		if (processorHostModule !== void 0) await Promise.all(packagesWithProcessorFactories.map(async (pkg) => {
 			const { manifest, processorFactory } = pkg;
@@ -1024,7 +1258,7 @@ async function createReactor(localPackage) {
 			try {
 				const factory = await processorFactory?.(processorHostModule);
 				if (!factory) return;
-				await reactorClientModule.reactorModule?.processorManager.registerFactory(id, factory);
+				await reactorModule.processorManager.registerFactory(id, factory);
 			} catch (error) {
 				logger.error(`Error registering processor: @label`, label);
 				logger.error("@error", error);
@@ -1044,5 +1278,5 @@ function getDriveUrl() {
 //#endregion
 export { createReactor as n, clearReactorStorage as t };
 
-//# sourceMappingURL=reactor-DWY9_ifj.js.map
-//# debugId=e4ac466f-3b1a-588d-9c21-2041c2992b7e
+//# sourceMappingURL=reactor-Bo6Lut7c.js.map
+//# debugId=a1393f51-b593-56ea-8200-57f565bcd3ca