@caryhu/codemine-forge 0.0.1-alpha.0

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

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupportedViteDevScript = exports.createDevServerPreview = exports.DefaultDevServerPreview = void 0;
+const package_resolution_1 = require("../package-resolution");
+const diagnostics_1 = require("./diagnostics");
+const preview_document_1 = require("./preview-document");
+const types_1 = require("./types");
+class DefaultDevServerPreview {
+    constructor(options) {
+        this.options = options;
+        this.capability = types_1.DEV_SERVER_PREVIEW_CAPABILITY;
+        this.listeners = new Set();
+        this.sessions = new Map();
+        this.nextSessionNumber = 1;
+        this.createSessionId =
+            options.createSessionId ??
+                (() => `dev-${this.nextSessionNumber.toString(36)}`);
+        this.now = options.now ?? (() => new Date().toISOString());
+    }
+    async start(options = {}) {
+        const startedAt = this.now();
+        const sessionId = options.sessionId ?? this.allocateSessionId();
+        const previewUrl = createPreviewUrl(sessionId);
+        const record = {
+            entry: options.entry,
+            session: {
+                id: sessionId,
+                status: "starting",
+                previewUrl,
+                revision: 0,
+                startedAt,
+                updatedAt: startedAt,
+                diagnostics: [],
+            },
+        };
+        this.sessions.set(sessionId, record);
+        const devScriptDiagnostics = await this.validateDevScript();
+        if (devScriptDiagnostics.length > 0) {
+            return this.failStart(record, devScriptDiagnostics, "dev-script");
+        }
+        const buildResult = await this.options.buildPipeline.build({
+            entry: options.entry,
+        });
+        if (!buildResult.success) {
+            return this.failStart(record, buildResult.diagnostics, "initial-build", buildResult);
+        }
+        const previewDocument = await this.createPreviewDocument(sessionId, previewUrl, 1, buildResult);
+        const session = {
+            ...record.session,
+            status: "running",
+            revision: 1,
+            updatedAt: this.now(),
+            diagnostics: buildResult.diagnostics,
+            buildResult,
+            previewDocument,
+        };
+        record.session = session;
+        record.unsubscribe = this.options.fileSystem.watch((event) => {
+            this.handleFileEvent(record, event);
+        });
+        this.emit({ type: "dev:session-started", session });
+        return {
+            success: true,
+            session,
+            diagnostics: buildResult.diagnostics,
+            buildResult,
+        };
+    }
+    async rebuild(sessionId, options = {}) {
+        const record = this.sessions.get(sessionId);
+        if (record === undefined) {
+            const diagnostic = (0, diagnostics_1.createSessionNotFoundDiagnostic)(sessionId);
+            return { success: false, diagnostics: [diagnostic] };
+        }
+        return this.performRebuild(record, options.reason ?? "manual", options.entry);
+    }
+    async stop(sessionId) {
+        const record = this.sessions.get(sessionId);
+        if (record === undefined) {
+            const diagnostic = (0, diagnostics_1.createSessionNotFoundDiagnostic)(sessionId);
+            return { success: false, diagnostics: [diagnostic] };
+        }
+        record.unsubscribe?.();
+        record.unsubscribe = undefined;
+        const session = {
+            ...record.session,
+            status: "stopped",
+            updatedAt: this.now(),
+            diagnostics: [],
+        };
+        record.session = session;
+        this.emit({ type: "dev:session-stopped", session });
+        return {
+            success: true,
+            session,
+            diagnostics: [],
+        };
+    }
+    getSession(sessionId) {
+        return this.sessions.get(sessionId)?.session;
+    }
+    watch(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    async validateDevScript() {
+        try {
+            const manifest = await (0, package_resolution_1.readPackageManifest)(this.options.fileSystem);
+            const devScript = manifest.scripts.dev;
+            if (devScript === undefined) {
+                return [(0, diagnostics_1.createMissingDevScriptDiagnostic)()];
+            }
+            if (!isSupportedViteDevScript(devScript)) {
+                return [(0, diagnostics_1.createUnsupportedDevScriptDiagnostic)(devScript)];
+            }
+            return [];
+        }
+        catch (error) {
+            if (error instanceof package_resolution_1.ForgePackageResolutionError) {
+                return [error.diagnostic];
+            }
+            throw error;
+        }
+    }
+    async failStart(record, diagnostics, reason, buildResult) {
+        const session = {
+            ...record.session,
+            status: "failed",
+            updatedAt: this.now(),
+            diagnostics,
+            buildResult,
+        };
+        record.session = session;
+        this.emit({
+            type: "dev:session-failed",
+            session,
+            diagnostics,
+            buildResult,
+            reason,
+        });
+        return {
+            success: false,
+            session,
+            diagnostics,
+            buildResult,
+        };
+    }
+    handleFileEvent(record, event) {
+        const change = describeFileChange(event);
+        if (change === undefined || record.session.status === "stopped") {
+            return;
+        }
+        const previous = record.rebuildQueue ?? Promise.resolve(undefined);
+        const next = previous.then(() => this.performRebuild(record, change.reason, record.entry));
+        record.rebuildQueue = next;
+        void next.catch(() => {
+            record.rebuildQueue = undefined;
+        });
+    }
+    async performRebuild(record, reason, entry) {
+        if (record.session.status === "stopped") {
+            const diagnostic = (0, diagnostics_1.createSessionStoppedDiagnostic)(record.session.id);
+            return {
+                success: false,
+                session: record.session,
+                diagnostics: [diagnostic],
+            };
+        }
+        record.session = {
+            ...record.session,
+            status: "rebuilding",
+            updatedAt: this.now(),
+        };
+        const buildResult = await this.options.buildPipeline.build({ entry });
+        if (!buildResult.success) {
+            const session = {
+                ...record.session,
+                status: "failed",
+                updatedAt: this.now(),
+                diagnostics: buildResult.diagnostics,
+                buildResult,
+            };
+            record.session = session;
+            this.emit({
+                type: "dev:session-failed",
+                session,
+                diagnostics: buildResult.diagnostics,
+                buildResult,
+                reason,
+            });
+            return {
+                success: false,
+                session,
+                diagnostics: buildResult.diagnostics,
+                buildResult,
+            };
+        }
+        const revision = record.session.revision + 1;
+        const previewDocument = await this.createPreviewDocument(record.session.id, record.session.previewUrl, revision, buildResult);
+        const session = {
+            ...record.session,
+            status: "running",
+            revision,
+            updatedAt: this.now(),
+            diagnostics: buildResult.diagnostics,
+            buildResult,
+            previewDocument,
+        };
+        record.session = session;
+        this.emit({
+            type: "preview:refreshed",
+            session,
+            buildResult,
+            reason,
+        });
+        return {
+            success: true,
+            session,
+            diagnostics: buildResult.diagnostics,
+            buildResult,
+        };
+    }
+    async createPreviewDocument(sessionId, previewUrl, revision, buildResult) {
+        const htmlShell = (await this.options.fileSystem.exists("/index.html"))
+            ? await this.options.fileSystem.readText("/index.html")
+            : undefined;
+        return (0, preview_document_1.createForgePreviewDocument)({
+            buildResult,
+            htmlShell,
+            previewUrl,
+            revision,
+            sessionId,
+        });
+    }
+    allocateSessionId() {
+        const sessionId = this.createSessionId();
+        this.nextSessionNumber += 1;
+        return sessionId;
+    }
+    emit(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Dev-session listeners are observers and must not break the session.
+            }
+        }
+    }
+}
+exports.DefaultDevServerPreview = DefaultDevServerPreview;
+function createDevServerPreview(options) {
+    return new DefaultDevServerPreview(options);
+}
+exports.createDevServerPreview = createDevServerPreview;
+function isSupportedViteDevScript(script) {
+    const argv = script.trim().split(/\s+/);
+    if (argv[0] !== "vite") {
+        return false;
+    }
+    return (argv.length === 1 ||
+        argv[1] === "dev" ||
+        argv[1].startsWith("-"));
+}
+exports.isSupportedViteDevScript = isSupportedViteDevScript;
+function createPreviewUrl(sessionId) {
+    return `/preview/${encodeURIComponent(sessionId)}/`;
+}
+function describeFileChange(event) {
+    const path = event.type === "file:renamed" ? event.to : event.path;
+    if (path.startsWith("/.forge/")) {
+        return undefined;
+    }
+    return {
+        reason: `${event.type}:${path}`,
+    };
+}

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

