nmtjs 0.15.0-beta.1 → 0.15.0-beta.2

package/dist/_exports/application.js

@@ -0,0 +1 @@
+export * from '@nmtjs/runtime/application';

package/dist/_exports/common.js

@@ -0,0 +1 @@
+export * from '@nmtjs/common';

package/dist/_exports/contract.js

@@ -0,0 +1,2 @@
+export * from '@nmtjs/contract';
+export { default } from '@nmtjs/contract';

package/dist/_exports/core.js

@@ -0,0 +1 @@
+export * from '@nmtjs/core';

package/dist/_exports/gateway.js

@@ -0,0 +1 @@
+export * from '@nmtjs/gateway';

package/dist/_exports/http-transport/bun.js

@@ -0,0 +1 @@
+export * from '@nmtjs/http-transport/bun';

package/dist/_exports/http-transport/deno.js

@@ -0,0 +1 @@
+export * from '@nmtjs/http-transport/deno';

package/dist/_exports/http-transport/node.js

@@ -0,0 +1 @@
+export * from '@nmtjs/http-transport/node';

package/dist/_exports/http-transport.js

@@ -0,0 +1 @@
+export * from '@nmtjs/http-transport';

package/dist/_exports/index.js

@@ -0,0 +1,39 @@
+import { CoreInjectables, createConsolePrettyDestination, createFactoryInjectable, createLazyInjectable, createOptionalInjectable, createValueInjectable, } from '@nmtjs/core';
+import { createTransport, GatewayInjectables } from '@nmtjs/gateway';
+import { createContractProcedure, createContractRouter, createFilter, createGuard, createHook, createJob, createMiddleware, createPlugin, createProcedure, createRouter, createStep, defineApplication, RuntimeInjectables, } from '@nmtjs/runtime';
+export const neemata = {
+    app: defineApplication,
+    injectables: {
+        ...CoreInjectables,
+        ...GatewayInjectables,
+        ...RuntimeInjectables,
+    },
+    transport: createTransport,
+    plugin: createPlugin,
+    logging: {
+        console: 
+        // TODO: TSC wants it
+        createConsolePrettyDestination,
+    },
+    optional: createOptionalInjectable,
+    value: createValueInjectable,
+    lazy: createLazyInjectable,
+    factory: createFactoryInjectable,
+    router: createRouter,
+    contractRouter: createContractRouter,
+    procedure: createProcedure,
+    contractProcedure: createContractProcedure,
+    middleware: createMiddleware,
+    guard: createGuard,
+    filter: createFilter,
+    job: createJob,
+    step: createStep,
+    hook: createHook,
+};
+export { c } from '@nmtjs/contract';
+export { Scope } from '@nmtjs/core';
+export { ErrorCode, ProtocolBlob } from '@nmtjs/protocol';
+export { t } from '@nmtjs/type';
+export { ApiError, defineApplication, LifecycleHook } from 'nmtjs/runtime';
+export { neemata as n };
+export default neemata;

package/dist/_exports/json-format.js

@@ -0,0 +1 @@
+export * from '@nmtjs/json-format/server';

package/dist/_exports/protocol/client.js

@@ -0,0 +1 @@
+export * from '@nmtjs/protocol/client';

package/dist/_exports/protocol/server.js

@@ -0,0 +1 @@
+export * from '@nmtjs/protocol/server';

package/dist/_exports/protocol.js

@@ -0,0 +1 @@
+export * from '@nmtjs/protocol';

package/dist/_exports/runtime/types.js

@@ -0,0 +1 @@
+export * from '@nmtjs/runtime/types';

package/dist/_exports/runtime.js

@@ -0,0 +1 @@
+export * from '@nmtjs/runtime';

package/dist/_exports/type.js

@@ -0,0 +1,2 @@
+export * from '@nmtjs/type';
+export { default } from '@nmtjs/type';

package/dist/_exports/ws-transport/bun.js

@@ -0,0 +1 @@
+export * from '@nmtjs/ws-transport/bun';

package/dist/_exports/ws-transport/deno.js

@@ -0,0 +1 @@
+export * from '@nmtjs/ws-transport/deno';

package/dist/_exports/ws-transport/node.js

@@ -0,0 +1 @@
+export * from '@nmtjs/ws-transport/node';

package/dist/_exports/ws-transport.js

@@ -0,0 +1 @@
+export * from '@nmtjs/ws-transport';

