freelang-editor 11.7.4

package/src/__tests__/special-forms-advanced.test.ts

@@ -0,0 +1,106 @@
+// v11.7: eval-special-forms 심화 테스트 (v11 실제 지원 패턴만)
+
+import { lex } from "../lexer";
+import { Parser } from "../parser";
+import { Interpreter } from "../interpreter";
+
+beforeAll(() => { jest.useFakeTimers(); });
+afterAll(() => { jest.useRealTimers(); });
+
+function run(source: string): any {
+  const tokens = lex(source);
+  const ast = new Parser(tokens).parse();
+  return new Interpreter().interpret(ast).lastValue;
+}
+
+describe("define — 변수/함수", () => {
+  test("define 변수 + 사용", () => {
+    expect(run("(define x 42) (+ $x 0)")).toBe(42);
+  });
+  test("define 함수 3-arg + 호출", () => {
+    expect(run("(define triple [$x] (* $x 3)) (triple 4)")).toBe(12);
+  });
+});
+
+describe("set!", () => {
+  test("기존 변수 재할당", () => {
+    expect(run("(define x 1) (set! $x 99) (+ $x 0)")).toBe(99);
+  });
+});
+
+describe("do / begin", () => {
+  test("do: 마지막 값 반환", () => {
+    expect(run("(do 1 2 3 4 5)")).toBe(5);
+  });
+  test("begin: 동일 동작", () => {
+    expect(run("(begin (define x 10) (+ $x 0))")).toBe(10);
+  });
+});
+
+describe("v11.1 defn + 호출", () => {
+  test("defn $-params", () => {
+    expect(run("(defn double [$x] (* $x 2)) (double 21)")).toBe(42);
+  });
+  test("defn bare symbol", () => {
+    expect(run("(defn sq [x] (* x x)) (sq 7)")).toBe(49);
+  });
+  test("defn with multiple params", () => {
+    expect(run("(defn add3 [a b c] (+ a b c)) (add3 10 20 30)")).toBe(60);
+  });
+});
+
+describe("let 스코프", () => {
+  test("let 외부 define 접근", () => {
+    expect(run(`
+      (define a 10)
+      (let [b 5] (+ a b))
+    `)).toBe(15);
+  });
+  test("let 중첩", () => {
+    expect(run("(let [x 1] (let [y 2] (+ x y)))")).toBe(3);
+  });
+});
+
+describe("and / or / not", () => {
+  test("and false 단락", () => {
+    expect(run("(and true false true)")).toBe(false);
+  });
+  test("or true 단락", () => {
+    expect(run("(or false true false)")).toBe(true);
+  });
+  test("not", () => {
+    expect(run("(not false)")).toBe(true);
+  });
+});
+
+describe("cond 다중 분기", () => {
+  test("cond first-match", () => {
+    expect(run(`
+      (define grade 85)
+      (cond
+        [(>= $grade 90) "A"]
+        [(>= $grade 80) "B"]
+        [(>= $grade 70) "C"]
+        [true "F"])
+    `)).toBe("B");
+  });
+  test("cond 기본값", () => {
+    expect(run("(cond [false 1] [false 2] [true 99])")).toBe(99);
+  });
+});
+
+describe("v11.1 — fn via define", () => {
+  test("fn 저장 후 호출", () => {
+    expect(run("(define f (fn [$x] (+ $x 10))) (f 5)")).toBe(15);
+  });
+  test("fn 다수 인자", () => {
+    expect(run("(define g (fn [$a $b $c] (+ $a $b $c))) (g 1 2 3)")).toBe(6);
+  });
+  test("fn closure", () => {
+    expect(run(`
+      (define make-adder (fn [$n] (fn [$x] (+ $x $n))))
+      (define add10 (make-adder 10))
+      (add10 5)
+    `)).toBe(15);
+  });
+});

package/src/__tests__/stdlib-crypto-rsa.test.ts

