vite-plugin-zephyr 1.1.2 → 1.2.0

package/dist/lib/vite-plugin-zephyr.js

@@ -1,272 +1,718 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withZephyr = withZephyr;
-const tslib_1 = require("tslib");
-const promises_1 = require("node:fs/promises");
-const magic_string_1 = tslib_1.__importDefault(require("magic-string"));
-const vite_1 = require("vite");
-const zephyr_agent_1 = require("zephyr-agent");
-const extract_entrypoint_1 = require("./internal/extract/extract-entrypoint");
-const extract_mf_plugin_1 = require("./internal/extract/extract_mf_plugin");
-const extract_vite_assets_map_1 = require("./internal/extract/extract_vite_assets_map");
-const ensure_runtime_plugin_1 = require("./internal/mf-vite-etl/ensure_runtime_plugin");
-const extract_mf_vite_remotes_1 = require("./internal/mf-vite-etl/extract-mf-vite-remotes");
-const DEFAULT_LIBRARY_TYPE = 'module';
-function loadModuleFederationPlugin() {
-    let moduleFederation;
-    try {
-        moduleFederation = require('@module-federation/vite');
+var __webpack_modules__ = {
+    "@module-federation/vite" (module) {
+        module.exports = require("@module-federation/vite");
     }
-    catch (error) {
-        throw new zephyr_agent_1.ZephyrError(zephyr_agent_1.ZeErrors.ERR_UNKNOWN, {
-            message: `vite-plugin-zephyr: @module-federation/vite is required when mfConfig is provided. Install a compatible version of @module-federation/vite to use Module Federation with withZephyr().${error instanceof Error ? ` Original error: ${error.message}` : ''}`,
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
         });
-    }
-    if (typeof moduleFederation.federation !== 'function') {
-        throw new zephyr_agent_1.ZephyrError(zephyr_agent_1.ZeErrors.ERR_UNKNOWN, {
-            message: 'vite-plugin-zephyr: failed to load @module-federation/vite federation plugin',
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
         });
-    }
-    return moduleFederation.federation;
-}
-function withZephyrCore(options = {}) {
-    const { zephyr_engine_defer, zephyr_defer_create } = zephyr_agent_1.ZephyrEngine.defer_create();
-    const hooks = options.hooks;
-    let resolve_vite_internal_options;
-    const vite_internal_options_defer = new Promise((resolve) => {
-        resolve_vite_internal_options = resolve;
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        withZephyr: ()=>withZephyr
     });
-    let cachedSpecifier;
-    let entrypoint;
-    let mfConfig = options.mfConfig;
-    return {
-        name: 'with-zephyr',
-        // Run before Vite's env replacement so ZE_PUBLIC_* reads can be rewritten first.
-        enforce: 'pre',
-        config: (config) => {
-            var _a, _b;
-            // If MF was configured separately, inject the Zephyr runtime plugin before MF emits.
-            const detectedMfConfig = (_b = (0, extract_mf_plugin_1.extract_mf_plugin)((_a = config.plugins) !== null && _a !== void 0 ? _a : [])) === null || _b === void 0 ? void 0 : _b._options;
-            if (detectedMfConfig) {
-                mfConfig = (0, ensure_runtime_plugin_1.ensureRuntimePlugin)(detectedMfConfig);
-            }
+    const promises_namespaceObject = require("node:fs/promises");
+    const external_node_crypto_namespaceObject = require("node:crypto");
+    const external_node_path_namespaceObject = require("node:path");
+    const external_magic_string_namespaceObject = require("magic-string");
+    var external_magic_string_default = /*#__PURE__*/ __webpack_require__.n(external_magic_string_namespaceObject);
+    const external_zephyr_agent_namespaceObject = require("zephyr-agent");
+    const extract_entrypoint_js_namespaceObject = require("./internal/extract/extract-entrypoint.js");
+    const extract_mf_plugin_js_namespaceObject = require("./internal/extract/extract_mf_plugin.js");
+    const extract_vite_assets_map_js_namespaceObject = require("./internal/extract/extract_vite_assets_map.js");
+    const ensure_runtime_plugin_js_namespaceObject = require("./internal/mf-vite-etl/ensure_runtime_plugin.js");
+    const extract_mf_vite_remotes_js_namespaceObject = require("./internal/mf-vite-etl/extract-mf-vite-remotes.js");
+    const federation_metadata_js_namespaceObject = require("./internal/mf-vite-etl/federation-metadata.js");
+    const partial_build_scope_js_namespaceObject = require("./internal/partial-build-scope.js");
+    const DEFAULT_LIBRARY_TYPE = 'module';
+    const VITE_ENVIRONMENT_OUTPUT_PREFIX = 'vite-environment:';
+    function isOriginAbsoluteBase(base) {
+        return 'string' == typeof base && base.startsWith('/') && !base.startsWith('//');
+    }
+    function mergeClaimedPartialMaps(claims) {
+        const merged = {};
+        for (const claim of claims)for (const [partialKey, assetsMap] of Object.entries(claim.partialAssetMaps)){
+            if (Object.prototype.hasOwnProperty.call(merged, partialKey)) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                message: `Vite partial output "${partialKey}" was produced by multiple build scopes.`
+            });
+            merged[partialKey] = assetsMap;
+        }
+        return merged;
+    }
+    function mergeAssetMaps(maps) {
+        const merged = {};
+        const paths = new Map();
+        for (const assetsMap of maps)for (const [hash, asset] of Object.entries(assetsMap)){
+            const existingHash = paths.get(asset.path);
+            if (existingHash && existingHash !== hash) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                message: `Vite emitted conflicting partial assets for "${asset.path}".`
+            });
+            paths.set(asset.path, hash);
+            merged[hash] = asset;
+        }
+        return merged;
+    }
+    function viteEnvironmentOutputPrefix(environmentName) {
+        return `${VITE_ENVIRONMENT_OUTPUT_PREFIX}${encodeURIComponent(environmentName)}:`;
+    }
+    function viteEnvironmentOutputKey(environmentName, outputDirectory, outputFile, outputFormat, assetsMap) {
+        const destination = outputFile ? external_node_path_namespaceObject.join(outputDirectory, external_node_path_namespaceObject.basename(outputFile)) : outputDirectory;
+        const assets = Object.values(assetsMap).map((asset)=>[
+                asset.path.replace(/\\/g, '/'),
+                asset.hash,
+                asset.size
+            ]).sort(([leftPath, leftHash], [rightPath, rightHash])=>leftPath === rightPath ? leftHash.localeCompare(rightHash) : leftPath.localeCompare(rightPath));
+        const identity = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify({
+            destination: destination.replace(/\\/g, '/'),
+            format: outputFormat ?? null,
+            assets
+        })).digest('hex');
+        return `${viteEnvironmentOutputPrefix(environmentName)}${identity}`;
+    }
+    function parseViteEnvironmentOutputName(key) {
+        if (!key.startsWith(VITE_ENVIRONMENT_OUTPUT_PREFIX)) return null;
+        const outputIdentity = key.slice(VITE_ENVIRONMENT_OUTPUT_PREFIX.length);
+        const separator = outputIdentity.indexOf(':');
+        if (separator <= 0 || separator === outputIdentity.length - 1) return null;
+        try {
+            const environmentName = decodeURIComponent(outputIdentity.slice(0, separator));
+            return environmentName || null;
+        } catch  {
             return null;
-        },
-        configResolved: async (config) => {
-            var _a, _b, _c;
-            const root = config.root;
-            // Normalize the entrypoint early so uploads use the same path in serve/build.
-            entrypoint = (0, extract_entrypoint_1.extractEntrypoint)(config);
-            // Initialize the Zephyr engine in both serve and build flows.
-            zephyr_defer_create({
-                builder: 'vite',
-                context: root,
+        }
+    }
+    function prefixAssetsMap(assetsMap, prefix) {
+        const normalized = prefix?.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+        if (!normalized) return assetsMap;
+        return Object.fromEntries(Object.values(assetsMap).map((asset)=>{
+            const assetPath = asset.path.replace(/\\/g, '/').replace(/^\/+/, '');
+            const prefixedPath = assetPath.startsWith(`${normalized}/`) ? assetPath : `${normalized}/${assetPath}`;
+            const prefixedAsset = (0, external_zephyr_agent_namespaceObject.zeBuildAssets)({
+                filepath: prefixedPath,
+                content: asset.buffer
             });
-            resolve_vite_internal_options({
-                root,
-                outDir: (_a = config.build) === null || _a === void 0 ? void 0 : _a.outDir,
-                publicDir: config.publicDir,
+            return [
+                prefixedAsset.hash,
+                prefixedAsset
+            ];
+        }));
+    }
+    function inferServerEntrypoint(partials, override, serverEnvironmentNames) {
+        if (override) return normalizeEntrypoint(override);
+        const allPaths = Object.values(partials).flatMap((assetsMap)=>Object.values(assetsMap).map((asset)=>asset.path));
+        const serverEnvironments = new Set(serverEnvironmentNames);
+        const serverPaths = Object.entries(partials).flatMap(([key, assetsMap])=>{
+            const environmentName = parseViteEnvironmentOutputName(key);
+            return environmentName && serverEnvironments.has(environmentName) ? Object.values(assetsMap).map((asset)=>asset.path) : [];
+        });
+        const paths = serverEnvironmentNames.length > 0 ? serverPaths : allPaths;
+        const preferred = [
+            'server/index.js',
+            'server/index.mjs',
+            'server/index.cjs',
+            'ssr/index.js',
+            'ssr/index.mjs',
+            'ssr/index.cjs',
+            'rsc/index.js',
+            'rsc/index.mjs',
+            'rsc/index.cjs'
+        ];
+        return preferred.find((candidate)=>paths.includes(candidate)) ?? paths.find((candidate)=>/(^|\/)(server|index)\.(mjs|cjs|js)$/.test(candidate));
+    }
+    function commonDirectory(paths) {
+        if (0 === paths.length) return;
+        const resolvedPaths = paths.map((item)=>external_node_path_namespaceObject.resolve(item));
+        let candidate = resolvedPaths[0];
+        while(candidate && !resolvedPaths.every((item)=>{
+            const relative = external_node_path_namespaceObject.relative(candidate, item);
+            return !relative || !relative.startsWith(`..${external_node_path_namespaceObject.sep}`) && '..' !== relative;
+        })){
+            const parent = external_node_path_namespaceObject.dirname(candidate);
+            if (parent === candidate) return;
+            candidate = parent;
+        }
+        if (candidate === external_node_path_namespaceObject.parse(candidate).root && resolvedPaths.length > 1) return;
+        return candidate;
+    }
+    function normalizeEntrypoint(entrypoint) {
+        const normalized = entrypoint.replace(/\\/g, '/').replace(/^\.?\/+/, '');
+        const segments = normalized.split('/').filter((segment)=>segment && '.' !== segment);
+        if (!normalized || 0 === segments.length || segments.includes('..')) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+            message: `Vite entrypoint must be a relative path inside the snapshot: "${entrypoint}".`
+        });
+        return segments.join('/');
+    }
+    function uniqueParticipant(base, reserved) {
+        let participant = base;
+        let suffix = 1;
+        const used = new Set(reserved);
+        while(used.has(participant))participant = `${base}-${suffix++}`;
+        return participant;
+    }
+    function toModuleFederationConfigArray(mfConfig) {
+        if (!mfConfig) return [];
+        return Array.isArray(mfConfig) ? mfConfig : [
+            mfConfig
+        ];
+    }
+    function attachViteFederationBuildStats(buildStats, federationMetadata) {
+        const federation = federationMetadata.federation;
+        if (!federation || 0 === federation.length) return buildStats;
+        const legacyFederation = 1 === federation.length ? federation[0] : void 0;
+        return {
+            ...buildStats,
+            federation,
+            ...legacyFederation ? {
+                remote: legacyFederation.remote,
+                mf_manifest: legacyFederation.mf_manifest,
+                library_type: legacyFederation.library_type,
+                exposes: legacyFederation.exposes,
+                shared: legacyFederation.shared
+            } : {
+                remote: void 0,
+                mf_manifest: void 0,
+                library_type: void 0,
+                exposes: void 0,
+                shared: void 0
+            }
+        };
+    }
+    function loadModuleFederationPlugin() {
+        let moduleFederation;
+        try {
+            moduleFederation = __webpack_require__("@module-federation/vite");
+        } catch (error) {
+            throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_UNKNOWN, {
+                message: `vite-plugin-zephyr: @module-federation/vite is required when mfConfig is provided. Install a compatible version of @module-federation/vite to use Module Federation with withZephyr().${error instanceof Error ? ` Original error: ${error.message}` : ''}`
             });
-            const detectedMfConfig = (_c = (0, extract_mf_plugin_1.extract_mf_plugin)((_b = config.plugins) !== null && _b !== void 0 ? _b : [])) === null || _c === void 0 ? void 0 : _c._options;
-            if (detectedMfConfig) {
-                mfConfig = (0, ensure_runtime_plugin_1.ensureRuntimePlugin)(detectedMfConfig);
+        }
+        if ('function' != typeof moduleFederation.federation) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_UNKNOWN, {
+            message: 'vite-plugin-zephyr: failed to load @module-federation/vite federation plugin'
+        });
+        return moduleFederation.federation;
+    }
+    function withZephyrCore(options = {}) {
+        const { zephyr_engine_defer, zephyr_defer_create } = external_zephyr_agent_namespaceObject.ZephyrEngine.defer_create();
+        const hooks = options.hooks;
+        const preservesLockedArtifactPaths = 'tap-app' === options.target;
+        const buildInvocationId = `vite-${(0, external_node_crypto_namespaceObject.randomUUID)()}`;
+        const usesExternalPartialBuild = void 0 !== options.partialBuild || Boolean(process.env['ZE_BUILD_INVOCATION_ID']?.trim());
+        const externalPartialScope = usesExternalPartialBuild ? (0, partial_build_scope_js_namespaceObject.resolveVitePartialBuildScope)(options.partialBuild) : void 0;
+        let resolve_vite_internal_options;
+        const vite_internal_options_defer = new Promise((resolve)=>{
+            resolve_vite_internal_options = resolve;
+        });
+        let cachedSpecifier;
+        let entrypoint;
+        const configureModuleFederationRuntime = (config)=>preservesLockedArtifactPaths ? config : (0, ensure_runtime_plugin_js_namespaceObject.ensureRuntimePlugin)(config);
+        const mfConfigSources = toModuleFederationConfigArray(options.mfConfig).map(configureModuleFederationRuntime);
+        const ownedConfigIdentities = new Set(mfConfigSources.flatMap((config)=>(0, federation_metadata_js_namespaceObject.getConfigIdentities)(config)));
+        let environmentNames = [];
+        let environmentMetadata = new Map();
+        let sharedOutputRoot;
+        let isWatchMode = false;
+        let buildGeneration = 0;
+        let applicationContext;
+        let uploadMetadata;
+        let baseHref = '';
+        let supportsBuildApp = false;
+        const registerModuleFederationConfigs = (configs)=>{
+            for (const config of configs){
+                const identities = (0, federation_metadata_js_namespaceObject.getConfigIdentities)(config);
+                if (identities.some((identity)=>ownedConfigIdentities.has(identity))) continue;
+                const runtimeConfigured = configureModuleFederationRuntime(config);
+                if (!mfConfigSources.includes(runtimeConfigured)) {
+                    mfConfigSources.push(runtimeConfigured);
+                    for (const identity of (0, federation_metadata_js_namespaceObject.getConfigIdentities)(runtimeConfigured))ownedConfigIdentities.add(identity);
+                }
             }
-            mfConfig !== null && mfConfig !== void 0 ? mfConfig : (mfConfig = detectedMfConfig);
-            if (mfConfig) {
+        };
+        const getModuleFederationPublicationMetadata = ()=>(0, federation_metadata_js_namespaceObject.createViteModuleFederationPublicationMetadata)(mfConfigSources);
+        return {
+            name: 'with-zephyr',
+            enforce: 'pre',
+            config: (config, env)=>{
+                registerModuleFederationConfigs((0, extract_mf_plugin_js_namespaceObject.extract_mf_plugins)(config.plugins ?? []).map((plugin)=>plugin._options));
+                return preservesLockedArtifactPaths || 'build' !== env.command || null != config.base ? null : {
+                    base: './'
+                };
+            },
+            configResolved: async (config)=>{
+                const vite = await import("vite");
+                supportsBuildApp = Number.parseInt(vite.version.split('.')[0] ?? '0', 10) >= 6;
+                const root = config.root;
+                baseHref = (0, external_zephyr_agent_namespaceObject.normalizeBasePath)(config.base);
+                entrypoint = normalizeEntrypoint(options.entrypoint ?? (0, extract_entrypoint_js_namespaceObject.extractEntrypoint)(config));
+                isWatchMode = Boolean(config.build?.watch);
+                const configuredEnvironments = config.environments ?? {};
+                environmentNames = Object.keys(configuredEnvironments);
+                environmentMetadata = new Map(Object.entries(configuredEnvironments).map(([name, environment])=>[
+                        name,
+                        {
+                            consumer: environment.consumer,
+                            outputDir: environment.build?.outDir ? external_node_path_namespaceObject.resolve(root, environment.build.outDir) : void 0
+                        }
+                    ]));
+                const outputDirectories = [
+                    ...environmentMetadata.values()
+                ].map(({ outputDir })=>outputDir).filter((value)=>!!value);
+                sharedOutputRoot = preservesLockedArtifactPaths || outputDirectories.length !== environmentNames.length ? void 0 : commonDirectory(outputDirectories);
+                zephyr_defer_create({
+                    builder: 'vite',
+                    context: root,
+                    target: options.target
+                });
                 try {
-                    // Resolve remotes early so zephyr-manifest.json includes runtime dependencies.
-                    const dependencyPairs = (0, extract_mf_vite_remotes_1.extract_remotes_dependencies)(root, mfConfig);
-                    if (dependencyPairs) {
+                    const zephyrEngine = await zephyr_engine_defer;
+                    if ((0, external_zephyr_agent_namespaceObject.usesPathAddressing)(await zephyrEngine.application_configuration) && isOriginAbsoluteBase(config.base)) external_zephyr_agent_namespaceObject.ze_log.init(`The resolved Vite base '${config.base}' is still origin-absolute for a path-addressed target. A later config hook may have overridden Zephyr's relative base.`);
+                } catch (error) {
+                    (0, external_zephyr_agent_namespaceObject.handleGlobalError)(error);
+                }
+                resolve_vite_internal_options({
+                    root,
+                    outDir: config.build?.outDir,
+                    publicDir: config.publicDir,
+                    target: options.target
+                });
+                registerModuleFederationConfigs((0, extract_mf_plugin_js_namespaceObject.extract_mf_plugins)(config.plugins ?? []).map((plugin)=>plugin._options));
+                const federationMetadata = getModuleFederationPublicationMetadata();
+                const mfConfigs = federationMetadata.mfConfigs ?? [];
+                if (mfConfigs.length > 0 && !preservesLockedArtifactPaths) try {
+                    const dependencyPairs = [
+                        ...new Map(mfConfigs.flatMap((mfConfig)=>(0, extract_mf_vite_remotes_js_namespaceObject.extract_remotes_dependencies)(root, mfConfig) ?? []).map((dependency)=>[
+                                `${dependency.name}:${dependency.version}`,
+                                dependency
+                            ])).values()
+                    ];
+                    if (dependencyPairs.length > 0) {
                         const zephyr_engine = await zephyr_engine_defer;
                         await zephyr_engine.resolve_remote_dependencies(dependencyPairs, DEFAULT_LIBRARY_TYPE);
-                        zephyr_agent_1.ze_log.remotes(`Resolved ${dependencyPairs.length} remote dependencies in configResolved`);
+                        external_zephyr_agent_namespaceObject.ze_log.remotes(`Resolved ${dependencyPairs.length} remote dependencies in configResolved`);
                     }
+                } catch (error) {
+                    (0, external_zephyr_agent_namespaceObject.handleGlobalError)(error);
                 }
-                catch (error) {
-                    (0, zephyr_agent_1.handleGlobalError)(error);
-                }
-            }
-            try {
-                // Mirror ZE_PUBLIC_* into process.env for agent-side manifest generation.
-                const loaded = (0, vite_1.loadEnv)(config.mode || 'production', root, '');
-                for (const [k, v] of Object.entries(loaded)) {
-                    if (k.startsWith('ZE_PUBLIC_') &&
-                        typeof v === 'string' &&
-                        !(k in process.env)) {
-                        process.env[k] = v;
-                    }
-                }
-            }
-            catch (_d) {
-                // ignore if loadEnv unavailable
-            }
-        },
-        resolveId: async (source) => {
-            if (source === ensure_runtime_plugin_1.ZEPHYR_MF_RUNTIME_PLUGIN_ID) {
-                return ensure_runtime_plugin_1.RESOLVED_ZEPHYR_MF_RUNTIME_PLUGIN_ID;
-            }
-            try {
-                const zephyr_engine = await zephyr_engine_defer;
-                if (!cachedSpecifier) {
-                    cachedSpecifier = `env:vars:${zephyr_engine.application_uid}`;
-                }
-                if (source === cachedSpecifier) {
-                    if (process.env['NODE_ENV'] === 'development') {
-                        // Keep dev env imports aligned with the manifest JSON route used by other Zephyr plugins.
-                        return '/zephyr-manifest.json';
-                    }
-                    return { id: source, external: true };
-                }
-            }
-            catch (_a) {
-                // ignore
-            }
-            return null;
-        },
-        load: async (id) => {
-            if (id === ensure_runtime_plugin_1.RESOLVED_ZEPHYR_MF_RUNTIME_PLUGIN_ID) {
-                return (0, promises_1.readFile)((0, ensure_runtime_plugin_1.getRuntimePluginPath)(), 'utf8');
-            }
-            return null;
-        },
-        transform: {
-            order: 'post',
-            // Limit the hook to source-like files only.
-            filter: {
-                id: /\.(mjs|cjs|js|ts|jsx|tsx)/,
+                try {
+                    const loaded = vite.loadEnv(config.mode || 'production', root, '');
+                    for (const [k, v] of Object.entries(loaded))if (k.startsWith('ZE_PUBLIC_') && 'string' == typeof v && !(k in process.env)) process.env[k] = v;
+                } catch  {}
             },
-            handler: async (code, id) => {
+            resolveId: async (source)=>{
+                if (source === ensure_runtime_plugin_js_namespaceObject.ZEPHYR_MF_RUNTIME_PLUGIN_ID) return ensure_runtime_plugin_js_namespaceObject.RESOLVED_ZEPHYR_MF_RUNTIME_PLUGIN_ID;
                 try {
-                    // Rewrite ZE_PUBLIC_* reads in app code; node_modules stay untouched.
-                    if (!id.includes('node_modules')) {
-                        const zephyr_engine = await zephyr_engine_defer;
-                        if (!cachedSpecifier) {
-                            cachedSpecifier = `env:vars:${zephyr_engine.application_uid}`;
-                        }
-                        const res = (0, zephyr_agent_1.rewriteEnvReadsToVirtualModule)(String(code), cachedSpecifier);
-                        if (res && typeof res.code === 'string' && res.code !== code) {
-                            code = res.code;
-                            return {
-                                code,
-                                map: new magic_string_1.default(code).generateMap({
-                                    hires: true,
-                                }),
-                            };
-                        }
+                    const zephyr_engine = await zephyr_engine_defer;
+                    if (!cachedSpecifier) cachedSpecifier = `env:vars:${zephyr_engine.application_uid}`;
+                    if (source === cachedSpecifier) {
+                        if ('development' === process.env['NODE_ENV']) return '/zephyr-manifest.json';
+                        return {
+                            id: source,
+                            external: true
+                        };
                     }
-                    return null;
-                }
-                catch (error) {
-                    (0, zephyr_agent_1.handleGlobalError)(error);
-                    return null;
-                }
+                } catch  {}
+                return null;
+            },
+            load: async (id)=>{
+                if (id === ensure_runtime_plugin_js_namespaceObject.RESOLVED_ZEPHYR_MF_RUNTIME_PLUGIN_ID) return (0, promises_namespaceObject.readFile)((0, ensure_runtime_plugin_js_namespaceObject.getRuntimePluginPath)(), 'utf8');
+                return null;
             },
-        },
-        generateBundle: async function (_outputOptions, bundle) {
-            if (cachedSpecifier) {
-                for (const [, chunk] of Object.entries(bundle)) {
-                    if (chunk &&
-                        typeof chunk === 'object' &&
-                        'type' in chunk &&
-                        chunk.type === 'chunk' &&
-                        'code' in chunk) {
-                        // Preserve JSON import assertions after bundling so runtime import maps still work.
-                        const importWithoutAssertion = new RegExp(`import\\s+([^\\s]+)\\s+from\\s*['"]${cachedSpecifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`, 'g');
-                        if (chunk.code.match(importWithoutAssertion)) {
-                            chunk.code = chunk.code.replace(importWithoutAssertion, `import $1 from '${cachedSpecifier}' with { type: 'json' }`);
+            transform: {
+                order: 'post',
+                filter: {
+                    id: /\.(mjs|cjs|js|ts|jsx|tsx)/
+                },
+                handler: async (code, id)=>{
+                    if (preservesLockedArtifactPaths) return null;
+                    try {
+                        if (!id.includes('node_modules')) {
+                            const zephyr_engine = await zephyr_engine_defer;
+                            if (!cachedSpecifier) cachedSpecifier = `env:vars:${zephyr_engine.application_uid}`;
+                            const res = (0, external_zephyr_agent_namespaceObject.rewriteEnvReadsToVirtualModule)(String(code), cachedSpecifier);
+                            if (res && 'string' == typeof res.code && res.code !== code) {
+                                code = res.code;
+                                return {
+                                    code,
+                                    map: new (external_magic_string_default())(code).generateMap({
+                                        hires: true
+                                    })
+                                };
+                            }
                         }
+                        return null;
+                    } catch (error) {
+                        (0, external_zephyr_agent_namespaceObject.handleGlobalError)(error);
+                        return null;
                     }
                 }
-            }
-            try {
-                const zephyr_engine = await zephyr_engine_defer;
-                const dependencies = zephyr_engine.federated_dependencies || [];
-                const manifestContent = (0, zephyr_agent_1.createManifestContent)(dependencies, true);
-                this.emitFile({
-                    type: 'asset',
-                    fileName: 'zephyr-manifest.json',
-                    source: manifestContent,
-                });
-            }
-            catch (error) {
-                (0, zephyr_agent_1.handleGlobalError)(error);
-                this.emitFile({
-                    type: 'asset',
-                    fileName: 'zephyr-manifest.json',
-                    source: JSON.stringify({
-                        version: '1.0.0',
-                        timestamp: new Date().toISOString(),
-                        dependencies: {},
-                        zeVars: {},
-                    }, null, 2),
-                });
-            }
-        },
-        configureServer: async (server) => {
-            try {
-                const zephyr_engine = await zephyr_engine_defer;
-                if (!cachedSpecifier) {
-                    cachedSpecifier = `env:vars:${zephyr_engine.application_uid}`;
+            },
+            renderChunk: {
+                order: 'post',
+                handler (code) {
+                    if (preservesLockedArtifactPaths || !cachedSpecifier) return null;
+                    const importWithoutAttribute = new RegExp(`import\\s+([^\\s]+)\\s+from\\s*['"]${cachedSpecifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`, 'g');
+                    const nextCode = code.replace(importWithoutAttribute, `import $1 from '${cachedSpecifier}' with { type: 'json' }`);
+                    return nextCode === code ? null : {
+                        code: nextCode,
+                        map: null
+                    };
                 }
-                server.middlewares.use((req, res, next) => {
-                    void (async () => {
-                        if (!req.url) {
-                            next();
-                            return;
-                        }
-                        const requestUrl = req.url.split('?')[0];
-                        if (requestUrl === '/zephyr-manifest.json') {
-                            try {
+            },
+            generateBundle: async function() {
+                if (preservesLockedArtifactPaths) return;
+                try {
+                    const zephyr_engine = await zephyr_engine_defer;
+                    const dependencies = zephyr_engine.federated_dependencies || [];
+                    const manifestContent = (0, external_zephyr_agent_namespaceObject.createManifestContent)(dependencies, true);
+                    this.emitFile({
+                        type: 'asset',
+                        fileName: 'zephyr-manifest.json',
+                        source: manifestContent
+                    });
+                } catch (error) {
+                    (0, external_zephyr_agent_namespaceObject.handleGlobalError)(error);
+                    this.emitFile({
+                        type: 'asset',
+                        fileName: 'zephyr-manifest.json',
+                        source: JSON.stringify({
+                            version: '1.0.0',
+                            timestamp: new Date().toISOString(),
+                            dependencies: {},
+                            zeVars: {}
+                        }, null, 2)
+                    });
+                }
+            },
+            configureServer: async (server)=>{
+                try {
+                    const zephyr_engine = await zephyr_engine_defer;
+                    if (!cachedSpecifier) cachedSpecifier = `env:vars:${zephyr_engine.application_uid}`;
+                    server.middlewares.use((req, res, next)=>{
+                        (async ()=>{
+                            if (!req.url) return void next();
+                            const requestUrl = req.url.split('?')[0];
+                            if ('/zephyr-manifest.json' === requestUrl) try {
                                 const dependencies = zephyr_engine.federated_dependencies || [];
-                                const manifestContent = (0, zephyr_agent_1.createManifestContent)(dependencies, true);
+                                const manifestContent = (0, external_zephyr_agent_namespaceObject.createManifestContent)(dependencies, true);
                                 res.setHeader('Content-Type', 'application/json; charset=utf-8');
                                 res.setHeader('Access-Control-Allow-Origin', '*');
                                 res.end(manifestContent);
                                 return;
+                            } catch (error) {
+                                (0, external_zephyr_agent_namespaceObject.handleGlobalError)(error);
                             }
-                            catch (error) {
-                                (0, zephyr_agent_1.handleGlobalError)(error);
+                            next();
+                        })();
+                    });
+                } catch  {}
+            },
+            writeBundle: async function(outputOptions, bundle) {
+                const partialClaims = [];
+                try {
+                    const [vite_internal_options, zephyr_engine] = await Promise.all([
+                        vite_internal_options_defer,
+                        zephyr_engine_defer
+                    ]);
+                    zephyr_engine.buildProperties.baseHref = baseHref;
+                    const environmentName = this.environment?.name;
+                    const isMultiEnvironment = environmentNames.length > 1;
+                    if (isWatchMode && isMultiEnvironment) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: "Vite multi-environment watch publication is not supported because environment rebuilds do not expose an atomic application generation."
+                    });
+                    const outputDirectory = external_node_path_namespaceObject.resolve(vite_internal_options.root, outputOptions.dir ?? (outputOptions.file ? external_node_path_namespaceObject.dirname(outputOptions.file) : vite_internal_options.outDir));
+                    const resolvedEnvironmentName = environmentName ?? [
+                        ...environmentMetadata.entries()
+                    ].find(([, metadata])=>metadata.outputDir === outputDirectory)?.[0] ?? (1 === environmentNames.length ? environmentNames[0] : void 0);
+                    const coordinateWithBuildApp = supportsBuildApp && !isWatchMode;
+                    if (coordinateWithBuildApp && !resolvedEnvironmentName) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: `Could not associate Vite output directory "${outputDirectory}" with an environment.`
+                    });
+                    let assetPrefix;
+                    if (coordinateWithBuildApp && isMultiEnvironment && !preservesLockedArtifactPaths) {
+                        if (!sharedOutputRoot) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: 'Could not determine a shared output root for Vite environments.'
+                        });
+                        const relativeOutput = external_node_path_namespaceObject.relative(sharedOutputRoot, outputDirectory);
+                        if ('..' === relativeOutput || relativeOutput.startsWith(`..${external_node_path_namespaceObject.sep}`) || external_node_path_namespaceObject.isAbsolute(relativeOutput)) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: `Vite environment output "${outputDirectory}" is outside shared output root "${sharedOutputRoot}".`
+                        });
+                        assetPrefix = relativeOutput ? relativeOutput.split(external_node_path_namespaceObject.sep).join('/') : void 0;
+                    }
+                    const extractionOptions = {
+                        ...vite_internal_options,
+                        dir: outputOptions.dir,
+                        outDir: outputDirectory,
+                        assets: bundle,
+                        publicDir: isMultiEnvironment && resolvedEnvironmentName && environmentMetadata.get(resolvedEnvironmentName)?.consumer === 'server' ? void 0 : vite_internal_options.publicDir
+                    };
+                    let assetsMap = await (0, extract_vite_assets_map_js_namespaceObject.extract_vite_assets_map)(zephyr_engine, extractionOptions);
+                    if (coordinateWithBuildApp) {
+                        if (!resolvedEnvironmentName) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: `Could not associate Vite output directory "${outputDirectory}" with an environment.`
+                        });
+                        const persistedAssetsMap = preservesLockedArtifactPaths ? assetsMap : prefixAssetsMap(assetsMap, assetPrefix);
+                        await (0, external_zephyr_agent_namespaceObject.savePartialAssetMap)(zephyr_engine.application_uid, viteEnvironmentOutputKey(resolvedEnvironmentName, outputDirectory, outputOptions.file, outputOptions.format, persistedAssetsMap), persistedAssetsMap, {
+                            invocationId: buildInvocationId,
+                            generation: buildGeneration
+                        });
+                        return;
+                    }
+                    if (!isWatchMode && externalPartialScope) {
+                        const batch = await (0, external_zephyr_agent_namespaceObject.claimPartialAssetMapBatch)(zephyr_engine.application_uid, [
+                            externalPartialScope
+                        ]);
+                        if (!batch) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: 'Vite partialBuild was configured, but its external partial output was unavailable or already claimed.'
+                        });
+                        partialClaims.push(...batch.claims);
+                        const partials = mergeClaimedPartialMaps(partialClaims);
+                        assetsMap = mergeAssetMaps([
+                            ...Object.values(partials),
+                            assetsMap
+                        ]);
+                    }
+                    if (!zephyr_engine.hasActiveBuild) await zephyr_engine.start_new_build();
+                    const federationMetadata = getModuleFederationPublicationMetadata();
+                    (0, external_zephyr_agent_namespaceObject.assertTapFederationPublicationMetadata)({
+                        target: options.target,
+                        mfConfigs: federationMetadata.mfConfigs,
+                        federation: federationMetadata.federation
+                    });
+                    await zephyr_engine.upload_assets({
+                        assetsMap,
+                        buildStats: attachViteFederationBuildStats(await (0, external_zephyr_agent_namespaceObject.zeBuildDashData)(zephyr_engine), federationMetadata),
+                        mfConfig: federationMetadata.mfConfig,
+                        mfConfigs: federationMetadata.mfConfigs,
+                        hooks,
+                        entrypoint,
+                        snapshotType: options.snapshotType ?? 'csr'
+                    });
+                    await zephyr_engine.build_finished();
+                    await (0, external_zephyr_agent_namespaceObject.commitPartialAssetMapClaimBatch)(zephyr_engine.application_uid, partialClaims.map(({ claimId })=>claimId));
+                } catch (error) {
+                    try {
+                        const zephyr_engine = await zephyr_engine_defer;
+                        zephyr_engine.build_failed();
+                    } catch  {}
+                    if (partialClaims.length > 0) try {
+                        const zephyr_engine = await zephyr_engine_defer;
+                        await (0, external_zephyr_agent_namespaceObject.rollbackPartialAssetMapClaimBatch)(zephyr_engine.application_uid, partialClaims.map(({ claimId })=>claimId));
+                    } catch (restoreError) {
+                        (0, external_zephyr_agent_namespaceObject.handleGlobalError)(restoreError);
+                    }
+                    (0, external_zephyr_agent_namespaceObject.handleGlobalError)(error);
+                }
+            },
+            buildApp: {
+                order: 'post',
+                async handler (builder) {
+                    if (!supportsBuildApp) return;
+                    const environments = Object.entries(builder.environments);
+                    if (isWatchMode) {
+                        if (environments.length > 1) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: "Vite multi-environment watch publication is not supported because environment rebuilds do not expose an atomic application generation."
+                        });
+                        return;
+                    }
+                    if (0 === environments.length) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: 'Vite exposed no build environments for Zephyr publication.'
+                    });
+                    let incomplete = environments.filter(([, environment])=>!environment.isBuilt).map(([name])=>name);
+                    if (incomplete.length === environments.length) {
+                        for (const [, environment] of environments)await builder.build(environment);
+                        incomplete = environments.filter(([, environment])=>!environment.isBuilt).map(([name])=>name);
+                    }
+                    if (incomplete.length > 0) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: `Vite completed without these environments: ${incomplete.join(', ')}. Zephyr will not publish partial compiler output.`
+                    });
+                    const partialClaims = [];
+                    const generation = buildGeneration++;
+                    try {
+                        const zephyrEngine = await zephyr_engine_defer;
+                        zephyrEngine.buildProperties.baseHref = baseHref;
+                        const claimScopes = [
+                            {
+                                invocationId: buildInvocationId,
+                                generation
+                            },
+                            ...externalPartialScope ? [
+                                externalPartialScope
+                            ] : []
+                        ];
+                        const batch = await (0, external_zephyr_agent_namespaceObject.claimPartialAssetMapBatch)(zephyrEngine.application_uid, claimScopes);
+                        if (!batch) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: externalPartialScope ? 'Vite could not atomically claim both environment and configured external partial output.' : 'Vite environment output was unavailable or already claimed.'
+                        });
+                        partialClaims.push(...batch.claims);
+                        const claimedPartials = mergeClaimedPartialMaps(partialClaims);
+                        if (0 === Object.keys(claimedPartials).length) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: 'Vite produced no environment assets for Zephyr publication.'
+                        });
+                        const expectedEnvironmentNames = new Set(environments.map(([name])=>name));
+                        const environmentOutputCounts = new Map(environments.map(([name])=>[
+                                name,
+                                0
+                            ]));
+                        const unexpectedEnvironmentOutputs = [];
+                        for (const key of Object.keys(claimedPartials)){
+                            if (!key.startsWith(VITE_ENVIRONMENT_OUTPUT_PREFIX)) continue;
+                            const environmentName = parseViteEnvironmentOutputName(key);
+                            if (!environmentName || !expectedEnvironmentNames.has(environmentName)) {
+                                unexpectedEnvironmentOutputs.push(key);
+                                continue;
                             }
+                            environmentOutputCounts.set(environmentName, (environmentOutputCounts.get(environmentName) ?? 0) + 1);
                         }
