nmtjs 0.15.0-beta.3 → 0.15.0-beta.5

package/dist/_exports/index.d.ts

@@ -1,14 +1,17 @@
-import { createConsolePrettyDestination, createFactoryInjectable, createLazyInjectable, createOptionalInjectable, createValueInjectable } from '@nmtjs/core';
+import { createConsolePrettyDestination, createFactoryInjectable, createLazyInjectable, createValueInjectable } from '@nmtjs/core';
 import { createTransport } from '@nmtjs/gateway';
-import { createContractProcedure, createContractRouter, createFilter, createGuard, createHook, createJob, createMiddleware, createPlugin, createProcedure, createRouter, createStep, defineApplication } from '@nmtjs/runtime';
+import { createContractProcedure, createContractRouter, createFilter, createGuard, createHook, createJob, createMiddleware, createPlugin, createProcedure, createRootRouter, createRouter, defineApplication, defineServer } from '@nmtjs/runtime';
 export declare const neemata: {
     app: typeof defineApplication;
+    server: typeof defineServer;
     injectables: {
         pubSubAdapter: import("@nmtjs/core").LazyInjectable<import("@nmtjs/runtime").PubSubAdapterType, import("@nmtjs/core").Scope.Global>;
         pubSubPublish: import("@nmtjs/core").LazyInjectable<import("@nmtjs/runtime").PubSubPublish, import("@nmtjs/core").Scope.Global>;
         pubSubSubscribe: import("@nmtjs/core").LazyInjectable<import("@nmtjs/runtime").PubSubSubscribe, import("@nmtjs/core").Scope.Global>;
         jobManager: import("@nmtjs/core").LazyInjectable<import("@nmtjs/runtime").JobManagerInstance, import("@nmtjs/core").Scope.Global>;
         storeConfig: import("@nmtjs/core").LazyInjectable<import("@nmtjs/runtime").ServerStoreConfig, import("@nmtjs/core").Scope.Global>;
+        workerType: import("@nmtjs/core").LazyInjectable<import("@nmtjs/runtime").WorkerType, import("@nmtjs/core").Scope.Global>;
+        jobWorkerQueue: import("@nmtjs/core").LazyInjectable<import("@nmtjs/runtime").JobWorkerQueue, import("@nmtjs/core").Scope.Global>;
         connection: import("@nmtjs/core").LazyInjectable<import("@nmtjs/gateway").GatewayConnection, import("@nmtjs/core").Scope.Connection>;
         connectionId: import("@nmtjs/core").LazyInjectable<string, import("@nmtjs/core").Scope.Connection>;
         connectionData: import("@nmtjs/core").LazyInjectable<unknown, import("@nmtjs/core").Scope.Connection>;
@@ -37,10 +40,10 @@ export declare const neemata: {
     logging: {
         console: typeof createConsolePrettyDestination;
     };
-    optional: typeof createOptionalInjectable;
     value: typeof createValueInjectable;
     lazy: typeof createLazyInjectable;
     factory: typeof createFactoryInjectable;
+    rootRouter: typeof createRootRouter;
     router: typeof createRouter;
     contractRouter: typeof createContractRouter;
     procedure: typeof createProcedure;
@@ -49,13 +52,13 @@ export declare const neemata: {
     guard: typeof createGuard;
     filter: typeof createFilter;
     job: typeof createJob;
-    step: typeof createStep;
     hook: typeof createHook;
 };
 export { c } from '@nmtjs/contract';
 export { Scope } from '@nmtjs/core';
-export { ErrorCode, ProtocolBlob } from '@nmtjs/protocol';
+export { type ConnectionIdentityType, GatewayHook, ProxyableTransportType, } from '@nmtjs/gateway';
+export { ConnectionType, ErrorCode, ProtocolBlob } from '@nmtjs/protocol';
 export { t } from '@nmtjs/type';
-export { ApiError, defineApplication, LifecycleHook } from 'nmtjs/runtime';
+export { ApiError, defineApplication, JobWorkerQueue, LifecycleHook, StoreType, WorkerType, } from 'nmtjs/runtime';
 export { neemata as n };
 export default neemata;

package/dist/_exports/index.js

@@ -1,8 +1,9 @@
-import { CoreInjectables, createConsolePrettyDestination, createFactoryInjectable, createLazyInjectable, createOptionalInjectable, createValueInjectable, } from '@nmtjs/core';
+import { CoreInjectables, createConsolePrettyDestination, createFactoryInjectable, createLazyInjectable, 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';
+import { createContractProcedure, createContractRouter, createFilter, createGuard, createHook, createJob, createMiddleware, createPlugin, createProcedure, createRootRouter, createRouter, defineApplication, defineServer, RuntimeInjectables, } from '@nmtjs/runtime';
 export const neemata = {
     app: defineApplication,
+    server: defineServer,
     injectables: {
         ...CoreInjectables,
         ...GatewayInjectables,
@@ -15,10 +16,10 @@ export const neemata = {
         // TODO: TSC wants it
         createConsolePrettyDestination,
     },
-    optional: createOptionalInjectable,
     value: createValueInjectable,
     lazy: createLazyInjectable,
     factory: createFactoryInjectable,
+    rootRouter: createRootRouter,
     router: createRouter,
     contractRouter: createContractRouter,
     procedure: createProcedure,
@@ -27,14 +28,14 @@ export const neemata = {
     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 { GatewayHook, ProxyableTransportType, } from '@nmtjs/gateway';
+export { ConnectionType, ErrorCode, ProtocolBlob } from '@nmtjs/protocol';
 export { t } from '@nmtjs/type';
-export { ApiError, defineApplication, LifecycleHook } from 'nmtjs/runtime';
+export { ApiError, defineApplication, JobWorkerQueue, LifecycleHook, StoreType, WorkerType, } from 'nmtjs/runtime';
 export { neemata as n };
 export default neemata;
 //# sourceMappingURL=index.js.map

package/dist/_exports/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/_exports/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,8BAA8B,EAC9B,uBAAuB,EACvB,oBAAoB,EACpB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACpE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,YAAY,EACZ,WAAW,EACX,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,UAAU,EACV,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,gBAAgB,CAAA;AAEvB,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,GAAG,EAAE,iBAAiB;IACtB,WAAW,EAAE;QACX,GAAG,eAAe;QAClB,GAAG,kBAAkB;QACrB,GAAI,kBAAgD;KACrD;IACD,SAAS,EAAE,eAAe;IAC1B,MAAM,EAAE,YAAY;IACpB,OAAO,EAAE;QACP,OAAO;QACL,qBAAqB;QACrB,8BAAuE;KAC1E;IACD,QAAQ,EAAE,wBAAwB;IAClC,KAAK,EAAE,qBAAqB;IAC5B,IAAI,EAAE,oBAAoB;IAC1B,OAAO,EAAE,uBAAuB;IAChC,MAAM,EAAE,YAAY;IACpB,cAAc,EAAE,oBAAoB;IACpC,SAAS,EAAE,eAAe;IAC1B,iBAAiB,EAAE,uBAAuB;IAC1C,UAAU,EAAE,gBAAgB;IAC5B,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,YAAY;IACpB,GAAG,EAAE,SAAS;IACd,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,UAAU;CACjB,CAAA;AAED,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAA;AAC/B,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAE1E,OAAO,EAAE,OAAO,IAAI,CAAC,EAAE,CAAA;AACvB,eAAe,OAAO,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/_exports/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,8BAA8B,EAC9B,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACpE,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,YAAY,EACZ,WAAW,EACX,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,GACnB,MAAM,gBAAgB,CAAA;AAEvB,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,GAAG,EAAE,iBAAiB;IACtB,MAAM,EAAE,YAAY;IACpB,WAAW,EAAE;QACX,GAAG,eAAe;QAClB,GAAG,kBAAkB;QACrB,GAAI,kBAAgD;KACrD;IACD,SAAS,EAAE,eAAe;IAC1B,MAAM,EAAE,YAAY;IACpB,OAAO,EAAE;QACP,OAAO;QACL,qBAAqB;QACrB,8BAAuE;KAC1E;IACD,KAAK,EAAE,qBAAqB;IAC5B,IAAI,EAAE,oBAAoB;IAC1B,OAAO,EAAE,uBAAuB;IAChC,UAAU,EAAE,gBAAgB;IAC5B,MAAM,EAAE,YAAY;IACpB,cAAc,EAAE,oBAAoB;IACpC,SAAS,EAAE,eAAe;IAC1B,iBAAiB,EAAE,uBAAuB;IAC1C,UAAU,EAAE,gBAAgB;IAC5B,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,YAAY;IACpB,GAAG,EAAE,SAAS;IACd,IAAI,EAAE,UAAU;CACjB,CAAA;AAED,OAAO,EAAE,CAAC,EAAE,MAAM,iBAAiB,CAAA;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,EAEL,WAAW,EACX,sBAAsB,GACvB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AACzE,OAAO,EAAE,CAAC,EAAE,MAAM,aAAa,CAAA;AAC/B,OAAO,EACL,QAAQ,EACR,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,SAAS,EACT,UAAU,GACX,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAE,OAAO,IAAI,CAAC,EAAE,CAAA;AACvB,eAAe,OAAO,CAAA"}

package/dist/vite/server.js

@@ -3,6 +3,7 @@ export function createServer(options, config, dev = {}) {
     return createViteServer({
         ...config,
         server: { middlewareMode: true, ws: false },
+        resolve: { tsconfigPaths: true, ...config.resolve },
         environments: {
             neemata: {
                 consumer: 'server',

package/dist/vite/server.js.map

@@ -1 +1 @@
-{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/vite/server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,MAAM,CAAA;AAIvD,MAAM,UAAU,YAAY,CAC1B,OAA0B,EAC1B,MAAkB,EAClB,MAA6B,EAAE;IAE/B,OAAO,gBAAgB,CAAC;QACtB,GAAG,MAAM;QACT,MAAM,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE;QAC3C,YAAY,EAAE;YACZ,OAAO,EAAE;gBACP,QAAQ,EAAE,QAAQ;gBAClB,GAAG;gBACH,MAAM,EAAE;oBACN,eAAe,EAAE,IAAI,CAAC,SAAS,CAC7B,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAC/C;oBACD,uBAAuB,EAAE,IAAI,CAAC,SAAS,CACrC,IAAI,CAAC,SAAS,CACZ,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,GAAG,CAC5C,CAAC,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CACzC,CACF,CACF,CACF;iBACF;aACF;SACF;KACF,CAAC,CAAA;AACJ,CAAC"}
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/vite/server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,MAAM,CAAA;AAIvD,MAAM,UAAU,YAAY,CAC1B,OAA0B,EAC1B,MAAkB,EAClB,MAA6B,EAAE;IAE/B,OAAO,gBAAgB,CAAC;QACtB,GAAG,MAAM;QACT,MAAM,EAAE,EAAE,cAAc,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE;QAC3C,OAAO,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC,OAAO,EAAE;QACnD,YAAY,EAAE;YACZ,OAAO,EAAE;gBACP,QAAQ,EAAE,QAAQ;gBAClB,GAAG;gBACH,MAAM,EAAE;oBACN,eAAe,EAAE,IAAI,CAAC,SAAS,CAC7B,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAC/C;oBACD,uBAAuB,EAAE,IAAI,CAAC,SAAS,CACrC,IAAI,CAAC,SAAS,CACZ,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,GAAG,CAC5C,CAAC,CAAC,OAAO,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CACzC,CACF,CACF,CACF;iBACF;aACF;SACF;KACF,CAAC,CAAA;AACJ,CAAC"}

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/common": "0.15.0-beta.3",
-    "@nmtjs/contract": "0.15.0-beta.3",
-    "@nmtjs/gateway": "0.15.0-beta.3",
-    "@nmtjs/json-format": "0.15.0-beta.3",
-    "@nmtjs/protocol": "0.15.0-beta.3",
-    "@nmtjs/runtime": "0.15.0-beta.3",
-    "@nmtjs/core": "0.15.0-beta.3",
-    "@nmtjs/type": "0.15.0-beta.3",
-    "@nmtjs/ws-transport": "0.15.0-beta.3",
-    "@nmtjs/http-transport": "0.15.0-beta.3"
+    "@nmtjs/common": "0.15.0-beta.5",
+    "@nmtjs/contract": "0.15.0-beta.5",
+    "@nmtjs/core": "0.15.0-beta.5",
+    "@nmtjs/gateway": "0.15.0-beta.5",
+    "@nmtjs/json-format": "0.15.0-beta.5",
+    "@nmtjs/protocol": "0.15.0-beta.5",
+    "@nmtjs/runtime": "0.15.0-beta.5",
+    "@nmtjs/type": "0.15.0-beta.5",
+    "@nmtjs/ws-transport": "0.15.0-beta.5",
+    "@nmtjs/http-transport": "0.15.0-beta.5"
   },
   "devDependencies": {
-    "@nmtjs/proxy": "0.15.0-beta.3"
+    "@nmtjs/proxy": "0.15.0-beta.5"
   },
   "peerDependencies": {
-    "@nmtjs/proxy": "0.15.0-beta.3"
+    "@nmtjs/proxy": "0.15.0-beta.5"
   },
   "peerDependenciesMeta": {
     "@nmtjs/proxy": {
@@ -40,10 +40,11 @@
   },
   "files": [
     "dist",
+    "src",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.3",
+  "version": "0.15.0-beta.5",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc --declaration --sourcemap",

package/src/_exports/application.ts

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

package/src/_exports/common.ts

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

package/src/_exports/contract.ts

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

package/src/_exports/core.ts

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

package/src/_exports/gateway.ts

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

package/src/_exports/http-transport/bun.ts

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

package/src/_exports/http-transport/deno.ts

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

package/src/_exports/http-transport/node.ts

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

package/src/_exports/http-transport.ts

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

package/src/_exports/index.ts

@@ -0,0 +1,75 @@
+import {
+  CoreInjectables,
+  createConsolePrettyDestination,
+  createFactoryInjectable,
+  createLazyInjectable,
+  createValueInjectable,
+} from '@nmtjs/core'
+import { createTransport, GatewayInjectables } from '@nmtjs/gateway'
+import {
+  createContractProcedure,
+  createContractRouter,
+  createFilter,
+  createGuard,
+  createHook,
+  createJob,
+  createMiddleware,
+  createPlugin,
+  createProcedure,
+  createRootRouter,
+  createRouter,
+  defineApplication,
+  defineServer,
+  RuntimeInjectables,
+} from '@nmtjs/runtime'
+
+export const neemata = {
+  app: defineApplication,
+  server: defineServer,
+  injectables: {
+    ...CoreInjectables,
+    ...GatewayInjectables,
+    ...(RuntimeInjectables as typeof RuntimeInjectables),
+  },
+  transport: createTransport,
+  plugin: createPlugin,
+  logging: {
+    console:
+      // TODO: TSC wants it
+      createConsolePrettyDestination as typeof createConsolePrettyDestination,
+  },
+  value: createValueInjectable,
+  lazy: createLazyInjectable,
+  factory: createFactoryInjectable,
+  rootRouter: createRootRouter,
+  router: createRouter,
+  contractRouter: createContractRouter,
+  procedure: createProcedure,
+  contractProcedure: createContractProcedure,
+  middleware: createMiddleware,
+  guard: createGuard,
+  filter: createFilter,
+  job: createJob,
+  hook: createHook,
+}
+
+export { c } from '@nmtjs/contract'
+export { Scope } from '@nmtjs/core'
+export {
+  type ConnectionIdentityType,
+  GatewayHook,
+  ProxyableTransportType,
+} from '@nmtjs/gateway'
+export { ConnectionType, ErrorCode, ProtocolBlob } from '@nmtjs/protocol'
+export { t } from '@nmtjs/type'
+export {
+  ApiError,
+  defineApplication,
+  JobWorkerQueue,
+  LifecycleHook,
+  StoreType,
+  WorkerType,
+} from 'nmtjs/runtime'
+
+export { neemata as n }
+export default neemata

package/src/_exports/json-format.ts

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

package/src/_exports/protocol/client.ts

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

package/src/_exports/protocol/server.ts

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

package/src/_exports/protocol.ts

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

package/src/_exports/runtime/types.ts

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

package/src/_exports/runtime.ts

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

package/src/_exports/type.ts

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

package/src/_exports/ws-transport/bun.ts

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

package/src/_exports/ws-transport/deno.ts

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

package/src/_exports/ws-transport/node.ts

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

package/src/_exports/ws-transport.ts

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

package/src/cli.ts

@@ -0,0 +1,139 @@
+#!/usr/bin/env node --enable-source-maps
+
+import { once } from 'node:events'
+import { relative, resolve } from 'node:path'
+import process from 'node:process'
+
+import type { ArgDef } from 'citty'
+import { defineCommand, runMain } from 'citty'
+import { config as dotenv } from 'dotenv'
+
+import type { NeemataConfig } from './config.ts'
+import type { ViteConfigOptions } from './vite/config.ts'
+import { resolver } from './resolver.ts'
+import { generateTypings } from './typings.ts'
+import { createBuilder } from './vite/builder.ts'
+import { baseViteConfigOptions } from './vite/config.ts'
+import { createMainServer } from './vite/servers/main.ts'
+
+// 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,
+  },
+} satisfies Record<string, ArgDef>
+
+let config: NeemataConfig
+let viteConfigOptions: ViteConfigOptions
+let applicationImports: Record<string, { path: string; specifier: string }>
+
+const mainCommand = defineCommand({
+  meta: { description: 'Neemata CLI' },
+  args: { ...commonArgs },
+  async setup(ctx) {
+    const configPath = resolve(ctx.args.config as string)
+    config = await import(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/src/command.ts

@@ -0,0 +1,30 @@
+// import type { ApplicationWorker } from '@nmtjs/runtime/worker'
+// import { typeToString } from '@nmtjs/type'
+// import { defineCommand } from 'citty'
+
+// 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/src/config.ts

@@ -0,0 +1,64 @@
+import type { Plugin as VitePlugin } from 'vite'
+
+export type ExtrernalDependency = string | RegExp
+
+type DeepPartial<T> = {
+  [P in keyof T]?: T[P] extends Record<any, unknown> ? DeepPartial<T[P]> : T[P]
+}
+
+export interface NeemataConfig {
+  /**
+   * Path to application entry point
+   */
+  applications: {
+    /**
+     * Application name
+     */
+    [appName: string]: string
+  }
+  /**
+   * Path to server entry point
+   */
+  serverPath: string
+  /**
+   * External dependencies to exclude from application bundle
+   *
+   * 'prod' - exclude production dependencies from package.json
+   *
+   * 'all' - exclude all dependencies from package.json
+   *
+   * ExtrernalDependency[] - array of package names or regular expressions to match package names
+   */
+  externalDependencies: 'prod' | 'all' | ExtrernalDependency[]
+  /**
+   * Timeout in milliseconds for graceful shutdown of application workers
+   */
+  timeout: number
+
+  /**
+   * Environment variables to set for application workers
+   *
+   * Strings are paths to .env files
+   * Records are key-value pairs to set directly
+   */
+  env: (Record<string, string> | string)[]
+
+  build: { outDir: string; minify: boolean }
+  plugins: VitePlugin[]
+}
+
+export function defineConfig(
+  config: DeepPartial<NeemataConfig> = {},
+): NeemataConfig {
+  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/src/entrypoints/cli.ts

@@ -0,0 +1,13 @@
+// // import { ApplicationType, ApplicationWorkerType } from '@nmtjs/application'
+// import { runMain } from 'citty'
+
+// 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/src/entrypoints/main.ts

@@ -0,0 +1,111 @@
+import type { Worker } from 'node:worker_threads'
+import EventEmitter from 'node:events'
+import { fileURLToPath } from 'node:url'
+
+import type { ServerConfig } from '@nmtjs/runtime'
+import type { ViteDevServer } from 'vite'
+import { ApplicationServer, isServerConfig } from '@nmtjs/runtime'
+
+declare global {
+  const __VITE_CONFIG__: string
+  const __APPLICATIONS_CONFIG__: string
+}
+
+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: EventEmitter<{ worker: [Worker] }> | undefined
+let _viteWorkerServer: ViteDevServer | undefined
+
+let server: ApplicationServer
+
+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.ts')
+  const neemataConfig = await import(
+    /* @vite-ignore */
+    _vite.options.configPath
+  ).then((m) => m.default as import('../config.ts').NeemataConfig)
+  _viteServerEvents = new EventEmitter<{ worker: [Worker] }>()
+  _viteWorkerServer = await createWorkerServer(
+    _vite.options,
+    _vite.mode,
+    neemataConfig,
+    _viteServerEvents,
+  )
+}
+
+async function createServer(config: ServerConfig) {
+  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: 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/src/entrypoints/thread.ts

@@ -0,0 +1,69 @@
+import type { MessagePort } from 'node:worker_threads'
+import { fileURLToPath } from 'node:url'
+import { workerData as _workerData } from 'node:worker_threads'
+
+import type { ThreadPortMessage } from '@nmtjs/runtime'
+import type { ModuleRunner } from 'vite/module-runner'
+
+export type RunWorkerOptions = {
+  port: MessagePort
+  runtime:
+    | { type: 'application'; name: string; path: string; transportsData: any }
+    | { type: 'jobs'; jobWorkerQueue: string }
+  vite?: 'development' | 'production'
+}
+
+const workerData = _workerData as RunWorkerOptions
+
+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: ModuleRunner
+let workerModule: typeof import('./worker.ts')
+
+try {
+  if (workerData.vite) {
+    const { createModuleRunner } = (await import(
+      '../vite/runners/worker.ts'
+    )) as typeof import('../vite/runners/worker.ts')
+
+    runner = createModuleRunner(workerData.vite)
+    workerModule = await runner.import(workerPath)
+  } else {
+    runner = undefined as any
+    workerModule = await import(
+      /* @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 },
+  } satisfies ThreadPortMessage)
+} catch (error) {
+  console.error(new Error('Worker thread error:', { cause: error }))
+}

package/src/entrypoints/worker.ts

@@ -0,0 +1,48 @@
+import { workerData } from 'node:worker_threads'
+
+import type { ServerConfig } from '@nmtjs/runtime'
+import {
+  ApplicationWorkerRuntime,
+  isApplicationConfig,
+  JobWorkerRuntime,
+} from '@nmtjs/runtime'
+
+import type { RunWorkerOptions } from './thread.ts'
+
+export async function run(options: RunWorkerOptions['runtime']) {
+  const serverConfig: ServerConfig = await import(
+    // @ts-expect-error
+    '#server'
+  ).then((m) => m.default)
+  if (options.type === 'application') {
+    globalThis._hotAccept = (module: any) => {
+      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(
+      /* @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 as any).type}`)
+  }
+}

package/src/resolver.ts

@@ -0,0 +1,16 @@
+import { ResolverFactory } from 'oxc-resolver'
+
+const fallback: Record<string, [string]> = {}
+
+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/src/typings.ts

@@ -0,0 +1,27 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+
+import dedent from 'dedent'
+
+export async function generateTypings(
+  applicationImports: Record<string, { path: string; specifier: string }>,
+) {
+  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/src/vite/builder.ts

@@ -0,0 +1,119 @@
+import { isBuiltin } from 'node:module'
+import { resolve } from 'node:path'
+
+import { build as viteBuild } from 'vite'
+
+import type { NeemataConfig } from '../config.ts'
+import type { ViteConfigOptions } from './config.ts'
+// import pkgJson from '../../package.json' with { type: 'json' }
+import { createConfig } from './config.ts'
+import { buildPlugins } from './plugins.ts'
+
+export async function createBuilder(
+  configOptions: ViteConfigOptions,
+  neemataConfig: NeemataConfig,
+) {
+  const config = createConfig(configOptions)
+  async function build(): Promise<any> {
+    const packageJson = await import(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/src/vite/config.ts

@@ -0,0 +1,42 @@
+import { fileURLToPath } from 'node:url'
+
+export type ViteConfigOptions = {
+  applicationImports: Record<string, { path: string; specifier: string }>
+  serverEntryPath: string
+  entrypointMainPath: string
+  entrypointWorkerPath: string
+  entrypointThreadPath: string
+  // entrypointCLIPath: string
+  configPath: string
+}
+
+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')),
+} satisfies Partial<ViteConfigOptions>
+
+export function createConfig(options: ViteConfigOptions) {
+  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/src/vite/plugins.ts

@@ -0,0 +1,26 @@
+import { dirname, join } from 'node:path'
+
+import type { Plugin } from 'vite'
+import type { Target } from 'vite-plugin-static-copy'
+import { viteStaticCopy } from 'vite-plugin-static-copy'
+
+import { resolver } from '../resolver.ts'
+
+const targets: Target[] = []
+
+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: Plugin[] = [
+  ...(targets.length ? viteStaticCopy({ targets }) : []),
+]

package/src/vite/runners/worker.ts

@@ -0,0 +1,57 @@
+import {
+  BroadcastChannel,
+  isInternalThread,
+  isMainThread,
+  parentPort,
+  threadId,
+} from 'node:worker_threads'
+
+import type { HotPayload } from 'vite'
+import type { ModuleRunnerTransport } from 'vite/module-runner'
+import { noopFn } from '@nmtjs/common'
+import {
+  createNodeImportMeta,
+  ESModulesEvaluator,
+  ModuleRunner,
+} from 'vite/module-runner'
+
+export function createBroadcastChannel(threadId: number): BroadcastChannel {
+  return new BroadcastChannel(`nmtjs:vite:${threadId}`)
+}
+
+export function createModuleRunner(
+  mode: 'development' | 'production' = 'development',
+): ModuleRunner {
+  if (isMainThread || isInternalThread)
+    throw new Error('Module runner can only be created inside worker threads.')
+
+  const channel = createBroadcastChannel(threadId)
+
+  const transport: ModuleRunnerTransport = {
+    connect({ onMessage, onDisconnection }) {
+      // @ts-expect-error
+      channel.onmessage = (event: MessageEvent<HotPayload>) => {
+        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/src/vite/server.ts

@@ -0,0 +1,36 @@
+import type { DevEnvironmentOptions, UserConfig } from 'vite'
+import { createServer as createViteServer } from 'vite'
+
+import type { ViteConfigOptions } from './config.ts'
+
+export function createServer(
+  options: ViteConfigOptions,
+  config: UserConfig,
+  dev: DevEnvironmentOptions = {},
+) {
+  return createViteServer({
+    ...config,
+    server: { middlewareMode: true, ws: false },
+    resolve: { tsconfigPaths: true, ...config.resolve },
+    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/src/vite/servers/main.ts

@@ -0,0 +1,34 @@
+import type { ViteDevServer } from 'vite'
+import type { ModuleRunner } from 'vite/module-runner'
+import { noopFn } from '@nmtjs/common'
+import { createServerModuleRunner } from 'vite'
+
+import type { NeemataConfig } from '../../config.ts'
+import type { ViteConfigOptions } from '../config.ts'
+import { createConfig } from '../config.ts'
+import { buildPlugins } from '../plugins.ts'
+import { createServer } from '../server.ts'
+
+export async function createMainServer(
+  options: ViteConfigOptions,
+  mode: 'development' | 'production',
+  neemataConfig: NeemataConfig,
+): Promise<{ server: ViteDevServer; runner: ModuleRunner }> {
+  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/src/vite/servers/worker.ts

@@ -0,0 +1,107 @@
+import type EventEmitter from 'node:events'
+import type { BroadcastChannel, Worker } from 'node:worker_threads'
+
+import type {
+  HotChannel,
+  HotChannelClient,
+  HotChannelListener,
+  HotPayload,
+  ViteDevServer,
+} from 'vite'
+import { DevEnvironment } from 'vite'
+
+import type { NeemataConfig } from '../../config.ts'
+import type { ViteConfigOptions } from '../config.ts'
+import { createConfig } from '../config.ts'
+import { buildPlugins } from '../plugins.ts'
+import { createBroadcastChannel } from '../runners/worker.ts'
+import { createServer } from '../server.ts'
+
+export async function createWorkerServer(
+  options: ViteConfigOptions,
+  mode: 'development' | 'production',
+  neemataConfig: NeemataConfig,
+  events: EventEmitter<{ worker: [Worker] }>,
+): Promise<ViteDevServer> {
+  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<number, BroadcastChannel>()
+        const clients = new Map<BroadcastChannel, HotChannelClient>()
+        const handlers = new Map<string, HotChannelListener>()
+
+        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: HotPayload) => {
+              channel.postMessage(payload)
+            },
+          }
+          clients.set(channel, client)
+          worker.on('exit', () => {
+            const handler = handlers.get('vite:client:disconnect')
+            if (handler) handler(undefined, client)
+          })
+        })
+
+        const transport: HotChannel = {
+          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
+}