@@ -0,0 +1,122 @@
+// Phase A.1 — RSA / RS256 primitive 테스트 (dclub-auth)
+//
+// self/stdlib/crypto.fl:28-35 stub과 정합하는 TS 빌트인이
+// 자가 서명·검증, 변조 거부, JWK 직렬화, 외부 호환성을 만족하는지 검증.
+
+import { lex } from "../lexer";
+import { Parser } from "../parser";
+import { Interpreter } from "../interpreter";
+import { createCryptoRsaModule } from "../stdlib-crypto-rsa";
+import {
+  createSign,
+  createVerify,
+  generateKeyPairSync,
+} from "crypto";
+
+function run(source: string): any {
+  const tokens = lex(source);
+  const ast = new Parser(tokens).parse();
+  const interp = new Interpreter();
+  interp.registerModule(createCryptoRsaModule());
+  return interp.interpret(ast).lastValue;
+}
+
+describe("stdlib-crypto-rsa (RS256)", () => {
+  test("crypto_rsa_generate → publicKey/privateKey PEM", () => {
+    const result = run(`
+      (define keys (crypto_rsa_generate 2048))
+      (get $keys "publicKey")
+    `);
+    expect(typeof result).toBe("string");
+    expect(result).toContain("-----BEGIN PUBLIC KEY-----");
+    expect(result).toContain("-----END PUBLIC KEY-----");
+  });
+
+  test("sign/verify 라운드트립 PASS", () => {
+    const ok = run(`
+      (define keys (crypto_rsa_generate 2048))
+      (define sig  (crypto_rsa_sign  (get $keys "privateKey") "hello-rs256"))
+      (crypto_rsa_verify (get $keys "publicKey") "hello-rs256" $sig)
+    `);
+    expect(ok).toBe(true);
+  });
+
+  test("변조된 데이터는 검증 실패", () => {
+    const ok = run(`
+      (define keys (crypto_rsa_generate 2048))
+      (define sig  (crypto_rsa_sign  (get $keys "privateKey") "original"))
+      (crypto_rsa_verify (get $keys "publicKey") "tampered" $sig)
+    `);
+    expect(ok).toBe(false);
+  });
+
+  test("다른 키쌍의 공개키로 검증 시 실패", () => {
+    const ok = run(`
+      (define keysA (crypto_rsa_generate 2048))
+      (define keysB (crypto_rsa_generate 2048))
+      (define sig   (crypto_rsa_sign (get $keysA "privateKey") "data"))
+      (crypto_rsa_verify (get $keysB "publicKey") "data" $sig)
+    `);
+    expect(ok).toBe(false);
+  });
+
+  test("JWK 출력에 RS256 필수 필드 모두 존재", () => {
+    const fields = run(`
+      (let [keys (crypto_rsa_generate 2048)
+            jwk  (crypto_rsa_public_to_jwk (get $keys "publicKey") "key-1")]
+        [(get $jwk "kty")
+         (get $jwk "alg")
+         (get $jwk "use")
+         (get $jwk "kid")
+         (get $jwk "n")
+         (get $jwk "e")])
+    `);
+    expect(fields[0]).toBe("RSA");
+    expect(fields[1]).toBe("RS256");
+    expect(fields[2]).toBe("sig");
+    expect(fields[3]).toBe("key-1");
+    expect(typeof fields[4]).toBe("string");
+    expect(fields[4].length).toBeGreaterThan(100);
+    expect(typeof fields[5]).toBe("string");
+    expect(fields[5].length).toBeGreaterThan(0);
+  });
+
+  test("외부 Node crypto로 서명한 것을 우리가 검증 가능 (cross-verify)", () => {
+    const { publicKey, privateKey } = generateKeyPairSync("rsa", {
+      modulusLength: 2048,
+      publicKeyEncoding: { type: "spki", format: "pem" },
+      privateKeyEncoding: { type: "pkcs8", format: "pem" },
+    });
+    const data = "external-signed";
+    const signer = createSign("RSA-SHA256");
+    signer.update(data);
+    signer.end();
+    const sigB64Url = signer.sign(privateKey).toString("base64url");
+
+    const ok = run(`
+      (crypto_rsa_verify ${JSON.stringify(publicKey)} ${JSON.stringify(data)} ${JSON.stringify(sigB64Url)})
+    `);
+    expect(ok).toBe(true);
+  });
+
+  test("우리가 서명한 것을 외부 Node crypto가 검증 가능 (cross-sign)", () => {
+    const result = run(`
+      (let [keys (crypto_rsa_generate 2048)
+            sig  (crypto_rsa_sign (get $keys "privateKey") "ours")]
+        [(get $keys "publicKey") $sig])
+    `);
+    const [pub, sig] = result;
+    const verifier = createVerify("RSA-SHA256");
+    verifier.update("ours");
+    verifier.end();
+    expect(verifier.verify(pub, Buffer.from(sig, "base64url"))).toBe(true);
+  });
+
+  test("base64url_decode 라운드트립", () => {
+    const result = run(`
+      (define encoded (base64url_encode "hello world"))
+      (base64url_decode $encoded)
+    `);
+    expect(result).toBe("hello world");
+  });
+});

