sonamu 0.11.11 → 0.11.13

package/dist/ui-web/index.html

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/sonamu-ui/setting.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>{{projectName}}: Sonamu UI</title>
-    <script type="module" crossorigin src="/sonamu-ui/assets/index-C_RUxOdN.js"></script>
-    <link rel="stylesheet" crossorigin href="/sonamu-ui/assets/index-5i4uZVES.css">
+    <script type="module" crossorigin src="/sonamu-ui/assets/index-ClxAM2Lk.js"></script>
+    <link rel="stylesheet" crossorigin href="/sonamu-ui/assets/index-BMdIyKXS.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/utils/fs-utils.js

@@ -1,5 +1,5 @@
 import { __esmMin } from "../_virtual/_rolldown/runtime.js";
-import { formatCode, init_formatter } from "./formatter.js";
+import { formatCode, init_code_formatting } from "../code-formatting/index.js";
 import { constants } from "fs";
 import path, { dirname } from "path";
 import { access, readFile, stat, writeFile } from "fs/promises";
@@ -63,10 +63,10 @@ async function copyFileWithReplaceCoreToShared(fromPath, toPath, syncHeader) {
 	return true;
 }
 var init_fs_utils = __esmMin((() => {
-	init_formatter();
+	init_code_formatting();
 }));
 //#endregion
 init_fs_utils();
 export { copyFileWithReplaceCoreToShared, exists, fileExists, init_fs_utils };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnMtdXRpbHMuanMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2ZzLXV0aWxzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNvbnN0YW50cyB9IGZyb20gXCJmc1wiO1xuaW1wb3J0IHsgdHlwZSBQYXRoTGlrZSB9IGZyb20gXCJmc1wiO1xuaW1wb3J0IHsgYWNjZXNzLCByZWFkRmlsZSwgc3RhdCwgd3JpdGVGaWxlIH0gZnJvbSBcImZzL3Byb21pc2VzXCI7XG5pbXBvcnQgcGF0aCwgeyBkaXJuYW1lIH0gZnJvbSBcInBhdGhcIjtcblxuaW1wb3J0IHsgZm9ybWF0Q29kZSB9IGZyb20gXCIuLi9jb2RlLWZvcm1hdHRpbmdcIjtcblxuLyoqXG4gKiBmcy9wcm9taXNlc+yXkOuKlCBleGlzdHPqsIAg7JeG7Ja07JqULiDrjIDsi6AgYWNjZXNz6rCAIOyeiOyKteuLiOuLpC5cbiAqIOq3vOuNsCDslpjripQg7J247YSw7Y6Y7J207Iqk6rCAIOyTsOq4sCDrtojtjrjtlbTsmpQuIOq3uOuemOyEnCDqsJDsi7jso7zsl4jsirXri4jri6QuXG4gKiBAcGFyYW0gdGFyZ2V0UGF0aFxuICogQHJldHVybnNcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGV4aXN0cyh0YXJnZXRQYXRoOiBQYXRoTGlrZSk6IFByb21pc2U8Ym9vbGVhbj4ge1xuICB0cnkge1xuICAgIGF3YWl0IGFjY2Vzcyh0YXJnZXRQYXRoLCBjb25zdGFudHMuRl9PSyk7XG4gICAgcmV0dXJuIHRydWU7XG4gIH0gY2F0Y2gge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxufVxuXG4vLyDrlJTroInthqDrpqzqsIAg7JWE64uI6528IO2MjOydvOunjCDsobTsnqztlZjripTsp4Ag7ZmV7J247ZWp64uI64ukLlxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGZpbGVFeGlzdHModGFyZ2V0UGF0aDogUGF0aExpa2UpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgdHJ5IHtcbiAgICBjb25zdCBzdGF0cyA9IGF3YWl0IHN0YXQodGFyZ2V0UGF0aCk7XG4gICAgcmV0dXJuIHN0YXRzLmlzRmlsZSgpO1xuICB9IGNhdGNoIHtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cbn1cblxuLyoqXG4gKiDtjIzsnbzsnYQg67O17IKs7ZWY66m07IScIGBmcm9tIFwic29uYW11XCJgIGltcG9ydOulvCBzb25hbXUuc2hhcmVkLnRzIOqyveuhnOuhnCDsuZjtmZjtlanri4jri6QuXG4gKlxuICogd2Vi7J2064KYIGFwcCDrk7Hsl5DripQgc29uYW11IO2MqO2CpOyngOqwgCDsl4bsnLzrr4DroZwsIO2VqOq7mCDrs7XsgqzrkJjripQgc29uYW11LnNoYXJlZC50c+yXkOyEnCDqsIDsoLjsmKTrj4TroZ0g67OA7ZmY7ZWp64uI64ukLlxuICog64yA7IOBIO2MjOydvOydmCDsnITsuZjsl5Ag65Sw6528IOyDgeuMgCDqsr3roZzqsIAg64us65287KeR64uI64ukOlxuICogLSBzZXJ2aWNlcy9zb25hbXUuZ2VuZXJhdGVkLnRzIOKGkiAuL3NvbmFtdS5zaGFyZWRcbiAqIC0gc2VydmljZXMvdXNlci91c2VyLnR5cGVzLnRzIOKGkiAuLi9zb25hbXUuc2hhcmVkXG4gKiAtIGkxOG4va28udHMg4oaSIC4uL3NlcnZpY2VzL3NvbmFtdS5zaGFyZWRcbiAqXG4gKiB0cy90c3gg7YyM7J287J2AIOyTsOq4sCDsoITsl5Agb3hmbXQvb3hsaW50IO2VnOuyiCDrj4zroKTspI3ri4jri6QhXG4gKlxuICogQHBhcmFtIGZyb21QYXRoIOybkOuzuCDtjIzsnbwg6rK966GcXG4gKiBAcGFyYW0gdG9QYXRoIOuMgOyDgSDtjIzsnbwg6rK966GcXG4gKiBAcGFyYW0gc3luY0hlYWRlciDrj5nquLDtmZQg7IucIO2MjOydvCDstZzsg4Hri6jsl5Ag7IK97J6F7ZWgIOyjvOyEnSDruJTroZ0uIOq4sOyhtCBAZ2VuZXJhdGVkIOu4lOuhneydtCDsnojsnLzrqbQg6rWQ7LK07ZWY6rOgLCDsl4bsnLzrqbQg7LWc7IOB64uo7JeQIOy2lOqwgO2VqeuLiOuLpC5cbiAqIEByZXR1cm5zIO2MjOydvOydhCDsjbzsnLzrqbQgdHJ1ZSwg6rG064SI65uw7JeI7Jy866m0IGZhbHNlXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBjb3B5RmlsZVdpdGhSZXBsYWNlQ29yZVRvU2hhcmVkKFxuICBmcm9tUGF0aDogc3RyaW5nLFxuICB0b1BhdGg6IHN0cmluZyxcbiAgc3luY0hlYWRlcj86IHN0cmluZyxcbik6IFByb21pc2U8Ym9vbGVhbj4ge1xuICBpZiAoIShhd2FpdCBleGlzdHMoZnJvbVBhdGgpKSkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuXG4gIGNvbnN0IG9sZEZpbGVDb250ZW50ID0gKGF3YWl0IHJlYWRGaWxlKGZyb21QYXRoKSkudG9TdHJpbmcoKTtcblxuICBsZXQgbmV3RmlsZUNvbnRlbnQgPSAoKCkgPT4ge1xuICAgIC8vIHNvbmFtdS5zaGFyZWQudHPripQg7ZWt7IOBIHtiYXNlfS9zcmMvc2VydmljZXMvc29uYW11LnNoYXJlZC50c+yXkCDsnITsuZjtlanri4jri6QuXG4gICAgLy8gdG9QYXRo7JeQ7IScIC9zcmMv66W8IOywvuyVhCBzZXJ2aWNlcyDrlJTroInthqDrpqwg6rK966Gc66W8IOqzhOyCsO2VqeuLiOuLpC5cbiAgICBjb25zdCBzcmNNYXRjaCA9IHRvUGF0aC5tYXRjaCgvXiguK1xcL3NyYylcXC8vKTtcbiAgICBpZiAoIXNyY01hdGNoKSB7XG4gICAgICAvLyAvc3JjL+qwgCDsl4bsnLzrqbQg67OA7ZmYIOyXhuydtCDqt7jrjIDroZwg67CY7ZmYXG4gICAgICByZXR1cm4gb2xkRmlsZUNvbnRlbnQ7XG4gICAgfVxuXG4gICAgY29uc3Qgc2VydmljZXNEaXIgPSBwYXRoLmpvaW4oc3JjTWF0Y2hbMV0sIFwic2VydmljZXNcIik7XG4gICAgY29uc3QgZmlsZURpciA9IGRpcm5hbWUodG9QYXRoKTtcbiAgICBjb25zdCByZWxhdGl2ZVBhdGggPSBwYXRoLnJlbGF0aXZlKGZpbGVEaXIsIHNlcnZpY2VzRGlyKTtcbiAgICBjb25zdCBzaGFyZWRQYXRoID0gcmVsYXRpdmVQYXRoID09PSBcIlwiID8gXCIuL3NvbmFtdS5zaGFyZWRcIiA6IGAke3JlbGF0aXZlUGF0aH0vc29uYW11LnNoYXJlZGA7XG5cbiAgICByZXR1cm4gb2xkRmlsZUNvbnRlbnQucmVwbGFjZSgvZnJvbSBcInNvbmFtdShcXC9kaWN0KT9cIi9nLCBgZnJvbSBcIiR7c2hhcmVkUGF0aH1cImApO1xuICB9KSgpO1xuXG4gIC8vIHN5bmNIZWFkZXLqsIAg7KCc6rO165CcIOqyveyasCBAZ2VuZXJhdGVkIOu4lOuhneydhCDqtZDssrTtlZjqsbDrgpgg7LWc7IOB64uo7JeQIOy2lOqwgO2VqeuLiOuLpC5cbiAgLy8gYCovYCDsp4Htm4Tsl5DripQg7ZWt7IOBIOu5iCDspIQg7ZWcIOqwnOulvCDrs7TsnqXtlZjsl6wgb3hmbXTqsIAg7KO87ISd7J2EIGltcG9ydOydmCBsZWFkaW5nIGNvbW1lbnTroZwg7Jik7J247ZW0IOygleugrCDsi5wg64GM66Ck6rCA64qUIOusuOygnOulvCDrsKnsp4Dtlanri4jri6QuXG4gIGlmIChzeW5jSGVhZGVyKSB7XG4gICAgLy8g6riw7KG0IEBnZW5lcmF0ZWQg67iU66GdICsg65Kk7J207Ja0IOyYpOuKlCDruYgg7KSE65OkKOyeiOycvOuptCDtj6ztlagp7J2EIO2VnOq6vOuyiOyXkCDrp6Tsua3tlZjsl6wg6rWQ7LK0IOyLnCDruYgg7KSE7J20IOuIhOyggeuQmOyngCDslYrqsowg7ZWp64uI64ukLlxuICAgIC8vIO2VnCDspITsp5zrpqwoLyoqIEBnZW5lcmF0ZWQgKi8p64qUIOunpOy5re2VmOyngCDslYrsnLzrr4DroZwg7IiY64+Z7Jy866GcIOy2leyVve2VmOyngCDrp4jshLjsmpQuXG4gICAgY29uc3QgZ2VuZXJhdGVkQmxvY2tSZWdleCA9IC9cXC9cXCpcXCpcXHI/XFxuIFxcKiBAZ2VuZXJhdGVkXFxyP1xcbltcXHNcXFNdKj9cXCpcXC9cXHI/XFxuKFxccj9cXG4pKi87XG4gICAgaWYgKGdlbmVyYXRlZEJsb2NrUmVnZXgudGVzdChuZXdGaWxlQ29udGVudCkpIHtcbiAgICAgIG5ld0ZpbGVDb250ZW50ID0gbmV3RmlsZUNvbnRlbnQucmVwbGFjZShnZW5lcmF0ZWRCbG9ja1JlZ2V4LCBgJHtzeW5jSGVhZGVyfVxcblxcbmApO1xuICAgIH0gZWxzZSB7XG4gICAgICBuZXdGaWxlQ29udGVudCA9IGAke3N5bmNIZWFkZXJ9XFxuXFxuJHtuZXdGaWxlQ29udGVudH1gO1xuICAgIH1cbiAgfVxuXG4gIC8vIC50cy8udHN4IOyCsOy2nOusvOydgCDsk7DquLAg7KCE7JeQIO2PrOunt+uPhCDtlbTspJjsmpQg44WO44WOXG4gIGlmICh0b1BhdGguZW5kc1dpdGgoXCIudHNcIikgfHwgdG9QYXRoLmVuZHNXaXRoKFwiLnRzeFwiKSkge1xuICAgIG5ld0ZpbGVDb250ZW50ID0gYXdhaXQgZm9ybWF0Q29kZShuZXdGaWxlQ29udGVudCwgdG9QYXRoKTtcbiAgfVxuXG4gIGF3YWl0IHdyaXRlRmlsZSh0b1BhdGgsIG5ld0ZpbGVDb250ZW50KTtcbiAgcmV0dXJuIHRydWU7XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQWFBLGVBQXNCLE9BQU8sWUFBd0M7Q0FDbkUsSUFBSTtFQUNGLE1BQU0sT0FBTyxZQUFZLFVBQVUsSUFBSTtFQUN2QyxPQUFPO0NBQ1QsUUFBUTtFQUNOLE9BQU87Q0FDVDtBQUNGO0FBR0EsZUFBc0IsV0FBVyxZQUF3QztDQUN2RSxJQUFJO0VBRUYsUUFBTyxNQURhLEtBQUssVUFBVSxFQUM1QixDQUFNLE9BQU87Q0FDdEIsUUFBUTtFQUNOLE9BQU87Q0FDVDtBQUNGOzs7Ozs7Ozs7Ozs7Ozs7OztBQWtCQSxlQUFzQixnQ0FDcEIsVUFDQSxRQUNBLFlBQ2tCO0NBQ2xCLElBQUksQ0FBRSxNQUFNLE9BQU8sUUFBUSxHQUN6QixPQUFPO0NBR1QsTUFBTSxrQkFBa0IsTUFBTSxTQUFTLFFBQVEsRUFBQSxDQUFHLFNBQVM7Q0FFM0QsSUFBSSx3QkFBd0I7RUFHMUIsTUFBTSxXQUFXLE9BQU8sTUFBTSxjQUFjO0VBQzVDLElBQUksQ0FBQyxVQUVILE9BQU87RUFHVCxNQUFNLGNBQWMsS0FBSyxLQUFLLFNBQVMsSUFBSSxVQUFVO0VBQ3JELE1BQU0sVUFBVSxRQUFRLE1BQU07RUFDOUIsTUFBTSxlQUFlLEtBQUssU0FBUyxTQUFTLFdBQVc7RUFDdkQsTUFBTSxhQUFhLGlCQUFpQixLQUFLLG9CQUFvQixHQUFHLGFBQWE7RUFFN0UsT0FBTyxlQUFlLFFBQVEsMkJBQTJCLFNBQVMsV0FBVyxFQUFFO0NBQ2pGLEVBQUEsQ0FBRztDQUlILElBQUksWUFBWTtFQUdkLE1BQU0sc0JBQXNCO0VBQzVCLElBQUksb0JBQW9CLEtBQUssY0FBYyxHQUN6QyxpQkFBaUIsZUFBZSxRQUFRLHFCQUFxQixHQUFHLFdBQVcsS0FBSztPQUVoRixpQkFBaUIsR0FBRyxXQUFXLE1BQU07Q0FFekM7Q0FHQSxJQUFJLE9BQU8sU0FBUyxLQUFLLEtBQUssT0FBTyxTQUFTLE1BQU0sR0FDbEQsaUJBQWlCLE1BQU0sV0FBVyxnQkFBZ0IsTUFBTTtDQUcxRCxNQUFNLFVBQVUsUUFBUSxjQUFjO0NBQ3RDLE9BQU87QUFDVDs7c0JBM0YrQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.11.11",