package/dist/cli.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node --enable-source-maps
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { once } from 'node:events';
+import { relative, resolve } from 'node:path';
+import process from 'node:process';
+import { defineCommand, runMain } from 'citty';
+import { config as dotenv } from 'dotenv';
+import { resolver } from "./resolver.js";
+import { generateTypings } from "./typings.js";
+import { createBuilder } from "./vite/builder.js";
+import { baseViteConfigOptions } from "./vite/config.js";
+import { createMainServer } from "./vite/servers/main.js";
+// import { createMainRunner } from './vite/runner.ts'
+const commonArgs = {
+    config: {
+        type: 'string',
+        alias: 'c',
+        default: './neemata.config.ts',
+        description: 'Path to Neemata config file',
+        required: false,
+    },
+};
+let config;
+let viteConfigOptions;
+let applicationImports;
+const mainCommand = defineCommand({
+    meta: { description: 'Neemata CLI' },
+    args: { ...commonArgs },
+    async setup(ctx) {
+        const configPath = resolve(ctx.args.config);
+        config = await import(__rewriteRelativeImportExtension(configPath)).then((m) => m.default);
+        for (const env of config.env) {
+            if (typeof env === 'string') {
+                const { error } = dotenv({ path: env });
+                if (error)
+                    console.warn(error);
+            }
+            else if (typeof env === 'object') {
+                for (const key in env) {
+                    process.env[key] = env[key];
+                }
+            }
+        }
+        // const applicationEntryPaths: Record<string, string> = {}
+        applicationImports = {};
+        const currentPkg = resolver.sync(process.cwd(), './package.json');
+        for (const [appName, appSpecifier] of Object.entries(config.applications)) {
+            const resolution = resolver.sync(process.cwd(), appSpecifier);
+            if (resolution.error)
+                throw new Error(`Failed to resolve application path for ${appName}: ${resolution.error}`);
+            if (!resolution.path)
+                throw new Error(`Failed to resolve application path for ${appName}: no path found`);
+            const specifier = resolution.packageJsonPath === currentPkg.path
+                ? relative(resolve('.neemata'), resolution.path)
+                : appSpecifier;
+            applicationImports[appName] = { path: resolution.path, specifier };
+        }
+        viteConfigOptions = {
+            applicationImports,
+            serverEntryPath: resolve(config.serverPath),
+            ...baseViteConfigOptions,
+            configPath,
+        };
+    },
+    subCommands: {
+        prepare: defineCommand({
+            async run(ctx) {
+                await generateTypings(applicationImports);
+            },
+        }),
+        dev: defineCommand({
+            async run(ctx) {
+                const { runner } = await createMainServer(viteConfigOptions, 'development', config);
+                await runner.import(viteConfigOptions.entrypointMainPath);
+                await once(process, 'beforeExit');
+            },
+        }),
+        preview: defineCommand({
+            async run(ctx) {
+                const { runner } = await createMainServer(viteConfigOptions, 'production', config);
+                await runner.import(viteConfigOptions.entrypointMainPath);
+                await once(process, 'beforeExit');
+            },
+        }),
+        build: defineCommand({
+            async run(ctx) {
+                const builder = await createBuilder(viteConfigOptions, config);
+                await builder.build();
+            },
+        }),
+        // command: defineCommand({
+        //   async run(ctx) {
+        //     const runner = await createRunner(
+        //       viteConfigOptions,
+        //       'production',
+        //       config,
+        //     )
+        //     const workerModule = await runner.import<
+        //       typeof import('./entrypoints/worker.ts')
+        //     >(import.meta.resolve('./entrypoints/worker.js'))
+        //     const commandModule = await runner.import<
+        //       typeof import('./command.ts')
+        //     >(import.meta.resolve('./command.js'))
+        //     const worker = await workerModule.default({
+        //       applicationWorkerData: undefined,
+        //       type: ApplicationType.Command,
+        //       workerType: ApplicationWorkerType.Command,
+        //     })
+        //     await runMain(commandModule.default(worker), { rawArgs: ctx.rawArgs })
+        //   },
+        // }),
+    },
+});
+runMain(mainCommand);

package/dist/command.js

