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

package/dist/build-pipeline/pipeline.js

@@ -2,16 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isSupportedViteBuildScript = exports.createBuildPipeline = exports.DefaultBuildPipeline = void 0;
 const package_resolution_1 = require("../package-resolution");
+const telemetry_1 = require("../telemetry");
 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",
@@ -27,64 +24,112 @@ class DefaultBuildPipeline {
     async build(request = {}) {
         const timingStart = createTimingStart(this.now());
         const mode = "production";
-        const warningDiagnostics = await detectViteConfigDiagnostics(this.options.fileSystem);
+        const initialCancellation = getCancellationDiagnostic(request.signal);
+        if (initialCancellation !== undefined) {
+            return this.failure(mode, [initialCancellation], timingStart);
+        }
+        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, viteConfig);
+        }
         let manifest;
         try {
             manifest = await (0, package_resolution_1.readPackageManifest)(this.options.fileSystem);
         }
         catch (error) {
             if (error instanceof package_resolution_1.ForgePackageResolutionError) {
-                return this.failure(mode, [error.diagnostic, ...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, 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, viteConfig);
+            }
             const sourceFiles = await collectSourceFiles(this.options.fileSystem);
             const browserBundleResult = await (0, browser_bundle_1.createBrowserBundle)({
                 entry,
                 fileSystem: this.options.fileSystem,
                 packageResolution,
                 scriptTransformer: createEsbuildWorkerScriptTransformer(this.options.esbuildWorker),
+                viteConfig,
             });
             if (browserBundleResult.diagnostics.length > 0) {
-                return this.failure(mode, [...browserBundleResult.diagnostics, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [
+                    ...browserBundleResult.diagnostics,
+                    ...packageWarnings,
+                    ...warningDiagnostics,
+                ], timingStart, viteConfig);
+            }
+            if (browserBundleResult.browserBundle === undefined) {
+                throw new Error("Browser bundle output was missing after a successful build.");
             }
-            const buildManifest = createBuildManifest(entry, mode, sourceFiles, packageResolution, browserBundleResult.browserBundle);
+            const bundleCancellation = getCancellationDiagnostic(request.signal);
+            if (bundleCancellation !== undefined) {
+                return this.failure(mode, [bundleCancellation, ...packageWarnings, ...warningDiagnostics], timingStart, viteConfig);
+            }
+            const buildManifest = createBuildManifest(entry, mode, sourceFiles, packageResolution, browserBundleResult.browserBundle, viteConfig);
             const outputFiles = [
                 createBuildManifestOutput(buildManifest),
                 ...browserBundleResult.outputFiles,
             ];
-            await writeBuildOutputFiles(this.options.fileSystem, outputFiles);
-            return {
+            const outputCancellation = getCancellationDiagnostic(request.signal);
+            if (outputCancellation !== undefined) {
+                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, 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, viteConfig);
+            }
+            return this.complete({
                 success: true,
                 mode,
                 entry,
                 browserBundle: browserBundleResult.browserBundle,
                 manifest: buildManifest,
                 outputFiles,
-                diagnostics: warningDiagnostics,
+                diagnostics: [
+                    ...packageWarnings,
+                    ...buildCacheWarnings,
+                    ...warningDiagnostics,
+                ],
                 packageResolution,
+                viteConfig,
                 timing: completeTiming(timingStart, this.now()),
-            };
+            });
         }
         catch (error) {
             if (error instanceof package_resolution_1.ForgePackageResolutionError) {
-                return this.failure(mode, [error.diagnostic, ...warningDiagnostics], timingStart);
+                return this.failure(mode, [error.diagnostic, ...error.warnings, ...warningDiagnostics], timingStart, viteConfig);
             }
             throw error;
         }
@@ -108,17 +153,70 @@ class DefaultBuildPipeline {
         }
         return undefined;
     }
