@moonsjs/vite 0.3.0 → 0.5.0

package/dist/server/server-select.d.ts

@@ -0,0 +1,9 @@
+import { startBunServer } from "./bun-server";
+import { startNodeServer, type NodeServerOptions } from "./node-server";
+/**
+ * Addendum Q (3B): pemilih transport produksi.
+ * Default: Bun.serve saat berjalan di Bun, node:http di Node.
+ * Override eksplisit: `MOONS_SERVER=bun|node`.
+ */
+export declare function startServer(handler: (request: Request) => Promise<Response>, options?: NodeServerOptions): ReturnType<typeof startNodeServer> | ReturnType<typeof startBunServer>;
+//# sourceMappingURL=server-select.d.ts.map

package/dist/server/server-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-select.d.ts","sourceRoot":"","sources":["../../src/server/server-select.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAExE;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAChD,OAAO,GAAE,iBAAsB,GAC9B,UAAU,CAAC,OAAO,eAAe,CAAC,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAexE"}

package/dist/server/transport.d.ts

@@ -0,0 +1,98 @@
+import { type PrerenderStorage } from "@moonsjs/core";
+import type { Logger } from "./logger";
+/**
+ * Addendum Q (3B): bagian transport yang tidak bergantung runtime — dipakai
+ * `node-server` dan `bun-server` agar paritas bukan duplikasi.
+ */
+/** Batas transport default (Addendum J.2); RPC punya batas lebih kecil dari config. */
+export declare const MAX_TRANSPORT_BODY_BYTES: number;
+/** Request tidak valid (Host/URL malformed) → dipetakan ke 400 oleh server. */
+export declare class InvalidRequestError extends Error {
+    constructor(message: string);
+}
+/** Body melebihi batas → dipetakan ke 413; pembacaan dihentikan saat melewati. */
+export declare class BodyLimitError extends Error {
+    readonly limit: number;
+    constructor(limit: number);
+}
+export interface ToWebRequestOptions {
+    /** Addendum J.1: percayai `x-forwarded-proto`/`x-forwarded-host` (default false). */
+    trustProxy?: boolean;
+    /** Batas pembacaan body (byte). Default: `MAX_TRANSPORT_BODY_BYTES`. */
+    maxBodyBytes?: number;
+}
+/** Addendum J.7: default aman runtime; `config.headers` tetap menang (cek `has`). */
+export declare const DEFAULT_SECURITY_HEADERS: Record<string, string>;
+export declare function firstHeaderValue(value: string | string[] | undefined): string | null;
+export declare function forwardedProtocol(value: string | string[] | undefined): "http" | "https" | null;
+export declare function forwardedHost(value: string | string[] | undefined): string | null;
+/**
+ * IP klien tepercaya (Addendum J.1) dari nilai header mentah — inti yang sama
+ * untuk Node (`IncomingMessage`) dan Bun (`Request` + `server.requestIP`).
+ */
+export declare function resolveClientIpValues(forwardedFor: string | string[] | undefined, remoteAddress: string | null, trustProxy: boolean): string | null;
+export declare const MIME_TYPES: Record<string, string>;
+export declare const COMPRESSIBLE_FILE: RegExp;
+export declare const GZIP_MIN_BYTES = 1024;
+/** Varian gzip ter-cache per file+mtime (bounded FIFO) — Addendum K.5. */
+export declare function gzipCached(file: string, mtimeMs: number, body: Buffer): Buffer;
+export declare function acceptsGzipHeader(value: string | null): boolean;
+/** 413 transport dengan format §15 yang sama seperti `rpc.ts` (Addendum J.2). */
+export declare function rpcBodyTooLargeText(limit: number, size: number | null): string;
+/** Handler melewati `requestTimeoutMs` → transport menjawab 504 (Addendum R). */
+export declare class RequestTimeoutError extends Error {
+    readonly limit: number;
+    constructor(limit: number);
+}
+/** 504 dengan format §15 (dipakai kedua transport). */
+export declare function requestTimeoutText(limit: number): string;
+/**
+ * Jalankan handler dengan batas waktu eksplisit (Addendum R; review G1).
+ * `timeoutMs` undefined/0 → tanpa batas (perilaku lama).
+ */
+export declare function runHandlerWithTimeout(handler: (request: Request) => Promise<Response>, request: Request, timeoutMs: number | undefined): Promise<Response>;
+/** Klasifikasi abort klien / koneksi putus (review G7) — bukan error server. */
+export declare function isAbortLike(error: unknown): boolean;
+/** Respons teks transport (400/413/500/504) — tetap membawa header config + default aman (review G6). */
+export declare function textResponseWithHeaders(status: number, text: string, configured?: Record<string, string>): Response;
+/** Target header minimal yang dipenuhi `ServerResponse` dan `Headers`. */
+export interface HeaderTarget {
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+}
+/**
+ * Addendum J.7: header konfigurasi (menang), default aman, dan
+ * `Cache-Control: immutable` untuk aset ber-hash di `/assets/*`.
+ */
+export declare function applyStaticHeaders(target: HeaderTarget, pathname: string, configured: Record<string, string> | undefined): void;
+/**
+ * Baca body Web stream dengan batas tegas (Addendum J.2): begitu melewati
+ * `maxBytes`, pembacaan dihentikan dan `BodyLimitError` dilempar.
+ */
+export declare function readBodyWithLimit(stream: ReadableStream<Uint8Array> | null, maxBytes: number): Promise<Uint8Array>;
+/** Resolve file static dengan proteksi path traversal (+ manifest prerender D.5). */
+export declare function resolveStaticFile(clientDir: string, pathname: string): string | null;
+/**
+ * Target file untuk `pathname` (tanpa cek keberadaan) — dipakai penyajian,
+ * `createFileStorage().write`, dan test. Proteksi path traversal tetap.
+ */
+export declare function staticFileTarget(clientDir: string, pathname: string): string | null;
+export interface PrerenderManifestInfo {
+    paths: Set<string>;
+    revalidate: Map<string, number>;
+}
+export declare function readPrerenderManifest(clientDir: string): PrerenderManifestInfo;
+/** ISR: jika file prerender kedaluwarsa, regenerasi background (SWR). */
+export declare function scheduleRevalidation(input: {
+    pathname: string;
+    mtimeMs: number;
+    file?: string;
+    storage?: PrerenderStorage;
+    handler: (request: Request) => Promise<Response>;
+    options: {
+        canary?: string;
+    };
+    clientDir: string;
+    logger?: Logger | null;
+}): void;
+//# sourceMappingURL=transport.d.ts.map