@@ -0,0 +1,105 @@
+import type { ForgeBuildDiagnostic, ForgeBuildPipeline, ForgeBuildResult } from "../build-pipeline";
+import type { ForgePackageDiagnostic } from "../package-resolution";
+import type { ForgeFileEvent, ForgeUnsubscribe, ForgeVirtualFileSystem } from "../virtual-file-system";
+export declare const DEV_SERVER_PREVIEW_CAPABILITY: "dev-server-preview";
+export type ForgeDevSessionStatus = "starting" | "running" | "rebuilding" | "stopped" | "failed";
+export type ForgeDevServerPreviewDiagnosticCode = "missing_dev_script" | "session_not_found" | "session_stopped" | "unsupported_dev_script";
+export interface ForgeDevServerPreviewDiagnostic {
+    readonly code: ForgeDevServerPreviewDiagnosticCode;
+    readonly severity: "error";
+    readonly message: string;
+    readonly path?: string;
+    readonly script?: string;
+    readonly sessionId?: string;
+}
+export type ForgeDevSessionDiagnostic = ForgeBuildDiagnostic | ForgeDevServerPreviewDiagnostic | ForgePackageDiagnostic;
+export interface ForgePreviewDocument {
+    readonly contentType: "text/html";
+    readonly html: string;
+    readonly revision: number;
+    readonly sessionId: string;
+}
+export interface ForgeDevSession {
+    readonly id: string;
+    readonly status: ForgeDevSessionStatus;
+    readonly previewUrl: string;
+    readonly revision: number;
+    readonly startedAt: string;
+    readonly updatedAt: string;
+    readonly diagnostics: readonly ForgeDevSessionDiagnostic[];
+    readonly buildResult?: ForgeBuildResult;
+    readonly previewDocument?: ForgePreviewDocument;
+}
+export interface ForgeStartDevSessionOptions {
+    readonly entry?: string;
+    readonly sessionId?: string;
+}
+export interface ForgeRebuildDevSessionOptions {
+    readonly entry?: string;
+    readonly reason?: string;
+}
+export interface ForgeDevSessionStartResult {
+    readonly success: boolean;
+    readonly session: ForgeDevSession;
+    readonly diagnostics: readonly ForgeDevSessionDiagnostic[];
+    readonly buildResult?: ForgeBuildResult;
+}
+export interface ForgeDevSessionRefreshResult {
+    readonly success: boolean;
+    readonly session?: ForgeDevSession;
+    readonly diagnostics: readonly ForgeDevSessionDiagnostic[];
+    readonly buildResult?: ForgeBuildResult;
+}
+export interface ForgeDevSessionStopResult {
+    readonly success: boolean;
+    readonly session?: ForgeDevSession;
+    readonly diagnostics: readonly ForgeDevSessionDiagnostic[];
+}
+export type ForgeDevServerPreviewEvent = ForgeDevSessionFailedEvent | ForgeDevSessionStartedEvent | ForgeDevSessionStoppedEvent | ForgePreviewRefreshedEvent;
+export interface ForgeDevSessionStartedEvent {
+    readonly type: "dev:session-started";
+    readonly session: ForgeDevSession;
+}
+export interface ForgeDevSessionStoppedEvent {
+    readonly type: "dev:session-stopped";
+    readonly session: ForgeDevSession;
+}
+export interface ForgePreviewRefreshedEvent {
+    readonly type: "preview:refreshed";
+    readonly session: ForgeDevSession;
+    readonly buildResult: ForgeBuildResult;
+    readonly reason: string;
+}
+export interface ForgeDevSessionFailedEvent {
+    readonly type: "dev:session-failed";
+    readonly session: ForgeDevSession;
+    readonly diagnostics: readonly ForgeDevSessionDiagnostic[];
+    readonly buildResult?: ForgeBuildResult;
+    readonly reason: string;
+}
+export type ForgeDevServerPreviewEventListener = (event: ForgeDevServerPreviewEvent) => void;
+export interface ForgeDevServerPreviewOptions {
+    readonly fileSystem: ForgeVirtualFileSystem;
+    readonly buildPipeline: ForgeBuildPipeline;
+    readonly createSessionId?: () => string;
+    readonly now?: () => string;
+}
+export interface ForgeCreatePreviewDocumentOptions {
+    readonly buildResult: ForgeBuildResult;
+    readonly htmlShell?: string;
+    readonly previewUrl: string;
+    readonly revision: number;
+    readonly sessionId: string;
+}
+export interface ForgeDevServerPreview {
+    readonly capability: typeof DEV_SERVER_PREVIEW_CAPABILITY;
+    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;
+}
+export interface ForgeDevSessionFileChange {
+    readonly event: ForgeFileEvent;
+    readonly reason: string;
+}

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_SERVER_PREVIEW_CAPABILITY = void 0;
+exports.DEV_SERVER_PREVIEW_CAPABILITY = "dev-server-preview";