package/src/__tests__/stdlib-f4.test.ts

@@ -0,0 +1,159 @@
+// stdlib-f4.test.ts — Phase F-4 테스트
+
+import { execSync } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+
+describe("stdlib-f4: Phase F-4 모듈 검증", () => {
+  const bootstrapPath = path.join(__dirname, "../../bootstrap.js");
+  let counter = 0;
+
+  const run = (code: string): any => {
+    const tmpFile = path.join(os.tmpdir(), `fl-f4-${Date.now()}-${counter++}.fl`);
+    fs.writeFileSync(tmpFile, `(json-str ${code})`);
+    try {
+      const out = execSync(`node ${bootstrapPath} run ${tmpFile}`, {
+        encoding: "utf-8", timeout: 5000
+      }).trim();
+      return JSON.parse(out);
+    } finally {
+      fs.unlinkSync(tmpFile);
+    }
+  };
+
+  // ── optional 모듈 ────────────────────────────────────────────────
+  describe("optional: 선택적 npm 브릿지", () => {
+    it("require_optional: 존재하는 모듈 → true", () => {
+      expect(run(`(require_optional "path")`)).toBe(true);
+    });
+
+    it("require_optional: 없는 모듈 → false", () => {
+      expect(run(`(require_optional "nonexistent-module-xyz-abc")`)).toBe(false);
+    });
+
+    it("optional_has?: path 존재 → true", () => {
+      expect(run(`(optional_has? "path")`)).toBe(true);
+    });
+
+    it("optional_fn: path.join 사용 가능", () => {
+      const result = run(`
+        (let [[$join (optional_fn "path" "join")]]
+          (if (= $join nil) false true))
+      `);
+      expect(result).toBe(true);
+    });
+  });
+
+  // ── rest-crud 모듈 ────────────────────────────────────────────────
+  describe("rest-crud: REST 라우팅 매크로", () => {
+    it("route_info: 기본 경로 분석", () => {
+      const result = run(`(route_info "/users")`) as any;
+      expect(result.base).toBe("/users");
+      expect(result.param_name).toBe("user_id");
+      expect(result.collection_path).toBe("/users");
+      expect(result.item_path).toBe("/users/:user_id");
+    });
+
+    it("rest_crud: list+get handler → 2개 라우트", () => {
+      const result = run(`
+        (rest_crud "/posts"
+          {"list" (fn [r] "list") "get" (fn [r] "get")})
+      `) as any[];
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(2);
+      const methods = result.map((r: any) => r.method);
+      expect(methods).toContain("GET");
+    });
+
+    it("rest_ok: 200 응답", () => {
+      const result = run(`(rest_ok {"id" 1 "name" "test"})`) as any;
+      expect(result.status).toBe(200);
+      expect(result.body.id).toBe(1);
+    });
+
+    it("rest_created: 201 응답", () => {
+      const result = run(`(rest_created {"id" 42})`) as any;
+      expect(result.status).toBe(201);
+    });
+
+    it("rest_not_found: 404 응답", () => {
+      const result = run(`(rest_not_found "User not found")`) as any;
+      expect(result.status).toBe(404);
+      expect(result.body.error).toBe("User not found");
+    });
+
+    it("rest_error: 커스텀 에러", () => {
+      const result = run(`(rest_error 422 "Validation failed")`) as any;
+      expect(result.status).toBe(422);
+    });
+
+    it("path_param: 파라미터 추출", () => {
+      const result = run(`
+        (path_param {"params" {"user_id" "123"}} "user_id")
+      `);
+      expect(result).toBe("123");
+    });
+  });
+
+  // ── capture-error 모듈 ────────────────────────────────────────────
+  describe("capture_error: 에러 추적", () => {
+    it("capture_error: 성공 케이스", () => {
+      const result = run(`
+        (capture_error (fn [] (+ 1 2 3)))
+      `) as any;
+      expect(result.ok).toBe(true);
+      expect(result.result).toBe(6);
+    });
+
+    it("capture_error: 에러 캡처", () => {
+      const result = run(`
+        (capture_error (fn [] (throw "test error")) "test-ctx")
+      `) as any;
+      expect(result.ok).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(typeof result.error.message).toBe("string");
+    });
+
+    it("error_count: 에러 수 증가", () => {
+      const result = run(`
+        (let [[$_ (capture_error (fn [] (throw "err1")))]
+              [$n (error_count)]]
+          $n)
+      `) as number;
+      expect(typeof result).toBe("number");
+      expect(result).toBeGreaterThan(0);
+    });
+
+    it("make_error: 에러 맵 생성", () => {
+      const result = run(`(make_error "test msg" "MyError" 42)`) as any;
+      expect(result.message).toBe("test msg");
+      expect(result.name).toBe("MyError");
+      expect(result.code).toBe(42);
+    });
+
+    it("error_message: 메시지 추출", () => {
+      const result = run(`
+        (error_message (make_error "hello error"))
+      `);
+      expect(result).toBe("hello error");
+    });
+
+    it("retry: 성공 케이스", () => {
+      const result = run(`
+        (retry (fn [] (* 6 7)) 3)
+      `) as any;
+      expect(result.ok).toBe(true);
+      expect(result.result).toBe(42);
+      expect(result.attempts_used).toBe(1);
+    });
+
+    it("retry: 실패 케이스", () => {
+      const result = run(`
+        (retry (fn [] (throw "always fails")) 2)
+      `) as any;
+      expect(result.ok).toBe(false);
+      expect(result.attempts_used).toBe(2);
+    });
+  });
+});