@@ -0,0 +1,30 @@
+// import type { ApplicationWorker } from '@nmtjs/runtime/worker'
+// import { typeToString } from '@nmtjs/type'
+// import { defineCommand } from 'citty'
+export {};
+// export default (worker: ApplicationWorker) =>
+//   defineCommand({
+//     meta: { description: 'Application CLI' },
+//     subCommands: {
+//       list: defineCommand({
+//         async run(ctx) {
+//           worker.app.initializeCore()
+//           const commands = Array.from(worker.app.registry.commands).map(
+//             ([name, command]) => ({
+//               command: name,
+//               args: typeToString(command.args),
+//               kwargs: typeToString(command.kwargs),
+//             }),
+//           )
+//           console.table(commands, ['command', 'args', 'kwargs'])
+//         },
+//       }),
+//       execute: defineCommand({
+//         async run(ctx) {
+//           const { _: positionals, ...kwargs } = ctx.args
+//           const [commandName, ...args] = positionals
+//           await worker.runCommand(commandName, args, kwargs)
+//         },
+//       }),
+//     },
+//   })

package/dist/config.js

@@ -0,0 +1,13 @@
+export function defineConfig(config = {}) {
+    return {
+        serverPath: './src/server.ts',
+        externalDependencies: 'prod',
+        timeout: 10000,
+        env: [],
+        plugins: [],
+        ...config,
+        // @ts-expect-error
+        applications: config.applications || {},
+        build: { outDir: './dist', minify: true, ...config.build },
+    };
+}

package/dist/entrypoints/cli.js

@@ -0,0 +1,11 @@
+// // import { ApplicationType, ApplicationWorkerType } from '@nmtjs/application'
+// import { runMain } from 'citty'
+export {};
+// import command from '../command.ts'
+// import createWorker from './worker.ts'
+// const worker = await createWorker({
+//   applicationWorkerData: undefined,
+//   // type: ApplicationType.Command,
+//   // workerType: ApplicationWorkerType.Command,
+// })
+// runMain(command(worker))

package/dist/entrypoints/main.js

@@ -0,0 +1,85 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import EventEmitter from 'node:events';
+import { fileURLToPath } from 'node:url';
+import { ApplicationServer, isServerConfig } from '@nmtjs/runtime';
+class InvalidServerConfigError extends Error {
+    constructor() {
+        super(`Server config file does not have a default export, or it not a valid application. Please, make sure the application is defined using defineApplication().`);
+        this.name = 'InvalidServerConfigError';
+    }
+}
+const _ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js';
+const _vite = __VITE_CONFIG__ ? JSON.parse(__VITE_CONFIG__) : undefined;
+const applicationsConfig = __APPLICATIONS_CONFIG__
+    ? JSON.parse(__APPLICATIONS_CONFIG__)
+    : {};
+let _viteServerEvents;
+let _viteWorkerServer;
+let server;
+if (import.meta.env.DEV && import.meta.hot) {
+    import.meta.hot.accept('#server', async (module) => {
+        await server.stop();
+        await createServer(module?.default);
+    });
+}
+if (_vite) {
+    const { createWorkerServer } = await import("../vite/servers/worker.js");
+    const neemataConfig = await import(__rewriteRelativeImportExtension(
+    /* @vite-ignore */
+    _vite.options.configPath)).then((m) => m.default);
+    _viteServerEvents = new EventEmitter();
+    _viteWorkerServer = await createWorkerServer(_vite.options, _vite.mode, neemataConfig, _viteServerEvents);
+}
+async function createServer(config) {
+    if (!isServerConfig(config))
+        throw new InvalidServerConfigError();
+    server = new ApplicationServer(config, applicationsConfig, {
+        path: fileURLToPath(import.meta.resolve(`./thread${_ext}`)),
+        workerData: { vite: _vite?.mode },
+        worker: _viteServerEvents
+            ? (worker) => {
+                _viteServerEvents.emit('worker', worker);
+            }
+            : undefined,
+    });
+    await server.start();
+}
+let isTerminating = false;
+async function handleTermination() {
+    if (isTerminating)
+        return;
+    isTerminating = true;
+    await server?.stop();
+    _viteWorkerServer?.close();
+    process.exit(0);
+}
+function handleUnexpectedError(error) {
+    console.error(new Error('Unexpected Error:', { cause: error }));
+}
+process.once('SIGTERM', handleTermination);
+process.once('SIGINT', handleTermination);
+process.on('uncaughtException', handleUnexpectedError);
+process.on('unhandledRejection', handleUnexpectedError);
+await createServer(await import(
+// @ts-expect-error
+'#server').then((m) => m.default));
+const { format } = Intl.NumberFormat('en', {
+    notation: 'compact',
+    maximumFractionDigits: 2,
+    unit: 'byte',
+});
+const printMem = () => {
+    globalThis.gc?.();
+    // print memory usage every 10 seconds
+    const memoryUsage = process.memoryUsage();
+    console.log(`Memory Usage: RSS=${format(memoryUsage.rss)}, HeapTotal=${format(memoryUsage.heapTotal)}, HeapUsed=${format(memoryUsage.heapUsed)}, External=${format(memoryUsage.external)}, ArrayBuffers=${format(memoryUsage.arrayBuffers)}`);
+};
+// printMem()
+// setInterval(printMem, 5000)