-                        next();
-                    })();
-                });
-            }
-            catch (_a) {
-                // ignore
-            }
-        },
-        writeBundle: async function (options, bundle) {
-            try {
-                const [vite_internal_options, zephyr_engine] = await Promise.all([
-                    vite_internal_options_defer,
-                    zephyr_engine_defer,
-                ]);
-                vite_internal_options.dir = options.dir;
-                vite_internal_options.assets = bundle;
-                const assetsMap = await (0, extract_vite_assets_map_1.extract_vite_assets_map)(zephyr_engine, vite_internal_options);
-                await zephyr_engine.upload_assets({
-                    assetsMap,
-                    buildStats: await (0, zephyr_agent_1.zeBuildDashData)(zephyr_engine),
-                    hooks,
-                    entrypoint,
-                    snapshotType: 'csr',
-                });
-                await zephyr_engine.build_finished();
-            }
-            catch (error) {
-                (0, zephyr_agent_1.handleGlobalError)(error);
+                        const missingEnvironmentOutputs = environments.map(([name])=>name).filter((name)=>0 === environmentOutputCounts.get(name)).map(viteEnvironmentOutputPrefix);
+                        if (missingEnvironmentOutputs.length > 0) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: `Vite did not produce Zephyr output for: ${missingEnvironmentOutputs.join(', ')}`
+                        });
+                        if (unexpectedEnvironmentOutputs.length > 0) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: 'Vite found stale or unexpected environment output for: ' + unexpectedEnvironmentOutputs.join(', ')
+                        });
+                        const serverEnvironmentNames = environments.filter(([name, environment])=>environment.config?.consumer === 'server' || environmentMetadata.get(name)?.consumer === 'server').map(([name])=>name);
+                        const inferredSsr = serverEnvironmentNames.length > 0;
+                        const snapshotType = options.snapshotType ?? (!preservesLockedArtifactPaths && inferredSsr ? 'ssr' : 'csr');
+                        const finalEntrypoint = 'ssr' === snapshotType ? inferServerEntrypoint(claimedPartials, options.entrypoint, serverEnvironmentNames) : preservesLockedArtifactPaths ? void 0 : options.entrypoint ?? entrypoint;
+                        if ('ssr' === snapshotType && !finalEntrypoint) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: 'Could not infer a Vite server entrypoint. Set withZephyr({ entrypoint }).'
+                        });
+                        if ('ssr' === snapshotType && finalEntrypoint && !Object.values(claimedPartials).some((assetsMap)=>Object.values(assetsMap).some((asset)=>asset.path === finalEntrypoint))) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: `Vite server entrypoint "${finalEntrypoint}" was not emitted in the coordinated snapshot.`
+                        });
+                        uploadMetadata = {
+                            snapshotType,
+                            entrypoint: finalEntrypoint
+                        };
+                        applicationContext ??= new external_zephyr_agent_namespaceObject.ApplicationContext({
+                            applicationUid: zephyrEngine.application_uid,
+                            prepare: ()=>zephyrEngine.hasActiveBuild ? void 0 : zephyrEngine.start_new_build(),
+                            publish: async ({ assetsMap })=>{
+                                if (!uploadMetadata) throw new external_zephyr_agent_namespaceObject.ZephyrError(external_zephyr_agent_namespaceObject.ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                                    message: 'Vite upload metadata was not prepared.'
+                                });
+                                const federationMetadata = getModuleFederationPublicationMetadata();
+                                (0, external_zephyr_agent_namespaceObject.assertTapFederationPublicationMetadata)({
+                                    target: options.target,
+                                    mfConfigs: federationMetadata.mfConfigs,
+                                    federation: federationMetadata.federation
+                                });
+                                await zephyrEngine.upload_assets({
+                                    assetsMap,
+                                    buildStats: attachViteFederationBuildStats(await (0, external_zephyr_agent_namespaceObject.zeBuildDashData)(zephyrEngine), federationMetadata),
+                                    mfConfig: federationMetadata.mfConfig,
+                                    mfConfigs: federationMetadata.mfConfigs,
+                                    hooks,
+                                    snapshotType: uploadMetadata.snapshotType,
+                                    entrypoint: uploadMetadata.entrypoint
+                                });
+                            },
+                            finish: ()=>zephyrEngine.build_finished(),
+                            onFailure: ()=>zephyrEngine.build_failed()
+                        });
+                        const outputParticipant = uniqueParticipant('vite-output', environments.map(([name])=>name));
+                        const session = applicationContext.beginBuild({
+                            invocationId: `${buildInvocationId}:${generation}`,
+                            generation,
+                            strictAssetPaths: preservesLockedArtifactPaths,
+                            participants: [
+                                ...environments.map(([name, environment])=>({
+                                        name,
+                                        role: environment.config?.consumer ?? environmentMetadata.get(name)?.consumer ?? name
+                                    })),
+                                {
+                                    name: outputParticipant,
+                                    role: snapshotType
+                                }
+                            ]
+                        });
+                        for (const [name] of environments)session.completeParticipant(name);
+                        for (const [key, assetsMap] of Object.entries(claimedPartials))session.contribute({
+                            participant: outputParticipant,
+                            key,
+                            assetsMap
+                        });
+                        session.completeParticipant(outputParticipant);
+                        await session.publish();
+                        await (0, external_zephyr_agent_namespaceObject.commitPartialAssetMapClaimBatch)(zephyrEngine.application_uid, partialClaims.map(({ claimId })=>claimId));
+                    } catch (error) {
+                        try {
+                            const zephyrEngine = await zephyr_engine_defer;
+                            zephyrEngine.build_failed();
+                        } catch  {}
+                        if (partialClaims.length > 0) try {
+                            const zephyrEngine = await zephyr_engine_defer;
+                            await (0, external_zephyr_agent_namespaceObject.rollbackPartialAssetMapClaimBatch)(zephyrEngine.application_uid, partialClaims.map(({ claimId })=>claimId));
+                        } catch (restoreError) {
+                            (0, external_zephyr_agent_namespaceObject.handleGlobalError)(restoreError);
+                        }
+                        (0, external_zephyr_agent_namespaceObject.handleGlobalError)(error);
+                    }
+                }
             }
