diff --git a/frameworks/morojs/Dockerfile b/frameworks/morojs/Dockerfile
new file mode 100644
index 000000000..8898ceefb
--- /dev/null
+++ b/frameworks/morojs/Dockerfile
@@ -0,0 +1,20 @@
+FROM node:26-trixie-slim AS build
+WORKDIR /app
+COPY package.json .
+# @morojs/engine ships prebuilt binaries, so no toolchain is needed here
+RUN npm install --omit=dev --no-audit --no-fund
+
+FROM node:26-trixie-slim
+WORKDIR /app
+COPY --from=build /app/node_modules ./node_modules
+COPY app.mjs .
+COPY views ./views
+ENV NODE_ENV=production
+# The libuv threadpool carries the compression and file reads of every worker
+# thread in the process. Moro sizes it to 64 itself, but only at listen(),
+# after its startup has already initialised the pool at Node's default of 4;
+# an environment variable at process start is what Node reads. 64 matches the
+# benchmark cpuset.
+ENV UV_THREADPOOL_SIZE=64
+EXPOSE 8080
+CMD ["node", "app.mjs"]
diff --git a/frameworks/morojs/README.md b/frameworks/morojs/README.md
new file mode 100644
index 000000000..4629694f5
--- /dev/null
+++ b/frameworks/morojs/README.md
@@ -0,0 +1,76 @@
+# morojs
+
+MoroJS on its native HTTP engine, clustered by the framework itself.
+
+## Stack
+
+- **Language:** JavaScript
+- **Runtime:** Node.js 26
+- **Framework:** [MoroJS 1.8](https://github.com/Moro-JS/moro) on `@morojs/engine`, its own native HTTP engine
+- **Build:** Multi-stage on `node:26-trixie-slim`; the engine ships prebuilt binaries, so no toolchain
+
+## Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/pipeline` | GET | Returns `ok` (plain text) |
+| `/baseline11` | GET/POST | Sums query parameter values, plus the body for POST |
+| `/baseline2` | GET | Sums query parameter values (behind the gateway proxies) |
+| `/delay/:ms` | GET | Waits `ms` milliseconds on an awaited timer, then returns `ms` |
+| `/json/:count` | GET | Serializes a slice of the dataset, brotli or gzip when the client asks for it |
+| `/echo` | POST | Returns the request body back verbatim (TLS listener) |
+| `/ws` | WebSocket | Echoes every text and binary frame unchanged |
+| `/async-db` | GET | Reads from PostgreSQL through `pg`, prepared statement, pool sized under `DATABASE_MAX_CONN` |
+| `/fortunes` | GET | Reads 200 rows from PostgreSQL, appends the runtime row, sorts and renders `views/fortunes.ejs` |
+| `/static/:filename` | GET | Serves a file from disk through the framework's `staticFiles` middleware (TLS listener) |
+| `/public/baseline`, `/public/json/:count` | GET | The baseline and JSON routes as the production-stack edge forwards them, no auth |
+| `/api/items/:id` | GET/POST | Cache-aside read with `X-Cache: HIT` or `MISS`, or a JSON-body update that invalidates the entry and answers 204 |
+| `/api/me` | GET | Reads the user named by `X-User-Id` through the same cache-aside |
+
+## Notes
+
+- Standard mode: the app is `createApp()` with its defaults on the native engine (`engine: 'moro'`,
+  which is also the default). Request tracking and request logging are turned off through their
+  documented options; nothing else is configured.
+- `/pipeline` is a literal handler, `.handler('ok')`: the framework's static route, answered inside
+  the engine without entering JS, with the same `text/plain` reply `res.send('ok')` would give.
+- Clustering is Moro's own (`performance.clustering`): one worker per core, which on the native
+  engine means worker threads that each bind the port through `SO_REUSEPORT`. The count is passed
+  in explicitly from the cgroup quota, because Moro's `auto` counts every host core even under
+  `--cpuset-cpus`.
+- `json-comp` is the framework's `compression()` middleware attached to the `/json` route alone,
+  so no other endpoint pays for the encoder. It negotiates off `Accept-Encoding` per request and
+  leaves the body alone when the header is absent. gzip is preferred over brotli through the
+  middleware's `encodings` option: at the default level it costs about half the CPU of brotli at
+  the default quality for a body a tenth larger, and the profile scores bytes squared against
+  rate; brotli remains available to a client that accepts nothing else.
+- `UV_THREADPOOL_SIZE=64` is set in the Dockerfile. The libuv pool serves the compression and
+  file reads of every worker thread in the process; Moro sets 64 itself but only at `listen()`,
+  after its startup has initialised the pool at Node's default of 4, and Node reads the variable
+  only at process start.
+- `json-tls`, `static-tls` and `8gbit` listen on `8081` behind the engine's own TLS listener
+  (TLS 1.3, ALPN `http/1.1`), when `/certs/server.crt` and `/certs/server.key` are mounted. Moro
+  locks one configuration per process, so that listener is a second process running the same file
+  with `MORO_ROLE=tls`, clustered the same way; it is not started when the certificates are absent.
+- `tls_check` is opted into: a third process of the same file (`MORO_ROLE=tlscheck`) listens on
+  `9000` reading `/certs-tls`, with `server.ssl.watch: true`, so a pair replaced on disk is
+  validated and swapped onto the running listener without a restart and without touching
+  connections already established. Only started when `/certs-tls` is mounted, which validate.sh
+  alone does.
+- `/echo` sends back `req.rawBody`, the framework's undecoded copy of the request body, so the
+  bytes are the bytes that arrived, `Content-Length` or chunked alike.
+- `/ws` is the engine's own RFC 6455 support through `app.websocket()` with `{ raw: true }`, so a
+  text frame reaches the handler as the string it carried and `socket.send()` returns it as one.
+- Static files go through `staticFiles({ root: '/data/static', precompressed: true })`, which
+  stats and reads the file on every request, so a replaced file is served on the next response,
+  and serves the `.br` or `.gz` sidecar on disk when the client accepts it. It is mounted on the
+  TLS listener behind a path check so the JSON route on that port does not pay for the lookup.
+- `fortunes` goes through EJS directly: Moro ships no view layer, so the template is rendered by
+  the engine's own `renderFile`, a separate file with `<%= %>` escaping every cell.
+- The gateway and production-stack edges are stock nginx and Caddy, configured as the fulmine
+  entry configures them: `/static/*` off disk at the edge, everything else forwarded over
+  loopback h1 with a keepalive pool, and `/api/*` past the shared JWT verifier first.
+- The production-stack cache-aside goes through the framework's cache adapters:
+  `RedisCacheAdapter` on the stack's `REDIS_URL`, one connection per worker so an update on any
+  worker invalidates what every other one reads, and `MemoryCacheAdapter` otherwise. Items live
+  for at most a second, users for thirty.
diff --git a/frameworks/morojs/app.mjs b/frameworks/morojs/app.mjs
new file mode 100644
index 000000000..ddfdaf86c
--- /dev/null
+++ b/frameworks/morojs/app.mjs
@@ -0,0 +1,422 @@
+// morojs - MoroJS on its native HTTP engine (@morojs/engine), default
+// configuration. Clustering is the framework's own: performance.clustering
+// starts one worker per core, and on the native engine those are worker
+// threads that each bind the port through SO_REUSEPORT. Moro re-runs this
+// file in every worker; the primary only starts and supervises them.
+
+import { spawn } from 'node:child_process';
+import cluster from 'node:cluster';
+import { existsSync, readFileSync } from 'node:fs';
+import { availableParallelism } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isMainThread } from 'node:worker_threads';
+import { createApp, middleware, MemoryCacheAdapter, RedisCacheAdapter } from '@morojs/moro';
+import ejs from 'ejs';
+import pg from 'pg';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const FORTUNES_VIEW = join(HERE, 'views', 'fortunes.ejs');
+const DATASET_PATH = process.env.DATASET_PATH || '/data/dataset.json';
+const STATIC_ROOT = '/data/static';
+
+// One process per listener, because Moro locks one configuration per
+// process. 'plain' serves :8080; 'tls' serves json-tls, static-tls and 8gbit
+// on :8081 from /certs; 'tlscheck' serves the opt-in TLS hardening section on
+// :9000 from /certs-tls, reloading the pair whenever the files change.
+const ROLE = process.env.MORO_ROLE || 'plain';
+const LISTENERS = {
+    plain: { port: 8080 },
+    tls: { port: 8081, certs: '/certs' },
+    tlscheck: { port: 9000, certs: '/certs-tls', watch: true },
+};
+const pairIn = dir => ({ keyFile: join(dir, 'server.key'), certFile: join(dir, 'server.crt') });
+const hasPair = dir => existsSync(pairIn(dir).keyFile) && existsSync(pairIn(dir).certFile);
+
+// The container is pinned to a cpuset, so the cgroup quota is read first and
+// availableParallelism(), which honours the affinity mask, is the fallback.
+// Moro's 'auto' counts the same way now; the number is computed here as well
+// because the Postgres pool below has to divide by it.
+function cpuCount() {
+    try {
+        const [quota, period] = readFileSync('/sys/fs/cgroup/cpu.max', 'utf8').trim().split(' ');
+        if (quota !== 'max') {
+            const n = Math.floor(Number(quota) / Number(period));
+            if (n >= 1) return n;
+        }
+    } catch {}
+    return availableParallelism();
+}
+const workers = cpuCount();
+
+// A worker thread on the native engine, a node:cluster process on the
+// fallback transport. The primary serves nothing, so it loads no dataset and
+// opens no database pool.
+const isWorker = !isMainThread || cluster.isWorker;
+const isPrimary = !isWorker;
+
+// The harness mounts /certs for the TLS profiles and /certs-tls for the
+// tls_check section only; a listener whose pair is absent is not started.
+if (ROLE === 'plain' && isPrimary) {
+    for (const role of ['tls', 'tlscheck']) {
+        if (!hasPair(LISTENERS[role].certs)) continue;
+        const child = spawn(process.execPath, [fileURLToPath(import.meta.url)], {
+            stdio: 'inherit',
+            env: { ...process.env, MORO_ROLE: role },
+        });
+        child.on('exit', (code, signal) => {
+            console.error(`morojs: ${role} process exited (${signal ?? code})`);
+        });
+        for (const signal of ['SIGTERM', 'SIGINT']) {
+            process.on(signal, () => child.kill(signal));
+        }
+    }
+}
+
+// Dataset for /json; a missing file serves an empty list instead of taking
+// the worker down.
+let dataset = [];
+if (isWorker) {
+    try {
+        dataset = JSON.parse(readFileSync(DATASET_PATH, 'utf8'));
+    } catch {}
+}
+
+// Postgres for /async-db, /fortunes and the production-stack api, all served
+// on :8080. The pool is sized from DATABASE_MAX_CONN across the workers, so
+// the cluster as a whole stays inside what Postgres allows.
+let pool = null;
+if (isWorker && ROLE === 'plain' && process.env.DATABASE_URL) {
+    const maxConn = parseInt(process.env.DATABASE_MAX_CONN, 10) || 256;
+    pool = new pg.Pool({
+        connectionString: process.env.DATABASE_URL,
+        max: Math.max(1, Math.floor(maxConn / workers)),
+    });
+    pool.on('error', () => {});
+}
+
+// The production-stack cache-aside goes through the framework's own cache
+// adapters: Redis when the stack provides one, shared across the cluster so
+// a write on any worker invalidates what every other one reads, and the
+// in-process memory adapter otherwise. TTLs are seconds.
+let cache = null;
+if (isWorker && ROLE === 'plain') {
+    cache = process.env.REDIS_URL
+        ? new RedisCacheAdapter({ url: process.env.REDIS_URL, keyPrefix: 'httparena:' })
+        : new MemoryCacheAdapter();
+}
+const ITEM_TTL = 1;
+const USER_TTL = 30;
+
+function sumQuery(query) {
+    let sum = 0;
+    for (const key in query) {
+        const n = parseInt(query[key], 10);
+        if (n === n) sum += n;
+    }
+    return sum;
+}
+
+const EMPTY = { items: [], count: 0 };
+const ITEM_COLUMNS = 'id, name, category, price, quantity, active, tags, rating_score, rating_count';
+const ASYNC_DB_SQL = `SELECT ${ITEM_COLUMNS} FROM items WHERE price BETWEEN $1 AND $2 LIMIT $3`;
+const itemShape = r => ({
+    id: r.id, name: r.name, category: r.category,
+    price: r.price, quantity: r.quantity, active: r.active,
+    tags: r.tags,
+    rating: { score: r.rating_score, count: r.rating_count },
+});
+const dbError = (res, message) => res.status(500).json({ error: message });
+const RUNTIME_FORTUNE = 'Additional fortune added at request time.';
+
+// The /json response: the first count items with total = price x quantity x m.
+function jsonItems(req) {
+    let count = parseInt(req.params.count, 10) || 0;
+    if (count < 0) count = 0;
+    if (count > dataset.length) count = dataset.length;
+    const m = parseInt(req.query.m, 10) || 1;
+    const items = new Array(count);
+    for (let i = 0; i < count; i++) {
+        const d = dataset[i];
+        items[i] = {
+            id: d.id, name: d.name, category: d.category,
+            price: d.price, quantity: d.quantity, active: d.active,
+            tags: d.tags, rating: d.rating,
+            total: d.price * d.quantity * m,
+        };
+    }
+    return { items, count };
+}
+
+function defineRoutes(app) {
+    // A literal body in place of a handler is the framework's documented
+    // static route: @morojs/engine answers it without entering JS, the same
+    // way Bun's static routes serve the bun entry's /pipeline. It goes out as
+    // res.send('ok') would, text/plain.
+    app.get('/pipeline').handler('ok');
+
+    // The framework hands the body over parsed: text/plain arrives as a
+    // string whether it came with a Content-Length or chunked, so POST adds
+    // it to the query sum.
+    const baseline11 = (req, res) => {
+        let total = sumQuery(req.query);
+        if (req.method === 'POST' && typeof req.body === 'string') {
+            const n = parseInt(req.body.trim(), 10);
+            if (n === n) total += n;
+        }
+        res.send(String(total));
+    };
+    app.get('/baseline11').handler(baseline11);
+    app.post('/baseline11').handler(baseline11);
+
+    // Behind the gateway proxies, which terminate TLS and h2 and forward this
+    // over loopback h1.
+    app.get('/baseline2').handler((req, res) => {
+        res.send(String(sumQuery(req.query)));
+    });
+
+    // An awaited timer suspends the request and frees the thread, so the
+    // waits in flight are bounded by memory. The delay is read from the path
+    // on every request.
+    app.get('/delay/:ms').handler(async (req, res) => {
+        const ms = Number.parseInt(req.params.ms, 10);
+        if (!Number.isInteger(ms) || ms < 0) {
+            res.status(404).send('Not found');
+            return;
+        }
+        if (ms > 0) await new Promise(resolve => setTimeout(resolve, ms));
+        res.send(String(ms));
+    });
+
+    // json-comp: the framework's compression middleware on this route alone,
+    // so no other endpoint pays for the encoder. It negotiates off
+    // Accept-Encoding per request and sends the body as is when none is sent,
+    // which is what json-tls on :8081 gets. gzip is preferred over brotli:
+    // at the middleware's default level it costs about half the CPU of
+    // brotli at the default quality for a body one tenth larger, and the
+    // profile prices bytes squared against rate. brotli stays available for
+    // a client that accepts nothing else.
+    app.get('/json/:count')
+        .before(middleware.compression({ encodings: ['gzip', 'br'] }))
+        .handler((req, res) => {
+            res.json(jsonItems(req));
+        });
+
+    // 8gbit: the body exactly as it arrived, Content-Length or chunked, sent
+    // back as the same bytes. req.rawBody is the framework's undecoded copy.
+    app.post('/echo').handler((req, res) => {
+        res.setHeader('Content-Type', 'application/octet-stream');
+        res.send(req.rawBody ?? Buffer.alloc(0));
+    });
+
+    app.get('/async-db').handler(async (req, res) => {
+        if (!pool) {
+            res.json(EMPTY);
+            return;
+        }
+        const min = parseInt(req.query.min, 10) || 10;
+        const max = parseInt(req.query.max, 10) || 50;
+        let limit = parseInt(req.query.limit, 10) || 50;
+        if (limit < 1) limit = 1;
+        if (limit > 50) limit = 50;
+        try {
+            const { rows } = await pool.query({ name: 'async-db', text: ASYNC_DB_SQL, values: [min, max, limit] });
+            res.json({ items: rows.map(itemShape), count: rows.length });
+        } catch {
+            res.json(EMPTY);
+        }
+    });
+
+    // fortunes: Moro has no view layer of its own, so the page goes through
+    // EJS directly, a real template engine rendering a separate template file
+    // per request, with <%= %> escaping the row that carries a <script> tag.
+    app.get('/fortunes').handler(async (req, res) => {
+        if (!pool) {
+            res.status(500).send('DB not available');
+            return;
+        }
+        try {
+            const { rows } = await pool.query({ name: 'fortunes', text: 'SELECT id, message FROM fortune' });
+            rows.push({ id: 0, message: RUNTIME_FORTUNE });
+            // Ordinal, not locale aware: the seed carries em-dashes and collation
+            // rules would order them in a way the profile does not ask for.
+            rows.sort((a, b) => (a.message < b.message ? -1 : a.message > b.message ? 1 : 0));
+            const html = await ejs.renderFile(FORTUNES_VIEW, { fortunes: rows }, { cache: true });
+            res.setHeader('Content-Type', 'text/html; charset=utf-8');
+            res.send(html);
+        } catch {
+            res.status(500).send('query failed');
+        }
+    });
+
+    // production-stack: the edge serves /static/* itself and sends /api/* past
+    // the shared JWT verifier first, so nothing here checks a token. What
+    // arrives is already authorised and carries X-User-Id.
+    app.get('/public/baseline').handler((req, res) => {
+        res.send(String(sumQuery(req.query)));
+    });
+    app.get('/public/json/:count').handler((req, res) => {
+        res.json(jsonItems(req));
+    });
+
+    // Cache-aside read: the cache first, Postgres on a miss, and the row goes
+    // into the cache for a second at most.
+    app.get('/api/items/:id').handler(async (req, res) => {
+        if (!pool) {
+            dbError(res, 'DB not available');
+            return;
+        }
+        const id = parseInt(req.params.id, 10);
+        if (!Number.isFinite(id)) {
+            res.sendStatus(404);
+            return;
+        }
+        try {
+            const cached = await cache.get('item:' + id);
+            if (cached) {
+                res.setHeader('X-Cache', 'HIT');
+                res.json(cached);
+                return;
+            }
+            const { rows } = await pool.query({
+                name: 'item-read',
+                text: `SELECT ${ITEM_COLUMNS} FROM items WHERE id = $1 LIMIT 1`,
+                values: [id],
+            });
+            if (rows.length === 0) {
+                res.sendStatus(404);
+                return;
+            }
+            const item = itemShape(rows[0]);
+            void cache.set('item:' + id, item, ITEM_TTL);
+            res.setHeader('X-Cache', 'MISS');
+            res.json(item);
+        } catch {
+            dbError(res, 'query failed');
+        }
+    });
+
+    // Write path: the JSON body arrives parsed by the framework. The cache
+    // entry goes after the row is written, so the next read misses and
+    // repopulates from Postgres. 204 and no body.
+    app.post('/api/items/:id').handler(async (req, res) => {
+        if (!pool) {
+            dbError(res, 'DB not available');
+            return;
+        }
+        const id = parseInt(req.params.id, 10);
+        if (!Number.isFinite(id)) {
+            res.sendStatus(404);
+            return;
+        }
+        const body = req.body && typeof req.body === 'object' ? req.body : {};
+        try {
+            const { rowCount } = await pool.query({
+                name: 'item-update',
+                text: 'UPDATE items SET name = $1, price = $2, quantity = $3 WHERE id = $4',
+                values: [body.name ?? 'Updated', body.price ?? 0, body.quantity ?? 0, id],
+            });
+            if (rowCount === 0) {
+                res.sendStatus(404);
+                return;
+            }
+            await cache.del('item:' + id);
+            res.status(204).end();
+        } catch {
+            dbError(res, 'update failed');
+        }
+    });
+
+    app.get('/api/me').handler(async (req, res) => {
+        if (!pool) {
+            dbError(res, 'DB not available');
+            return;
+        }
+        const id = parseInt(req.headers['x-user-id'], 10);
+        if (!Number.isFinite(id)) {
+            res.sendStatus(401);
+            return;
+        }
+        try {
+            const cached = await cache.get('user:' + id);
+            if (cached) {
+                res.setHeader('X-Cache', 'HIT');
+                res.json(cached);
+                return;
+            }
+            const { rows } = await pool.query({
+                name: 'user-read',
+                text: 'SELECT id, name, email, plan FROM users WHERE id = $1 LIMIT 1',
+                values: [id],
+            });
+            if (rows.length === 0) {
+                res.sendStatus(404);
+                return;
+            }
+            const u = rows[0];
+            const user = { id: u.id, name: u.name, email: u.email, plan: u.plan };
+            void cache.set('user:' + id, user, USER_TTL);
+            res.setHeader('X-Cache', 'MISS');
+            res.json(user);
+        } catch {
+            dbError(res, 'query failed');
+        }
+    });
+}
+
+// The listener this process owns. A TLS listener is the engine's own, ALPN
+// http/1.1; on :9000 the pair is watched and reloaded on the running listener
+// when the files change, connections in flight untouched.
+const listener = LISTENERS[ROLE];
+const server = { port: listener.port };
+if (listener.certs) {
+    server.ssl = { ...pairIn(listener.certs), ...(listener.watch ? { watch: true } : {}) };
+}
+
+const app = await createApp({
+    server: {
+        // Every interface: the harness reaches the container through published
+        // ports as well as host networking, and Moro's default host is localhost.
+        host: '0.0.0.0',
+        engine: 'moro',
+        requestTracking: { enabled: false },
+        requestLogging: { enabled: false },
+        ...server,
+    },
+    performance: { clustering: { enabled: true, workers } },
+    // The engine's own RFC 6455 WebSocket support, on the plain listener where
+    // the echo profiles run.
+    ...(ROLE === 'plain' ? { websocket: { enabled: true } } : {}),
+    logger: { level: process.env.LOG_LEVEL || 'warn' },
+});
+defineRoutes(app);
+
+if (ROLE === 'plain') {
+    // echo-ws: a raw namespace, so a text frame arrives as the string it
+    // carried and goes back the same way; binary frames likewise.
+    app.websocket(
+        '/ws',
+        {
+            message: (socket, text) => {
+                socket.send(text);
+            },
+            binary: (socket, bytes) => {
+                socket.send(bytes, true);
+            },
+        },
+        { raw: true }
+    );
+}
+
+if (ROLE === 'tls') {
+    // Static files through the framework's own handler, which stats and
+    // reads the file on every request and serves the .br or .gz sidecar on
+    // disk when the client accepts it. Behind a path check so the JSON route
+    // on this port does not pay for the file lookup.
+    const serveStatic = middleware.staticFiles({ root: STATIC_ROOT, prefix: '/static', precompressed: true });
+    await app.use((req, res, next) =>
+        req.path.startsWith('/static/') ? serveStatic(req, res, next) : next()
+    );
+}
+
+app.listen();
diff --git a/frameworks/morojs/compose.gateway-h3.yml b/frameworks/morojs/compose.gateway-h3.yml
new file mode 100644
index 000000000..7896b56ab
--- /dev/null
+++ b/frameworks/morojs/compose.gateway-h3.yml
@@ -0,0 +1,43 @@
+# gateway-h3 - the same two services as compose.gateway.yml, reached over QUIC
+# instead. Stock Caddy already binds 8443 on tcp and udp with `protocols h1 h2
+# h3`, so the proxy config is identical and only the load generator differs.
+# The proxy to server hop stays loopback h1 either way.
+services:
+  proxy:
+    build:
+      context: ./proxy
+    network_mode: host
+    cpuset: "${PROXY_CPUSET:-0-15,64-79}"
+    ulimits:
+      memlock: -1
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    security_opt:
+      - seccomp:unconfined
+    volumes:
+      - ${CERTS_DIR}:/certs:ro
+      - ${DATA_DIR}/static:/data/static:ro
+    depends_on:
+      - server
+
+  server:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    network_mode: host
+    cpuset: "${SERVER_CPUSET:-16-31,80-95}"
+    ulimits:
+      memlock: -1
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    security_opt:
+      - seccomp:unconfined
+    environment:
+      - DATABASE_URL=${DATABASE_URL}
+      - DATABASE_MAX_CONN=256
+      - DATASET_PATH=/data/dataset.json
+    volumes:
+      - ${DATA_DIR}/dataset.json:/data/dataset.json:ro
+      - ${DATA_DIR}/static:/data/static:ro
diff --git a/frameworks/morojs/compose.gateway.yml b/frameworks/morojs/compose.gateway.yml
new file mode 100644
index 000000000..696264f05
--- /dev/null
+++ b/frameworks/morojs/compose.gateway.yml
@@ -0,0 +1,47 @@
+# gateway-64 - stock nginx (TLS + h2 on 8443) in front of the morojs server,
+# forwarding the dynamic endpoints over loopback h1 with keepalive. The server
+# gets no certs here, so it comes up cleartext on 8080 only and starts no TLS
+# process. Caddy stays on the h3 profile only, where QUIC is required.
+#
+# The CPU split is the knob worth sweeping, via PROXY_CPUSET / SERVER_CPUSET.
+# Terminating TLS under multiplexed h2 is the heavier half even for nginx, so
+# the proxy gets 20 cores against 12, the same split the fulmine entry holds.
+services:
+  proxy:
+    build:
+      context: ./proxy-nginx
+    network_mode: host
+    cpuset: "${PROXY_CPUSET:-0-19,64-83}"
+    ulimits:
+      memlock: -1
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    security_opt:
+      - seccomp:unconfined
+    volumes:
+      - ${CERTS_DIR}:/certs:ro
+      - ${DATA_DIR}/static:/data/static:ro
+    depends_on:
+      - server
+
+  server:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    network_mode: host
+    cpuset: "${SERVER_CPUSET:-20-31,84-95}"
+    ulimits:
+      memlock: -1
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    security_opt:
+      - seccomp:unconfined
+    environment:
+      - DATABASE_URL=${DATABASE_URL}
+      - DATABASE_MAX_CONN=256
+      - DATASET_PATH=/data/dataset.json
+    volumes:
+      - ${DATA_DIR}/dataset.json:/data/dataset.json:ro
+      - ${DATA_DIR}/static:/data/static:ro
diff --git a/frameworks/morojs/compose.production-stack.yml b/frameworks/morojs/compose.production-stack.yml
new file mode 100644
index 000000000..e1ed5fd1a
--- /dev/null
+++ b/frameworks/morojs/compose.production-stack.yml
@@ -0,0 +1,109 @@
+# production-stack: edge + cache + authsvc + server, on a 64 logical CPU budget.
+#
+#   edge     (nginx)  - 32, terminates TLS and h2 and serves /static off disk
+#   cache    (redis)  -  2, single threaded on the data path, so more would sit idle
+#   authsvc  (rust)   -  8, one HMAC per /api request and nothing else
+#   server   (node)   - 22, the rest: JSON, Postgres, Redis client, one worker thread per core
+#
+# The edge gets the larger half because it is what saturates: terminating TLS under
+# multiplexed h2 is the expensive half here, and it is the knob to sweep first through
+# EDGE_CPUSET and SERVER_CPUSET. The split is the one the fulmine entry settled on.
+#
+# All four on host networking, so what goes between them is loopback rather than a bridge.
+# Redis binds 6379, authsvc 9090, server 8080, the edge 8443.
+services:
+  edge:
+    build: ./proxy-production
+    network_mode: host
+    cpuset: "${EDGE_CPUSET:-0-15,64-79}"
+    ulimits:
+      memlock: -1
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    security_opt:
+      - seccomp:unconfined
+    volumes:
+      - ${CERTS_DIR}:/certs:ro
+      - ${DATA_DIR}/static:/data/static:ro
+    # authsvc has to be answering, not merely started: the edge asks it about every /api request,
+    # so if it is not there the run measures 5xx from the edge and never reaches the server.
+    depends_on:
+      authsvc:
+        condition: service_healthy
+      server:
+        condition: service_started
+
+  cache:
+    image: redis:7-alpine
+    network_mode: host
+    cpuset: "${CACHE_CPUSET:-16,80}"
+    ulimits:
+      memlock: -1
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    security_opt:
+      - seccomp:unconfined
+    volumes:
+      - ${DATA_DIR}/redis-seed.txt:/seed.txt:ro
+      - ${DATA_DIR}/redis-entrypoint.sh:/entrypoint.sh:ro
+    entrypoint: ["sh", "/entrypoint.sh"]
+    # A cache that cannot bind is a silent downgrade, not a failure: with the
+    # short `depends_on: - cache` form the server starts anyway and quietly
+    # talks to whatever else holds 6379. Fail the stack instead.
+    healthcheck:
+      test: ["CMD", "redis-cli", "-p", "6379", "ping"]
+      interval: 30s
+      timeout: 2s
+      retries: 3
+      start_period: 30s
+      start_interval: 1s
+
+  authsvc:
+    build: ../_shared/authsvc
+    network_mode: host
+    cpuset: "${AUTH_CPUSET:-17-20,81-84}"
+    ulimits:
+      memlock: -1
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    security_opt:
+      - seccomp:unconfined
+    environment:
+      - JWT_SECRET=httparena-bench-secret-do-not-use-in-production
+      - AUTHSVC_LISTEN=0.0.0.0:9090
+    # /_health is the sidecar's own endpoint and wget is busybox's, so this needs nothing the
+    # image does not already carry.
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://127.0.0.1:9090/_health"]
+      interval: 30s
+      timeout: 2s
+      retries: 3
+      start_period: 30s
+      start_interval: 1s
+
+  server:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    network_mode: host
+    cpuset: "${SERVER_CPUSET:-21-31,85-95}"
+    ulimits:
+      memlock: -1
+      nofile:
+        soft: 1048576
+        hard: 1048576
+    security_opt:
+      - seccomp:unconfined
+    environment:
+      - DATABASE_URL=${DATABASE_URL}
+      - DATABASE_MAX_CONN=256
+      - REDIS_URL=redis://127.0.0.1:6379
+      - DATASET_PATH=/data/dataset.json
+    volumes:
+      - ${DATA_DIR}/dataset.json:/data/dataset.json:ro
+    depends_on:
+      cache:
+        condition: service_healthy
diff --git a/frameworks/morojs/meta.json b/frameworks/morojs/meta.json
new file mode 100644
index 000000000..0c628fc81
--- /dev/null
+++ b/frameworks/morojs/meta.json
@@ -0,0 +1,41 @@
+{
+  "display_name": "morojs",
+  "language": "JS",
+  "type": "emerging",
+  "mode": "standard",
+  "completeness": {
+    "routing": true,
+    "middleware": true,
+    "request": true,
+    "response": true
+  },
+  "engine": "@morojs/engine",
+  "description": "MoroJS 1.8 on its native HTTP engine (@morojs/engine), default configuration, clustered by the framework itself with one worker thread per core sharing the port through SO_REUSEPORT. Routing, path and query parameters and body parsing through the Moro request, JSON through res.json, compression, static files and the cache-aside through the built-in middleware and cache adapters, WebSockets through the engine's own RFC 6455 support.",
+  "repo": "https://github.com/Moro-JS/moro",
+  "enabled": true,
+  "tls_check": true,
+  "tests": [
+    "baseline",
+    "latency-1m",
+    "latency-10k",
+    "latency-500k-8cpu",
+    "pipelined",
+    "limited-conn",
+    "async",
+    "json-comp",
+    "8gbit",
+    "async-db",
+    "static-tls",
+    "echo-ws",
+    "echo-ws-pipeline",
+    "echo-ws-limited",
+    "json-tls",
+    "gateway-64",
+    "gateway-h3",
+    "production-stack",
+    "fortunes"
+  ],
+  "maintainers": [
+    "M-Chris"
+  ]
+}
diff --git a/frameworks/morojs/package.json b/frameworks/morojs/package.json
new file mode 100644
index 000000000..089243fb5
--- /dev/null
+++ b/frameworks/morojs/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "httparena-morojs",
+  "private": true,
+  "dependencies": {
+    "@morojs/moro": "^1.8.13",
+    "ejs": "^3.1.10",
+    "pg": "^8.16.3",
+    "redis": "^5.0.0"
+  }
+}
diff --git a/frameworks/morojs/proxy-nginx/Dockerfile b/frameworks/morojs/proxy-nginx/Dockerfile
new file mode 100644
index 000000000..7e9ddf240
--- /dev/null
+++ b/frameworks/morojs/proxy-nginx/Dockerfile
@@ -0,0 +1,8 @@
+# Stock nginx. It covers gateway-64 only; gateway-h3 uses the Caddy image in ../proxy.
+FROM nginx:1.27-alpine
+
+COPY nginx.conf /etc/nginx/nginx.conf
+
+EXPOSE 8443/tcp
+
+CMD ["nginx", "-g", "daemon off;"]
diff --git a/frameworks/morojs/proxy-nginx/nginx.conf b/frameworks/morojs/proxy-nginx/nginx.conf
new file mode 100644
index 000000000..afaf2ce94
--- /dev/null
+++ b/frameworks/morojs/proxy-nginx/nginx.conf
@@ -0,0 +1,65 @@
+# morojs gateway edge, nginx.
+#
+# nginx terminates TLS and h2 on 8443, serves /static/* from disk and forwards the rest to the
+# morojs server over loopback h1 through a keepalive pool. gateway-h3 keeps the Caddy edge in
+# ./proxy, since the stock nginx image does not speak QUIC.
+
+worker_processes auto;
+worker_rlimit_nofile 1048576;
+
+events {
+    worker_connections 65535;
+    multi_accept on;
+}
+
+http {
+    include /etc/nginx/mime.types;
+    default_type application/octet-stream;
+
+    sendfile on;
+    tcp_nopush on;
+    tcp_nodelay on;
+
+    # precompressed .gz sidecars straight from disk, nothing is compressed per request
+    gzip_static on;
+    gzip_vary on;
+
+    keepalive_timeout 65;
+    # the generator holds its connections for the whole run, so never close one on a request count
+    keepalive_requests 1000000;
+
+    access_log off;
+    error_log /dev/stderr warn;
+
+    upstream backend {
+        server 127.0.0.1:8080;
+        keepalive 2048;
+        keepalive_requests 1000000;
+        keepalive_timeout 300s;
+    }
+
+    server {
+        listen 8443 ssl;
+        http2 on;
+
+        ssl_certificate /certs/server.crt;
+        ssl_certificate_key /certs/server.key;
+        ssl_protocols TLSv1.2 TLSv1.3;
+        ssl_prefer_server_ciphers off;
+
+        # the profile asks the proxy to serve these from disk rather than forward them
+        location /static/ {
+            alias /data/static/;
+            expires off;
+            add_header Cache-Control "no-cache";
+        }
+
+        # everything else is the morojs server
+        location / {
+            proxy_pass http://backend;
+            proxy_http_version 1.1;
+            proxy_set_header Connection "";
+            proxy_set_header Host $host;
+        }
+    }
+}
diff --git a/frameworks/morojs/proxy-production/Dockerfile b/frameworks/morojs/proxy-production/Dockerfile
new file mode 100644
index 000000000..4ca5765e2
--- /dev/null
+++ b/frameworks/morojs/proxy-production/Dockerfile
@@ -0,0 +1,8 @@
+# Stock nginx with the production-stack routing.
+FROM nginx:1.27-alpine
+
+COPY nginx.conf /etc/nginx/nginx.conf
+
+EXPOSE 8443/tcp
+
+CMD ["nginx", "-g", "daemon off;"]
diff --git a/frameworks/morojs/proxy-production/nginx.conf b/frameworks/morojs/proxy-production/nginx.conf
new file mode 100644
index 000000000..8a3ef227b
--- /dev/null
+++ b/frameworks/morojs/proxy-production/nginx.conf
@@ -0,0 +1,102 @@
+# morojs production-stack edge, nginx.
+#
+# nginx terminates TLS and h2 on 8443 and splits the three paths the profile defines:
+# /static/* off disk here, /public/* straight to the server, /api/* past the shared JWT
+# verifier first. The server itself never sees a token, only the X-User-Id that survives.
+
+worker_processes auto;
+worker_rlimit_nofile 1048576;
+
+events {
+    worker_connections 65535;
+    multi_accept on;
+}
+
+http {
+    include /etc/nginx/mime.types;
+    default_type application/octet-stream;
+
+    sendfile on;
+    tcp_nopush on;
+    tcp_nodelay on;
+
+    gzip_static on;
+    gzip_vary on;
+
+    keepalive_timeout 65;
+    # the generator holds its connections for the whole run, so never close one on a request count
+    keepalive_requests 1000000;
+
+    access_log off;
+    error_log /dev/stderr warn;
+
+    upstream backend {
+        server 127.0.0.1:8080;
+        keepalive 2048;
+        keepalive_requests 1000000;
+        keepalive_timeout 300s;
+    }
+
+    upstream authsvc {
+        server 127.0.0.1:9090;
+        keepalive 256;
+        keepalive_requests 1000000;
+        keepalive_timeout 300s;
+    }
+
+    server {
+        listen 8443 ssl;
+        http2 on;
+
+        ssl_certificate /certs/server.crt;
+        ssl_certificate_key /certs/server.key;
+        ssl_protocols TLSv1.2 TLSv1.3;
+        ssl_prefer_server_ciphers off;
+
+        auth_request_set $auth_user_id $upstream_http_x_user_id;
+
+        # authsvc answers 200 with X-User-Id or 401. The Authorization header goes with the
+        # subrequest, the body does not: the verifier only reads the token.
+        location = /_auth {
+            internal;
+            proxy_pass http://authsvc/_auth;
+            proxy_http_version 1.1;
+            proxy_set_header Connection "";
+            proxy_set_header Host $host;
+            proxy_set_header Authorization $http_authorization;
+            proxy_pass_request_body off;
+            proxy_set_header Content-Length "";
+        }
+
+        location /static/ {
+            alias /data/static/;
+            expires off;
+            add_header Cache-Control "no-cache";
+        }
+
+        location /public/ {
+            proxy_pass http://backend;
+            proxy_http_version 1.1;
+            proxy_set_header Connection "";
+            proxy_set_header Host $host;
+        }
+
+        # an unauthenticated /api/* never reaches the server at all: the 401 from authsvc is
+        # passed straight back
+        location /api/ {
+            auth_request /_auth;
+            error_page 401 = @auth_failed;
+
+            proxy_pass http://backend;
+            proxy_http_version 1.1;
+            proxy_set_header Connection "";
+            proxy_set_header Host $host;
+            proxy_set_header X-User-Id $auth_user_id;
+        }
+
+        location @auth_failed {
+            add_header Content-Type "application/json" always;
+            return 401 '{"error":"unauthorized"}';
+        }
+    }
+}
diff --git a/frameworks/morojs/proxy/Caddyfile b/frameworks/morojs/proxy/Caddyfile
new file mode 100644
index 000000000..2c1bd55b4
--- /dev/null
+++ b/frameworks/morojs/proxy/Caddyfile
@@ -0,0 +1,43 @@
+# morojs gateway-h3 edge.
+#
+# Stock Caddy terminates TLS and h3 on 8443, serves /static/* from disk,
+# and forwards the dynamic endpoints to the morojs server. Both services run
+# with network_mode: host, so the server is reachable on loopback.
+#
+# Only compose.gateway-h3.yml uses this; gateway-64 uses the nginx edge in
+# ../proxy-nginx, which does not speak QUIC in the stock image.
+{
+	admin off
+	auto_https off
+	servers {
+		protocols h1 h2 h3
+	}
+}
+
+https://localhost:8443 {
+	tls /certs/server.crt /certs/server.key
+
+	# the profile asks the proxy to serve these from disk rather than forward
+	# them. precompressed prefers the .br / .gz sidecars per Accept-Encoding.
+	# (root /data + request /static/foo -> /data/static/foo.)
+	handle /static/* {
+		root * /data
+		file_server {
+			precompressed br gzip
+		}
+	}
+
+	# everything else is the morojs server. Plain h1 with a large keepalive
+	# pool, so the streams arriving multiplexed over one h2 connection fan out
+	# across the backend workers instead of queueing behind one upstream.
+	handle {
+		reverse_proxy 127.0.0.1:8080 {
+			transport http {
+				versions 1.1
+				keepalive 5m
+				keepalive_idle_conns 2048
+				keepalive_idle_conns_per_host 2048
+			}
+		}
+	}
+}
diff --git a/frameworks/morojs/proxy/Dockerfile b/frameworks/morojs/proxy/Dockerfile
new file mode 100644
index 000000000..62d344cf6
--- /dev/null
+++ b/frameworks/morojs/proxy/Dockerfile
@@ -0,0 +1,10 @@
+# Stock Caddy, which ships h3 in the base image, so no custom build. It covers
+# gateway-h3 (QUIC over UDP) only; gateway-64 uses the nginx edge in
+# ../proxy-nginx.
+FROM caddy:2-alpine
+
+COPY Caddyfile /etc/caddy/Caddyfile
+
+EXPOSE 8443/tcp 8443/udp
+
+CMD ["caddy", "run", "--config", "/etc/caddy/Caddyfile", "--adapter", "caddyfile"]
diff --git a/frameworks/morojs/views/fortunes.ejs b/frameworks/morojs/views/fortunes.ejs
new file mode 100644
index 000000000..1675a16af
--- /dev/null
+++ b/frameworks/morojs/views/fortunes.ejs
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head><title>Fortunes</title></head>
+<body>
+<table>
+<tr><th>id</th><th>message</th></tr>
+<% for (const fortune of fortunes) { %><tr><td><%= fortune.id %></td><td><%= fortune.message %></td></tr>
+<% } %></table>
+</body>
+</html>
diff --git a/site/data/frameworks.json b/site/data/frameworks.json
index b82911391..c5a76e1de 100644
--- a/site/data/frameworks.json
+++ b/site/data/frameworks.json
@@ -1233,6 +1233,20 @@
     "type": "engine",
     "engine": "mongoose"
   },
+  "morojs": {
+    "dir": "morojs",
+    "description": "MoroJS 1.8 on its native HTTP engine (@morojs/engine), default configuration, clustered by the framework itself with one worker thread per core sharing the port through SO_REUSEPORT. Routing, path and query parameters and body parsing through the Moro request, JSON through res.json, compression, static files and the cache-aside through the built-in middleware and cache adapters, WebSockets through the engine's own RFC 6455 support.",
+    "repo": "https://github.com/Moro-JS/moro",
+    "type": "emerging",
+    "engine": "@morojs/engine",
+    "mode": "standard",
+    "completeness": {
+      "routing": true,
+      "middleware": true,
+      "request": true,
+      "response": true
+    }
+  },
   "mq-bridge-py": {
     "dir": "mq-bridge-py",
     "description": "mq-bridge Python bindings (mq_bridge_py). A single http->response route dispatches on request metadata while HTTP framing stays in Rust; cleartext HTTP/1.1 + h2c run on 8080/8082, optional TLS listeners serve HTTP/2 on 8443 and HTTP/1.1 on 8081, and the inline-response fast path keeps responses off the GIL so the Python handler runs only the per-request dispatch. Postgres via psycopg for async-db, crud (Redis cache-aside) and fortunes, which renders per request with the Jinja2 template engine; static assets are read from /data/static per request, serving the on-disk .gz variant when the client accepts it; /delay waits with a blocking sleep, so async concurrency is the worker-process count.",
diff --git a/site/data/results/morojs.json b/site/data/results/morojs.json
new file mode 100644
index 000000000..83344a3de
--- /dev/null
+++ b/site/data/results/morojs.json
@@ -0,0 +1,594 @@
+{
+  "framework": "morojs",
+  "results": {
+    "8gbit-512": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 49336,
+      "avg_latency": "119.4us",
+      "p99_latency": "174.0us",
+      "cpu": "321.7%",
+      "memory": "4.1GiB",
+      "connections": 512,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "511.08MB/s",
+      "input_bw": "481.80MB/s",
+      "reconnects": 0,
+      "status_2xx": 246751,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "cpu_usec": 18114219,
+      "cpu_per_req_us": 73.4109,
+      "target_rate": 50000,
+      "rate_ratio": 0.9867,
+      "p99_9_latency": "5678.0us"
+    },
+    "async-32000": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 1987758,
+      "avg_latency": "16.01ms",
+      "p99_latency": "24.90ms",
+      "cpu": "6270.4%",
+      "memory": "4.7GiB",
+      "connections": 32000,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "223.65MB/s",
+      "input_bw": "90.99MB/s",
+      "reconnects": 0,
+      "status_2xx": 19877580,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "async-db-1024": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 193185,
+      "avg_latency": "4.86ms",
+      "p99_latency": "29.40ms",
+      "cpu": "5960.4%",
+      "memory": "4.9GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "737.15MB/s",
+      "input_bw": "12.90MB/s",
+      "reconnects": 76827,
+      "status_2xx": 1931850,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "baseline-4096": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 2204116,
+      "avg_latency": "1.86ms",
+      "p99_latency": "3.62ms",
+      "cpu": "6730.2%",
+      "memory": "4.0GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "247.97MB/s",
+      "input_bw": "170.26MB/s",
+      "reconnects": 0,
+      "status_2xx": 11020580,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "echo-ws-16384": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 3134466,
+      "avg_latency": "5.16ms",
+      "p99_latency": "9.80ms",
+      "cpu": "6161.9%",
+      "memory": "4.1GiB",
+      "connections": 16384,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "21.32MB/s",
+      "reconnects": 0,
+      "status_2xx": 15672331,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "echo-ws-4096": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 3446745,
+      "avg_latency": "1.19ms",
+      "p99_latency": "2.44ms",
+      "cpu": "6279.3%",
+      "memory": "3.9GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "23.02MB/s",
+      "reconnects": 0,
+      "status_2xx": 17233727,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "echo-ws-512": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 3382028,
+      "avg_latency": "150us",
+      "p99_latency": "374us",
+      "cpu": "6577.8%",
+      "memory": "3.8GiB",
+      "connections": 512,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "22.58MB/s",
+      "reconnects": 0,
+      "status_2xx": 16910141,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "echo-ws-limited-4096": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 2007288,
+      "avg_latency": "1.54ms",
+      "p99_latency": "5.65ms",
+      "cpu": "6176.0%",
+      "memory": "5.1GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "38.08MB/s",
+      "reconnects": 1003518,
+      "status_2xx": 10036442,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "echo-ws-limited-512": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 1684460,
+      "avg_latency": "207us",
+      "p99_latency": "777us",
+      "cpu": "5886.9%",
+      "memory": "4.3GiB",
+      "connections": 512,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "31.96MB/s",
+      "reconnects": 842241,
+      "status_2xx": 8422302,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "echo-ws-pipeline-16384": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 4315535,
+      "avg_latency": "59.38ms",
+      "p99_latency": "68.70ms",
+      "cpu": "6280.0%",
+      "memory": "4.2GiB",
+      "connections": 16384,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 16,
+      "bandwidth": "29.20MB/s",
+      "reconnects": 0,
+      "status_2xx": 21577677,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "echo-ws-pipeline-4096": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 4434002,
+      "avg_latency": "14.74ms",
+      "p99_latency": "18.40ms",
+      "cpu": "6350.8%",
+      "memory": "4.0GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 16,
+      "bandwidth": "29.63MB/s",
+      "reconnects": 0,
+      "status_2xx": 22170014,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "echo-ws-pipeline-512": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 4301358,
+      "avg_latency": "1.90ms",
+      "p99_latency": "3.54ms",
+      "cpu": "6489.2%",
+      "memory": "3.9GiB",
+      "connections": 512,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 16,
+      "bandwidth": "28.71MB/s",
+      "reconnects": 0,
+      "status_2xx": 21506790,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "fortunes-1024": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 61667,
+      "avg_latency": "15.42ms",
+      "p99_latency": "29.90ms",
+      "cpu": "6540.2%",
+      "memory": "6.1GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "1.43GB/s",
+      "reconnects": 0,
+      "status_2xx": 308338,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "gateway-64-1024": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 132017,
+      "avg_latency": "204.29ms",
+      "p99_latency": "3.73s",
+      "cpu": "3937.4%",
+      "memory": "6.2GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "1.66GB/s",
+      "reconnects": 0,
+      "status_2xx": 669331,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "tpl_static": 200799,
+      "tpl_baseline": 133866,
+      "tpl_json": 234265,
+      "tpl_async_db": 100399,
+      "cpu_breakdown": "server: 2254% 4.5GiB | proxy: 1684% 1.7GiB"
+    },
+    "gateway-64-512": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 131486,
+      "avg_latency": "113.98ms",
+      "p99_latency": "1.14s",
+      "cpu": "3672.1%",
+      "memory": "4.6GiB",
+      "connections": 512,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "1.62GB/s",
+      "reconnects": 0,
+      "status_2xx": 662691,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "tpl_static": 198807,
+      "tpl_baseline": 132538,
+      "tpl_json": 231941,
+      "tpl_async_db": 99403,
+      "cpu_breakdown": "server: 2224% 3.1GiB | proxy: 1449% 1.5GiB"
+    },
+    "gateway-h3-256": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 58910,
+      "avg_latency": "132.87ms",
+      "p99_latency": "807.76ms",
+      "cpu": "3229.8%",
+      "memory": "2.5GiB",
+      "connections": 256,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "623.43MB/s",
+      "reconnects": 0,
+      "status_2xx": 296319,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "tpl_static": 88895,
+      "tpl_baseline": 59263,
+      "tpl_json": 103711,
+      "tpl_async_db": 44447,
+      "cpu_breakdown": "proxy: 2178% 1.2GiB | server: 1052% 1.3GiB"
+    },
+    "gateway-h3-64": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 81332,
+      "avg_latency": "25.05ms",
+      "p99_latency": "87.65ms",
+      "cpu": "4101.2%",
+      "memory": "1.6GiB",
+      "connections": 64,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "882.04MB/s",
+      "reconnects": 0,
+      "status_2xx": 407477,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "tpl_static": 122243,
+      "tpl_baseline": 81495,
+      "tpl_json": 142616,
+      "tpl_async_db": 61121,
+      "cpu_breakdown": "proxy: 2687% 312MiB | server: 1414% 1.3GiB"
+    },
+    "json-comp-16384": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 129852,
+      "avg_latency": "123.86ms",
+      "p99_latency": "234.20ms",
+      "cpu": "6021.4%",
+      "memory": "11.7GiB",
+      "connections": 16384,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "177.54MB/s",
+      "input_bw": "9.66MB/s",
+      "reconnects": 16756,
+      "status_2xx": 649264,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "json-comp-4096": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 147090,
+      "avg_latency": "27.89ms",
+      "p99_latency": "69.30ms",
+      "cpu": "6208.7%",
+      "memory": "8.9GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "200.69MB/s",
+      "input_bw": "10.94MB/s",
+      "reconnects": 27564,
+      "status_2xx": 735453,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "json-tls-4096": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 844930,
+      "avg_latency": "4.85ms",
+      "p99_latency": "74.43ms",
+      "cpu": "6620.7%",
+      "memory": "4.2GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "2.86GB",
+      "reconnects": 0,
+      "status_2xx": 4308783,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "latency-10k-1024": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 9981,
+      "avg_latency": "77.2us",
+      "p99_latency": "117.0us",
+      "cpu": "32.4%",
+      "memory": "3.6GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "20s",
+      "pipeline": 1,
+      "bandwidth": "1.17MB/s",
+      "reconnects": 0,
+      "status_2xx": 199678,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "cpu_usec": 6796958,
+      "cpu_per_req_us": 34.0396,
+      "target_rate": 10000,
+      "rate_ratio": 0.9981,
+      "p99_9_latency": "185.0us"
+    },
+    "latency-1m-1024": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 997623,
+      "avg_latency": "121.5us",
+      "p99_latency": "214.0us",
+      "cpu": "3155.9%",
+      "memory": "3.9GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "20s",
+      "pipeline": 1,
+      "bandwidth": "116.72MB/s",
+      "reconnects": 0,
+      "status_2xx": 19956022,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "cpu_usec": 573348441,
+      "cpu_per_req_us": 28.7306,
+      "target_rate": 1000000,
+      "rate_ratio": 0.9976,
+      "p99_9_latency": "5270.0us"
+    },
+    "latency-500k-8cpu-1024": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 396396,
+      "avg_latency": "2030071.8us",
+      "p99_latency": "5015552.0us",
+      "cpu": "794.2%",
+      "memory": "494MiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "20s",
+      "pipeline": 1,
+      "bandwidth": "46.38MB/s",
+      "reconnects": 0,
+      "status_2xx": 7930671,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "cpu_usec": 159607857,
+      "cpu_per_req_us": 20.1254,
+      "target_rate": 500000,
+      "rate_ratio": 0.7928,
+      "p99_9_latency": "5203968.0us"
+    },
+    "limited-conn-4096": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 1885683,
+      "avg_latency": "2.15ms",
+      "p99_latency": "8.52ms",
+      "cpu": "6534.4%",
+      "memory": "4.0GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "212.15MB/s",
+      "input_bw": "145.66MB/s",
+      "reconnects": 941345,
+      "status_2xx": 9428418,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "pipelined-4096": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 37648418,
+      "avg_latency": "1.74ms",
+      "p99_latency": "3.31ms",
+      "cpu": "6404.5%",
+      "memory": "3.9GiB",
+      "connections": 4096,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 16,
+      "bandwidth": "4.14GB/s",
+      "reconnects": 0,
+      "status_2xx": 188242092,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    },
+    "production-stack-1024": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 106517,
+      "avg_latency": "131.70ms",
+      "p99_latency": "4.45s",
+      "cpu": "2697.0%",
+      "memory": "3.1GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "1.19GB/s",
+      "reconnects": 0,
+      "status_2xx": 540045,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "tpl_static": 162013,
+      "tpl_baseline": 54004,
+      "tpl_items": 270022,
+      "tpl_me": 54004,
+      "cpu_breakdown": "server: 468% 1.2GiB | authsvc: 724% 492MiB | edge: 1289% 1.4GiB | cache: 217% 10MiB"
+    },
+    "production-stack-256": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 120812,
+      "avg_latency": "34.63ms",
+      "p99_latency": "148.25ms",
+      "cpu": "2968.9%",
+      "memory": "2.4GiB",
+      "connections": 256,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "1.32GB/s",
+      "reconnects": 0,
+      "status_2xx": 608893,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0,
+      "tpl_static": 182667,
+      "tpl_baseline": 60889,
+      "tpl_items": 304446,
+      "tpl_me": 60889,
+      "cpu_breakdown": "server: 627% 1.2GiB | authsvc: 757% 153MiB | edge: 1371% 1.1GiB | cache: 214% 19MiB"
+    },
+    "static-tls-1024": {
+      "framework": "morojs",
+      "language": "JS",
+      "rps": 70911,
+      "avg_latency": "14.41ms",
+      "p99_latency": "38.15ms",
+      "cpu": "5950.4%",
+      "memory": "4.4GiB",
+      "connections": 1024,
+      "threads": 64,
+      "duration": "5s",
+      "pipeline": 1,
+      "bandwidth": "1.09GB",
+      "reconnects": 0,
+      "status_2xx": 360843,
+      "status_3xx": 0,
+      "status_4xx": 0,
+      "status_5xx": 0
+    }
+  }
+}
diff --git a/site/data/tls/morojs.json b/site/data/tls/morojs.json
new file mode 100644
index 000000000..01c943cac
--- /dev/null
+++ b/site/data/tls/morojs.json
@@ -0,0 +1,5 @@
+{
+  "framework": "morojs",
+  "tls": "pass",
+  "check": "none"
+}
diff --git a/site/static/logs/8gbit/512/morojs.log b/site/static/logs/8gbit/512/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/async-db/1024/morojs.log b/site/static/logs/async-db/1024/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/async/32000/morojs.log b/site/static/logs/async/32000/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/baseline/4096/morojs.log b/site/static/logs/baseline/4096/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/echo-ws-limited/4096/morojs.log b/site/static/logs/echo-ws-limited/4096/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/echo-ws-limited/512/morojs.log b/site/static/logs/echo-ws-limited/512/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/echo-ws-pipeline/16384/morojs.log b/site/static/logs/echo-ws-pipeline/16384/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/echo-ws-pipeline/4096/morojs.log b/site/static/logs/echo-ws-pipeline/4096/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/echo-ws-pipeline/512/morojs.log b/site/static/logs/echo-ws-pipeline/512/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/echo-ws/16384/morojs.log b/site/static/logs/echo-ws/16384/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/echo-ws/4096/morojs.log b/site/static/logs/echo-ws/4096/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/echo-ws/512/morojs.log b/site/static/logs/echo-ws/512/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/fortunes/1024/morojs.log b/site/static/logs/fortunes/1024/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/gateway-64/1024/morojs.log b/site/static/logs/gateway-64/1024/morojs.log
new file mode 100644
index 000000000..194aefda8
--- /dev/null
+++ b/site/static/logs/gateway-64/1024/morojs.log
@@ -0,0 +1 @@
+Error response from daemon: No such container: httparena-bench-morojs
diff --git a/site/static/logs/gateway-64/512/morojs.log b/site/static/logs/gateway-64/512/morojs.log
new file mode 100644
index 000000000..194aefda8
--- /dev/null
+++ b/site/static/logs/gateway-64/512/morojs.log
@@ -0,0 +1 @@
+Error response from daemon: No such container: httparena-bench-morojs
diff --git a/site/static/logs/gateway-h3/256/morojs.log b/site/static/logs/gateway-h3/256/morojs.log
new file mode 100644
index 000000000..194aefda8
--- /dev/null
+++ b/site/static/logs/gateway-h3/256/morojs.log
@@ -0,0 +1 @@
+Error response from daemon: No such container: httparena-bench-morojs
diff --git a/site/static/logs/gateway-h3/64/morojs.log b/site/static/logs/gateway-h3/64/morojs.log
new file mode 100644
index 000000000..194aefda8
--- /dev/null
+++ b/site/static/logs/gateway-h3/64/morojs.log
@@ -0,0 +1 @@
+Error response from daemon: No such container: httparena-bench-morojs
diff --git a/site/static/logs/json-comp/16384/morojs.log b/site/static/logs/json-comp/16384/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/json-comp/4096/morojs.log b/site/static/logs/json-comp/4096/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/json-tls/4096/morojs.log b/site/static/logs/json-tls/4096/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/latency-10k/1024/morojs.log b/site/static/logs/latency-10k/1024/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/latency-1m/1024/morojs.log b/site/static/logs/latency-1m/1024/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/latency-500k-8cpu/1024/morojs.log b/site/static/logs/latency-500k-8cpu/1024/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/limited-conn/4096/morojs.log b/site/static/logs/limited-conn/4096/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/pipelined/4096/morojs.log b/site/static/logs/pipelined/4096/morojs.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/site/static/logs/production-stack/1024/morojs.log b/site/static/logs/production-stack/1024/morojs.log
new file mode 100644
index 000000000..194aefda8
--- /dev/null
+++ b/site/static/logs/production-stack/1024/morojs.log
@@ -0,0 +1 @@
+Error response from daemon: No such container: httparena-bench-morojs
diff --git a/site/static/logs/production-stack/256/morojs.log b/site/static/logs/production-stack/256/morojs.log
new file mode 100644
index 000000000..194aefda8
--- /dev/null
+++ b/site/static/logs/production-stack/256/morojs.log
@@ -0,0 +1 @@
+Error response from daemon: No such container: httparena-bench-morojs
diff --git a/site/static/logs/static-tls/1024/morojs.log b/site/static/logs/static-tls/1024/morojs.log
new file mode 100644
index 000000000..e69de29bb