package/dist/esbuild-wasm-worker/diagnostics.d.ts

@@ -0,0 +1,12 @@
+import type { ForgeEsbuildWasmUnsupportedOperation, ForgeEsbuildWasmWorkerDiagnostic } from "./types";
+interface WorkerStartupFailureInput {
+    readonly workerScriptUrl: string;
+    readonly cause?: unknown;
+    readonly causeCategory?: "message_channel" | "worker_script_load";
+}
+export declare function createWorkerStartupFailureDiagnostic(input: WorkerStartupFailureInput): ForgeEsbuildWasmWorkerDiagnostic;
+export declare function createWasmInitializationFailureDiagnostic(wasmAssetUrl: string, cause?: unknown): ForgeEsbuildWasmWorkerDiagnostic;
+export declare function createWorkerNotInitializedDiagnostic(): ForgeEsbuildWasmWorkerDiagnostic;
+export declare function createUnsupportedOperationDiagnostic(operation: ForgeEsbuildWasmUnsupportedOperation): ForgeEsbuildWasmWorkerDiagnostic;
+export declare function createTransformFailureDiagnostic(path: string, cause?: unknown): ForgeEsbuildWasmWorkerDiagnostic;
+export {};

package/dist/esbuild-wasm-worker/diagnostics.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformFailureDiagnostic = exports.createUnsupportedOperationDiagnostic = exports.createWorkerNotInitializedDiagnostic = exports.createWasmInitializationFailureDiagnostic = exports.createWorkerStartupFailureDiagnostic = void 0;
+function createWorkerStartupFailureDiagnostic(input) {
+    return {
+        code: "worker_startup_failed",
+        severity: "error",
+        message: "Esbuild wasm worker failed to start.",
+        workerScriptUrl: input.workerScriptUrl,
+        causeCategory: input.causeCategory ?? "worker_script_load",
+        cause: input.cause,
+    };
+}
+exports.createWorkerStartupFailureDiagnostic = createWorkerStartupFailureDiagnostic;
+function createWasmInitializationFailureDiagnostic(wasmAssetUrl, cause) {
+    return {
+        code: "wasm_initialization_failed",
+        severity: "error",
+        message: "Esbuild wasm runtime failed to initialize from the wasm asset.",
+        wasmAssetUrl,
+        causeCategory: "runtime_initialization",
+        cause,
+    };
+}
+exports.createWasmInitializationFailureDiagnostic = createWasmInitializationFailureDiagnostic;
+function createWorkerNotInitializedDiagnostic() {
+    return {
+        code: "worker_not_initialized",
+        severity: "error",
+        message: "Esbuild wasm worker has not been initialized.",
+    };
+}
+exports.createWorkerNotInitializedDiagnostic = createWorkerNotInitializedDiagnostic;
+function createUnsupportedOperationDiagnostic(operation) {
+    return {
+        code: "unsupported_operation",
+        severity: "error",
+        message: `Esbuild wasm worker does not support ${operation}.`,
+        operation,
+    };
+}
+exports.createUnsupportedOperationDiagnostic = createUnsupportedOperationDiagnostic;
+function createTransformFailureDiagnostic(path, cause) {
+    return {
+        code: "transform_failed",
+        severity: "error",
+        message: "Esbuild wasm transform failed.",
+        path,
+        causeCategory: "transform",
+        cause,
+    };
+}
+exports.createTransformFailureDiagnostic = createTransformFailureDiagnostic;