-    failure(mode, diagnostics, timingStart) {
-        return {
+    failure(mode, diagnostics, timingStart, viteConfig) {
+        return this.complete({
             success: false,
             mode,
             outputFiles: [],
             diagnostics,
+            viteConfig,
             timing: completeTiming(timingStart, this.now()),
+        });
+    }
+    complete(result) {
+        (0, telemetry_1.emitForgeTelemetry)(this.options.telemetry, {
+            operation: "build",
+            outcome: result.success ? "success" : "failure",
+            startedAt: result.timing.startedAt,
+            endedAt: result.timing.endedAt,
+            durationMs: result.timing.durationMs,
+            mode: result.mode,
+            entry: result.entry,
+            outputFileCount: result.outputFiles.length,
+            packageCount: result.packageResolution?.packages.length,
+            diagnostics: (0, telemetry_1.summarizeForgeTelemetryDiagnostics)(result.diagnostics),
+        });
+        return result;
+    }
+    async writeBuildCacheRecord(entry, mode, manifest, browserBundle, outputFiles) {
+        if (this.options.storage === undefined) {
+            return [];
+        }
+        const value = {
+            browserBundle,
+            entry,
+            manifest,
+            mode,
+            outputFiles: outputFiles.map((outputFile) => ({
+                contentType: outputFile.contentType,
+                path: outputFile.path,
+                size: outputFile.size,
+            })),
         };
+        const encoded = new TextEncoder().encode(JSON.stringify(value));
+        try {
+            await this.options.storage.putBuildCacheRecord({
+                key: `build:${mode}:${entry}`,
+                size: encoded.byteLength,
+                updatedAt: this.now(),
+                value,
+            });
+            return [];
+        }
+        catch (error) {
+            if (isLimitExceededError(error)) {
+                return [toWarningDiagnostic(error.diagnostic)];
+            }
+            throw error;
+        }
     }
 }
 exports.DefaultBuildPipeline = DefaultBuildPipeline;
+function getCancellationDiagnostic(signal) {
+    return signal?.aborted === true
+        ? (0, diagnostics_1.createBuildCancelledDiagnostic)(signal.reason)
+        : undefined;
+}
 function createEsbuildWorkerScriptTransformer(esbuildWorker) {
     if (esbuildWorker === undefined) {
         return undefined;
@@ -158,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);
@@ -212,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
             : {
@@ -226,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,
             },
     };
 }
@@ -248,6 +343,22 @@ async function writeBuildOutputFiles(fileSystem, outputFiles) {
         });
     }
 }
