@moonsjs/vite 0.1.17 → 0.2.0

package/src/server/handler.ts

@@ -104,6 +104,8 @@ export function createRequestHandler(
       resolved.params,
       data,
       searchParams,
+      undefined,
+      config.trailingSlash,
     );
     const payload = encodeSsrPayload({
       key: pageKey,
@@ -116,7 +118,10 @@ export function createRequestHandler(
     // A1: pindai payload SSR (dev saja — `payloadScan` tidak diisi production).
     warnPayloadFindings(payload, options.payloadScan, warnedPayloadLabels);
 
-    return htmlResponse(await shell(markup, payload, request.url, meta), 200);
+    return htmlResponse(
+      withTrailingSlashMeta(await shell(markup, payload, request.url, meta), config.trailingSlash),
+      200,
+    );
   }
 
   /** Addendum D.1: dispatch endpoint `src/api` (405/HEAD/OPTIONS + error). */
@@ -132,9 +137,9 @@ export function createRequestHandler(
         new MoonsError({
           code: "E_API_HANDLER_INVALID",
           file: route.file,
-          message: `modul API \`${route.path}\` tidak bisa dimuat`,
-          details: "Peta `loadApi` tidak memuat route ini (build/dev tidak sinkron).",
-          suggestions: ["Jalankan ulang build / restart dev server"],
+          message: `API module \`${route.path}\` could not be loaded`,
+          details: "The `loadApi` map does not contain this route (build/dev out of sync).",
+          suggestions: ["Rebuild / restart the dev server"],
         }),
         route,
       );
@@ -151,9 +156,9 @@ export function createRequestHandler(
         new MoonsError({
           code: "E_API_HANDLER_INVALID",
           file: route.file,
-          message: "modul API tidak mengekspor objek handler",
-          details: `Modul \`${route.path}\` harus mengekspor handler method.`,
-          suggestions: ["Export `GET`/`POST`/… sebagai fungsi `(args) => Response`"],
+          message: "API module does not export a handler object",
+          details: `Module \`${route.path}\` must export method handlers.`,
+          suggestions: ["Export `GET`/`POST`/… as `(args) => Response` functions"],
         }),
         route,
       );
@@ -194,9 +199,9 @@ export function createRequestHandler(
           new MoonsError({
             code: "E_API_HANDLER_INVALID",
             file: route.file,
-            message: `handler \`${requestMethod}\` tidak mengembalikan \`Response\``,
-            details: "Handler API wajib mengembalikan `new Response(...)`.",
-            suggestions: ["Kembalikan `new Response(body, { status, headers })`"],
+            message: `handler \`${requestMethod}\` did not return a \`Response\``,
+            details: "API handlers must return `new Response(...)`.",
+            suggestions: ["Return `new Response(body, { status, headers })`"],
           }),
           route,
         );
@@ -222,20 +227,22 @@ export function createRequestHandler(
           { page: module as RouteModuleShape, layouts: [] },
           {},
           {},
+          {},
+          undefined,
+          config.trailingSlash,
+        );
+        return htmlResponse(
+          withTrailingSlashMeta(await shell(markup, payload, request.url), config.trailingSlash),
+          404,
         );
-        return htmlResponse(await shell(markup, payload, request.url), 404);
       } catch (error) {
-        console.error("[moons] gagal merender _404 kustom:", error);
+        console.error("[moons] failed to render custom _404:", error);
       }
     }
 
     const payload = encodeSsrPayload({ key: "", params: {}, data: {} });
