@morojs/engine 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) CM Ventures Inc.
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
package/README.md ADDED
@@ -0,0 +1,74 @@
1
+ # @morojs/engine
2
+
3
+ MoroJS's native HTTP engine: a Moro-authored C++ core with raw-V8 bindings,
4
+ shipped as **prebuilt binaries per platform x Node ABI**. MIT licensed.
5
+
6
+ This is the meta package. It contains only a small JavaScript loader plus the
7
+ TypeScript types; the actual `.node` binaries are delivered by per-platform
8
+ optional dependencies (`@morojs/engine-<platform>-<arch>[-<libc>]`). The loader
9
+ selects the correct binary for your `process.platform` / `arch` /
10
+ `versions.modules` (Node ABI), and is glibc/musl-aware on Linux.
11
+
12
+ ## Install
13
+
14
+ ```bash
15
+ npm install @morojs/engine
16
+ ```
17
+
18
+ You normally do not install this directly - MoroJS depends on it and uses it
19
+ automatically, falling back to Node's built-in `http` server wherever a
20
+ prebuilt binary is not available:
21
+
22
+ ```js
23
+ // moro config
24
+ server: {
25
+ engine: 'moro', // default - native engine when loadable, Node http otherwise
26
+ // engine: 'node' - always use Node http
27
+ // engine: 'uws' - opt in to uWebSockets.js
28
+ }
29
+ ```
30
+
31
+ MoroJS always degrades to the Node `http` server when the native engine can't
32
+ load (the reason is logged at startup and exposed via `app.engine.fallbackReason`);
33
+ there is no "fail fast" engine value. The legacy `'auto'`/`'native'` values map
34
+ to `'moro'` with a deprecation warning.
35
+
36
+ ## Graceful degradation
37
+
38
+ Requiring/importing this package **never throws**, even on a platform with no
39
+ prebuilt binary. Use the non-throwing `probe()` to detect availability:
40
+
41
+ ```js
42
+ const engine = require('@morojs/engine');
43
+
44
+ const info = engine.probe();
45
+ // { ok: true, version, platform, arch, abi } when a binary loaded
46
+ // { ok: false, platform, arch, abi, error } otherwise (actionable message)
47
+
48
+ if (info.ok) {
49
+ // engine.serve(...), engine.listen(...), ...
50
+ }
51
+ ```
52
+
53
+ Actual API calls (`serve`, `listen`, ...) on a platform without a binary throw a
54
+ rich, actionable error (`err.code === 'MORO_ENGINE_BINARY_MISSING'`) that names
55
+ the expected package, the running Node ABI, and the remediation for npm's
56
+ optional-dependency lockfile bug ([npm/cli#4828](https://github.com/npm/cli/issues/4828)).
57
+
58
+ ## Supported platforms
59
+
60
+ | Package | os | cpu | libc |
61
+ | -------------------------------- | ------ | ------- | ----- |
62
+ | `@morojs/engine-darwin-arm64` | darwin | arm64 | - |
63
+ | `@morojs/engine-darwin-x64` | darwin | x64 | - |
64
+ | `@morojs/engine-linux-x64-gnu` | linux | x64 | glibc |
65
+ | `@morojs/engine-linux-arm64-gnu` | linux | arm64 | glibc |
66
+ | `@morojs/engine-linux-x64-musl` | linux | x64 | musl |
67
+
68
+ Node ABIs: 115/127/131/137/141/147 (Node 20/22/23/24/25/26). Any other
69
+ platform/ABI (including Windows, until an MSVC build lands) falls back to
70
+ Node's `http` server via MoroJS.
71
+
72
+ ## License
73
+
74
+ MIT licensed.
package/index.d.ts ADDED
@@ -0,0 +1,201 @@
1
+ // Type definitions for @morojs/engine.
2
+ // The Moro-shaped native HTTP/1.1 + WebSocket binding (see docs/API.md).
3
+
4
+ export interface EngineCapabilities {
5
+ /** The full serve() limit surface (maxHeadSize/maxHeaders/wsMaxMessageSize/
6
+ * wsBackpressureLimit/writeHighWaterMark/backlog) is parsed. */
7
+ limits: boolean;
8
+ /** In-process TLS termination via ServeOptions.ssl. */
9
+ tls: boolean;
10
+ /** ALPN-negotiated HTTP/2 alongside HTTP/1.1 via ServeOptions.http2. */
11
+ http2: boolean;
12
+ /** WebSocket permessage-deflate (RFC 7692) via ServeOptions.wsDeflate. */
13
+ wsDeflate: boolean;
14
+ }
15
+
16
+ export interface EngineProbeResult {
17
+ /** True when a native binary loaded for this platform/ABI */
18
+ ok: boolean;
19
+ /** Engine version — the published package version (always set by the loader). */
20
+ version?: string;
21
+ platform: string;
22
+ arch: string;
23
+ /** Node ABI (process.versions.modules) the binary was built for */
24
+ abi: number | string;
25
+ /** Feature flags for consumers to gate option passing on (feature-detect;
26
+ * treat absent as all-false). */
27
+ capabilities?: EngineCapabilities;
28
+ /** Load failure detail when ok is false */
29
+ error?: string;
30
+ }
31
+
32
+ export interface ServeCallbacks {
33
+ /** A complete request (head + body) arrived. methodIdx indexes
34
+ * ['GET','POST','PUT','DELETE','PATCH','HEAD','OPTIONS','OTHER']. */
35
+ onRequest(reqId: number, methodIdx: number, path: string): void;
36
+ /** The client disconnected before the response completed. */
37
+ onAborted(reqId: number): void;
38
+ /** A backpressured write() drained; safe to write more. */
39
+ onWritable(reqId: number): void;
40
+ /** WebSocket opened after a successful Upgrade. */
41
+ onWsOpen?(wsId: number, path: string): void;
42
+ /** WebSocket message (text -> string, binary -> ArrayBuffer). */
43
+ onWsMessage?(wsId: number, data: string | ArrayBuffer, isBinary: boolean): void;
44
+ /** WebSocket closed (code per RFC 6455 §7.4). */
45
+ onWsClose?(wsId: number, code: number): void;
46
+ }
47
+
48
+ export interface ServeOptions {
49
+ /** Max request body in bytes; larger bodies are rejected natively (413). */
50
+ maxBodySize?: number;
51
+ /** Close a connection after this many ms with no bytes received while not
52
+ * running a handler (slowloris defense + keep-alive cap). 0 disables.
53
+ * Default 120000. */
54
+ idleTimeoutMs?: number;
55
+ /** Max simultaneous connections; accepts beyond this are dropped
56
+ * immediately (connection-flood defense). 0 = unlimited (default). */
57
+ maxConnections?: number;
58
+ /** Cap on bytes buffered for one connection while its response is in flight
59
+ * (pipelined-flood defense). 0 = maxHeadSize + maxBodySize (default). */
60
+ maxPendingBytes?: number;
61
+ /** Budget in ms for receiving one complete request (head + body), measured
62
+ * from its first byte. Unlike idleTimeoutMs it does NOT reset on activity,
63
+ * so slow-drip (slowloris) clients are bounded. Expiry answers 408 and
64
+ * closes. 0 disables. Default 300000 (Node's server.requestTimeout). */
65
+ requestTimeoutMs?: number;
66
+ /** Bind with SO_REUSEPORT so several engine instances (worker threads or
67
+ * processes) can share one port with kernel-load-balanced accepts —
68
+ * required for clustering. POSIX only; ignored on Windows. Default false. */
69
+ reusePort?: boolean;
70
+ /** Max bytes for the request line + all headers; larger heads are rejected
71
+ * (431). Must be > 0. Default 65536. */
72
+ maxHeadSize?: number;
73
+ /** Max header count; more is rejected (431). Must be > 0. Default 100. */
74
+ maxHeaders?: number;
75
+ /** Cap on a complete (reassembled) WebSocket message; larger messages fail
76
+ * the connection with close code 1009. Must be > 0. Default 16 MiB. */
77
+ wsMaxMessageSize?: number;
78
+ /** WebSocket send backpressure cap: a slow consumer whose write queue grows
79
+ * past this is shed with close code 1013 rather than buffering without
80
+ * bound. 0 = unlimited. Default 1 MiB. */
81
+ wsBackpressureLimit?: number;
82
+ /** Write-queue level above which write()/wsSend() report backpressure
83
+ * (false) and onWritable is armed. Must be > 0. Default 262144. */
84
+ writeHighWaterMark?: number;
85
+ /** TCP listen backlog handed to the kernel. Must be > 0. Default 512. */
86
+ backlog?: number;
87
+ /** In-process TLS termination (feature-detect via
88
+ * probe().capabilities.tls). Both shapes work; inline PEM wins when both
89
+ * are given for the same slot. Config errors THROW from serve(). */
90
+ ssl?: {
91
+ /** File-path shape */
92
+ key_file_name?: string;
93
+ cert_file_name?: string;
94
+ ca_file_name?: string;
95
+ /** Inline-PEM shape (node-style; string | Buffer | ArrayBuffer) */
96
+ key?: string | ArrayBuffer | Uint8Array;
97
+ cert?: string | ArrayBuffer | Uint8Array;
98
+ ca?: string | ArrayBuffer | Uint8Array;
99
+ /** Decrypts an encrypted private key */
100
+ passphrase?: string;
101
+ /** Protocol floor. Default 'TLSv1.2'. */
102
+ minVersion?: 'TLSv1.2' | 'TLSv1.3';
103
+ /** Request a client certificate (mutual TLS) */
104
+ requestCert?: boolean;
105
+ /** Fail the handshake when the client cert doesn't verify (default true) */
106
+ rejectUnauthorized?: boolean;
107
+ };
108
+ /** WebSocket permessage-deflate (RFC 7692). Off by default.
109
+ * boolean to enable with defaults, or an options object. */
110
+ wsDeflate?:
111
+ | boolean
112
+ | {
113
+ serverNoContextTakeover?: boolean;
114
+ clientNoContextTakeover?: boolean;
115
+ serverMaxWindowBits?: number; // 8..15
116
+ clientMaxWindowBits?: number; // 8..15
117
+ /** Min message bytes before a send is compressed. Default 1024. */
118
+ threshold?: number;
119
+ /** Hard cap on an inflated message (zip-bomb defense).
120
+ * Default: wsMaxMessageSize. */
121
+ maxDecompressedSize?: number;
122
+ };
123
+ }
124
+
125
+ type BodyInit = string | ArrayBuffer | Uint8Array | Buffer;
126
+
127
+ /** Register callbacks and create a server. Sockets open only at listen(). */
128
+ export function serve(callbacks: ServeCallbacks, options?: ServeOptions): number;
129
+ /** Bind + listen; returns the actual bound port (supports port 0). Throws on failure. */
130
+ export function listen(serverId: number, host: string, port: number): number;
131
+ /** Tear down the server: stop accepting AND close every live connection
132
+ * (in-flight requests get onAborted). For a graceful shutdown, call
133
+ * stopListening() first, drain, then close(). */
134
+ export function close(serverId: number): void;
135
+ /** Stop accepting new connections while existing ones keep being served —
136
+ * the drain phase of a graceful shutdown. Idempotent. */
137
+ export function stopListening(serverId: number): void;
138
+
139
+ // ---- per-request accessors (valid until the response ends / aborts) ----
140
+ export function getMethod(reqId: number): string | undefined;
141
+ export function getQuery(reqId: number): string;
142
+ /** Flat [k0,v0,k1,v1,...] with lowercased keys. */
143
+ export function getHeaders(reqId: number): string[];
144
+ export function getHeader(reqId: number, lowercaseName: string): string | undefined;
145
+ export function getBody(reqId: number): ArrayBuffer | null;
146
+ export function getRemoteAddress(reqId: number): string;
147
+ export function isAborted(reqId: number): boolean;
148
+
149
+ // ---- response ----
150
+ /** Terminal single-shot response (status + headers + body in one cork). */
151
+ export function respond(
152
+ reqId: number,
153
+ status: number,
154
+ headersFlat: string[] | null,
155
+ body: BodyInit | null
156
+ ): void;
157
+ export function writeHead(reqId: number, status: number, headersFlat: string[] | null): void;
158
+ /** Stream a chunk; returns false on backpressure (wait for onWritable). */
159
+ export function write(reqId: number, chunk: BodyInit): boolean;
160
+ export function end(reqId: number, chunk?: BodyInit): void;
161
+
162
+ // ---- WebSocket (RFC 6455) ----
163
+ /** Upgrade the request's connection; returns wsId, or -1 if not a valid upgrade. */
164
+ export function upgradeToWebSocket(reqId: number): number;
165
+ /** Send a frame; returns false on backpressure. */
166
+ export function wsSend(wsId: number, data: string | ArrayBuffer | Uint8Array | Buffer, isBinary: boolean): boolean;
167
+ /** Send a Close frame and close the connection. */
168
+ export function wsClose(wsId: number, code?: number, reason?: string): void;
169
+
170
+ /** Non-throwing load diagnostics. Never throws. */
171
+ export function probe(): EngineProbeResult;
172
+ // The engine version comes from this package's package.json (stamped from the
173
+ // release tag), available without loading the addon via `probe().version` or on
174
+ // the default export as `engine.version` — neither forces the native addon to
175
+ // load. It is intentionally not a standalone named export, so that a bare
176
+ // `import` of this package never loads the addon.
177
+
178
+ declare const engine: {
179
+ serve: typeof serve;
180
+ listen: typeof listen;
181
+ close: typeof close;
182
+ stopListening: typeof stopListening;
183
+ getMethod: typeof getMethod;
184
+ getQuery: typeof getQuery;
185
+ getHeaders: typeof getHeaders;
186
+ getHeader: typeof getHeader;
187
+ getBody: typeof getBody;
188
+ getRemoteAddress: typeof getRemoteAddress;
189
+ isAborted: typeof isAborted;
190
+ respond: typeof respond;
191
+ writeHead: typeof writeHead;
192
+ write: typeof write;
193
+ end: typeof end;
194
+ upgradeToWebSocket: typeof upgradeToWebSocket;
195
+ wsSend: typeof wsSend;
196
+ wsClose: typeof wsClose;
197
+ probe: typeof probe;
198
+ version: string;
199
+ };
200
+
201
+ export default engine;
package/index.js ADDED
@@ -0,0 +1,130 @@
1
+ 'use strict';
2
+ // @morojs/engine loader (CJS core - .node addon loading is require-based).
3
+ //
4
+ // Resolution order:
5
+ // 1. The matching per-platform package (@morojs/engine-<platform>-<arch>[-libc])
6
+ // published as an exact-version optionalDependency of this package.
7
+ // 2. A local build/ directory (engine repo development).
8
+ //
9
+ // Binary naming: moro_engine_<platform>_<arch>[_<libc>]_<abi>.node
10
+ // (libc segment on linux only: gnu | musl)
11
+
12
+ const { existsSync } = require('fs');
13
+ const { join } = require('path');
14
+
15
+ // The engine version is whatever this package publishes: tools/prepare-release.mjs
16
+ // stamps package.json from the release tag, so reading it here keeps probe() and
17
+ // `.version` in lockstep with the published package — one source of truth, no
18
+ // compiled constant to drift. (The native binding still carries kEngineVersion
19
+ // as a build-time fallback; the loader overrides it below.)
20
+ const { version: ENGINE_VERSION } = require('./package.json');
21
+
22
+ function libcSuffix() {
23
+ if (process.platform !== 'linux') return '';
24
+ // glibc exposes its version in the process report; musl does not. When the
25
+ // report API is unavailable entirely, assume glibc (the overwhelmingly
26
+ // common case) rather than musl.
27
+ try {
28
+ const report = process.report && process.report.getReport();
29
+ if (!report) return '-gnu';
30
+ if (report.header && report.header.glibcVersionRuntime) return '-gnu';
31
+ return '-musl';
32
+ } catch {
33
+ return '-gnu';
34
+ }
35
+ }
36
+
37
+ function binaryName() {
38
+ const libc = libcSuffix().replace('-', '_'); // '' | '_gnu' | '_musl'
39
+ return `moro_engine_${process.platform}_${process.arch}${libc}_${process.versions.modules}.node`;
40
+ }
41
+
42
+ function platformPackageName() {
43
+ return `@morojs/engine-${process.platform}-${process.arch}${libcSuffix()}`;
44
+ }
45
+
46
+ function tryLoad() {
47
+ const name = binaryName();
48
+ const attempts = [];
49
+
50
+ // 1. Per-platform npm package
51
+ const pkg = platformPackageName();
52
+ try {
53
+ return { module: require(require.resolve(`${pkg}/${name}`)), from: pkg };
54
+ } catch (err) {
55
+ attempts.push(`${pkg}/${name}: ${err.message.split('\n')[0]}`);
56
+ }
57
+
58
+ // 2. Engine repo local build (development)
59
+ const local = join(__dirname, '..', '..', 'build', name);
60
+ if (existsSync(local)) {
61
+ try {
62
+ return { module: require(local), from: local };
63
+ } catch (err) {
64
+ attempts.push(`${local}: ${err.message.split('\n')[0]}`);
65
+ }
66
+ } else {
67
+ attempts.push(`${local}: not present`);
68
+ }
69
+
70
+ const error = new Error(
71
+ `@morojs/engine: no prebuilt binary for ${process.platform}/${process.arch} ` +
72
+ `on Node ABI ${process.versions.modules} (Node ${process.versions.node}).\n` +
73
+ `Expected package: ${pkg}\n` +
74
+ `Attempts:\n ${attempts.join('\n ')}\n` +
75
+ `If the platform package is missing from node_modules, this is usually npm's ` +
76
+ `optional-dependency lockfile bug (npm/cli#4828): rm -rf node_modules package-lock.json && npm install.\n` +
77
+ `MoroJS falls back to the Node.js http server automatically; the reason is ` +
78
+ `logged at startup and exposed via app.engine.fallbackReason.`
79
+ );
80
+ error.code = 'MORO_ENGINE_BINARY_MISSING';
81
+ return { error };
82
+ }
83
+
84
+ let loaded = null;
85
+
86
+ function loadBinding() {
87
+ if (!loaded) loaded = tryLoad();
88
+ if (loaded.error) throw loaded.error;
89
+ return loaded.module;
90
+ }
91
+
92
+ /**
93
+ * Non-throwing diagnostics: can the engine load here, and what is it?
94
+ * MoroJS's preflight uses this instead of exception-driven detection.
95
+ */
96
+ function probe() {
97
+ if (!loaded) loaded = tryLoad();
98
+ if (loaded.error) {
99
+ return {
100
+ ok: false,
101
+ version: ENGINE_VERSION,
102
+ platform: process.platform,
103
+ arch: process.arch,
104
+ abi: process.versions.modules,
105
+ error: loaded.error.message,
106
+ };
107
+ }
108
+ // package.json is the source of truth for the version (see ENGINE_VERSION);
109
+ // override the binding's build-time constant so the two can never disagree.
110
+ return { ...loaded.module.probe(), version: ENGINE_VERSION };
111
+ }
112
+
113
+ module.exports = new Proxy(
114
+ { probe, version: ENGINE_VERSION },
115
+ {
116
+ get(target, prop) {
117
+ if (prop in target) return target[prop];
118
+ // Structural probes must never force (and possibly fail) the native
119
+ // load: `then` is touched by `await`/Promise.resolve() on the module,
120
+ // and symbols by console.log/util.inspect. Real engine API props are
121
+ // string-named and never `then`.
122
+ if (typeof prop === 'symbol' || prop === 'then') return undefined;
123
+ // Everything else (serve, listen, ... as the engine grows) comes from the
124
+ // native binding, loaded on first touch. `probe` and `version` are served
125
+ // from the target above so neither forces a native load.
126
+ const binding = loadBinding();
127
+ return binding[prop];
128
+ },
129
+ }
130
+ );
package/index.mjs ADDED
@@ -0,0 +1,38 @@
1
+ // ESM wrapper for @morojs/engine.
2
+ //
3
+ // The core loader (index.js) is CJS because loading a .node addon is
4
+ // require-based, and it exposes the native API through a lazy Proxy. Node's
5
+ // CJS->ESM interop can only surface a Proxy's *default* export (cjs-module-lexer
6
+ // cannot enumerate dynamic props), so this wrapper restates the named surface
7
+ // declared in index.d.ts for ESM consumers.
8
+ //
9
+ // Every function is a thin lazy pass-through: it touches the native binding
10
+ // only when CALLED, so a bare `import` never loads the addon and never throws
11
+ // on a platform without a prebuilt binary. probe() stays non-throwing.
12
+ //
13
+ // Maintenance: keep this list in sync with the function exports in index.d.ts.
14
+ import engine from './index.js';
15
+
16
+ export default engine;
17
+
18
+ // probe() lives on the loader itself (never loads the binding) - safe to alias.
19
+ export const probe = engine.probe;
20
+
21
+ export const serve = (...a) => engine.serve(...a);
22
+ export const listen = (...a) => engine.listen(...a);
23
+ export const close = (...a) => engine.close(...a);
24
+ export const stopListening = (...a) => engine.stopListening(...a);
25
+ export const getMethod = (...a) => engine.getMethod(...a);
26
+ export const getQuery = (...a) => engine.getQuery(...a);
27
+ export const getHeaders = (...a) => engine.getHeaders(...a);
28
+ export const getHeader = (...a) => engine.getHeader(...a);
29
+ export const getBody = (...a) => engine.getBody(...a);
30
+ export const getRemoteAddress = (...a) => engine.getRemoteAddress(...a);
31
+ export const isAborted = (...a) => engine.isAborted(...a);
32
+ export const respond = (...a) => engine.respond(...a);
33
+ export const writeHead = (...a) => engine.writeHead(...a);
34
+ export const write = (...a) => engine.write(...a);
35
+ export const end = (...a) => engine.end(...a);
36
+ export const upgradeToWebSocket = (...a) => engine.upgradeToWebSocket(...a);
37
+ export const wsSend = (...a) => engine.wsSend(...a);
38
+ export const wsClose = (...a) => engine.wsClose(...a);
package/package.json ADDED
@@ -0,0 +1,55 @@
1
+ {
2
+ "name": "@morojs/engine",
3
+ "version": "1.0.0",
4
+ "description": "MoroJS native HTTP engine - Moro-authored C++ core with per-platform prebuilt binaries and automatic Node.js fallback in MoroJS",
5
+ "license": "MIT",
6
+ "author": "CM Ventures Inc.",
7
+ "homepage": "https://github.com/Moro-JS/engine#readme",
8
+ "repository": {
9
+ "type": "git",
10
+ "url": "https://github.com/Moro-JS/engine.git"
11
+ },
12
+ "bugs": {
13
+ "url": "https://github.com/Moro-JS/engine/issues"
14
+ },
15
+ "main": "index.js",
16
+ "types": "index.d.ts",
17
+ "exports": {
18
+ ".": {
19
+ "types": "./index.d.ts",
20
+ "import": "./index.mjs",
21
+ "require": "./index.js",
22
+ "default": "./index.js"
23
+ },
24
+ "./package.json": "./package.json"
25
+ },
26
+ "files": [
27
+ "index.js",
28
+ "index.mjs",
29
+ "index.d.ts",
30
+ "LICENSE",
31
+ "README.md"
32
+ ],
33
+ "engines": {
34
+ "node": ">=20"
35
+ },
36
+ "publishConfig": {
37
+ "access": "public",
38
+ "provenance": true
39
+ },
40
+ "optionalDependencies": {
41
+ "@morojs/engine-darwin-arm64": "1.0.0",
42
+ "@morojs/engine-darwin-x64": "1.0.0",
43
+ "@morojs/engine-linux-x64-gnu": "1.0.0",
44
+ "@morojs/engine-linux-arm64-gnu": "1.0.0",
45
+ "@morojs/engine-linux-x64-musl": "1.0.0",
46
+ "@morojs/engine-win32-x64": "1.0.0"
47
+ },
48
+ "keywords": [
49
+ "morojs",
50
+ "http",
51
+ "server",
52
+ "native",
53
+ "performance"
54
+ ]
55
+ }