+async function writeBuildOutputFilesAtomically(fileSystem, outputFiles) {
+    const rollbackSnapshot = await fileSystem.snapshot({
+        includeGeneratedFiles: true,
+    });
+    try {
+        await writeBuildOutputFiles(fileSystem, outputFiles);
+        return undefined;
+    }
+    catch (error) {
+        if (isLimitExceededError(error)) {
+            await fileSystem.restore(rollbackSnapshot);
+            return error.diagnostic;
+        }
+        throw error;
+    }
+}
 async function ensureDirectory(fileSystem, path) {
     await fileSystem.mkdir(path, {
         recursive: true,
@@ -271,3 +382,13 @@ function completeTiming(start, endedAt) {
         durationMs: Math.max(0, Date.now() - start.startedMs),
     };
 }
+function isLimitExceededError(error) {
+    return (error instanceof virtual_file_system_1.ForgeFileSystemError &&
+        error.diagnostic.code === "limit_exceeded");
+}
+function toWarningDiagnostic(diagnostic) {
+    return {
+        ...diagnostic,
+        severity: "warning",
+    };
+}

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

@@ -1,9 +1,10 @@
 import type { ForgeImportMap, ForgePackageDiagnostic, ForgePackageResolutionResult, ForgePackageResolver } from "../package-resolution";
 import type { ForgeEsbuildWasmWorkerDiagnostic, ForgeEsbuildWasmWorkerService } from "../esbuild-wasm-worker";
-import type { ForgeVirtualFileSystem } from "../virtual-file-system";
+import type { ForgeVirtualFileSystem, ForgeVirtualFileSystemStorage } from "../virtual-file-system";
+import type { ForgeTelemetryReporter } from "../telemetry";
 export declare const BUILD_PIPELINE_CAPABILITY: "build-pipeline";
 export type ForgeBuildMode = "production";
-export type ForgeBuildPipelineDiagnosticCode = "esbuild_worker_transform_failed" | "missing_build_script" | "missing_entry" | "unresolved_import" | "unsupported_build_script" | "vite_config_not_executed";
+export type ForgeBuildPipelineDiagnosticCode = "build_cancelled" | "esbuild_worker_transform_failed" | "missing_build_script" | "missing_entry" | "unresolved_import" | "unsupported_build_script" | "vite_config_not_executed";
 export interface ForgeBuildPipelineDiagnostic {
     readonly code: ForgeBuildPipelineDiagnosticCode;
     readonly severity: "error" | "warning";
@@ -22,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;
@@ -29,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;
@@ -44,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;
@@ -60,16 +78,20 @@ export interface ForgeBuildResult {
     readonly outputFiles: readonly ForgeBuildOutputFile[];
     readonly diagnostics: readonly ForgeBuildDiagnostic[];
     readonly packageResolution?: ForgePackageResolutionResult;
+    readonly viteConfig?: ForgeViteConfigMetadata;
     readonly timing: ForgeBuildTiming;
 }
 export interface ForgeBuildPipelineOptions {
     readonly fileSystem: ForgeVirtualFileSystem;
     readonly packageResolver: ForgePackageResolver;
     readonly esbuildWorker?: ForgeEsbuildWasmWorkerService;
+    readonly telemetry?: ForgeTelemetryReporter;
     readonly now?: () => string;
+    readonly storage?: ForgeVirtualFileSystemStorage;
 }
 export interface ForgeBuildRequest {
     readonly entry?: string;
+    readonly signal?: AbortSignal;
 }
 export interface ForgeBuildPipeline {
     readonly capability: typeof BUILD_PIPELINE_CAPABILITY;

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>;

package/dist/build-pipeline/vite-config.js

@@ -0,0 +1,215 @@
+"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.readViteConfigMetadata = exports.VITE_CONFIG_PATHS = void 0;
+const ts = __importStar(require("typescript"));
+const virtual_file_system_1 = require("../virtual-file-system");
+exports.VITE_CONFIG_PATHS = [
+    "/vite.config.js",
+    "/vite.config.mjs",
+    "/vite.config.ts",
+];
+async function readViteConfigMetadata(fileSystem) {
+    const detectedPaths = [];
+    for (const path of exports.VITE_CONFIG_PATHS) {
+        if (await fileSystem.exists(path)) {
+            detectedPaths.push(path);
+        }
+    }
+    const selectedPath = detectedPaths[0];
+    if (selectedPath === undefined) {
+        return {
+            detectedPaths,
+        };
+    }
+    return {
+        detectedPaths,
+        metadata: parseViteConfigMetadata(selectedPath, await fileSystem.readText(selectedPath)),
+    };
+}
+exports.readViteConfigMetadata = readViteConfigMetadata;
+function parseViteConfigMetadata(path, source) {
+    const sourceFile = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true, scriptKindForPath(path));
+    const configObject = findDefaultConfigObject(sourceFile);
+    if (configObject === undefined) {
+        return {
+            aliases: {},
+            define: {},
+            path,
+        };
+    }
+    return {
+        aliases: parseAliasMap(configObject),
+        base: parseBase(configObject),
+        define: parseDefineMap(configObject),
+        path,
+    };
+}
+function findDefaultConfigObject(sourceFile) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportAssignment(statement)) {
+            continue;
+        }
+        return unwrapConfigObject(statement.expression);
+    }
+    return undefined;
+}
+function unwrapConfigObject(expression) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isObjectLiteralExpression(unwrapped)) {
+        return unwrapped;
+    }
+    if (ts.isCallExpression(unwrapped) &&
+        unwrapped.arguments.length > 0) {
+        return unwrapConfigObject(unwrapped.arguments[0]);
+    }
+    return undefined;
+}
+function unwrapExpression(expression) {
+    if (ts.isParenthesizedExpression(expression)) {
+        return unwrapExpression(expression.expression);
+    }
+    if (ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression)) {
+        return unwrapExpression(expression.expression);
+    }
+    if (ts.isSatisfiesExpression(expression)) {
+        return unwrapExpression(expression.expression);
+    }
+    return expression;
+}
+function parseAliasMap(configObject) {
+    const resolveObject = getObjectProperty(configObject, "resolve");
+    const aliasObject = resolveObject === undefined ? undefined : getObjectProperty(resolveObject, "alias");
+    if (aliasObject === undefined) {
+        return {};
+    }
+    const aliases = {};
+    for (const property of aliasObject.properties) {
+        if (!ts.isPropertyAssignment(property)) {
+            continue;
+        }
+        const key = getPropertyNameText(property.name);
+        const value = getStringLiteralText(property.initializer);
+        const normalizedValue = value === undefined ? undefined : normalizeAliasReplacement(value);
+        if (key !== undefined && normalizedValue !== undefined) {
+            aliases[key] = normalizedValue;
+        }
+    }
+    return sortRecord(aliases);
+}
+function parseDefineMap(configObject) {
+    const defineObject = getObjectProperty(configObject, "define");
+    if (defineObject === undefined) {
+        return {};
+    }
+    const define = {};
+    for (const property of defineObject.properties) {
+        if (!ts.isPropertyAssignment(property)) {
+            continue;
+        }
+        const key = getPropertyNameText(property.name);
+        const value = getDefineValueText(property.initializer);
+        if (key !== undefined && value !== undefined) {
+            define[key] = value;
+        }
+    }
+    return sortRecord(define);
+}
+function parseBase(configObject) {
+    const baseProperty = getProperty(configObject, "base");
+    return baseProperty === undefined
+        ? undefined
+        : getStringLiteralText(baseProperty.initializer);
+}
+function getObjectProperty(object, propertyName) {
+    const property = getProperty(object, propertyName);
+    if (property === undefined) {
+        return undefined;
+    }
+    const initializer = unwrapExpression(property.initializer);
+    return ts.isObjectLiteralExpression(initializer) ? initializer : undefined;
+}
+function getProperty(object, propertyName) {
+    for (const property of object.properties) {
+        if (!ts.isPropertyAssignment(property)) {
+            continue;
+        }
+        if (getPropertyNameText(property.name) === propertyName) {
+            return property;
+        }
+    }
+    return undefined;
+}
+function getPropertyNameText(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function getStringLiteralText(expression) {
+    const unwrapped = unwrapExpression(expression);
+    if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) {
+        return unwrapped.text;
+    }
+    return undefined;
+}
+function getDefineValueText(expression) {
+    const unwrapped = unwrapExpression(expression);
+    const stringText = getStringLiteralText(unwrapped);
+    if (stringText !== undefined) {
+        return stringText;
+    }
+    if (unwrapped.kind === ts.SyntaxKind.TrueKeyword) {
+        return "true";
+    }
+    if (unwrapped.kind === ts.SyntaxKind.FalseKeyword) {
+        return "false";
+    }
+    if (unwrapped.kind === ts.SyntaxKind.NullKeyword) {
+        return "null";
+    }
+    if (ts.isNumericLiteral(unwrapped)) {
+        return unwrapped.text;
+    }
+    return undefined;
+}
+function normalizeAliasReplacement(value) {
+    const path = value.startsWith("/")
+        ? value
+        : value.startsWith("./")
+            ? value.slice(1)
+            : undefined;
+    if (path === undefined) {
+        return undefined;
+    }
+    const normalized = (0, virtual_file_system_1.normalizeForgePath)(path);
+    return normalized.ok ? normalized.path : undefined;
+}
+function scriptKindForPath(path) {
+    return path.endsWith(".ts") ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+}
+function sortRecord(record) {
+    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}