-    const html = await shell(
-      "<h1>404</h1><p>Halaman tidak ditemukan.</p>",
-      payload,
-      request.url,
-    );
-    return htmlResponse(html, 404);
+    const html = await shell("<h1>404</h1><p>Page not found.</p>", payload, request.url);
+    return htmlResponse(withTrailingSlashMeta(html, config.trailingSlash), 404);
   }
 
   /**
@@ -272,10 +279,14 @@ export function createRequestHandler(
           {},
           {},
           serialized === undefined ? undefined : reviveError(serialized),
+          config.trailingSlash,
+        );
+        return htmlResponse(
+          withTrailingSlashMeta(await shell(markup, payload, request.url), config.trailingSlash),
+          500,
         );
-        return htmlResponse(await shell(markup, payload, request.url), 500);
       } catch (renderError) {
-        console.error("[moons] gagal merender _error kustom:", renderError);
+        console.error("[moons] failed to render custom _error:", renderError);
       }
     }
 
@@ -292,9 +303,9 @@ export function createRequestHandler(
         throw new MoonsError({
           code: "E_MIDDLEWARE_INVALID",
           file: definition.file,
-          message: "middleware direktori tidak bisa dimuat",
-          details: "Peta `loadRoute` tidak memuat `_middleware.ts` ini.",
-          suggestions: ["Restart dev server / jalankan ulang build"],
+          message: "directory middleware could not be loaded",
+          details: "The `loadRoute` map does not contain this `_middleware.ts`.",
+          suggestions: ["Restart the dev server / rebuild"],
         });
       }
       const module = (await load()) as { default?: unknown };
@@ -303,8 +314,8 @@ export function createRequestHandler(
         throw new MoonsError({
           code: "E_MIDDLEWARE_INVALID",
           file: definition.file,
-          message: "`_middleware.ts` tidak meng-export default fungsi",
-          details: "Middleware direktori mengikuti bentuk `(args) => Promise<Response>`.",
+          message: "`_middleware.ts` does not default-export a function",
+          details: "Directory middleware follows the `(args) => Promise<Response>` shape.",
           suggestions: ["Export default `async ({ req, ctx, next }) => await next()`"],
         });
       }
@@ -324,9 +335,9 @@ export function createRequestHandler(
         throw new MoonsError({
           code: "E_MIDDLEWARE_INVALID",
           file: definition.file,
-          message: "middleware API tidak bisa dimuat",
-          details: "Peta `loadApiMiddleware` tidak memuat `_middleware.ts` ini.",
-          suggestions: ["Restart dev server / jalankan ulang build"],
+          message: "API middleware could not be loaded",
+          details: "The `loadApiMiddleware` map does not contain this `_middleware.ts`.",
+          suggestions: ["Restart the dev server / rebuild"],
         });
       }
       const module = (await load()) as { default?: unknown };
@@ -334,8 +345,8 @@ export function createRequestHandler(
         throw new MoonsError({
           code: "E_MIDDLEWARE_INVALID",
           file: definition.file,
-          message: "`_middleware.ts` tidak meng-export default fungsi",
-          details: "Middleware direktori mengikuti bentuk `(args) => Promise<Response>`.",
+          message: "`_middleware.ts` does not default-export a function",
+          details: "Directory middleware follows the `(args) => Promise<Response>` shape.",
           suggestions: ["Export default `async ({ req, ctx, next }) => await next()`"],
         });
       }
@@ -385,7 +396,7 @@ export function createRequestHandler(
               middlewares,
               ctx,
               () => handleApiRequest(apiMatch.route, apiMatch.params, request, ctx),
-              { code: "E_MIDDLEWARE_INVALID", label: "middleware API" },
+              { code: "E_MIDDLEWARE_INVALID", label: "API middleware" },
             )(request);
           }
         }
@@ -404,7 +415,7 @@ export function createRequestHandler(
             middlewares,
             ctx,
             () => renderRoute(resolved, request, ctx),
-            { code: "E_MIDDLEWARE_INVALID", label: "middleware direktori" },
+            { code: "E_MIDDLEWARE_INVALID", label: "directory middleware" },
           )(request);
         } catch (error) {
           // Addendum B.2: sinyal routing dari loader/meta.
@@ -538,9 +549,9 @@ async function loadModules(
       if (load === undefined) {
         throw new MoonsError({
           code: "E_INTERNAL",
-          message: `modul route \`${key}\` tidak terdaftar`,
-          details: "Registry route tidak sinkron dengan hasil scan.",
-          suggestions: ["Jalankan ulang `bun run build`, atau restart dev server"],
+          message: `route module \`${key}\` is not registered`,
+          details: "The route registry is out of sync with the scan result.",
+          suggestions: ["Run `bun run build` again, or restart the dev server"],
         });
       }
       return await load();
@@ -561,11 +572,11 @@ async function runRouteMeta(
     throw new MoonsError({
       code: "E_INTERNAL",
       file,
-      message: "export `meta` harus berupa fungsi `({ data }) => RouteMeta`",
-      details: "Bentuk `meta` mengikuti ",
+      message: "export `meta` must be a function `({ data }) => RouteMeta`",
+      details: "The `meta` shape follows `RouteMeta`.",
       suggestions: [
-        "Ubah menjadi `export const meta = ({ data }) => ({ title: \"...\" })`",
-        "Atau hapus export `meta`",
+        "Change it to `export const meta = ({ data }) => ({ title: \"...\" })`",
+        "Or remove the `meta` export",
       ],
     });
   }
@@ -574,9 +585,9 @@ async function runRouteMeta(
     throw new MoonsError({
       code: "E_INTERNAL",
       file,
-      message: "`meta()` harus mengembalikan objek RouteMeta",
-      details: "Nilai yang dikembalikan dipakai untuk <title>/description/og.",
-      suggestions: ["Kembalikan objek, mis. `({ title: \"Halaman\" })`"],
+      message: "`meta()` must return a RouteMeta object",
+      details: "The returned value is used for <title>/description/og.",
+      suggestions: ["Return an object, e.g. `({ title: \"Home\" })`"],
     });
   }
   return result as Record<string, unknown>;
@@ -589,13 +600,13 @@ function apiErrorResponse(error: unknown, route: ApiRouteDefinition): Response {
   const isProduction = process.env["NODE_ENV"] === "production";
   if (error instanceof MoonsError) {
     console.error(`[moons] API ${route.path}: ${error.format()}`);
-    return new Response(isProduction ? "Terjadi kesalahan internal." : error.format(), {
+    return new Response(isProduction ? "Internal server error." : error.format(), {
       status: 500,
       headers: { "content-type": "text/plain; charset=utf-8" },
     });
   }
   console.error(`[moons] API ${route.path}:`, error);
-  return new Response(isProduction ? "Terjadi kesalahan internal." : String(error), {
+  return new Response(isProduction ? "Internal server error." : String(error), {
     status: 500,
     headers: { "content-type": "text/plain; charset=utf-8" },
   });
@@ -609,14 +620,25 @@ function internalErrorResponse(error: unknown, options: { log?: boolean } = {}):
   const detail =
     process.env["NODE_ENV"] !== "production" && error instanceof MoonsError
       ? `<pre>${escapeHtml(error.format())}</pre>`
-      : "<p>Terjadi kesalahan internal.</p>";
+      : "<p>Internal server error.</p>";
 
   return htmlResponse(
-    `<!doctype html><html lang="id"><head><meta charset="utf-8"><title>500</title></head><body><h1>500</h1>${detail}</body></html>`,
+    `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>500</title></head><body><h1>500</h1>${detail}</body></html>`,
     500,
   );
 }
 
+/** Addendum O: expose the trailing-slash policy to the client runtime. */
+function withTrailingSlashMeta(html: string, policy?: "never" | "always"): string {
+  if (policy === undefined) {
+    return html;
+  }
+  return html.replace(
+    "</head>",
+    `  <meta name="moons:trailing-slash" content="${policy}" />\n</head>`,
+  );
+}
+
 function htmlResponse(html: string, status: number): Response {
   return new Response(html, {
     status,
@@ -667,7 +689,7 @@ function warnPayloadFindings(
     }
     warned.add(label);
     console.warn(
-      `[moons] peringatan dev: payload SSR memuat ${label} — jangan mengembalikan rahasia dari loader.`,
+      `[moons] dev warning: SSR payload contains ${label} — do not return secrets from loaders.`,
     );
   }
 }

package/src/server/isr.ts

@@ -57,7 +57,7 @@ async function runRevalidate(options: RevalidateOptions): Promise<void> {
       }),
     );
     if (response.status !== 200) {
-      log(`[moons] isr: lewati ${options.pathname} (status ${response.status})`);
+      log(`[moons] isr: skipped ${options.pathname} (status ${response.status})`);
       return;
     }
     const html = await response.text();
