@powerhousedao/connect 6.2.2-dev.9 → 6.2.2

package/dist/{reactor-ynguOpe7.js → reactor-DBCWJdBA.js}

@@ -1,24 +1,104 @@
 
-!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]="e6d789cd-51cc-5a5a-b3c5-95dea7e29db0")}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]="139fd9bf-816c-554d-8fe6-a26d88299956")}catch(e){}}();
 import { n as getRuntimeConfig } from "./runtime-config-DL3QjcfM.js";
 import { a as resolvePgMajorForRuntime, r as loadPGliteModule } from "./pglite-major-B39aOEiE.js";
-import { r as getVersion, t as getGitSha } from "./build-info-AUWI7jOw.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 { i as getVersion, n as getGitSha } from "./build-info-D8VekPcJ.js";
+import { n as buildPHGlobalConfig, o as phGlobalConfig } from "./connect.config-DaHDEUrw.js";
+import { t as refreshPwaManifestLink } from "./pwa-manifest-link-DIgOSo2Q.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-3w4liC1X.js";
+import { r as toast } from "./toast-BXIGd4Eb.js";
+import { PWA_IDB_KEY, PWA_IDB_NAME, PWA_IDB_STORE, PWA_IDB_VERSION, mergePwaConfig, withInferredCategory } from "@powerhousedao/shared/connect";
 import { createRelationalDb } from "@powerhousedao/shared/processors";
