freelang-editor 11.7.4

package/src/test-phase27-stdlib-codegen.ts

@@ -0,0 +1,325 @@
+// FreeLang v9: Phase 27 — 표준 라이브러리 Codegen 완성도
+// TS 인터프리터가 지원하는 모든 builtin → JS 컴파일 검증
+// 목표: 컴파일된 JS가 TS 런타임 없이 standalone 실행 가능
+
+import * as vm from "vm";
+import * as fs from "fs";
+import * as path from "path";
+import { Interpreter } from "./interpreter";
+import { lex } from "./lexer";
+import { parse } from "./parser";
+
+let passed = 0;
+let failed = 0;
+
+function test(name: string, fn: () => void) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (e: any) {
+    console.log(`  ❌ ${name}: ${e.message}`);
+    failed++;
+  }
+}
+
+const flSrcDir = path.join(__dirname, "..", "src");
+const lexerSrc   = fs.readFileSync(path.join(flSrcDir, "freelang-lexer.fl"),  "utf-8");
+const parserSrc  = fs.readFileSync(path.join(flSrcDir, "freelang-parser.fl"), "utf-8");
+const codegenSrc = fs.readFileSync(path.join(flSrcDir, "freelang-codegen.fl"), "utf-8");
+
+function compileAndRun(flSrc: string): any {
+  const interp = new Interpreter();
+  for (const src of [lexerSrc, parserSrc, codegenSrc]) {
+    interp.interpret(parse(lex(src)));
+  }
+  interp.interpret(parse(lex(`(gen-js (parse (lex ${JSON.stringify(flSrc)})))`)));
+  const jsCode = interp.context.lastValue as string;
+  if (typeof jsCode !== "string") throw new Error(`codegen returned ${typeof jsCode}`);
+  const sandbox: Record<string, any> = { module: { exports: {} }, console };
+  vm.createContext(sandbox);
+  vm.runInContext(jsCode, sandbox);
+  return sandbox.module.exports;
+}
+
+// ─── [15] 배열 조작 builtins ──────────────────────────────────────
+console.log("\n[15] 배열 조작 builtins");
+
+test("first: 첫 번째 원소", () => {
+  const exp = compileAndRun(`
+[FUNC head :params [$lst] :body ((first $lst))]
+(export head)
+  `.trim());
+  if (exp.head([10, 20, 30]) !== 10) throw new Error(`got ${exp.head([10,20,30])}`);
+});
+
+test("rest: 나머지 원소", () => {
+  const exp = compileAndRun(`
+[FUNC tail :params [$lst] :body ((rest $lst))]
+(export tail)
+  `.trim());
+  const r = exp.tail([1, 2, 3, 4]);
+  if (r.join(",") !== "2,3,4") throw new Error(`got ${r}`);
+});
+
+test("last: 마지막 원소", () => {
+  const exp = compileAndRun(`
+[FUNC final :params [$lst] :body ((last $lst))]
+(export final)
+  `.trim());
+  if (exp.final([1, 2, 3, 99]) !== 99) throw new Error(`got ${exp.final([1,2,3,99])}`);
+});
+
+test("reverse: 배열 뒤집기", () => {
+  const exp = compileAndRun(`
+[FUNC flip :params [$lst] :body ((reverse $lst))]
+(export flip)
+  `.trim());
+  const r = exp.flip([1, 2, 3]);
+  if (r.join(",") !== "3,2,1") throw new Error(`got ${r}`);
+});
+
+test("find: 조건 만족 첫 원소", () => {
+  const exp = compileAndRun(`
+[FUNC find-positive :params [$lst]
+  :body ((find $lst [x] (> $x 0)))
+]
+(export find-positive)
+  `.trim());
+  if (exp["find-positive"]([-3, -1, 4, 6]) !== 4) throw new Error(`got ${exp["find-positive"]([-3,-1,4,6])}`);
+});
+
+test("sort: 문자열 정렬", () => {
+  const exp = compileAndRun(`
+[FUNC alpha-sort :params [$lst] :body ((sort $lst))]
+(export alpha-sort)
+  `.trim());
+  const r = exp["alpha-sort"](["banana", "apple", "cherry"]);
+  if (r.join(",") !== "apple,banana,cherry") throw new Error(`got ${r}`);
+});
+
+test("unique: 중복 제거", () => {
+  const exp = compileAndRun(`
+[FUNC dedup :params [$lst] :body ((unique $lst))]
+(export dedup)
+  `.trim());
+  const r = exp.dedup([1, 2, 2, 3, 1, 4]);
+  if (r.length !== 4) throw new Error(`got ${r}`);
+});
+
+test("flatten: 중첩 배열 평탄화", () => {
+  const exp = compileAndRun(`
+[FUNC flat1 :params [$lst] :body ((flatten $lst))]
+(export flat1)
+  `.trim());
+  const r = exp.flat1([[1, 2], [3, 4], [5]]);
+  if (r.join(",") !== "1,2,3,4,5") throw new Error(`got ${r}`);
+});
+
+test("push: 원소 추가 (불변)", () => {
+  const exp = compileAndRun(`
+[FUNC add-item :params [$lst $item] :body ((push $lst $item))]
+(export add-item)
+  `.trim());
+  const r = exp["add-item"]([1, 2, 3], 4);
+  if (r.join(",") !== "1,2,3,4") throw new Error(`got ${r}`);
+});
+
+// ─── [16] 문자열 builtins ─────────────────────────────────────────
+console.log("\n[16] 문자열 builtins");
+
+test("char-at: 특정 인덱스 문자", () => {
+  const exp = compileAndRun(`
+[FUNC nth-char :params [$s $n] :body ((char-at $s $n))]
+(export nth-char)
+  `.trim());
+  if (exp["nth-char"]("hello", 1) !== "e") throw new Error(`got ${exp["nth-char"]("hello",1)}`);
+});
+
+test("substring: 부분 문자열", () => {
+  const exp = compileAndRun(`
+[FUNC sub :params [$s $a $b] :body ((substring $s $a $b))]
+(export sub)
+  `.trim());
+  if (exp.sub("hello world", 6, 11) !== "world") throw new Error(`got ${exp.sub("hello world",6,11)}`);
+});
+
+test("starts-with?: 접두사 확인", () => {
+  const exp = compileAndRun(`
+[FUNC starts? :params [$s $p] :body ((starts-with? $s $p))]
+(export starts?)
+  `.trim());
+  if (exp["starts?"]("hello", "hel") !== true) throw new Error("starts-with? failed");
+  if (exp["starts?"]("hello", "xyz") !== false) throw new Error("starts-with? false failed");
+});
+
+test("ends-with?: 접미사 확인", () => {
+  const exp = compileAndRun(`
+[FUNC ends? :params [$s $p] :body ((ends-with? $s $p))]
+(export ends?)
+  `.trim());
+  if (exp["ends?"]("hello", "llo") !== true) throw new Error("ends-with? failed");
+});
+
+test("index-of: 첫 번째 위치", () => {
+  const exp = compileAndRun(`
+[FUNC find-idx :params [$s $sub] :body ((index-of $s $sub))]
+(export find-idx)
+  `.trim());
+  if (exp["find-idx"]("hello world", "world") !== 6) throw new Error(`got ${exp["find-idx"]("hello world","world")}`);
+  if (exp["find-idx"]("hello", "xyz") !== -1) throw new Error("not found case failed");
+});
+
+test("split: 구분자로 분리", () => {
+  const exp = compileAndRun(`
+[FUNC tokenize :params [$s $sep] :body ((split $s $sep))]
+(export tokenize)
+  `.trim());
+  const r = exp.tokenize("a,b,c,d", ",");
+  if (r.join("|") !== "a|b|c|d") throw new Error(`got ${r}`);
+});
+
+// ─── [17] 수학 builtins ───────────────────────────────────────────
+console.log("\n[17] 수학 builtins");
+
+test("sqrt: 제곱근", () => {
+  const exp = compileAndRun(`
+[FUNC sq :params [$n] :body ((sqrt $n))]
+(export sq)
+  `.trim());
+  if (Math.abs(exp.sq(9) - 3) > 0.001) throw new Error(`got ${exp.sq(9)}`);
+  if (Math.abs(exp.sq(2) - 1.414) > 0.001) throw new Error(`got ${exp.sq(2)}`);
+});
+
+test("pow: 거듭제곱", () => {
+  const exp = compileAndRun(`
+[FUNC power :params [$base $exp] :body ((pow $base $exp))]
+(export power)
+  `.trim());
+  if (exp.power(2, 10) !== 1024) throw new Error(`got ${exp.power(2,10)}`);
+  if (exp.power(3, 3) !== 27) throw new Error(`got ${exp.power(3,3)}`);
+});
+
+// ─── [18] 타입 조건자 ─────────────────────────────────────────────
+console.log("\n[18] 타입 조건자");
+
+test("string?: 문자열 판별", () => {
+  const exp = compileAndRun(`
+[FUNC str? :params [$x] :body ((string? $x))]
+(export str?)
+  `.trim());
+  if (exp["str?"]("hello") !== true) throw new Error("string? true failed");
+  if (exp["str?"](42) !== false) throw new Error("string? false failed");
+});
+
+test("number?: 숫자 판별", () => {
+  const exp = compileAndRun(`
+[FUNC num? :params [$x] :body ((number? $x))]
+(export num?)
+  `.trim());
+  if (exp["num?"](42) !== true) throw new Error("number? true failed");
+  if (exp["num?"]("42") !== false) throw new Error("number? false failed");
+});
+
+test("array?: 배열 판별", () => {
+  const exp = compileAndRun(`
+[FUNC arr? :params [$x] :body ((array? $x))]
+(export arr?)
+  `.trim());
+  if (exp["arr?"]([1, 2, 3]) !== true) throw new Error("array? true failed");
+  if (exp["arr?"]("hello") !== false) throw new Error("array? false failed");
+});
+
+test("map?: 맵 판별", () => {
+  const exp = compileAndRun(`
+[FUNC obj? :params [$x] :body ((map? $x))]
+(export obj?)
+  `.trim());
+  if (exp["obj?"]({ a: 1 }) !== true) throw new Error("map? true failed");
+  if (exp["obj?"]([1, 2]) !== false) throw new Error("map? false (array) failed");
+});
+
+// ─── [19] 복합 실용 예제 ─────────────────────────────────────────
+console.log("\n[19] 복합 실용 예제");
+
+test("숫자 정렬 (sort + map)", () => {
+  const exp = compileAndRun(`
+[FUNC sort-nums :params [$lst]
+  :body (
+    (sort $lst (fn [$a $b] (- $a $b)))
+  )
+]
+(export sort-nums)
+  `.trim());
+  const r = exp["sort-nums"]([5, 3, 1, 4, 2]);
+  if (r.join(",") !== "1,2,3,4,5") throw new Error(`got ${r}`);
+});
+
+test("팰린드롬 검사", () => {
+  const exp = compileAndRun(`
+[FUNC palindrome? :params [$s]
+  :body (
+    (let [[rev (str-join (reverse (split $s "")) "")]]
+      (= $s $rev)
+    )
+  )
+]
+(export palindrome?)
+  `.trim());
+  if (exp["palindrome?"]("racecar") !== true) throw new Error("racecar not palindrome");
+  if (exp["palindrome?"]("hello") !== false) throw new Error("hello palindrome?");
+});
+
+test("단어 빈도 계산", () => {
+  const exp = compileAndRun(`
+[FUNC word-freq :params [$words]
+  :body (
+    (reduce $words {} [acc word]
+      (assoc $acc $word
+        (if (null? (get $acc $word))
+          1
+          (+ (get $acc $word) 1)
+        )
+      )
+    )
+  )
+]
+(export word-freq)
+  `.trim());
+  const freq = exp["word-freq"](["a", "b", "a", "c", "b", "a"]);
+  if (freq.a !== 3 || freq.b !== 2 || freq.c !== 1) throw new Error(`got ${JSON.stringify(freq)}`);
+});
+
+test("깊이 우선 탐색 (트리)", () => {
+  const exp = compileAndRun(`
+[FUNC tree-sum :params [$node]
+  :body (
+    (if (null? $node)
+      0
+      (+ (get $node :val)
+         (+ (tree-sum (get $node :left))
+            (tree-sum (get $node :right))))
+    )
+  )
+]
+(export tree-sum)
+  `.trim());
+  // tree: {val:1, left:{val:2, left:null, right:null}, right:{val:3, left:null, right:null}}
+  const tree = { val: 1, left: { val: 2, left: null, right: null }, right: { val: 3, left: null, right: null } };
+  if (exp["tree-sum"](tree) !== 6) throw new Error(`got ${exp["tree-sum"](tree)}`);
+});
+
+test("json_keys: 객체 키 순회", () => {
+  const exp = compileAndRun(`
+[FUNC obj-keys :params [$m] :body ((sort (json_keys $m)))]
+(export obj-keys)
+  `.trim());
+  const keys = exp["obj-keys"]({ c: 3, a: 1, b: 2 });
+  if (keys.join(",") !== "a,b,c") throw new Error(`got ${keys}`);
+});
+
+// ─── 결과 ─────────────────────────────────────────────────────────
+console.log(`\n${"─".repeat(50)}`);
+console.log(`Phase 27 stdlib codegen: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);
+process.exit(0);

package/src/test-phase28-loop-recur.ts

@@ -0,0 +1,182 @@
+// FreeLang v9: Phase 28 — loop/recur 꼬리 재귀 최적화
+// (loop [bindings] body) + (recur vals) → while 루프로 컴파일
+
+import * as vm from "vm";
+import * as fs from "fs";
+import * as path from "path";
+import { Interpreter } from "./interpreter";
+import { lex } from "./lexer";
+import { parse } from "./parser";
+
+let passed = 0;
+let failed = 0;
+
+function test(name: string, fn: () => void) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (e: any) {
+    console.log(`  ❌ ${name}: ${e.message}`);
+    failed++;
+  }
+}
+
+const flSrcDir = path.join(__dirname, "..", "src");
+const lexerSrc   = fs.readFileSync(path.join(flSrcDir, "freelang-lexer.fl"),  "utf-8");
+const parserSrc  = fs.readFileSync(path.join(flSrcDir, "freelang-parser.fl"), "utf-8");
+const codegenSrc = fs.readFileSync(path.join(flSrcDir, "freelang-codegen.fl"), "utf-8");
+
+function compileAndRun(flSrc: string): any {
+  const interp = new Interpreter();
+  for (const src of [lexerSrc, parserSrc, codegenSrc]) {
+    interp.interpret(parse(lex(src)));
+  }
+  interp.interpret(parse(lex(`(gen-js (parse (lex ${JSON.stringify(flSrc)})))`)));
+  const jsCode = interp.context.lastValue as string;
+  if (typeof jsCode !== "string") throw new Error(`codegen returned ${typeof jsCode}`);
+  const sandbox: Record<string, any> = { module: { exports: {} }, console };
+  vm.createContext(sandbox);
+  vm.runInContext(jsCode, sandbox);
+  return sandbox.module.exports;
+}
+
+// ─── [20] loop/recur 기본 ──────────────────────────────────────────
+console.log("\n[20] loop/recur 기본");
+
+test("loop: 단순 카운트다운", () => {
+  const exp = compileAndRun(`
+[FUNC countdown :params [$n]
+  :body (
+    (loop [[$n $n] [$acc 0]]
+      (if (<= $n 0)
+        $acc
+        (recur (- $n 1) (+ $acc 1))
+      )
+    )
+  )
+]
+(export countdown)
+  `.trim());
+  if (exp.countdown(100) !== 100) throw new Error(`got ${exp.countdown(100)}`);
+  if (exp.countdown(0) !== 0) throw new Error(`got ${exp.countdown(0)}`);
+});
+
+test("loop: 반복 덧셈 (꼬리 재귀 sum)", () => {
+  const exp = compileAndRun(`
+[FUNC sum-loop :params [$n]
+  :body (
+    (loop [[$i $n] [$acc 0]]
+      (if (<= $i 0)
+        $acc
+        (recur (- $i 1) (+ $acc $i))
+      )
+    )
+  )
+]
+(export sum-loop)
+  `.trim());
+  // 1+2+...+100 = 5050
+  if (exp["sum-loop"](100) !== 5050) throw new Error(`got ${exp["sum-loop"](100)}`);
+});
+
+test("loop: 팩토리얼 (꼬리 재귀)", () => {
+  const exp = compileAndRun(`
+[FUNC fact-loop :params [$n]
+  :body (
+    (loop [[$n $n] [$acc 1]]
+      (if (<= $n 1)
+        $acc
+        (recur (- $n 1) (* $acc $n))
+      )
+    )
+  )
+]
+(export fact-loop)
+  `.trim());
+  if (exp["fact-loop"](10) !== 3628800) throw new Error(`got ${exp["fact-loop"](10)}`);
+  if (exp["fact-loop"](0) !== 1) throw new Error(`got ${exp["fact-loop"](0)}`);
+});
+
+test("loop: fibonacci (꼬리 재귀)", () => {
+  const exp = compileAndRun(`
+[FUNC fib-loop :params [$n]
+  :body (
+    (loop [[$n $n] [$a 0] [$b 1]]
+      (if (<= $n 0)
+        $a
+        (recur (- $n 1) $b (+ $a $b))
+      )
+    )
+  )
+]
+(export fib-loop)
+  `.trim());
+  if (exp["fib-loop"](10) !== 55) throw new Error(`got ${exp["fib-loop"](10)}`);
+  if (exp["fib-loop"](0) !== 0) throw new Error(`got ${exp["fib-loop"](0)}`);
+  if (exp["fib-loop"](1) !== 1) throw new Error(`got ${exp["fib-loop"](1)}`);
+});
+
+// ─── [21] 깊은 재귀 (TCO 검증) ───────────────────────────────────
+console.log("\n[21] 깊은 재귀 — TCO 검증");
+
+test("loop: 10만 번 반복 (스택 오버플로우 없음)", () => {
+  const exp = compileAndRun(`
+[FUNC big-sum :params [$n]
+  :body (
+    (loop [[$i $n] [$acc 0]]
+      (if (<= $i 0)
+        $acc
+        (recur (- $i 1) (+ $acc $i))
+      )
+    )
+  )
+]
+(export big-sum)
+  `.trim());
+  // 1+2+...+100000 = 5000050000
+  const result = exp["big-sum"](100000);
+  if (result !== 5000050000) throw new Error(`got ${result}`);
+});
+
+test("loop: GCD (최대공약수)", () => {
+  const exp = compileAndRun(`
+[FUNC gcd :params [$a $b]
+  :body (
+    (loop [[$a $a] [$b $b]]
+      (if (= $b 0)
+        $a
+        (recur $b (% $a $b))
+      )
+    )
+  )
+]
+(export gcd)
+  `.trim());
+  if (exp.gcd(48, 18) !== 6) throw new Error(`gcd(48,18)=${exp.gcd(48,18)}`);
+  if (exp.gcd(100, 75) !== 25) throw new Error(`gcd(100,75)=${exp.gcd(100,75)}`);
+});
+
+test("loop: 문자열 반복 구성", () => {
+  const exp = compileAndRun(`
+[FUNC repeat-str :params [$s $n]
+  :body (
+    (loop [[$n $n] [$acc ""]]
+      (if (<= $n 0)
+        $acc
+        (recur (- $n 1) (concat $acc $s))
+      )
+    )
+  )
+]
+(export repeat-str)
+  `.trim());
+  if (exp["repeat-str"]("ab", 3) !== "ababab") throw new Error(`got ${exp["repeat-str"]("ab",3)}`);
+  if (exp["repeat-str"]("x", 0) !== "") throw new Error(`got ${exp["repeat-str"]("x",0)}`);
+});
+
+// ─── 결과 ─────────────────────────────────────────────────────────
+console.log(`\n${"─".repeat(50)}`);
+console.log(`Phase 28 loop/recur TCO: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);
+process.exit(0);

