vite-plugin-zephyr 1.1.2 → 1.2.0

package/README.md

@@ -56,6 +56,50 @@ export default defineConfig({
 });
 ```
 
+### Multi-Environment and SSR Builds
+
+Vite 6, 7, and 8 environment builds are collected across `client`, `server`, RSC, or custom
+child environments and published once after `buildApp` completes. The plugin validates
+that each current environment contributed output; persisted partial-build contributions
+are merged atomically. Vite 5 and watch builds use the direct single-environment upload
+path.
+
+```typescript
+withZephyr({
+  snapshotType: 'ssr',
+  entrypoint: 'server/index.mjs',
+});
+```
+
+- `snapshotType` overrides automatic CSR/SSR detection.
+- `entrypoint` is relative to the shared snapshot root and is required when an SSR entry
+  cannot be inferred.
+
+For intentionally separate Vite invocations, use `withZephyrPartial()` in producer
+configs and `withZephyr()` in the final config. Give every producer and finalizer the
+same `invocationId` (or set `ZE_BUILD_INVOCATION_ID`). To derive that identity from a
+supported CI job, explicitly pass `partialBuild: {}` to the finalizer; an ordinary
+`withZephyr()` build ignores ambient CI metadata. The plugin fails closed when a producer
+has no shared build identity. Partial maps are isolated by invocation and generation,
+protected by an inter-process lock, and claimed transactionally. Commit removes only
+unchanged claimed revisions, while rollback releases the claim without overwriting a
+newer concurrent write.
+
+```typescript
+withZephyrPartial({ invocationId: process.env.BUILD_ID });
+withZephyr({ partialBuild: { invocationId: process.env.BUILD_ID } });
+```
+
+For builds with no user-defined `base`, the plugin defaults Vite to `./`. Relative build
+asset URLs work for hostname deployments and allow Zephyr to add a path prefix later.
+Explicit bases are preserved; an origin-absolute base such as `/docs/` produces a warning
+when the application or one of its environments uses path addressing because that URL
+cannot be relocated under another prefix.
+
+This build-time default does not by itself make deep SSR/RSC routes prefix-aware. Runtime
+HTML generation must still resolve asset URLs against the request/deployment base. The
+specialized TanStack Start and Vinext plugins coordinate that runtime output separately.
+
 ### With Module Federation
 
 For microfrontend applications using Module Federation:
@@ -157,7 +201,7 @@ Add these scripts to your `package.json`:
 
 ## Requirements
 
-- Vite 5.x, 6.x, or 7.x
+- Vite 5.x, 6.x, 7.x, or 8.x
 - Rollup 4.x
 - Node.js version supported by your Vite toolchain
 - Zephyr Cloud account (sign up at [zephyr-cloud.io](https://zephyr-cloud.io))

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+export { withZephyr } from './lib/vite-plugin-zephyr.mjs';
+export { withZephyrPartial } from './lib/vite-plugin-zephyr-partial.mjs';
+export type { WithZephyrOptions } from './lib/vite-plugin-zephyr.mjs';
+export type { VitePartialBuildOptions } from './lib/internal/partial-build-scope.mjs';
+export type { ModuleFederationOptions } from './lib/internal/mf-vite-etl/ensure_runtime_plugin.mjs';
+export type { ZephyrBuildHooks, DeploymentInfo } from 'zephyr-agent';
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.ts

@@ -1,3 +1,7 @@
 export { withZephyr } from './lib/vite-plugin-zephyr';
 export { withZephyrPartial } from './lib/vite-plugin-zephyr-partial';
+export type { WithZephyrOptions } from './lib/vite-plugin-zephyr';
+export type { VitePartialBuildOptions } from './lib/internal/partial-build-scope';
+export type { ModuleFederationOptions } from './lib/internal/mf-vite-etl/ensure_runtime_plugin';
 export type { ZephyrBuildHooks, DeploymentInfo } from 'zephyr-agent';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,8 +1,46 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withZephyrPartial = exports.withZephyr = void 0;
-var vite_plugin_zephyr_1 = require("./lib/vite-plugin-zephyr");
-Object.defineProperty(exports, "withZephyr", { enumerable: true, get: function () { return vite_plugin_zephyr_1.withZephyr; } });
-var vite_plugin_zephyr_partial_1 = require("./lib/vite-plugin-zephyr-partial");
-Object.defineProperty(exports, "withZephyrPartial", { enumerable: true, get: function () { return vite_plugin_zephyr_partial_1.withZephyrPartial; } });
+var __webpack_require__ = {};
+(()=>{
+    __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'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    withZephyr: ()=>vite_plugin_zephyr_js_namespaceObject.withZephyr,
+    withZephyrPartial: ()=>vite_plugin_zephyr_partial_js_namespaceObject.withZephyrPartial
+});
+const vite_plugin_zephyr_js_namespaceObject = require("./lib/vite-plugin-zephyr.js");
+const vite_plugin_zephyr_partial_js_namespaceObject = require("./lib/vite-plugin-zephyr-partial.js");
+exports.withZephyr = __webpack_exports__.withZephyr;
+exports.withZephyrPartial = __webpack_exports__.withZephyrPartial;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "withZephyr",
+    "withZephyrPartial"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
 //# sourceMappingURL=index.js.map

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export { withZephyr } from "./lib/vite-plugin-zephyr.mjs";
+export { withZephyrPartial } from "./lib/vite-plugin-zephyr-partial.mjs";

package/dist/lib/internal/extract/extract-entrypoint.d.mts

@@ -0,0 +1,11 @@
+import type { ResolvedConfig } from 'vite' with { 'resolution-mode': 'import' };
+/**
+ * Extracts and normalizes the entrypoint from Vite config.
+ *
+ * Priority order:
+ *
+ * 1. Config.build.rollupOptions.input (auto-detected)
+ * 2. 'index.html' (Vite default)
+ */
+export declare function extractEntrypoint(config: ResolvedConfig): string;
+//# sourceMappingURL=extract-entrypoint.d.mts.map

package/dist/lib/internal/extract/extract-entrypoint.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedConfig } from 'vite';
+import type { ResolvedConfig } from 'vite' with { 'resolution-mode': 'import' };
 /**
  * Extracts and normalizes the entrypoint from Vite config.
  *
@@ -8,3 +8,4 @@ import type { ResolvedConfig } from 'vite';
  * 2. 'index.html' (Vite default)
  */
 export declare function extractEntrypoint(config: ResolvedConfig): string;
+//# sourceMappingURL=extract-entrypoint.d.ts.map

package/dist/lib/internal/extract/extract-entrypoint.js

@@ -1,54 +1,69 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractEntrypoint = extractEntrypoint;
-const zephyr_agent_1 = require("zephyr-agent");
-const normalize_entrypoint_1 = require("../utils/normalize-entrypoint");
-/**
- * Extracts and normalizes the entrypoint from Vite config.
- *
- * Priority order:
- *
- * 1. Config.build.rollupOptions.input (auto-detected)
- * 2. 'index.html' (Vite default)
- */
+var __webpack_require__ = {};
+(()=>{
+    __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'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    extractEntrypoint: ()=>extractEntrypoint
+});
+const external_zephyr_agent_namespaceObject = require("zephyr-agent");
+const normalize_entrypoint_js_namespaceObject = require("../utils/normalize-entrypoint.js");
 function extractEntrypoint(config) {
-    var _a, _b;
-    // Priority 1: Extract from Vite config
-    const input = (_b = (_a = config.build) === null || _a === void 0 ? void 0 : _a.rollupOptions) === null || _b === void 0 ? void 0 : _b.input;
+    const input = config.build?.rollupOptions?.input;
     if (input) {
-        // Case: String input (e.g., 'index.html')
-        if (typeof input === 'string') {
-            zephyr_agent_1.ze_log.init(`Detected entrypoint from Vite config: ${input}`);
-            return (0, normalize_entrypoint_1.normalizeEntrypoint)(input);
+        if ('string' == typeof input) {
+            external_zephyr_agent_namespaceObject.ze_log.init(`Detected entrypoint from Vite config: ${input}`);
+            return (0, normalize_entrypoint_js_namespaceObject.normalizeEntrypoint)(input);
         }
-        // Case: Object with multiple entries (e.g., { main: 'index.html', admin: 'admin.html' })
-        if (typeof input === 'object' && !Array.isArray(input)) {
+        if ('object' == typeof input && !Array.isArray(input)) {
             const entries = Object.entries(input);
             if (entries.length > 0) {
                 const [firstKey, firstValue] = entries[0];
-                if (entries.length > 1) {
-                    zephyr_agent_1.ze_log.init(`Multiple entrypoints detected (${entries.length}). Using first: ${firstKey} -> ${firstValue}`);
-                }
-                else {
-                    zephyr_agent_1.ze_log.init(`Detected entrypoint from Vite config: ${firstKey} -> ${firstValue}`);
-                }
-                return (0, normalize_entrypoint_1.normalizeEntrypoint)(String(firstValue));
+                if (entries.length > 1) external_zephyr_agent_namespaceObject.ze_log.init(`Multiple entrypoints detected (${entries.length}). Using first: ${firstKey} -> ${firstValue}`);
+                else external_zephyr_agent_namespaceObject.ze_log.init(`Detected entrypoint from Vite config: ${firstKey} -> ${firstValue}`);
+                return (0, normalize_entrypoint_js_namespaceObject.normalizeEntrypoint)(String(firstValue));
             }
         }
-        // Case: Array input (rare, but possible)
         if (Array.isArray(input) && input.length > 0) {
             const firstEntry = input[0];
-            if (input.length > 1) {
-                zephyr_agent_1.ze_log.init(`Multiple entrypoints detected (${input.length}). Using first: ${firstEntry}`);
-            }
-            else {
-                zephyr_agent_1.ze_log.init(`Detected entrypoint from Vite config: ${firstEntry}`);
-            }
-            return (0, normalize_entrypoint_1.normalizeEntrypoint)(String(firstEntry));
+            if (input.length > 1) external_zephyr_agent_namespaceObject.ze_log.init(`Multiple entrypoints detected (${input.length}). Using first: ${firstEntry}`);
+            else external_zephyr_agent_namespaceObject.ze_log.init(`Detected entrypoint from Vite config: ${firstEntry}`);
+            return (0, normalize_entrypoint_js_namespaceObject.normalizeEntrypoint)(String(firstEntry));
         }
     }
-    // Priority 2: Default fallback
-    zephyr_agent_1.ze_log.init('No entrypoint specified, using Vite default: index.html');
+    external_zephyr_agent_namespaceObject.ze_log.init('No entrypoint specified, using Vite default: index.html');
     return 'index.html';
 }
+exports.extractEntrypoint = __webpack_exports__.extractEntrypoint;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extractEntrypoint"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
 //# sourceMappingURL=extract-entrypoint.js.map

package/dist/lib/internal/extract/extract-entrypoint.mjs

@@ -0,0 +1,32 @@
+import "node:module";
+import { ze_log } from "zephyr-agent";
+import { normalizeEntrypoint } from "../utils/normalize-entrypoint.mjs";
+function extractEntrypoint(config) {
+    const input = config.build?.rollupOptions?.input;
+    if (input) {
+        if ('string' == typeof input) {
+            ze_log.init(`Detected entrypoint from Vite config: ${input}`);
+            return normalizeEntrypoint(input);
+        }
+        if ('object' == typeof input && !Array.isArray(input)) {
+            const entries = Object.entries(input);
+            if (entries.length > 0) {
+                const [firstKey, firstValue] = entries[0];
+                if (entries.length > 1) ze_log.init(`Multiple entrypoints detected (${entries.length}). Using first: ${firstKey} -> ${firstValue}`);
+                else ze_log.init(`Detected entrypoint from Vite config: ${firstKey} -> ${firstValue}`);
+                return normalizeEntrypoint(String(firstValue));
+            }
+        }
+        if (Array.isArray(input) && input.length > 0) {
+            const firstEntry = input[0];
+            if (input.length > 1) ze_log.init(`Multiple entrypoints detected (${input.length}). Using first: ${firstEntry}`);
+            else ze_log.init(`Detected entrypoint from Vite config: ${firstEntry}`);
+            return normalizeEntrypoint(String(firstEntry));
+        }
+    }
+    ze_log.init('No entrypoint specified, using Vite default: index.html');
+    return 'index.html';
+}
+export { extractEntrypoint };
+
+//# sourceMappingURL=extract-entrypoint.mjs.map

package/dist/lib/internal/extract/extract_mf_plugin.d.mts

@@ -0,0 +1,10 @@
+import type { Plugin, PluginOption } from 'vite' with {
+    'resolution-mode': 'import'
+};
+import type { ModuleFederationOptions } from '../mf-vite-etl/ensure_runtime_plugin.mjs';
+export interface ViteMFPlugin {
+    _options: ModuleFederationOptions;
+}
+export declare function extract_mf_plugins(plugins: readonly PluginOption[]): Array<Plugin & ViteMFPlugin>;
+export declare function extract_mf_plugin(plugins: readonly PluginOption[]): Plugin<any> & ViteMFPlugin;
+//# sourceMappingURL=extract_mf_plugin.d.mts.map

package/dist/lib/internal/extract/extract_mf_plugin.d.ts

@@ -1,6 +1,10 @@
-import type { Plugin, PluginOption } from 'vite';
+import type { Plugin, PluginOption } from 'vite' with {
+    'resolution-mode': 'import'
+};
 import type { ModuleFederationOptions } from '../mf-vite-etl/ensure_runtime_plugin';
 export interface ViteMFPlugin {
     _options: ModuleFederationOptions;
 }
-export declare function extract_mf_plugin(plugins: readonly PluginOption[]): (Plugin & ViteMFPlugin) | undefined;
+export declare function extract_mf_plugins(plugins: readonly PluginOption[]): Array<Plugin & ViteMFPlugin>;
+export declare function extract_mf_plugin(plugins: readonly PluginOption[]): Plugin<any> & ViteMFPlugin;
+//# sourceMappingURL=extract_mf_plugin.d.ts.map

package/dist/lib/internal/extract/extract_mf_plugin.js

@@ -1,14 +1,57 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract_mf_plugin = extract_mf_plugin;
+var __webpack_require__ = {};
+(()=>{
+    __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'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
 function isPlugin(plugin) {
-    return !!plugin && typeof plugin === 'object' && 'name' in plugin;
+    return !!plugin && 'object' == typeof plugin && 'name' in plugin;
 }
 function flattenPlugins(plugins) {
-    const flatPlugins = plugins.flat(Infinity);
+    const flatPlugins = plugins.flat(1 / 0);
     return flatPlugins.filter(isPlugin);
 }
+function extract_mf_plugins(plugins) {
+    return flattenPlugins(plugins).filter((plugin)=>'module-federation-vite' === plugin.name && '_options' in plugin && !!plugin._options);
+}
 function extract_mf_plugin(plugins) {
-    return flattenPlugins(plugins).find((plugin) => plugin.name === 'module-federation-vite');
+    return extract_mf_plugins(plugins)[0];
 }
+__webpack_require__.d(__webpack_exports__, {
+    extract_mf_plugin: ()=>extract_mf_plugin,
+    extract_mf_plugins: ()=>extract_mf_plugins
+});
+exports.extract_mf_plugin = __webpack_exports__.extract_mf_plugin;
+exports.extract_mf_plugins = __webpack_exports__.extract_mf_plugins;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extract_mf_plugin",
+    "extract_mf_plugins"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
 //# sourceMappingURL=extract_mf_plugin.js.map

package/dist/lib/internal/extract/extract_mf_plugin.mjs

@@ -0,0 +1,17 @@
+import "node:module";
+function isPlugin(plugin) {
+    return !!plugin && 'object' == typeof plugin && 'name' in plugin;
+}
+function flattenPlugins(plugins) {
+    const flatPlugins = plugins.flat(1 / 0);
+    return flatPlugins.filter(isPlugin);
+}
+function extract_mf_plugins(plugins) {
+    return flattenPlugins(plugins).filter((plugin)=>'module-federation-vite' === plugin.name && '_options' in plugin && !!plugin._options);
+}
+function extract_mf_plugin(plugins) {
+    return extract_mf_plugins(plugins)[0];
+}
+export { extract_mf_plugin, extract_mf_plugins };
+
+//# sourceMappingURL=extract_mf_plugin.mjs.map

package/dist/lib/internal/extract/extract_vite_assets_map.d.mts

@@ -0,0 +1,4 @@
+import { type ZeBuildAssetsMap, type ZephyrEngine } from 'zephyr-agent';
+import type { ZephyrInternalOptions } from '../types/zephyr-internal-options.mjs';
+export declare function extract_vite_assets_map(_zephyr_engine: ZephyrEngine, vite_internal_options: ZephyrInternalOptions): Promise<ZeBuildAssetsMap>;
+//# sourceMappingURL=extract_vite_assets_map.d.mts.map

package/dist/lib/internal/extract/extract_vite_assets_map.d.ts

@@ -1,3 +1,4 @@
 import { type ZeBuildAssetsMap, type ZephyrEngine } from 'zephyr-agent';
 import type { ZephyrInternalOptions } from '../types/zephyr-internal-options';
-export declare function extract_vite_assets_map(zephyr_engine: ZephyrEngine, vite_internal_options: ZephyrInternalOptions): Promise<ZeBuildAssetsMap>;
+export declare function extract_vite_assets_map(_zephyr_engine: ZephyrEngine, vite_internal_options: ZephyrInternalOptions): Promise<ZeBuildAssetsMap>;
+//# sourceMappingURL=extract_vite_assets_map.d.ts.map

package/dist/lib/internal/extract/extract_vite_assets_map.js

@@ -1,56 +1,86 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract_vite_assets_map = extract_vite_assets_map;
-const zephyr_agent_1 = require("zephyr-agent");
-const load_static_assets_1 = require("./load_static_assets");
-async function extract_vite_assets_map(zephyr_engine, vite_internal_options) {
-    const application_uid = zephyr_engine.application_uid;
-    const assets = await (0, load_static_assets_1.loadStaticAssets)(vite_internal_options);
-    const partialAssetMap = await (0, zephyr_agent_1.getPartialAssetMap)(application_uid);
-    await (0, zephyr_agent_1.removePartialAssetMap)(application_uid);
+var __webpack_require__ = {};
+(()=>{
+    __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'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    extract_vite_assets_map: ()=>extract_vite_assets_map
+});
+const external_zephyr_agent_namespaceObject = require("zephyr-agent");
+const external_load_static_assets_js_namespaceObject = require("./load_static_assets.js");
+const external_merge_vite_output_assets_js_namespaceObject = require("./merge_vite_output_assets.js");
+async function extract_vite_assets_map(_zephyr_engine, vite_internal_options) {
+    const assets = await (0, external_load_static_assets_js_namespaceObject.loadStaticAssets)(vite_internal_options);
     const runtime_assets = vite_internal_options.assets;
-    const complete_assets = Object.assign({}, assets, ...Object.values(partialAssetMap !== null && partialAssetMap !== void 0 ? partialAssetMap : {}), runtime_assets);
-    const filtered_assets = Object.fromEntries(Object.entries(complete_assets)
-        .map(toRollupOutputEntry)
-        .filter((entry) => entry !== null));
-    return (0, zephyr_agent_1.buildAssetsMap)(filtered_assets, extractBuffer, getAssetType);
+    const complete_assets = {
+        ...assets
+    };
+    (0, external_merge_vite_output_assets_js_namespaceObject.mergeViteOutputAssets)(complete_assets, Object.entries(runtime_assets ?? {}), {
+        target: vite_internal_options.target
+    });
+    const filtered_assets = Object.fromEntries(Object.entries(complete_assets).map(toRollupOutputEntry).filter((entry)=>null !== entry));
+    return (0, external_zephyr_agent_namespaceObject.buildAssetsMap)(filtered_assets, extractBuffer, getAssetType);
 }
 function shouldSkipAsset(assetPath) {
     return /(^|\/)\.vite-inspect(\/|$)/.test(assetPath);
 }
-function isRollupOutput(asset) {
-    if (!asset || typeof asset !== 'object' || !('type' in asset)) {
-        return false;
-    }
-    return asset.type === 'chunk' || asset.type === 'asset';
+function isBundlerOutput(asset) {
+    if (!asset || 'object' != typeof asset || !('type' in asset)) return false;
+    if ('chunk' === asset.type) return 'code' in asset && 'string' == typeof asset.code;
+    if ('asset' === asset.type && 'source' in asset) return 'string' == typeof asset.source || asset.source instanceof Uint8Array;
+    return false;
 }
 function toRollupOutputEntry([assetPath, asset]) {
-    if (shouldSkipAsset(assetPath) || !isRollupOutput(asset)) {
-        return null;
-    }
-    return [assetPath, asset];
+    if (shouldSkipAsset(assetPath) || !isBundlerOutput(asset)) return null;
+    return [
+        assetPath,
+        asset
+    ];
 }
 function getAssetType(asset) {
     return asset.type;
 }
-/**
- * Extracts buffer content from Rollup assets.
- *
- * @param asset - Output chunk or asset from Rollup
- * @returns String for text-based chunks, Buffer for binary assets, undefined for unknown
- *   types
- */
 function extractBuffer(asset) {
-    switch (asset.type) {
+    switch(asset.type){
         case 'chunk':
             return asset.code;
         case 'asset':
-            if (typeof asset.source === 'string') {
-                return asset.source;
-            }
+            if ('string' == typeof asset.source) return asset.source;
             return Buffer.from(asset.source);
         default:
-            return undefined;
+            return;
     }
 }
+exports.extract_vite_assets_map = __webpack_exports__.extract_vite_assets_map;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extract_vite_assets_map"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
 //# sourceMappingURL=extract_vite_assets_map.js.map

package/dist/lib/internal/extract/extract_vite_assets_map.mjs

@@ -0,0 +1,49 @@
+import "node:module";
+import { buildAssetsMap } from "zephyr-agent";
+import { loadStaticAssets } from "./load_static_assets.mjs";
+import { mergeViteOutputAssets } from "./merge_vite_output_assets.mjs";
+async function extract_vite_assets_map(_zephyr_engine, vite_internal_options) {
+    const assets = await loadStaticAssets(vite_internal_options);
+    const runtime_assets = vite_internal_options.assets;
+    const complete_assets = {
+        ...assets
+    };
+    mergeViteOutputAssets(complete_assets, Object.entries(runtime_assets ?? {}), {
+        target: vite_internal_options.target
+    });
+    const filtered_assets = Object.fromEntries(Object.entries(complete_assets).map(toRollupOutputEntry).filter((entry)=>null !== entry));
+    return buildAssetsMap(filtered_assets, extractBuffer, getAssetType);
+}
+function shouldSkipAsset(assetPath) {
+    return /(^|\/)\.vite-inspect(\/|$)/.test(assetPath);
+}
+function isBundlerOutput(asset) {
+    if (!asset || 'object' != typeof asset || !('type' in asset)) return false;
+    if ('chunk' === asset.type) return 'code' in asset && 'string' == typeof asset.code;
+    if ('asset' === asset.type && 'source' in asset) return 'string' == typeof asset.source || asset.source instanceof Uint8Array;
+    return false;
+}
+function toRollupOutputEntry([assetPath, asset]) {
+    if (shouldSkipAsset(assetPath) || !isBundlerOutput(asset)) return null;
+    return [
+        assetPath,
+        asset
+    ];
+}
+function getAssetType(asset) {
+    return asset.type;
+}
+function extractBuffer(asset) {
+    switch(asset.type){
+        case 'chunk':
+            return asset.code;
+        case 'asset':
+            if ('string' == typeof asset.source) return asset.source;
+            return Buffer.from(asset.source);
+        default:
+            return;
+    }
+}
+export { extract_vite_assets_map };
+
+//# sourceMappingURL=extract_vite_assets_map.mjs.map

package/dist/lib/internal/extract/load_public_dir.d.mts

@@ -0,0 +1,10 @@
+import { type ZephyrBuildTarget } from 'zephyr-agent';
+import type { ZephyrOutputAsset } from '../types/zephyr-output.mjs';
+interface LoadPublicDirOptions {
+    outDir: string;
+    publicDir: string;
+    target?: ZephyrBuildTarget;
+}
+export declare function load_public_dir({ publicDir, outDir, target, }: LoadPublicDirOptions): Promise<ZephyrOutputAsset[]>;
+export {};
+//# sourceMappingURL=load_public_dir.d.mts.map

package/dist/lib/internal/extract/load_public_dir.d.ts

@@ -1,7 +1,10 @@
-import type { OutputAsset } from 'rollup';
+import { type ZephyrBuildTarget } from 'zephyr-agent';
+import type { ZephyrOutputAsset } from '../types/zephyr-output';
 interface LoadPublicDirOptions {
     outDir: string;
     publicDir: string;
+    target?: ZephyrBuildTarget;
 }
-export declare function load_public_dir({ publicDir, outDir, }: LoadPublicDirOptions): Promise<OutputAsset[]>;
+export declare function load_public_dir({ publicDir, outDir, target, }: LoadPublicDirOptions): Promise<ZephyrOutputAsset[]>;
 export {};
+//# sourceMappingURL=load_public_dir.d.ts.map