vite-plugin-zephyr 1.3.0 → 1.4.1

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

@@ -1,8 +1,8 @@
-import "node:module";
 import { readFile } from "node:fs/promises";
 import { createHash, randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
 import magic_string from "magic-string";
-import { ApplicationContext, ZeErrors, ZephyrEngine, ZephyrError, assertZephyrBuildTarget, claimPartialAssetMapBatch, commitPartialAssetMapClaimBatch, createManifestContent, handleGlobalError, normalizeBasePath, rewriteEnvReadsToVirtualModule, rollbackPartialAssetMapClaimBatch, savePartialAssetMap, zeBuildAssets, zeBuildDashData, ze_log } from "zephyr-agent";
+import { ApplicationContext, ZeErrors, ZephyrEngine, ZephyrError, assertZephyrBuildTarget, claimPartialAssetMapBatch, commitPartialAssetMapClaimBatch, createManifestContent, handleGlobalError, logFn, normalizeBasePath, rewriteEnvReadsToVirtualModule, rollbackPartialAssetMapClaimBatch, savePartialAssetMap, zeBuildAssets, zeBuildDashData, ze_log } from "zephyr-agent";
 import { extractEntrypoint } from "./internal/extract/extract-entrypoint.mjs";
 import { extract_mf_plugins } from "./internal/extract/extract_mf_plugin.mjs";
 import { extract_vite_assets_map } from "./internal/extract/extract_vite_assets_map.mjs";
@@ -10,17 +10,12 @@ import { RESOLVED_ZEPHYR_MF_RUNTIME_PLUGIN_ID, ZEPHYR_MF_RUNTIME_PLUGIN_ID, ensu
 import { extract_remotes_dependencies } from "./internal/mf-vite-etl/extract-mf-vite-remotes.mjs";
 import { createViteModuleFederationPublicationMetadata, getConfigIdentities } from "./internal/mf-vite-etl/federation-metadata.mjs";
 import { resolveVitePartialBuildScope } from "./internal/partial-build-scope.mjs";
-import { __webpack_require__ } from "../rslib-runtime~0.mjs";
-import { createRequire as __rspack_createRequire } from "node:module";
-const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+import { fileURLToPath as __rspack_fileURLToPath } from "node:url";
+var __rspack_import_meta_filename__ = __rspack_fileURLToPath(import.meta.url);
 import * as __rspack_external_node_path_806ed179 from "node:path";
-__webpack_require__.add({
-    "@module-federation/vite" (module) {
-        module.exports = __rspack_createRequire_require("@module-federation/vite");
-    }
-});
 const DEFAULT_LIBRARY_TYPE = 'module';
 const VITE_ENVIRONMENT_OUTPUT_PREFIX = 'vite-environment:';
+const runtimeRequire = createRequire(__rspack_import_meta_filename__);
 function mergeClaimedPartialMaps(claims) {
     const merged = {};
     for (const claim of claims)for (const [partialKey, assetsMap] of Object.entries(claim.partialAssetMaps)){
@@ -111,6 +106,18 @@ function inferServerEntrypoint(partials, override, serverEnvironmentNames) {
     ];
     return preferred.find((candidate)=>paths.includes(candidate)) ?? paths.find((candidate)=>/(^|\/)(server|index)\.(mjs|cjs|js)$/.test(candidate));
 }
+function hasLateOutputHook(value) {
+    if (Array.isArray(value)) return value.some(hasLateOutputHook);
+    if (!value || 'object' != typeof value) return false;
+    if ('then' in value) return true;
+    return [
+        'outputOptions',
+        'writeBundle'
+    ].some((name)=>{
+        const hook = value[name];
+        return Boolean(hook && 'object' == typeof hook && 'order' in hook && 'post' === hook.order);
+    });
+}
 function commonDirectory(paths) {
     if (0 === paths.length) return;
     const resolvedPaths = paths.map((item)=>__rspack_external_node_path_806ed179.resolve(item));
@@ -172,7 +179,7 @@ function attachViteFederationBuildStats(buildStats, federationMetadata) {
 function loadModuleFederationPlugin() {
     let moduleFederation;
     try {
-        moduleFederation = __webpack_require__("@module-federation/vite");
+        moduleFederation = runtimeRequire('@module-federation/vite');
     } catch (error) {
         throw new ZephyrError(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}` : ''}`
@@ -207,7 +214,29 @@ function withZephyrCore(options = {}) {
     let applicationContext;
     let uploadMetadata;
     let baseHref = '';
-    let supportsBuildApp = false;
+    let isApplicationBuild = false;
+    let unsupportedVite6Builder = false;
+    let directOutputs = [];
+    let directBuildFailed = false;
+    let directSsr = false;
+    let expectedDirectOutputs = 1;
+    let buildManifest;
+    let hasLaterWriteHook = false;
+    let hasLaterCloseHook = false;
+    let hasLaterOutputOptionsHook = false;
+    const instantiatedEnvironments = new Set();
+    let environmentBuildStarted = false;
+    const buildAppStart = {
+        name: 'with-zephyr:build-app-start',
+        enforce: 'pre',
+        sharedDuringBuild: true,
+        buildApp: {
+            order: 'pre',
+            async handler () {
+                isApplicationBuild = true;
+            }
+        }
+    };
     const registerModuleFederationConfigs = (configs)=>{
         for (const config of configs){
             const identities = getConfigIdentities(config);
@@ -220,8 +249,67 @@ function withZephyrCore(options = {}) {
         }
     };
     const getModuleFederationPublicationMetadata = ()=>createViteModuleFederationPublicationMetadata(mfConfigSources);
-    return {
+    const publishDirectOutputs = async (outputs)=>{
+        const partialClaims = [];
+        const zephyrEngine = await zephyr_engine_defer;
+        try {
+            const outputRoot = commonDirectory(outputs.map((output)=>output.directory));
+            if (!outputRoot) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                message: 'Could not determine a shared output root for the Vite build.'
+            });
+            const serverEntries = new Set();
+            const maps = outputs.map((output)=>{
+                const prefix = preservesLockedArtifactPaths ? void 0 : __rspack_external_node_path_806ed179.relative(outputRoot, output.directory).split(__rspack_external_node_path_806ed179.sep).join('/');
+                for (const entry of output.entrypoints)serverEntries.add(prefix ? `${prefix}/${entry}` : entry);
+                return prefixAssetsMap(output.assetsMap, prefix);
+            });
+            let assetsMap = 1 === maps.length ? maps[0] : mergeAssetMaps(maps);
+            if (!isWatchMode && externalPartialScope) {
+                const batch = await claimPartialAssetMapBatch(zephyrEngine.application_uid, [
+                    externalPartialScope
+                ]);
+                if (!batch) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                    message: 'Vite partialBuild was configured, but its external partial output was unavailable or already claimed.'
+                });
+                partialClaims.push(...batch.claims);
+                assetsMap = mergeAssetMaps([
+                    ...Object.values(mergeClaimedPartialMaps(partialClaims)),
+                    assetsMap
+                ]);
+            }
+            const snapshotType = options.snapshotType ?? (!preservesLockedArtifactPaths && outputs.some((output)=>output.ssr) ? 'ssr' : 'csr');
+            const finalEntrypoint = 'ssr' === snapshotType ? options.entrypoint ? normalizeEntrypoint(options.entrypoint) : 1 === serverEntries.size ? [
+                ...serverEntries
+            ][0] : void 0 : preservesLockedArtifactPaths ? void 0 : entrypoint;
+            if ('ssr' === snapshotType && (!finalEntrypoint || !Object.values(assetsMap).some((asset)=>asset.path === finalEntrypoint))) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                message: 'Could not identify an emitted Vite server entrypoint. Set withZephyr({ entrypoint }) to an emitted server chunk.'
+            });
+            if (!zephyrEngine.hasActiveBuild) await zephyrEngine.start_new_build();
+            const federationMetadata = getModuleFederationPublicationMetadata();
+            await zephyrEngine.upload_assets({
+                assetsMap,
+                buildStats: attachViteFederationBuildStats(await zeBuildDashData(zephyrEngine), federationMetadata),
+                mfConfig: federationMetadata.mfConfig,
+                mfConfigs: federationMetadata.mfConfigs,
+                hooks,
+                entrypoint: finalEntrypoint,
+                snapshotType
+            });
+            await zephyrEngine.build_finished();
+            await commitPartialAssetMapClaimBatch(zephyrEngine.application_uid, partialClaims.map(({ claimId })=>claimId));
+        } catch (error) {
+            zephyrEngine.build_failed();
+            if (partialClaims.length > 0) try {
+                await rollbackPartialAssetMapClaimBatch(zephyrEngine.application_uid, partialClaims.map(({ claimId })=>claimId));
+            } catch (rollbackError) {
+                logFn('error', ZephyrError.format(rollbackError));
+            }
+            throw error;
+        }
+    };
+    const plugin = {
         name: 'with-zephyr',
+        sharedDuringBuild: true,
         enforce: 'pre',
         config: (config)=>{
             registerModuleFederationConfigs(extract_mf_plugins(config.plugins ?? []).map((plugin)=>plugin._options));
@@ -229,13 +317,41 @@ function withZephyrCore(options = {}) {
         },
         configResolved: async (config)=>{
             const vite = await import("vite");
-            supportsBuildApp = Number.parseInt(vite.version.split('.')[0] ?? '0', 10) >= 6;
+            const viteMajor = Number.parseInt(vite.version.split('.')[0] ?? '0', 10);
+            if (environmentBuildStarted) {
+                instantiatedEnvironments.clear();
+                environmentBuildStarted = false;
+            }
+            const createEnvironment = config.build?.createEnvironment;
+            if (createEnvironment) config.build.createEnvironment = function(name, environmentConfig) {
+                const environment = createEnvironment.call(this, name, environmentConfig);
+                instantiatedEnvironments.add(name);
+                return environment;
+            };
+            isApplicationBuild = false;
+            directOutputs = [];
+            directBuildFailed = false;
+            buildManifest = void 0;
+            directSsr = Boolean(config.build?.ssr);
+            const configuredOutput = config.build?.rolldownOptions?.output ?? config.build?.rollupOptions?.output;
+            expectedDirectOutputs = Array.isArray(configuredOutput) ? configuredOutput.length : config.build?.lib ? config.build.lib.formats?.length ?? 2 : 1;
+            const firstBuildAppPlugin = config.getSortedPlugins?.('buildApp')[0];
+            if (viteMajor >= 7 && firstBuildAppPlugin && firstBuildAppPlugin !== buildAppStart) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                message: 'Place withZephyr() before other pre-ordered buildApp plugins so Zephyr can collect application output atomically.'
+            });
+            const writePlugins = config.getSortedPlugins?.('writeBundle');
+            hasLaterWriteHook = Boolean(writePlugins?.length && writePlugins.at(-1) !== plugin);
+            const closePlugins = config.getSortedPlugins?.('closeBundle');
+            hasLaterCloseHook = Boolean(closePlugins?.length && closePlugins.at(-1) !== plugin);
+            const outputOptionPlugins = config.getSortedPlugins?.('outputOptions');
+            hasLaterOutputOptionsHook = Boolean(outputOptionPlugins?.length && outputOptionPlugins.at(-1) !== plugin);
             const root = config.root;
             baseHref = normalizeBasePath(config.base);
             entrypoint = normalizeEntrypoint(options.entrypoint ?? extractEntrypoint(config));
             isWatchMode = Boolean(config.build?.watch);
             const configuredEnvironments = config.environments ?? {};
             environmentNames = Object.keys(configuredEnvironments);
+            unsupportedVite6Builder = 6 === viteMajor && (Boolean(config.builder) || environmentNames.length > 1);
             environmentMetadata = new Map(Object.entries(configuredEnvironments).map(([name, environment])=>[
                     name,
                     {
@@ -346,7 +462,7 @@ function withZephyrCore(options = {}) {
             try {
                 const zephyr_engine = await zephyr_engine_defer;
                 const dependencies = zephyr_engine.federated_dependencies || [];
-                const manifestContent = createManifestContent(dependencies, true);
+                const manifestContent = isApplicationBuild || isWatchMode ? createManifestContent(dependencies, true) : buildManifest ??= createManifestContent(dependencies, true);
                 this.emitFile({
                     type: 'asset',
                     fileName: 'zephyr-manifest.json',
@@ -389,102 +505,127 @@ function withZephyrCore(options = {}) {
                 });
             } 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 ZephyrError(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 = __rspack_external_node_path_806ed179.resolve(vite_internal_options.root, outputOptions.dir ?? (outputOptions.file ? __rspack_external_node_path_806ed179.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 ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
-                    message: `Could not associate Vite output directory "${outputDirectory}" with an environment.`
+        outputOptions: {
+            order: 'post',
+            handler (output) {
+                if (!isApplicationBuild && !isWatchMode && (hasLaterOutputOptionsHook || hasLateOutputHook(output.plugins))) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                    message: 'Zephyr cannot verify post-ordered or asynchronous output-plugin writers. Use normal outputOptions and writeBundle ordering in synchronous output plugins.'
                 });
-                let assetPrefix;
-                if (coordinateWithBuildApp && isMultiEnvironment && !preservesLockedArtifactPaths) {
-                    if (!sharedOutputRoot) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
-                        message: 'Could not determine a shared output root for Vite environments.'
+                return null;
+            }
+        },
+        buildStart () {
+            environmentBuildStarted = true;
+        },
+        buildEnd (error) {
+            if (error) directBuildFailed = true;
+        },
+        renderError () {
+            directBuildFailed = true;
+        },
+        closeBundle: {
+            order: 'post',
+            sequential: true,
+            async handler () {
+                if (isApplicationBuild || isWatchMode || 0 === directOutputs.length) return;
+                const outputs = directOutputs;
+                directOutputs = [];
+                if (directBuildFailed || outputs.length !== expectedDirectOutputs) return;
+                try {
+                    await publishDirectOutputs(outputs);
+                } catch (error) {
+                    handleGlobalError(error);
+                }
+            }
+        },
+        writeBundle: {
+            order: 'post',
+            sequential: true,
+            async handler (outputOptions, bundle) {
+                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 && unsupportedVite6Builder) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: 'Vite 6 application-builder publication requires Vite 7 or newer. Vite 6 supports only single-environment builds without a builder configuration.'
                     });
-                    const relativeOutput = __rspack_external_node_path_806ed179.relative(sharedOutputRoot, outputDirectory);
-                    if ('..' === relativeOutput || relativeOutput.startsWith(`..${__rspack_external_node_path_806ed179.sep}`) || __rspack_external_node_path_806ed179.isAbsolute(relativeOutput)) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
-                        message: `Vite environment output "${outputDirectory}" is outside shared output root "${sharedOutputRoot}".`
+                    if (isWatchMode && isMultiEnvironment) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: "Vite multi-environment watch publication is not supported because environment rebuilds do not expose an atomic application generation."
                     });
-                    assetPrefix = relativeOutput ? relativeOutput.split(__rspack_external_node_path_806ed179.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 extract_vite_assets_map(zephyr_engine, extractionOptions);
-                if (coordinateWithBuildApp) {
-                    if (!resolvedEnvironmentName) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
-                        message: `Could not associate Vite output directory "${outputDirectory}" with an environment.`
+                    const outputDirectory = __rspack_external_node_path_806ed179.resolve(vite_internal_options.root, outputOptions.dir ?? (outputOptions.file ? __rspack_external_node_path_806ed179.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 = isApplicationBuild && !isWatchMode;
+                    if (!coordinateWithBuildApp && instantiatedEnvironments.size > 1) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: 'Use builder.buildApp() to publish multiple Vite environments atomically; individual builder.build(environment) calls cannot finalize the application.'
                     });
-                    const persistedAssetsMap = preservesLockedArtifactPaths ? assetsMap : prefixAssetsMap(assetsMap, assetPrefix);
-                    await savePartialAssetMap(zephyr_engine.application_uid, viteEnvironmentOutputKey(resolvedEnvironmentName, outputDirectory, outputOptions.file, outputOptions.format, persistedAssetsMap), persistedAssetsMap, {
-                        invocationId: buildInvocationId,
-                        generation: buildGeneration
+                    if (!coordinateWithBuildApp && !isWatchMode && (hasLaterWriteHook || hasLaterCloseHook)) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: 'Zephyr must be the last writeBundle and closeBundle hook. Use normal hook ordering for other plugins so publication cannot precede a failed build.'
                     });
-                    return;
-                }
-                if (!isWatchMode && externalPartialScope) {
-                    const batch = await claimPartialAssetMapBatch(zephyr_engine.application_uid, [
-                        externalPartialScope
-                    ]);
-                    if (!batch) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
-                        message: 'Vite partialBuild was configured, but its external partial output was unavailable or already claimed.'
+                    if (coordinateWithBuildApp && !resolvedEnvironmentName) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                        message: `Could not associate Vite output directory "${outputDirectory}" with an environment.`
                     });
-                    partialClaims.push(...batch.claims);
-                    const partials = mergeClaimedPartialMaps(partialClaims);
-                    assetsMap = mergeAssetMaps([
-                        ...Object.values(partials),
-                        assetsMap
+                    let assetPrefix;
+                    if (coordinateWithBuildApp && isMultiEnvironment && !preservesLockedArtifactPaths) {
+                        if (!sharedOutputRoot) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: 'Could not determine a shared output root for Vite environments.'
+                        });
+                        const relativeOutput = __rspack_external_node_path_806ed179.relative(sharedOutputRoot, outputDirectory);
+                        if ('..' === relativeOutput || relativeOutput.startsWith(`..${__rspack_external_node_path_806ed179.sep}`) || __rspack_external_node_path_806ed179.isAbsolute(relativeOutput)) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: `Vite environment output "${outputDirectory}" is outside shared output root "${sharedOutputRoot}".`
+                        });
+                        assetPrefix = relativeOutput ? relativeOutput.split(__rspack_external_node_path_806ed179.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
+                    };
+                    const assetsMap = await extract_vite_assets_map(zephyr_engine, extractionOptions);
+                    if (coordinateWithBuildApp) {
+                        if (!resolvedEnvironmentName) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
+                            message: `Could not associate Vite output directory "${outputDirectory}" with an environment.`
+                        });
+                        const persistedAssetsMap = preservesLockedArtifactPaths ? assetsMap : prefixAssetsMap(assetsMap, assetPrefix);
+                        await savePartialAssetMap(zephyr_engine.application_uid, viteEnvironmentOutputKey(resolvedEnvironmentName, outputDirectory, outputOptions.file, outputOptions.format, persistedAssetsMap), persistedAssetsMap, {
+                            invocationId: buildInvocationId,
+                            generation: buildGeneration
+                        });
+                        return;
+                    }
+                    const output = {
+                        assetsMap,
+                        directory: outputDirectory,
+                        entrypoints: Object.values(bundle).flatMap((asset)=>'chunk' === asset.type && asset.isEntry ? [
+                                asset.fileName
+                            ] : []),
+                        ssr: directSsr || void 0 !== resolvedEnvironmentName && environmentMetadata.get(resolvedEnvironmentName)?.consumer === 'server'
+                    };
+                    if (isWatchMode) await publishDirectOutputs([
+                        output
                     ]);
+                    else directOutputs.push(output);
+                } catch (error) {
+                    directBuildFailed = true;
+                    try {
+                        const zephyr_engine = await zephyr_engine_defer;
+                        zephyr_engine.build_failed();
+                    } catch  {}
+                    handleGlobalError(error);
                 }
-                if (!zephyr_engine.hasActiveBuild) await zephyr_engine.start_new_build();
-                const federationMetadata = getModuleFederationPublicationMetadata();
-                await zephyr_engine.upload_assets({
-                    assetsMap,
-                    buildStats: attachViteFederationBuildStats(await zeBuildDashData(zephyr_engine), federationMetadata),
-                    mfConfig: federationMetadata.mfConfig,
-                    mfConfigs: federationMetadata.mfConfigs,
-                    hooks,
-                    entrypoint,
-                    snapshotType: options.snapshotType ?? 'csr'
-                });
-                await zephyr_engine.build_finished();
-                await 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 rollbackPartialAssetMapClaimBatch(zephyr_engine.application_uid, partialClaims.map(({ claimId })=>claimId));
-                } catch (restoreError) {
-                    handleGlobalError(restoreError);
-                }
-                handleGlobalError(error);
             }
         },
         buildApp: {
             order: 'post',
             async handler (builder) {
-                if (!supportsBuildApp) return;
+                isApplicationBuild = true;
                 const environments = Object.entries(builder.environments);
                 if (isWatchMode) {
                     if (environments.length > 1) throw new ZephyrError(ZeErrors.ERR_DEPLOY_LOCAL_BUILD, {
@@ -616,13 +757,17 @@ function withZephyrCore(options = {}) {
                         const zephyrEngine = await zephyr_engine_defer;
                         await rollbackPartialAssetMapClaimBatch(zephyrEngine.application_uid, partialClaims.map(({ claimId })=>claimId));
                     } catch (restoreError) {
-                        handleGlobalError(restoreError);
+                        logFn('error', ZephyrError.format(restoreError));
                     }
                     handleGlobalError(error);
                 }
             }
         }
     };
+    return [
+        plugin,
+        buildAppStart
+    ];
 }
 function withZephyr(options = {}) {
     if (void 0 !== options.target) assertZephyrBuildTarget(options.target, 'withZephyr({ target })');
@@ -633,7 +778,7 @@ function withZephyr(options = {}) {
         const preservesLockedArtifactPaths = 'tap-app' === options.target;
         for (const mfConfig of mfConfigs)plugins.push(...federation(preservesLockedArtifactPaths ? mfConfig : ensureRuntimePlugin(mfConfig)));
     }
-    plugins.push(withZephyrCore(options));
+    plugins.push(...withZephyrCore(options));
     return plugins;
 }
 export { withZephyr };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/vitejs/vite-plugin-registry/refs/heads/main/data/schema/extended-package-json.schema.json",
   "name": "vite-plugin-zephyr",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Vite plugin for Zephyr",
   "keywords": [
     "deploy",
@@ -51,7 +51,7 @@
     "acorn": "^8.18.0",
     "acorn-walk": "^8.3.5",
     "magic-string": "1.2.3",
-    "zephyr-agent": "1.3.0"
+    "zephyr-agent": "1.4.1"
   },
   "devDependencies": {
     "@module-federation/vite": "1.21.2",

package/dist/rslib-runtime~0.mjs

@@ -1,21 +0,0 @@
-import "node:module";
-var __webpack_modules__ = {};
-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__.m = __webpack_modules__;
-(()=>{
-    __webpack_require__.add = function(modules) {
-        Object.assign(__webpack_require__.m, modules);
-    };
-})();
-export { __webpack_require__ };
-
-//# sourceMappingURL=rslib-runtime~0.mjs.map