package/src/__tests__/stdlib-helpers.test.ts

@@ -0,0 +1,128 @@
+// stdlib-helpers.test.ts — Phase G: MISTAKES-100 자동 처리 검증
+
+import { execSync } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+
+describe("stdlib-helpers: Phase G MISTAKES-100", () => {
+  const bootstrapPath = path.join(__dirname, "../../bootstrap.js");
+  let testCounter = 0;
+
+  const run = (code: string) => {
+    const tmpFile = path.join(os.tmpdir(), `fl-helpers-${Date.now()}-${testCounter++}.fl`);
+    const wrappedCode = `(json-str ${code})`;
+    fs.writeFileSync(tmpFile, wrappedCode);
+    try {
+      const output = execSync(`node ${bootstrapPath} run ${tmpFile}`, {
+        encoding: "utf-8",
+        timeout: 5000,
+      }).trim();
+      return JSON.parse(output);
+    } finally {
+      fs.unlinkSync(tmpFile);
+    }
+  };
+
+  // ── G-1: 에러 추천 ─────────────────────────────────────────
+  describe("G-1: 에러 추천", () => {
+    it("suggest-fn: console_log → println", () => {
+      const r = run(`(suggest-fn "console_log")`);
+      expect(r).toContain("println");
+    });
+
+    it("suggest-fn: push → append", () => {
+      expect(run(`(suggest-fn "push")`)).toContain("append");
+    });
+
+    it("suggest-fn: fetch → http_get", () => {
+      expect(run(`(suggest-fn "fetch")`)).toContain("http_get");
+    });
+
+    it("alias-of: console_log returns object", () => {
+      const r = run(`(alias-of "console_log")`);
+      expect(r).toBeTruthy();
+      expect(r.correct).toBe("println");
+    });
+
+    it("alias-of: unknown returns nil", () => {
+      const r = run(`(alias-of "nonexistent_xyz_12345")`);
+      expect(r).toBeNull();
+    });
+
+    it("help-text: 알려진 별칭", () => {
+      const r = run(`(help-text "console_log")`);
+      expect(r).toMatch(/println/);
+    });
+  });
+
+  // ── G-2: 인자 자동 수정 ────────────────────────────────────
+  describe("G-2: 인자 자동 감지", () => {
+    it("smart-map (fn arr) — 정상", () => {
+      expect(run(`(smart-map (fn [$x] (* $x 2)) [1 2 3])`)).toEqual([2, 4, 6]);
+    });
+
+    it("smart-map (arr fn) — 자동 수정", () => {
+      expect(run(`(smart-map [1 2 3] (fn [$x] (* $x 2)))`)).toEqual([2, 4, 6]);
+    });
+
+    it("smart-filter (fn arr)", () => {
+      expect(run(`(smart-filter (fn [$x] (> $x 2)) [1 2 3 4])`)).toEqual([3, 4]);
+    });
+
+    it("smart-filter (arr fn) — 자동 수정", () => {
+      expect(run(`(smart-filter [1 2 3 4] (fn [$x] (> $x 2)))`)).toEqual([3, 4]);
+    });
+
+    it("smart-get (map key)", () => {
+      expect(run(`(smart-get {:name "kim"} "name")`)).toBe("kim");
+    });
+
+    it("smart-get (key map) — 자동 수정", () => {
+      expect(run(`(smart-get "name" {:name "kim"})`)).toBe("kim");
+    });
+
+    it("smart-get (arr idx)", () => {
+      expect(run(`(smart-get [10 20 30] 1)`)).toBe(20);
+    });
+
+    it("smart-assoc (map k v)", () => {
+      expect(run(`(smart-assoc {:a 1} "b" 2)`)).toEqual({ a: 1, b: 2 });
+    });
+
+    it("smart-assoc (k v map) — 자동 수정", () => {
+      expect(run(`(smart-assoc "b" 2 {:a 1})`)).toEqual({ a: 1, b: 2 });
+    });
+  });
+
+  // ── G-3-B: try-call (Result) ────────────────────────────────
+  describe("G-3-B: try-call (Result 패턴)", () => {
+    it("try-call: 성공 시 Ok 반환", () => {
+      const r = run(`(try-call (fn [] (+ 1 2)))`);
+      expect(r._tag).toBe("Ok");
+      expect(r.value).toBe(3);
+    });
+
+    it("try-call: 실패 시 Err 반환", () => {
+      const r = run(`(try-call (fn [] (error "boom")))`);
+      expect(r._tag).toBe("Err");
+      expect(r.message).toMatch(/boom/);
+    });
+
+    it("ok? + unwrap: 성공 케이스", () => {
+      expect(run(`(ok? (try-call (fn [] 42)))`)).toBe(true);
+      expect(run(`(unwrap (try-call (fn [] 42)))`)).toBe(42);
+    });
+
+    it("err? + unwrap-or: 실패 케이스", () => {
+      expect(run(`(err? (try-call (fn [] (error "x"))))`)).toBe(true);
+      expect(run(`(unwrap-or (try-call (fn [] (error "x"))) 999)`)).toBe(999);
+    });
+
+    it("try-call-1: 인자 1개", () => {
+      const r = run(`(try-call-1 (fn [$x] (* $x 10)) 5)`);
+      expect(r._tag).toBe("Ok");
+      expect(r.value).toBe(50);
+    });
+  });
+});