@@ -69,8 +69,8 @@ async function runRevalidate(options: RevalidateOptions): Promise<void> {
       const labels = findings
         .map((finding) => (finding.kind === "canary" ? "canary" : `env(${finding.label})`))
         .join(", ");
-      // Fail-closed: jangan menimpa file statis dengan konten bocor.
-      log(`[moons] isr: TIDAK menulis ${options.pathname} — memuat ${labels}`);
+      // Fail-closed: tidak menimpa file statis dengan konten bocor.
+      log(`[moons] isr: NOT writing ${options.pathname} — contains ${labels}`);
       return;
     }
     if (options.storage !== undefined) {
@@ -78,14 +78,14 @@ async function runRevalidate(options: RevalidateOptions): Promise<void> {
       return;
     }
     if (options.file === undefined) {
-      log(`[moons] isr: lewati ${options.pathname} — tanpa file/storage tujuan`);
+      log(`[moons] isr: skipped ${options.pathname} — no destination file/storage`);
       return;
     }
     const tmp = `${options.file}.tmp-${process.pid}`;
     writeFileSync(tmp, html);
     renameSync(tmp, options.file);
   } catch (error) {
-    log(`[moons] isr: gagal regenerasi ${options.pathname}: ${String(error)}`);
+    log(`[moons] isr: failed to regenerate ${options.pathname}: ${String(error)}`);
   }
 }
 

