rwsdk 0.2.0 → 0.3.1

package/dist/vite/createViteAwareResolver.mjs

@@ -0,0 +1,208 @@
+import resolve from "enhanced-resolve";
+import fs from "fs";
+import path from "path";
+import createDebug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+const debug = createDebug("rwsdk:vite:enhanced-resolve-plugin");
+// Enhanced-resolve plugin that wraps Vite plugin resolution
+class VitePluginResolverPlugin {
+    constructor(environment, source = "resolve", target = "resolved") {
+        this.environment = environment;
+        this.source = source;
+        this.target = target;
+        // Create an enhanced-resolve instance for the plugin context
+        const baseOptions = mapViteResolveToEnhancedResolveOptions(this.environment.config, this.environment.name);
+        this.enhancedResolver = resolve.create(baseOptions);
+    }
+    apply(resolver) {
+        const target = resolver.ensureHook(this.target);
+        resolver
+            .getHook(this.source)
+            .tapAsync("VitePluginResolverPlugin", (request, resolveContext, callback) => {
+            const plugins = this.environment?.plugins;
+            if (!plugins) {
+                return callback();
+            }
+            // Create a plugin context with enhanced-resolve-based resolve method
+            const pluginContext = {
+                environment: this.environment,
+                resolve: async (id, importer) => {
+                    return new Promise((resolve) => {
+                        this.enhancedResolver({}, importer || this.environment.config.root, id, {}, (err, result) => {
+                            if (!err && result) {
+                                debug("Context resolve: %s -> %s", id, result);
+                                resolve({ id: result });
+                            }
+                            else {
+                                debug("Context resolve failed for %s: %s", id, err?.message || "not found");
+                                resolve(null);
+                            }
+                        });
+                    });
+                },
+            };
+            debug("Trying to resolve %s from %s", request.request, request.path);
+            // This function encapsulates the logic to process Vite plugins for a given request.
+            const runPluginProcessing = async (currentRequest) => {
+                debug("Available plugins:", plugins.map((p) => p.name));
+                for (const plugin of plugins) {
+                    const resolveIdHandler = plugin.resolveId;
+                    if (!resolveIdHandler)
+                        continue;
+                    let handlerFn;
+                    if (typeof resolveIdHandler === "function") {
+                        handlerFn = resolveIdHandler;
+                    }
+                    else if (typeof resolveIdHandler === "object" &&
+                        typeof resolveIdHandler.handler === "function") {
+                        handlerFn = resolveIdHandler.handler;
+                    }
+                    if (!handlerFn)
+                        continue;
+                    try {
+                        debug("Calling plugin '%s' for '%s'", plugin.name, currentRequest.request);
+                        const result = await handlerFn.call(pluginContext, currentRequest.request, currentRequest.path, { scan: true });
+                        debug("Plugin '%s' returned:", plugin.name, result);
+                        if (!result)
+                            continue;
+                        const resolvedId = typeof result === "string" ? result : result.id;
+                        if (resolvedId && resolvedId !== currentRequest.request) {
+                            debug("Plugin '%s' resolved '%s' -> '%s'", plugin.name, currentRequest.request, resolvedId);
+                            return callback(null, {
+                                ...currentRequest,
+                                path: resolvedId,
+                            });
+                        }
+                        else if (resolvedId === currentRequest.request) {
+                            debug("Plugin '%s' returned unchanged ID, continuing to next plugin", plugin.name);
+                        }
+                    }
+                    catch (e) {
+                        debug("Plugin '%s' failed while resolving '%s': %s", plugin.name, currentRequest.request, e.message);
+                    }
+                }
+                // If no plugin resolves, fall back to enhanced-resolve's default behavior
+                debug("No Vite plugin resolved '%s', falling back.", currentRequest.request);
+                // For absolute paths, check if the file exists
+                if (path.isAbsolute(currentRequest.request)) {
+                    try {
+                        if (fs.existsSync(currentRequest.request)) {
+                            debug("File exists, resolving to: %s", currentRequest.request);
+                            return callback(null, {
+                                ...currentRequest,
+                                path: currentRequest.request,
+                            });
+                        }
+                    }
+                    catch (e) {
+                        debug("Error checking file existence: %s", e.message);
+                    }
+                }
+                callback();
+            };
+            // For relative imports, normalize them to absolute paths first
+            if (request.request.startsWith("../") ||
+                request.request.startsWith("./")) {
+                try {
+                    // Use path.dirname to get the directory of the importer file
+                    const importerDir = path.dirname(request.path);
+                    const absolutePath = normalizeModulePath(request.request, importerDir, { absolute: true });
+                    debug("Absolutified %s -> %s", request.request, absolutePath);
+                    const absoluteRequest = { ...request, request: absolutePath };
+                    runPluginProcessing(absoluteRequest).catch((e) => {
+                        debug("Error in plugin processing: %s", e.message);
+                        callback();
+                    });
+                }
+                catch (e) {
+                    debug("Failed to absolutify %s: %s", request.request, e.message);
+                    callback();
+                }
+            }
+            else {
+                // For non-relative imports, process them directly
+                runPluginProcessing(request).catch((e) => {
+                    debug("Error in plugin processing: %s", e.message);
+                    callback();
+                });
+            }
+        });
+    }
+}
+const mapAlias = (alias) => {
+    const mappedAlias = {};
+    if (Array.isArray(alias)) {
+        // Handle array format: { find: string | RegExp, replacement: string }
+        for (const { find, replacement } of alias) {
+            if (find instanceof RegExp) {
+                // For RegExp, use the source as-is
+                mappedAlias[find.source] = replacement;
+            }
+            else {
+                // For string aliases, use them as-is without modification
+                mappedAlias[find] = replacement;
+            }
+        }
+    }
+    else {
+        // Handle object format: { [find: string]: replacement }
+        for (const [find, replacement] of Object.entries(alias)) {
+            // Use the alias key as-is without modification
+            mappedAlias[find] = replacement;
+        }
+    }
+    return mappedAlias;
+};
+export const mapViteResolveToEnhancedResolveOptions = (viteConfig, envName) => {
+    const env = viteConfig.environments[envName];
+    if (!env) {
+        throw new Error(`Could not find environment configuration for "${envName}".`);
+    }
+    const envResolveOptions = (env.resolve || {});
+    // Merge root config aliases with environment-specific aliases
+    const mergedAlias = {
+        ...(viteConfig.resolve?.alias ? mapAlias(viteConfig.resolve.alias) : {}),
+        ...(envResolveOptions.alias ? mapAlias(envResolveOptions.alias) : {}),
+    };
+    // Use comprehensive extensions list similar to Vite's defaults
+    const extensions = envResolveOptions.extensions || [
+        ".mjs",
+        ".js",
+        ".mts",
+        ".ts",
+        ".jsx",
+        ".tsx",
+        ".json",
+    ];
+    const baseOptions = {
+        // File system is required by enhanced-resolve.
+        fileSystem: fs,
+        // Map Vite's resolve options to enhanced-resolve's options.
+        alias: Object.keys(mergedAlias).length > 0 ? mergedAlias : undefined,
+        conditionNames: envResolveOptions.conditions,
+        mainFields: envResolveOptions.mainFields,
+        extensions,
+        symlinks: envResolveOptions.preserveSymlinks,
+        // Add default node modules resolution.
+        modules: ["node_modules"],
+        roots: [viteConfig.root],
+    };
+    return baseOptions;
+};
+export const createViteAwareResolver = (viteConfig, envName, environment) => {
+    const baseOptions = mapViteResolveToEnhancedResolveOptions(viteConfig, envName);
+    // Add Vite plugin resolver if environment is provided
+    const plugins = environment
+        ? [new VitePluginResolverPlugin(environment)]
+        : [];
+    const enhancedResolveOptions = {
+        ...baseOptions,
+        plugins,
+    };
+    debug("Creating enhanced-resolve with options:", {
+        extensions: enhancedResolveOptions.extensions,
+        alias: enhancedResolveOptions.alias,
+        roots: enhancedResolveOptions.roots,
+    });
+    return resolve.create(enhancedResolveOptions);
+};

