@caryhu/codemine-forge 0.0.1-alpha.0

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

@@ -0,0 +1,584 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserBundle = void 0;
+const ts = __importStar(require("typescript"));
+const virtual_file_system_1 = require("../virtual-file-system");
+const diagnostics_1 = require("./diagnostics");
+const BROWSER_IMPORT_MAP_PATH = "/.forge/build/browser-import-map.json";
+const DEFAULT_RESOLVE_EXTENSIONS = [
+    "",
+    ".tsx",
+    ".ts",
+    ".jsx",
+    ".js",
+    ".json",
+    ".css",
+];
+const INDEX_RESOLVE_EXTENSIONS = [
+    "/index.tsx",
+    "/index.ts",
+    "/index.jsx",
+    "/index.js",
+    "/index.json",
+    "/index.css",
+];
+const SCRIPT_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx"]);
+async function createBrowserBundle(options) {
+    const diagnostics = [];
+    const packageImports = new Map();
+    const modules = new Map();
+    const packageModules = new Map();
+    const visiting = new Set();
+    const visitingPackageModules = new Set();
+    async function visitWorkspaceModule(sourcePath) {
+        if (modules.has(sourcePath)) {
+            return;
+        }
+        if (visiting.has(sourcePath)) {
+            return;
+        }
+        visiting.add(sourcePath);
+        const extension = getExtension(sourcePath);
+        if (!SCRIPT_EXTENSIONS.has(extension) &&
+            extension !== ".css" &&
+            extension !== ".json") {
+            modules.set(sourcePath, {
+                outputPath: createModuleOutputPath(sourcePath),
+                sourcePath,
+                transformedSource: createAssetModule(sourcePath, await options.fileSystem.readFile(sourcePath)),
+            });
+            visiting.delete(sourcePath);
+            return;
+        }
+        const source = await options.fileSystem.readText(sourcePath);
+        const imports = extractImportReferences(source).map((reference) => reference.specifier);
+        const rewrites = new Map();
+        for (const specifier of imports) {
+            if (isExternalUrl(specifier)) {
+                continue;
+            }
+            if (isLocalSpecifier(specifier)) {
+                const resolvedPath = await resolveLocalImport(options.fileSystem, sourcePath, specifier);
+                if (resolvedPath === undefined) {
+                    diagnostics.push((0, diagnostics_1.createUnresolvedImportDiagnostic)(specifier, sourcePath));
+                    continue;
+                }
+                rewrites.set(specifier, createModuleOutputPath(resolvedPath));
+                await visitWorkspaceModule(resolvedPath);
+                continue;
+            }
+            const packageImport = resolvePackageImport(options.packageResolution.packages, specifier);
+            if (packageImport === undefined) {
+                diagnostics.push((0, diagnostics_1.createUnresolvedImportDiagnostic)(specifier, sourcePath));
+                continue;
+            }
+            packageImports.set(specifier, packageImport.kind === "external"
+                ? packageImport.url
+                : packageImport.outputPath);
+            if (packageImport.kind === "package-file") {
+                await visitPackageModule(packageImport.packageRecord, packageImport.filePath);
+            }
+        }
+        const transformResult = await transformWorkspaceModule(sourcePath, source, options.scriptTransformer);
+        if (!transformResult.success) {
+            diagnostics.push(...transformResult.diagnostics);
+            visiting.delete(sourcePath);
+            return;
+        }
+        const transformedSource = rewriteModuleSpecifiers(transformResult.outputText, rewrites);
+        modules.set(sourcePath, {
+            outputPath: createModuleOutputPath(sourcePath),
+            sourcePath,
+            transformedSource,
+        });
+        visiting.delete(sourcePath);
+    }
+    async function visitPackageModule(packageRecord, filePath) {
+        const normalizedFilePath = normalizePackageFilePath(filePath);
+        const key = createPackageModuleKey(packageRecord, normalizedFilePath);
+        if (packageModules.has(key)) {
+            return;
+        }
+        if (visitingPackageModules.has(key)) {
+            return;
+        }
+        visitingPackageModules.add(key);
+        const packageFile = readPackageFile(packageRecord, normalizedFilePath);
+        const importer = createPackageImporterPath(packageRecord, normalizedFilePath);
+        if (packageFile === undefined || packageFile.content === undefined) {
+            diagnostics.push((0, diagnostics_1.createUnresolvedImportDiagnostic)(normalizedFilePath, importer));
+            visitingPackageModules.delete(key);
+            return;
+        }
+        const content = packageFile.content;
+        const source = typeof content === "string" ? content : undefined;
+        const imports = source === undefined
+            ? []
+            : extractImportReferences(source).map((reference) => reference.specifier);
+        const rewrites = new Map();
+        for (const specifier of imports) {
+            if (isExternalUrl(specifier)) {
+                continue;
+            }
+            if (isLocalSpecifier(specifier)) {
+                const resolvedPath = resolvePackageFileImport(packageRecord, normalizedFilePath, specifier);
+                if (resolvedPath === undefined) {
+                    diagnostics.push((0, diagnostics_1.createUnresolvedImportDiagnostic)(specifier, importer));
+                    continue;
+                }
+                rewrites.set(specifier, createPackageModuleOutputPath(packageRecord, resolvedPath));
+                await visitPackageModule(packageRecord, resolvedPath);
+                continue;
+            }
+            const packageImport = resolvePackageImport(options.packageResolution.packages, specifier);
+            if (packageImport === undefined) {
+                diagnostics.push((0, diagnostics_1.createUnresolvedImportDiagnostic)(specifier, importer));
+                continue;
+            }
+            packageImports.set(specifier, packageImport.kind === "external"
+                ? packageImport.url
+                : packageImport.outputPath);
+            if (packageImport.kind === "package-file") {
+                await visitPackageModule(packageImport.packageRecord, packageImport.filePath);
+            }
+        }
+        const transformResult = transformPackageModule(importer, normalizedFilePath, content);
+        if (!transformResult.success) {
+            diagnostics.push(...transformResult.diagnostics);
+            visitingPackageModules.delete(key);
+            return;
+        }
+        packageModules.set(key, {
+            filePath: normalizedFilePath,
+            outputPath: createPackageModuleOutputPath(packageRecord, normalizedFilePath),
+            packageRecord,
+            transformedSource: rewriteModuleSpecifiers(transformResult.outputText, rewrites),
+        });
+        visitingPackageModules.delete(key);
+    }
+    await visitWorkspaceModule(options.entry);
+    if (diagnostics.length > 0) {
+        return {
+            diagnostics,
+            outputFiles: [],
+        };
+    }
+    const outputFiles = Array.from(modules.values())
+        .sort((left, right) => left.outputPath.localeCompare(right.outputPath))
+        .map((moduleRecord) => createOutputFile(moduleRecord.outputPath, moduleRecord.transformedSource, "text/javascript"));
+    const packageOutputFiles = Array.from(packageModules.values())
+        .sort((left, right) => left.outputPath.localeCompare(right.outputPath))
+        .map((moduleRecord) => createOutputFile(moduleRecord.outputPath, moduleRecord.transformedSource, "text/javascript"));
+    const moduleOutputFiles = [...outputFiles, ...packageOutputFiles];
+    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 importMap = {
+        imports: sortRecord({
+            ...packageEntryImports,
+            ...packageImportEntries,
+            ...localImports,
+        }),
+    };
+    const importMapFile = createOutputFile(BROWSER_IMPORT_MAP_PATH, `${JSON.stringify(importMap, null, 2)}\n`, "application/importmap+json");
+    const entryOutputPath = createModuleOutputPath(options.entry);
+    const allOutputFiles = [...moduleOutputFiles, importMapFile];
+    return {
+        browserBundle: {
+            entry: options.entry,
+            entryOutputPath,
+            format: "esm",
+            importMap,
+            importMapPath: BROWSER_IMPORT_MAP_PATH,
+            moduleCount: modules.size + packageModules.size,
+            outputPaths: allOutputFiles.map((file) => file.path),
+        },
+        diagnostics: [],
+        outputFiles: allOutputFiles,
+    };
+}
+exports.createBrowserBundle = createBrowserBundle;
+async function transformWorkspaceModule(sourcePath, source, scriptTransformer) {
+    const extension = getExtension(sourcePath);
+    if (extension === ".css") {
+        return transformSuccess(createCssModule(sourcePath, source));
+    }
+    if (extension === ".json") {
+        return transformSuccess(createJsonModule(source));
+    }
+    if (!SCRIPT_EXTENSIONS.has(extension)) {
+        return transformSuccess(source);
+    }
+    const loader = scriptLoaderForExtension(extension);
+    if (loader !== undefined && scriptTransformer !== undefined) {
+        return scriptTransformer({
+            loader,
+            sourcePath,
+            sourceText: 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: sourcePath,
+        reportDiagnostics: false,
+    }).outputText);
+}
+function transformSuccess(outputText) {
+    return {
+        success: true,
+        outputText,
+        diagnostics: [],
+    };
+}
+function transformPackageModule(importer, filePath, content) {
+    const extension = getExtension(filePath);
+    if (typeof content !== "string" &&
+        !SCRIPT_EXTENSIONS.has(extension) &&
+        extension !== ".css" &&
+        extension !== ".json") {
+        return transformSuccess(createAssetModule(filePath, content));
+    }
+    const source = typeof content === "string" ? content : new TextDecoder().decode(content);
+    if (extension === ".css") {
+        return transformSuccess(createCssModule(importer, source));
+    }
+    if (extension === ".json") {
+        return transformSuccess(createJsonModule(source));
+    }
+    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);
+}
+function createCssModule(sourcePath, css) {
+    return [
+        `const css = ${JSON.stringify(css)};`,
+        `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);",
+        "export default css;",
+        "",
+    ].join("\n");
+}
+function createJsonModule(json) {
+    return `export default ${json.trim()};\n`;
+}
+function createAssetModule(sourcePath, content) {
+    const contentType = inferAssetContentType(sourcePath);
+    const dataUrl = `data:${contentType};base64,${toBase64(content)}`;
+    return `export default ${JSON.stringify(dataUrl)};\n`;
+}
+function rewriteModuleSpecifiers(source, rewrites) {
+    if (rewrites.size === 0) {
+        return source;
+    }
+    return source
+        .replace(/(\b(?:import|export)\s+(?:[^'"]*?\s+from\s*)?)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
+        const replacement = rewrites.get(specifier);
+        return replacement === undefined
+            ? match
+            : `${prefix}${quote}${replacement}${quote}`;
+    })
+        .replace(/(\bimport\s*\(\s*)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
+        const replacement = rewrites.get(specifier);
+        return replacement === undefined
+            ? match
+            : `${prefix}${quote}${replacement}${quote}`;
+    });
+}
+function extractImportReferences(source) {
+    const references = [];
+    const patterns = [
+        /\bimport\s+(?:[^'"]*?\s+from\s*)?["']([^"']+)["']/g,
+        /\bexport\s+[^'"]*?\s+from\s*["']([^"']+)["']/g,
+        /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g,
+    ];
+    for (const pattern of patterns) {
+        for (const match of source.matchAll(pattern)) {
+            references.push({ specifier: match[1] });
+        }
+    }
+    return references;
+}
+async function resolveLocalImport(fileSystem, importer, specifier) {
+    const basePath = specifier.startsWith("/")
+        ? specifier
+        : `${dirname(importer)}/${specifier}`;
+    const normalized = (0, virtual_file_system_1.normalizeForgePath)(basePath);
+    if (!normalized.ok) {
+        return undefined;
+    }
+    for (const suffix of DEFAULT_RESOLVE_EXTENSIONS) {
+        const candidate = `${normalized.path}${suffix}`;
+        if (await fileSystem.exists(candidate)) {
+            return candidate;
+        }
+    }
+    for (const suffix of INDEX_RESOLVE_EXTENSIONS) {
+        const candidate = `${normalized.path}${suffix}`;
+        if (await fileSystem.exists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function resolvePackageImport(packages, specifier) {
+    const parsed = parsePackageSpecifier(specifier);
+    if (parsed === undefined) {
+        return undefined;
+    }
+    const packageRecord = packages.find((record) => record.name === parsed.name);
+    if (packageRecord === undefined) {
+        return undefined;
+    }
+    if (packageRecord.entryUrl !== undefined && parsed.subpath === "") {
+        return {
+            kind: "external",
+            url: packageRecord.entryUrl,
+        };
+    }
+    const normalizedEntry = packageRecord.entry.startsWith("/")
+        ? packageRecord.entry
+        : `/${packageRecord.entry}`;
+    const entryWithoutExtension = normalizedEntry.replace(/\.[cm]?[jt]sx?$/i, "");
+    if (packageRecord.entryUrl !== undefined &&
+        (parsed.subpath === normalizedEntry || parsed.subpath === entryWithoutExtension)) {
+        return {
+            kind: "external",
+            url: packageRecord.entryUrl,
+        };
+    }
+    const filePath = resolvePackageImportFilePath(packageRecord, parsed.subpath);
+    return filePath === undefined
+        ? undefined
+        : {
+            kind: "package-file",
+            filePath,
+            outputPath: createPackageModuleOutputPath(packageRecord, filePath),
+            packageRecord,
+        };
+}
+function createPackageEntryImports(packages) {
+    return Object.fromEntries(packages
+        .filter((record) => record.entryUrl !== undefined)
+        .map((record) => [record.name, record.entryUrl])
+        .sort(([left], [right]) => left.localeCompare(right)));
+}
+function resolvePackageImportFilePath(packageRecord, subpath) {
+    const requestedPath = subpath.length === 0 ? packageRecord.entry : normalizePackageFilePath(subpath);
+    return resolvePackageFilePath(packageRecord, requestedPath);
+}
+function resolvePackageFileImport(packageRecord, importerPath, specifier) {
+    const basePath = specifier.startsWith("/")
+        ? specifier
+        : `${dirname(importerPath)}/${specifier}`;
+    return resolvePackageFilePath(packageRecord, basePath);
+}
+function resolvePackageFilePath(packageRecord, requestedPath) {
+    const normalized = normalizePackageFilePath(requestedPath);
+    const candidates = [
+        ...DEFAULT_RESOLVE_EXTENSIONS.map((suffix) => `${normalized}${suffix}`),
+        ...INDEX_RESOLVE_EXTENSIONS.map((suffix) => `${normalized}${suffix}`),
+    ];
+    for (const candidate of candidates) {
+        const candidatePath = normalizePackageFilePath(candidate);
+        if (readPackageFile(packageRecord, candidatePath) !== undefined) {
+            return candidatePath;
+        }
+    }
+    return undefined;
+}
+function readPackageFile(packageRecord, filePath) {
+    const normalized = normalizePackageFilePath(filePath);
+    for (const [recordPath, file] of Object.entries(packageRecord.files)) {
+        const candidates = [
+            recordPath,
+            file.path,
+        ].map((path) => normalizePackageFilePath(path));
+        if (candidates.includes(normalized)) {
+            return file;
+        }
+    }
+    return undefined;
+}
+function createPackageModuleKey(packageRecord, filePath) {
+    return `${packageRecord.name}@${packageRecord.version}:${normalizePackageFilePath(filePath)}`;
+}
+function createPackageImporterPath(packageRecord, filePath) {
+    return `${packageRecord.name}:${normalizePackageFilePath(filePath)}`;
+}
+function createPackageModuleOutputPath(packageRecord, filePath) {
+    const packageSegment = `${safePathSegment(packageRecord.name)}@${safePathSegment(packageRecord.version)}`;
+    const modulePath = normalizePackageFilePath(filePath)
+        .replace(/\.[^.]+$/, ".js")
+        .replace(/[^/a-z0-9._~-]+/gi, "-");
+    return `/.forge/build/packages/${packageSegment}${modulePath}`;
+}
+function normalizePackageFilePath(path) {
+    const input = path.startsWith("/") ? path : `/${path.replace(/^\.\//, "")}`;
+    const normalized = (0, virtual_file_system_1.normalizeForgePath)(input);
+    return normalized.ok ? normalized.path : input;
+}
+function safePathSegment(value) {
+    return value
+        .replace(/^@/, "")
+        .replace(/\//g, "__")
+        .replace(/[^a-z0-9._~-]+/gi, "-")
+        .toLowerCase();
+}
+function parsePackageSpecifier(specifier) {
+    if (specifier.startsWith("@")) {
+        const parts = specifier.split("/");
+        if (parts.length < 2) {
+            return undefined;
+        }
+        const name = `${parts[0]}/${parts[1]}`;
+        return {
+            name,
+            subpath: specifier.slice(name.length),
+        };
+    }
+    const [name = ""] = specifier.split("/");
+    if (name.length === 0) {
+        return undefined;
+    }
+    return {
+        name,
+        subpath: specifier.slice(name.length),
+    };
+}
+function createModuleOutputPath(sourcePath) {
+    const baseName = sourcePath
+        .replace(/^\//, "")
+        .replace(/\.[^.]+$/, "")
+        .replace(/[^a-z0-9]+/gi, "-")
+        .replace(/^-+|-+$/g, "")
+        .toLowerCase();
+    const safeName = baseName.length > 0 ? baseName : "module";
+    return `/.forge/build/assets/${safeName}-${hashText(sourcePath)}.js`;
+}
+function createOutputFile(path, content, contentType) {
+    return {
+        path,
+        content,
+        contentType,
+        size: new TextEncoder().encode(content).byteLength,
+    };
+}
+function isLocalSpecifier(specifier) {
+    return specifier.startsWith(".") || specifier.startsWith("/");
+}
+function isExternalUrl(specifier) {
+    return /^https?:\/\//i.test(specifier) || specifier.startsWith("data:");
+}
+function dirname(path) {
+    const index = path.lastIndexOf("/");
+    return index <= 0 ? "/" : path.slice(0, index);
+}
+function getExtension(path) {
+    const index = path.lastIndexOf(".");
+    return index === -1 ? "" : path.slice(index).toLowerCase();
+}
+function scriptLoaderForExtension(extension) {
+    switch (extension) {
+        case ".ts":
+            return "ts";
+        case ".tsx":
+            return "tsx";
+        default:
+            return undefined;
+    }
+}
+function inferAssetContentType(path) {
+    switch (getExtension(path)) {
+        case ".gif":
+            return "image/gif";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        case ".svg":
+            return "image/svg+xml";
+        case ".webp":
+            return "image/webp";
+        case ".woff":
+            return "font/woff";
+        case ".woff2":
+            return "font/woff2";
+        default:
+            return "application/octet-stream";
+    }
+}
+function sortRecord(record) {
+    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+function hashText(text) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, "0");
+}
+function toBase64(bytes) {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let output = "";
+    for (let index = 0; index < bytes.length; index += 3) {
+        const first = bytes[index];
+        const second = bytes[index + 1];
+        const third = bytes[index + 2];
+        const triplet = (first << 16) | ((second ?? 0) << 8) | (third ?? 0);
+        output += alphabet[(triplet >> 18) & 63];
+        output += alphabet[(triplet >> 12) & 63];
+        output += second === undefined ? "=" : alphabet[(triplet >> 6) & 63];
+        output += third === undefined ? "=" : alphabet[triplet & 63];
+    }
+    return output;
+}

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

@@ -0,0 +1,7 @@
+import type { ForgeBuildPipelineDiagnostic } from "./types";
+export declare function createEsbuildWorkerTransformDiagnostic(path: string, cause: unknown): ForgeBuildPipelineDiagnostic;
+export declare function createMissingBuildScriptDiagnostic(): ForgeBuildPipelineDiagnostic;
+export declare function createUnsupportedBuildScriptDiagnostic(script: string): ForgeBuildPipelineDiagnostic;
+export declare function createMissingEntryDiagnostic(): ForgeBuildPipelineDiagnostic;
+export declare function createUnresolvedImportDiagnostic(importSpecifier: string, importer: string): ForgeBuildPipelineDiagnostic;
+export declare function createViteConfigNotExecutedDiagnostic(path: string): ForgeBuildPipelineDiagnostic;

package/dist/build-pipeline/diagnostics.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createViteConfigNotExecutedDiagnostic = exports.createUnresolvedImportDiagnostic = exports.createMissingEntryDiagnostic = exports.createUnsupportedBuildScriptDiagnostic = exports.createMissingBuildScriptDiagnostic = exports.createEsbuildWorkerTransformDiagnostic = void 0;
+function createEsbuildWorkerTransformDiagnostic(path, cause) {
+    return {
+        code: "esbuild_worker_transform_failed",
+        severity: "error",
+        message: "Esbuild wasm worker failed to transform a workspace module.",
+        path,
+        cause,
+        workerDiagnostic: isWorkerDiagnostic(cause) ? cause : undefined,
+    };
+}
+exports.createEsbuildWorkerTransformDiagnostic = createEsbuildWorkerTransformDiagnostic;
+function createMissingBuildScriptDiagnostic() {
+    return {
+        code: "missing_build_script",
+        severity: "error",
+        message: "Package manifest does not define scripts.build.",
+        path: "/package.json",
+    };
+}
+exports.createMissingBuildScriptDiagnostic = createMissingBuildScriptDiagnostic;
+function createUnsupportedBuildScriptDiagnostic(script) {
+    return {
+        code: "unsupported_build_script",
+        severity: "error",
+        message: "Build script is not supported by Forge.",
+        path: "/package.json",
+        script,
+    };
+}
+exports.createUnsupportedBuildScriptDiagnostic = createUnsupportedBuildScriptDiagnostic;
+function createMissingEntryDiagnostic() {
+    return {
+        code: "missing_entry",
+        severity: "error",
+        message: "No supported browser app entry was found.",
+    };
+}
+exports.createMissingEntryDiagnostic = createMissingEntryDiagnostic;
+function createUnresolvedImportDiagnostic(importSpecifier, importer) {
+    return {
+        code: "unresolved_import",
+        severity: "error",
+        message: `Unable to resolve import '${importSpecifier}' from ${importer}.`,
+        importSpecifier,
+        importer,
+        path: importer,
+    };
+}
+exports.createUnresolvedImportDiagnostic = createUnresolvedImportDiagnostic;
+function createViteConfigNotExecutedDiagnostic(path) {
+    return {
+        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.",
+        path,
+    };
+}
+exports.createViteConfigNotExecutedDiagnostic = createViteConfigNotExecutedDiagnostic;
+function isWorkerDiagnostic(cause) {
+    return (typeof cause === "object" &&
+        cause !== null &&
+        "code" in cause &&
+        "severity" in cause);
+}

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

@@ -0,0 +1,3 @@
+export { 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";

package/dist/build-pipeline/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILD_PIPELINE_CAPABILITY = exports.isSupportedViteBuildScript = exports.DefaultBuildPipeline = exports.createBuildPipeline = exports.createViteConfigNotExecutedDiagnostic = exports.createUnsupportedBuildScriptDiagnostic = exports.createUnresolvedImportDiagnostic = exports.createMissingEntryDiagnostic = exports.createMissingBuildScriptDiagnostic = exports.createEsbuildWorkerTransformDiagnostic = void 0;
+var diagnostics_1 = require("./diagnostics");
+Object.defineProperty(exports, "createEsbuildWorkerTransformDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createEsbuildWorkerTransformDiagnostic; } });
+Object.defineProperty(exports, "createMissingBuildScriptDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createMissingBuildScriptDiagnostic; } });
+Object.defineProperty(exports, "createMissingEntryDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createMissingEntryDiagnostic; } });
+Object.defineProperty(exports, "createUnresolvedImportDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnresolvedImportDiagnostic; } });
+Object.defineProperty(exports, "createUnsupportedBuildScriptDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnsupportedBuildScriptDiagnostic; } });
+Object.defineProperty(exports, "createViteConfigNotExecutedDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createViteConfigNotExecutedDiagnostic; } });
+var pipeline_1 = require("./pipeline");
+Object.defineProperty(exports, "createBuildPipeline", { enumerable: true, get: function () { return pipeline_1.createBuildPipeline; } });
+Object.defineProperty(exports, "DefaultBuildPipeline", { enumerable: true, get: function () { return pipeline_1.DefaultBuildPipeline; } });
+Object.defineProperty(exports, "isSupportedViteBuildScript", { enumerable: true, get: function () { return pipeline_1.isSupportedViteBuildScript; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "BUILD_PIPELINE_CAPABILITY", { enumerable: true, get: function () { return types_1.BUILD_PIPELINE_CAPABILITY; } });