@caryhu/codemine-forge 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/build-pipeline/browser-bundle.d.ts

@@ -1,6 +1,6 @@
 import type { ForgePackageResolutionResult } from "../package-resolution";
 import { type ForgeVirtualFileSystem } from "../virtual-file-system";
-import type { ForgeBrowserBundle, ForgeBuildOutputFile, ForgeBuildPipelineDiagnostic } from "./types";
+import type { ForgeBrowserBundle, ForgeBuildOutputFile, ForgeBuildPipelineDiagnostic, ForgeViteConfigMetadata } from "./types";
 export interface ForgeBrowserBundleResult {
     readonly browserBundle?: ForgeBrowserBundle;
     readonly diagnostics: readonly ForgeBuildPipelineDiagnostic[];
@@ -11,6 +11,7 @@ interface CreateBrowserBundleOptions {
     readonly fileSystem: ForgeVirtualFileSystem;
     readonly packageResolution: ForgePackageResolutionResult;
     readonly scriptTransformer?: ForgeBrowserBundleScriptTransformer;
+    readonly viteConfig?: ForgeViteConfigMetadata;
 }
 export type ForgeBrowserBundleScriptLoader = "ts" | "tsx";
 export interface ForgeBrowserBundleScriptTransformRequest {

package/dist/build-pipeline/browser-bundle.js

@@ -24,6 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBrowserBundle = void 0;
+const compiler_sfc_1 = require("@vue/compiler-sfc");
 const ts = __importStar(require("typescript"));
 const virtual_file_system_1 = require("../virtual-file-system");
 const diagnostics_1 = require("./diagnostics");
@@ -36,6 +37,7 @@ const DEFAULT_RESOLVE_EXTENSIONS = [
     ".js",
     ".json",
     ".css",
+    ".vue",
 ];
 const INDEX_RESOLVE_EXTENSIONS = [
     "/index.tsx",
@@ -44,6 +46,7 @@ const INDEX_RESOLVE_EXTENSIONS = [
     "/index.js",
     "/index.json",
     "/index.css",
+    "/index.vue",
 ];
 const SCRIPT_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx"]);
 async function createBrowserBundle(options) {
@@ -64,7 +67,8 @@ async function createBrowserBundle(options) {
         const extension = getExtension(sourcePath);
         if (!SCRIPT_EXTENSIONS.has(extension) &&
             extension !== ".css" &&
-            extension !== ".json") {
+            extension !== ".json" &&
+            extension !== ".vue") {
             modules.set(sourcePath, {
                 outputPath: createModuleOutputPath(sourcePath),
                 sourcePath,
@@ -74,12 +78,24 @@ async function createBrowserBundle(options) {
             return;
         }
         const source = await options.fileSystem.readText(sourcePath);
-        const imports = extractImportReferences(source).map((reference) => reference.specifier);
+        const importSource = extension === ".vue" ? createVueSfcModule(sourcePath, source) : source;
+        const imports = extractImportReferences(importSource).map((reference) => reference.specifier);
         const rewrites = new Map();
         for (const specifier of imports) {
             if (isExternalUrl(specifier)) {
                 continue;
             }
+            const aliasSpecifier = resolveAliasSpecifier(specifier, options.viteConfig?.aliases ?? {});
+            if (aliasSpecifier !== undefined) {
+                const resolvedPath = await resolveLocalImport(options.fileSystem, sourcePath, aliasSpecifier);
+                if (resolvedPath === undefined) {
+                    diagnostics.push((0, diagnostics_1.createUnresolvedImportDiagnostic)(specifier, sourcePath));
+                    continue;
+                }
+                rewrites.set(specifier, createModuleOutputPath(resolvedPath));
+                await visitWorkspaceModule(resolvedPath);
+                continue;
+            }
             if (isLocalSpecifier(specifier)) {
                 const resolvedPath = await resolveLocalImport(options.fileSystem, sourcePath, specifier);
                 if (resolvedPath === undefined) {
@@ -102,7 +118,7 @@ async function createBrowserBundle(options) {
                 await visitPackageModule(packageImport.packageRecord, packageImport.filePath);
             }
         }
-        const transformResult = await transformWorkspaceModule(sourcePath, source, options.scriptTransformer);
+        const transformResult = await transformWorkspaceModule(sourcePath, source, options.scriptTransformer, options.viteConfig?.define ?? {});
         if (!transformResult.success) {
             diagnostics.push(...transformResult.diagnostics);
             visiting.delete(sourcePath);
@@ -196,6 +212,7 @@ async function createBrowserBundle(options) {
     const localImports = Object.fromEntries(moduleOutputFiles.map((file) => [file.path, file.path]));
     const packageImportEntries = Object.fromEntries(Array.from(packageImports.entries()).sort(([left], [right]) => left.localeCompare(right)));
     const packageEntryImports = createPackageEntryImports(options.packageResolution.packages);
+    const bundleModules = createBrowserBundleModules(Array.from(modules.values()), Array.from(packageModules.values()));
     const importMap = {
         imports: sortRecord({
             ...packageEntryImports,
@@ -213,34 +230,60 @@ async function createBrowserBundle(options) {
             format: "esm",
             importMap,
             importMapPath: BROWSER_IMPORT_MAP_PATH,
-            moduleCount: modules.size + packageModules.size,
+            moduleCount: bundleModules.length,
+            modules: bundleModules,
             outputPaths: allOutputFiles.map((file) => file.path),
+            viteConfig: options.viteConfig,
         },
         diagnostics: [],
         outputFiles: allOutputFiles,
     };
 }
 exports.createBrowserBundle = createBrowserBundle;
-async function transformWorkspaceModule(sourcePath, source, scriptTransformer) {
+function createBrowserBundleModules(workspaceModules, packageModules) {
+    return [
+        ...workspaceModules.map((moduleRecord) => ({
+            origin: "workspace",
+            outputPath: moduleRecord.outputPath,
+            sourcePath: moduleRecord.sourcePath,
+        })),
+        ...packageModules.map((moduleRecord) => ({
+            origin: "package",
+            outputPath: moduleRecord.outputPath,
+            sourcePath: createPackageImporterPath(moduleRecord.packageRecord, moduleRecord.filePath),
+        })),
+    ].sort((left, right) => left.outputPath.localeCompare(right.outputPath));
+}
+async function transformWorkspaceModule(sourcePath, source, scriptTransformer, defineReplacements) {
     const extension = getExtension(sourcePath);
     if (extension === ".css") {
-        return transformSuccess(createCssModule(sourcePath, source));
+        return transformSuccess(createWorkspaceCssModule(sourcePath, source));
     }
     if (extension === ".json") {
         return transformSuccess(createJsonModule(source));
     }
+    const applyDefines = (outputText) => applyDefineReplacements(outputText, defineReplacements);
+    if (extension === ".vue") {
+        return transformSuccess(applyDefines(transpileScript(sourcePath, createVueSfcModule(sourcePath, source))));
+    }
     if (!SCRIPT_EXTENSIONS.has(extension)) {
         return transformSuccess(source);
     }
     const loader = scriptLoaderForExtension(extension);
     if (loader !== undefined && scriptTransformer !== undefined) {
-        return scriptTransformer({
+        const transformResult = await scriptTransformer({
             loader,
             sourcePath,
             sourceText: source,
         });
+        return transformResult.success
+            ? transformSuccess(applyDefines(transformResult.outputText))
+            : transformResult;
     }
-    return transformSuccess(ts.transpileModule(source, {
+    return transformSuccess(applyDefines(transpileScript(sourcePath, source)));
+}
+function transpileScript(sourcePath, source) {
+    return ts.transpileModule(source, {
         compilerOptions: {
             esModuleInterop: true,
             importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Remove,
@@ -252,7 +295,7 @@ async function transformWorkspaceModule(sourcePath, source, scriptTransformer) {
         },
         fileName: sourcePath,
         reportDiagnostics: false,
-    }).outputText);
+    }).outputText;
 }
 function transformSuccess(outputText) {
     return {
@@ -271,7 +314,7 @@ function transformPackageModule(importer, filePath, content) {
     }
     const source = typeof content === "string" ? content : new TextDecoder().decode(content);
     if (extension === ".css") {
-        return transformSuccess(createCssModule(importer, source));
+        return transformSuccess(createPlainCssModule(importer, source));
     }
     if (extension === ".json") {
         return transformSuccess(createJsonModule(source));
@@ -279,21 +322,63 @@ function transformPackageModule(importer, filePath, content) {
     if (!SCRIPT_EXTENSIONS.has(extension)) {
         return transformSuccess(source);
     }
-    return transformSuccess(ts.transpileModule(source, {
-        compilerOptions: {
-            esModuleInterop: true,
-            importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Remove,
-            jsx: ts.JsxEmit.React,
-            jsxFactory: "React.createElement",
-            jsxFragmentFactory: "React.Fragment",
-            module: ts.ModuleKind.ESNext,
-            target: ts.ScriptTarget.ES2020,
-        },
-        fileName: importer,
-        reportDiagnostics: false,
-    }).outputText);
+    return transformSuccess(transpileScript(importer, source));
+}
+function createVueSfcModule(sourcePath, source) {
+    const filename = sourcePath;
+    const id = `forge-vue-${hashText(sourcePath)}`;
+    const parseResult = (0, compiler_sfc_1.parse)(source, { filename });
+    if (parseResult.errors.length > 0) {
+        throw new Error(formatVueCompilerErrors(parseResult.errors));
+    }
+    const { descriptor } = parseResult;
+    const script = descriptor.script === null && descriptor.scriptSetup === null
+        ? undefined
+        : (0, compiler_sfc_1.compileScript)(descriptor, {
+            genDefaultAs: "__forgeVueDefault",
+            id,
+        });
+    const scriptContent = script?.content ?? "const __forgeVueDefault = {};";
+    const template = descriptor.template === null
+        ? undefined
+        : (0, compiler_sfc_1.compileTemplate)({
+            compilerOptions: {
+                bindingMetadata: script?.bindings ?? {},
+            },
+            filename,
+            id,
+            scoped: descriptor.styles.some((style) => style.scoped),
+            source: descriptor.template.content,
+        });
+    if (template?.errors !== undefined && template.errors.length > 0) {
+        throw new Error(formatVueCompilerErrors(template.errors));
+    }
+    const templateContent = template?.code ?? "function render() { return null; }";
+    return [
+        scriptContent,
+        "",
+        templateContent,
+        "",
+        "const __forgeVueComponent = Object.assign(__forgeVueDefault, {",
+        `  __file: ${JSON.stringify(sourcePath)},`,
+        "  render,",
+        "});",
+        "",
+        "export default __forgeVueComponent;",
+        "",
+    ].join("\n");
 }
-function createCssModule(sourcePath, css) {
+function formatVueCompilerErrors(errors) {
+    return errors
+        .map((error) => (error instanceof Error ? error.message : String(error)))
+        .join("\n");
+}
+function createWorkspaceCssModule(sourcePath, css) {
+    return isCssModulePath(sourcePath)
+        ? createCssModule(sourcePath, css)
+        : createPlainCssModule(sourcePath, css);
+}
+function createPlainCssModule(sourcePath, css) {
     return [
         `const css = ${JSON.stringify(css)};`,
         `const id = ${JSON.stringify(`forge-css:${sourcePath}`)};`,
@@ -306,6 +391,70 @@ function createCssModule(sourcePath, css) {
         "",
     ].join("\n");
 }
+function createCssModule(sourcePath, css) {
+    const protectedCss = protectCssModuleGlobalSelectors(css);
+    const classMap = createCssModuleClassMap(sourcePath, protectedCss.css);
+    const rewrittenCss = restoreCssModuleGlobalSelectors(rewriteCssModuleClassSelectors(protectedCss.css, classMap), protectedCss.globalSelectors);
+    return [
+        `const css = ${JSON.stringify(rewrittenCss)};`,
+        `const id = ${JSON.stringify(`forge-css:${sourcePath}`)};`,
+        "const previous = document.querySelector(`style[data-forge-css=\"${id}\"]`);",
+        "const style = previous ?? document.createElement('style');",
+        "style.setAttribute('data-forge-css', id);",
+        "style.textContent = css;",
+        "if (previous === null) document.head.append(style);",
+        `const classes = ${JSON.stringify(classMap, null, 2)};`,
+        "export default classes;",
+        "",
+    ].join("\n");
+}
+function protectCssModuleGlobalSelectors(css) {
+    const globalSelectors = [];
+    const protectedCss = css.replace(/:global\(([^()]*)\)/g, (_match, selector) => {
+        const placeholder = `/*__forge_css_module_global_${globalSelectors.length}__*/`;
+        globalSelectors.push({ placeholder, selector });
+        return placeholder;
+    });
+    return { css: protectedCss, globalSelectors };
+}
+function restoreCssModuleGlobalSelectors(css, globalSelectors) {
+    return globalSelectors.reduce((currentCss, globalSelector) => currentCss
+        .split(globalSelector.placeholder)
+        .join(globalSelector.selector), css);
+}
+function createCssModuleClassMap(sourcePath, css) {
+    const classNames = new Set();
+    for (const match of css.matchAll(/\.([A-Za-z_][\w-]*)/g)) {
+        classNames.add(match[1]);
+    }
+    return Object.fromEntries(Array.from(classNames)
+        .sort((left, right) => left.localeCompare(right))
+        .map((className) => [
+        className,
+        createCssModuleScopedClassName(sourcePath, className),
+    ]));
+}
+function rewriteCssModuleClassSelectors(css, classMap) {
+    return css.replace(/(^|[\s,{>+~])\.([A-Za-z_][\w-]*)/g, (match, prefix, className) => {
+        const scopedClassName = classMap[className];
+        return scopedClassName === undefined
+            ? match
+            : `${prefix}.${scopedClassName}`;
+    });
+}
+function createCssModuleScopedClassName(sourcePath, className) {
+    const pathParts = sourcePath.split("/");
+    const fileName = pathParts[pathParts.length - 1] ?? "style.module.css";
+    const baseName = fileName
+        .replace(/\.module\.css$/i, "")
+        .replace(/[^a-z0-9_-]+/gi, "_");
+    const safeClassName = className.replace(/[^a-z0-9_-]+/gi, "_");
+    const hash = hashText(`${sourcePath}:${className}`).slice(0, 8);
+    return `_${baseName}_${safeClassName}_${hash}`;
+}
+function isCssModulePath(path) {
+    return /\.module\.css$/i.test(path);
+}
 function createJsonModule(json) {
     return `export default ${json.trim()};\n`;
 }
@@ -346,6 +495,31 @@ function extractImportReferences(source) {
     }
     return references;
 }
+function resolveAliasSpecifier(specifier, aliases) {
+    for (const [find, replacement] of Object.entries(aliases).sort(([left], [right]) => right.length - left.length || left.localeCompare(right))) {
+        if (specifier === find) {
+            return replacement;
+        }
+        if (specifier.startsWith(`${find}/`)) {
+            const normalizedReplacement = replacement.endsWith("/")
+                ? replacement.slice(0, -1)
+                : replacement;
+            return `${normalizedReplacement}${specifier.slice(find.length)}`;
+        }
+    }
+    return undefined;
+}
+function applyDefineReplacements(source, defineReplacements) {
+    let output = source;
+    for (const [key, value] of Object.entries(defineReplacements).sort(([left], [right]) => right.length - left.length || left.localeCompare(right))) {
+        if (!isSupportedDefineKey(key)) {
+            continue;
+        }
+        const pattern = new RegExp(`(^|[^A-Za-z0-9_$.])${escapeRegExp(key)}(?![A-Za-z0-9_$])`, "g");
+        output = output.replace(pattern, (_match, prefix) => `${prefix}${value}`);
+    }
+    return output;
+}
 async function resolveLocalImport(fileSystem, importer, specifier) {
     const basePath = specifier.startsWith("/")
         ? specifier
@@ -517,6 +691,12 @@ function isLocalSpecifier(specifier) {
 function isExternalUrl(specifier) {
     return /^https?:\/\//i.test(specifier) || specifier.startsWith("data:");
 }
+function isSupportedDefineKey(key) {
+    return /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(key);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function dirname(path) {
     const index = path.lastIndexOf("/");
     return index <= 0 ? "/" : path.slice(0, index);

package/dist/build-pipeline/diagnostics.js

@@ -64,7 +64,7 @@ function createViteConfigNotExecutedDiagnostic(path) {
         code: "vite_config_not_executed",
         severity: "warning",
         message: `Forge detected ${path} but did not execute it. ` +
-            "Config-driven aliases, plugins, defines, and server options are ignored.",
+            "Only static aliases, defines, and base are parsed; plugins and dynamic config are ignored.",
         path,
     };
 }

package/dist/build-pipeline/index.d.ts

@@ -1,3 +1,3 @@
 export { createBuildCancelledDiagnostic, createEsbuildWorkerTransformDiagnostic, createMissingBuildScriptDiagnostic, createMissingEntryDiagnostic, createUnresolvedImportDiagnostic, createUnsupportedBuildScriptDiagnostic, createViteConfigNotExecutedDiagnostic, } from "./diagnostics";
 export { createBuildPipeline, DefaultBuildPipeline, isSupportedViteBuildScript, } from "./pipeline";
-export { BUILD_PIPELINE_CAPABILITY, type ForgeBrowserBundle, type ForgeBrowserBundleManifest, type ForgeBuildDiagnostic, type ForgeBuildManifest, type ForgeBuildMode, type ForgeBuildOutputFile, type ForgeBuildPipeline, type ForgeBuildPipelineDiagnostic, type ForgeBuildPipelineDiagnosticCode, type ForgeBuildPipelineOptions, type ForgeBuildRequest, type ForgeBuildResult, type ForgeBuildTiming, } from "./types";
+export { BUILD_PIPELINE_CAPABILITY, type ForgeBrowserBundle, type ForgeBrowserBundleManifest, type ForgeBrowserBundleModule, type ForgeBrowserBundleModuleOrigin, type ForgeBuildDiagnostic, type ForgeBuildManifest, type ForgeBuildMode, type ForgeBuildOutputFile, type ForgeBuildPipeline, type ForgeBuildPipelineDiagnostic, type ForgeBuildPipelineDiagnosticCode, type ForgeBuildPipelineOptions, type ForgeBuildRequest, type ForgeBuildResult, type ForgeBuildTiming, type ForgeViteConfigMetadata, } from "./types";

package/dist/build-pipeline/pipeline.js

@@ -7,12 +7,8 @@ const virtual_file_system_1 = require("../virtual-file-system");
 const diagnostics_1 = require("./diagnostics");
 const browser_bundle_1 = require("./browser-bundle");
 const types_1 = require("./types");
+const vite_config_1 = require("./vite-config");
 const BUILD_MANIFEST_PATH = "/.forge/build/build-manifest.json";
-const VITE_CONFIG_PATHS = [
-    "/vite.config.js",
-    "/vite.config.mjs",
-    "/vite.config.ts",
-];
 const DEFAULT_ENTRY_CANDIDATES = [
     "/src/main.tsx",
     "/src/main.jsx",
@@ -32,10 +28,12 @@ class DefaultBuildPipeline {
         if (initialCancellation !== undefined) {
             return this.failure(mode, [initialCancellation], timingStart);
         }
-        const warningDiagnostics = await detectViteConfigDiagnostics(this.options.fileSystem);
+        const viteConfigRead = await (0, vite_config_1.readViteConfigMetadata)(this.options.fileSystem);
+        const warningDiagnostics = createViteConfigDiagnostics(viteConfigRead.detectedPaths);
+        const viteConfig = viteConfigRead.metadata;
         const configCancellation = getCancellationDiagnostic(request.signal);
         if (configCancellation !== undefined) {
-            return this.failure(mode, [configCancellation, ...warningDiagnostics], timingStart);
+            return this.failure(mode, [configCancellation, ...warningDiagnostics], timingStart, viteConfig);
         }
         let manifest;
         try {
@@ -43,34 +41,34 @@ class DefaultBuildPipeline {
         }
         catch (error) {
             if (error instanceof package_resolution_1.ForgePackageResolutionError) {
-                return this.failure(mode, [error.diagnostic, ...error.warnings, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [error.diagnostic, ...error.warnings, ...warningDiagnostics], timingStart, viteConfig);
             }
             throw error;
         }
         const buildScript = manifest.scripts.build;
         if (buildScript === undefined) {
-            return this.failure(mode, [(0, diagnostics_1.createMissingBuildScriptDiagnostic)(), ...warningDiagnostics], timingStart);
+            return this.failure(mode, [(0, diagnostics_1.createMissingBuildScriptDiagnostic)(), ...warningDiagnostics], timingStart, viteConfig);
         }
         if (!isSupportedViteBuildScript(buildScript)) {
             return this.failure(mode, [
                 (0, diagnostics_1.createUnsupportedBuildScriptDiagnostic)(buildScript),
                 ...warningDiagnostics,
-            ], timingStart);
+            ], timingStart, viteConfig);
         }
         const manifestCancellation = getCancellationDiagnostic(request.signal);
         if (manifestCancellation !== undefined) {
-            return this.failure(mode, [manifestCancellation, ...warningDiagnostics], timingStart);
+            return this.failure(mode, [manifestCancellation, ...warningDiagnostics], timingStart, viteConfig);
         }
         const entry = await this.resolveEntry(request.entry);
         if (entry === undefined) {
-            return this.failure(mode, [(0, diagnostics_1.createMissingEntryDiagnostic)(), ...warningDiagnostics], timingStart);
+            return this.failure(mode, [(0, diagnostics_1.createMissingEntryDiagnostic)(), ...warningDiagnostics], timingStart, viteConfig);
         }
         try {
             const packageResolution = await this.options.packageResolver.resolve();
             const packageWarnings = packageResolution.warnings;
             const packageCancellation = getCancellationDiagnostic(request.signal);
             if (packageCancellation !== undefined) {
-                return this.failure(mode, [packageCancellation, ...packageWarnings, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [packageCancellation, ...packageWarnings, ...warningDiagnostics], timingStart, viteConfig);
             }
             const sourceFiles = await collectSourceFiles(this.options.fileSystem);
             const browserBundleResult = await (0, browser_bundle_1.createBrowserBundle)({
@@ -78,38 +76,39 @@ class DefaultBuildPipeline {
                 fileSystem: this.options.fileSystem,
                 packageResolution,
                 scriptTransformer: createEsbuildWorkerScriptTransformer(this.options.esbuildWorker),
+                viteConfig,
             });
             if (browserBundleResult.diagnostics.length > 0) {
                 return this.failure(mode, [
                     ...browserBundleResult.diagnostics,
                     ...packageWarnings,
                     ...warningDiagnostics,
-                ], timingStart);
+                ], timingStart, viteConfig);
             }
             if (browserBundleResult.browserBundle === undefined) {
                 throw new Error("Browser bundle output was missing after a successful build.");
             }
             const bundleCancellation = getCancellationDiagnostic(request.signal);
             if (bundleCancellation !== undefined) {
-                return this.failure(mode, [bundleCancellation, ...packageWarnings, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [bundleCancellation, ...packageWarnings, ...warningDiagnostics], timingStart, viteConfig);
             }
-            const buildManifest = createBuildManifest(entry, mode, sourceFiles, packageResolution, browserBundleResult.browserBundle);
+            const buildManifest = createBuildManifest(entry, mode, sourceFiles, packageResolution, browserBundleResult.browserBundle, viteConfig);
             const outputFiles = [
                 createBuildManifestOutput(buildManifest),
                 ...browserBundleResult.outputFiles,
             ];
             const outputCancellation = getCancellationDiagnostic(request.signal);
             if (outputCancellation !== undefined) {
-                return this.failure(mode, [outputCancellation, ...packageWarnings, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [outputCancellation, ...packageWarnings, ...warningDiagnostics], timingStart, viteConfig);
             }
             const outputWriteDiagnostic = await writeBuildOutputFilesAtomically(this.options.fileSystem, outputFiles);
             if (outputWriteDiagnostic !== undefined) {
-                return this.failure(mode, [outputWriteDiagnostic, ...packageWarnings, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [outputWriteDiagnostic, ...packageWarnings, ...warningDiagnostics], timingStart, viteConfig);
             }
             const buildCacheWarnings = await this.writeBuildCacheRecord(entry, mode, buildManifest, browserBundleResult.browserBundle, outputFiles);
             const cacheCancellation = getCancellationDiagnostic(request.signal);
             if (cacheCancellation !== undefined) {
-                return this.failure(mode, [cacheCancellation, ...packageWarnings, ...buildCacheWarnings, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [cacheCancellation, ...packageWarnings, ...buildCacheWarnings, ...warningDiagnostics], timingStart, viteConfig);
             }
             return this.complete({
                 success: true,
@@ -124,12 +123,13 @@ class DefaultBuildPipeline {
                     ...warningDiagnostics,
                 ],
                 packageResolution,
+                viteConfig,
                 timing: completeTiming(timingStart, this.now()),
             });
         }
         catch (error) {
             if (error instanceof package_resolution_1.ForgePackageResolutionError) {
-                return this.failure(mode, [error.diagnostic, ...error.warnings, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [error.diagnostic, ...error.warnings, ...warningDiagnostics], timingStart, viteConfig);
             }
             throw error;
         }
@@ -153,12 +153,13 @@ class DefaultBuildPipeline {
         }
         return undefined;
     }
-    failure(mode, diagnostics, timingStart) {
+    failure(mode, diagnostics, timingStart, viteConfig) {
         return this.complete({
             success: false,
             mode,
             outputFiles: [],
             diagnostics,
+            viteConfig,
             timing: completeTiming(timingStart, this.now()),
         });
     }
@@ -255,14 +256,8 @@ function createEsbuildWorkerScriptTransformer(esbuildWorker) {
         };
     };
 }
-async function detectViteConfigDiagnostics(fileSystem) {
-    const diagnostics = [];
-    for (const path of VITE_CONFIG_PATHS) {
-        if (await fileSystem.exists(path)) {
-            diagnostics.push((0, diagnostics_1.createViteConfigNotExecutedDiagnostic)(path));
-        }
-    }
-    return diagnostics;
+function createViteConfigDiagnostics(paths) {
+    return paths.map((path) => (0, diagnostics_1.createViteConfigNotExecutedDiagnostic)(path));
 }
 function createBuildPipeline(options) {
     return new DefaultBuildPipeline(options);
@@ -309,13 +304,14 @@ async function collectSourceFiles(fileSystem, path = "/") {
     }
     return files.sort((left, right) => left.localeCompare(right));
 }
-function createBuildManifest(entry, mode, sourceFiles, packageResolution, browserBundle) {
+function createBuildManifest(entry, mode, sourceFiles, packageResolution, browserBundle, viteConfig) {
     return {
         entry,
         mode,
         sourceFiles,
         packageNames: packageResolution.packages.map((record) => record.name),
         packageResolutionMode: packageResolution.lock.resolutionMode,
+        viteConfig,
         browserBundle: browserBundle === undefined
             ? undefined
             : {
@@ -323,7 +319,9 @@ function createBuildManifest(entry, mode, sourceFiles, packageResolution, browse
                 format: browserBundle.format,
                 importMapPath: browserBundle.importMapPath,
                 moduleCount: browserBundle.moduleCount,
+                modules: browserBundle.modules,
                 outputPaths: browserBundle.outputPaths,
+                viteConfig: browserBundle.viteConfig,
             },
     };
 }

package/dist/build-pipeline/types.d.ts

@@ -23,6 +23,12 @@ export interface ForgeBuildOutputFile {
     readonly contentType: string;
     readonly size: number;
 }
+export interface ForgeViteConfigMetadata {
+    readonly path: string;
+    readonly aliases: Readonly<Record<string, string>>;
+    readonly define: Readonly<Record<string, string>>;
+    readonly base?: string;
+}
 export interface ForgeBuildManifest {
     readonly entry: string;
     readonly mode: ForgeBuildMode;
@@ -30,13 +36,22 @@ export interface ForgeBuildManifest {
     readonly packageNames: readonly string[];
     readonly packageResolutionMode: string;
     readonly browserBundle?: ForgeBrowserBundleManifest;
+    readonly viteConfig?: ForgeViteConfigMetadata;
+}
+export type ForgeBrowserBundleModuleOrigin = "package" | "workspace";
+export interface ForgeBrowserBundleModule {
+    readonly origin: ForgeBrowserBundleModuleOrigin;
+    readonly outputPath: string;
+    readonly sourcePath: string;
 }
 export interface ForgeBrowserBundleManifest {
     readonly entryOutputPath: string;
     readonly format: "esm";
     readonly importMapPath: string;
     readonly moduleCount: number;
+    readonly modules: readonly ForgeBrowserBundleModule[];
     readonly outputPaths: readonly string[];
+    readonly viteConfig?: ForgeViteConfigMetadata;
 }
 export interface ForgeBrowserBundle {
     readonly entry: string;
@@ -45,7 +60,9 @@ export interface ForgeBrowserBundle {
     readonly importMap: ForgeImportMap;
     readonly importMapPath: string;
     readonly moduleCount: number;
+    readonly modules: readonly ForgeBrowserBundleModule[];
     readonly outputPaths: readonly string[];
+    readonly viteConfig?: ForgeViteConfigMetadata;
 }
 export interface ForgeBuildTiming {
     readonly startedAt: string;
@@ -61,6 +78,7 @@ export interface ForgeBuildResult {
     readonly outputFiles: readonly ForgeBuildOutputFile[];
     readonly diagnostics: readonly ForgeBuildDiagnostic[];
     readonly packageResolution?: ForgePackageResolutionResult;
+    readonly viteConfig?: ForgeViteConfigMetadata;
     readonly timing: ForgeBuildTiming;
 }
 export interface ForgeBuildPipelineOptions {

package/dist/build-pipeline/vite-config.d.ts

@@ -0,0 +1,8 @@
+import { type ForgeVirtualFileSystem } from "../virtual-file-system";
+import type { ForgeViteConfigMetadata } from "./types";
+export declare const VITE_CONFIG_PATHS: readonly ["/vite.config.js", "/vite.config.mjs", "/vite.config.ts"];
+export interface ForgeViteConfigReadResult {
+    readonly detectedPaths: readonly string[];
+    readonly metadata?: ForgeViteConfigMetadata;
+}
+export declare function readViteConfigMetadata(fileSystem: ForgeVirtualFileSystem): Promise<ForgeViteConfigReadResult>;