+  "version": "0.11.13",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "framework",
@@ -104,7 +104,7 @@
     "@logtape/pretty": "2.2.2",
     "@logtape/redaction": "2.2.2",
     "@sheetkit/node": "^0.5.0",
-    "@sonamu-kit/hmr-hook": "^0.5.1",
+    "@sonamu-kit/hmr-hook": "^0.6.0",
     "@sonamu-kit/hmr-runner": "^0.2.0",
     "@sonamu-kit/tasks": "^0.3.1",
     "@sonamu-kit/ts-loader": "^2.2.0",
@@ -129,7 +129,7 @@
     "node-cron": "^4.2.1",
     "node-sql-parser": "^5.2.0",
     "oxfmt": "^0.55.0",
-    "oxlint": "1.80.0",
+    "oxlint": "1.86.0",
     "pg": "^8.16.3",
     "prompts": "^2.4.2",
     "qs": "^6.14.1",

package/src/code-formatting/__tests__/formatter-batching.test.ts

@@ -0,0 +1,210 @@
+import { access, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import * as processUtils from "../../utils/process-utils";
+import { formatCode } from "../index";
+
+const OXLINT_FLAGS = ["--fix", "--fix-suggestions", "--type-aware"];
+const FIXED_SUFFIX = "// oxlint 적용\n";
+
+let testDirectory = "";
+
+function createGate() {
+  let open = () => {};
+  const promise = new Promise<void>((resolve) => {
+    open = resolve;
+  });
+  return { open, promise };
+}
+
+function extractTemporaryFiles(args: string[]): string[] {
+  return args.slice(OXLINT_FLAGS.length);
+}
+
+async function listTemporaryFiles(): Promise<string[]> {
+  const entries = await readdir(testDirectory, { withFileTypes: true });
+  return entries
+    .filter(
+      (entry) => entry.isFile() && entry.name.startsWith(".sonamu-") && entry.name.endsWith(".ts"),
+    )
+    .map((entry) => path.join(testDirectory, entry.name));
+}
+
+async function waitForTemporaryFiles(count: number): Promise<void> {
+  await vi.waitFor(async () => {
+    const paths = await listTemporaryFiles();
+    expect(paths).toHaveLength(count);
+    const contents = await Promise.all(paths.map((filePath) => readFile(filePath, "utf8")));
+    contents.forEach((content) => expect(content.length).toBeGreaterThan(0));
+  });
+
+  // 완료된 파일 쓰기의 후속 continuation까지 실행해 대기열 구성을 확정합니다.
+  await new Promise<void>((resolve) => setImmediate(resolve));
+}
+
+async function applyFixes(args: string[]): Promise<void> {
+  await Promise.all(
+    extractTemporaryFiles(args).map(async (filePath) => {
+      const source = await readFile(filePath, "utf8");
+      await writeFile(filePath, `${source}${FIXED_SUFFIX}`, "utf8");
+    }),
+  );
+}
+
+async function expectTemporaryFilesRemoved(filePaths: string[]): Promise<void> {
+  await Promise.all(
+    filePaths.map(async (filePath) => {
+      await expect(access(filePath)).rejects.toMatchObject({ code: "ENOENT" });
+    }),
+  );
+}
+
+beforeEach(async () => {
+  vi.restoreAllMocks();
+  vi.unstubAllEnvs();
+  vi.stubEnv("NODE_ENV", "development");
+  testDirectory = await mkdtemp(path.join(os.tmpdir(), "sonamu-formatter-batching-"));
+  vi.spyOn(process, "cwd").mockReturnValue(testDirectory);
+});
+
+afterEach(async () => {
+  vi.restoreAllMocks();
+  vi.unstubAllEnvs();
+  await rm(testDirectory, { recursive: true, force: true });
+});
+
+describe("formatter oxlint 내부 배칭", () => {
+  it("동시 호출을 소수 배치로 합치고 한 번에 한 프로세스만 실행하며 호출별 결과를 반환한다", async () => {
+    const releaseExecutions = createGate();
+    const firstExecutionStarted = createGate();
+    const batches: string[][] = [];
+    let activeExecutions = 0;
+    let maxActiveExecutions = 0;
+
+    vi.spyOn(processUtils, "execute").mockImplementation(
+      async (_bin: string, args: string[], options) => {
+        batches.push(extractTemporaryFiles(args));
+        activeExecutions += 1;
+        maxActiveExecutions = Math.max(maxActiveExecutions, activeExecutions);
+        firstExecutionStarted.open();
+        try {
+          expect(args.slice(0, OXLINT_FLAGS.length)).toEqual(OXLINT_FLAGS);
+          expect(options?.timeout).toBe(10_000);
+          await releaseExecutions.promise;
+          await applyFixes(args);
+          return "";
+        } finally {
+          activeExecutions -= 1;
+        }
+      },
+    );
+
+    const inputs = Array.from(
+      { length: 8 },
+      (_, index) => `const formatterBatchingValue${index} = ${index};\n`,
+    );
+    const results = inputs.map((code, index) => formatCode(code, `generated-${index}.ts`));
+
+    await firstExecutionStarted.promise;
+    await waitForTemporaryFiles(inputs.length);
+    releaseExecutions.open();
+
+    await expect(Promise.all(results)).resolves.toEqual(
+      inputs.map((code) => `${code}${FIXED_SUFFIX}`),
+    );
+
+    expect(batches).toHaveLength(2);
+    expect(batches.flat()).toHaveLength(inputs.length);
+    expect(maxActiveExecutions).toBe(1);
+    await expectTemporaryFilesRemoved(batches.flat());
+  });
+
+  it("실패한 배치의 호출자만 거부하고 실행 중 쌓인 다음 배치는 정상 처리한다", async () => {
+    const firstExecution = createGate();
+    const firstExecutionStarted = createGate();
+    const failingExecution = createGate();
+    const succeedingExecutions = createGate();
+    const secondExecutionStarted = createGate();
+    const batchError = Object.assign(new Error("oxlint 실행 실패"), { code: null });
+    const batches: string[][] = [];
+
+    vi.spyOn(processUtils, "execute").mockImplementation(async (_bin: string, args: string[]) => {
+      const batchIndex = batches.length;
+      batches.push(extractTemporaryFiles(args));
+      if (batchIndex === 0) {
+        firstExecutionStarted.open();
+        await firstExecution.promise;
+        await applyFixes(args);
+        return "";
+      }
+      if (batchIndex === 1) {
+        secondExecutionStarted.open();
+        await failingExecution.promise;
+        throw batchError;
+      }
+      await succeedingExecutions.promise;
+      await applyFixes(args);
+      return "";
+    });
+
+    const firstCode = "const formatterBatchingFirst = 1;\n";
+    const firstResult = formatCode(firstCode, "first-batch.ts");
+    await firstExecutionStarted.promise;
+    await waitForTemporaryFiles(1);
+
+    const failedCodes = [
+      "const formatterBatchingFailedA = 2;\n",
+      "const formatterBatchingFailedB = 3;\n",
+    ];
+    const failedResults = failedCodes.map((code, index) => formatCode(code, `failed-${index}.ts`));
+    const failedOutcomes = Promise.allSettled(failedResults);
+    await waitForTemporaryFiles(3);
+    firstExecution.open();
+    await secondExecutionStarted.promise;
+
+    const recoveryCode = "const formatterBatchingRecovered = 4;\n";
+    const recoveryResult = formatCode(recoveryCode, "recovered.ts");
+    await waitForTemporaryFiles(3);
+    failingExecution.open();
+    succeedingExecutions.open();
+
+    await expect(firstResult).resolves.toBe(`${firstCode}${FIXED_SUFFIX}`);
+    await expect(failedOutcomes).resolves.toEqual(
+      failedCodes.map(() => ({ reason: batchError, status: "rejected" })),
+    );
+    await expect(recoveryResult).resolves.toBe(`${recoveryCode}${FIXED_SUFFIX}`);
+
+    expect(batches.map((batch) => batch.length)).toEqual([1, 2, 1]);
+    await expectTemporaryFilesRemoved(batches.flat());
+  });
+
+  it("숫자 exit code이면 적용된 fix를 반환하고 임시 파일을 정리한다", async () => {
+    const lintError = Object.assign(new Error("수정 후 lint 오류가 남음"), { code: 1 });
+    let temporaryFile = "";
+    const execute = vi.spyOn(processUtils, "execute").mockImplementation(async (_bin, args) => {
+      [temporaryFile] = extractTemporaryFiles(args);
+      await applyFixes(args);
+      throw lintError;
+    });
+
+    const code = "const formatterBatchingNumericExit = 1;\n";
+
+    await expect(formatCode(code, "numeric-exit.ts")).resolves.toBe(`${code}${FIXED_SUFFIX}`);
+    expect(execute).toHaveBeenCalledTimes(1);
+    await expectTemporaryFilesRemoved([temporaryFile]);
+  });
+
+  it("테스트 환경에서는 파일이나 프로세스를 사용하지 않고 원본을 반환한다", async () => {
+    vi.stubEnv("NODE_ENV", "test");
+    const execute = vi.spyOn(processUtils, "execute");
+    const code = "const formatterBatchingTestBypass = 1;\n";
+
+    await expect(formatCode(code, "test-bypass.ts")).resolves.toBe(code);
+
+    expect(execute).not.toHaveBeenCalled();
+    await expect(listTemporaryFiles()).resolves.toEqual([]);
+  });
+});

package/src/{utils → code-formatting}/__tests__/formatter-bin.test.ts

@@ -7,7 +7,7 @@ import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { z } from "zod";
 
-import { resolveOxlintBin } from "../formatter";
+import { resolveOxlintBin } from "../oxlint";
 
 const OxlintManifestSchema = z
   .union([
@@ -39,7 +39,7 @@ afterEach(async () => {
 
 describe("oxlint 실행 파일 해석 회귀", () => {
   it("설치된 패키지 manifest에서 실행 가능한 로컬 절대 경로를 반환한다", async () => {
-    const requireFromFormatter = createRequire(new URL("../formatter.ts", import.meta.url));
+    const requireFromFormatter = createRequire(new URL("../oxlint.ts", import.meta.url));
     const manifestPath = requireFromFormatter.resolve("oxlint/package.json");
     const manifest = OxlintManifestSchema.parse(JSON.parse(await readFile(manifestPath, "utf8")));
     const expectedBin = path.resolve(path.dirname(manifestPath), manifest.bin);

package/src/code-formatting/index.ts

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+
+import { cached } from "../utils/async-utils";
+import { runOxfmt } from "./oxfmt";
+import { runOxlint } from "./oxlint";
+
+/**
+ * 코드를 프로젝트의 oxfmt + oxlint 설정에 맞춰 포매팅한 문자열을 반환합니다.
+ *
+ * 캐싱도 있어요 ㅎㅎ 똑같은 입력에 대해서 캐시 커버됩니다.
+ * 수명은 프로세스 죽을때까지 ㅋ
+ */
+export const formatCode = cached(formatCodeInternal, (code, filePath) => {
+  const ext = filePath.endsWith(".tsx") ? "tsx" : filePath.endsWith(".json") ? "json" : "ts";
+  return `${ext}:${createHash("sha1").update(code).digest("hex")}`;
+});
+
+/**
+ * 캐시 없는 포맷함수 엔트리.
+ */
+async function formatCodeInternal(code: string, filePath: string): Promise<string> {
+  // json은 포맷만 하면 됩니다.
+  if (filePath.endsWith(".json")) {
+    return runOxfmt(code, filePath);
+  }
+
+  // 린트 먼저 한 다음에 포맷으로 마무리해요.
+  return runOxfmt(await runOxlint(code), filePath);
+}

package/src/code-formatting/oxfmt.ts

@@ -0,0 +1,63 @@
+import { readFile } from "node:fs/promises";
+import path, { dirname, join } from "node:path";
+
+import { format, type FormatConfig } from "oxfmt";
+
+import { isTest } from "../utils/controller";
+
+/**
+ * 프로젝트 설정을 찾아서 이에 맞춰서 코드를 포맷합니다.
+ */
+export async function runOxfmt(code: string, filePath: string): Promise<string> {
+  const result = await format(path.basename(filePath), code, await loadOxfmtConfig());
+
+  const errors = result.errors.filter((e) => e.severity === "Error");
+  if (errors.length > 0) {
+    if (!isTest()) {
+      console.error(`oxfmt errors (${filePath}):`);
+      for (const err of errors) {
+        const label = err.labels[0];
+        if (label) {
+          const before = code.slice(Math.max(0, label.start - 80), label.start);
+          const at = code.slice(label.start, label.end);
+          const after = code.slice(label.end, Math.min(code.length, label.end + 80));
+          console.error(`  - ${err.message} (offset ${label.start}-${label.end})`);
+          console.error(`    around: ...${before}»${at}«${after}...`);
+        } else {
+          console.error(`  - ${err.message}`);
+        }
+      }
+    }
+    return code;
+  }
+  return result.code;
+}
+
+let cachedOxfmtConfig: FormatConfig | null = null;
+async function loadOxfmtConfig(): Promise<FormatConfig> {
+  if (cachedOxfmtConfig !== null) {
+    return cachedOxfmtConfig;
+  }
+
+  let dir = process.cwd();
+  while (true) {
+    const candidate = join(dir, ".oxfmtrc.json");
+    try {
+      // SAFETY: 선행 분기와 함수 계약이 이 타입을 보장합니다.
+      cachedOxfmtConfig = JSON.parse(await readFile(candidate, "utf-8")) as FormatConfig;
+      return cachedOxfmtConfig;
+    } catch (e) {
+      // SAFETY: 선행 분기와 함수 계약이 이 타입을 보장합니다.
+      if ((e as NodeJS.ErrnoException).code !== "ENOENT") {
+        !isTest() && console.error(`Failed to load ${candidate}:`, e);
+        break;
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  cachedOxfmtConfig = {};
+  return cachedOxfmtConfig;
+}

package/src/{utils/formatter.ts → code-formatting/oxlint.ts}

@@ -1,4 +1,3 @@
-import { createHash } from "node:crypto";
 // 테스트 환경에서는 fs/promises가 mock되지만, 아래 runOxlint이 isTest 가드로 안 도니까
 // 그냥 fs/promises 그대로 사용. (production에서만 임시파일 흐름이 돕니다.)
 import { constants } from "node:fs";
@@ -6,13 +5,11 @@ import { access, readFile, unlink, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import path, { dirname, join } from "node:path";
 
-import { format, type FormatConfig } from "oxfmt";
 import { z } from "zod";
 
-import { cached } from "./async-utils";
-import { isTest } from "./controller";
-import { execute } from "./process-utils";
-import { isNumberValue } from "./runtime-value";
+import { isTest } from "../utils/controller";
+import { execute } from "../utils/process-utils";
+import { isNumberValue } from "../utils/runtime-value";
 
 const requireFromHere = createRequire(import.meta.url);
 
@@ -27,86 +24,16 @@ const OxlintNamedBinManifestSchema = z.object({
   bin: z.object({ oxlint: z.string().trim().min(1) }),
 });
 
-/**
- * 코드를 프로젝트의 oxfmt + oxlint 설정에 맞춰 포매팅한 문자열을 반환합니다.
- *
- * 캐싱도 있어요 ㅎㅎ 똑같은 입력에 대해서 캐시 커버됩니다.
- * 수명은 프로세스 죽을때까지 ㅋ
- */
-export const formatCode = cached(formatCodeInternal, (code, filePath) => {
-  const ext = filePath.endsWith(".tsx") ? "tsx" : filePath.endsWith(".json") ? "json" : "ts";
-  return `${ext}:${createHash("sha1").update(code).digest("hex")}`;
-});
+type OxlintRequest = {
+  tmpFile: string;
+  resolve: () => void;
+  reject: (error: OxlintError) => void;
+};
 
-/**
- * 캐시 없는 포맷함수 엔트리.
- */
-async function formatCodeInternal(code: string, filePath: string): Promise<string> {
-  // json은 포맷만 하면 됩니다.
-  if (filePath.endsWith(".json")) {
-    return runOxfmt(code, filePath);
-  }
+type OxlintError = Error & { code?: string | number | null };
 
-  // 린트 먼저 한 다음에 포맷으로 마무리해요.
-  return runOxfmt(await runOxlint(code), filePath);
-}
-
-/**
- * 프로젝트 설정을 찾아서 이에 맞춰서 코드를 포맷합니다.
- */
-async function runOxfmt(code: string, filePath: string): Promise<string> {
-  const result = await format(path.basename(filePath), code, await loadOxfmtConfig());
-
-  const errors = result.errors.filter((e) => e.severity === "Error");
-  if (errors.length > 0) {
-    if (!isTest()) {
-      console.error(`oxfmt errors (${filePath}):`);
-      for (const err of errors) {
-        const label = err.labels[0];
-        if (label) {
-          const before = code.slice(Math.max(0, label.start - 80), label.start);
-          const at = code.slice(label.start, label.end);
-          const after = code.slice(label.end, Math.min(code.length, label.end + 80));
-          console.error(`  - ${err.message} (offset ${label.start}-${label.end})`);
-          console.error(`    around: ...${before}»${at}«${after}...`);
-        } else {
-          console.error(`  - ${err.message}`);
-        }
-      }
-    }
-    return code;
-  }
-  return result.code;
-}
-
-let cachedOxfmtConfig: FormatConfig | null = null;
-async function loadOxfmtConfig(): Promise<FormatConfig> {
-  if (cachedOxfmtConfig !== null) {
-    return cachedOxfmtConfig;
-  }
-
-  let dir = process.cwd();
-  while (true) {
-    const candidate = join(dir, ".oxfmtrc.json");
-    try {
-      // SAFETY: 선행 분기와 함수 계약이 이 타입을 보장합니다.
-      cachedOxfmtConfig = JSON.parse(await readFile(candidate, "utf-8")) as FormatConfig;
-      return cachedOxfmtConfig;
-    } catch (e) {
-      // SAFETY: 선행 분기와 함수 계약이 이 타입을 보장합니다.
-      if ((e as NodeJS.ErrnoException).code !== "ENOENT") {
-        !isTest() && console.error(`Failed to load ${candidate}:`, e);
-        break;
-      }
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-
-  cachedOxfmtConfig = {};
-  return cachedOxfmtConfig;
-}
+const oxlintQueue: OxlintRequest[] = [];
+let isOxlintRunning = false;
 
 /**
  * 프로젝트 설정에 맞춰 코드를 lint합니다.
@@ -114,8 +41,23 @@ async function loadOxfmtConfig(): Promise<FormatConfig> {
  * 프로젝트 설정을 적용받는 oxlint cli를 찾아 띄워서,
  * 임시 파일에 in-place로 써서 그 결과를 빼오는 방식으로 작동합니다.
  * 왜 이렇게 하느냐? oxlint가 node api도 안 주고 cli에서 stdin 옵션도 안 주기 때문...
+ *
+ * 그런데 이 친구는 호출할 때마다 무지성으로 oxlint cli를 돌리지는 않습니다.
+ * 그런 식으로 했다가는 oxlint 프로세스만 동시에 수십 개가 떠 있게 될 수도 있어요.
+ * 그러다가 sync에서 파일 생성이 10초도 넘게 걸리는 일도 있었습니다.
+ * 이를 막기 위해, oxlint가 돌아가고 있을 때에 새 runOxlint 호출이 들어오면 내부에서 알아서 잘 쟁여놨다가 실행 끝나면 배치로 굴립니다.
+ * 한 번에 오직 하나의 oxlint cli 실행만 돌아가게 하는 겁니다.
+ *
+ * 자세한 배칭 전략:
+ * - 아무 것도 없을 때에 호출되면 바로 oxlint 실행합니다.
+ * - oxlint 실행 중에 들어오면 큐에 쟁여둡니다.
+ * - oxlint 실행 완료 시점에서 큐에 뭐가 있으면 그걸로 다음 배치 바로 실행합니다.
+ *
+ * 그래서 띄엄띄엄 하나씩 들어오면 그냥 순차 실행과 다름이 없고, 여러개 우루루 들어오면 그때 효용이 생깁니다.
+ * 다만 동시에 30개가 한번에 들어온다고 30개가 모두 한 배치를 타지는 않고,
+ * idle에서의 첫 요청에 즉시 배치를 시작하므로 최소 2배치가 소요된다는 점 주의염.
  */
-async function runOxlint(code: string): Promise<string> {
+export async function runOxlint(code: string): Promise<string> {
   if (isTest()) {
     // 테스트 환경에서는 느려지기만 하고 검증할 가치도 없어서 안 합니다.
     // GitHub Actions 환경에서 lint가 오래 걸려서 뻗기도 했어요. (https://github.com/cartanova-ai/sonamu/actions/runs/25267214027/job/74083630169)
@@ -125,34 +67,64 @@ async function runOxlint(code: string): Promise<string> {
   const tmpFile = join(
     // 타겟 파일이 루트 아래에 있어야 해요. 그래서 tmp 디렉토리같은거 안 씁니다!
     process.cwd(),
-    `.sonamu-fmt-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`,
+    `.sonamu-oxlint-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`,
   );
 
   try {
     await writeFile(tmpFile, code, "utf-8");
+    await enqueueOxlint(tmpFile);
+    return await readFile(tmpFile, "utf-8");
+  } finally {
+    try {
+      await unlink(tmpFile);
+    } catch {
+      // 삭제 실패해도 어차피 ignore됨.
+    }
+  }
+}
+
+function enqueueOxlint(tmpFile: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    oxlintQueue.push({ tmpFile, resolve, reject });
+    if (!isOxlintRunning) {
+      void flushOxlintQueue();
+    }
+  });
+}
+
+async function flushOxlintQueue(): Promise<void> {
+  if (isOxlintRunning || oxlintQueue.length === 0) {
+    return;
+  }
+
+  isOxlintRunning = true;
+  // 실행을 시작할 때까지 준비된 파일만 묶어 다음 요청은 후속 배치로 넘깁니다.
+  const batch = oxlintQueue.splice(0);
 
+  try {
     try {
       await execute(
         await resolveOxlintBin(),
-        ["--fix", "--fix-suggestions", "--type-aware", tmpFile],
+        ["--fix", "--fix-suggestions", "--type-aware", ...batch.map(({ tmpFile }) => tmpFile)],
         {
           timeout: 10000,
         },
       );
     } catch (e) {
-      // lint 위반 시 exit code != 0이지만 --fix는 적용됨. exec 자체 실패만 throw.
+      // lint 위반 시 exit code != 0이지만 --fix는 적용됨. exec 자체 실패만 배치 전체에 전달합니다.
       // SAFETY: 선행 분기와 함수 계약이 이 타입을 보장합니다.
-      if (!isNumberValue((e as Error & { code?: number }).code)) {
-        throw e;
+      const error = e as OxlintError;
+      if (!isNumberValue(error.code)) {
+        batch.forEach(({ reject }) => reject(error));
+        return;
       }
     }
 
-    return await readFile(tmpFile, "utf-8");
+    batch.forEach(({ resolve }) => resolve());
   } finally {
-    try {
-      await unlink(tmpFile);
-    } catch {
-      // 삭제 실패해도 어차피 ignore됨.
+    isOxlintRunning = false;
+    if (oxlintQueue.length > 0) {
+      void flushOxlintQueue();
     }
   }
 }

package/src/dict/sonamu-dictionary.ts

@@ -6,9 +6,9 @@ import { Workbook } from "@sheetkit/node";
 import ts from "@typescript/typescript6";
 
 import { Sonamu } from "../api/sonamu";
+import { formatCode } from "../code-formatting";
 import { EntityManager } from "../entity/entity-manager";
 import { BadRequestException } from "../exceptions/so-exceptions";
-import { formatCode } from "../utils/formatter";
 import { SD } from "./sd";
 import {
   type DictEntry,

package/src/entity/entity.ts

@@ -7,6 +7,7 @@ import { group, unique } from "radashi";
 import { z } from "zod";
 
 import { Sonamu } from "../api/sonamu";
+import { formatCode } from "../code-formatting";
 import {
   getEnumDefValues,
   getSubsetFields,
@@ -33,7 +34,6 @@ import {
   type SubsetQuery,
 } from "../types/types";
 import { importMembers } from "../utils/esm-utils";
-import { formatCode } from "../utils/formatter";
 import { exists } from "../utils/fs-utils";
 import { runtimePath } from "../utils/path-utils";
 import { isStringValue } from "../utils/runtime-value";

package/src/migration/code-generation.ts

@@ -2,6 +2,7 @@ import equal from "fast-deep-equal";
 import { type Knex } from "knex";
 import { alphabetical, diff } from "radashi";
 
+import { formatCode } from "../code-formatting";
 import { EntityManager } from "../entity/entity-manager";
 import { Naite } from "../naite/naite";
 import {
@@ -13,7 +14,6 @@ import {
   type MigrationSet,
 } from "../types/types";
 import { isSearchTextProp } from "../types/types";
-import { formatCode } from "../utils/formatter";
 import { isStringValue } from "../utils/runtime-value";
 import { differenceWith, intersectionBy } from "../utils/utils";
 import {