@caryhu/codemine-forge 0.0.1-alpha.0

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

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEsbuildWasmWorkerService = exports.DefaultEsbuildWasmWorkerService = void 0;
+const diagnostics_1 = require("./diagnostics");
+const types_1 = require("./types");
+const DEFAULT_REQUEST_TIMEOUT_MS = 5000;
+class DefaultEsbuildWasmWorkerService {
+    constructor(options) {
+        this.capability = types_1.ESBUILD_WASM_WORKER_CAPABILITY;
+        this.pendingRequests = new Map();
+        this.nextRequestId = 1;
+        this.handleMessage = (event) => {
+            const message = event.data;
+            if (!isWorkerResponseMessage(message)) {
+                return;
+            }
+            const pending = this.pendingRequests.get(message.id);
+            if (pending === undefined) {
+                return;
+            }
+            this.pendingRequests.delete(message.id);
+            clearTimeout(pending.timeoutId);
+            pending.resolve(message);
+        };
+        this.handleError = (event) => {
+            const diagnostic = (0, diagnostics_1.createWorkerStartupFailureDiagnostic)({
+                workerScriptUrl: stringifyUrl(this.workerScriptUrl),
+                cause: getEventCause(event),
+                causeCategory: "message_channel",
+            });
+            this.failPendingRequests([diagnostic]);
+        };
+        this.workerScriptUrl = options.workerScriptUrl;
+        this.wasmAssetUrl = options.wasmAssetUrl;
+        this.requestTimeoutMs =
+            options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        this.workerFactory = options.workerFactory ?? createDefaultWorker;
+    }
+    async initialize(request = {}) {
+        if (this.initializedResult !== undefined) {
+            return this.initializedResult;
+        }
+        if (this.initializePromise !== undefined) {
+            return this.initializePromise;
+        }
+        this.initializePromise = this.initializeWorker(request);
+        const result = await this.initializePromise;
+        if (result.success) {
+            this.initializedResult = result;
+        }
+        else {
+            this.initializePromise = undefined;
+        }
+        return result;
+    }
+    async transform(request) {
+        if (this.initializedResult === undefined) {
+            return {
+                success: false,
+                diagnostics: [(0, diagnostics_1.createWorkerNotInitializedDiagnostic)()],
+            };
+        }
+        const id = this.createRequestId();
+        const message = {
+            protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+            id,
+            type: "transform",
+            payload: request,
+        };
+        const response = await this.requestWorker(message, (diagnostics) => ({
+            protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+            id,
+            type: "transform:result",
+            success: false,
+            diagnostics,
+        }));
+        if (!response.success) {
+            return {
+                success: false,
+                diagnostics: response.diagnostics,
+            };
+        }
+        return {
+            success: true,
+            outputText: response.payload.outputText,
+            warnings: response.payload.warnings,
+            diagnostics: [],
+        };
+    }
+    unsupportedOperation(operation) {
+        return {
+            success: false,
+            operation,
+            diagnostics: [(0, diagnostics_1.createUnsupportedOperationDiagnostic)(operation)],
+        };
+    }
+    dispose() {
+        this.failPendingRequests([
+            (0, diagnostics_1.createWorkerStartupFailureDiagnostic)({
+                workerScriptUrl: stringifyUrl(this.workerScriptUrl),
+                cause: "Worker service disposed.",
+                causeCategory: "message_channel",
+            }),
+        ]);
+        if (this.worker === undefined) {
+            return;
+        }
+        this.worker.removeEventListener("message", this.handleMessage);
+        this.worker.removeEventListener("error", this.handleError);
+        this.worker.terminate?.();
+        this.worker = undefined;
+        this.initializePromise = undefined;
+        this.initializedResult = undefined;
+    }
+    async initializeWorker(request) {
+        const workerResult = this.ensureWorker();
+        if (!workerResult.ok) {
+            return {
+                success: false,
+                diagnostics: [workerResult.diagnostic],
+            };
+        }
+        const id = this.createRequestId();
+        const wasmAssetUrl = stringifyUrl(request.wasmAssetUrl ?? this.wasmAssetUrl);
+        const message = {
+            protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+            id,
+            type: "initialize",
+            payload: {
+                wasmAssetUrl,
+            },
+        };
+        const response = await this.requestWorker(message, (diagnostics) => ({
+            protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+            id,
+            type: "initialize:result",
+            success: false,
+            diagnostics,
+        }));
+        if (!response.success) {
+            return {
+                success: false,
+                diagnostics: response.diagnostics,
+            };
+        }
+        return {
+            success: true,
+            metadata: response.payload,
+            diagnostics: [],
+        };
+    }
+    requestWorker(message, createFailureResponse) {
+        const workerResult = this.ensureWorker();
+        if (!workerResult.ok) {
+            return Promise.resolve(createFailureResponse([workerResult.diagnostic]));
+        }
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                this.pendingRequests.delete(message.id);
+                resolve(createFailureResponse([
+                    (0, diagnostics_1.createWorkerStartupFailureDiagnostic)({
+                        workerScriptUrl: stringifyUrl(this.workerScriptUrl),
+                        cause: `No worker response within ${this.requestTimeoutMs}ms.`,
+                        causeCategory: "message_channel",
+                    }),
+                ]));
+            }, this.requestTimeoutMs);
+            this.pendingRequests.set(message.id, {
+                resolve: (response) => resolve(response),
+                fail: (diagnostics) => resolve(createFailureResponse(diagnostics)),
+                timeoutId,
+            });
+            try {
+                workerResult.worker.postMessage(message);
+            }
+            catch (error) {
+                const pending = this.pendingRequests.get(message.id);
+                if (pending !== undefined) {
+                    this.pendingRequests.delete(message.id);
+                    clearTimeout(pending.timeoutId);
+                }
+                resolve(createFailureResponse([
+                    (0, diagnostics_1.createWorkerStartupFailureDiagnostic)({
+                        workerScriptUrl: stringifyUrl(this.workerScriptUrl),
+                        cause: error,
+                        causeCategory: "message_channel",
+                    }),
+                ]));
+            }
+        });
+    }
+    ensureWorker() {
+        if (this.worker !== undefined) {
+            return {
+                ok: true,
+                worker: this.worker,
+            };
+        }
+        try {
+            const worker = this.workerFactory(this.workerScriptUrl);
+            worker.addEventListener("message", this.handleMessage);
+            worker.addEventListener("error", this.handleError);
+            this.worker = worker;
+            return {
+                ok: true,
+                worker,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                diagnostic: (0, diagnostics_1.createWorkerStartupFailureDiagnostic)({
+                    workerScriptUrl: stringifyUrl(this.workerScriptUrl),
+                    cause: error,
+                    causeCategory: "worker_script_load",
+                }),
+            };
+        }
+    }
+    failPendingRequests(diagnostics) {
+        const pendingRequests = Array.from(this.pendingRequests.values());
+        this.pendingRequests.clear();
+        for (const pending of pendingRequests) {
+            clearTimeout(pending.timeoutId);
+            pending.fail(diagnostics);
+        }
+    }
+    createRequestId() {
+        const id = `esbuild-wasm-${this.nextRequestId}`;
+        this.nextRequestId += 1;
+        return id;
+    }
+}
+exports.DefaultEsbuildWasmWorkerService = DefaultEsbuildWasmWorkerService;
+function createEsbuildWasmWorkerService(options) {
+    return new DefaultEsbuildWasmWorkerService(options);
+}
+exports.createEsbuildWasmWorkerService = createEsbuildWasmWorkerService;
+function createDefaultWorker(workerScriptUrl) {
+    return new Worker(workerScriptUrl, {
+        type: "module",
+    });
+}
+function isWorkerResponseMessage(message) {
+    if (message === null || typeof message !== "object") {
+        return false;
+    }
+    const candidate = message;
+    return (candidate.protocol === types_1.ESBUILD_WASM_WORKER_PROTOCOL &&
+        typeof candidate.id === "string" &&
+        (candidate.type === "initialize:result" ||
+            candidate.type === "transform:result"));
+}
+function stringifyUrl(url) {
+    return typeof url === "string" ? url : url.toString();
+}
+function getEventCause(event) {
+    const maybeErrorEvent = event;
+    return maybeErrorEvent.error ?? maybeErrorEvent.message ?? event.type;
+}

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