package/dist/server/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/server/transport.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonsjs/vite",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "module",
   "license": "MIT",
   "sideEffects": false,
@@ -50,9 +50,9 @@
   },
   "dependencies": {
     "@babel/parser": "^8.0.7",
-    "@moonsjs/core": "^0.3.0",
-    "@moonsjs/react": "^0.3.0",
-    "@moonsjs/server": "^0.3.0"
+    "@moonsjs/core": "^0.5.0",
+    "@moonsjs/react": "^0.5.0",
+    "@moonsjs/server": "^0.5.0"
   },
   "peerDependencies": {
     "vite": "^8.3.4"

package/src/plugin.ts

@@ -60,6 +60,7 @@ export default function moons(options: MoonsVitePluginOptions = {}): Plugin {
   // Addendum J.1/J.2: paritas dev & produksi (paritas E7).
   let trustProxy = false;
   let bodyLimitBytes: number | undefined;
+  let requestTimeoutMs: number | undefined;
   let apiDir = "";
   let apiRoutes: ApiRouteDefinition[] = [];
   let apiMiddlewares: ApiMiddlewareDefinition[] = [];
@@ -251,6 +252,7 @@ export default function moons(options: MoonsVitePluginOptions = {}): Plugin {
       serverOnlyPackages = config.security?.serverOnlyPackages ?? [];
       trustProxy = config.security?.trustProxy === true;
       bodyLimitBytes = config.security?.bodyLimitBytes;
+      requestTimeoutMs = config.requestTimeoutMs;
 
       // Addendum D.1: scan + validasi statis modul `src/api`.
       apiDir = resolvePath(root, config.apiDir ?? "src/api");
@@ -466,6 +468,7 @@ export default function moons(options: MoonsVitePluginOptions = {}): Plugin {
           : { apiPrefix: `/${apiDir.split(/[\\/]/).filter((part) => part.length > 0).pop() ?? "api"}` }),
         trustProxy,
         ...(bodyLimitBytes === undefined ? {} : { bodyLimitBytes }),
+        ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
       });
       server.config.logger.info("[moons] devtools: /__moons/devtools");
     },