package/src/__tests__/stdlib-modules.test.ts

@@ -0,0 +1,161 @@
+// v11.8: stdlib 모듈별 smoke test (커버리지 확대)
+
+import { lex } from "../lexer";
+import { Parser } from "../parser";
+import { Interpreter } from "../interpreter";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+beforeAll(() => { jest.useFakeTimers(); });
+afterAll(() => { jest.useRealTimers(); });
+
+function run(source: string): any {
+  const tokens = lex(source);
+  const ast = new Parser(tokens).parse();
+  return new Interpreter().interpret(ast).lastValue;
+}
+
+describe("stdlib-time", () => {
+  test("now_unix > 0", () => {
+    expect(run("(now_unix)")).toBeGreaterThan(0);
+  });
+  test("now_ms > 0", () => {
+    expect(run("(now_ms)")).toBeGreaterThan(0);
+  });
+  test("now_iso 포맷", () => {
+    const v = run("(now_iso)");
+    expect(typeof v).toBe("string");
+    expect(v).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+});
+
+describe("stdlib-crypto", () => {
+  test("hex_encode + hex_decode round-trip", () => {
+    expect(run('(hex_decode (hex_encode "hello"))')).toBe("hello");
+  });
+  test("uuid_short 길이", () => {
+    const v = run("(uuid_short)");
+    expect(typeof v).toBe("string");
+    expect(v.length).toBeGreaterThan(0);
+  });
+  test("random_int 범위", () => {
+    const v = run("(random_int 1 10)");
+    expect(v).toBeGreaterThanOrEqual(1);
+    expect(v).toBeLessThanOrEqual(10);
+  });
+});
+
+describe("stdlib-data (json)", () => {
+  test("json_parse + json_str round-trip", () => {
+    const v = run('(json_parse "{\\"a\\":1,\\"b\\":[2,3]}")');
+    expect(v.a).toBe(1);
+    expect(v.b).toEqual([2, 3]);
+  });
+  test("json_keys", () => {
+    const v = run('(json_keys (json_parse "{\\"x\\":1,\\"y\\":2}"))');
+    expect(v).toEqual(expect.arrayContaining(["x", "y"]));
+  });
+  test("json_get nested", () => {
+    const v = run('(json_get (json_parse "{\\"a\\":{\\"b\\":42}}") "a.b")');
+    expect(v).toBe(42);
+  });
+  test("json_merge", () => {
+    const v = run(`(json_merge
+      (json_parse "{\\"a\\":1}")
+      (json_parse "{\\"b\\":2}"))`);
+    expect(v).toEqual({ a: 1, b: 2 });
+  });
+});
+
+describe("stdlib-collection (arr_*)", () => {
+  test("arr_unique", () => {
+    expect(run("(arr_unique (list 1 2 2 3 3 3))")).toEqual([1, 2, 3]);
+  });
+  test("arr_flatten", () => {
+    expect(run("(arr_flatten (list (list 1 2) (list 3 4)))")).toEqual([1, 2, 3, 4]);
+  });
+  test("arr_sum", () => {
+    expect(run("(arr_sum (list 1 2 3 4 5))")).toBe(15);
+  });
+  test("arr_take", () => {
+    expect(run("(arr_take (list 10 20 30 40) 2)")).toEqual([10, 20]);
+  });
+  test("arr_drop", () => {
+    expect(run("(arr_drop (list 10 20 30 40) 2)")).toEqual([30, 40]);
+  });
+  test("arr_chunk", () => {
+    const v = run("(arr_chunk (list 1 2 3 4 5 6) 2)");
+    expect(v).toEqual([[1, 2], [3, 4], [5, 6]]);
+  });
+});
+
+describe("stdlib-cache (in-memory TTL)", () => {
+  test("cache_set + cache_get", () => {
+    expect(run(`
+      (cache_set "k1" 42 60)
+      (cache_get "k1")
+    `)).toBe(42);
+  });
+  test("cache_has", () => {
+    expect(run(`
+      (cache_set "k2" "value" 60)
+      (cache_has "k2")
+    `)).toBe(true);
+  });
+  test("cache_del", () => {
+    expect(run(`
+      (cache_set "k3" 1 60)
+      (cache_del "k3")
+      (cache_has "k3")
+    `)).toBe(false);
+  });
+});
+
+describe("stdlib-auth (JWT)", () => {
+  test("sign + verify round-trip", () => {
+    expect(run(`
+      (define token (auth_jwt_sign {:sub "user1"} "secret-key-32bytes-minimum-xxxxxxx" 3600))
+      (define claims (auth_jwt_verify $token "secret-key-32bytes-minimum-xxxxxxx"))
+      (get $claims "sub")
+    `)).toBe("user1");
+  });
+  test("jwt_decode (검증 없이)", () => {
+    expect(run(`
+      (define token (auth_jwt_sign {:role "admin"} "any-secret-key-32-bytes-xxxxxxxxxx" 3600))
+      (get (auth_jwt_decode $token) "role")
+    `)).toBe("admin");
+  });
+  test("hash_password + verify", () => {
+    expect(run(`
+      (define hashed (auth_hash_password "mypass"))
+      (auth_verify_password "mypass" $hashed)
+    `)).toBe(true);
+  });
+});
+
+describe("stdlib-file (temp dir)", () => {
+  const TMP = path.join(os.tmpdir(), `fl-test-${Date.now()}`);
+
+  beforeAll(() => { fs.mkdirSync(TMP, { recursive: true }); });
+  afterAll(() => {
+    try { fs.rmSync(TMP, { recursive: true, force: true }); } catch {}
+  });
+
+  test("file_write + file_read", () => {
+    const p = path.join(TMP, "a.txt");
+    run(`(file_write "${p.replace(/\\/g, "\\\\")}" "hello")`);
+    expect(run(`(file_read "${p.replace(/\\/g, "\\\\")}")`)).toBe("hello");
+  });
+  test("file_exists", () => {
+    const p = path.join(TMP, "b.txt");
+    run(`(file_write "${p.replace(/\\/g, "\\\\")}" "x")`);
+    expect(run(`(file_exists "${p.replace(/\\/g, "\\\\")}")`)).toBe(true);
+    expect(run(`(file_exists "${p.replace(/\\/g, "\\\\")}/nonexistent")`)).toBe(false);
+  });
+  test("dir_list", () => {
+    run(`(file_write "${TMP.replace(/\\/g, "\\\\")}/c.txt" "")`);
+    const files = run(`(dir_list "${TMP.replace(/\\/g, "\\\\")}")`);
+    expect(Array.isArray(files)).toBe(true);
+  });
+});