@@ -0,0 +1,139 @@
+export declare const ESBUILD_WASM_WORKER_CAPABILITY: "esbuild-wasm-worker";
+export declare const ESBUILD_WASM_WORKER_PROTOCOL: "forge.esbuild-wasm-worker.v1";
+export type ForgeEsbuildWasmUrl = string | URL;
+export type ForgeEsbuildWasmWorkerDiagnosticCode = "worker_startup_failed" | "wasm_initialization_failed" | "worker_not_initialized" | "unsupported_operation" | "transform_failed";
+export type ForgeEsbuildWasmDiagnosticCauseCategory = "message_channel" | "runtime_initialization" | "transform" | "worker_script_load";
+export interface ForgeEsbuildWasmWorkerDiagnostic {
+    readonly code: ForgeEsbuildWasmWorkerDiagnosticCode;
+    readonly severity: "error";
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly causeCategory?: ForgeEsbuildWasmDiagnosticCauseCategory;
+    readonly operation?: ForgeEsbuildWasmUnsupportedOperation;
+    readonly path?: string;
+    readonly wasmAssetUrl?: string;
+    readonly workerScriptUrl?: string;
+}
+export interface ForgeEsbuildWasmRuntimeMetadata {
+    readonly capability: typeof ESBUILD_WASM_WORKER_CAPABILITY;
+    readonly initialized: true;
+    readonly wasmAssetUrl: string;
+    readonly esbuildVersion?: string;
+}
+export interface ForgeEsbuildWasmInitializeRequest {
+    readonly wasmAssetUrl?: ForgeEsbuildWasmUrl;
+}
+export interface ForgeEsbuildWasmInitializeSuccessResult {
+    readonly success: true;
+    readonly metadata: ForgeEsbuildWasmRuntimeMetadata;
+    readonly diagnostics: readonly [];
+}
+export interface ForgeEsbuildWasmInitializeFailureResult {
+    readonly success: false;
+    readonly diagnostics: readonly ForgeEsbuildWasmWorkerDiagnostic[];
+}
+export type ForgeEsbuildWasmInitializeResult = ForgeEsbuildWasmInitializeSuccessResult | ForgeEsbuildWasmInitializeFailureResult;
+export type ForgeEsbuildWasmTransformLoader = "ts" | "tsx";
+export interface ForgeEsbuildWasmTransformRequest {
+    readonly sourceText: string;
+    readonly loader: ForgeEsbuildWasmTransformLoader;
+    readonly sourcePath: string;
+    readonly target?: string;
+}
+export interface ForgeEsbuildWasmTransformWarning {
+    readonly text: string;
+    readonly location?: {
+        readonly file: string;
+        readonly line: number;
+        readonly column: number;
+    };
+}
+export interface ForgeEsbuildWasmTransformSuccessResult {
+    readonly success: true;
+    readonly outputText: string;
+    readonly warnings: readonly ForgeEsbuildWasmTransformWarning[];
+    readonly diagnostics: readonly [];
+}
+export interface ForgeEsbuildWasmTransformFailureResult {
+    readonly success: false;
+    readonly diagnostics: readonly ForgeEsbuildWasmWorkerDiagnostic[];
+}
+export type ForgeEsbuildWasmTransformResult = ForgeEsbuildWasmTransformSuccessResult | ForgeEsbuildWasmTransformFailureResult;
+export type ForgeEsbuildWasmUnsupportedOperation = "hmr" | "package_bundling" | "registry_resolution" | "vite_config_loading";
+export interface ForgeEsbuildWasmUnsupportedOperationResult {
+    readonly success: false;
+    readonly operation: ForgeEsbuildWasmUnsupportedOperation;
+    readonly diagnostics: readonly ForgeEsbuildWasmWorkerDiagnostic[];
+}
+export interface ForgeEsbuildWasmWorkerServiceOptions {
+    readonly workerScriptUrl: ForgeEsbuildWasmUrl;
+    readonly wasmAssetUrl: ForgeEsbuildWasmUrl;
+    readonly requestTimeoutMs?: number;
+    readonly workerFactory?: ForgeEsbuildWasmWorkerFactory;
+}
+export interface ForgeEsbuildWasmWorkerService {
+    readonly capability: typeof ESBUILD_WASM_WORKER_CAPABILITY;
+    initialize(request?: ForgeEsbuildWasmInitializeRequest): Promise<ForgeEsbuildWasmInitializeResult>;
+    transform(request: ForgeEsbuildWasmTransformRequest): Promise<ForgeEsbuildWasmTransformResult>;
+    unsupportedOperation(operation: ForgeEsbuildWasmUnsupportedOperation): ForgeEsbuildWasmUnsupportedOperationResult;
+    dispose(): void;
+}
+export type ForgeEsbuildWasmWorkerFactory = (workerScriptUrl: ForgeEsbuildWasmUrl) => ForgeEsbuildWasmWorkerPort;
+export interface ForgeEsbuildWasmWorkerMessageEvent {
+    readonly data: ForgeEsbuildWasmWorkerResponseMessage;
+}
+export interface ForgeEsbuildWasmWorkerPort {
+    postMessage(message: ForgeEsbuildWasmWorkerRequestMessage): void;
+    addEventListener(type: "message", listener: (event: ForgeEsbuildWasmWorkerMessageEvent) => void): void;
+    addEventListener(type: "error", listener: (event: Event) => void): void;
+    removeEventListener(type: "message", listener: (event: ForgeEsbuildWasmWorkerMessageEvent) => void): void;
+    removeEventListener(type: "error", listener: (event: Event) => void): void;
+    terminate?(): void;
+}
+export interface ForgeEsbuildWasmInitializeWorkerRequest {
+    readonly protocol: typeof ESBUILD_WASM_WORKER_PROTOCOL;
+    readonly id: string;
+    readonly type: "initialize";
+    readonly payload: {
+        readonly wasmAssetUrl: string;
+    };
+}
+export interface ForgeEsbuildWasmTransformWorkerRequest {
+    readonly protocol: typeof ESBUILD_WASM_WORKER_PROTOCOL;
+    readonly id: string;
+    readonly type: "transform";
+    readonly payload: ForgeEsbuildWasmTransformRequest;
+}
+export type ForgeEsbuildWasmWorkerRequestMessage = ForgeEsbuildWasmInitializeWorkerRequest | ForgeEsbuildWasmTransformWorkerRequest;
+export interface ForgeEsbuildWasmInitializeWorkerSuccessResponse {
+    readonly protocol: typeof ESBUILD_WASM_WORKER_PROTOCOL;
+    readonly id: string;
+    readonly type: "initialize:result";
+    readonly success: true;
+    readonly payload: ForgeEsbuildWasmRuntimeMetadata;
+}
+export interface ForgeEsbuildWasmInitializeWorkerFailureResponse {
+    readonly protocol: typeof ESBUILD_WASM_WORKER_PROTOCOL;
+    readonly id: string;
+    readonly type: "initialize:result";
+    readonly success: false;
+    readonly diagnostics: readonly ForgeEsbuildWasmWorkerDiagnostic[];
+}
+export interface ForgeEsbuildWasmTransformWorkerSuccessResponse {
+    readonly protocol: typeof ESBUILD_WASM_WORKER_PROTOCOL;
+    readonly id: string;
+    readonly type: "transform:result";
+    readonly success: true;
+    readonly payload: {
+        readonly outputText: string;
+        readonly warnings: readonly ForgeEsbuildWasmTransformWarning[];
+    };
+}
+export interface ForgeEsbuildWasmTransformWorkerFailureResponse {
+    readonly protocol: typeof ESBUILD_WASM_WORKER_PROTOCOL;
+    readonly id: string;
+    readonly type: "transform:result";
+    readonly success: false;
+    readonly diagnostics: readonly ForgeEsbuildWasmWorkerDiagnostic[];
+}
+export type ForgeEsbuildWasmWorkerResponseMessage = ForgeEsbuildWasmInitializeWorkerSuccessResponse | ForgeEsbuildWasmInitializeWorkerFailureResponse | ForgeEsbuildWasmTransformWorkerSuccessResponse | ForgeEsbuildWasmTransformWorkerFailureResponse;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESBUILD_WASM_WORKER_PROTOCOL = exports.ESBUILD_WASM_WORKER_CAPABILITY = void 0;
+exports.ESBUILD_WASM_WORKER_CAPABILITY = "esbuild-wasm-worker";
+exports.ESBUILD_WASM_WORKER_PROTOCOL = "forge.esbuild-wasm-worker.v1";

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

