freelang-editor 11.7.4

package/self/all.fl

@@ -0,0 +1,1353 @@
+;; self/all.fl — FreeLang 컴파일러 (self-hosted)
+;; 독립선언 v1 달성 (2026-05-12) — L2 고정점 SHA256: 5fe0a3fd...
+
+;; ── Lexer ───────────────────────────────────────────────────────────
+;; 입력: source string
+;; 출력: tokens list. 각 토큰 = {:kind :value :line :col}
+;; 토큰 종류: LParen/RParen/LBracket/RBracket/LBrace/RBrace
+;;          Number/String/Symbol/Variable/Keyword/Unknown
+
+;; ── char predicates
+
+(defn is-digit? [$c]
+  (if (null? $c) false (and (>= $c "0") (<= $c "9"))))
+
+(defn is-alpha? [$c]
+  (if (null? $c) false
+  (or (and (>= $c "a") (<= $c "z"))
+      (and (>= $c "A") (<= $c "Z")))))
+
+(defn is-alnum? [$c]
+  (or (is-digit? $c) (is-alpha? $c)))
+
+(defn is-space? [$c]
+  (or (= $c " ") (= $c "\t") (= $c "\n") (= $c "\r")))
+
+(defn is-symbol-char? [$c]
+  (if (null? $c) false
+  (or (is-alnum? $c)
+      (= $c "-") (= $c "_") (= $c "?") (= $c "!")
+      (= $c "/") (= $c ".") (= $c "<") (= $c ">")
+      (= $c "=") (= $c "+") (= $c "*") (= $c "%")
+      (= $c "&") (= $c "|") (= $c "^") (= $c "~"))))
+
+;; ── state = {:src :idx :line :col :tokens}
+
+(defn make-state [$src]
+  {:src $src :idx 0 :line 1 :col 1 :tokens []})
+
+(defn peek-at [$st $offset]
+  (let [[$src (get $st :src)]
+      [$i (+ (get $st :idx) $offset)]]
+  (if (>= $i (length $src)) null (char-at $src $i))))
+
+(defn peek [$st]
+  (peek-at $st 0))
+
+(defn at-end? [$st]
+  (>= (get $st :idx) (length (get $st :src))))
+
+(defn advance [$st]
+  (let [[$c (peek $st)]]
+  (if (= $c "\n")
+    {:src (get $st :src) :idx (+ (get $st :idx) 1)
+     :line (+ (get $st :line) 1) :col 1
+     :tokens (get $st :tokens)}
+    {:src (get $st :src) :idx (+ (get $st :idx) 1)
+     :line (get $st :line) :col (+ (get $st :col) 1)
+     :tokens (get $st :tokens)})))
+
+(defn emit [$st $kind $value $sl $sc]
+  {:src (get $st :src) :idx (get $st :idx)
+  :line (get $st :line) :col (get $st :col)
+  :tokens (append (get $st :tokens)
+                  {:kind $kind :type $kind :value $value :line $sl :col $sc})})
+
+;; ── 스킵 (whitespace + ; line comment)
+
+(defn skip-comment-loop [$cur]
+  (if (or (at-end? $cur) (= (peek $cur) "\n"))
+    (if (at-end? $cur) $cur (advance $cur))
+    (skip-comment-loop (advance $cur))))
+
+(defn skip-comment [$st]
+  (skip-comment-loop $st))
+
+(defn skip-ws-loop [$cur]
+  (if (at-end? $cur) $cur
+    (let [[$c (peek $cur)]]
+      (cond
+        [(is-space? $c) (skip-ws-loop (advance $cur))]
+        [(= $c ";")     (skip-ws-loop (skip-comment $cur))]
+        [true           $cur]))))
+
+(defn skip-ws [$st]
+  (skip-ws-loop $st))
+
+;; ── 숫자 (정수/실수/음수)
+
+(defn read-number-iter [$cur $res_acc $dot $line $col]
+  (if (at-end? $cur) (emit $cur "Number" $res_acc $line $col)
+    (let [[$c (peek $cur)]]
+      (cond
+        [(is-digit? $c)
+         (read-number-iter (advance $cur) (str $res_acc $c) $dot $line $col)]
+        [(and (= $c ".") (not $dot))
+         (read-number-iter (advance $cur) (str $res_acc $c) true $line $col)]
+        [true (emit $cur "Number" $res_acc $line $col)]))))
+
+(defn read-number-body [$st $acc $has-dot $line $col]
+  (read-number-iter $st $acc $has-dot $line $col))
+
+(defn read-number [$st]
+  (read-number-body $st "" false (get $st :line) (get $st :col)))
+
+;; ── 문자열 (escape \n \t \r \" \\)
+
+(defn translate-esc [$c]
+  (cond
+  [(= $c "n") "\n"] [(= $c "t") "\t"] [(= $c "r") "\r"]
+  [(= $c "\"") "\""] [(= $c "\\") "\\"] [true $c]))
+
+(defn read-string-iter [$cur $res_acc $line $col]
+  (if (at-end? $cur) (emit $cur "String" $res_acc $line $col)
+    (let [[$c (peek $cur)]]
+      (cond
+        [(= $c "\"")
+         (emit (advance $cur) "String" $res_acc $line $col)]
+        [(= $c "\\")
+         (let [[$st2 (advance $cur)] [$c2 (peek $st2)]]
+           (read-string-iter (advance $st2) (str $res_acc (translate-esc $c2)) $line $col))]
+        [true
+         (read-string-iter (advance $cur) (str $res_acc $c) $line $col)]))))
+
+(defn read-string-body [$st $acc $line $col]
+  (read-string-iter $st $acc $line $col))
+
+(defn read-string [$st]
+  (let [[$line (get $st :line)] [$col (get $st :col)]
+      [$st1 (advance $st)]]
+  (read-string-body $st1 "" $line $col)))
+
+;; ── 심볼 / 변수 / 키워드 (모두 symbol-char 연속)
+
+(defn read-symbol-iter [$cur $res_acc $line $col $kind]
+  (if (at-end? $cur) (emit $cur $kind $res_acc $line $col)
+    (let [[$c (peek $cur)]]
+      (if (is-symbol-char? $c)
+        (read-symbol-iter (advance $cur) (str $res_acc $c) $line $col $kind)
+        (emit $cur $kind $res_acc $line $col)))))
+
+(defn read-symbol-body-kind [$st $acc $line $col $kind]
+  (read-symbol-iter $st $acc $line $col $kind))
+
+(defn read-symbol [$st]
+  (read-symbol-body-kind $st "" (get $st :line) (get $st :col) "Symbol"))
+
+(defn read-variable [$st]
+  (let [[$line (get $st :line)] [$col (get $st :col)]
+      [$st1 (advance $st)]]
+  (read-symbol-body-kind $st1 "" $line $col "Variable")))
+
+(defn read-keyword [$st]
+  (let [[$line (get $st :line)] [$col (get $st :col)]
+      [$st1 (advance $st)]]
+  (read-symbol-body-kind $st1 "" $line $col "Keyword")))
+
+;; ── 토큰 하나 읽기
+
+(defn read-token [$st]
+  (let [[$st1 (skip-ws $st)]]
+  (if (at-end? $st1) $st1
+    (let [[$c (peek $st1)] [$line (get $st1 :line)] [$col (get $st1 :col)]]
+      (cond
+        [(= $c "(") (emit (advance $st1) "LParen"   $c $line $col)]
+        [(= $c ")") (emit (advance $st1) "RParen"   $c $line $col)]
+        [(= $c "[") (emit (advance $st1) "LBracket" $c $line $col)]
+        [(= $c "]") (emit (advance $st1) "RBracket" $c $line $col)]
+        [(= $c "{") (emit (advance $st1) "LBrace"   $c $line $col)]
+        [(= $c "}") (emit (advance $st1) "RBrace"   $c $line $col)]
+        [(= $c "\"") (read-string $st1)]
+        [(= $c "$") (read-variable $st1)]
+        [(= $c ":") (read-keyword $st1)]
+        [(is-digit? $c) (read-number $st1)]
+        [(and (= $c "-") (is-digit? (peek-at $st1 1)))
+         (read-number-body (advance $st1) "-" false $line $col)]
+        [(is-symbol-char? $c) (read-symbol $st1)]
+        [true (emit (advance $st1) "Unknown" $c $line $col)])))))
+
+;; ── 메인 루프 — 모든 토큰 수집
+
+(defn lex-loop [$cur]
+  (let [[$ws (skip-ws $cur)]]
+  (if (at-end? $ws)
+    (get $ws :tokens)
+    (lex-loop (read-token $ws)))))
+
+(defn lex [$src]
+  (lex-loop (make-state $src)))
+
+;; ── AST 노드 생성자 ─────────────────────────────────────────────────
+;; 모든 노드는 plain map: {:kind "..." ...필드}
+
+;; ── 21 기본 원자 (Literal/Variable/Keyword/SExpr)
+
+(defn make-literal [type value line]
+  {:kind "literal" :type type :value value :line line})
+
+(defn make-variable [name line]
+  {:kind "variable" :name name :line line})
+
+(defn make-keyword [name line]
+  {:kind "keyword" :name name :line line})
+
+(defn make-sexpr [op args line]
+  {:kind "sexpr" :op op :args args :line line})
+
+;; ── 22 SExpr 편의 + 원시값 래퍼
+
+(defn make-number [v line]
+  (make-literal "number" v line))
+
+(defn make-string [v line]
+  (make-literal "string" v line))
+
+(defn make-bool [v line]
+  (make-literal "boolean" v line))
+
+(defn make-null [line]
+  (make-literal "null" null line))
+
+(defn make-symbol [v line]
+  (make-literal "symbol" v line))
+
+;; ──────────────────────────────────────
+;; 23 Block (Array/Map/Named)
+;; fields 는 items(list) 또는 named map. block 의 type 으로 구분.
+;; ──────────────────────────────────────
+
+(defn make-block [type name fields line]
+  {:kind "block" :type type :name name :fields fields :line line})
+
+(defn make-array-block [items line]
+  (make-block "Array" null {:items items} line))
+
+(defn make-map-block [items line]
+  (make-block "Map" null {:items items} line))
+
+;; ── 24 Pattern 7종
+
+(defn make-pattern-literal [value line]
+  {:kind "pattern-literal" :value value :line line})
+
+(defn make-pattern-variable [name line]
+  {:kind "pattern-variable" :name name :line line})
+
+(defn make-pattern-wildcard [line]
+  {:kind "pattern-wildcard" :line line})
+
+(defn make-pattern-list [items rest line]
+  {:kind "pattern-list" :items items :rest rest :line line})
+
+(defn make-pattern-struct [type-name fields line]
+  {:kind "pattern-struct" :type type-name :fields fields :line line})
+
+(defn make-pattern-or [alternatives line]
+  {:kind "pattern-or" :alternatives alternatives :line line})
+
+(defn make-pattern-range [start end line]
+  {:kind "pattern-range" :start start :end end :line line})
+
+;; ── 25 Pattern matching
+
+(defn make-pattern-match [value cases line]
+  {:kind "pattern-match" :value value :cases cases :line line})
+
+(defn make-match-case [pattern guard body line]
+  {:kind "match-case" :pattern pattern :guard guard :body body :line line})
+
+;; ── 26 함수/타입
+
+(defn make-function-value [params body captured-env name]
+  {:kind "function-value" :params params :body body
+  :capturedEnv captured-env :name name})
+
+(defn make-type-class [name generics methods line]
+  {:kind "type-class" :name name :generics generics
+  :methods methods :line line})
+
+(defn make-type-class-instance [class-name type-name impls line]
+  {:kind "type-class-instance" :class class-name :type type-name
+  :impls impls :line line})
+
+;; ── 27 Module / Import
+
+(defn make-module-block [name exports body line]
+  {:kind "module" :name name :exports exports :body body :line line})
+
+(defn make-import-block [path alias names line]
+  {:kind "import" :path path :alias alias :names names :line line})
+
+(defn make-open-block [module-name line]
+  {:kind "open" :module module-name :line line})
+
+;; ── 28 AI 블록 (SearchBlock / LearnBlock / ReasoningBlock)
+
+(defn make-search-block [query fields line]
+  {:kind "search-block" :query query :fields fields :line line})
+
+(defn make-learn-block [topic fields line]
+  {:kind "learn-block" :topic topic :fields fields :line line})
+
+(defn make-reasoning-block [name fields line]
+  {:kind "reasoning-block" :name name :fields fields :line line})
+
+;; ── 29 Async / Try
+
+(defn make-async-function [name params body line]
+  {:kind "async-function" :name name :params params :body body :line line})
+
+(defn make-await [expr line]
+  {:kind "await" :expr expr :line line})
+
+(defn make-try [body catch finally line]
+  {:kind "try" :body body :catch catch :finally finally :line line})
+
+(defn make-catch [param body line]
+  {:kind "catch" :param param :body body :line line})
+
+(defn make-throw [expr line]
+  {:kind "throw" :expr expr :line line})
+
+(defn make-template-string [parts expressions line]
+  {:kind "template-string" :parts parts :expressions expressions :line line})
+
+(defn make-loop [init condition update body line]
+  {:kind "loop" :init init :condition condition :update update :body body :line line})
+
+;; ── 30 웹 노드 + deep-equal?
+
+(defn make-page [name path fields line]
+  {:kind "page" :name name :path path :fields fields :line line})
+
+(defn make-route [method path handler line]
+  {:kind "route" :method method :path path :handler handler :line line})
+
+(defn make-component [name fields line]
+  {:kind "component" :name name :fields fields :line line})
+
+(defn make-form [name fields line]
+  {:kind "form" :name name :fields fields :line line})
+
+;; deep-equal? — 노드 비교 (line 무시)
+;; Map 이면 모든 키를 순회, list 면 원소별, 원시값은 =.
+
+(defn deep-equal? [a b]
+  (cond
+  [(and (null? a) (null? b)) true]
+  [(or  (null? a) (null? b)) false]
+  [(and (list? a) (list? b)) (deep-equal-list? a b 0)]
+  [(and (map? a) (map? b))   (deep-equal-map? a b)]
+  [true (= a b)]))
+
+(defn deep-equal-list? [a b i]
+  (cond
+  [(not (= (length a) (length b))) false]
+  [(>= i (length a)) true]
+  [(not (deep-equal? (get a i) (get b i))) false]
+  [true (deep-equal-list? a b (+ i 1))]))
+
+;; Map 비교: :line 은 무시. keys 정렬 후 각 키의 값 비교.
+(defn deep-equal-map? [a b]
+  (let [[ka (keys-no-line a)]
+      [kb (keys-no-line b)]]
+  (if (not (= (length ka) (length kb))) false
+    (deep-equal-map-keys? a b ka 0))))
+
+(defn keys-no-line [m]
+  (filter (fn [k] (not (= k "line"))) (json_keys m)))
+
+(defn deep-equal-map-keys? [a b ks i]
+  (cond
+  [(>= i (length ks)) true]
+  [(let [[k (get ks i)]]
+     (not (deep-equal? (get a k) (get b k)))) false]
+  [true (deep-equal-map-keys? a b ks (+ i 1))]))
+
+;; ── 독립선언 v1: 누락 builtin 추가 ──────────────────────────
+(defn json-keys [m] (obj-keys m))
+;; list? / array? / map? 는 prelude builtin — 재정의 불필요
+
+;; ── Parser ──────────────────────────────────────────────────────────
+;; 입력: tokens (lexer 출력) / 출력: AST nodes
+;; 모든 함수 [FUNC] 블록. 파서 상태 = {:tokens :idx}.
+;; node 생성자는 self/ast.fl 정의 재사용. 테스트 단독 실행 위해 여기에도 복제.
+
+;; ──────────────────────────────────────
+;; AST 생성자 — self/ast.fl 에서 정의됨
+;; (모든 make-* 함수는 ast.fl 표준 정의 참조)
+;; ──────────────────────────────────────
+
+;; ── 31 파서 상태 + peek/advance/expect
+
+(defn p-make [$tokens]
+  {:tokens $tokens :idx 0 :ast []})
+
+(defn p-peek [$p]
+  (let [[$i (get $p :idx)] [$t (get $p :tokens)]]
+  (if (>= $i (length $t)) null (get $t $i))))
+
+(defn p-peek-at [$p $offset]
+  (let [[$i (+ (get $p :idx) $offset)] [$t (get $p :tokens)]]
+  (if (>= $i (length $t)) null (get $t $i))))
+
+(defn p-end? [$p]
+  (>= (get $p :idx) (length (get $p :tokens))))
+
+(defn p-advance [$p]
+  {:tokens (get $p :tokens) :idx (+ (get $p :idx) 1) :ast (get $p :ast)})
+
+(defn p-with-ast [$p $ast]
+  {:tokens (get $p :tokens) :idx (get $p :idx) :ast $ast})
+
+(defn p-append-ast [$p $node]
+  (p-with-ast $p (append (get $p :ast) $node)))
+
+;; 2-tuple 반환용 map {:p p' :node n}
+(defn r-pair [$p $node]
+  {:p $p :node $node})
+
+;; ── 32 parseAtom — number/string/symbol/keyword/variable
+
+(defn string-contains? [$s $substr]
+  (not (= -1 (str-index-of $s $substr))))
+
+(defn parse-atom [$p]
+  (let [[$t (p-peek $p)] [$k (get $t :kind)] [$v (get $t :value)] [$line (get $t :line)]]
+  (cond
+    [(= $k "Number")
+     (r-pair (p-advance $p) (make-literal "number" $v $line))]
+    [(= $k "String")
+     (if (string-contains? $v (str "$" "{"))
+       (r-pair (p-advance $p) (make-template-string $v (list) $line))
+       (r-pair (p-advance $p) (make-literal "string" $v $line)))]
+    [(= $k "Symbol")
+     (r-pair (p-advance $p) (make-literal "symbol" $v $line))]
+    [(= $k "Variable")
+     (r-pair (p-advance $p) (make-variable $v $line))]
+    [(= $k "Keyword")
+     (r-pair (p-advance $p) (make-keyword $v $line))]
+    [true (r-pair (p-advance $p) (make-literal "unknown" $v $line))])))
+
+;; ── 33 parse-expr — 단일 표현식 (atom 또는 S-expr/array/map/block)
+
+(defn parse-expr [$p]
+  (let [[$t (p-peek $p)] [$k (get $t :kind)]]
+  (cond
+    [(= $k "LParen")   (parse-sexpr $p)]
+    [(= $k "LBracket") (parse-bracket $p)]
+    [(= $k "LBrace")   (parse-map $p)]
+    [true (parse-atom $p)])))
+
+;; ── 33 parse-sexpr (parens)
+
+(defn parse-sexpr [$p]
+  (let [[$start-tok (p-peek $p)] [$line (get $start-tok :line)]
+      [$p1 (p-advance $p)]                          ;; consume (
+      [$first (parse-args $p1 [])]                  ;; collect until )
+      [$p2 (get $first :p)] [$args (get $first :node)]]
+  (if (= (length $args) 0)
+    (r-pair (parse-consume-rparen $p2) (make-sexpr "" (list) $line))
+    (let [[$op-node (get $args 0)]
+          [$op (if (= (get $op-node :kind) "literal")
+                 (get $op-node :value)
+                 (if (= (get $op-node :kind) "variable")
+                   (str "$" (get $op-node :name))
+                   "unknown"))]
+          [$rest (slice $args 1 (length $args))]]
+      (cond
+        [(= $op "try")
+         ;; try-catch-finally: (try body (catch param body) (finally body))
+         (let [[$body (if (> (length $rest) 0) (get $rest 0) null)]
+               [$catch-clause (if (> (length $rest) 1) (get $rest 1) null)]
+               [$finally-clause (if (> (length $rest) 2) (get $rest 2) null)]]
+           (r-pair (parse-consume-rparen $p2)
+                   (make-try $body $catch-clause $finally-clause $line)))]
+        [(= $op "loop")
+         ;; loop: (loop [[$i 0] (< $i 10) (+ $i 1)] body...)
+         ;; 형식: (loop [init-binding condition update] body)
+         (let [[$loop-array (if (> (length $rest) 0) (get $rest 0) null)]
+               [$body-start (if (> (length $rest) 1) (get $rest 1) null)]]
+           (if (null? $loop-array)
+             (r-pair (parse-consume-rparen $p2) (make-sexpr "loop" (list) $line))
+             (if (not (= (get $loop-array :kind) "array"))
+               (r-pair (parse-consume-rparen $p2) (make-sexpr "loop" $rest $line))
+               (let [[$items (get $loop-array :items)]
+                     [$init (if (> (length $items) 0) (get $items 0) null)]
+                     [$condition (if (> (length $items) 1) (get $items 1) null)]
+                     [$update (if (> (length $items) 2) (get $items 2) null)]
+                     [$body-exprs (slice $rest 1 (length $rest))]]
+                 (r-pair (parse-consume-rparen $p2)
+                         (make-loop $init $condition $update
+                                   (if (= (length $body-exprs) 1)
+                                     (get $body-exprs 0)
+                                     (make-sexpr "do" $body-exprs $line))
+                                   $line))))))]
+        [true
+         (r-pair (parse-consume-rparen $p2)
+                 (make-sexpr $op $rest $line))])))))
+
+(defn parse-consume-rparen [$p]
+  (let [[$t (p-peek $p)]]
+  (if (and (not (null? $t)) (= (get $t :kind) "RParen"))
+    (p-advance $p)
+    $p)))
+
+;; args 수집 (재귀): RParen 만나면 중단
+(defn parse-args [$p $acc]
+  (let [[$t (p-peek $p)]]
+  (cond
+    [(null? $t)                              (r-pair $p $acc)]
+    [(= (get $t :kind) "RParen")             (r-pair $p $acc)]
+    [(= (get $t :kind) "RBracket")           (r-pair $p $acc)]
+    [(= (get $t :kind) "RBrace")             (r-pair $p $acc)]
+    [true
+     (let [[$one (parse-expr $p)]]
+       (parse-args (get $one :p) (append $acc (get $one :node))))])))
+
+;; ── 34 parse-bracket — [a b c] 또는 [FUNC ...] 블록
+
+(defn parse-bracket [$p]
+  (let [[$tok (p-peek $p)] [$line (get $tok :line)]
+      [$p1 (p-advance $p)]                ;; consume [
+      [$next (p-peek $p1)]]
+  (if (and (not (null? $next))
+           (= (get $next :kind) "Symbol")
+           (is-block-type? (get $next :value))
+           (= (get $next :value) (upper-case (get $next :value))))
+    (parse-named-block $p1 $line)
+    (parse-array $p1 $line))))
+
+(defn is-block-type? [$s]
+  (let [[$c (char-at $s 0)]]
+  (and (>= $c "A") (<= $c "Z"))))
+
+(defn upper-case [$s]
+  $s)   ;; FL stdlib 기본 upper-case 가 없으면 identity. 판별엔 첫글자만 본다.
+
+(defn parse-array [$p $line]
+  (let [[$collected (parse-args $p [])]
+      [$p2 (get $collected :p)] [$items (get $collected :node)]]
+  (r-pair (parse-consume-rbracket $p2) (make-array-block $items $line))))
+
+(defn parse-consume-rbracket [$p]
+  (let [[$t (p-peek $p)]]
+  (if (and (not (null? $t)) (= (get $t :kind) "RBracket"))
+    (p-advance $p)
+    $p)))
+
+;; [TYPE name? :k v :k v ...]  Named block (FUNC/ROUTE/PAGE 등)
+(defn parse-named-block [$p $line]
+  (let [[$type-tok (p-peek $p)] [$type (get $type-tok :value)]
+      [$p1 (p-advance $p)]
+      [$name-info (parse-optional-name $p1)]
+      [$p2 (get $name-info :p)] [$name (get $name-info :node)]
+      [$fields-info (parse-block-fields $p2 {})]
+      [$p3 (get $fields-info :p)] [$fields (get $fields-info :node)]]
+  (r-pair (parse-consume-rbracket $p3)
+          (make-block $type $name $fields $line))))
+
+(defn parse-optional-name [$p]
+  (let [[$t (p-peek $p)]]
+  (if (and (not (null? $t))
+           (= (get $t :kind) "Symbol")
+           (not (= (char-at (get $t :value) 0) ":")))
+    (r-pair (p-advance $p) (get $t :value))
+    (r-pair $p null))))
+
+;; :k v :k v ... 반복. RBracket 만나면 중단.
+(defn parse-block-fields [$p $acc]
+  (if (p-end? $p) (r-pair $p $acc)
+    (let [[$t (p-peek $p)]]
+      (if (= (get $t :kind) "Keyword")
+        (let [[$key (get $t :value)]
+              [$p1 (p-advance $p)]
+              [$val (parse-expr $p1)]]
+          (parse-block-fields (get $val :p) (_fl_map_set $acc $key (get $val :node))))
+        (r-pair $p $acc)))))
+;; ──────────────────────────────────────
+
+(defn parse-map [$p]
+  (let [[$tok (p-peek $p)] [$line (get $tok :line)]
+      [$p1 (p-advance $p)]
+      [$collected (parse-args $p1 [])]
+      [$p2 (get $collected :p)] [$items (get $collected :node)]]
+  (r-pair (parse-consume-rbrace $p2) (make-map-block $items $line))))
+
+(defn parse-consume-rbrace [$p]
+  (let [[$t (p-peek $p)]]
+  (if (and (not (null? $t)) (= (get $t :kind) "RBrace"))
+    (p-advance $p)
+    $p)))
+
+;; ── 40/44 공개 API: parse(tokens) → ast list
+
+(defn parse-all [$p]
+  (if (p-end? $p)
+  (get $p :ast)
+  (let [[$one (parse-expr $p)]
+        [$p2 (p-append-ast (get $one :p) (get $one :node))]]
+    (parse-all $p2))))
+
+(defn parse [$tokens]
+  (parse-all (p-make $tokens)))
+
+;; ── Codegen: FL AST → JS source ────────────────────────────────────
+
+(defn js-reserved? [$n]
+  (or (= $n "default") (= $n "class") (= $n "const") (= $n "let")
+  (= $n "if") (= $n "else") (= $n "switch") (= $n "case")
+  (= $n "break") (= $n "continue") (= $n "for") (= $n "while")
+  (= $n "function") (= $n "return") (= $n "throw") (= $n "try")
+  (= $n "catch") (= $n "new") (= $n "delete") (= $n "typeof")
+  (= $n "instanceof") (= $n "var") (= $n "in") (= $n "of")
+  (= $n "this") (= $n "super") (= $n "void") (= $n "yield")
+  (= $n "async") (= $n "await") (= $n "import") (= $n "export")
+  (= $n "enum") (= $n "do") (= $n "with") (= $n "finally")
+  (= $n "null") (= $n "true") (= $n "false")))
+
+(defn js-name-inner [$n]
+  (let [[$g (str-replace (str-replace (str-replace (str-replace (str-replace (str-replace (str-replace $n "-" "_") "?" "_q") "!" "_x") ">" "_gt") "<" "_lt") "*" "_st") "+" "_pl")]]
+  (if (js-reserved? $g) (str $g "_") $g)))
+
+(defn js-name [$n]
+  (if (null? $n) "_" (js-name-inner $n)))
+
+(defn js-esc-inner [$s]
+  (str-replace (str-replace (str-replace (str-replace (str-replace $s "\\" "\\\\") "\"" "\\\"") "\n" "\\n") "\r" "\\r") "\t" "\\t"))
+
+(defn js-esc [$s]
+  (str "\"" (js-esc-inner $s) "\""))
+
+(defn get-block-items [$node]
+  (if (null? $node) (list)
+  (if (and (= (get $node :kind) "block") (= (get $node :type) "Array"))
+    (get (get $node :fields) "items")
+    $node)))
+
+;; ═══════ Code Generation ═══════
+
+(defn cg [$n]
+  (cond
+  [(null? $n) "null"]
+  [(= (get $n :kind) "literal") (cg-literal $n)]
+  [(= (get $n :kind) "variable") (js-name (get $n :name))]
+  [(= (get $n :kind) "keyword") (js-esc (get $n :name))]
+  [(= (get $n :kind) "template-string") (cg-template-string $n)]
+  [(= (get $n :kind) "try") (cg-try $n)]
+  [(= (get $n :kind) "loop") (cg-loop $n)]
+  [(= (get $n :kind) "sexpr") (cg-sexpr $n)]
+  [(= (get $n :kind) "block") (cg-block $n)]
+  [(= (get $n :kind) "and") (cg-and (get $n :args))]
+  [(= (get $n :kind) "or") (cg-or (get $n :args))]
+  [(= (get $n :kind) "pattern-match") (cg-match $n)]
+  [(= (get $n :kind) "await") (str "(await " (cg (get $n :argument)) ")")]
+  [(= (get $n :kind) "throw") (str "((()=>{throw new Error(String(" (cg (get $n :argument)) "))})())")]
+  [true "null"]))
+
+(defn cg-literal [$n]
+  (let [[$t (get $n :type)] [$v (get $n :value)]]
+  (cond
+    [(= $t "number") (str $v)]
+    [(= $t "string") (js-esc $v)]
+    [(= $t "boolean") (if $v "true" "false")]
+    [(= $t "symbol") (cond [(= $v "true") "true"] [(= $v "false") "false"] [(= $v "null") "null"] [(= $v "nil") "null"] [true (js-name $v)])]
+    [true "null"])))
+
+(defn cg-template-string [$n]
+  (str "`" (str-replace (str-replace (get $n :value) "\\" "\\\\") "`" "\\`") "`"))
+
+(defn cg-try [$n]
+  (let [[$body (cg (get $n :body))]
+      [$catch (get $n :catch)]
+      [$finally (get $n :finally)]
+      [$c-code (if (null? $catch) "" (cg-catch-clause $catch))]
+      [$f-code (if (null? $finally) "" (str "finally{" (cg $finally) "}"))]]
+  (str "(()=>{try{return " $body "}catch(err){" $c-code "}" $f-code "})()")))
+
+(defn cg-catch-clause [$c]
+  (let [[$is-sexpr (= (get $c :kind) "sexpr")]
+      [$param (if $is-sexpr (js-name (get (get (get $c :args) 0) :name)) "err")]
+      [$body (if $is-sexpr (cg (get (get $c :args) 1)) (cg $c))]]
+  (str "let " $param "=err;return " $body ";")))
+
+(defn cg-func-block [$n]
+  (let [[$name (js-name (get $n :name))]
+      [$f (get $n :fields)]
+      [$params-block (get $f :params)]
+      [$body-node (get $f :body)]
+      [$ps-info (extract-params (get-block-items $params-block))]
+      [$body (cg $body-node)]
+      [$pre (get $ps-info :preamble)]
+      [$final-body (if (= (length $pre) 0) $body (str "((() => { " $pre " return " $body "; })())"))]]
+  (str "function " $name "(" (get $ps-info :params) ") { return " $final-body "; }")))
+
+(defn cg-block [$n]
+  (let [[$t (get $n :type)] [$f (get $n :fields)]]
+  (cond
+    [(= $t "FUNC") (cg-func-block $n)]
+    [(= $t "Map") (str "({" (cg-map-entries $f) "})")]
+    [(= $t "Array") (str "[" (cg-args (get $f "items")) "]")]
+    [true "null"])))
+
+(defn cg-map-entries [$f]
+  (let [[$items (get $f "items")]]
+  (if (array? $items)
+    (cg-map-flat-loop $items 0 "")
+    (cg-map-loop (map-entries $f) 0 ""))))
+
+(defn cg-map-loop [$e $i $acc]
+  (if (>= $i (length $e)) $acc
+  (let [[$pair (str (js-esc (get (get $e $i) 0)) ":" (cg (get (get $e $i) 1)))]]
+    (cg-map-loop $e (+ $i 1) (if (= $i 0) $pair (str $acc "," $pair))))))
+
+(defn cg-map-flat-loop [$it $i $acc]
+  (if (>= $i (length $it)) $acc
+  (let [[$k (get $it $i)] [$v (get $it (+ $i 1))]
+        [$key (cond [(= (get $k :kind) "keyword") (js-esc (get $k :name))] [(= (get $k :kind) "literal") (js-esc (str (get $k :value)))] [true "\"_anon\""])]
+        [$pair (str $key ":" (cg $v))]]
+    (cg-map-flat-loop $it (+ $i 2) (if (= $i 0) $pair (str $acc "," $pair))))))
+
+;; ═══════ Special Forms ═══════
+
+(defn cg-sexpr [$n]
+  (let [[$op (get $n :op)]]
+  (if (string? $op)
+    (cg-sexpr-dispatch $op (get $n :args))
+    (str "(" (cg $op) ")(" (cg-args (get $n :args)) ")"))))
+
+(defn cg-sexpr-dispatch [$op $args]
+  (cond
+  [(= $op "if") (str "(" (cg (get $args 0)) "?" (cg (get $args 1)) ":" (if (>= (length $args) 3) (cg (get $args 2)) "null") ")")]
+  [(= $op "fn") (cg-fn $args)]
+  [(= $op "defn") (cg-defn $args)]
+  [(= $op "let") (cg-let $args)]
+  [(= $op "do") (str "(()=>{" (cg-do-body $args 0 "") "})()")]
+  [(= $op "cond") (cg-cond $args)]
+  [(= $op "loop") (cg-loop $args)]
+  [(= $op "recur") (str "{__recur:true,a:[" (cg-args $args) "]}")]
+  [(= $op "and") (str "(" (join (map (fn [$a] (cg $a)) $args) "&&") ")")]
+  [(= $op "or") (str "(" (join (map (fn [$a] (cg $a)) $args) "||") ")")]
+  [(= $op "+") (if (= (length $args) 0) "0" (str "(" (binop-loop $args 0 "" "+") ")"))]
+  [(= $op "-") (if (= (length $args) 1) (str "(-" (cg (get $args 0)) ")") (str "(" (binop-loop $args 0 "" "-") ")"))]
+  [(= $op "*") (if (= (length $args) 0) "1" (str "(" (binop-loop $args 0 "" "*") ")"))]
+  [(= $op "/") (str "(" (cg (get $args 0)) "/" (cg (get $args 1)) ")")]
+  [(= $op "=") (str "(" (cg (get $args 0)) "===" (cg (get $args 1)) ")")]
+  [(= $op "<") (str "(" (cg (get $args 0)) "<" (cg (get $args 1)) ")")]
+  [(= $op ">") (str "(" (cg (get $args 0)) ">" (cg (get $args 1)) ")")]
+  [(= $op "<=") (str "(" (cg (get $args 0)) "<=" (cg (get $args 1)) ")")]
+  [(= $op ">=") (str "(" (cg (get $args 0)) ">=" (cg (get $args 1)) ")")]
+  [(= $op "!=") (str "(" (cg (get $args 0)) "!==" (cg (get $args 1)) ")")]
+  [(= $op "%") (str "(" (cg (get $args 0)) "%" (cg (get $args 1)) ")")]
+  [(= $op "while") (str "(()=>{ while(" (cg (get $args 0)) ") { " (cg-stmts (slice $args 1 (length $args)) 0 "") " } })()")]
+  [(= $op "set!") (str "(" (js-name (get (get $args 0) :name)) " = " (cg (get $args 1)) ")")]
+  [(= $op "define") (str "const " (extract-name (get $args 0)) "=" (cg (get $args 1)))]
+  [true (cg-native-dispatch $op (cg-args $args))]))
+
+(defn cg-fn [$args]
+  (let [[$ps-info (extract-params (get-block-items (get $args 0)))]
+      [$body (cg (get $args 1))]
+      [$pre (get $ps-info :preamble)]
+      [$final-body (if (= (length $pre) 0) $body (str "((() => { " $pre " return " $body "; })())"))]]
+  (str "((" (get $ps-info :params) ") => " $final-body ")")))
+
+(defn cg-defn [$args]
+  (let [[$ps-info (extract-params (get-block-items (get $args 1)))]
+      [$body (cg (get $args 2))]
+      [$pre (get $ps-info :preamble)]
+      [$final-body (if (= (length $pre) 0) $body (str "((() => { " $pre " return " $body "; })())"))]]
+  (str "var " (extract-name (get $args 0)) " = (" (get $ps-info :params) ") => " $final-body)))
+
+(defn cg-let [$args]
+  (let [[$items (get-block-items (get $args 0))]
+      [$first (get $items 0)]
+      [$nested (and (= (get $first :kind) "block") (= (get $first :type) "Array"))]
+      [$bindings (if $nested (cg-let-2d $items 0 "") (cg-let-1d $items 0 ""))]
+      [$body (cg-do-body (slice $args 1 (length $args)) 0 "")]]
+  (str "((()=>{" $bindings $body "})())")))
+
+(defn cg-let-1d [$it $i $acc]
+  (if (>= $i (length $it)) $acc
+  (cg-let-1d $it (+ $i 2) (str $acc "let " (extract-name (get $it $i)) "=" (cg (get $it (+ $i 1))) ";"))))
+
+(defn cg-let-2d [$it $i $acc]
+  (if (>= $i (length $it)) $acc
+  (let [[$p (get-block-items (get $it $i))]]
+    (cg-let-2d $it (+ $i 1) (str $acc "let " (extract-name (get $p 0)) "=" (cg (get $p 1)) ";")))))
+
+(defn cg-do-body [$args $i $acc]
+  (if (>= $i (length $args)) $acc
+  (let [[$last (= $i (- (length $args) 1))]
+        [$c (cg (get $args $i))]
+        [$sep (if $last "return " "")]]
+    (cg-do-body $args (+ $i 1) (str $acc $sep $c ";")))))
+
+(defn cg-stmts [$args $i $acc]
+  (if (>= $i (length $args)) $acc
+  (cg-stmts $args (+ $i 1) (str $acc (cg (get $args $i)) ";"))))
+
+(defn cg-cond [$args]
+  (if (= (length $args) 0) "null"
+  (let [[$first (get $args 0)]
+        [$nested (and (= (get $first :kind) "block") (= (get $first :type) "Array"))]]
+    (if $nested
+      (cg-cond-nested $args (- (length $args) 1) "null")
+      (cg-cond-flat $args 0 "null")))))
+
+(defn cg-cond-nested [$args $i $acc]
+  (if (< $i 0) $acc
+  (let [[$items (get-block-items (get $args $i))]]
+    (cg-cond-nested $args (- $i 1) (str "(" (cg (get $items 0)) "?" (cg (get $items 1)) ":" $acc ")")))))
+
+(defn cg-cond-flat [$args $i $acc]
+  (let [[$len (length $args)]]
+  (if (>= $i $len) $acc
+    (if (= $i (- $len 1)) (str "(" (cg (get $args $i)) ")")
+      (str "(" (cg (get $args $i)) "?" (cg (get $args (+ $i 1))) ":" (cg-cond-flat $args (+ $i 2) $acc) ")")))))
+
+(defn cg-loop [$args]
+  (let [[$items (get-block-items (get $args 0))]
+      [$first (get $items 0)]
+      [$nested (and (= (get $first :kind) "block") (= (get $first :type) "Array"))]
+      [$inits (if $nested (loop-inits-2d $items 0 "") (loop-inits-1d $items 0 ""))]
+      [$names (if $nested (loop-names-2d $items 0 "") (loop-names-1d $items 0 ""))]
+      [$body (cg-do-body (slice $args 1 (length $args)) 0 "")]]
+  (str "((()=>{" $inits "while(true){let __r=(()=>{" $body "})();if(__r&&__r.__recur){" (if (= (length $names) 0) "" (str "[" $names "]=__r.a;")) "continue;}return __r;}})())")))
+
+(defn loop-inits-1d [$it $i $acc]
+  (if (>= $i (length $it)) $acc (loop-inits-1d $it (+ $i 2) (str $acc "let " (extract-name (get $it $i)) "=" (cg (get $it (+ $i 1))) ";"))))
+(defn loop-inits-2d [$it $i $acc]
+  (if (>= $i (length $it)) $acc (let [[$p (get-block-items (get $it $i))]] (loop-inits-2d $it (+ $i 1) (str $acc "let " (extract-name (get $p 0)) "=" (cg (get $p 1)) ";")))))
+(defn loop-names-1d [$it $i $acc]
+  (if (>= $i (length $it)) $acc (let [[$n (extract-name (get $it $i))]] (loop-names-1d $it (+ $i 2) (if (= (length $acc) 0) $n (str $acc "," $n))))))
+(defn loop-names-2d [$it $i $acc]
+  (if (>= $i (length $it)) $acc (let [[$p (get-block-items (get $it $i))] [$n (extract-name (get $p 0))]] (loop-names-2d $it (+ $i 1) (if (= (length $acc) 0) $n (str $acc "," $n))))))
+
+;; ═══════ Arguments & Params ═══════
+
+(defn cg-args [$args]
+  (args-loop $args 0 ""))
+(defn args-loop [$args $i $acc]
+  (if (or (null? $args) (>= $i (length $args))) $acc (let [[$c (cg (get $args $i))]] (args-loop $args (+ $i 1) (if (= $i 0) $c (str $acc "," $c))))))
+
+(defn binop-loop [$args $i $acc $op]
+  (if (>= $i (length $args)) $acc (let [[$c (cg (get $args $i))]] (binop-loop $args (+ $i 1) (if (= $i 0) $c (str $acc $op $c)) $op))))
+
+(defn extract-name [$n]
+  (cond [(= (get $n :kind) "variable") (js-name (get $n :name))] [(= (get $n :kind) "literal") (js-name (get $n :value))] [true "_anon"]))
+
+(defn extract-params [$it]
+  (extract-params-loop $it 0 "" "" 0))
+(defn extract-params-loop [$it $i $ps $pre $tc]
+  (if (or (null? $it) (>= $i (length $it))) {:params $ps :preamble $pre}
+  (let [[$c (get $it $i)] [$k (get $c :kind)]]
+    (if (or (= $k "variable") (= $k "literal")) (extract-params-loop $it (+ $i 1) (if (= (length $ps) 0) (extract-name $c) (str $ps "," (extract-name $c))) $pre $tc)
+      (if (and (= $k "block") (= (get $c :type) "Array"))
+        (let [[$t (str "_arg" $tc)] [$sub (get (get $c :fields) "items")]]
+          (extract-params-loop $it (+ $i 1) (if (= (length $ps) 0) $t (str $ps "," $t)) (str $pre (destructure-loop $sub $t 0)) (+ $tc 1)))
+        (extract-params-loop $it (+ $i 1) (if (= (length $ps) 0) "p" (str $ps ",p")) $pre $tc))))))
+
+(defn destructure-loop [$it $t $i]
+  (if (>= $i (length $it)) "" (str "let " (extract-name (get $it $i)) "=" $t "[" $i "]; " (destructure-loop $it $t (+ $i 1)))))
+
+(defn cg-native-dispatch [$op $as]
+  (cond
+  [(= $op "str") (str "_fl_str(" $as ")")]
+  [(= $op "length") (str "_fl_length(" $as ")")]
+  [(= $op "println") (str "_fl_print(" $as ")")]
+  [(= $op "print") (str "_fl_print(" $as ")")]
+  [true (str (js-name $op) "(" $as ")")]))
+
+;; ═══════ Prelude ═══════
+
+(defn prelude-parts []
+  (list
+    "const _fl_str = (...xs) => xs.map(x => x==null?'':String(x)).join('');"
+    "const _fl_length = (x) => (x?x.length:0);"
+    "const _fl_get = (o,k,d) => { if(o==null)return d||null; let ks=String(k).startsWith(':')?k.slice(1):String(k); if(Array.isArray(o)){let idx=parseInt(ks);if(!isNaN(idx))return o[idx]!==undefined?o[idx]:(d||null);if(ks==='length')return o.length;} if(typeof o==='object'){if(o[ks]!==undefined)return o[ks];} return d||null; }"
+    "const _fl_null_q = (v) => v===null||v===undefined;"
+    "const _fl_keys = (o) => o?Object.keys(o):[];"
+    "const _fl_map_set = (o,k,v) => ({...o,[k]:v});"
+    "const _fl_has_key_q = (o,k) => o?(String(k) in o):false;"
+    "const _fl_append = (l,x) => [...(l||[]),x];"
+    "const list = (...args) => [...args];"
+    "const append = (l,x) => [...(l||[]),x];"
+    "const _fl_first = (l) => (l&&l.length>0)?l[0]:null;"
+    "const _fl_last = (l) => (l&&l.length>0)?l[l.length-1]:null;"
+    "const _fl_rest = (l) => (l&&l.length>0)?l.slice(1):[];"
+    "const _fl_slice = (l,a,b) => (l||[]).slice(a,b);"
+    "const _fl_map = (arr,fn) => (arr||[]).map(x=>fn(x));"
+    "const _fl_filter = (arr,fn) => (arr||[]).filter(x=>{const r=fn(x);return r!==false&&r!==null;});"
+    "const _fl_reduce = (arr,fn,init) => (arr||[]).reduce((a,x)=>fn(a,x),init);"
+    "const _fl_some = (f,l) => (l||[]).some(x=>f(x));"
+    "const _fl_every = (f,l) => (l||[]).every(x=>f(x));"
+    "const _fl_file_read = (p) => require('fs').readFileSync(p,'utf8');"
+    "const _fl_file_write = (p,c) => require('fs').writeFileSync(p,c);"
+    "const _fl_file_exists = (p) => require('fs').existsSync(p);"
+    "const _fl_file_delete = (p) => { try { require('fs').unlinkSync(p); } catch(e) {} };"
+    "const _fl_file_append = (p,c) => require('fs').appendFileSync(p,String(c));"
+    "const _fl_file_copy = (s,d) => require('fs').copyFileSync(s,d);"
+    "const _fl_file_rename = (o,n) => require('fs').renameSync(o,n);"
+    "const _fl_file_size = (p) => { try { return require('fs').statSync(p).size; } catch(e) { return 0; } };"
+    "const _fl_file_modified = (p) => { try { return require('fs').statSync(p).mtimeMs; } catch(e) { return 0; } };"
+    "const _fl_file_mkdir = (p) => { try { require('fs').mkdirSync(p,{recursive:true}); } catch(e) {} };"
+    "const _fl_file_rmdir = (p) => { try { require('fs').rmSync(p,{recursive:true,force:true}); } catch(e) {} };"
+    "const _fl_file_list = (p) => { try { return require('fs').readdirSync(p); } catch(e) { return []; } };"
+    "const _fl_process_run = (cmd) => { try { return require('child_process').execSync(cmd,{encoding:'utf8'}); } catch(e) { return ''; } };"
+    "const _fl_process_run_args = (cmd,args) => { try { return require('child_process').execSync(cmd+' '+(args||[]).join(' '),{encoding:'utf8'}); } catch(e) { return ''; } };"
+    "const _fl_process_exec = (cmd) => { try { return require('child_process').execSync(cmd,{encoding:'utf8'}); } catch(e) { return ''; } };"
+    "const _fl_process_exec_args = (cmd,args) => { try { return require('child_process').execSync(cmd+' '+(args||[]).join(' '),{encoding:'utf8'}); } catch(e) { return ''; } };"
+    "const _fl_process_spawn = (cmd,args) => { try { const r=require('child_process').spawnSync(cmd,args||[],{encoding:'utf8'}); return r.stdout||''; } catch(e) { return ''; } };"
+    "const _fl_process_kill = (pid) => { try { process.kill(pid); } catch(e) {} };"
+    "const _fl_process_wait = (pid) => null;"
+    "const _fl_env_get = (k) => process.env[k]||null;"
+    "const _fl_env_set = (k,v) => { process.env[k]=String(v); };"
+    "const _fl_env_all = () => process.env;"
+    "const _fl_file_is_file = (p) => { try { return require('fs').statSync(p).isFile(); } catch(e) { return false; } };"
+    "const _fl_file_is_dir = (p) => { try { return require('fs').statSync(p).isDirectory(); } catch(e) { return false; } };"
+    "const _fl_process_exists = (pid) => { try { process.kill(pid,0); return true; } catch(e) { return false; } };"
+    "const _fl_process_getcwd = () => process.cwd();"
+    "const _fl_process_chdir = (p) => { try { process.chdir(p); } catch(e) {} };"
+    "const _fl_process_pid = () => process.pid;"
+    "const _fl_process_ppid = () => process.ppid||null;"
+    "var file_read = (p) => _fl_file_read(String(p));"
+    "var file_write = (p,c) => _fl_file_write(String(p),String(c));"
+    "var file_exists = (p) => _fl_file_exists(String(p));"
+    "const _fl_get_argv = () => (typeof process!=='undefined'?process.argv.slice(2):[]);"
+    "const _fl_print = (v) => { console.log(v); return v; }"
+    "const null_q = _fl_null_q;"
+    "const some_q = _fl_some;"
+    "const every_q = _fl_every;"
+    "const cli_args = _fl_get_argv;"
+    "const get = _fl_get;"
+    "const keys = _fl_keys;"
+    "const has_key_q = _fl_has_key_q;"
+    "const slice = _fl_slice;"
+    "const first = _fl_first;"
+    "const last = _fl_last;"
+    "const rest = _fl_rest;"
+    "const map = (fn,arr) => (arr||[]).map(x=>fn(x));"
+    "const filter = (fn,arr) => (arr||[]).filter(x=>{const r=fn(x);return r!==false&&r!==null;});"
+    "const reduce = (fn,init,arr) => (arr||[]).reduce((a,x)=>fn(a,x),init);"
+    "const print = _fl_print;"
+    "const println = (v) => { console.log(v==null?'':String(v)); return v; }"
+    "var str_replace = (s,ov,nv) => { if(s==null)return ''; const st=String(s); return st.split(String(ov)).join(nv==null?'':String(nv)); };"
+    "const str_index_of = (s,sub) => (typeof s==='string'&&typeof sub==='string')?s.indexOf(sub):-1;"
+    "const index_of = str_index_of;"
+    "const str_slice = (s,a,b) => s?(b===undefined?s.slice(a):s.slice(a,b)):'';"
+    "const substring = str_slice;"
+    "const char_at = (s,i) => (s&&s[i])||null;"
+    "const char_code_at = (s,i) => typeof s==='string'?s.charCodeAt(i):0;"
+    "const trim = (s) => String(s||'').trim();"
+    "const starts_with_q = (s,p) => String(s||'').startsWith(String(p||''));"
+    "const ends_with_q = (s,sf) => String(s||'').endsWith(String(sf||''));"
+    "const replace = (s,ov,nv) => { if(s==null)return ''; const st=String(s); if(ov instanceof RegExp)return st.replace(ov,nv==null?'':String(nv)); return st.split(String(ov)).join(nv==null?'':String(nv)); };"
+    "const split = (s,sep) => String(s||'').split(sep);"
+    "const str_join = (arr,sep) => (arr||[]).join(sep===undefined?'':sep);"
+    "const join = str_join;"
+    "const concat = (a,b) => (Array.isArray(a)&&Array.isArray(b))?[...a,...b]:String(a||'')+String(b||'');"
+    "const push = (arr,v) => [...(arr||[]),v];"
+    "const pop = (arr) => (arr&&arr.length>0)?arr.slice(0,-1):[];"
+    "const reverse = (arr) => Array.isArray(arr)?[...arr].reverse():arr;"
+    "const sort_by = (arr,fn) => Array.isArray(arr)?[...arr].sort((a,b)=>fn(a)<fn(b)?-1:fn(a)>fn(b)?1:0):arr;"
+    "const flat_map = (arr,fn) => (arr||[]).flatMap(fn);"
+    "const range = (s,e) => { const r=[]; let st=e===undefined?0:s; let en=e===undefined?s:e; for(let i=st;i<en;i++)r.push(i); return r; };"
+    "const merge = (a,b) => Object.assign({},a,b);"
+    "const assoc = (o,k,v) => { const r=Object.assign({},o); const key=typeof k==='string'&&k.startsWith(':')?k.slice(1):String(k); r[key]=v; return r; };"
+    "const dissoc = (o,k) => { const r=Object.assign({},o); const key=typeof k==='string'&&k.startsWith(':')?k.slice(1):String(k); delete r[key]; return r; };"
+    "var map_entries = (m) => m instanceof Map?[...m.entries()]:(m&&typeof m==='object'&&!Array.isArray(m)?Object.entries(m):[]);"
+    "var map_keys = (m) => m instanceof Map?[...m.keys()]:(m&&typeof m==='object'&&!Array.isArray(m)?Object.keys(m):[]);"
+    "var map_values = (m) => m instanceof Map?[...m.values()]:(m&&typeof m==='object'&&!Array.isArray(m)?Object.values(m):[]);"
+    "const array_q = (v) => Array.isArray(v);"
+    "var list_q = (v) => Array.isArray(v);"
+    "var map_q = (v) => v!==null&&typeof v==='object'&&!Array.isArray(v);"
+    "var fn_q = (v) => typeof v==='function';"
+    "const number_q = (v) => typeof v==='number';"
+    "const string_q = (v) => typeof v==='string';"
+    "var str_upper = (s) => String(s||'').toUpperCase();"
+    "var str_lower = (s) => String(s||'').toLowerCase();"
+    "var str_contains = (s,sub) => String(s||'').includes(String(sub||''));"
+    "var str_starts_with = (s,p) => String(s||'').startsWith(String(p||''));"
+    "var str_ends_with = (s,sf) => String(s||'').endsWith(String(sf||''));"
+    "var str_trim = (s) => String(s||'').trim();"
+    "var str_length = (s) => String(s||'').length;"
+    "var str_split = (s,sep) => String(s||'').split(sep);"
+    "var take = (n,arr) => (arr||[]).slice(0,n);"
+    "var drop = (n,arr) => (arr||[]).slice(n);"
+    "var zip = (a,b) => { const r=[]; const l=Math.min((a||[]).length,(b||[]).length); for(let i=0;i<l;i++)r.push([a[i],b[i]]); return r; };"
+    "var flatten = (arr) => (arr||[]).flat();"
+    "var sort = (arr,fn) => fn?[...(arr||[])].sort((a,b)=>fn(a,b)?-1:1):[...(arr||[])].sort();"
+    "var math_sqrt = (n) => Math.sqrt(n);"
+    "var math_pi = Math.PI;"
+    "var unknown = (...a) => a[a.length-1];"
+    "function _fl_type_of(v) { if(v===null||v===undefined)return 'nil'; if(Array.isArray(v))return 'list'; return typeof v; }"
+    "const not = (v) => !v;"
+    "const abs = (n) => Math.abs(n);"
+    "const floor = (n) => Math.floor(n);"
+    "const ceil_val = (n) => Math.ceil(n);"
+    "const round = (n) => Math.round(n);"
+    "const max_val = (a,b) => a>b?a:b;"
+    "const min_val = (a,b) => a<b?a:b;"
+    "const error = (msg) => { throw new Error(String(msg)); };"
+    "const now_ms = () => Date.now();"
+    "const now_iso = () => new Date().toISOString();"
+    "const now_unix = () => Math.floor(Date.now()/1000);"
+    "const json_parse = (s) => { try{return JSON.parse(s);}catch(e){return null;} };"
+    "const json_stringify = (v) => JSON.stringify(v);"
+    "const shell_exec = (cmd,inp) => { try{const {execSync}=require('child_process');const opts={encoding:'utf8'};if(inp)opts.input=inp;return execSync(cmd,opts);}catch(e){return '';} };"
+    "const _fl_run_inherit = (cmd) => { require('child_process').spawnSync(cmd,{shell:true,stdio:'inherit'}); };"
+    "const __fl_routes = [];"
+    "const _fl_server_get = (path,fn) => { __fl_routes.push({method:'GET',path,fn}); };"
+    "const _fl_server_start = (port) => { const http=require('http'); http.createServer(async(req,res)=>{ const r=__fl_routes.find(r=>r.method===req.method&&r.path===require('url').parse(req.url).pathname); if(r){const result=await(typeof r.fn==='string'?eval(r.fn):r.fn)(req);res.end(String(result));}else{res.statusCode=404;res.end('Not Found');} }).listen(port);console.log('Server on '+port); };"
+    "const server_get = _fl_server_get;"
+    "const server_start = _fl_server_start;"
+  ))
+
+(defn runtime-prelude []
+  (join (prelude-parts) "\n"))
+
+(defn fl->js-code [$ast]
+  (reduce (fn [acc n] (str acc (cg n) ";\n")) "" $ast))
+
+(defn fl->js-with-prelude [$ast]
+  (str (runtime-prelude) "\n" (fl->js-code $ast)))
+
+(defn count-parens [$tokens]
+  (reduce
+    (fn [$acc $tok]
+      (let [[$k (or (get $tok :type) (get $tok :kind))]]
+        (if (= $k "LParen") (+ $acc 1)
+        (if (= $k "RParen") (- $acc 1)
+        $acc))))
+    0
+    $tokens))
+
+(defn compile-file [$input $output]
+  (let [[$src (file-read $input)]
+      [$tokens (lex $src)]
+      [$depth (count-parens $tokens)]
+      [$ast (parse $tokens)]
+      [$node-count (length $ast)]
+      [$js (fl->js-with-prelude $ast)]]
+  (do
+    (if (not (= $depth 0))
+      (println (str "Warning: " $input ": 괄호 불균형 (깊이=" $depth ")"))
+      null)
+    (file-write $output $js)
+    (println (str "Parsed: " $node-count " nodes"))
+    (println (str "Compiled " $input " -> " $output)))))
+
+;; ── stdlib: 데이터 변환 ─────────────────────────────────────────────
+
+;; 줄 분리
+(defn str-lines [s]
+  (split s "\n"))
+
+;; 단어 분리
+(defn str-words [s]
+  (split (trim s) " "))
+
+;; 줄 합치기
+(defn str-join-lines [lines]
+  (str-join-loop lines 0 ""))
+(defn str-join-loop [lst i acc]
+  (if (>= i (length lst)) acc
+  (str-join-loop lst (+ i 1)
+    (if (= i 0) (get lst 0) (str acc "\n" (get lst i))))))
+
+;; 부분 문자열 출현 횟수
+(defn str-count [s sub]
+  (if (= (length sub) 0) 0
+  (str-count-loop s sub 0 0)))
+(defn str-count-loop [s sub pos acc]
+  (let [[rest (substring s pos (length s))]
+      [idx (index-of rest sub)]]
+  (if (< idx 0) acc
+    (str-count-loop s sub (+ pos idx (length sub)) (+ acc 1)))))
+
+;; CSV 행 파싱 (간단한 버전, 따옴표 미지원)
+(defn csv-parse-line [line]
+  (split line ","))
+
+;; CSV 본문 파싱
+(defn csv-parse [csv]
+  (let [[lines (split csv "\n")]]
+  (csv-parse-loop lines 0 (list))))
+(defn csv-parse-loop [lines i acc]
+  (if (>= i (length lines)) acc
+  (csv-parse-loop lines (+ i 1)
+    (append acc (csv-parse-line (get lines i))))))
+
+;; str-repeat 은 builtin — 재정의 불필요
+
+;; JSON 헬퍼 (json.fl 기반)
+(defn data-json-parse [s]
+  (json-parse s))
+
+(defn data-json-str [obj]
+  (json-stringify obj))
+
+(defn data-json-pretty [obj]
+  (json-stringify obj))
+
+;; 객체를 쿼리 문자열로 변환
+(defn to-query-string [obj]
+  (to-query-loop (keys obj) obj 0 (list)))
+(defn to-query-loop [ks obj i acc]
+  (if (>= i (length ks)) (join acc "&")
+  (let [[k (get ks i)]
+        [v (get obj k)]]
+    (to-query-loop ks obj (+ i 1)
+      (append acc (str k "=" v))))))
+
+;; ── stdlib: hash ────────────────────────────────────────────────────
+;; 해시 함수
+
+(defn hash-simple [s]
+  (hash-simple-loop (str s) 0 5381 0))
+(defn hash-simple-loop [s i hash max]
+  (if (>= i (length s)) (% (abs hash) 2147483647)
+  (hash-simple-loop s (+ i 1)
+    (+ (* hash 33) (char-code-at s i)) (+ i 1))))
+
+(defn hash-fnv1a [s]
+  (let [[fnv-offset 2166136261]
+      [fnv-prime 16777619]]
+  (hash-fnv-loop (str s) 0 fnv-offset)))
+(defn hash-fnv-loop [s i hash]
+  (if (>= i (length s)) (% (abs hash) 2147483647)
+  (hash-fnv-loop s (+ i 1)
+    (* (bit-xor hash (char-code-at s i)) 16777619))))
+
+(defn hash-djb2 [s]
+  (hash-djb-loop (str s) 0 5381))
+(defn hash-djb-loop [s i hash]
+  (if (>= i (length s)) (% (abs hash) 2147483647)
+  (hash-djb-loop s (+ i 1)
+    (+ (* hash 33) (char-code-at s i)))))
+
+(defn hash-object [obj]
+  (hash-simple (json-stringify obj)))
+
+(defn hash-consistent [s seed]
+  (let [[h (hash-simple s)]]
+  (% (+ (* h seed) seed) 2147483647)))
+
+;; ── stdlib: time ────────────────────────────────────────────────────
+;;
+;; now-ms 는 prelude(JS runtime) 에서 이미 `const now_ms = () => Date.now()` 로
+;; 제공되므로 FL 에서 재정의하지 않는다. FL 코드에서 (now-ms) 호출 시
+;; codegen 이 `now_ms()` JS 로 번역 → prelude 정의로 해소됨.
+;; 재정의하면 `Identifier 'now_ms' has already been declared` SyntaxError.
+
+(defn now-s []
+  (floor (/ (now) 1000)))
+
+(defn time-diff-ms [t1 t2]
+  (- t2 t1))
+(defn time-elapsed [start]
+  (- (now) start))
+
+(defn date-parts [ts]
+  {:ts ts :s (floor (/ ts 1000))
+  :m (floor (/ ts 60000))
+  :h (floor (/ ts 3600000))
+  :d (floor (/ ts 86400000))})
+
+(defn ts-to-s [ts]
+  (floor (/ ts 1000)))
+(defn s-to-ts [s]
+  (* s 1000))
+
+(defn time-ago [ts]
+  (let [[diff (- (now) ts)]
+      [s (floor (/ diff 1000))]
+      [m (floor (/ s 60))]
+      [h (floor (/ m 60))]
+      [d (floor (/ h 24))]]
+  (cond [(< s 60) (str s "s ago")]
+        [(< m 60) (str m "m ago")]
+        [(< h 24) (str h "h ago")]
+        [true (str d "d ago")])))
+
+;; ── stdlib: string 확장 ─────────────────────────────────────────────
+
+;; str-starts-with?/str-ends-with? 은 미사용 — starts-with?/ends-with? 내장 사용
+
+;; str-repeat/str-pad-left/str-pad-right 은 builtin — 재정의 불필요
+
+;; str-upper/str-lower/str-contains 는 prelude builtin — 재정의 불필요
+
+
+;; ── stdlib: file ────────────────────────────────────────────────────
+;; 파일 I/O 연산 (native file_* builtin wrapper)
+
+; file-read/file-write: prelude에 const로 정의됨 (중복 방지)
+
+(defn file-append [path content]
+  (_fl_file_append (str path) (str content)))
+
+(defn file-exists? [path]
+  (file_exists (str path)))
+
+(defn file-delete [path]
+  (_fl_file_delete (str path)))
+
+(defn file-copy [src dest]
+  (_fl_file_copy (str src) (str dest)))
+
+(defn file-rename [old new]
+  (_fl_file_rename (str old) (str new)))
+
+(defn file-size [path]
+  (_fl_file_size (str path)))
+
+(defn file-modified [path]
+  (_fl_file_modified (str path)))
+
+(defn file-json [path]
+  (json-parse (file-read (str path))))
+
+(defn file-json-write [path obj]
+  (file-write (str path) (json-stringify obj)))
+
+(defn file-lines [path]
+  (str-lines (file-read (str path))))
+
+(defn file-mkdir [path]
+  (_fl_file_mkdir (str path)))
+
+(defn file-rmdir [path]
+  (_fl_file_rmdir (str path)))
+
+(defn file-list [path]
+  (_fl_file_list (str path)))
+
+(defn file-is-file? [path]
+  (_fl_file_is_file (str path)))
+
+(defn file-is-dir? [path]
+  (_fl_file_is_dir (str path)))
+
+;; ── stdlib: process ─────────────────────────────────────────────────
+;; 프로세스/쉘 연산 (native process_* builtin wrapper)
+
+(defn process-run [cmd]
+  (_fl_process_run (str cmd)))
+
+(defn process-run-args [cmd args]
+  (_fl_process_run_args (str cmd) args))
+
+(defn process-exec [cmd]
+  (_fl_process_exec (str cmd)))
+
+(defn process-exec-args [cmd args]
+  (_fl_process_exec_args (str cmd) args))
+
+(defn process-spawn [cmd args]
+  (_fl_process_spawn (str cmd) args))
+
+(defn process-kill [pid]
+  (_fl_process_kill (floor pid)))
+
+(defn process-exists? [pid]
+  (_fl_process_exists (floor pid)))
+
+(defn process-wait [pid]
+  (_fl_process_wait (floor pid)))
+
+(defn shell-run [cmd]
+  (_fl_run_inherit (str cmd)))
+
+(defn shell-pipe [cmd1 cmd2]
+  (process_exec (str cmd1 " | " cmd2)))
+
+(defn env-get [key]
+  (_fl_env_get (str key)))
+
+(defn env-set [key value]
+  (_fl_env_set (str key) (str value)))
+
+(defn env-all []
+  (_fl_env_all))
+
+(defn getcwd []
+  (_fl_process_getcwd))
+
+(defn chdir [path]
+  (_fl_process_chdir (str path)))
+
+(defn pid []
+  (_fl_process_pid))
+
+(defn pid-parent []
+  (_fl_process_ppid))
+
+;; Vector Math Functions (Phase C-9)
+;; vector-add, vector-dot, vector-magnitude, math-sqrt
+
+(defn vector-add [$v1 $v2]
+  (map (fn [$i]
+  (+ (get $v1 $i) (get $v2 $i)))
+  (range 0 (length $v1))))
+
+(defn vector-dot [$v1 $v2]
+  (reduce (fn [$acc $i]
+  (+ $acc (* (get $v1 $i) (get $v2 $i))))
+  0
+  (range 0 (length $v1))))
+
+(defn vector-magnitude [$v]
+  (math-sqrt
+  (reduce (fn [$acc $x]
+    (+ $acc (* $x $x)))
+    0
+    $v)))
+
+;; math-sqrt 은 prelude builtin (Math.sqrt) — 재정의 불필요
+
+;; math-pow 은 builtin (Math.pow) — 재정의 불필요
+
+(defn cosine-sim [$v1 $v2]
+  (let [[$dot (vector-dot $v1 $v2)]
+            [$mag1 (vector-magnitude $v1)]
+            [$mag2 (vector-magnitude $v2)]]
+  (if (or (= $mag1 0) (= $mag2 0))
+    0
+    (/ $dot (* $mag1 $mag2)))))
+
+
+(defn do-run [$input $extra-args]
+  (let [[$output (str "/tmp/fl-run-" (now-ms) ".js")]
+      [$args-str (str-join $extra-args " ")]]
+  (do
+    (compile-file $input $output)
+    (shell-run (str "node " $output " " $args-str))
+    (file-delete $output))))
+
+(defn cli-main []
+  (let [[$argv (cli-args)]]
+  (if (null? $argv) null
+    (if (= (length $argv) 0) null
+      (let [[$cmd (get $argv 0)]]
+        (if (= $cmd "run")
+          (let [[$input (get $argv 1)]
+                [$extra (slice $argv 2 (length $argv))]]
+            (do-run $input $extra))
+          (let [[$input (get $argv 0)]
+                [$output (if (>= (length $argv) 2) (get $argv 1) (str $input ".out.js"))]]
+            (compile-file $input $output))))))))
+
+;; Entry point trigger
+(cli-main)
+