-        },
-    };
-}
-function withZephyr(options = {}) {
-    const plugins = [];
-    if (options.mfConfig) {
-        const federation = loadModuleFederationPlugin();
-        plugins.push(...federation((0, ensure_runtime_plugin_1.ensureRuntimePlugin)(options.mfConfig)));
+        };
     }
-    plugins.push(withZephyrCore(options));
-    return plugins;
-}
+    function withZephyr(options = {}) {
+        if (void 0 !== options.target) (0, external_zephyr_agent_namespaceObject.assertZephyrBuildTarget)(options.target, 'withZephyr({ target })');
+        const plugins = [];
+        const mfConfigs = toModuleFederationConfigArray(options.mfConfig);
+        if (mfConfigs.length > 0) {
+            const federation = loadModuleFederationPlugin();
+            const preservesLockedArtifactPaths = 'tap-app' === options.target;
+            for (const mfConfig of mfConfigs)plugins.push(...federation(preservesLockedArtifactPaths ? mfConfig : (0, ensure_runtime_plugin_js_namespaceObject.ensureRuntimePlugin)(mfConfig)));
+        }
+        plugins.push(withZephyrCore(options));
+        return plugins;
+    }
+})();
+exports.withZephyr = __webpack_exports__.withZephyr;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "withZephyr"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
 //# sourceMappingURL=vite-plugin-zephyr.js.map