@@ -0,0 +1,38 @@
+import { type ForgeEsbuildWasmWorkerRequestMessage, type ForgeEsbuildWasmWorkerResponseMessage } from "./types";
+export interface ForgeEsbuildWasmRuntime {
+    readonly version?: string;
+    initialize(options: {
+        readonly wasmURL: string;
+        readonly worker: false;
+    }): Promise<void>;
+    transform(sourceText: string, options: {
+        readonly loader: "ts" | "tsx";
+        readonly sourcefile: string;
+        readonly target?: string;
+        readonly format: "esm";
+    }): Promise<{
+        readonly code: string;
+        readonly warnings: readonly EsbuildTransformWarning[];
+    }>;
+}
+interface EsbuildTransformWarning {
+    readonly text?: string;
+    readonly location?: {
+        readonly file?: string;
+        readonly line?: number;
+        readonly column?: number;
+    } | null;
+}
+export interface ForgeEsbuildWasmWorkerAdapterOptions {
+    readonly runtime?: ForgeEsbuildWasmRuntime;
+    readonly postMessage?: (message: ForgeEsbuildWasmWorkerResponseMessage) => void;
+}
+export interface ForgeEsbuildWasmWorkerGlobalScope {
+    postMessage(message: ForgeEsbuildWasmWorkerResponseMessage): void;
+    addEventListener(type: "message", listener: (event: MessageEvent<ForgeEsbuildWasmWorkerRequestMessage>) => void): void;
+}
+export declare function createEsbuildWasmWorkerMessageHandler(options?: ForgeEsbuildWasmWorkerAdapterOptions): (event: {
+    readonly data: ForgeEsbuildWasmWorkerRequestMessage;
+}) => void;
+export declare function installEsbuildWasmWorker(scope?: ForgeEsbuildWasmWorkerGlobalScope): void;
+export {};

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