package/dist/entrypoints/thread.js

@@ -0,0 +1,52 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { fileURLToPath } from 'node:url';
+import { workerData as _workerData } from 'node:worker_threads';
+const workerData = _workerData;
+const ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js';
+const workerPath = fileURLToPath(import.meta.resolve(`./worker${ext}`));
+process.on('uncaughtException', (error) => {
+    console.error(new Error('Uncaught Exception:', { cause: error }));
+});
+process.on('unhandledRejection', (error) => {
+    console.error(new Error('Unhandled Promise Rejection:', { cause: error }));
+});
+process.on('beforeExit', (code) => {
+    runner?.close();
+});
+let runner;
+let workerModule;
+try {
+    if (workerData.vite) {
+        const { createModuleRunner } = (await import("../vite/runners/worker.js"));
+        runner = createModuleRunner(workerData.vite);
+        workerModule = await runner.import(workerPath);
+    }
+    else {
+        runner = undefined;
+        workerModule = await import(__rewriteRelativeImportExtension(
+        /* @vite-ignore */
+        workerPath));
+    }
+    const runtime = await workerModule.run(workerData.runtime);
+    workerData.port.on('message', async (msg) => {
+        if (msg.type === 'stop') {
+            await runtime.stop();
+            process.exit(0);
+        }
+    });
+    const hosts = (await runtime?.start()) || undefined;
+    workerData.port.postMessage({
+        type: 'ready',
+        data: { hosts },
+    });
+}
+catch (error) {
+    console.error(new Error('Worker thread error:', { cause: error }));
+}

package/dist/entrypoints/worker.js

@@ -0,0 +1,41 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { workerData } from 'node:worker_threads';
+import { ApplicationWorkerRuntime, isApplicationConfig, JobWorkerRuntime, } from '@nmtjs/runtime';
+export async function run(options) {
+    const serverConfig = await import(
+    // @ts-expect-error
+    '#server').then((m) => m.default);
+    if (options.type === 'application') {
+        globalThis._hotAccept = (module) => {
+            if (module) {
+                if (!isApplicationConfig(module.default))
+                    throw new Error('Invalid application config');
+                runtime.reload(module.default);
+            }
+        };
+        const { name, path, transportsData } = options;
+        const appConfig = await import(__rewriteRelativeImportExtension(
+        /* @vite-ignore */
+        path)).then((m) => m.default);
+        const runtime = new ApplicationWorkerRuntime(serverConfig, { name, path, transports: transportsData }, appConfig);
+        return runtime;
+    }
+    else if (options.type === 'jobs') {
+        const { jobWorkerQueue } = options;
+        const runtime = new JobWorkerRuntime(serverConfig, {
+            queueName: jobWorkerQueue,
+            port: workerData.port,
+        });
+        return runtime;
+    }
+    else {
+        throw new Error(`Unknown runtime type: ${workerData.runtime.type}`);
+    }
+}

package/dist/resolver.js

@@ -0,0 +1,14 @@
+import { ResolverFactory } from 'oxc-resolver';
+const fallback = {};
+try {
+    // oxc-resolver fails to resolve uWebSockets.js for some reason
+    const mdl = 'uWebSockets.js';
+    const path = import.meta.resolve(mdl);
+    fallback[mdl] = [path];
+}
+catch { }
+export const resolver = new ResolverFactory({
+    tsconfig: 'auto',
+    extensions: ['.ts', '.js', '.mjs', '.mts', '.json', '.node'],
+    fallback,
+});

package/dist/typings.js