package/src/server/node-server.ts

@@ -366,13 +366,13 @@ function rpcBodyTooLargeText(limit: number, size: number | null): string {
     code: "E_RPC_BODY_TOO_LARGE",
     message:
       size === null
-        ? `body melebihi limit ${megabytes(limit)} MB`
-        : `body ${megabytes(size)} MB melebihi limit ${megabytes(limit)} MB`,
+        ? `body exceeds the ${megabytes(limit)} MB limit`
+        : `body ${megabytes(size)} MB exceeds the ${megabytes(limit)} MB limit`,
     details:
-      "Body melebihi `security.bodyLimitBytes`; pembacaan dihentikan di transport sebelum penuh.",
+      "Body exceeds `security.bodyLimitBytes`; reading stops at the transport before the body is fully buffered.",
     suggestions: [
-      "Kurangi ukuran payload, atau",
-      "Naikkan security.bodyLimitBytes jika memang perlu",
+      "Reduce the payload size, or",
+      "Increase security.bodyLimitBytes if you really need to",
     ],
   }).format();
 }
@@ -524,7 +524,7 @@ function scheduleRevalidation(input: {
       if (logger !== null) {
         logger({ msg: "isr:revalidate-failed", level: "warn", path: normalized, error: message });
       } else {
-        console.error(`[moons] isr regenerasi gagal (${normalized}): ${message}`);
+        console.error(`[moons] isr regeneration failed (${normalized}): ${message}`);
       }
     });
 }

package/src/server/node.ts

@@ -18,7 +18,7 @@ export class InvalidRequestError extends Error {
 export class BodyLimitError extends Error {
   readonly limit: number;
   constructor(limit: number) {
-    super(`request body melebihi batas ${limit} byte`);
+    super(`request body exceeds the ${limit} byte limit`);
     this.name = "BodyLimitError";
     this.limit = limit;
   }
@@ -48,7 +48,7 @@ export function resolveRequestUrl(
   try {
     return new URL(`${proto ?? "http"}://${host}${req.url ?? "/"}`);
   } catch {
-    throw new InvalidRequestError(`header Host tidak valid: ${JSON.stringify(hostHeader)}`);
+    throw new InvalidRequestError(`invalid Host header: ${JSON.stringify(hostHeader)}`);
   }
 }
 

package/src/server/plugins.ts

@@ -69,7 +69,7 @@ export function createPluginRuntime(options: PluginRuntimeOptions): PluginRuntim
         try {
           await plugin.onShutdown?.(app);
         } catch (error) {
-          log(`[moons] plugin \`${plugin.name}\` gagal saat onShutdown: ${String(error)}`);
+          log(`[moons] plugin \`${plugin.name}\` failed during onShutdown: ${String(error)}`);
         }
       }
     },

package/src/server/prerender.ts

@@ -80,11 +80,11 @@ export async function runPrerender(options: PrerenderOptions): Promise<Prerender
         throw new MoonsError({
           code: "E_ISR_INVALID",
           file: route.file,
-          message: "`revalidate` tidak valid atau dipakai tanpa `prerender = true`",
-          details: "ISR berbasis file: `revalidate` (detik, number >= 0) + `prerender`.",
+          message: "`revalidate` is invalid or used without `prerender = true`",
+          details: "File-based ISR: `revalidate` (seconds, number >= 0) + `prerender`.",
           suggestions: [
-            "Gunakan angka detik, mis. `export const revalidate = 60`",
-            "Tambahkan `export const prerender = true` pada page yang sama",
+            "Use a number of seconds, e.g. `export const revalidate = 60`",
+            "Add `export const prerender = true` to the same page",
           ],
         });
       }