package/src/test-phase29-import.ts

@@ -0,0 +1,165 @@
+// FreeLang v9: Phase 29 — 크로스 파일 import/module 지원
+// (import "./file.js" [$fn]) → const { fn } = require("./file.js");
+
+import * as vm from "vm";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { Interpreter } from "./interpreter";
+import { lex } from "./lexer";
+import { parse } from "./parser";
+
+let passed = 0;
+let failed = 0;
+
+function test(name: string, fn: () => void) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (e: any) {
+    console.log(`  ❌ ${name}: ${e.message}`);
+    failed++;
+  }
+}
+
+const flSrcDir = path.join(__dirname, "..", "src");
+const lexerSrc   = fs.readFileSync(path.join(flSrcDir, "freelang-lexer.fl"),  "utf-8");
+const parserSrc  = fs.readFileSync(path.join(flSrcDir, "freelang-parser.fl"), "utf-8");
+const codegenSrc = fs.readFileSync(path.join(flSrcDir, "freelang-codegen.fl"), "utf-8");
+
+function compileToJS(flSrc: string): string {
+  const interp = new Interpreter();
+  for (const src of [lexerSrc, parserSrc, codegenSrc]) {
+    interp.interpret(parse(lex(src)));
+  }
+  interp.interpret(parse(lex(`(gen-js (parse (lex ${JSON.stringify(flSrc)})))`)));
+  const jsCode = interp.context.lastValue as string;
+  if (typeof jsCode !== "string") throw new Error(`codegen returned ${typeof jsCode}`);
+  return jsCode;
+}
+
+// Node.js require 가능한 sandbox 실행 (임시 파일 방식)
+function runWithRequire(mainJS: string, deps: Record<string, string>): any {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fl-test-"));
+  try {
+    // 의존 파일들 임시 디렉토리에 저장
+    for (const [name, code] of Object.entries(deps)) {
+      fs.writeFileSync(path.join(tmpDir, name), code);
+    }
+    // 메인 파일 저장 + 실행
+    const mainPath = path.join(tmpDir, "main.js");
+    fs.writeFileSync(mainPath, mainJS);
+    // require 가능하게 실행
+    const mod = require(mainPath);
+    return mod;
+  } finally {
+    // cleanup
+    for (const [name] of Object.entries(deps)) {
+      try { fs.unlinkSync(path.join(tmpDir, name)); } catch {}
+    }
+    try { fs.unlinkSync(path.join(tmpDir, "main.js")); } catch {}
+    try { fs.rmdirSync(tmpDir); } catch {}
+  }
+}
+
+// ─── [22] import 코드젠 검증 ──────────────────────────────────────
+console.log("\n[22] import 코드젠 검증");
+
+test("import 코드 생성 확인", () => {
+  const js = compileToJS(`
+(import "./math-utils.js" [$double $triple])
+[FUNC quad :params [$n] :body ((double (double $n)))]
+(export quad)
+  `.trim());
+  if (!js.includes('require("./math-utils.js")')) throw new Error("require not found");
+  if (!js.includes("double")) throw new Error("double not found");
+});
+
+test("import: 하이픈 이름 처리", () => {
+  const js = compileToJS(`
+(import "./utils.js" [$add-one $sub-one])
+[FUNC apply-both :params [$n] :body ((+ (add-one $n) (sub-one $n)))]
+(export apply-both)
+  `.trim());
+  if (!js.includes('"add-one": add_one')) throw new Error(`hyphen name not properly aliased: ${js.slice(0, 300)}`);
+});
+
+// ─── [23] import 실행 검증 (실제 파일 require) ────────────────────
+console.log("\n[23] import 실행 검증");
+
+test("두 FL 파일: math-utils + main", () => {
+  // 1. math-utils.fl 컴파일
+  const utilsJS = compileToJS(`
+[FUNC double :params [$n] :body ((* $n 2))]
+[FUNC square :params [$n] :body ((* $n $n))]
+(export double square)
+  `.trim());
+
+  // 2. main.fl 컴파일 (import 사용)
+  const mainJS = compileToJS(`
+(import "./math-utils.js" [$double $square])
+[FUNC double-square :params [$n] :body ((double (square $n)))]
+(export double-square)
+  `.trim());
+
+  const exp = runWithRequire(mainJS, { "math-utils.js": utilsJS });
+  // double-square(3) = double(square(3)) = double(9) = 18
+  if (exp["double-square"](3) !== 18) throw new Error(`got ${exp["double-square"](3)}`);
+  if (exp["double-square"](5) !== 50) throw new Error(`got ${exp["double-square"](5)}`);
+});
+
+test("세 FL 파일: a → b → main", () => {
+  const aJS = compileToJS(`
+[FUNC inc :params [$n] :body ((+ $n 1))]
+(export inc)
+  `.trim());
+
+  const bJS = compileToJS(`
+(import "./a.js" [$inc])
+[FUNC inc3 :params [$n] :body ((inc (inc (inc $n))))]
+(export inc3)
+  `.trim());
+
+  const mainJS = compileToJS(`
+(import "./b.js" [$inc3])
+[FUNC inc6 :params [$n] :body ((inc3 (inc3 $n)))]
+(export inc6)
+  `.trim());
+
+  const exp = runWithRequire(mainJS, { "a.js": aJS, "b.js": bJS });
+  if (exp.inc6(0) !== 6) throw new Error(`got ${exp.inc6(0)}`);
+  if (exp.inc6(10) !== 16) throw new Error(`got ${exp.inc6(10)}`);
+});
+
+test("import + loop/recur 조합", () => {
+  const mathJS = compileToJS(`
+[FUNC pow2 :params [$n] :body ((* $n $n))]
+(export pow2)
+  `.trim());
+
+  const mainJS = compileToJS(`
+(import "./math.js" [$pow2])
+[FUNC sum-squares :params [$lst]
+  :body (
+    (loop [[$i 0] [$acc 0]]
+      (if (>= $i (length $lst))
+        $acc
+        (recur (+ $i 1) (+ $acc (pow2 (get $lst $i))))
+      )
+    )
+  )
+]
+(export sum-squares)
+  `.trim());
+
+  const exp = runWithRequire(mainJS, { "math.js": mathJS });
+  // 1²+2²+3²+4²+5² = 55
+  if (exp["sum-squares"]([1,2,3,4,5]) !== 55) throw new Error(`got ${exp["sum-squares"]([1,2,3,4,5])}`);
+});
+
+// ─── 결과 ─────────────────────────────────────────────────────────
+console.log(`\n${"─".repeat(50)}`);
+console.log(`Phase 29 import/module: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);
+process.exit(0);