package/dist/vite/directiveModulesDevPlugin.d.mts

@@ -0,0 +1,8 @@
+import { Plugin } from "vite";
+export declare const VIRTUAL_CLIENT_BARREL_ID = "virtual:rwsdk:client-module-barrel";
+export declare const VIRTUAL_SERVER_BARREL_ID = "virtual:rwsdk:server-module-barrel";
+export declare const directiveModulesDevPlugin: ({ clientFiles, serverFiles, projectRootDir, }: {
+    clientFiles: Set<string>;
+    serverFiles: Set<string>;
+    projectRootDir: string;
+}) => Plugin;

package/dist/vite/directiveModulesDevPlugin.mjs

@@ -0,0 +1,87 @@
+import path from "path";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+import { CLIENT_BARREL_PATH, SERVER_BARREL_PATH } from "../lib/constants.mjs";
+import { runDirectivesScan } from "./runDirectivesScan.mjs";
+export const VIRTUAL_CLIENT_BARREL_ID = "virtual:rwsdk:client-module-barrel";
+export const VIRTUAL_SERVER_BARREL_ID = "virtual:rwsdk:server-module-barrel";
+const CLIENT_BARREL_EXPORT_PATH = "rwsdk/__client_barrel";
+const SERVER_BARREL_EXPORT_PATH = "rwsdk/__server_barrel";
+const generateBarrelContent = (files, projectRootDir) => {
+    const imports = [...files]
+        .filter((file) => file.includes("node_modules"))
+        .map((file, i) => `import * as M${i} from '${normalizeModulePath(file, projectRootDir, {
+        absolute: true,
+    })}';`)
+        .join("\n");
+    const exports = "export default {\n" +
+        [...files]
+            .filter((file) => file.includes("node_modules"))
+            .map((file, i) => `  '${normalizeModulePath(file, projectRootDir)}': M${i},`)
+            .join("\n") +
+        "\n};";
+    return `${imports}\n\n${exports}`;
+};
+export const directiveModulesDevPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+    let scanPromise = null;
+    return {
+        name: "rwsdk:directive-modules-dev",
+        configureServer(server) {
+            if (!process.env.VITE_IS_DEV_SERVER || process.env.RWSDK_WORKER_RUN) {
+                return;
+            }
+            // Start the directive scan as soon as the server is configured.
+            // We don't await it here, allowing Vite to continue its startup.
+            scanPromise = runDirectivesScan({
+                rootConfig: server.config,
+                environment: server.environments.worker,
+                clientFiles,
+                serverFiles,
+            }).then(() => {
+                // After the scan is complete, write the barrel files.
+                const clientBarrelContent = generateBarrelContent(clientFiles, projectRootDir);
+                writeFileSync(CLIENT_BARREL_PATH, clientBarrelContent);
+                const serverBarrelContent = generateBarrelContent(serverFiles, projectRootDir);
+                writeFileSync(SERVER_BARREL_PATH, serverBarrelContent);
+            });
+            // context(justinvdm, 4 Sep 2025): Add middleware to block incoming
+            // requests until the scan is complete. This gives us a single hook for
+            // preventing app code being processed by vite until the scan is complete.
+            // This improves perceived startup time by not blocking Vite's optimizer.
+            server.middlewares.use(async (_req, _res, next) => {
+                if (scanPromise) {
+                    await scanPromise;
+                }
+                next();
+            });
+        },
+        configResolved(config) {
+            if (config.command !== "serve") {
+                return;
+            }
+            // Create dummy files to give esbuild a real path to resolve.
+            mkdirSync(path.dirname(CLIENT_BARREL_PATH), { recursive: true });
+            writeFileSync(CLIENT_BARREL_PATH, "");
+            mkdirSync(path.dirname(SERVER_BARREL_PATH), { recursive: true });
+            writeFileSync(SERVER_BARREL_PATH, "");
+            for (const [envName, env] of Object.entries(config.environments || {})) {
+                env.optimizeDeps ??= {};
+                env.optimizeDeps.include ??= [];
+                env.optimizeDeps.include.push(CLIENT_BARREL_EXPORT_PATH, SERVER_BARREL_EXPORT_PATH);
+                env.optimizeDeps.esbuildOptions ??= {};
+                env.optimizeDeps.esbuildOptions.plugins ??= [];
+                env.optimizeDeps.esbuildOptions.plugins.push({
+                    name: "rwsdk:block-optimizer-for-scan",
+                    setup(build) {
+                        build.onStart(async () => {
+                            // context(justinvdm, 4 Sep 2025): We await the scan promise
+                            // here because we want to block the optimizer until the scan is
+                            // complete.
+                            await scanPromise;
+                        });
+                    },
+                });
+            }
+        },
+    };
+};