@@ -0,0 +1,17 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import dedent from 'dedent';
+export async function generateTypings(applicationImports) {
+    await mkdir('.neemata', { recursive: true }).catch(() => { });
+    await writeFile(resolve('.neemata', 'types.d.ts'), dedent `
+    /// <reference types="@nmtjs/runtime/types" />
+
+    declare module '@nmtjs/runtime/types' {
+      interface Applications {
+        ${Object.entries(applicationImports)
+        .map(([appName, { specifier }]) => `'${appName}': typeof import('${specifier}').default`)
+        .join('\n')}
+      }
+    }
+    `);
+}

package/dist/vite/builder.js

@@ -0,0 +1,109 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { isBuiltin } from 'node:module';
+import { resolve } from 'node:path';
+import { build as viteBuild } from 'vite';
+// import pkgJson from '../../package.json' with { type: 'json' }
+import { createConfig } from "./config.js";
+import { buildPlugins } from "./plugins.js";
+export async function createBuilder(configOptions, neemataConfig) {
+    const config = createConfig(configOptions);
+    async function build() {
+        const packageJson = await import(__rewriteRelativeImportExtension(resolve('./package.json')), {
+            with: { type: 'json' },
+        }).then((mod) => mod.default);
+        // techinically it's possible to do the same with rolldown directly,
+        // but vite handles a lot of things, like defines substitutions, etc.
+        // also, since during dev the code is processed via vite anyway,
+        // using vite for build as well ensures consistency between dev and prod
+        return await viteBuild({
+            appType: 'custom',
+            clearScreen: false,
+            resolve: { alias: config.alias },
+            ssr: { noExternal: true },
+            plugins: [...buildPlugins, ...neemataConfig.plugins],
+            build: {
+                lib: { entry: config.entries, formats: ['es'] },
+                ssr: true,
+                target: 'node20',
+                sourcemap: true,
+                outDir: resolve(neemataConfig.build.outDir),
+                minify: neemataConfig.build.minify,
+                emptyOutDir: true,
+                rolldownOptions: {
+                    platform: 'node',
+                    external: (id) => {
+                        if (neemataConfig.externalDependencies === 'all')
+                            return true;
+                        if (isBuiltin(id) ||
+                            id.includes('vite/server') ||
+                            id.endsWith('.node'))
+                            return true;
+                        if (neemataConfig.externalDependencies === 'prod') {
+                            const prodDeps = Object.keys(packageJson.dependencies ?? {});
+                            if (prodDeps.includes(id))
+                                return true;
+                        }
+                        if (Array.isArray(neemataConfig.externalDependencies)) {
+                            for (const dep of neemataConfig.externalDependencies) {
+                                if (typeof dep === 'string' && dep === id)
+                                    return true;
+                                if (dep instanceof RegExp && dep.test(id))
+                                    return true;
+                            }
+                        }
+                        return false;
+                    },
+                    transform: {
+                        define: {
+                            __VITE_CONFIG__: '""',
+                            __APPLICATIONS_CONFIG__: JSON.stringify(JSON.stringify(Object.fromEntries(Object.keys(configOptions.applicationImports).map((appName) => [appName, `./application.${appName}.js`])))),
+                            __dirname: 'new URL(".", import.meta.url).pathname',
+                            __filename: 'new URL(import.meta.url).pathname',
+                        },
+                    },
+                    output: {
+                        entryFileNames: '[name].js',
+                        chunkFileNames: 'chunks/[name]-[hash].js',
+                        advancedChunks: {
+                            groups: [
+                                {
+                                    name: 'ioredis',
+                                    test: /node_modules[\\/](@ioredis|ioredis|redis)/,
+                                    priority: 4,
+                                },
+                                {
+                                    name: 'bullmq',
+                                    test: /node_modules[\\/]bullmq/,
+                                    priority: 2,
+                                },
+                                { name: 'zod', test: /node_modules[\\/]zod/, priority: 2 },
+                                { name: 'pino', test: /node_modules[\\/]pino/, priority: 2 },
+                                {
+                                    name: '@nmtjs-runtime',
+                                    test: /node_modules[\\/](@nmtjs[\\/]runtime)/,
+                                    priority: 2,
+                                },
+                                {
+                                    name: '@nmtjs-common',
+                                    test: /node_modules[\\/]@nmtjs[\\/](?=[^runtime|nmtjs])/,
+                                    priority: 1,
+                                },
+                                { name: 'vendor', test: /node_modules/, priority: 0 },
+                            ],
+                        },
+                        minify: neemataConfig.build.minify,
+                    },
+                },
+                chunkSizeWarningLimit: 10_000,
+            },
+        });
+    }
+    return { build };
+}