-import { DocumentModelRegistry, DocumentModelResolver, ReactorEventTypes } from "@powerhousedao/reactor";
+import { DocumentModelRegistry, DocumentModelResolver, ReactorEventTypes, createReactorHostModuleBase } 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 { BrowserLocalStorage, ChannelScheme as ChannelScheme$1, DRIVE_DOCUMENT_TYPES, DocumentCache, DocumentChangeType, ReactorBuilder as ReactorBuilder$1, ReactorClientBuilder as ReactorClientBuilder$1, RegistryClient, addDrive, 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 { PwaConfigSchema } from "@powerhousedao/shared/document-model";
+import { createAttachmentClient, createRemoteAttachmentService, createXhrUploadTransport } 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 { toCdnUrl } from "@powerhousedao/shared/registry/urls";
 import vetraPkg from "@powerhousedao/vetra/package.json" with { type: "json" };
+//#region src/utils/pwa-idb.ts
+function openPwaIdb() {
+	return new Promise((resolve, reject) => {
+		const req = indexedDB.open(PWA_IDB_NAME, PWA_IDB_VERSION);
+		req.onupgradeneeded = () => {
+			if (!req.result.objectStoreNames.contains(PWA_IDB_STORE)) req.result.createObjectStore(PWA_IDB_STORE);
+		};
+		req.onerror = () => reject(req.error ?? /* @__PURE__ */ new Error("ph-pwa open failed"));
+		req.onblocked = () => reject(/* @__PURE__ */ new Error("ph-pwa open blocked"));
+		req.onsuccess = () => resolve(req.result);
+	});
+}
+/** Write (replace) the single merged fragment record. Best-effort: a failure to
+* mirror the manifest must never break package installation, so callers ignore
+* rejections. No-op when IndexedDB is unavailable (SSR/tests). */
+async function writeMergedPwaFragment(fragment) {
+	if (typeof indexedDB === "undefined") return;
+	const db = await openPwaIdb();
+	try {
+		await new Promise((resolve, reject) => {
+			const tx = db.transaction(PWA_IDB_STORE, "readwrite");
+			tx.oncomplete = () => resolve();
+			tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("PWA fragment write failed"));
+			tx.objectStore(PWA_IDB_STORE).put({
+				version: 1,
+				fragment,
+				updatedAt: Date.now()
+			}, PWA_IDB_KEY);
+		});
+	} finally {
+		db.close();
+	}
+}
+/** Resolve `src` against the package `baseUrl`, absolute srcs passing through.
+* `baseUrl` may itself be relative (e.g. a same-origin-proxied registry, or the
+* dev `/node_modules/…` path), so it is first made absolute against the app
+* origin — `new URL(src, relativeBase)` would otherwise throw and silently
+* leave the src unresolved. A malformed src is left untouched. */
+function toAbsoluteAssetUrl(src, baseUrl) {
+	try {
+		const origin = typeof location !== "undefined" ? location.href : "http://localhost/";
+		return new URL(src, new URL(baseUrl, origin)).toString();
+	} catch {
+		return src;
+	}
+}
+function resolveIconSrc(icon, baseUrl) {
+	return {
+		...icon,
+		src: toAbsoluteAssetUrl(icon.src, baseUrl)
+	};
+}
+/**
+* Rewrite a package fragment's relative asset srcs (manifest icons and
+* file-handler icons) to absolute URLs against the package's base — a runtime
+* package's assets live on the registry CDN, not the app origin, so the served
+* manifest must point there. `baseUrl` null (a local/bundled package whose
+* assets are app-origin-relative) leaves srcs untouched.
+*/
+function resolveFragmentAssetUrls(config, baseUrl) {
+	if (!baseUrl || !config.manifest) return config;
+	const m = config.manifest;
+	const resolveIcons = (icons) => icons?.map((icon) => resolveIconSrc(icon, baseUrl));
+	return {
+		...config,
+		manifest: {
+			...m,
+			icons: resolveIcons(m.icons),
+			file_handlers: m.file_handlers?.map((handler) => ({
+				...handler,
+				icons: resolveIcons(handler.icons)
+			}))
+		}
+	};
+}
+//#endregion
 //#region src/pglite.db.ts
 async function createMainThreadPGlite(major, dbName) {
 	const { PGlite } = await loadPGliteModule(major);
@@ -73,7 +153,7 @@ async function getDb() {
 * Creates a Reactor that plugs into legacy storage but syncs through the new
 * Reactor GQL API.
 */
-async function createBrowserReactor(documentModelModules, upgradeManifests, renown, documentModelLoader) {
+async function createBrowserReactor(documentModelModules, upgradeManifests, renown, featureFlags, documentModelLoader) {
 	const signerConfig = {
 		signer: renown.signer,
 		verifier: createSignatureVerifier()
@@ -84,7 +164,7 @@ async function createBrowserReactor(documentModelModules, upgradeManifests, reno
 	};
 	const pg = await getReactorPGlite();
 	const logger = new ConsoleLogger(["reactor-client"]);
-	const builder = new ReactorClientBuilder$1().withLogger(logger).withSigner(signerConfig).withReactorBuilder(new ReactorBuilder$1().withDocumentModelSources(documentModelModules).withUpgradeManifests(upgradeManifests).withChannelScheme(ChannelScheme$1.CONNECT).withJwtHandler(jwtHandler).withKysely(new Kysely({ dialect: new PGliteDialect(pg) })));
+	const builder = new ReactorClientBuilder$1().withLogger(logger).withSigner(signerConfig).withReactorBuilder(new ReactorBuilder$1().withDocumentModelSources(documentModelModules).withUpgradeManifests(upgradeManifests).withChannelScheme(ChannelScheme$1.CONNECT).withExecutorConfig({ featureFlags }).withJwtHandler(jwtHandler).withKysely(new Kysely({ dialect: new PGliteDialect(pg) })));
 	if (documentModelLoader) builder.withDocumentModelLoader(documentModelLoader);
 	const module = await builder.buildModule();
 	return {
@@ -103,40 +183,74 @@ function getDefaultDrives(runtimeConfig) {
 * Add default drives for the new reactor via sync manager.
 *
 * Drives register concurrently so a slow or unreachable drive can't delay the
-* others — in particular the one the URL slug resolves to. Retries with linear
-* backoff to handle the common race where Connect's dev server is ready before
-* the switchboard has finished binding its port.
+* others — in particular the one the URL slug resolves to. Remote drives
+* retry with linear backoff to handle the common race where Connect's dev
+* server is ready before the switchboard has finished binding its port.
 *
-* @param drives - Array of drive objects with url, optional name and icon
+* Each entry is either a remote drive (a URL registered with the sync
+* manager, waited on for initial backfill) or a local drive (created once in
+* this browser's local reactor; its fixed id makes later boots skip it).
+*
+* @param drives - Array of default-drive entries
 */
 async function addDefaultDrivesForNewReactor(drives) {
+	await Promise.all(drives.map((drive) => "url" in drive ? addRemoteDefaultDrive(drive) : addLocalDefaultDrive(drive)));
+}
+async function addRemoteDefaultDrive(drive) {
 	const MAX_ATTEMPTS = 3;
 	const BACKOFF_MS = 2e3;
-	await Promise.all(drives.map(async (drive) => {
-		let driveId;
-		for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) try {
-			driveId = await addRemoteDrive(drive.url);
-			break;
-		} catch (error) {
-			if (isDriveAuthError(error)) break;
-			if (attempt === MAX_ATTEMPTS) console.error(`Failed to add default drive ${drive.url} after ${MAX_ATTEMPTS} attempts:`, error);
-			else {
-				const delay = BACKOFF_MS * attempt;
-				console.warn(`Default drive ${drive.url} not reachable (attempt ${attempt}/${MAX_ATTEMPTS}), retrying in ${delay}ms...`);
-				await new Promise((resolve) => setTimeout(resolve, delay));
-			}
+	let driveId;
+	for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) try {
+		driveId = await addRemoteDrive(drive.url);
+		break;
+	} catch (error) {
+		if (isDriveAuthError(error)) break;
+		if (attempt === MAX_ATTEMPTS) console.error(`Failed to add default drive ${drive.url} after ${MAX_ATTEMPTS} attempts:`, error);
+		else {
+			const delay = BACKOFF_MS * attempt;
+			console.warn(`Default drive ${drive.url} not reachable (attempt ${attempt}/${MAX_ATTEMPTS}), retrying in ${delay}ms...`);
+			await new Promise((resolve) => setTimeout(resolve, delay));
 		}
-		if (driveId && (drive.name || drive.icon)) try {
-			const reactorClient = window.ph?.reactorClient;
-			if (reactorClient) await waitForDocumentReady(reactorClient, driveId, { timeoutMs: 15e3 });
-			await setDriveMetadata(driveId, {
-				name: drive.name,
-				icon: drive.icon
-			});
-		} catch (error) {
-			console.warn(`Default drive ${drive.url} was added but metadata update failed:`, error);
+	}
+	if (driveId && (drive.name || drive.icon)) try {
+		const reactorClient = window.ph?.reactorClientModule?.client;
+		if (reactorClient) await waitForDocumentReady(reactorClient, driveId, { timeoutMs: 15e3 });
+		await setDriveMetadata(driveId, {
+			name: drive.name,
+			icon: drive.icon
+		});
+	} catch (error) {
+		console.warn(`Default drive ${drive.url} was added but metadata update failed:`, error);
+	}
+}
+/**
+* Create a configured local default drive in this browser's local reactor.
+* The drive is only created when the configured id is not already taken, so
+* repeated boots are idempotent and a drive the user deleted stays deleted.
+* Name and icon are written straight into the created document's global state
+* (no setDriveMetadata round-trip), and `app` maps to the drive's preferred
+* editor.
+*/
+async function addLocalDefaultDrive(drive) {
+	if (!drive.id) {
+		console.error("Ignoring local default drive with no id:", JSON.stringify(drive));
+		return;
+	}
+	try {
+		const reactorClient = window.ph?.reactorClientModule?.client;
+		if (reactorClient) {
+			if (await reactorClient.isDocumentIdTaken(drive.id)) return;
 		}
-	}));
+		await addDrive({
+			id: drive.id,
+			global: {
+				name: drive.name ?? "",
+				icon: drive.icon ?? null
+			}
+		}, drive.app);
+	} catch (error) {
+		console.error(`Failed to create local default drive ${drive.id}:`, error);
+	}
 }
 //#endregion
 //#region src/feature-flags.ts
@@ -601,14 +715,14 @@ var BrowserPackageManager = class {
 	#cdnUrl;
 	#localPackageVersion;
 	#localPackageNames = new Set([LOCAL_PACKAGE_NAME]);
+	#pwaSyncTimer;
+	/** Serialized last-mirrored PWA fragment; lets a sync skip the IndexedDB
+	* write + manifest re-attach when nothing PWA-relevant changed. */
+	#lastSyncedFragmentJson;
 	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`;
+		this.#cdnUrl = registryUrl !== null ? toCdnUrl(registryUrl) : null;
 	}
 	async init(localPackage, localPackageVersion, studioMode) {
 		this.addLocalPackage(common.manifest.name, common, commonPkg.version);
@@ -829,6 +943,53 @@ var BrowserPackageManager = class {
 		this.#subscribers.forEach((handler) => {
 			handler({ packages });
 		});
+		this.#schedulePwaSync();
+	}
+	/**
+	* Debounced mirror of every loaded package's PWA fragment into IndexedDB, so
+	* the service worker can serve a web-app manifest that reflects packages
+	* installed AT RUNTIME (a SW can't read localStorage, where the package list
+	* lives). Debounced because `init()` rehydrates many packages in a burst;
+	* coalescing collapses that into a single write.
+	*/
+	#schedulePwaSync() {
+		if (typeof indexedDB === "undefined") return;
+		clearTimeout(this.#pwaSyncTimer);
+		this.#pwaSyncTimer = setTimeout(() => {
+			this.#syncPwaFragments();
+		}, 50);
+	}
+	async #syncPwaFragments() {
+		const contributions = [];
+		for (const [name, loadedPackage] of this.#packages) {
+			const manifest = loadedPackage.manifest;
+			let config = {};
+			if (manifest.pwa) {
+				const parsed = PwaConfigSchema.safeParse(manifest.pwa);
+				if (parsed.success) {
+					const importUrl = this.#storage.get(name)?.importUrl ?? null;
+					const baseUrl = importUrl ? importUrl.replace(/browser\/index\.js$/, "") : null;
+					config = resolveFragmentAssetUrls(parsed.data, baseUrl);
+				} else console.warn(`[Connect][PWA] "${name}" ships an invalid pwa fragment; skipped.`, parsed.error);
+			}
+			config = withInferredCategory(config, manifest.category);
+			if (Object.keys(config).length === 0) continue;
+			contributions.push({
+				source: name,
+				config
+			});
+		}
+		const merged = mergePwaConfig(contributions);
+		const mergedJson = JSON.stringify(merged);
+		if (mergedJson === this.#lastSyncedFragmentJson) return;
+		try {
+			await writeMergedPwaFragment(merged);
+		} catch (error) {
+			console.debug("[Connect][PWA] fragment mirror to IndexedDB failed:", error);
+			return;
+		}
+		this.#lastSyncedFragmentJson = mergedJson;
+		refreshPwaManifestLink();
 	}
 };
 //#endregion
@@ -855,6 +1016,10 @@ function bumpWorkerGen(namespace, gen) {
 const PING_INTERVAL_MS = 2e3;
 const PING_DEADLINE_MS = 3e3;
 const MAX_MISSED_PINGS = 2;
+/** Sorted so the same set always produces the same fingerprint. */
+function enabledFlagList(flags) {
+	return Object.entries(flags).filter(([, enabled]) => enabled).map(([name]) => name).sort().join(",");
+}
 function toReactorIdentity(user) {
 	if (!user) return null;
 	return {
@@ -890,14 +1055,17 @@ function createWorkerReactorClientModule(args) {
 			models: args.documentModelModules.map((m) => ({
 				id: m.documentModel.global.id,
 				version: m.version ?? 1
-			}))
+			})),
+			featureFlags: enabledFlagList(args.featureFlags)
 		},
 		construct: {
 			namespace: args.namespace,
 			relationalNamespace: args.relationalNamespace,
 			cdnUrl: args.cdnUrl,
 			packageSpecs: args.packageSpecs,
-			studioMode: args.studioMode
+			studioMode: args.studioMode,
+			renownChainId: args.renownChainId,
+			featureFlags: args.featureFlags
 		},
 		packages: args.packageSpecs
 	}, args.onReload, documentModelRegistry);
@@ -1004,29 +1172,23 @@ var NullAttachmentService = class {
 	get() {
 		return Promise.reject(/* @__PURE__ */ new Error("NullAttachmentService: no attachment service configured"));
 	}
+	getDownloadTarget() {
+		return Promise.reject(/* @__PURE__ */ new Error("NullAttachmentService: no attachment service configured"));
+	}
 };
 async function createProcessorHostModule(reactorClient, readModels, attachmentService) {
 	try {
 		const { pgLite, relationalDb } = await getDb();
 		const { store: analyticsStore } = await createAnalyticsStore({ pgLite });
 		return {
-			relationalDb,
-			analyticsStore,
-			processorApp: "connect",
-			client: reactorClient,
-			attachments: createAttachmentClient(attachmentService ?? new NullAttachmentService()),
-			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;
-			}
+			...createReactorHostModuleBase({
+				client: reactorClient,
+				readModels,
+				relationalDb,
+				analyticsStore,
+				processorApp: "connect"
+			}),
+			attachments: createAttachmentClient(attachmentService ?? new NullAttachmentService())
 		};
 	} catch (error) {
 		console.error(`Failed to initialize processor host module:`);
@@ -1120,11 +1282,16 @@ async function createReactor(localPackage) {
 	setPHToast(toast);
 	const features = await initFeatureFlags();
 	logger.info("Features: @features", JSON.stringify(Object.fromEntries(features), null, 2));
+	const renownChainId = getRuntimeConfig().connect.renown?.chainId;
 	const keyPairStorage = await BrowserKeyStorage.create();
-	const renownCrypto = await new RenownCryptoBuilder().withKeyPairStorage(keyPairStorage).build();
+	const cryptoBuilder = new RenownCryptoBuilder().withKeyPairStorage(keyPairStorage);
+	if (renownChainId !== void 0) cryptoBuilder.withChainId(renownChainId);
+	const renownCrypto = await cryptoBuilder.build();
 	const renown = await new RenownBuilder("connect", {
 		basename: getRuntimeConfig().connect.renown?.namespace ?? phGlobalConfig.routerBasename,
-		baseUrl: phGlobalConfig.renownUrl
+		baseUrl: phGlobalConfig.renownUrl,
+		switchboardUrl: phGlobalConfig.switchboardUrl,
+		chainId: renownChainId
 	}).withCrypto(renownCrypto).build();
 	const runtimeConfig = getRuntimeConfig();
 	const packageManager = new BrowserPackageManager(phGlobalConfig.routerBasename ?? "", runtimeConfig.packageRegistryUrl ?? null);
@@ -1146,6 +1313,9 @@ async function createReactor(localPackage) {
 		storageKey: phGlobalConfig.routerBasename ?? ""
 	}) : new NoRegistryDiscoveryService(packageManager);
 	setPackageDiscoveryService(discoveryService);
+	const reactorFeatureFlags = runtimeConfig.connect?.reactor?.featureFlags ?? {};
+	const enabledReactorFlags = Object.entries(reactorFeatureFlags).filter(([, enabled]) => enabled).map(([name]) => name);
+	if (enabledReactorFlags.length > 0) logger.info(`Reactor feature flags: ${enabledReactorFlags.join(", ")}`);
 	let reactorClientModule;
 	if (isReactorWorkerEnabled()) {
 		const packageSpecs = packageManager.getRegistryPackages().map((p) => p.version ? `${p.name}@${p.version}` : p.name);
@@ -1156,6 +1326,8 @@ async function createReactor(localPackage) {
 			cdnUrl: packageManager.cdnUrl ?? "",
 			packageSpecs,
 			studioMode: phGlobalConfig.studioMode,
+			renownChainId,
+			featureFlags: reactorFeatureFlags,
 			documentModelModules,
 			upgradeManifests,
 			documentModelLoader: { async load(documentType) {
@@ -1183,7 +1355,7 @@ async function createReactor(localPackage) {
 			logger.error("Reactor worker failed to start: @error", error);
 			throw error;
 		}
-	} else reactorClientModule = await createBrowserReactor(documentModelModules, upgradeManifests, renown, discoveryService);
+	} else reactorClientModule = await createBrowserReactor(documentModelModules, upgradeManifests, renown, reactorFeatureFlags, discoveryService);
 	const drives = await getDrives(reactorClientModule.client);
 	await login(getDidFromUrl(), renown);
 	const documentCache = new DocumentCache(reactorClientModule.client);
@@ -1206,7 +1378,8 @@ async function createReactor(localPackage) {
 			};
 			setAttachmentService(createRemoteAttachmentService({
 				remoteUrl: switchboardOrigin,
-				jwtHandler: attachmentJwtHandler
+				jwtHandler: attachmentJwtHandler,
+				uploadTransport: createXhrUploadTransport()
 			}));
 		}
 	}
@@ -1278,5 +1451,5 @@ function getDriveUrl() {
 //#endregion
 export { createReactor as n, clearReactorStorage as t };
 
-//# sourceMappingURL=reactor-ynguOpe7.js.map
-//# debugId=e6d789cd-51cc-5a5a-b3c5-95dea7e29db0
+//# sourceMappingURL=reactor-DBCWJdBA.js.map
+//# debugId=139fd9bf-816c-554d-8fe6-a26d88299956