package/dist/esbuild-wasm-worker/index.d.ts

@@ -0,0 +1,4 @@
+export { createTransformFailureDiagnostic, createUnsupportedOperationDiagnostic, createWasmInitializationFailureDiagnostic, createWorkerNotInitializedDiagnostic, createWorkerStartupFailureDiagnostic, } from "./diagnostics";
+export { createEsbuildWasmWorkerService, DefaultEsbuildWasmWorkerService, } from "./service";
+export { createEsbuildWasmWorkerMessageHandler, installEsbuildWasmWorker, type ForgeEsbuildWasmRuntime, type ForgeEsbuildWasmWorkerAdapterOptions, type ForgeEsbuildWasmWorkerGlobalScope, } from "./worker-adapter";
+export { ESBUILD_WASM_WORKER_CAPABILITY, ESBUILD_WASM_WORKER_PROTOCOL, type ForgeEsbuildWasmDiagnosticCauseCategory, type ForgeEsbuildWasmInitializeRequest, type ForgeEsbuildWasmInitializeResult, type ForgeEsbuildWasmInitializeSuccessResult, type ForgeEsbuildWasmInitializeFailureResult, type ForgeEsbuildWasmInitializeWorkerFailureResponse, type ForgeEsbuildWasmInitializeWorkerRequest, type ForgeEsbuildWasmInitializeWorkerSuccessResponse, type ForgeEsbuildWasmRuntimeMetadata, type ForgeEsbuildWasmTransformFailureResult, type ForgeEsbuildWasmTransformLoader, type ForgeEsbuildWasmTransformRequest, type ForgeEsbuildWasmTransformResult, type ForgeEsbuildWasmTransformSuccessResult, type ForgeEsbuildWasmTransformWarning, type ForgeEsbuildWasmTransformWorkerFailureResponse, type ForgeEsbuildWasmTransformWorkerRequest, type ForgeEsbuildWasmTransformWorkerSuccessResponse, type ForgeEsbuildWasmUnsupportedOperation, type ForgeEsbuildWasmUnsupportedOperationResult, type ForgeEsbuildWasmUrl, type ForgeEsbuildWasmWorkerDiagnostic, type ForgeEsbuildWasmWorkerDiagnosticCode, type ForgeEsbuildWasmWorkerFactory, type ForgeEsbuildWasmWorkerMessageEvent, type ForgeEsbuildWasmWorkerPort, type ForgeEsbuildWasmWorkerRequestMessage, type ForgeEsbuildWasmWorkerResponseMessage, type ForgeEsbuildWasmWorkerService, type ForgeEsbuildWasmWorkerServiceOptions, } from "./types";

