@baseplate-dev/plugin-auth 0.6.17 → 0.6.19

package/dist/web/assets/virtual_mf-REMOTE_ENTRY_ID___mfe_internal__plugin-auth__remoteEntry_js-BZBRyml2.js

@@ -0,0 +1,747 @@
+import { t as __vitePreload } from "./vite-preload-helper-ARKYL6bp.js";
+import { r as helpers, t as init$1 } from "./dist-DQd1TAJX.js";
+({ ...helpers.global });
+var share = helpers.share;
+helpers.utils;
+//#endregion
+//#region virtual:mf-REMOTE_ENTRY_ID:__mfe_internal__plugin-auth__remoteEntry_js
+if (typeof __VUE_HMR_RUNTIME__ === "undefined") globalThis.__VUE_HMR_RUNTIME__ = {
+	createRecord() {},
+	rerender() {},
+	reload() {}
+};
+var __mfResolveGlobalKey = "__mf_init__virtual:mf:__mfe_internal__plugin_mf_2_auth__mf_owner__1__mf_v__runtimeInit__mf_v__.js__";
+var __mfResolveState = globalThis[__mfResolveGlobalKey];
+if (!__mfResolveState) {
+	let initResolve, initReject;
+	const initPromise = new Promise((re, rj) => {
+		initResolve = re;
+		initReject = rj;
+	});
+	__mfResolveState = globalThis[__mfResolveGlobalKey] = {
+		initPromise,
+		initResolve,
+		initReject
+	};
+}
+var initResolve = __mfResolveState.initResolve;
+var __mfCacheGlobalKey = "__mf_module_cache__";
+globalThis[__mfCacheGlobalKey] ||= {
+	share: {},
+	remote: {}
+};
+globalThis[__mfCacheGlobalKey].share ||= {};
+globalThis[__mfCacheGlobalKey].remote ||= {};
+var __mfModuleCache = globalThis[__mfCacheGlobalKey];
+for (const __mfShareKey of Object.keys(__mfModuleCache.share)) if (__mfShareKey.startsWith("default:")) {
+	const __mfLegacyShareKey = __mfShareKey.slice(8);
+	if (__mfModuleCache.share[__mfLegacyShareKey] === void 0) __mfModuleCache.share[__mfLegacyShareKey] = __mfModuleCache.share[__mfShareKey];
+} else if (!__mfShareKey.includes(":")) {
+	const __mfDefaultShareKey = "default:" + __mfShareKey;
+	if (__mfModuleCache.share[__mfDefaultShareKey] === void 0) __mfModuleCache.share[__mfDefaultShareKey] = __mfModuleCache.share[__mfShareKey];
+}
+var initTokens = {};
+var shareScopeNames = Array.isArray("default") ? "default" : ["default"];
+var shareScopeName = "default";
+var mfName = "plugin-auth";
+var localSharedImportMapPromise;
+var exposesMapPromise;
+async function retrySharedInit(fn) {
+	for (let attempt = 0;; attempt++) try {
+		return await fn();
+	} catch (e) {
+		throw e;
+	}
+}
+var __mfOriginalProviderKey = Symbol("mf.originalSharedProvider");
+var __mfResolveShareHook = { emit: (params) => params };
+var __mfCreateProviderSelectionVersions = (versions, strategy) => {
+	if (strategy !== "version-first") return versions;
+	const selectionVersions = {};
+	for (const [version, provider] of Object.entries(versions)) selectionVersions[version] = Object.assign({}, provider, { [__mfOriginalProviderKey]: provider });
+	return selectionVersions;
+};
+var __mfFindSharedProviderEntry = (versions, provider) => {
+	if (!provider) return void 0;
+	const entries = Object.entries(versions || {});
+	const registeredEntry = entries.find(([, candidate]) => candidate === provider);
+	if (registeredEntry) return {
+		version: registeredEntry[0],
+		provider,
+		registered: true
+	};
+	if (typeof provider.version === "string" && provider.version) return {
+		version: provider.version,
+		provider,
+		registered: false
+	};
+	const provenanceEntries = entries.filter(([, candidate]) => candidate === provider || Boolean(provider.from && candidate?.from === provider.from));
+	if (provenanceEntries.length !== 1) return void 0;
+	return {
+		version: provenanceEntries[0][0],
+		provider,
+		registered: false
+	};
+};
+var __mfSelectSharedProvider = (versions, pkg, share$1, strategy) => {
+	if (!versions || !share$1) return void 0;
+	const scopes = Array.isArray(share$1.scope) ? share$1.scope : [share$1.scope || "default"];
+	const selectionVersions = __mfCreateProviderSelectionVersions(versions, strategy);
+	const shareScopeMap = {};
+	for (const scope of scopes) shareScopeMap[scope || "default"] = { [pkg]: selectionVersions };
+	const selected = share.getRegisteredShare(shareScopeMap, pkg, {
+		...share$1,
+		scope: scopes,
+		strategy
+	}, __mfResolveShareHook)?.shared;
+	return selected?.[__mfOriginalProviderKey] || selected;
+};
+var __mfSelectExternalSharedProvider = (versions, pkg, localShare, strategy) => {
+	const isLocalProvider = (provider) => __mfMatchesSharedProvider(provider, localShare);
+	const candidates = Object.fromEntries(Object.entries(versions || {}).filter(([, provider]) => !isLocalProvider(provider)));
+	if (localShare?.version && localShare.shareConfig?.import !== false) {
+		if (!candidates[localShare.version]) candidates[localShare.version] = localShare;
+	}
+	const provider = __mfSelectSharedProvider(candidates, pkg, localShare, strategy);
+	return isLocalProvider(provider) ? void 0 : provider;
+};
+var __mfMatchesSharedProvider = (provider, expected) => provider === expected || Boolean(expected?.from && provider?.from === expected.from);
+var __mfGetScopeRootProvider = (instances, scopeRoot, shared, scopeName, pkg, version, provider, passedProvider, strategy) => {
+	if (strategy !== "version-first" || !passedProvider) return void 0;
+	const scopeRootProviders = scopeRoot?.options?.shared?.[pkg];
+	const configuredScopeRootProvider = Array.isArray(scopeRootProviders) ? scopeRootProviders.find((candidate) => candidate?.version === version) : void 0;
+	const scopeRootProvider = (passedProvider?.from === scopeRoot?.options?.name ? passedProvider : void 0) || (__mfMatchesSharedProvider(configuredScopeRootProvider, passedProvider) ? configuredScopeRootProvider : scopeRoot ? void 0 : passedProvider);
+	if (!scopeRootProvider) return void 0;
+	return instances.some((instance) => instance !== scopeRoot && instance?.options?.name === provider?.from && instance?.shareScopeMap?.[scopeName] === shared) ? scopeRootProvider : void 0;
+};
+var __mfResolveExternalSharedProvider = (instances, scopeRoot, shared, scopeName, pkg, providerEntry, selectedExternalProvider, passedProvider, strategy) => {
+	const scopeRootProvider = providerEntry.registered ? __mfGetScopeRootProvider(instances, scopeRoot, shared, scopeName, pkg, providerEntry.version, providerEntry.provider, passedProvider, strategy) : void 0;
+	const provider = scopeRootProvider || selectedExternalProvider;
+	if (!provider) return void 0;
+	if (providerEntry.registered && !__mfMatchesSharedProvider(provider, passedProvider)) return void 0;
+	return {
+		provider,
+		scopeRootProvider
+	};
+};
+async function getLocalSharedImportMap() {
+	if (!localSharedImportMapPromise) localSharedImportMapPromise = retrySharedInit(() => __vitePreload(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__plugin_mf_2_auth__mf_owner__1-DUupKqD4.js"), [], import.meta.url)).catch((e) => {
+		localSharedImportMapPromise = void 0;
+		throw e;
+	});
+	return localSharedImportMapPromise;
+}
+async function getExposesMap() {
+	if (!exposesMapPromise) exposesMapPromise = retrySharedInit(() => __vitePreload(() => import("./virtualExposes-C7fDiAmS.js"), [], import.meta.url)).then((mod) => mod.default ?? mod).catch((e) => {
+		exposesMapPromise = void 0;
+		throw e;
+	});
+	return exposesMapPromise;
+}
+async function init(shared = {}, initScope = []) {
+	const __mfGetSharedCacheDescriptor = (pkg, singleton, version, scope) => {
+		const scopeName = (Array.isArray(scope) ? scope[0] : scope) || "default";
+		const id = singleton || !version ? pkg : pkg + "@" + version;
+		const descriptor = { canonical: scopeName + ":" + id };
+		if (scopeName === "default") descriptor.aliases = [id];
+		return descriptor;
+	};
+	const __mfReadSharedCache = (cache, descriptor) => {
+		const value = cache[descriptor.canonical];
+		if (value !== void 0) return value;
+		const aliases = descriptor.aliases || [];
+		for (const alias of aliases) {
+			if (!Object.prototype.hasOwnProperty.call(cache, alias)) continue;
+			const aliasValue = cache[alias];
+			if (aliasValue !== void 0) {
+				cache[descriptor.canonical] = aliasValue;
+				return aliasValue;
+			}
+		}
+	};
+	const __mfSharedCacheListenersKey = Symbol.for("module-federation.shared-cache-listeners");
+	const __mfSharedCacheOwnersKey = Symbol.for("module-federation.shared-cache-owners");
+	const __mfGetSharedCacheOwners = (cache) => {
+		let owners = cache[__mfSharedCacheOwnersKey];
+		if (owners === void 0) {
+			owners = Object.create(null);
+			Object.defineProperty(cache, __mfSharedCacheOwnersKey, {
+				value: owners,
+				enumerable: false,
+				configurable: false,
+				writable: false
+			});
+		}
+		return owners;
+	};
+	const __mfReadSharedCacheOwner = (cache, descriptor) => cache[__mfSharedCacheOwnersKey]?.[descriptor.canonical];
+	const __mfWriteSharedCache = (cache, descriptor, value, owner) => {
+		cache[descriptor.canonical] = value;
+		const aliases = descriptor.aliases || [];
+		for (const alias of aliases) Object.defineProperty(cache, alias, {
+			value,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		const owners = cache[__mfSharedCacheOwnersKey];
+		if (owner === void 0) {
+			if (owners) delete owners[descriptor.canonical];
+		} else __mfGetSharedCacheOwners(cache)[descriptor.canonical] = owner;
+		const listeners = cache[__mfSharedCacheListenersKey]?.[descriptor.canonical];
+		if (listeners) for (const listener of listeners) listener(value);
+		return value;
+	};
+	const __mfTreeShakingSharedCacheKey = Symbol.for("module-federation.tree-shaking-shared-cache");
+	const __mfGetTreeShakingSharedCache = (cache) => {
+		let metadata = cache[__mfTreeShakingSharedCacheKey];
+		if (metadata === void 0) {
+			metadata = Object.create(null);
+			Object.defineProperty(cache, __mfTreeShakingSharedCacheKey, {
+				value: metadata,
+				enumerable: false,
+				configurable: false,
+				writable: false
+			});
+		}
+		return metadata;
+	};
+	const __mfWriteTreeShakingSharedCache = (cache, descriptor, providedExports, value) => {
+		if (!Array.isArray(providedExports)) return value;
+		const normalizedExports = [...new Set(providedExports)].sort();
+		const metadata = __mfGetTreeShakingSharedCache(cache);
+		const entries = metadata[descriptor.canonical] ||= [];
+		const existing = entries.find((entry) => entry.providedExports.length === normalizedExports.length && entry.providedExports.every((name, index) => name === normalizedExports[index]));
+		if (existing) existing.value = value;
+		else entries.push({
+			providedExports: normalizedExports,
+			value
+		});
+		return value;
+	};
+	const __mfTreeShakingSelectionCacheKey = Symbol.for("module-federation.tree-shaking-shared-selection-cache");
+	const __mfGetTreeShakingSelectionCache = (cache) => {
+		let selections = cache[__mfTreeShakingSelectionCacheKey];
+		if (selections === void 0) {
+			selections = Object.create(null);
+			Object.defineProperty(cache, __mfTreeShakingSelectionCacheKey, {
+				value: selections,
+				enumerable: false,
+				configurable: false,
+				writable: false
+			});
+		}
+		return selections;
+	};
+	const __mfReadTreeShakingSharedSelection = (cache, descriptor, consumer) => {
+		const fullModule = __mfReadSharedCache(cache, descriptor);
+		if (fullModule !== void 0) return fullModule;
+		return cache[__mfTreeShakingSelectionCacheKey]?.[descriptor.canonical]?.[consumer];
+	};
+	const __mfWriteTreeShakingSharedSelection = (cache, descriptor, consumer, value) => {
+		const selections = __mfGetTreeShakingSelectionCache(cache);
+		const byConsumer = selections[descriptor.canonical] ||= Object.create(null);
+		byConsumer[consumer] = value;
+		return value;
+	};
+	const federationInstances = globalThis.__FEDERATION__?.__INSTANCES__ || [];
+	const initRootName = initScope.find((token) => token?.from)?.from;
+	const scopeRoot = federationInstances.find((instance) => instance?.options?.name === initRootName && instance?.shareScopeMap?.["default"] === shared) || federationInstances.find((instance) => instance?.options?.name !== mfName && instance?.shareScopeMap?.["default"] === shared);
+	const initialShared = Object.create(null);
+	for (const [pkg, versions] of Object.entries(shared)) {
+		const initialVersions = initialShared[pkg] = Object.create(null);
+		for (const [version, provider] of Object.entries(versions)) initialVersions[version] = Object.assign({}, provider);
+	}
+	const { usedShared, usedRemotes } = await getLocalSharedImportMap();
+	var initToken = initTokens[shareScopeName];
+	if (!initToken) initToken = initTokens[shareScopeName] = { from: mfName };
+	if (initScope.indexOf(initToken) >= 0) return;
+	initScope.push(initToken);
+	const __mfNormalizeRuntimeShare = (mod) => {
+		let current = mod;
+		for (let i = 0; i < 5; i++) {
+			const defaultExport = current?.default;
+			if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+			const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+			if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+			current = defaultExport;
+		}
+		return current;
+	};
+	const __browserPlugins = [];
+	const __ssrPlugins = typeof globalThis.window === "undefined" ? await Promise.all([]) : [];
+	const __mfRuntimeShareLoadIdKey = "__mf_vite_runtime_share_load_id__";
+	let __mfRuntimeShareLoadId = 0;
+	const __mfRuntimeShareSelections = /* @__PURE__ */ new Map();
+	const __mfRuntimeShareLifecycles = /* @__PURE__ */ new Map();
+	const initRes = init$1({
+		name: mfName,
+		remotes: usedRemotes,
+		shared: usedShared,
+		plugins: [
+			__mfSharePinLifecyclePlugin(),
+			...__browserPlugins,
+			...__ssrPlugins
+		],
+		shareStrategy: "version-first"
+	});
+	initRes.initShareScopeMap("default", shared);
+	function __mfSharePinLifecyclePlugin() {
+		return {
+			name: "vite-share-pin-lifecycle-plugin",
+			resolveShare(args) {
+				const loadId = args.shareInfo?.[__mfRuntimeShareLoadIdKey];
+				const lifecycle = loadId === void 0 ? void 0 : __mfRuntimeShareLifecycles.get(loadId);
+				if (!lifecycle) return args;
+				const defaultResolver = args.resolver;
+				args.resolver = (...resolverArgs) => {
+					lifecycle.pinned.reapply();
+					return defaultResolver(...resolverArgs);
+				};
+				lifecycle.pinned.reveal();
+				return args;
+			}
+		};
+	}
+	const runtimeResolveShareHook = initRes.sharedHandler.hooks.lifecycle.resolveShare;
+	const __mfRuntimeProviderOrigins = /* @__PURE__ */ new WeakMap();
+	runtimeResolveShareHook.on((args) => {
+		const loadId = args.shareInfo?.[__mfRuntimeShareLoadIdKey];
+		const resolver = args.resolver;
+		if (typeof resolver !== "function") return args;
+		const instrumentedResolver = (...resolverArgs) => {
+			const resolved = resolver(...resolverArgs);
+			const selectedProvider = resolved?.shared;
+			if (selectedProvider && (typeof selectedProvider === "object" || typeof selectedProvider === "function") && !__mfRuntimeProviderOrigins.has(selectedProvider)) __mfRuntimeProviderOrigins.set(selectedProvider, { from: selectedProvider.from });
+			if (loadId !== void 0 && selectedProvider) __mfRuntimeShareSelections.set(loadId, selectedProvider);
+			return resolved;
+		};
+		args.resolver = instrumentedResolver;
+		return args;
+	});
+	const __mfPinSharedProvider = (versionMap, version, currentProvider, provider) => {
+		if (!versionMap || versionMap[version] !== currentProvider) return void 0;
+		const pinnedProvider = Object.assign({}, provider, {
+			version: provider.version ?? version,
+			scope: provider.scope ?? currentProvider?.scope ?? ["default"],
+			strategy: "loaded-first"
+		});
+		const providerFrom = provider.from;
+		versionMap[version] = pinnedProvider;
+		const isCurrentProviderActive = () => currentProvider === void 0 ? versionMap[version] === void 0 : versionMap[version] === currentProvider;
+		return {
+			provider: pinnedProvider,
+			reveal() {
+				if (versionMap[version] !== pinnedProvider) return false;
+				if (currentProvider === void 0) delete versionMap[version];
+				else versionMap[version] = currentProvider;
+				return true;
+			},
+			reapply() {
+				if (!isCurrentProviderActive()) return false;
+				versionMap[version] = pinnedProvider;
+				return true;
+			},
+			release(loaded, selected = true) {
+				provider.from = providerFrom;
+				if (versionMap[version] !== pinnedProvider) return !selected && isCurrentProviderActive();
+				if (!selected) {
+					if (currentProvider === void 0) delete versionMap[version];
+					else versionMap[version] = currentProvider;
+					return true;
+				}
+				if (!loaded) {
+					if (currentProvider === void 0) delete versionMap[version];
+					else versionMap[version] = currentProvider;
+					return false;
+				}
+				pinnedProvider.from = providerFrom;
+				if (loaded && pinnedProvider.lib) pinnedProvider.loaded = true;
+				if (provider.strategy === void 0) delete pinnedProvider.strategy;
+				else pinnedProvider.strategy = provider.strategy;
+				return true;
+			}
+		};
+	};
+	const __mfSnapshotSharedProviders = (versionMap) => Object.entries(versionMap || {}).map(([version, provider]) => ({
+		provider,
+		version,
+		from: provider.from,
+		registered: true
+	}));
+	const __mfMatchLoadedSharedProvider = (providerSelections, factory) => {
+		if (factory === void 0) return void 0;
+		let match;
+		for (const selection of providerSelections) {
+			const provider = selection.provider;
+			const directProvider = provider.treeShaking || provider;
+			if (selection.loadedFactory !== factory && provider.lib !== factory && directProvider.lib !== factory) continue;
+			if (match) return void 0;
+			match = selection;
+		}
+		return match;
+	};
+	const __mfLoadRuntimeShare = async (pkg, shareConfig, pinned) => {
+		const loadId = ++__mfRuntimeShareLoadId;
+		__mfRuntimeShareLifecycles.set(loadId, { pinned });
+		try {
+			const factory = await initRes.loadShare(pkg, { customShareInfo: {
+				shareConfig,
+				[__mfRuntimeShareLoadIdKey]: loadId
+			} });
+			return {
+				factory: factory === false ? void 0 : factory,
+				selectedProvider: __mfRuntimeShareSelections.get(loadId)
+			};
+		} finally {
+			__mfRuntimeShareSelections.delete(loadId);
+			__mfRuntimeShareLifecycles.delete(loadId);
+		}
+	};
+	const __mfLoadPinnedRuntimeShare = async (pkg, shareConfig, versionMap, version, currentProvider, provider, providerRegistered = true) => {
+		const providerFrom = provider.from;
+		const pinned = __mfPinSharedProvider(versionMap, version, currentProvider, provider);
+		if (!pinned) return void 0;
+		let runtimeLoad;
+		try {
+			runtimeLoad = await __mfLoadRuntimeShare(pkg, shareConfig, pinned);
+		} catch (error) {
+			pinned.release(false);
+			throw error;
+		}
+		const factory = runtimeLoad?.factory;
+		if (factory === void 0) {
+			pinned.release(false);
+			return;
+		}
+		const providerSelections = __mfSnapshotSharedProviders(versionMap);
+		const directPinnedProvider = pinned.provider.treeShaking || pinned.provider;
+		const pinnedMatchesFactory = pinned.provider.lib === factory || directPinnedProvider.lib === factory;
+		if (!providerRegistered && pinnedMatchesFactory) {
+			const pinnedSelectionIndex = providerSelections.findIndex((selection) => selection.provider === pinned.provider);
+			if (pinnedSelectionIndex !== -1) providerSelections.splice(pinnedSelectionIndex, 1);
+		}
+		if (!providerRegistered && !providerSelections.some((selection) => selection.provider === provider)) providerSelections.push({
+			provider,
+			version,
+			from: providerFrom,
+			registered: false,
+			loadedFactory: pinnedMatchesFactory ? factory : void 0
+		});
+		const runtimeSelectedProvider = !providerRegistered && runtimeLoad.selectedProvider === pinned.provider && pinnedMatchesFactory ? provider : runtimeLoad.selectedProvider;
+		if (runtimeSelectedProvider && !providerSelections.some((selection) => selection.provider === runtimeSelectedProvider)) {
+			const runtimeProviderOrigin = __mfRuntimeProviderOrigins.get(runtimeSelectedProvider);
+			const selectedVersion = typeof runtimeSelectedProvider.version === "string" && runtimeSelectedProvider.version ? runtimeSelectedProvider.version : version;
+			providerSelections.push({
+				provider: runtimeSelectedProvider,
+				version: selectedVersion,
+				from: runtimeProviderOrigin ? runtimeProviderOrigin.from : runtimeSelectedProvider.from,
+				registered: versionMap?.[selectedVersion] === runtimeSelectedProvider,
+				loadedFactory: factory
+			});
+		}
+		const selection = providerSelections.find((candidate) => candidate.provider === runtimeSelectedProvider) ?? __mfMatchLoadedSharedProvider(providerSelections, factory);
+		if (!pinned.release(true, selection?.provider === pinned.provider) || !selection) return void 0;
+		const runtimeProviderOrigin = __mfRuntimeProviderOrigins.get(selection.provider);
+		selection.from = selection.provider === provider ? providerFrom : runtimeProviderOrigin ? runtimeProviderOrigin.from : selection.provider.from;
+		if (runtimeProviderOrigin) selection.provider.from = runtimeProviderOrigin.from;
+		const mod = typeof factory === "function" ? factory() : factory;
+		const resolved = await Promise.resolve(mod);
+		if (selection.registered && versionMap?.[selection.version] !== selection.provider) return void 0;
+		return {
+			provider: selection.provider,
+			selection,
+			resolved
+		};
+	};
+	const bridgedProviders = /* @__PURE__ */ new Set();
+	const bridgeSelections = /* @__PURE__ */ new Map();
+	const __mfBridgeMaterializedProvider = async (pkg, usedShare, versionMap) => {
+		const singleton = Boolean(usedShare.shareConfig?.singleton);
+		if (singleton && true) return;
+		if (usedShare.canLiveRebind === false) return;
+		try {
+			const provider = __mfSelectExternalSharedProvider(versionMap, pkg, usedShare, "version-first");
+			const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
+			if (!providerEntry) return;
+			const { version } = providerEntry;
+			if (!singleton && version !== usedShare.version) return;
+			if (!provider.lib && !provider.loading && !(provider.loaded && typeof provider.get === "function")) return;
+			const usedCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, singleton, usedShare.version, usedShare.scope);
+			if (__mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor) !== void 0) return;
+			const liveVersionMap = shared[pkg];
+			const liveProvider = liveVersionMap?.[version];
+			if (providerEntry.registered && !__mfMatchesSharedProvider(liveProvider, provider)) return;
+			let loadedShare;
+			let directFactory = provider.lib;
+			if (!directFactory && provider.loading) directFactory = await provider.loading;
+			if (!directFactory && provider.loaded && typeof provider.get === "function") directFactory = await provider.get();
+			if (!directFactory) return;
+			const directModule = typeof directFactory === "function" ? directFactory() : directFactory;
+			const directResolved = await Promise.resolve(directModule);
+			const directProvider = providerEntry.registered ? liveProvider : provider;
+			loadedShare = {
+				provider: directProvider,
+				selection: {
+					provider: directProvider,
+					version,
+					from: provider.from,
+					registered: providerEntry.registered
+				},
+				resolved: directResolved
+			};
+			const actualProvider = loadedShare?.provider;
+			const actualSelection = loadedShare?.selection;
+			if (!actualSelection) return;
+			const resolved = loadedShare?.resolved;
+			if (resolved === void 0) return;
+			if (__mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor) !== void 0) return;
+			if (actualSelection.registered && liveVersionMap?.[actualSelection.version] !== actualProvider) return;
+			__mfWriteSharedCache(__mfModuleCache.share, usedCacheDescriptor, __mfNormalizeRuntimeShare(resolved), actualSelection.from);
+			bridgedProviders.add(actualProvider);
+		} catch (e) {
+			console.error("[Module Federation] Failed to bridge materialized shared module \"" + pkg + "\"", e);
+		}
+	};
+	const __mfBridgeExternalSharedProvider = async (pkg, usedShare, versionMap, passedVersionMap, expectedSelection) => {
+		try {
+			const usedCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, usedShare.shareConfig?.singleton, usedShare.version, usedShare.scope);
+			const cachedShare = __mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor);
+			const cachedShareOwner = __mfReadSharedCacheOwner(__mfModuleCache.share, usedCacheDescriptor);
+			const selectedExternalProvider = __mfSelectExternalSharedProvider(versionMap, pkg, usedShare, "version-first");
+			const selectedRuntimeProvider = selectedExternalProvider || __mfSelectSharedProvider(versionMap, pkg, usedShare, "version-first") || usedShare;
+			const providerEntry = __mfFindSharedProviderEntry(versionMap, selectedRuntimeProvider);
+			if (!providerEntry) return;
+			const selectedLocalProvider = __mfMatchesSharedProvider(selectedRuntimeProvider, usedShare);
+			const { version } = providerEntry;
+			if (!usedShare.shareConfig?.singleton && version !== usedShare.version) return;
+			const passedProvider = passedVersionMap?.[version];
+			const resolvedExternalProvider = __mfResolveExternalSharedProvider(federationInstances, scopeRoot, shared, "default", pkg, providerEntry, selectedExternalProvider, passedProvider, "version-first");
+			if (!resolvedExternalProvider && !selectedLocalProvider) return;
+			const { provider, scopeRootProvider } = resolvedExternalProvider || {
+				provider: selectedRuntimeProvider,
+				scopeRootProvider: void 0
+			};
+			if (usedShare.canLiveRebind === false) return;
+			if (cachedShare !== void 0 && cachedShareOwner !== mfName) return;
+			const liveVersionMap = shared[pkg];
+			const liveProvider = liveVersionMap?.[version];
+			if (providerEntry.registered && !scopeRootProvider && !__mfMatchesSharedProvider(liveProvider, provider)) return;
+			const loadedShare = await __mfLoadPinnedRuntimeShare(pkg, usedShare.shareConfig, liveVersionMap, version, liveProvider, provider, providerEntry.registered && !selectedLocalProvider);
+			const actualProvider = loadedShare?.provider;
+			const actualSelection = loadedShare?.selection;
+			if (!actualSelection) return;
+			if (__mfMatchesSharedProvider(actualProvider, usedShare)) return;
+			if (expectedSelection) {
+				if (expectedSelection.version !== actualSelection.version || !__mfMatchesSharedProvider({ from: actualSelection.from }, expectedSelection.provider)) return;
+			}
+			if (bridgedProviders.has(actualProvider)) return;
+			const resolved = loadedShare?.resolved;
+			if (resolved === void 0) return;
+			const latestCachedShare = __mfReadSharedCache(__mfModuleCache.share, usedCacheDescriptor);
+			const latestCachedShareOwner = __mfReadSharedCacheOwner(__mfModuleCache.share, usedCacheDescriptor);
+			if (latestCachedShare !== void 0 && latestCachedShareOwner !== mfName) return;
+			if (actualSelection.registered && liveVersionMap?.[actualSelection.version] !== actualProvider) return;
+			if (!expectedSelection) bridgeSelections.set(pkg, {
+				version: actualSelection.version,
+				provider: { from: actualSelection.from }
+			});
+			bridgedProviders.add(actualProvider);
+			const normalized = __mfNormalizeRuntimeShare(resolved);
+			__mfWriteSharedCache(__mfModuleCache.share, usedCacheDescriptor, normalized, actualSelection.from);
+		} catch (e) {
+			console.error("[Module Federation] Failed to bridge external shared module \"" + pkg + "\"", e);
+		}
+	};
+	for (const [pkg, usedShare] of Object.entries(usedShared)) {
+		if (usedShare.treeShaking) continue;
+		await __mfBridgeMaterializedProvider(pkg, usedShare, initialShared[pkg]);
+	}
+	for (const [pkg, share] of Object.entries(usedShared)) {
+		if (share.treeShaking) continue;
+		const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+		if (__mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== void 0) continue;
+		const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
+		const singletonModule = __mfReadSharedCache(__mfModuleCache.share, singletonCacheDescriptor);
+		if (singletonModule !== void 0) __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, singletonModule, __mfReadSharedCacheOwner(__mfModuleCache.share, singletonCacheDescriptor));
+	}
+	const __mfSeedKeys = [
+		"react",
+		"react/jsx-runtime",
+		"react-dom",
+		"zod",
+		"@baseplate-dev/ui-components",
+		"@baseplate-dev/project-builder-lib/web",
+		"@baseplate-dev/project-builder-lib",
+		"@tanstack/react-router"
+	].filter((pkg) => usedShared[pkg] !== void 0);
+	const __mfSeedPackageName = (pkg) => pkg.startsWith("@") ? pkg.split("/").slice(0, 2).join("/") : pkg.split("/")[0];
+	for (const pkg of Object.keys(usedShared)) {
+		if (__mfSeedKeys.includes(pkg)) continue;
+		const packageName = __mfSeedPackageName(pkg);
+		const rootIndex = __mfSeedKeys.indexOf(packageName);
+		if (rootIndex === -1) {
+			__mfSeedKeys.push(pkg);
+			continue;
+		}
+		let insertIndex = rootIndex;
+		while (insertIndex > 0 && __mfSeedPackageName(__mfSeedKeys[insertIndex - 1]) === packageName && __mfSeedKeys[insertIndex - 1] !== packageName) insertIndex--;
+		__mfSeedKeys.splice(insertIndex, 0, pkg);
+	}
+	var __mfSeedLocalShared = async (seedKeys) => {
+		for (const pkg of seedKeys) {
+			const share = usedShared[pkg];
+			const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+			if (share.shareConfig?.import === false || Boolean(share.treeShaking) || __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) !== void 0) continue;
+			const singletonCacheDescriptor = __mfGetSharedCacheDescriptor(pkg, true, share.version, share.scope);
+			const singletonModule = __mfReadSharedCache(__mfModuleCache.share, singletonCacheDescriptor);
+			if (singletonModule !== void 0) {
+				__mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, singletonModule, __mfReadSharedCacheOwner(__mfModuleCache.share, singletonCacheDescriptor));
+				continue;
+			}
+			const factory = await share.get();
+			const mod = typeof factory === "function" ? factory() : factory;
+			const resolved = await Promise.resolve(mod);
+			const __mfNormalizeRuntimeShare = (mod) => {
+				let current = mod;
+				for (let i = 0; i < 5; i++) {
+					const defaultExport = current?.default;
+					if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+					const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+					if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+					current = defaultExport;
+				}
+				return current;
+			};
+			const normalizedModule = __mfNormalizeRuntimeShare(resolved);
+			const exportModule = normalizedModule === resolved ? { ...resolved } : normalizedModule;
+			if (exportModule.__esModule !== true) Object.defineProperty(exportModule, "__esModule", {
+				value: true,
+				enumerable: false
+			});
+			__mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, exportModule, mfName);
+		}
+	};
+	const __mfIsRuntimeOnlySharePending = (pkg) => {
+		const share = usedShared[pkg];
+		if (!share.treeShaking && share.shareConfig?.import !== false) return false;
+		const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+		return share.treeShaking ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName) === void 0 && __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) === void 0 : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) === void 0;
+	};
+	const __mfNeedsPreInitSeedBarrier = (pkg) => {
+		const share = usedShared[pkg];
+		const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+		if ((share.treeShaking ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName) ?? __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor) : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor)) !== void 0) return false;
+		if (share.treeShaking || share.shareConfig?.import === false) return true;
+		if (typeof __mfSelectExternalSharedProvider !== "function") return false;
+		return Boolean(__mfSelectExternalSharedProvider(initialShared[pkg], pkg, share, "version-first"));
+	};
+	const __mfFirstRuntimeSeedBarrierIndex = __mfSeedKeys.findIndex(__mfNeedsPreInitSeedBarrier);
+	const __mfImmediateSeedKeys = __mfFirstRuntimeSeedBarrierIndex === -1 ? __mfSeedKeys : __mfSeedKeys.slice(0, __mfFirstRuntimeSeedBarrierIndex);
+	var __mfDeferredSeedKeys = __mfFirstRuntimeSeedBarrierIndex === -1 ? [] : __mfSeedKeys.slice(__mfFirstRuntimeSeedBarrierIndex);
+	await __mfSeedLocalShared(__mfImmediateSeedKeys);
+	try {
+		await retrySharedInit(async () => {
+			await Promise.all(await initRes.initializeSharing("default", {
+				strategy: "version-first",
+				from: "build",
+				initScope
+			}));
+		});
+	} catch (e) {
+		console.error("[Module Federation]", e);
+	}
+	for (const [pkg, usedShare] of Object.entries(usedShared)) {
+		if (usedShare.treeShaking) continue;
+		await __mfBridgeExternalSharedProvider(pkg, usedShare, shared[pkg], initialShared[pkg], void 0);
+	}
+	try {
+		const allInstances = globalThis.__FEDERATION__?.__SHARE__;
+		const globalVersionsByPackage = Object.create(null);
+		if (allInstances) for (const [, scopes] of Object.entries(allInstances)) for (const scopeName of shareScopeNames) {
+			const scopeShare = scopes?.[scopeName];
+			if (!scopeShare) continue;
+			for (const [pkg, versionMap] of Object.entries(scopeShare)) {
+				const usedShare = usedShared?.[pkg];
+				const passedVersions = initialShared[pkg];
+				const bridgeSelection = bridgeSelections.get(pkg);
+				if (!usedShare) continue;
+				if (!passedVersions) continue;
+				if (!bridgeSelection) continue;
+				if (usedShare.treeShaking) continue;
+				const globalVersions = globalVersionsByPackage[pkg] || (globalVersionsByPackage[pkg] = Object.create(null));
+				for (const [version, provider] of Object.entries(versionMap)) {
+					if (!provider.lib) continue;
+					if (bridgeSelection.version !== version) continue;
+					if (!__mfMatchesSharedProvider(provider, bridgeSelection.provider)) continue;
+					const passedProvider = passedVersions[version];
+					if (!(provider === passedProvider || passedProvider?.from && provider.from === passedProvider.from)) continue;
+					if (provider === usedShare || usedShare.from && provider.from === usedShare.from) continue;
+					if (globalVersions[version] === void 0) globalVersions[version] = provider;
+				}
+			}
+		}
+		for (const [pkg, versionMap] of Object.entries(globalVersionsByPackage)) await __mfBridgeExternalSharedProvider(pkg, usedShared[pkg], versionMap, initialShared[pkg], bridgeSelections.get(pkg));
+	} catch (e) {
+		console.error("[Module Federation] Failed to bridge external shared modules", e);
+	}
+	const __mfResolveTreeShakingShared = async () => {};
+	const __mfResolveImportFalseShared = async (pkg, share) => {
+		const cacheDescriptor = __mfGetSharedCacheDescriptor(pkg, share.shareConfig?.singleton, share.version, share.scope);
+		const cachedShare = share.treeShaking ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName) : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor);
+		if (share.shareConfig?.import !== false || cachedShare !== void 0) return;
+		const __mfNormalizeRuntimeShare = (mod) => {
+			let current = mod;
+			for (let i = 0; i < 5; i++) {
+				const defaultExport = current?.default;
+				if (!defaultExport || typeof defaultExport !== "object" || Object.keys(defaultExport).length === 0) break;
+				const namedValues = Object.keys(current).filter((key) => key !== "default").map((key) => current[key]);
+				if (namedValues.length > 0 && namedValues.some((value) => value !== void 0)) break;
+				current = defaultExport;
+			}
+			return current;
+		};
+		const versionMap = shared?.[pkg];
+		const provider = __mfSelectSharedProvider(versionMap, pkg, share, "version-first") || share;
+		const providerEntry = __mfFindSharedProviderEntry(versionMap, provider);
+		if (!providerEntry) return;
+		const { version } = providerEntry;
+		const currentProvider = versionMap?.[version];
+		const loadedShare = await __mfLoadPinnedRuntimeShare(pkg, share.shareConfig, versionMap, version, currentProvider, provider, providerEntry.registered && !__mfMatchesSharedProvider(provider, share));
+		const providerSelection = loadedShare?.selection;
+		const actualProvider = loadedShare?.provider;
+		const resolved = loadedShare?.resolved;
+		if (!providerSelection) return;
+		if (__mfMatchesSharedProvider(actualProvider, share)) return;
+		if (resolved === void 0) return;
+		if ((share.treeShaking ? __mfReadTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName) : __mfReadSharedCache(__mfModuleCache.share, cacheDescriptor)) !== void 0) return;
+		if (providerSelection.registered && versionMap?.[providerSelection.version] !== actualProvider) return;
+		const normalizedShared = __mfNormalizeRuntimeShare(resolved);
+		if (share.treeShaking) {
+			const providedExports = share.treeShaking.providedExports ?? share.treeShaking.usedExports ?? [];
+			__mfWriteTreeShakingSharedCache(__mfModuleCache.share, cacheDescriptor, providedExports, normalizedShared);
+			__mfWriteTreeShakingSharedSelection(__mfModuleCache.share, cacheDescriptor, mfName, normalizedShared);
+		} else __mfWriteSharedCache(__mfModuleCache.share, cacheDescriptor, normalizedShared, providerSelection.from);
+	};
+	for (const pkg of __mfDeferredSeedKeys) {
+		const share = usedShared[pkg];
+		if (__mfIsRuntimeOnlySharePending(pkg)) {
+			if (share.treeShaking) await __mfResolveTreeShakingShared(pkg, share);
+			else if (share.shareConfig?.import === false) await __mfResolveImportFalseShared(pkg, share);
+		}
+		if (__mfIsRuntimeOnlySharePending(pkg)) break;
+		await __mfSeedLocalShared([pkg]);
+	}
+	initResolve(initRes);
+	return initRes;
+}
+async function getExposes(moduleName) {
+	const exposesMap = await getExposesMap();
+	if (!(moduleName in exposesMap)) throw new Error(`[Module Federation] Module ${moduleName} does not exist in container.`);
+	if (__mfModuleCache.pendingShareLoads) await Promise.all(__mfModuleCache.pendingShareLoads);
+	return exposesMap[moduleName]().then((res) => () => res);
+}
+//#endregion
+export { init as n, getExposes as t };
+
+//# sourceMappingURL=virtual_mf-REMOTE_ENTRY_ID___mfe_internal__plugin-auth__remoteEntry_js-BZBRyml2.js.map