@@ -92,7 +92,7 @@ export async function runPrerender(options: PrerenderOptions): Promise<Prerender
 
     if (prerender !== true) {
       if (prerender !== undefined && prerender !== false) {
-        throw prerenderError(route, "`prerender` harus boolean (`true`/`false`)");
+        throw prerenderError(route, "`prerender` must be a boolean (`true`/`false`)");
       }
       continue;
     }
@@ -107,15 +107,15 @@ export async function runPrerender(options: PrerenderOptions): Promise<Prerender
       );
 
       if (response.status === 404) {
-        log(`[moons] prerender: lewati ${pathname} (notFound)`);
+        log(`[moons] prerender: skipped ${pathname} (notFound)`);
         skipped += 1;
         continue;
       }
       if (response.status >= 300 && response.status < 400) {
-        throw prerenderError(route, `\`redirect()\` tidak didukung saat prerender (${pathname})`);
+        throw prerenderError(route, `\`redirect()\` is not supported during prerender (${pathname})`);
       }
       if (response.status !== 200) {
-        throw prerenderError(route, `status ${response.status} saat merender ${pathname}`);
+        throw prerenderError(route, `status ${response.status} while rendering ${pathname}`);
       }
 
       const html = await response.text();
@@ -152,7 +152,7 @@ export async function runPrerender(options: PrerenderOptions): Promise<Prerender
 
   const extras = [...(wrote404 ? [NOT_FOUND_FILE] : []), ...emitted];
   log(
-    `[moons] prerender selesai: ${written} file${extras.length > 0 ? ` + ${extras.join(" + ")}` : ""} (${skipped} dilewati)`,
+    `[moons] prerender done: ${written} file${extras.length > 0 ? ` + ${extras.join(" + ")}` : ""} (${skipped} skipped)`,
   );
   return { written, skipped };
 }
@@ -237,7 +237,7 @@ async function renderStaticNotFound(
   );
   if (response.status !== 404) {
     log(
-      `[moons] prerender: ${NOT_FOUND_FILE} dilewati (sentinel \`${NOT_FOUND_SENTINEL}\` → ${response.status})`,
+      `[moons] prerender: ${NOT_FOUND_FILE} skipped (sentinel \`${NOT_FOUND_SENTINEL}\` → ${response.status})`,
     );
     return null;
   }
@@ -267,11 +267,11 @@ function assertNoLeak(
   throw new MoonsError({
     code: "E_PRERENDER_LEAK",
     file,
-    message: `hasil prerender \`${pathname}\` memuat ${labels}`,
-    details: "HTML statis permanen — rahasia yang ter-prerender tidak bisa ditarik kembali.",
+    message: `prerender output \`${pathname}\` contains ${labels}`,
+    details: "Static HTML is permanent — a prerendered secret cannot be retracted.",
     suggestions: [
-      "Jangan mengembalikan nilai env rahasia dari loader yang di-prerender",
-      "Matikan `prerender` untuk route ini atau pindahkan datanya ke serverFn request-time",
+      "Do not return secret env values from a loader that runs at prerender time",
+      "Turn off `prerender` for this route or move the data to a request-time serverFn",
     ],
   });
 }