@@ -557,7 +560,7 @@ function renderServerEntryBuild(
 ): string {
   return [
     "// Generated by @moons. Do not edit manually.",
-    'import { createFileShell, createPluginRuntime, createRequestHandler, startNodeServer } from "@moonsjs/vite/server";',
+    'import { createFileShell, createPluginRuntime, createRequestHandler, startServer } from "@moonsjs/vite/server";',
     'import { renderToMarkup } from "@moonsjs/react/ssr";',
     'import config from "virtual:moons/config";',
     'import { routes, loadRoute } from "virtual:moons/routes";',
@@ -579,7 +582,7 @@ function renderServerEntryBuild(
     "  onContext: (ctx) => plugins.applyExtensions(ctx),",
     "});",
     "",
-    `startNodeServer(handler, { plugins, headers: config.headers, storage: config.isr?.storage, trustProxy: config.security?.trustProxy, bodyLimitBytes: config.security?.bodyLimitBytes, logging: config.logging, trailingSlash: config.trailingSlash${canary === undefined ? "" : `, canary: ${JSON.stringify(canary)}`} });`,
+    `startServer(handler, { plugins, headers: config.headers, storage: config.isr?.storage, trustProxy: config.security?.trustProxy, bodyLimitBytes: config.security?.bodyLimitBytes, requestTimeoutMs: config.requestTimeoutMs, logging: config.logging, trailingSlash: config.trailingSlash${canary === undefined ? "" : `, canary: ${JSON.stringify(canary)}`} });`,
     "",
   ].join("\n");
 }

package/src/server/bun-server.ts

@@ -0,0 +1,443 @@
+import { readFileSync, statSync } from "node:fs";
+import { extname, join, resolve } from "node:path";
+import { CLIENT_IP_HEADER, DEFAULT_BODY_LIMIT_BYTES, trailingSlashRedirect } from "@moonsjs/core";
+import { contentTypeForPathname } from "./storage";
+import {
+  BodyLimitError,
+  COMPRESSIBLE_FILE,
+  DEFAULT_SECURITY_HEADERS,
+  GZIP_MIN_BYTES,
+  InvalidRequestError,
+  MAX_TRANSPORT_BODY_BYTES,
+  MIME_TYPES,
+  RequestTimeoutError,
+  acceptsGzipHeader,
+  applyStaticHeaders,
+  forwardedHost,
+  forwardedProtocol,
+  gzipCached,
+  isAbortLike,
+  readBodyWithLimit,
+  requestTimeoutText,
+  resolveClientIpValues,
+  resolveStaticFile,
+  rpcBodyTooLargeText,
+  runHandlerWithTimeout,
+  scheduleRevalidation,
+  textResponseWithHeaders,
+} from "./transport";
+import { createLogger, type Logger } from "./logger";
+import type { NodeServerOptions } from "./node-server";
+import type { PluginRuntime } from "./plugins";
+
+/**
+ * Addendum Q (3B): host `Bun.serve` dengan perilaku paritas `node-server`:
+ * static + storage/ISR + ETag/gzip + trailingSlash + body limit RPC +
+ * header default + access log + drain SIGTERM. Dipilih otomatis oleh
+ * `startServer` saat berjalan di Bun (override: `MOONS_SERVER=node|bun`).
+ */
+
+interface BunServerHandle {
+  port: number;
+  stop(closeActiveConnections?: boolean): Promise<void>;
+}
+
+function appendVaryHeader(headers: Headers, value: string): void {
+  const existing = headers.get("vary");
+  if (existing !== null && existing.length > 0) {
+    if (!existing.toLowerCase().includes(value)) {
+      headers.set("vary", `${existing}, ${value}`);
+    }
+    return;
+  }
+  headers.set("vary", value);
+}
+
+/** J.7: response handler tanpa header default aman — mutasi langsung bila mungkin. */
+function withDefaultSecurityHeaders(response: Response): Response {
+  let missing = false;
+  for (const name of Object.keys(DEFAULT_SECURITY_HEADERS)) {
+    if (!response.headers.has(name)) {
+      missing = true;
+      break;
+    }
+  }
+  if (!missing) {
+    return response;
+  }
+  try {
+    for (const [name, value] of Object.entries(DEFAULT_SECURITY_HEADERS)) {
+      if (!response.headers.has(name)) {
+        response.headers.set(name, value);
+      }
+    }
+    return response;
+  } catch {
+    // Header immutable (mis. dari fetch) → bungkus ulang.
+    const headers = new Headers(response.headers);
+    for (const [name, value] of Object.entries(DEFAULT_SECURITY_HEADERS)) {
+      if (!headers.has(name)) {
+        headers.set(name, value);
+      }
+    }
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    });
+  }
+}
+
+/** J.1: URL dari Request Bun, mengikuti `x-forwarded-*` bila trustProxy aktif. */
+function resolveBunUrl(request: Request, trustProxy: boolean): URL {
+  let url: URL;
+  try {
+    url = new URL(request.url);
+  } catch {
+    throw new InvalidRequestError(`invalid request URL: ${request.url}`);
+  }
+  if (!trustProxy) {
+    return url;
+  }
+  const proto = forwardedProtocol(request.headers.get("x-forwarded-proto") ?? undefined);
+  const host = forwardedHost(request.headers.get("x-forwarded-host") ?? undefined);
+  if (proto === null && host === null) {
+    return url;
+  }
+  // Bangun URL baru (bukan mutasi `.host`): setter `host` mempertahankan port
+  // lama, sehingga `internal:3000` + `x-forwarded-host: app.example.com`
+  // menghasilkan origin `https://app.example.com:3000` — origin RPC meleset.
+  const effectiveProto = proto ?? (url.protocol === "https:" ? "https" : "http");
+  const effectiveHost = host ?? url.host;
+  try {
+    return new URL(`${effectiveProto}://${effectiveHost}${url.pathname}${url.search}${url.hash}`);
+  } catch {
+    throw new InvalidRequestError(`invalid forwarded host: ${JSON.stringify(effectiveHost)}`);
+  }
+}
+
+/** Request Web dengan body terbatas + `x-moons-client-ip` tepercaya (J.1/J.2). */
+async function toBoundedRequest(
+  request: Request,
+  url: URL,
+  clientIp: string | null,
+  maxBodyBytes: number,
+): Promise<Request> {
+  const headers = new Headers(request.headers);
+  headers.delete("content-length");
+  if (clientIp !== null) {
+    headers.set(CLIENT_IP_HEADER, clientIp);
+  }
+  if (request.method === "GET" || request.method === "HEAD") {
+    return new Request(url, { method: request.method, headers });
+  }
+  const body = await readBodyWithLimit(request.body, maxBodyBytes);
+  return new Request(url, { method: request.method, headers, body: body as unknown as BodyInit });
+}
+
+function installBunShutdown(
+  server: BunServerHandle,
+  options: { timeoutMs?: number; plugins?: PluginRuntime | undefined },
+): (signal: string) => void {
+  const timeoutMs = options.timeoutMs ?? 10_000;
+  let shuttingDown = false;
+  return (signal: string): void => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    console.log(`[moons] received ${signal} — no longer accepting connections, draining...`);
+    const timer = setTimeout(() => {
+      console.log(`[moons] drain exceeded ${timeoutMs}ms — forcing exit`);
+      void server.stop(true).catch(() => {});
+      process.exit(1);
+    }, timeoutMs);
+    (timer as { unref?: () => void }).unref?.();
+    void (async () => {
+      try {
+        await server.stop(false);
+      } catch (error) {
+        clearTimeout(timer);
+        console.log(
+          `[moons] server close failed: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        process.exit(1);
+        return;
+      }
+      if (options.plugins !== undefined) {
+        // Berbagi batas waktu dengan drain: timer di-ref kembali.
+        (timer as { ref?: () => void }).ref?.();
+        try {
+          await options.plugins.shutdown();
+        } catch (error) {
+          console.log(`[moons] onShutdown failed: ${String(error)}`);
+        }
+      }
+      clearTimeout(timer);
+      console.log("[moons] shutdown complete (full drain)");
+      process.exit(0);
+    })();
+  };
+}
+
+/**
+ * Serve produksi dengan `Bun.serve` (Addendum Q). API yang sama dengan
+ * `startNodeServer`; hanya tersedia di runtime Bun.
+ */
+export function startBunServer(
+  handler: (request: Request) => Promise<Response>,
+  options: NodeServerOptions = {},
+): BunServerHandle {
+  if (typeof Bun === "undefined") {
+    throw new Error("[moons] startBunServer requires the Bun runtime");
+  }
+  const clientDir = resolve(options.clientDir ?? join(process.cwd(), "dist/client"));
+  const port = options.port ?? Number(process.env["PORT"] ?? 3000);
+  const trustProxy = options.trustProxy === true;
+  const requestTimeoutMs = options.requestTimeoutMs;
+  // Addendum R: idleTimeout Bun diselaraskan dengan batas kita (+5 dtk grace)
+  // supaya 504 dari framework yang menang, bukan koneksi diputus diam-diam.
+  const idleTimeout =
+    requestTimeoutMs === undefined || requestTimeoutMs <= 0
+      ? 0
+      : Math.ceil(requestTimeoutMs / 1000) + 5;
+  const accessLogger: Logger | null =
+    options.logging?.accessLog === true
+      ? createLogger({
+          json: options.logging.json !== false,
+          redact: options.logging.redact ?? [],
+        })
+      : null;
+
+  const serveStatic = async (
+    request: Request,
+    url: URL,
+  ): Promise<Response | null> => {
+    if (options.storage !== undefined) {
+      // Addendum R (review G2): storage error = miss — aset & halaman non-ISR
+      // harus tetap jalan saat store bersama outage.
+      let entry: Awaited<ReturnType<NonNullable<typeof options.storage>["read"]>> | null = null;
+      try {
+        entry = await options.storage.read(url.pathname);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (accessLogger !== null) {
+          accessLogger({ msg: "isr:storage-read-failed", level: "warn", path: url.pathname, error: message });
+        } else {
+          console.warn(`[moons] isr storage read failed (${url.pathname}): ${message} — falling back to dist/client`);
+        }
+      }
+      if (entry !== null) {
+        scheduleRevalidation({
+          pathname: url.pathname,
+          mtimeMs: entry.mtimeMs,
+          storage: options.storage,
+          handler,
+          options,
+          clientDir,
+          logger: accessLogger,
+        });
+        const headers = new Headers();
+        headers.set("content-type", contentTypeForPathname(url.pathname));
+        applyStaticHeaders(headers, url.pathname, options.headers);
+        return new Response(
+          request.method === "HEAD" ? null : (entry.body as unknown as BodyInit),
+          { status: 200, headers },
+        );
+      }
+      // L.2 (temuan F1): storage MISS → fallback `dist/client`; storage tetap menang.
+    }
+    const staticFile = resolveStaticFile(clientDir, url.pathname);
+    if (staticFile === null) {
+      return null;
+    }
+    const stat = statSync(staticFile);
+    scheduleRevalidation({
+      pathname: url.pathname,
+      mtimeMs: stat.mtimeMs,
+      file: staticFile,
+      ...(options.storage === undefined ? {} : { storage: options.storage }),
+      handler,
+      options,
+      clientDir,
+      logger: accessLogger,
+    });
+    const headers = new Headers();
+    headers.set(
+      "content-type",
+      MIME_TYPES[extname(staticFile).toLowerCase()] ?? "application/octet-stream",
+    );
+    applyStaticHeaders(headers, url.pathname, options.headers);
+
+    // K.5: ETag + 304.
+    const etag = `W/"${stat.size}-${Math.floor(stat.mtimeMs)}"`;
+    headers.set("etag", etag);
+    const ifNoneMatch = request.headers.get("if-none-match");
+    if (ifNoneMatch !== null && ifNoneMatch.split(",").some((value) => value.trim() === etag)) {
+      return new Response(null, { status: 304, headers });
+    }
+
+    // K.5: gzip untuk aset teks (cache per mtime).
+    let payload: Uint8Array | null =
+      request.method === "HEAD" ? null : readFileSync(staticFile);
+    if (
+      payload !== null &&
+      COMPRESSIBLE_FILE.test(staticFile) &&
+      payload.byteLength >= GZIP_MIN_BYTES &&
+      acceptsGzipHeader(request.headers.get("accept-encoding"))
+    ) {
+      payload = gzipCached(staticFile, stat.mtimeMs, Buffer.from(payload));
+      headers.set("content-encoding", "gzip");
+      appendVaryHeader(headers, "accept-encoding");
+    }
+    return new Response(payload as unknown as BodyInit | null, { status: 200, headers });
+  };
+
+  const server = Bun.serve({
+    port,
+    idleTimeout,
+    fetch: async (request, bunServer) => {
+      const requestStartedAt = performance.now();
+      let url: URL;
+      try {
+        url = resolveBunUrl(request, trustProxy);
+      } catch (error) {
+        if (error instanceof InvalidRequestError) {
+          console.warn(`[moons] ${error.message} — 400`);
+          return textResponseWithHeaders(400, "Bad Request", options.headers);
+        }
+        throw error;
+      }
+      let clientIp: string | null = null;
+      const finish = (response: Response): Response => {
+        if (accessLogger !== null) {
+          accessLogger({
+            msg: "request",
+            method: request.method,
+            path: url.pathname + url.search,
+            status: response.status,
+            durationMs: Math.round(performance.now() - requestStartedAt),
+            ...(clientIp === null ? {} : { ip: clientIp }),
+          });
+        }
+        return response;
+      };
+
+      try {
+        // M: kanonikalisasi trailing slash di transport (termasuk path prerender).
+        if (options.trailingSlash !== undefined) {
+          const canonical = trailingSlashRedirect(url.pathname, options.trailingSlash);
+          if (canonical !== null) {
+            url.pathname = canonical;
+            return new Response(null, { status: 308, headers: { location: url.toString() } });
+          }
+        }
+
+        if (request.method === "GET" || request.method === "HEAD") {
+          const staticResponse = await serveStatic(request, url);
+          if (staticResponse !== null) {
+            return finish(staticResponse);
+          }
+        }
+
+        // J.2: batas body RPC di transport — content-length diperiksa lebih dulu.
+        const isRpc = url.pathname.startsWith("/_moons/fn/");
+        const rpcLimit = options.bodyLimitBytes ?? DEFAULT_BODY_LIMIT_BYTES;
+        if (isRpc) {
+          const contentLength = Number(request.headers.get("content-length") ?? "0");
+          if (Number.isFinite(contentLength) && contentLength > rpcLimit) {
+            return finish(
+              textResponseWithHeaders(413, rpcBodyTooLargeText(rpcLimit, contentLength), options.headers),
+            );
+          }
+        }
+
+        const remoteAddress = bunServer.requestIP(request)?.address ?? null;
+        clientIp = resolveClientIpValues(
+          request.headers.get("x-forwarded-for") ?? undefined,
+          remoteAddress,
+          trustProxy,
+        );
+        // Fast path: GET/HEAD tanpa rewrite URL & tanpa IP tepercaya → pakai
+        // Request asli (menghindari rekonstruksi + salinan header per request).
+        const needsRewrite = clientIp !== null || url.toString() !== request.url;
+        const webRequest =
+          (request.method === "GET" || request.method === "HEAD") && !needsRewrite
+            ? request
+            : await toBoundedRequest(
+                request,
+                url,
+                clientIp,
+                isRpc ? rpcLimit : MAX_TRANSPORT_BODY_BYTES,
+              );
+        // Addendum R: batas waktu eksplisit; 0/undefined = tanpa batas.
+        const response = await runHandlerWithTimeout(handler, webRequest, requestTimeoutMs);
+        return finish(withDefaultSecurityHeaders(response));
+      } catch (error) {
+        if (error instanceof BodyLimitError) {
+          const isRpc = url.pathname.startsWith("/_moons/fn/");
+          return finish(
+            textResponseWithHeaders(
+              413,
+              isRpc ? rpcBodyTooLargeText(error.limit, null) : "Payload Too Large",
+              options.headers,
+            ),
+          );
+        }
+        // Addendum R: timeout eksplisit — 504 + log terstruktur.
+        if (error instanceof RequestTimeoutError) {
+          if (accessLogger !== null) {
+            accessLogger({
+              msg: "request-timeout",
+              level: "warn",
+              method: request.method,
+              path: url.pathname + url.search,
+              limitMs: error.limit,
+            });
+          } else {
+            console.warn(`[moons] request timed out after ${error.limit}ms — ${request.method} ${url.pathname}`);
+          }
+          return finish(textResponseWithHeaders(504, requestTimeoutText(error.limit), options.headers));
+        }
+        // Review G7: abort klien/koneksi putus bukan error server (tanpa stack).
+        if (isAbortLike(error)) {
+          if (accessLogger !== null) {
+            accessLogger({
+              msg: "request-aborted",
+              level: "warn",
+              method: request.method,
+              path: url.pathname + url.search,
+            });
+          } else {
+            console.warn(`[moons] request aborted by the client — ${request.method} ${url.pathname}`);
+          }
+          return new Response(null, { status: 499 });
+        }
+        console.error("[moons] server error:", error);
+        return finish(textResponseWithHeaders(500, "Internal Server Error", options.headers));
+      }
+    },
+  });
+
+  // B.4: onStart sebelum log siap, onReady setelah server menerima koneksi.
+  const listenAfterStart = (): void => {
+    console.log(`[moons] server listening on http://localhost:${server.port}`);
+    void options.plugins?.ready();
+  };
+  if (options.plugins !== undefined) {
+    void options.plugins.start().then(listenAfterStart);
+  } else {
+    listenAfterStart();
+  }
+
+  if (options.handleSignals !== false) {
+    const shutdown = installBunShutdown(server as unknown as BunServerHandle, {
+      ...(options.shutdownTimeoutMs === undefined ? {} : { timeoutMs: options.shutdownTimeoutMs }),
+      plugins: options.plugins,
+    });
+    process.once("SIGTERM", () => shutdown("SIGTERM"));
+    process.once("SIGINT", () => shutdown("SIGINT"));
+  }
+
+  return server as unknown as BunServerHandle;
+}

package/src/server/dev.ts

@@ -13,6 +13,12 @@ import {
   toWebRequest,
 } from "./node";
 import { DEFAULT_BODY_LIMIT_BYTES } from "@moonsjs/core";
+import {
+  RequestTimeoutError,
+  applyStaticHeaders,
+  requestTimeoutText,
+  runHandlerWithTimeout,
+} from "./transport";
 import { emptyDevtoolsData, renderDevtoolsHtml, type DevtoolsData } from "../devtools";
 
 interface DevApp {
@@ -41,6 +47,8 @@ export function installDevMiddleware(
     /** Addendum J.1: paritas dev dengan produksi (trustProxy/bodyLimitBytes). */
     trustProxy?: boolean;
     bodyLimitBytes?: number;
+    /** Addendum R: batas waktu respons (ms); 0/undefined = tanpa batas. */
+    requestTimeoutMs?: number;
     /** Addendum I.4: datasource devtools overlay (dipanggil per request). */
     devtools?: () => DevtoolsData;
   },
@@ -110,7 +118,7 @@ async function handleRequest(
   getApp: () => Promise<DevApp>,
   req: IncomingMessage,
   res: ServerResponse,
-  options: { trustProxy?: boolean; bodyLimitBytes?: number },
+  options: { trustProxy?: boolean; bodyLimitBytes?: number; requestTimeoutMs?: number },
 ): Promise<void> {
   const app = await getApp();
   const url = resolveRequestUrl(req, { trustProxy: options.trustProxy === true });
@@ -119,7 +127,24 @@ async function handleRequest(
     trustProxy: options.trustProxy === true,
     ...(isRpc ? { maxBodyBytes: options.bodyLimitBytes ?? DEFAULT_BODY_LIMIT_BYTES } : {}),
   });
-  const response = await app.handler(request);
+  // Addendum R: paritas dev — batas waktu eksplisit yang sama dengan produksi.
+  let response: Response;
+  try {
+    response = await runHandlerWithTimeout(app.handler, request, options.requestTimeoutMs);
+  } catch (error) {
+    if (error instanceof RequestTimeoutError) {
+      res.statusCode = 504;
+      res.setHeader("content-type", "text/plain; charset=utf-8");
+      applyStaticHeaders(
+        { has: (name) => res.hasHeader(name), set: (name, value) => res.setHeader(name, value) },
+        "/",
+        undefined,
+      );
+      res.end(requestTimeoutText(error.limit));
+      return;
+    }
+    throw error;
+  }
   await sendNodeResponse(res, response);
 }