package/dist/vite/directivesFilteringPlugin.d.mts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+export declare const directivesFilteringPlugin: ({ clientFiles, serverFiles, projectRootDir, }: {
+    clientFiles: Set<string>;
+    serverFiles: Set<string>;
+    projectRootDir: string;
+}) => Plugin;

package/dist/vite/directivesFilteringPlugin.mjs

@@ -0,0 +1,31 @@
+import debug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:directives-filtering-plugin");
+export const directivesFilteringPlugin = ({ clientFiles, serverFiles, projectRootDir, }) => {
+    return {
+        name: "rwsdk:directives-filtering",
+        enforce: "post",
+        async buildEnd() {
+            if (this.environment.name !== "worker" ||
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return;
+            }
+            log("Filtering directive modules after worker build...");
+            process.env.VERBOSE &&
+                log("Directive modules before filtering: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
+            [clientFiles, serverFiles].forEach((files) => {
+                for (const id of files) {
+                    const absoluteId = normalizeModulePath(id, projectRootDir, {
+                        absolute: true,
+                    });
+                    const info = this.getModuleInfo(absoluteId);
+                    if (!info?.isIncluded) {
+                        files.delete(id);
+                    }
+                }
+            });
+            process.env.VERBOSE &&
+                log("Client/server files after filtering: client=%O, server=%O", Array.from(clientFiles), Array.from(serverFiles));
+        },
+    };
+};

package/dist/vite/directivesPlugin.mjs

@@ -28,36 +28,12 @@ const getLoader = (filePath) => {
 export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, }) => {
     let devServer;
     let isAfterFirstResponse = false;
-    const addModule = (kind, environment, id) => {
-        const files = kind === "client" ? clientFiles : serverFiles;
-        const rawId = id.split("?")[0];
-        const resolvedId = normalizeModulePath(rawId, projectRootDir);
-        const fullPath = normalizeModulePath(rawId, projectRootDir, {
-            absolute: true,
-        });
-        const isNodeModule = id.includes("node_modules");
-        const hadFile = files.has(id);
-        log("Adding %s module to %s and invalidating cache: id=%s", kind, files, resolvedId);
-        files.add(resolvedId);
-        if (devServer && isNodeModule) {
-            const lookupModule = kind === "client"
-                ? "virtual:use-client-lookup"
-                : "virtual:use-server-lookup";
-            log("Registering missing import for %s module resolvedId=%s in environment %s, fullPath=%s", kind, resolvedId, environment, fullPath);
-            devServer.environments[environment].depsOptimizer?.registerMissingImport(resolvedId, fullPath);
-            if (isAfterFirstResponse && !hadFile) {
-                log("Invalidating cache for lookup module %s after adding module id=%s", lookupModule, id);
-            }
-        }
-    };
-    const addClientModule = (environment, id) => {
-        addModule("client", environment, id);
-    };
-    const addServerModule = (environment, id) => {
-        addModule("server", environment, id);
-    };
+    let isBuild = false;
     return {
         name: "rwsdk:rsc-directives",
+        configResolved(config) {
+            isBuild = config.command === "build";
+        },
         configureServer(server) {
             devServer = server;
             devServer.middlewares.use((_req, res, next) => {
@@ -76,33 +52,46 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
             });
         },
         async transform(code, id) {
-            process.env.VERBOSE &&
-                log("Transform called for id=%s, environment=%s", id, this.environment.name);
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
+            if (isBuild &&
+                this.environment?.name === "worker" &&
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return;
+            }
             const normalizedId = normalizeModulePath(id, projectRootDir);
             const clientResult = await transformClientComponents(code, normalizedId, {
                 environmentName: this.environment.name,
                 clientFiles,
-                addClientModule,
             });
             if (clientResult) {
-                log("Client component transformation successful for id=%s", id);
+                process.env.VERBOSE &&
+                    log("Client component transformation successful for id=%s", id);
                 return {
                     code: clientResult.code,
                     map: clientResult.map,
                 };
             }
-            const serverResult = transformServerFunctions(code, normalizedId, this.environment.name, serverFiles, addServerModule);
+            const serverResult = transformServerFunctions(code, normalizedId, this.environment.name, serverFiles);
             if (serverResult) {
-                log("Server function transformation successful for id=%s", id);
+                process.env.VERBOSE &&
+                    log("Server function transformation successful for id=%s", id);
                 return {
                     code: serverResult.code,
                     map: serverResult.map,
                 };
             }
-            process.env.VERBOSE && log("No transformation applied for id=%s", id);
+            // Removed: too noisy even in verbose mode
         },
         configEnvironment(env, config) {
-            log("Configuring environment: env=%s", env);
+            if (isBuild &&
+                env === "worker" &&
+                process.env.RWSDK_BUILD_PASS !== "worker") {
+                return;
+            }
+            process.env.VERBOSE && log("Configuring environment: env=%s", env);
             config.optimizeDeps ??= {};
             config.optimizeDeps.esbuildOptions ??= {};
             config.optimizeDeps.esbuildOptions.plugins ??= [];
@@ -120,7 +109,6 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                         // dependency discovery, so we can skip transform work
                         // and use heuristics instead - see below inside if block
                         if (!args.path.includes("node_modules")) {
-                            log("Esbuild onLoad found app code, path=%s", args.path);
                             if (clientFiles.has(normalizedPath)) {
                                 // context(justinvdm,2025-06-15): If this is a client file:
                                 // * for ssr and client envs we can skip so esbuild looks at the
@@ -171,10 +159,10 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                             environmentName: env,
                             clientFiles,
                             isEsbuild: true,
-                            addClientModule,
                         });
                         if (clientResult) {
-                            log("Esbuild client component transformation successful for environment=%s, path=%s", env, args.path);
+                            process.env.VERBOSE &&
+                                log("Esbuild client component transformation successful for environment=%s, path=%s", env, args.path);
                             process.env.VERBOSE &&
                                 log("Esbuild client component transformation for environment=%s, path=%s, code: %j", env, args.path, clientResult.code);
                             return {
@@ -182,9 +170,10 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                                 loader: getLoader(args.path),
                             };
                         }
-                        const serverResult = transformServerFunctions(code, normalizedPath, env, serverFiles, addServerModule);
+                        const serverResult = transformServerFunctions(code, normalizedPath, env, serverFiles);
                         if (serverResult) {
-                            log("Esbuild server function transformation successful for environment=%s, path=%s", env, args.path);
+                            process.env.VERBOSE &&
+                                log("Esbuild server function transformation successful for environment=%s, path=%s", env, args.path);
                             return {
                                 contents: serverResult.code,
                                 loader: getLoader(args.path),
@@ -195,7 +184,8 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                     });
                 },
             });