package/dist/esbuild-wasm-worker/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESBUILD_WASM_WORKER_PROTOCOL = exports.ESBUILD_WASM_WORKER_CAPABILITY = exports.installEsbuildWasmWorker = exports.createEsbuildWasmWorkerMessageHandler = exports.DefaultEsbuildWasmWorkerService = exports.createEsbuildWasmWorkerService = exports.createWorkerStartupFailureDiagnostic = exports.createWorkerNotInitializedDiagnostic = exports.createWasmInitializationFailureDiagnostic = exports.createUnsupportedOperationDiagnostic = exports.createTransformFailureDiagnostic = void 0;
+var diagnostics_1 = require("./diagnostics");
+Object.defineProperty(exports, "createTransformFailureDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createTransformFailureDiagnostic; } });
+Object.defineProperty(exports, "createUnsupportedOperationDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnsupportedOperationDiagnostic; } });
+Object.defineProperty(exports, "createWasmInitializationFailureDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createWasmInitializationFailureDiagnostic; } });
+Object.defineProperty(exports, "createWorkerNotInitializedDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createWorkerNotInitializedDiagnostic; } });
+Object.defineProperty(exports, "createWorkerStartupFailureDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createWorkerStartupFailureDiagnostic; } });
+var service_1 = require("./service");
+Object.defineProperty(exports, "createEsbuildWasmWorkerService", { enumerable: true, get: function () { return service_1.createEsbuildWasmWorkerService; } });
+Object.defineProperty(exports, "DefaultEsbuildWasmWorkerService", { enumerable: true, get: function () { return service_1.DefaultEsbuildWasmWorkerService; } });
+var worker_adapter_1 = require("./worker-adapter");
+Object.defineProperty(exports, "createEsbuildWasmWorkerMessageHandler", { enumerable: true, get: function () { return worker_adapter_1.createEsbuildWasmWorkerMessageHandler; } });
+Object.defineProperty(exports, "installEsbuildWasmWorker", { enumerable: true, get: function () { return worker_adapter_1.installEsbuildWasmWorker; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "ESBUILD_WASM_WORKER_CAPABILITY", { enumerable: true, get: function () { return types_1.ESBUILD_WASM_WORKER_CAPABILITY; } });
+Object.defineProperty(exports, "ESBUILD_WASM_WORKER_PROTOCOL", { enumerable: true, get: function () { return types_1.ESBUILD_WASM_WORKER_PROTOCOL; } });

package/dist/esbuild-wasm-worker/service.d.ts

@@ -0,0 +1,26 @@
+import { type ForgeEsbuildWasmInitializeRequest, type ForgeEsbuildWasmInitializeResult, type ForgeEsbuildWasmTransformResult, type ForgeEsbuildWasmUnsupportedOperation, type ForgeEsbuildWasmUnsupportedOperationResult, type ForgeEsbuildWasmWorkerService, type ForgeEsbuildWasmWorkerServiceOptions, type ForgeEsbuildWasmTransformRequest } from "./types";
+export declare class DefaultEsbuildWasmWorkerService implements ForgeEsbuildWasmWorkerService {
+    readonly capability: "esbuild-wasm-worker";
+    private readonly requestTimeoutMs;
+    private readonly workerFactory;
+    private readonly workerScriptUrl;
+    private readonly wasmAssetUrl;
+    private readonly pendingRequests;
+    private worker;
+    private nextRequestId;
+    private initializePromise;
+    private initializedResult;
+    private readonly handleMessage;
+    private readonly handleError;
+    constructor(options: ForgeEsbuildWasmWorkerServiceOptions);
+    initialize(request?: ForgeEsbuildWasmInitializeRequest): Promise<ForgeEsbuildWasmInitializeResult>;
+    transform(request: ForgeEsbuildWasmTransformRequest): Promise<ForgeEsbuildWasmTransformResult>;
+    unsupportedOperation(operation: ForgeEsbuildWasmUnsupportedOperation): ForgeEsbuildWasmUnsupportedOperationResult;
+    dispose(): void;
+    private initializeWorker;
+    private requestWorker;
+    private ensureWorker;
+    private failPendingRequests;
+    private createRequestId;
+}
+export declare function createEsbuildWasmWorkerService(options: ForgeEsbuildWasmWorkerServiceOptions): ForgeEsbuildWasmWorkerService;