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

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

@@ -36,6 +36,7 @@ const DEFAULT_RESOLVE_EXTENSIONS = [
     ".js",
     ".json",
     ".css",
+    ".vue",
 ];
 const INDEX_RESOLVE_EXTENSIONS = [
     "/index.tsx",
@@ -44,6 +45,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 +66,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 +77,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 +117,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 +211,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 +229,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 +294,7 @@ async function transformWorkspaceModule(sourcePath, source, scriptTransformer) {
         },
         fileName: sourcePath,
         reportDiagnostics: false,
-    }).outputText);
+    }).outputText;
 }
 function transformSuccess(outputText) {
     return {
@@ -271,7 +313,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 +321,244 @@ 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 scriptSetup = extractVueSfcBlock(source, "script", "setup") ?? "";
+    const template = extractVueSfcBlock(source, "template") ?? "";
+    const bindings = collectVueSetupBindings(scriptSetup);
+    const renderExpression = createVueRenderExpression(template);
+    const setupReturn = bindings.length === 0
+        ? "{}"
+        : `{ ${bindings.map((binding) => `${binding}: ${binding}`).join(", ")} }`;
+    return [
+        'import { h as __forgeVueH } from "vue";',
+        scriptSetup,
+        "",
+        "const __forgeVueComponent = {",
+        `  __file: ${JSON.stringify(sourcePath)},`,
+        "  setup() {",
+        `    return ${setupReturn};`,
+        "  },",
+        "  render(__forgeVueCtx) {",
+        `    return ${renderExpression};`,
+        "  },",
+        "};",
+        "",
+        "export default __forgeVueComponent;",
+        "",
+    ].join("\n");
 }
-function createCssModule(sourcePath, css) {
+function extractVueSfcBlock(source, blockName, requiredAttribute) {
+    const pattern = new RegExp(`<${blockName}\\b([^>]*)>([\\s\\S]*?)<\\/${blockName}>`, "gi");
+    for (const match of source.matchAll(pattern)) {
+        const attributes = match[1] ?? "";
+        if (requiredAttribute !== undefined &&
+            !new RegExp(`\\b${requiredAttribute}\\b`, "i").test(attributes)) {
+            continue;
+        }
+        return match[2].trim();
+    }
+    return undefined;
+}
+function collectVueSetupBindings(scriptSetup) {
+    const bindings = new Set();
+    for (const match of scriptSetup.matchAll(/\bimport\s+(type\s+)?([\s\S]*?)\s+from\s*["'][^"']+["']/g)) {
+        if (match[1] !== undefined) {
+            continue;
+        }
+        for (const binding of parseImportBindingNames(match[2])) {
+            bindings.add(binding);
+        }
+    }
+    const declarationPatterns = [
+        /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g,
+        /\bfunction\s+([A-Za-z_$][\w$]*)/g,
+        /\bclass\s+([A-Za-z_$][\w$]*)/g,
+    ];
+    for (const pattern of declarationPatterns) {
+        for (const match of scriptSetup.matchAll(pattern)) {
+            bindings.add(match[1]);
+        }
+    }
+    return Array.from(bindings).sort((left, right) => left.localeCompare(right));
+}
+function parseImportBindingNames(importClause) {
+    const bindings = [];
+    const trimmed = importClause.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("{")) {
+        bindings.push(...parseNamedImportBindings(trimmed));
+        return bindings;
+    }
+    const [defaultOrNamespace = "", ...rest] = trimmed.split(",");
+    const defaultBinding = defaultOrNamespace.trim();
+    if (defaultBinding.startsWith("* as ")) {
+        bindings.push(defaultBinding.slice(5).trim());
+    }
+    else if (/^[A-Za-z_$][\w$]*$/.test(defaultBinding)) {
+        bindings.push(defaultBinding);
+    }
+    bindings.push(...parseNamedImportBindings(rest.join(",").trim()));
+    return bindings.filter((binding) => /^[A-Za-z_$][\w$]*$/.test(binding));
+}
+function parseNamedImportBindings(importClause) {
+    const namedMatch = importClause.match(/\{([\s\S]*?)\}/);
+    if (namedMatch === null) {
+        return [];
+    }
+    return namedMatch[1]
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0 && !part.startsWith("type "))
+        .map((part) => {
+        const aliasMatch = part.match(/\bas\s+([A-Za-z_$][\w$]*)$/);
+        return aliasMatch?.[1] ?? part;
+    })
+        .filter((binding) => /^[A-Za-z_$][\w$]*$/.test(binding));
+}
+function createVueRenderExpression(template) {
+    const nodes = parseVueTemplate(template);
+    const renderedChildren = nodes.map(createVueTemplateNodeExpression);
+    if (renderedChildren.length === 0) {
+        return "null";
+    }
+    return renderedChildren.length === 1
+        ? renderedChildren[0]
+        : `__forgeVueH("div", null, [${renderedChildren.join(", ")}])`;
+}
+function parseVueTemplate(template) {
+    const root = {
+        attributes: [],
+        children: [],
+        tagName: "__root__",
+    };
+    const stack = [root];
+    const tokenPattern = /<!--[\s\S]*?-->|<\/?[^>]+>|{{[\s\S]*?}}|[^<{]+|[<{]/g;
+    for (const match of template.matchAll(tokenPattern)) {
+        const token = match[0];
+        const current = stack[stack.length - 1];
+        if (token.startsWith("<!--")) {
+            continue;
+        }
+        if (token.startsWith("</")) {
+            if (stack.length > 1) {
+                stack.pop();
+            }
+            continue;
+        }
+        if (token.startsWith("<")) {
+            const element = parseVueTemplateElementToken(token);
+            if (element === undefined) {
+                continue;
+            }
+            current.children.push({
+                attributes: element.attributes,
+                children: element.children,
+                kind: "element",
+                tagName: element.tagName,
+            });
+            if (!isSelfClosingVueTemplateToken(token)) {
+                stack.push(element);
+            }
+            continue;
+        }
+        if (token.startsWith("{{")) {
+            current.children.push({
+                expression: token.slice(2, -2).trim(),
+                kind: "interpolation",
+            });
+            continue;
+        }
+        if (token.trim().length > 0) {
+            current.children.push({
+                kind: "text",
+                value: token.replace(/\s+/g, " "),
+            });
+        }
+    }
+    return root.children;
+}
+function parseVueTemplateElementToken(token) {
+    const content = token
+        .slice(1, isSelfClosingVueTemplateToken(token) ? -2 : -1)
+        .trim();
+    const tagMatch = content.match(/^([A-Za-z][\w.-]*)/);
+    if (tagMatch === null) {
+        return undefined;
+    }
+    return {
+        attributes: parseVueTemplateAttributes(content.slice(tagMatch[0].length)),
+        children: [],
+        tagName: tagMatch[1],
+    };
+}
+function parseVueTemplateAttributes(source) {
+    const attributes = [];
+    const pattern = /([:@A-Za-z_][\w:.-]*)(?:\s*=\s*("[^"]*"|'[^']*'|[^\s"'>/]+))?/g;
+    for (const match of source.matchAll(pattern)) {
+        const name = match[1];
+        if (name.startsWith(":") ||
+            name.startsWith("@") ||
+            name.startsWith("v-")) {
+            continue;
+        }
+        const rawValue = match[2];
+        const value = rawValue === undefined
+            ? true
+            : rawValue.replace(/^["']|["']$/g, "");
+        attributes.push({ name, value });
+    }
+    return attributes;
+}
+function createVueTemplateNodeExpression(node) {
+    switch (node.kind) {
+        case "element":
+            return createVueElementExpression(node);
+        case "interpolation":
+            return createVueInterpolationExpression(node.expression);
+        case "text":
+            return JSON.stringify(node.value);
+    }
+}
+function createVueElementExpression(node) {
+    const tagExpression = /^[A-Z]/.test(node.tagName)
+        ? `(__forgeVueCtx[${JSON.stringify(node.tagName)}] ?? ${JSON.stringify(node.tagName)})`
+        : JSON.stringify(node.tagName);
+    const propsExpression = createVuePropsExpression(node.attributes);
+    const children = node.children.map(createVueTemplateNodeExpression);
+    const childrenExpression = children.length === 0
+        ? "null"
+        : children.length === 1
+            ? children[0]
+            : `[${children.join(", ")}]`;
+    return `__forgeVueH(${tagExpression}, ${propsExpression}, ${childrenExpression})`;
+}
+function createVuePropsExpression(attributes) {
+    if (attributes.length === 0) {
+        return "null";
+    }
+    return `{ ${attributes
+        .map((attribute) => {
+        const value = attribute.value === true ? "true" : JSON.stringify(attribute.value);
+        return `${JSON.stringify(attribute.name)}: ${value}`;
+    })
+        .join(", ")} }`;
+}
+function createVueInterpolationExpression(expression) {
+    if (/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(expression)) {
+        return `String(__forgeVueCtx.${expression} ?? "")`;
+    }
+    return "String(\"\")";
+}
+function isSelfClosingVueTemplateToken(token) {
+    return /\/\s*>$/.test(token);
+}
+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 +571,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 +675,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 +871,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";