-            log("Environment configuration complete for env=%s", env);
+            process.env.VERBOSE &&
+                log("Environment configuration complete for env=%s", env);
         },
     };
 };

package/dist/vite/getViteEsbuild.d.mts

@@ -0,0 +1 @@
+export declare function getViteEsbuild(projectRootDir: string): Promise<any>;

package/dist/vite/getViteEsbuild.mjs

@@ -0,0 +1,12 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export async function getViteEsbuild(projectRootDir) {
+    const vitePath = require.resolve("vite/package.json", {
+        paths: [projectRootDir],
+    });
+    const viteDir = path.dirname(vitePath);
+    const esbuildPath = require.resolve("esbuild", { paths: [viteDir] });
+    const esbuildModule = await import(esbuildPath);
+    return esbuildModule.default || esbuildModule;
+}

package/dist/vite/injectVitePreamblePlugin.d.mts

@@ -1,4 +1,5 @@
 import { type Plugin } from "vite";
-export declare const injectVitePreamble: ({ clientEntryPathnames, }: {
-    clientEntryPathnames: string[];
+export declare const injectVitePreamble: ({ clientEntryPoints, projectRootDir, }: {
+    clientEntryPoints: Set<string>;
+    projectRootDir: string;
 }) => Plugin;

package/dist/vite/injectVitePreamblePlugin.mjs

@@ -1,12 +1,18 @@
 import MagicString from "magic-string";
-export const injectVitePreamble = ({ clientEntryPathnames, }) => ({
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+export const injectVitePreamble = ({ clientEntryPoints, projectRootDir, }) => ({
     name: "rwsdk:inject-vite-preamble",
     apply: "serve",
     transform(code, id) {
+        // Skip during directive scanning to avoid performance issues
+        if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+            return;
+        }
         if (this.environment.name !== "client") {
             return;
         }
-        if (!clientEntryPathnames.includes(id)) {
+        const normalizedId = normalizeModulePath(id, projectRootDir);
+        if (!clientEntryPoints.has(normalizedId)) {
             return;
         }
         // Only inject preamble in development mode

package/dist/vite/linkerPlugin.d.mts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+export declare const linkerPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
+}) => Plugin;

package/dist/vite/linkerPlugin.mjs

@@ -0,0 +1,41 @@
+import path from "node:path";
+import fsp from "node:fs/promises";
+import { CLIENT_MANIFEST_RELATIVE_PATH } from "../lib/constants.mjs";
+import debug from "debug";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+const log = debug("rwsdk:vite:linker-plugin");
+export const linkerPlugin = ({ projectRootDir, }) => {
+    return {
+        name: "rwsdk:linker",
+        async renderChunk(code) {
+            if (this.environment.name !== "worker" ||
+                process.env.RWSDK_BUILD_PASS !== "linker") {
+                return null;
+            }
+            log("Rendering final worker chunk");
+            let newCode = code;
+            // Read the manifest from the filesystem.
+            const manifestContent = await fsp.readFile(path.resolve(projectRootDir, CLIENT_MANIFEST_RELATIVE_PATH), "utf-8");
+            const manifest = JSON.parse(manifestContent);
+            // 1. Replace the manifest placeholder with the actual manifest content.
+            log("Injecting manifest into worker bundle");
+            newCode = newCode.replace('"__RWSDK_MANIFEST_PLACEHOLDER__"', manifestContent);
+            // 2. Replace asset placeholders with their final hashed paths.
+            log("Replacing asset placeholders in final worker bundle");
+            for (const [key, value] of Object.entries(manifest)) {
+                const normalizedKey = normalizeModulePath(key, projectRootDir, {
+                    isViteStyle: false,
+                });
+                newCode = newCode.replaceAll(`rwsdk_asset:${normalizedKey}`, `/${value.file}`);
+            }
+            // 3. Deprefix any remaining placeholders that were not in the manifest.
+            // This handles public assets that don't go through the bundler.
+            log("Deprefixing remaining asset placeholders");
+            newCode = newCode.replaceAll("rwsdk_asset:", "");
+            return {
+                code: newCode,
+                map: null,
+            };
+        },
+    };
+};

package/dist/vite/manifestPlugin.d.mts

@@ -1,4 +1,4 @@
 import { type Plugin } from "vite";
-export declare const manifestPlugin: ({ manifestPath, }: {
-    manifestPath: string;
+export declare const manifestPlugin: ({ projectRootDir, }: {
+    projectRootDir: string;
 }) => Plugin;