package/dist/dev-server-preview/index.d.ts

@@ -1,4 +1,4 @@
 export { createMissingDevScriptDiagnostic, createSessionNotFoundDiagnostic, createSessionStoppedDiagnostic, createUnsupportedDevScriptDiagnostic, } from "./diagnostics";
-export { createForgePreviewDocument } from "./preview-document";
+export { createForgePreviewDocument, createForgePreviewErrorOverlayDocument, } from "./preview-document";
 export { createDevServerPreview, DefaultDevServerPreview, isSupportedViteDevScript, } from "./server";
-export { DEV_SERVER_PREVIEW_CAPABILITY, type ForgeCreatePreviewDocumentOptions, type ForgeDevServerPreview, type ForgeDevServerPreviewDiagnostic, type ForgeDevServerPreviewDiagnosticCode, type ForgeDevServerPreviewEvent, type ForgeDevServerPreviewEventListener, type ForgeDevServerPreviewOptions, type ForgeDevSession, type ForgeDevSessionDiagnostic, type ForgeDevSessionFailedEvent, type ForgeDevSessionFileChange, type ForgeDevSessionRefreshResult, type ForgeDevSessionStartedEvent, type ForgeDevSessionStartResult, type ForgeDevSessionStatus, type ForgeDevSessionStoppedEvent, type ForgeDevSessionStopResult, type ForgePreviewDocument, type ForgePreviewRefreshedEvent, type ForgeRebuildDevSessionOptions, type ForgeStartDevSessionOptions, } from "./types";
+export { DEV_SERVER_PREVIEW_CAPABILITY, type ForgeCreatePreviewDocumentOptions, type ForgeDevServerAdapterFramework, type ForgeDevServerAdapterHmrMode, type ForgeDevServerAdapterMetadata, type ForgeDevServerAdapterName, type ForgeDevServerPreview, type ForgeDevServerPreviewDiagnostic, type ForgeDevServerPreviewDiagnosticCode, type ForgeDevServerPreviewEvent, type ForgeDevServerPreviewEventListener, type ForgeDevServerPreviewOptions, type ForgeDevSession, type ForgeDevSessionDiagnostic, type ForgeDevSessionFailedEvent, type ForgeDevSessionFileChange, type ForgeDevSessionRefreshResult, type ForgeDevSessionStartedEvent, type ForgeDevSessionStartResult, type ForgeDevSessionStatus, type ForgeDevSessionStoppedEvent, type ForgeDevSessionStopResult, type ForgePreviewDocument, type ForgePreviewModuleUpdate, type ForgePreviewModuleUpdatedEvent, type ForgePreviewRefreshedEvent, type ForgePreviewStyleUpdate, type ForgePreviewStyleUpdatedEvent, type ForgeRebuildDevSessionOptions, type ForgeStartDevSessionOptions, } from "./types";

