@caryhu/codemine-forge 0.0.1-alpha.0

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

@@ -0,0 +1,12 @@
+import { type ForgeBuildPipeline, type ForgeBuildPipelineOptions, type ForgeBuildRequest, type ForgeBuildResult } from "./types";
+export declare class DefaultBuildPipeline implements ForgeBuildPipeline {
+    private readonly options;
+    readonly capability: "build-pipeline";
+    private readonly now;
+    constructor(options: ForgeBuildPipelineOptions);
+    build(request?: ForgeBuildRequest): Promise<ForgeBuildResult>;
+    private resolveEntry;
+    private failure;
+}
+export declare function createBuildPipeline(options: ForgeBuildPipelineOptions): ForgeBuildPipeline;
+export declare function isSupportedViteBuildScript(script: string): boolean;

package/dist/build-pipeline/pipeline.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupportedViteBuildScript = exports.createBuildPipeline = exports.DefaultBuildPipeline = void 0;
+const package_resolution_1 = require("../package-resolution");
+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 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",
+    "/src/main.ts",
+    "/src/main.js",
+];
+class DefaultBuildPipeline {
+    constructor(options) {
+        this.options = options;
+        this.capability = types_1.BUILD_PIPELINE_CAPABILITY;
+        this.now = options.now ?? (() => new Date().toISOString());
+    }
+    async build(request = {}) {
+        const timingStart = createTimingStart(this.now());
+        const mode = "production";
+        const warningDiagnostics = await detectViteConfigDiagnostics(this.options.fileSystem);
+        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);
+            }
+            throw error;
+        }
+        const buildScript = manifest.scripts.build;
+        if (buildScript === undefined) {
+            return this.failure(mode, [(0, diagnostics_1.createMissingBuildScriptDiagnostic)(), ...warningDiagnostics], timingStart);
+        }
+        if (!isSupportedViteBuildScript(buildScript)) {
+            return this.failure(mode, [
+                (0, diagnostics_1.createUnsupportedBuildScriptDiagnostic)(buildScript),
+                ...warningDiagnostics,
+            ], timingStart);
+        }
+        const entry = await this.resolveEntry(request.entry);
+        if (entry === undefined) {
+            return this.failure(mode, [(0, diagnostics_1.createMissingEntryDiagnostic)(), ...warningDiagnostics], timingStart);
+        }
+        try {
+            const packageResolution = await this.options.packageResolver.resolve();
+            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),
+            });
+            if (browserBundleResult.diagnostics.length > 0) {
+                return this.failure(mode, [...browserBundleResult.diagnostics, ...warningDiagnostics], timingStart);
+            }
+            const buildManifest = createBuildManifest(entry, mode, sourceFiles, packageResolution, browserBundleResult.browserBundle);
+            const outputFiles = [
+                createBuildManifestOutput(buildManifest),
+                ...browserBundleResult.outputFiles,
+            ];
+            await writeBuildOutputFiles(this.options.fileSystem, outputFiles);
+            return {
+                success: true,
+                mode,
+                entry,
+                browserBundle: browserBundleResult.browserBundle,
+                manifest: buildManifest,
+                outputFiles,
+                diagnostics: warningDiagnostics,
+                packageResolution,
+                timing: completeTiming(timingStart, this.now()),
+            };
+        }
+        catch (error) {
+            if (error instanceof package_resolution_1.ForgePackageResolutionError) {
+                return this.failure(mode, [error.diagnostic, ...warningDiagnostics], timingStart);
+            }
+            throw error;
+        }
+    }
+    async resolveEntry(requestedEntry) {
+        if (requestedEntry !== undefined) {
+            const normalized = (0, virtual_file_system_1.normalizeForgePath)(requestedEntry);
+            return normalized.ok &&
+                (await this.options.fileSystem.exists(normalized.path))
+                ? normalized.path
+                : undefined;
+        }
+        const htmlEntry = await findHtmlModuleEntry(this.options.fileSystem);
+        if (htmlEntry !== undefined) {
+            return htmlEntry;
+        }
+        for (const candidate of DEFAULT_ENTRY_CANDIDATES) {
+            if (await this.options.fileSystem.exists(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    failure(mode, diagnostics, timingStart) {
+        return {
+            success: false,
+            mode,
+            outputFiles: [],
+            diagnostics,
+            timing: completeTiming(timingStart, this.now()),
+        };
+    }
+}
+exports.DefaultBuildPipeline = DefaultBuildPipeline;
+function createEsbuildWorkerScriptTransformer(esbuildWorker) {
+    if (esbuildWorker === undefined) {
+        return undefined;
+    }
+    let initialized = false;
+    return async ({ loader, sourcePath, sourceText }) => {
+        if (!initialized) {
+            const initializeResult = await esbuildWorker.initialize();
+            if (!initializeResult.success) {
+                return {
+                    success: false,
+                    diagnostics: [
+                        (0, diagnostics_1.createEsbuildWorkerTransformDiagnostic)(sourcePath, initializeResult.diagnostics[0] ?? initializeResult.diagnostics),
+                    ],
+                };
+            }
+            initialized = true;
+        }
+        const transformResult = await esbuildWorker.transform({
+            loader,
+            sourcePath,
+            sourceText,
+            target: "es2020",
+        });
+        if (!transformResult.success) {
+            return {
+                success: false,
+                diagnostics: [
+                    (0, diagnostics_1.createEsbuildWorkerTransformDiagnostic)(sourcePath, transformResult.diagnostics[0] ?? transformResult.diagnostics),
+                ],
+            };
+        }
+        return {
+            success: true,
+            outputText: transformResult.outputText,
+            diagnostics: [],
+        };
+    };
+}
+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 createBuildPipeline(options) {
+    return new DefaultBuildPipeline(options);
+}
+exports.createBuildPipeline = createBuildPipeline;
+function isSupportedViteBuildScript(script) {
+    const argv = script.trim().split(/\s+/);
+    return argv.length >= 2 && argv[0] === "vite" && argv[1] === "build";
+}
+exports.isSupportedViteBuildScript = isSupportedViteBuildScript;
+async function findHtmlModuleEntry(fileSystem) {
+    if (!(await fileSystem.exists("/index.html"))) {
+        return undefined;
+    }
+    const html = await fileSystem.readText("/index.html");
+    const scriptTags = html.match(/<script\b[^>]*>/gi) ?? [];
+    for (const scriptTag of scriptTags) {
+        if (!/\btype\s*=\s*["']module["']/i.test(scriptTag)) {
+            continue;
+        }
+        const sourceMatch = scriptTag.match(/\bsrc\s*=\s*["']([^"']+)["']/i);
+        if (sourceMatch === null) {
+            continue;
+        }
+        const normalized = (0, virtual_file_system_1.normalizeForgePath)(sourceMatch[1]);
+        if (normalized.ok && (await fileSystem.exists(normalized.path))) {
+            return normalized.path;
+        }
+    }
+    return undefined;
+}
+async function collectSourceFiles(fileSystem, path = "/") {
+    if (path === "/.forge" || path.startsWith("/.forge/")) {
+        return [];
+    }
+    const entries = await fileSystem.readdir(path);
+    const files = [];
+    for (const entry of entries) {
+        if (entry.kind === "directory") {
+            files.push(...(await collectSourceFiles(fileSystem, entry.path)));
+            continue;
+        }
+        files.push(entry.path);
+    }
+    return files.sort((left, right) => left.localeCompare(right));
+}
+function createBuildManifest(entry, mode, sourceFiles, packageResolution, browserBundle) {
+    return {
+        entry,
+        mode,
+        sourceFiles,
+        packageNames: packageResolution.packages.map((record) => record.name),
+        packageResolutionMode: packageResolution.lock.resolutionMode,
+        browserBundle: browserBundle === undefined
+            ? undefined
+            : {
+                entryOutputPath: browserBundle.entryOutputPath,
+                format: browserBundle.format,
+                importMapPath: browserBundle.importMapPath,
+                moduleCount: browserBundle.moduleCount,
+                outputPaths: browserBundle.outputPaths,
+            },
+    };
+}
+function createBuildManifestOutput(manifest) {
+    const content = `${JSON.stringify(manifest, null, 2)}\n`;
+    return {
+        path: BUILD_MANIFEST_PATH,
+        content,
+        contentType: "application/json",
+        size: new TextEncoder().encode(content).byteLength,
+    };
+}
+async function writeBuildOutputFiles(fileSystem, outputFiles) {
+    for (const outputFile of outputFiles) {
+        await ensureDirectory(fileSystem, dirname(outputFile.path));
+        await fileSystem.writeFile(outputFile.path, outputFile.content, {
+            contentType: outputFile.contentType,
+            source: "generated",
+        });
+    }
+}
+async function ensureDirectory(fileSystem, path) {
+    await fileSystem.mkdir(path, {
+        recursive: true,
+        source: "generated",
+    });
+}
+function dirname(path) {
+    const index = path.lastIndexOf("/");
+    return index <= 0 ? "/" : path.slice(0, index);
+}
+function createTimingStart(startedAt) {
+    return {
+        startedAt,
+        startedMs: Date.now(),
+    };
+}
+function completeTiming(start, endedAt) {
+    return {
+        startedAt: start.startedAt,
+        endedAt,
+        durationMs: Math.max(0, Date.now() - start.startedMs),
+    };
+}

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

@@ -0,0 +1,77 @@
+import type { ForgeImportMap, ForgePackageDiagnostic, ForgePackageResolutionResult, ForgePackageResolver } from "../package-resolution";
+import type { ForgeEsbuildWasmWorkerDiagnostic, ForgeEsbuildWasmWorkerService } from "../esbuild-wasm-worker";
+import type { ForgeVirtualFileSystem } from "../virtual-file-system";
+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 interface ForgeBuildPipelineDiagnostic {
+    readonly code: ForgeBuildPipelineDiagnosticCode;
+    readonly severity: "error" | "warning";
+    readonly message: string;
+    readonly path?: string;
+    readonly script?: string;
+    readonly importSpecifier?: string;
+    readonly importer?: string;
+    readonly cause?: unknown;
+    readonly workerDiagnostic?: ForgeEsbuildWasmWorkerDiagnostic;
+}
+export type ForgeBuildDiagnostic = ForgeBuildPipelineDiagnostic | ForgePackageDiagnostic;
+export interface ForgeBuildOutputFile {
+    readonly path: string;
+    readonly content: string;
+    readonly contentType: string;
+    readonly size: number;
+}
+export interface ForgeBuildManifest {
+    readonly entry: string;
+    readonly mode: ForgeBuildMode;
+    readonly sourceFiles: readonly string[];
+    readonly packageNames: readonly string[];
+    readonly packageResolutionMode: string;
+    readonly browserBundle?: ForgeBrowserBundleManifest;
+}
+export interface ForgeBrowserBundleManifest {
+    readonly entryOutputPath: string;
+    readonly format: "esm";
+    readonly importMapPath: string;
+    readonly moduleCount: number;
+    readonly outputPaths: readonly string[];
+}
+export interface ForgeBrowserBundle {
+    readonly entry: string;
+    readonly entryOutputPath: string;
+    readonly format: "esm";
+    readonly importMap: ForgeImportMap;
+    readonly importMapPath: string;
+    readonly moduleCount: number;
+    readonly outputPaths: readonly string[];
+}
+export interface ForgeBuildTiming {
+    readonly startedAt: string;
+    readonly endedAt: string;
+    readonly durationMs: number;
+}
+export interface ForgeBuildResult {
+    readonly success: boolean;
+    readonly mode: ForgeBuildMode;
+    readonly entry?: string;
+    readonly browserBundle?: ForgeBrowserBundle;
+    readonly manifest?: ForgeBuildManifest;
+    readonly outputFiles: readonly ForgeBuildOutputFile[];
+    readonly diagnostics: readonly ForgeBuildDiagnostic[];
+    readonly packageResolution?: ForgePackageResolutionResult;
+    readonly timing: ForgeBuildTiming;
+}
+export interface ForgeBuildPipelineOptions {
+    readonly fileSystem: ForgeVirtualFileSystem;
+    readonly packageResolver: ForgePackageResolver;
+    readonly esbuildWorker?: ForgeEsbuildWasmWorkerService;
+    readonly now?: () => string;
+}
+export interface ForgeBuildRequest {
+    readonly entry?: string;
+}
+export interface ForgeBuildPipeline {
+    readonly capability: typeof BUILD_PIPELINE_CAPABILITY;
+    build(request?: ForgeBuildRequest): Promise<ForgeBuildResult>;
+}

package/dist/build-pipeline/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILD_PIPELINE_CAPABILITY = void 0;
+exports.BUILD_PIPELINE_CAPABILITY = "build-pipeline";

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

@@ -0,0 +1,5 @@
+import type { ForgeDevServerPreviewDiagnostic } from "./types";
+export declare function createMissingDevScriptDiagnostic(): ForgeDevServerPreviewDiagnostic;
+export declare function createUnsupportedDevScriptDiagnostic(script: string): ForgeDevServerPreviewDiagnostic;
+export declare function createSessionNotFoundDiagnostic(sessionId: string): ForgeDevServerPreviewDiagnostic;
+export declare function createSessionStoppedDiagnostic(sessionId: string): ForgeDevServerPreviewDiagnostic;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionStoppedDiagnostic = exports.createSessionNotFoundDiagnostic = exports.createUnsupportedDevScriptDiagnostic = exports.createMissingDevScriptDiagnostic = void 0;
+function createMissingDevScriptDiagnostic() {
+    return {
+        code: "missing_dev_script",
+        severity: "error",
+        message: "Missing package.json scripts.dev for Forge preview.",
+        path: "/package.json",
+    };
+}
+exports.createMissingDevScriptDiagnostic = createMissingDevScriptDiagnostic;
+function createUnsupportedDevScriptDiagnostic(script) {
+    return {
+        code: "unsupported_dev_script",
+        severity: "error",
+        message: `Unsupported dev script for Forge preview: ${script}.`,
+        path: "/package.json",
+        script,
+    };
+}
+exports.createUnsupportedDevScriptDiagnostic = createUnsupportedDevScriptDiagnostic;
+function createSessionNotFoundDiagnostic(sessionId) {
+    return {
+        code: "session_not_found",
+        severity: "error",
+        message: `Forge dev session was not found: ${sessionId}.`,
+        sessionId,
+    };
+}
+exports.createSessionNotFoundDiagnostic = createSessionNotFoundDiagnostic;
+function createSessionStoppedDiagnostic(sessionId) {
+    return {
+        code: "session_stopped",
+        severity: "error",
+        message: `Forge dev session is stopped: ${sessionId}.`,
+        sessionId,
+    };
+}
+exports.createSessionStoppedDiagnostic = createSessionStoppedDiagnostic;

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

@@ -0,0 +1,4 @@
+export { createMissingDevScriptDiagnostic, createSessionNotFoundDiagnostic, createSessionStoppedDiagnostic, createUnsupportedDevScriptDiagnostic, } from "./diagnostics";
+export { createForgePreviewDocument } 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";

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

@@ -0,0 +1,16 @@
+"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;
+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; } });
+Object.defineProperty(exports, "createSessionStoppedDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createSessionStoppedDiagnostic; } });
+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; } });
+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; } });
+Object.defineProperty(exports, "isSupportedViteDevScript", { enumerable: true, get: function () { return server_1.isSupportedViteDevScript; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "DEV_SERVER_PREVIEW_CAPABILITY", { enumerable: true, get: function () { return types_1.DEV_SERVER_PREVIEW_CAPABILITY; } });

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

@@ -0,0 +1,2 @@
+import type { ForgeCreatePreviewDocumentOptions, ForgePreviewDocument } from "./types";
+export declare function createForgePreviewDocument(options: ForgeCreatePreviewDocumentOptions): ForgePreviewDocument;

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

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createForgePreviewDocument = void 0;
+const DEFAULT_HTML_SHELL = [
+    "<!doctype html>",
+    "<html>",
+    "<head>",
+    '  <meta charset="UTF-8">',
+    '  <meta name="viewport" content="width=device-width, initial-scale=1.0">',
+    "  <title>Forge Preview</title>",
+    "</head>",
+    "<body>",
+    '  <div id="root"></div>',
+    "</body>",
+    "</html>",
+].join("\n");
+const PREVIEW_MODULE_SPECIFIER_PREFIX = "__forge_preview__/";
+function createForgePreviewDocument(options) {
+    const htmlShell = options.htmlShell ?? DEFAULT_HTML_SHELL;
+    const browserBundle = options.buildResult.browserBundle;
+    const previewModuleSpecifiers = browserBundle === undefined
+        ? new Map()
+        : createPreviewModuleSpecifiers(options.buildResult.outputFiles);
+    const previewEntrySpecifier = browserBundle === undefined
+        ? undefined
+        : previewModuleSpecifiers.get(browserBundle.entryOutputPath) ??
+            browserBundle.entryOutputPath;
+    const metadata = {
+        browserBundle: browserBundle === undefined
+            ? undefined
+            : {
+                entryOutputPath: browserBundle.entryOutputPath,
+                format: browserBundle.format,
+                importMapPath: browserBundle.importMapPath,
+                moduleCount: browserBundle.moduleCount,
+                outputPaths: browserBundle.outputPaths,
+            },
+        entry: options.buildResult.entry,
+        mode: options.buildResult.mode,
+        outputFiles: options.buildResult.outputFiles.map((file) => ({
+            contentType: file.contentType,
+            path: file.path,
+            size: file.size,
+        })),
+        previewUrl: options.previewUrl,
+        revision: options.revision,
+        sessionId: options.sessionId,
+    };
+    const buildManifest = options.buildResult.outputFiles.find((file) => file.contentType === "application/json")?.content;
+    const previewImportMap = browserBundle === undefined
+        ? undefined
+        : createPreviewImportMap(options.buildResult.outputFiles, previewModuleSpecifiers);
+    const injection = [
+        `<script type="application/json" id="forge-preview-metadata">${escapeJsonForScript(JSON.stringify(metadata))}</script>`,
+        buildManifest === undefined
+            ? ""
+            : `<script type="application/json" id="forge-build-manifest">${escapeJsonForScript(buildManifest)}</script>`,
+        previewImportMap === undefined
+            ? ""
+            : `<script type="importmap" id="forge-browser-bundle-importmap">${escapeJsonForScript(JSON.stringify(previewImportMap))}</script>`,
+        browserBundle === undefined
+            ? ""
+            : `<script type="module" id="forge-browser-bundle-entry">import ${JSON.stringify(previewEntrySpecifier)};</script>`,
+    ]
+        .filter((line) => line.length > 0)
+        .join("\n");
+    return {
+        contentType: "text/html",
+        html: injectBeforeBodyEnd(removeProjectModuleScripts(htmlShell), injection),
+        revision: options.revision,
+        sessionId: options.sessionId,
+    };
+}
+exports.createForgePreviewDocument = createForgePreviewDocument;
+function createPreviewImportMap(outputFiles, previewModuleSpecifiers) {
+    const importMapFile = outputFiles.find((file) => file.contentType === "application/importmap+json");
+    if (importMapFile === undefined) {
+        return undefined;
+    }
+    const importMap = JSON.parse(importMapFile.content);
+    const outputFileByPath = new Map(outputFiles.map((file) => [file.path, file]));
+    const imports = Object.fromEntries(Object.entries(importMap.imports ?? {}).map(([specifier, target]) => {
+        const outputFile = outputFileByPath.get(target);
+        if (outputFile === undefined) {
+            return [specifier, target];
+        }
+        const previewSpecifier = specifier === target
+            ? previewModuleSpecifiers.get(specifier) ?? specifier
+            : specifier;
+        const content = outputFile.contentType === "text/javascript"
+            ? rewritePreviewModuleSpecifiers(outputFile.content, previewModuleSpecifiers)
+            : outputFile.content;
+        return [previewSpecifier, createDataUrl(content, outputFile.contentType)];
+    }));
+    return { imports };
+}
+function createPreviewModuleSpecifiers(outputFiles) {
+    return new Map(outputFiles
+        .filter((file) => file.contentType === "text/javascript")
+        .map((file) => [file.path, createPreviewModuleSpecifier(file.path)]));
+}
+function createPreviewModuleSpecifier(path) {
+    return `${PREVIEW_MODULE_SPECIFIER_PREFIX}${path.replace(/^\//, "")}`;
+}
+function rewritePreviewModuleSpecifiers(source, previewModuleSpecifiers) {
+    if (previewModuleSpecifiers.size === 0) {
+        return source;
+    }
+    return source
+        .replace(/(\b(?:import|export)\s+(?:[^'"]*?\s+from\s*)?)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
+        const replacement = previewModuleSpecifiers.get(specifier);
+        return replacement === undefined
+            ? match
+            : `${prefix}${quote}${replacement}${quote}`;
+    })
+        .replace(/(\bimport\s*\(\s*)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
+        const replacement = previewModuleSpecifiers.get(specifier);
+        return replacement === undefined
+            ? match
+            : `${prefix}${quote}${replacement}${quote}`;
+    });
+}
+function createDataUrl(content, contentType) {
+    return `data:${contentType};base64,${toBase64(new TextEncoder().encode(content))}`;
+}
+function injectBeforeBodyEnd(html, injection) {
+    const bodyEnd = /<\/body\s*>/i;
+    if (bodyEnd.test(html)) {
+        return html.replace(bodyEnd, `${injection}\n</body>`);
+    }
+    return `${html}\n${injection}`;
+}
+function removeProjectModuleScripts(html) {
+    return html.replace(/<script\b(?=[^>]*\btype\s*=\s*["']module["'])[^>]*>[\s\S]*?<\/script\s*>/gi, "");
+}
+function escapeJsonForScript(json) {
+    return json.replace(/</g, "\\u003c");
+}
+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/dev-server-preview/server.d.ts

@@ -0,0 +1,26 @@
+import type { ForgeUnsubscribe } from "../virtual-file-system";
+import { type ForgeDevServerPreview, type ForgeDevServerPreviewEventListener, type ForgeDevServerPreviewOptions, type ForgeDevSession, type ForgeDevSessionRefreshResult, type ForgeDevSessionStartResult, type ForgeDevSessionStopResult, type ForgeRebuildDevSessionOptions, type ForgeStartDevSessionOptions } from "./types";
+export declare class DefaultDevServerPreview implements ForgeDevServerPreview {
+    private readonly options;
+    readonly capability: "dev-server-preview";
+    private readonly createSessionId;
+    private readonly listeners;
+    private readonly now;
+    private readonly sessions;
+    private nextSessionNumber;
+    constructor(options: ForgeDevServerPreviewOptions);
+    start(options?: ForgeStartDevSessionOptions): Promise<ForgeDevSessionStartResult>;
+    rebuild(sessionId: string, options?: ForgeRebuildDevSessionOptions): Promise<ForgeDevSessionRefreshResult>;
+    stop(sessionId: string): Promise<ForgeDevSessionStopResult>;
+    getSession(sessionId: string): ForgeDevSession | undefined;
+    watch(listener: ForgeDevServerPreviewEventListener): ForgeUnsubscribe;
+    private validateDevScript;
+    private failStart;
+    private handleFileEvent;
+    private performRebuild;
+    private createPreviewDocument;
+    private allocateSessionId;
+    private emit;
+}
+export declare function createDevServerPreview(options: ForgeDevServerPreviewOptions): ForgeDevServerPreview;
+export declare function isSupportedViteDevScript(script: string): boolean;