@@ -291,37 +291,37 @@ async function resolvePathnames(route: RouteDefinition, module: RouteModule): Pr
     throw new MoonsError({
       code: "E_PRERENDER_NO_PATHS",
       file: route.file,
-      message: "route dynamic ber-`prerender = true` tanpa `export const paths`",
-      details: "Prerender butuh daftar param untuk merender tiap path.",
+      message: "dynamic route with `prerender = true` without `export const paths`",
+      details: "Prerendering needs a param list to render each path.",
       suggestions: [
-        'Tambahkan `export const paths = () => [{ id: "…" }]`',
-        "Atau hapus `prerender` agar dirender SSR saat request",
+        'Add `export const paths = () => [{ id: "…" }]`',
+        "Or remove `prerender` so the route renders at request time (SSR)",
       ],
     });
   }
 
   const raw = await (paths as () => unknown | Promise<unknown>)();
   if (!Array.isArray(raw)) {
-    throw prerenderError(route, "`paths()` harus mengembalikan array");
+    throw prerenderError(route, "`paths()` must return an array");
   }
 
   const expected = new Set(route.params);
   const result: string[] = [];
   for (const item of raw as unknown[]) {
     if (item === null || typeof item !== "object" || Array.isArray(item)) {
-      throw prerenderError(route, "item `paths()` harus objek param string");
+      throw prerenderError(route, "`paths()` items must be objects with string params");
     }
     const record = item as Record<string, unknown>;
     const keys = Object.keys(record);
     for (const name of expected) {
       const value = record[name];
       if (typeof value !== "string" || value.length === 0) {
-        throw prerenderError(route, `param \`${name}\` wajib string non-kosong`);
+        throw prerenderError(route, `param \`${name}\` must be a non-empty string`);
       }
     }
     for (const key of keys) {
       if (!expected.has(key)) {
-        throw prerenderError(route, `param \`${key}\` tidak ada di pola route`);
+        throw prerenderError(route, `param \`${key}\` is not in the route pattern`);
       }
     }
     result.push(buildPathname(route, record as Record<string, string>));
@@ -356,7 +356,7 @@ function buildPathname(route: RouteDefinition, params: Record<string, string>):
 
 function encodeSegment(route: RouteDefinition, value: string): string {
   if (value.length === 0 || /^\.+$/.test(value)) {
-    throw prerenderError(route, `nilai param \`${value}\` tidak valid untuk path file`);
+    throw prerenderError(route, `param value \`${value}\` is not valid for a file path`);
   }
   return encodeURIComponent(value);
 }
@@ -368,9 +368,9 @@ function outputFile(clientDir: string, pathname: string): string {
   if (file !== base && !file.startsWith(base + sep)) {
     throw new MoonsError({
       code: "E_PRERENDER_INVALID",
-      message: `path prerender keluar dari direktori client (\`${pathname}\`)`,
-      details: "Nama file harus berada di dalam `dist/client`.",
-      suggestions: ["Periksa nilai param `paths` — jangan memakai `..`"],
+      message: `prerender path escapes the client directory (\`${pathname}\`)`,
+      details: "The file name must stay inside `dist/client`.",
+      suggestions: ["Check the `paths` param values — do not use `..`"],
     });
   }
   return file;
@@ -381,10 +381,10 @@ function prerenderError(route: RouteDefinition, message: string): MoonsError {
     code: "E_PRERENDER_INVALID",
     file: route.file,
     message,
-    details: "Kontrak prerender mengikuti.",
+    details: "The prerender contract is enforced.",
     suggestions: [
-      "Perbaiki bentuk `paths`/param agar cocok dengan pola route",
-      "Jangan memakai `redirect()` pada route yang di-prerender",
+      "Fix the `paths`/params shape so it matches the route pattern",
+      "Do not use `redirect()` on a prerendered route",
     ],
   });
 }

package/src/server/shell.ts