package/dist/dev-server-preview/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEV_SERVER_PREVIEW_CAPABILITY = exports.isSupportedViteDevScript = exports.DefaultDevServerPreview = exports.createDevServerPreview = exports.createForgePreviewDocument = exports.createUnsupportedDevScriptDiagnostic = exports.createSessionStoppedDiagnostic = exports.createSessionNotFoundDiagnostic = exports.createMissingDevScriptDiagnostic = void 0;
+exports.DEV_SERVER_PREVIEW_CAPABILITY = exports.isSupportedViteDevScript = exports.DefaultDevServerPreview = exports.createDevServerPreview = exports.createForgePreviewErrorOverlayDocument = exports.createForgePreviewDocument = exports.createUnsupportedDevScriptDiagnostic = exports.createSessionStoppedDiagnostic = exports.createSessionNotFoundDiagnostic = exports.createMissingDevScriptDiagnostic = void 0;
 var diagnostics_1 = require("./diagnostics");
 Object.defineProperty(exports, "createMissingDevScriptDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createMissingDevScriptDiagnostic; } });
 Object.defineProperty(exports, "createSessionNotFoundDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createSessionNotFoundDiagnostic; } });
@@ -8,6 +8,7 @@ Object.defineProperty(exports, "createSessionStoppedDiagnostic", { enumerable: t
 Object.defineProperty(exports, "createUnsupportedDevScriptDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnsupportedDevScriptDiagnostic; } });
 var preview_document_1 = require("./preview-document");
 Object.defineProperty(exports, "createForgePreviewDocument", { enumerable: true, get: function () { return preview_document_1.createForgePreviewDocument; } });
+Object.defineProperty(exports, "createForgePreviewErrorOverlayDocument", { enumerable: true, get: function () { return preview_document_1.createForgePreviewErrorOverlayDocument; } });
 var server_1 = require("./server");
 Object.defineProperty(exports, "createDevServerPreview", { enumerable: true, get: function () { return server_1.createDevServerPreview; } });
 Object.defineProperty(exports, "DefaultDevServerPreview", { enumerable: true, get: function () { return server_1.DefaultDevServerPreview; } });

package/dist/dev-server-preview/preview-document.d.ts

@@ -1,2 +1,3 @@
-import type { ForgeCreatePreviewDocumentOptions, ForgePreviewDocument } from "./types";
+import type { ForgeCreatePreviewDocumentOptions, ForgeDevSessionDiagnostic, ForgePreviewDocument } from "./types";
 export declare function createForgePreviewDocument(options: ForgeCreatePreviewDocumentOptions): ForgePreviewDocument;
+export declare function createForgePreviewErrorOverlayDocument(previewDocument: ForgePreviewDocument, diagnostics: readonly ForgeDevSessionDiagnostic[]): ForgePreviewDocument;