package/dist/vite/config.js

@@ -0,0 +1,21 @@
+import { fileURLToPath } from 'node:url';
+const ext = new URL(import.meta.url).pathname.endsWith('.ts') ? '.ts' : '.js';
+export const baseViteConfigOptions = {
+    entrypointMainPath: fileURLToPath(import.meta.resolve(`../entrypoints/main${ext}`)),
+    entrypointWorkerPath: fileURLToPath(import.meta.resolve(`../entrypoints/worker${ext}`)),
+    entrypointThreadPath: fileURLToPath(import.meta.resolve(`../entrypoints/thread${ext}`)),
+    // entrypointCLIPath: fileURLToPath(import.meta.resolve('../entrypoints/cli')),
+};
+export function createConfig(options) {
+    const alias = { '#server': options.serverEntryPath };
+    const entries = {
+        server: options.serverEntryPath,
+        main: options.entrypointMainPath,
+        thread: options.entrypointThreadPath,
+        worker: options.entrypointWorkerPath,
+    };
+    for (const [name, { path }] of Object.entries(options.applicationImports)) {
+        entries[`application.${name}`] = path;
+    }
+    return { alias, entries };
+}

package/dist/vite/plugins.js

@@ -0,0 +1,17 @@
+import { dirname, join } from 'node:path';
+import { viteStaticCopy } from 'vite-plugin-static-copy';
+import { resolver } from "../resolver.js";
+const targets = [];
+try {
+    const { path } = resolver.sync(process.cwd(), '@nmtjs/proxy');
+    if (path) {
+        targets.push({
+            src: join(dirname(path), `neemata-proxy.${process.platform}-${process.arch}*.node`),
+            dest: './chunks/',
+        });
+    }
+}
+catch { }
+export const buildPlugins = [
+    ...(targets.length ? viteStaticCopy({ targets }) : []),
+];

package/dist/vite/runners/worker.js

@@ -0,0 +1,32 @@
+import { BroadcastChannel, isInternalThread, isMainThread, parentPort, threadId, } from 'node:worker_threads';
+import { noopFn } from '@nmtjs/common';
+import { createNodeImportMeta, ESModulesEvaluator, ModuleRunner, } from 'vite/module-runner';
+export function createBroadcastChannel(threadId) {
+    return new BroadcastChannel(`nmtjs:vite:${threadId}`);
+}
+export function createModuleRunner(mode = 'development') {
+    if (isMainThread || isInternalThread)
+        throw new Error('Module runner can only be created inside worker threads.');
+    const channel = createBroadcastChannel(threadId);
+    const transport = {
+        connect({ onMessage, onDisconnection }) {
+            // @ts-expect-error
+            channel.onmessage = (event) => {
+                onMessage(event.data);
+            };
+            parentPort.on('close', onDisconnection);
+        },
+        send(data) {
+            channel.postMessage(data);
+        },
+        timeout: 5000,
+    };
+    const runner = new ModuleRunner({
+        transport,
+        createImportMeta: createNodeImportMeta,
+        hmr: mode === 'development'
+            ? { logger: { debug: noopFn, error: console.error } }
+            : false,
+    }, new ESModulesEvaluator());
+    return runner;
+}

package/dist/vite/server.js

@@ -0,0 +1,17 @@
+import { createServer as createViteServer } from 'vite';
+export function createServer(options, config, dev = {}) {
+    return createViteServer({
+        ...config,
+        server: { middlewareMode: true, ws: false },
+        environments: {
+            neemata: {
+                consumer: 'server',
+                dev,
+                define: {
+                    __VITE_CONFIG__: JSON.stringify(JSON.stringify({ options, mode: config.mode })),
+                    __APPLICATIONS_CONFIG__: JSON.stringify(JSON.stringify(Object.fromEntries(Object.entries(options.applicationImports).map(([appName, { path }]) => [appName, path])))),
+                },
+            },
+        },
+    });
+}

package/dist/vite/servers/main.js

@@ -0,0 +1,22 @@
+import { noopFn } from '@nmtjs/common';
+import { createServerModuleRunner } from 'vite';
+import { createConfig } from "../config.js";
+import { buildPlugins } from "../plugins.js";
+import { createServer } from "../server.js";
+export async function createMainServer(options, mode, neemataConfig) {
+    const config = createConfig(options);
+    const server = await createServer(options, {
+        appType: 'custom',
+        clearScreen: false,
+        resolve: { alias: config.alias },
+        mode,
+        plugins: [...buildPlugins, ...neemataConfig.plugins],
+    });
+    const environment = server.environments.neemata;
+    const runner = createServerModuleRunner(environment, {
+        hmr: mode === 'development'
+            ? { logger: { debug: noopFn, error: console.error } }
+            : false,
+    });
+    return { server, runner };
+}