@@ -14,7 +14,7 @@ export const ROOT_PLACEHOLDER = '<div id="root"></div>';
 
 export const DEFAULT_TEMPLATE = [
   "<!doctype html>",
-  '<html lang="id">',
+  '<html lang="en">',
   "<head>",
   '  <meta charset="utf-8" />',
   '  <meta name="viewport" content="width=device-width, initial-scale=1" />',
@@ -38,11 +38,11 @@ export function injectShell(
   if (!template.includes(ROOT_PLACEHOLDER)) {
     throw new MoonsError({
       code: "E_INTERNAL",
-      message: `shell HTML tidak memuat \`${ROOT_PLACEHOLDER}\``,
-      details: "index.html aplikasi wajib memuat elemen root tersebut agar SSR bisa meng-inject markup.",
+      message: `shell HTML does not contain \`${ROOT_PLACEHOLDER}\``,
+      details: "The app's index.html must contain that root element so SSR can inject markup.",
       suggestions: [
-        `Tambahkan ${ROOT_PLACEHOLDER} ke index.html`,
-        "Atau hapus index.html untuk memakai shell bawaan",
+        `Add ${ROOT_PLACEHOLDER} to index.html`,
+        "Or remove index.html to use the built-in shell",
       ],
     });
   }
@@ -119,9 +119,9 @@ export function createFileShell(options: { clientDir?: string } = {}): Shell {
         throw new MoonsError({
           code: "E_INTERNAL",
           file,
-          message: "`dist/client/index.html` tidak ditemukan",
-          details: "Build client harus dijalankan sebelum server produksi dinyalakan.",
-          suggestions: ["Jalankan `bun run build` lebih dulu"],
+          message: "`dist/client/index.html` not found",
+          details: "The client build must run before starting the production server.",
+          suggestions: ["Run `bun run build` first"],
         });
       }
       cached = readFileSync(file, "utf8");

package/src/server/shutdown.ts

@@ -36,10 +36,10 @@ export function installGracefulShutdown(
       return;
     }
     shuttingDown = true;
-    log(`[moons] menerima ${signal} — berhenti menerima koneksi, drain...`);
+    log(`[moons] received ${signal} — no longer accepting connections, draining...`);
 
     const timer = setTimeout(() => {
-      log(`[moons] drain melewati ${timeoutMs}ms — keluar paksa`);
+      log(`[moons] drain exceeded ${timeoutMs}ms — forcing exit`);
       const closeAll = (server as { closeAllConnections?: () => void }).closeAllConnections;
       try {
         closeAll?.call(server);
@@ -59,7 +59,7 @@ export function installGracefulShutdown(
     server.close(async (error?: Error) => {
       if (error !== undefined) {
         clearTimeout(timer);
-        log(`[moons] penutupan server gagal: ${error.message}`);
+        log(`[moons] server close failed: ${error.message}`);
         exit(1);
         return;
       }
@@ -70,11 +70,11 @@ export function installGracefulShutdown(
         try {
           await options.onShutdown();
         } catch (hookError) {
-          log(`[moons] onShutdown gagal: ${String(hookError)}`);
+          log(`[moons] onShutdown failed: ${String(hookError)}`);
         }
       }
       clearTimeout(timer);
-      log("[moons] shutdown selesai (drain penuh)");
+      log("[moons] shutdown complete (full drain)");
       exit(0);
     });
   };

package/src/server/storage.ts

@@ -21,7 +21,7 @@ export function createFileStorage(clientDir: string): PrerenderStorage {
     async write(pathname: string, body: Uint8Array): Promise<void> {
       const target = staticFileTarget(clientDir, pathname);
       if (target === null) {
-        throw new Error(`[moons] isr: path tidak valid untuk ditulis: ${pathname}`);
+        throw new Error(`[moons] isr: invalid path to write: ${pathname}`);
       }
       mkdirSync(dirname(target), { recursive: true });
       const tmp = `${target}.tmp-${process.pid}`;

package/src/server/test-server.ts

@@ -1,5 +1,5 @@
 import type { MoonsConfig, RouteDefinition, RouteModule } from "@moonsjs/core";
-import { createRequestHandler } from "./handler";
+import { createRequestHandler, type RequestHandlerOptions } from "./handler";
 import { DEFAULT_TEMPLATE, injectShell, type Shell } from "./shell";
 
 export interface TestServerOptions {
@@ -7,6 +7,11 @@ export interface TestServerOptions {
   config: MoonsConfig;
   routesDir: string;
   loadRoute: Record<string, () => Promise<RouteModule>>;
+  /** Endpoint `src/api` (Addendum O) — hasil scan app. */
+  apiRoutes?: RequestHandlerOptions["apiRoutes"];
+  loadApi?: RequestHandlerOptions["loadApi"];
+  apiMiddlewares?: RequestHandlerOptions["apiMiddlewares"];
+  loadApiMiddleware?: RequestHandlerOptions["loadApiMiddleware"];
   /** Default: shell in-memory dari `DEFAULT_TEMPLATE` (tanpa file). */
   shell?: Shell;
 }
@@ -34,6 +39,12 @@ export function createTestServer(
     config: options.config,
     routesDir: options.routesDir,
     loadRoute: options.loadRoute,
+    ...(options.apiRoutes === undefined ? {} : { apiRoutes: options.apiRoutes }),
+    ...(options.loadApi === undefined ? {} : { loadApi: options.loadApi }),
+    ...(options.apiMiddlewares === undefined ? {} : { apiMiddlewares: options.apiMiddlewares }),
+    ...(options.loadApiMiddleware === undefined
+      ? {}
+      : { loadApiMiddleware: options.loadApiMiddleware }),
     shell,
   });