@@ -0,0 +1,165 @@
+"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.installEsbuildWasmWorker = exports.createEsbuildWasmWorkerMessageHandler = void 0;
+const esbuild = __importStar(require("esbuild-wasm/lib/browser"));
+const diagnostics_1 = require("./diagnostics");
+const types_1 = require("./types");
+function createEsbuildWasmWorkerMessageHandler(options = {}) {
+    const runtime = options.runtime ?? esbuild;
+    const postMessage = options.postMessage ??
+        ((message) => {
+            self.postMessage(message);
+        });
+    let initializedMetadata;
+    let initializePromise;
+    return (event) => {
+        const message = event.data;
+        if (!isWorkerRequestMessage(message)) {
+            return;
+        }
+        void handleMessage(message);
+    };
+    async function handleMessage(message) {
+        if (message.type === "initialize") {
+            await handleInitialize(message);
+            return;
+        }
+        await handleTransform(message);
+    }
+    async function handleInitialize(message) {
+        try {
+            if (initializedMetadata === undefined) {
+                if (initializePromise === undefined) {
+                    initializePromise = initializeRuntime(message.payload.wasmAssetUrl);
+                }
+                initializedMetadata = await initializePromise;
+            }
+            postMessage({
+                protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+                id: message.id,
+                type: "initialize:result",
+                success: true,
+                payload: initializedMetadata,
+            });
+        }
+        catch (error) {
+            initializePromise = undefined;
+            postMessage({
+                protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+                id: message.id,
+                type: "initialize:result",
+                success: false,
+                diagnostics: [
+                    (0, diagnostics_1.createWasmInitializationFailureDiagnostic)(message.payload.wasmAssetUrl, error),
+                ],
+            });
+        }
+    }
+    async function initializeRuntime(wasmAssetUrl) {
+        await runtime.initialize({
+            wasmURL: wasmAssetUrl,
+            worker: false,
+        });
+        return {
+            capability: types_1.ESBUILD_WASM_WORKER_CAPABILITY,
+            initialized: true,
+            wasmAssetUrl,
+            esbuildVersion: runtime.version,
+        };
+    }
+    async function handleTransform(message) {
+        if (initializedMetadata === undefined) {
+            postMessage({
+                protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+                id: message.id,
+                type: "transform:result",
+                success: false,
+                diagnostics: [(0, diagnostics_1.createWorkerNotInitializedDiagnostic)()],
+            });
+            return;
+        }
+        try {
+            const transform = await runtime.transform(message.payload.sourceText, {
+                loader: message.payload.loader,
+                sourcefile: message.payload.sourcePath,
+                target: message.payload.target,
+                format: "esm",
+            });
+            postMessage({
+                protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+                id: message.id,
+                type: "transform:result",
+                success: true,
+                payload: {
+                    outputText: transform.code,
+                    warnings: mapTransformWarnings(transform.warnings),
+                },
+            });
+        }
+        catch (error) {
+            postMessage({
+                protocol: types_1.ESBUILD_WASM_WORKER_PROTOCOL,
+                id: message.id,
+                type: "transform:result",
+                success: false,
+                diagnostics: [
+                    (0, diagnostics_1.createTransformFailureDiagnostic)(message.payload.sourcePath, error),
+                ],
+            });
+        }
+    }
+}
+exports.createEsbuildWasmWorkerMessageHandler = createEsbuildWasmWorkerMessageHandler;
+function installEsbuildWasmWorker(scope = self) {
+    scope.addEventListener("message", createEsbuildWasmWorkerMessageHandler({
+        postMessage: (message) => scope.postMessage(message),
+    }));
+}
+exports.installEsbuildWasmWorker = installEsbuildWasmWorker;
+function isWorkerRequestMessage(message) {
+    if (message === null || typeof message !== "object") {
+        return false;
+    }
+    const candidate = message;
+    return (candidate.protocol === types_1.ESBUILD_WASM_WORKER_PROTOCOL &&
+        typeof candidate.id === "string" &&
+        (candidate.type === "initialize" || candidate.type === "transform"));
+}
+function mapTransformWarnings(warnings) {
+    return warnings.map((warning) => {
+        const location = warning.location;
+        return {
+            text: warning.text ?? "Esbuild transform warning.",
+            location: location === null || location === undefined
+                ? undefined
+                : {
+                    file: location.file ?? "",
+                    line: location.line ?? 0,
+                    column: location.column ?? 0,
+                },
+        };
+    });
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_adapter_1 = require("./worker-adapter");
+(0, worker_adapter_1.installEsbuildWasmWorker)();

package/dist/forge-controller.d.ts

@@ -0,0 +1,38 @@
+import { type ForgeBuildPipeline, type ForgeBuildPipelineOptions } from "./build-pipeline";
+import { type ForgeDevServerPreview, type ForgeDevServerPreviewOptions, type ForgeDevSessionRefreshResult, type ForgeDevSessionStartResult, type ForgeDevSessionStopResult, type ForgeRebuildDevSessionOptions, type ForgeStartDevSessionOptions } from "./dev-server-preview";
+import { type ForgeVirtualFileSystem, type ForgeOpenVirtualFileSystemOptions } from "./virtual-file-system";
+import { type ForgePackageResolver, type ForgePackageResolverOptions } from "./package-resolution";
+import { type ForgeCommandResult, type ForgeTerminal, type ForgeTerminalExecuteOptions, type ForgeTerminalOptions } from "./terminal-commands";
+type ForgeControllerPackageResolutionOptions = Omit<ForgePackageResolverOptions, "fileSystem">;
+type ForgeOpenControllerPackageResolutionOptions = Omit<ForgePackageResolverOptions, "fileSystem" | "storage">;
+type ForgeControllerTerminalOptions = Omit<ForgeTerminalOptions, "buildPipeline" | "packageResolver">;
+type ForgeControllerBuildPipelineOptions = Omit<ForgeBuildPipelineOptions, "fileSystem" | "packageResolver">;
+type ForgeControllerDevServerPreviewOptions = Omit<ForgeDevServerPreviewOptions, "fileSystem" | "buildPipeline">;
+export interface ForgeControllerOptions {
+    readonly fileSystem?: ForgeVirtualFileSystem;
+    readonly buildPipeline?: ForgeBuildPipeline;
+    readonly buildPipelineOptions?: ForgeControllerBuildPipelineOptions;
+    readonly devServerPreview?: ForgeDevServerPreview;
+    readonly devServerPreviewOptions?: ForgeControllerDevServerPreviewOptions;
+    readonly packageResolver?: ForgePackageResolver;
+    readonly packageResolution?: ForgeControllerPackageResolutionOptions;
+    readonly terminal?: ForgeTerminal;
+    readonly terminalOptions?: ForgeControllerTerminalOptions;
+}
+export interface ForgeOpenControllerOptions extends ForgeOpenVirtualFileSystemOptions {
+    readonly packageResolution?: ForgeOpenControllerPackageResolutionOptions;
+}
+export interface ForgeController {
+    readonly fileSystem: ForgeVirtualFileSystem;
+    readonly buildPipeline: ForgeBuildPipeline;
+    readonly devServerPreview: ForgeDevServerPreview;
+    readonly packageResolver: ForgePackageResolver;
+    readonly terminal: ForgeTerminal;
+    executeCommand(commandText: string, options?: ForgeTerminalExecuteOptions): Promise<ForgeCommandResult>;
+    rebuildDevSession(sessionId: string, options?: ForgeRebuildDevSessionOptions): Promise<ForgeDevSessionRefreshResult>;
+    startDevSession(options?: ForgeStartDevSessionOptions): Promise<ForgeDevSessionStartResult>;
+    stopDevSession(sessionId: string): Promise<ForgeDevSessionStopResult>;
+}
+export declare function createForgeController(options?: ForgeControllerOptions): ForgeController;
+export declare function openForgeController(options: ForgeOpenControllerOptions): Promise<ForgeController>;
+export {};