package/dist/vite/servers/worker.js

@@ -0,0 +1,78 @@
+import { DevEnvironment } from 'vite';
+import { createConfig } from "../config.js";
+import { buildPlugins } from "../plugins.js";
+import { createBroadcastChannel } from "../runners/worker.js";
+import { createServer } from "../server.js";
+export async function createWorkerServer(options, mode, neemataConfig, events) {
+    const config = createConfig(options);
+    const applicationEntries = Object.values(options.applicationImports).map((v) => v.path);
+    const _injectHmr = `\n\nif(import.meta.hot) { import.meta.hot.accept(globalThis._hotAccept) }`;
+    const server = await createServer(options, {
+        appType: 'custom',
+        clearScreen: false,
+        resolve: { alias: config.alias },
+        mode,
+        plugins: [
+            ...buildPlugins,
+            ...neemataConfig.plugins,
+            mode === 'development'
+                ? [
+                    {
+                        name: 'neemata-worker-application-hmr',
+                        transform(code, id, options) {
+                            if (applicationEntries.includes(id)) {
+                                return code + _injectHmr;
+                            }
+                        },
+                    },
+                ]
+                : [],
+        ],
+    }, {
+        createEnvironment: async (name, config, context) => {
+            const channels = new Map();
+            const clients = new Map();
+            const handlers = new Map();
+            events.on('worker', (worker) => {
+                const channel = createBroadcastChannel(worker.threadId);
+                channel.onmessage = (event) => {
+                    const value = event.data;
+                    const handler = handlers.get(value.event);
+                    if (handler)
+                        handler(value.data, client);
+                };
+                channels.set(worker.threadId, channel);
+                const client = {
+                    send: (payload) => {
+                        channel.postMessage(payload);
+                    },
+                };
+                clients.set(channel, client);
+                worker.on('exit', () => {
+                    const handler = handlers.get('vite:client:disconnect');
+                    if (handler)
+                        handler(undefined, client);
+                });
+            });
+            const transport = {
+                send(data) {
+                    for (const channel of channels.values()) {
+                        channel.postMessage(data);
+                    }
+                },
+                on(event, handler) {
+                    handlers.set(event, handler);
+                },
+                off(event) {
+                    handlers.delete(event);
+                },
+            };
+            const environment = new DevEnvironment(name, config, {
+                hot: mode === 'development',
+                transport,
+            });
+            return environment;
+        },
+    });
+    return server;
+}

package/package.json

@@ -16,22 +16,22 @@
     "oxc-resolver": "^11.13.2",
     "vite": "npm:rolldown-vite@7.2.10",
     "vite-plugin-static-copy": "^3.1.4",
-    "@nmtjs/core": "0.15.0-beta.1",
-    "@nmtjs/gateway": "0.15.0-beta.1",
-    "@nmtjs/contract": "0.15.0-beta.1",
-    "@nmtjs/json-format": "0.15.0-beta.1",
-    "@nmtjs/protocol": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1",
-    "@nmtjs/http-transport": "0.15.0-beta.1",
-    "@nmtjs/ws-transport": "0.15.0-beta.1",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/runtime": "0.15.0-beta.1"
+    "@nmtjs/contract": "0.15.0-beta.2",
+    "@nmtjs/core": "0.15.0-beta.2",
+    "@nmtjs/gateway": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/protocol": "0.15.0-beta.2",
+    "@nmtjs/json-format": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/runtime": "0.15.0-beta.2",
+    "@nmtjs/ws-transport": "0.15.0-beta.2",
+    "@nmtjs/http-transport": "0.15.0-beta.2"
   },
   "devDependencies": {
-    "@nmtjs/proxy": "0.15.0-beta.1"
+    "@nmtjs/proxy": "0.15.0-beta.2"
   },
   "peerDependencies": {
-    "@nmtjs/proxy": "0.15.0-beta.1"
+    "@nmtjs/proxy": "0.15.0-beta.2"
   },
   "peerDependenciesMeta": {
     "@nmtjs/proxy": {
@@ -43,7 +43,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc",