freelang-editor 11.7.4

package/self-evolve/logs/speed-gen-0.fl

@@ -0,0 +1,1423 @@
+; self/all.fl — Phase 28 (AUTO-GENERATED)
+; $(date)
+
+;; self/lexer.fl — FL 로 작성된 Lexer (Phase 01, [FUNC] 블록 버전)
+;;
+;; v11 defn 이 forward-ref 를 지원하지 않아 [FUNC] 블록 사용.
+;; [FUNC] 는 2-pass 등록이라 상호재귀 허용.
+;;
+;; 입력: source string
+;; 출력: tokens list. 각 토큰 = {:kind :value :line :col}
+;;
+;; 토큰 종류: LParen / RParen / LBracket / RBracket / LBrace / RBrace
+;;     / Number / String / Symbol / Variable / Keyword
+;;     / Unknown / (comment 는 drop)
+;; ──────────────────────────────────────
+;; char predicates
+;; ──────────────────────────────────────
+[FUNC is-digit? :params [c]
+ :body (if (null? c) false (and (>= c "0") (<= c "9")))]
+[FUNC is-alpha? :params [c]
+ :body (if (null? c) false
+     (or (and (>= c "a") (<= c "z"))
+       (and (>= c "A") (<= c "Z"))))]
+[FUNC is-alnum? :params [c] :body (or (is-digit? c) (is-alpha? c))]
+[FUNC is-space? :params [c]
+ :body (or (= c " ") (= c "\t") (= c "\n") (= c "\r"))]
+[FUNC is-symbol-char? :params [c]
+ :body (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}
+;; ──────────────────────────────────────
+[FUNC make-state :params [src]
+ :body {:src src :idx 0 :line 1 :col 1 :tokens []}]
+[FUNC peek-at :params [st offset]
+ :body (let [[src (get st :src)]
+       [i (+ (get st :idx) offset)]]
+     (if (>= i (length src)) null (char-at src i)))]
+[FUNC peek :params [st] :body (peek-at st 0)]
+[FUNC at-end? :params [st]
+ :body (>= (get st :idx) (length (get st :src)))]
+[FUNC advance :params [st]
+ :body (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)}))]
+[FUNC emit :params [st kind value sl sc]
+ :body {:src (get st :src) :idx (get st :idx)
+     :line (get st :line) :col (get st :col)
+     :tokens (append (get st :tokens)
+             (list {:kind kind :type kind :value value :line sl :col sc}))}]
+;; ──────────────────────────────────────
+;; 스킵 (whitespace + ; line comment)
+;; ──────────────────────────────────────
+[FUNC skip-comment :params [st]
+ :body (if (at-end? st) st
+     (let [[c (peek st)]]
+      (if (= c "\n") (advance st) (skip-comment (advance st)))))]
+[FUNC skip-ws :params [st]
+ :body (if (at-end? st) st
+     (let [[c (peek st)]]
+      (cond
+       [(is-space? c) (skip-ws (advance st))]
+       [(= c ";") (skip-ws (skip-comment st))]
+       [true st])))]
+;; ──────────────────────────────────────
+;; 숫자 (정수/실수/음수)
+;; ──────────────────────────────────────
+[FUNC read-number-body :params [st acc has-dot line col]
+ :body (if (at-end? st) (emit st "Number" acc line col)
+     (let [[c (peek st)]]
+      (cond
+       [(is-digit? c)
+        (read-number-body (advance st) (str acc c) has-dot line col)]
+       [(and (= c ".") (not has-dot))
+        (read-number-body (advance st) (str acc c) true line col)]
+       [true (emit st "Number" acc line col)])))]
+[FUNC read-number :params [st]
+ :body (read-number-body st "" false (get st :line) (get st :col))]
+;; ──────────────────────────────────────
+;; 문자열 (escape \n \t \r \" \\)
+;; ──────────────────────────────────────
+[FUNC translate-esc :params [c]
+ :body (cond
+     [(= c "n") "\n"] [(= c "t") "\t"] [(= c "r") "\r"]
+     [(= c "\"") "\""] [(= c "\\") "\\"] [true c])]
+[FUNC read-string-body :params [st acc line col]
+ :body (if (at-end? st) (emit st "String" acc line col)
+     (let [[c (peek st)]]
+      (cond
+       [(= c "\"") (emit (advance st) "String" acc line col)]
+       [(= c "\\")
+        (let [[st2 (advance st)] [c2 (peek st2)]]
+         (read-string-body (advance st2) (str acc (translate-esc c2)) line col))]
+       [true (read-string-body (advance st) (str acc c) line col)])))]
+[FUNC read-string :params [st]
+ :body (let [[line (get st :line)] [col (get st :col)]
+       [st1 (advance st)]]
+     (read-string-body st1 "" line col))]
+;; ──────────────────────────────────────
+;; 심볼 / 변수 / 키워드 (모두 symbol-char 연속)
+;; ──────────────────────────────────────
+[FUNC read-symbol-body-kind :params [st acc line col kind]
+ :body (if (at-end? st) (emit st kind acc line col)
+     (let [[c (peek st)]]
+      (if (is-symbol-char? c)
+       (read-symbol-body-kind (advance st) (str acc c) line col kind)
+       (emit st kind acc line col))))]
+[FUNC read-symbol :params [st]
+ :body (read-symbol-body-kind st "" (get st :line) (get st :col) "Symbol")]
+[FUNC read-variable :params [st]
+ :body (let [[line (get st :line)] [col (get st :col)]
+       [st1 (advance st)]]
+     (read-symbol-body-kind st1 "" line col "Variable"))]
+[FUNC read-keyword :params [st]
+ :body (let [[line (get st :line)] [col (get st :col)]
+       [st1 (advance st)]]
+     (read-symbol-body-kind st1 "" line col "Keyword"))]
+;; ──────────────────────────────────────
+;; 토큰 하나 읽기
+;; ──────────────────────────────────────
+[FUNC read-token :params [st]
+ :body (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)]))))]
+;; ──────────────────────────────────────
+;; 메인 루프 — 모든 토큰 수집
+;; ──────────────────────────────────────
+[FUNC lex-loop :params [st]
+ :body (let [[st1 (skip-ws st)]]
+     (if (at-end? st1)
+      (get st1 :tokens)
+      (lex-loop (read-token st1))))]
+[FUNC lex :params [src] :body (lex-loop (make-state src))]
+;; self/ast.fl — AST 노드 생성자 (Phase 02/21-30)
+;;
+;; v11 src/ast.ts (806 줄, 25+ 노드) 의 FL 재작성.
+;; 모든 노드는 plain map: {:kind "..." ...필드}
+;; 생성자는 [FUNC make-xxx :params [...] :body {:kind ...}]
+;; ──────────────────────────────────────
+;; 21 기본 원자 (Literal/Variable/Keyword/SExpr)
+;; ──────────────────────────────────────
+[FUNC make-literal :params [type value line]
+ :body {:kind "literal" :type type :value value :line line}]
+[FUNC make-variable :params [name line]
+ :body {:kind "variable" :name name :line line}]
+[FUNC make-keyword :params [name line]
+ :body {:kind "keyword" :name name :line line}]
+[FUNC make-sexpr :params [op args line]
+ :body {:kind "sexpr" :op op :args args :line line}]
+;; ──────────────────────────────────────
+;; 22 SExpr 편의 + 원시값 래퍼
+;; ──────────────────────────────────────
+[FUNC make-number :params [v line]
+ :body (make-literal "number" v line)]
+[FUNC make-string :params [v line]
+ :body (make-literal "string" v line)]
+[FUNC make-bool :params [v line]
+ :body (make-literal "boolean" v line)]
+[FUNC make-null :params [line]
+ :body (make-literal "null" null line)]
+[FUNC make-symbol :params [v line]
+ :body (make-literal "symbol" v line)]
+;; ──────────────────────────────────────
+;; 23 Block (Array/Map/Named)
+;; fields 는 items(list) 또는 named map. block 의 type 으로 구분.
+;; ──────────────────────────────────────
+[FUNC make-block :params [type name fields line]
+ :body {:kind "block" :type type :name name :fields fields :line line}]
+[FUNC make-array-block :params [items line]
+ :body (make-block "Array" null {:items items} line)]
+[FUNC make-map-block :params [items line]
+ :body (make-block "Map" null {:items items} line)]
+;; ──────────────────────────────────────
+;; 24 Pattern 7종
+;; ──────────────────────────────────────
+[FUNC make-pattern-literal :params [value line]
+ :body {:kind "pattern-literal" :value value :line line}]
+[FUNC make-pattern-variable :params [name line]
+ :body {:kind "pattern-variable" :name name :line line}]
+[FUNC make-pattern-wildcard :params [line]
+ :body {:kind "pattern-wildcard" :line line}]
+[FUNC make-pattern-list :params [items rest line]
+ :body {:kind "pattern-list" :items items :rest rest :line line}]
+[FUNC make-pattern-struct :params [type-name fields line]
+ :body {:kind "pattern-struct" :type type-name :fields fields :line line}]
+[FUNC make-pattern-or :params [alternatives line]
+ :body {:kind "pattern-or" :alternatives alternatives :line line}]
+[FUNC make-pattern-range :params [start end line]
+ :body {:kind "pattern-range" :start start :end end :line line}]
+;; ──────────────────────────────────────
+;; 25 Pattern matching
+;; ──────────────────────────────────────
+[FUNC make-pattern-match :params [value cases line]
+ :body {:kind "pattern-match" :value value :cases cases :line line}]
+[FUNC make-match-case :params [pattern guard body line]
+ :body {:kind "match-case" :pattern pattern :guard guard :body body :line line}]
+;; ──────────────────────────────────────
+;; 26 함수/타입
+;; ──────────────────────────────────────
+[FUNC make-function-value :params [params body captured-env name]
+ :body {:kind "function-value" :params params :body body
+     :capturedEnv captured-env :name name}]
+[FUNC make-type-class :params [name generics methods line]
+ :body {:kind "type-class" :name name :generics generics
+     :methods methods :line line}]
+[FUNC make-type-class-instance :params [class-name type-name impls line]
+ :body {:kind "type-class-instance" :class class-name :type type-name
+     :impls impls :line line}]
+;; ──────────────────────────────────────
+;; 27 Module / Import
+;; ──────────────────────────────────────
+[FUNC make-module-block :params [name exports body line]
+ :body {:kind "module" :name name :exports exports :body body :line line}]
+[FUNC make-import-block :params [path alias names line]
+ :body {:kind "import" :path path :alias alias :names names :line line}]
+[FUNC make-open-block :params [module-name line]
+ :body {:kind "open" :module module-name :line line}]
+;; ──────────────────────────────────────
+;; 28 AI 블록 (SearchBlock / LearnBlock / ReasoningBlock)
+;; ──────────────────────────────────────
+[FUNC make-search-block :params [query fields line]
+ :body {:kind "search-block" :query query :fields fields :line line}]
+[FUNC make-learn-block :params [topic fields line]
+ :body {:kind "learn-block" :topic topic :fields fields :line line}]
+[FUNC make-reasoning-block :params [name fields line]
+ :body {:kind "reasoning-block" :name name :fields fields :line line}]
+;; ──────────────────────────────────────
+;; 29 Async / Try
+;; ──────────────────────────────────────
+[FUNC make-async-function :params [name params body line]
+ :body {:kind "async-function" :name name :params params :body body :line line}]
+[FUNC make-await :params [expr line]
+ :body {:kind "await" :expr expr :line line}]
+[FUNC make-try :params [body catch finally line]
+ :body {:kind "try" :body body :catch catch :finally finally :line line}]
+[FUNC make-catch :params [param body line]
+ :body {:kind "catch" :param param :body body :line line}]
+[FUNC make-throw :params [expr line]
+ :body {:kind "throw" :expr expr :line line}]
+[FUNC make-template-string :params [parts expressions line]
+ :body {:kind "template-string" :parts parts :expressions expressions :line line}]
+;; ──────────────────────────────────────
+;; 30 웹 노드 + deep-equal?
+;; ──────────────────────────────────────
+[FUNC make-page :params [name path fields line]
+ :body {:kind "page" :name name :path path :fields fields :line line}]
+[FUNC make-route :params [method path handler line]
+ :body {:kind "route" :method method :path path :handler handler :line line}]
+[FUNC make-component :params [name fields line]
+ :body {:kind "component" :name name :fields fields :line line}]
+[FUNC make-form :params [name fields line]
+ :body {:kind "form" :name name :fields fields :line line}]
+;; deep-equal? — 노드 비교 (line 무시)
+;; Map 이면 모든 키를 순회, list 면 원소별, 원시값은 =.
+[FUNC deep-equal? :params [a b]
+ :body (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)])]
+[FUNC deep-equal-list? :params [a b i]
+ :body (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 정렬 후 각 키의 값 비교.
+[FUNC deep-equal-map? :params [a b]
+ :body (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)))]
+[FUNC keys-no-line :params [m]
+ :body (filter (fn [k] (not (= k "line"))) (json_keys m))]
+[FUNC deep-equal-map-keys? :params [a b ks i]
+ :body (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))])]
+;; 타입 감지 헬퍼 (FL 에 list?/map? 기본 없으면 대체)
+[FUNC list? :params [v]
+ :body (if (null? v) false
+     (= (str-to-num (str "[" v)) null))] ;; 플레이스홀더. 실제로는 런타임이 Array 타입 제공 필요.
+[FUNC map? :params [v]
+ :body (if (null? v) false
+     (not (null? (get v :kind))))] ;; kind 키가 있으면 AST map 으로 간주
+;; NOTE: list?/map? 의 robust 한 구현은 FL 런타임 지원 필요 (Phase 07 builtins/type 에서 교체).
+;; 현재는 AST 비교에 사용될 때만 동작하는 placeholder.
+;; self/parser.fl — FL 로 작성된 Parser (Phase 03/31-45)
+;;
+;; 입력: tokens (lexer 출력)
+;; 출력: AST nodes (list of ast nodes)
+;;
+;; 모든 함수 [FUNC] 블록. 파서 상태 = {:tokens :idx}.
+;; node 생성자는 self/ast.fl 정의 재사용. 테스트 단독 실행 위해 여기에도 복제.
+;; ──────────────────────────────────────
+;; AST 생성자 — self/ast.fl 에서 정의됨
+;; (모든 make-* 함수는 ast.fl 표준 정의 참조)
+;; ──────────────────────────────────────
+;; ──────────────────────────────────────
+;; 31 파서 상태 + peek/advance/expect
+;; ──────────────────────────────────────
+[FUNC p-make :params [tokens]
+ :body {:tokens tokens :idx 0 :ast []}]
+[FUNC p-peek :params [p]
+ :body (let [[i (get p :idx)] [t (get p :tokens)]]
+     (if (>= i (length t)) null (get t i)))]
+[FUNC p-peek-at :params [p offset]
+ :body (let [[i (+ (get p :idx) offset)] [t (get p :tokens)]]
+     (if (>= i (length t)) null (get t i)))]
+[FUNC p-end? :params [p]
+ :body (>= (get p :idx) (length (get p :tokens)))]
+[FUNC p-advance :params [p]
+ :body {:tokens (get p :tokens) :idx (+ (get p :idx) 1) :ast (get p :ast)}]
+[FUNC p-with-ast :params [p ast]
+ :body {:tokens (get p :tokens) :idx (get p :idx) :ast ast}]
+[FUNC p-append-ast :params [p node]
+ :body (p-with-ast p (append (get p :ast) (list node)))]
+;; 2-tuple 반환용 map {:p p' :node n}
+[FUNC r-pair :params [p node]
+ :body {:p p :node node}]
+;; ──────────────────────────────────────
+;; 32 parseAtom — number/string/symbol/keyword/variable
+;; ──────────────────────────────────────
+[FUNC string-contains? :params [s substr]
+ :body (not (= -1 (str-index-of s substr)))]
+[FUNC parse-atom :params [p]
+ :body (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 "${")
+        (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)
+;; ──────────────────────────────────────
+[FUNC parse-expr :params [p]
+ :body (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)
+;; ──────────────────────────────────────
+[FUNC parse-sexpr :params [p]
+ :body (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))]]
+       (if (= 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)))
+        (r-pair (parse-consume-rparen p2)
+            (make-sexpr op rest line))))))]
+[FUNC parse-consume-rparen :params [p]
+ :body (let [[t (p-peek p)]]
+     (if (and (not (null? t)) (= (get t :kind) "RParen"))
+      (p-advance p)
+      p))]
+;; args 수집 (재귀): RParen 만나면 중단
+[FUNC parse-args :params [p acc]
+ :body (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 (list (get one :node)))))]))]
+;; ──────────────────────────────────────
+;; 34 parse-bracket — [a b c] 또는 [FUNC ...] 블록
+;; ──────────────────────────────────────
+[FUNC parse-bracket :params [p]
+ :body (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)))]
+[FUNC is-block-type? :params [s]
+ :body (let [[c (char-at s 0)]]
+     (and (>= c "A") (<= c "Z")))]
+[FUNC upper-case :params [s] :body s]  ;; FL stdlib 기본 upper-case 가 없으면 identity. 판별엔 첫글자만 본다.
+[FUNC parse-array :params [p line]
+ :body (let [[collected (parse-args p [])]
+       [p2 (get collected :p)] [items (get collected :node)]]
+     (r-pair (parse-consume-rbracket p2) (make-array-block items line)))]
+[FUNC parse-consume-rbracket :params [p]
+ :body (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 등)
+[FUNC parse-named-block :params [p line]
+ :body (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)))]
+[FUNC parse-optional-name :params [p]
+ :body (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 만나면 중단.
+[FUNC parse-block-fields :params [p acc]
+ :body (let [[t (p-peek p)]]
+     (cond
+      [(null? t) (r-pair p acc)]
+      [(= (get t :kind) "RBracket") (r-pair p acc)]
+      [(= (get t :kind) "Keyword")
+       (let [[key (get t :value)]
+          [p1 (p-advance p)]
+          [val (parse-expr p1)]
+          [p2 (get val :p)] [v (get val :node)]]
+        (parse-block-fields p2 (json_set acc key v)))]
+      [true (r-pair (p-advance p) acc)]))]
+;; ──────────────────────────────────────
+;; 35 parse-map — {:k v :k v ...}
+;; ──────────────────────────────────────
+[FUNC parse-map :params [p]
+ :body (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)))]
+[FUNC parse-consume-rbrace :params [p]
+ :body (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
+;; ──────────────────────────────────────
+[FUNC parse-all :params [p]
+ :body (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)))]
+[FUNC parse :params [tokens] :body (parse-all (p-make tokens))]
+;; self/codegen.fl — FL AST → JS source (v2, Phase 10 확장)
+;;
+;; 새로 추가:
+;;  특수폼: let (1D/2D), cond, do, and, or, quote
+;;  native stdlib: str, length, substring, char-at, replace
+;;         first, last, rest, append, get, slice
+;;         list, println, print, min, max, abs
+;;         null?, not, empty?, mod
+;;
+;; 생성된 JS 는 runtime prelude 함수 (_fl_*) 가 선두에 포함됨.
+;; ═══════ 유틸 ═══════
+;; map_entries: native 또는 runtime prelude 제공 (FL에서 정의 불필요)
+[FUNC esc-1 :params [s] :body (replace s "\\" "\\\\")]
+[FUNC esc-2 :params [s] :body (replace s "\"" "\\\"")]
+[FUNC esc-3 :params [s] :body (replace s "\n" "\\n")]
+[FUNC esc-4 :params [s] :body (replace s "\r" "\\r")]
+[FUNC esc-5 :params [s] :body (replace s "\t" "\\t")]
+[FUNC js-esc-inner :params [s]
+ :body (esc-5 (esc-4 (esc-3 (esc-2 (esc-1 s)))))]
+[FUNC js-esc :params [s]
+ :body (str "\"" (js-esc-inner s) "\"")]
+;; FL 예약 특수폼 (defn에서 검증)
+[FUNC fl-reserved? :params [n]
+ :body (or (= n "loop") (= n "recur") (= n "fn") (= n "defn") (= n "defun")
+      (= n "if") (= n "cond") (= n "do") (= n "begin") (= n "progn")
+      (= n "while") (= n "and") (= n "or") (= n "let") (= n "set!")
+      (= n "define") (= n "async") (= n "await") (= n "try")
+      (= n "catch") (= n "finally") (= n "throw") (= n "quote")
+      (= n "compose") (= n "pipe") (= n "->") (= n "->>") (= n "|>"))]
+;; JS 예약어 회피: let/const/default/class/etc → 뒤에 _ 추가
+[FUNC js-reserved? :params [n]
+ :body (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"))]
+[FUNC rename-1 :params [n] :body (replace n "-" "_")]
+[FUNC rename-2 :params [n] :body (replace n "?" "_q")]
+[FUNC rename-3 :params [n] :body (replace n "!" "_x")]
+[FUNC rename-4 :params [n] :body (replace n ">" "_gt")]
+[FUNC rename-5 :params [n] :body (replace n "<" "_lt")]
+[FUNC rename-6 :params [n] :body (replace n "*" "_st")]
+[FUNC rename-7 :params [n] :body (replace n "+" "_pl")]
+[FUNC js-name-inner :params [n]
+ :body (let [[g (rename-7 (rename-6 (rename-5 (rename-4 (rename-3 (rename-2 (rename-1 n)))))))]]
+     (if (js-reserved? g) (str g "_") g))]
+[FUNC js-name :params [n]
+ :body (if (null? n) "_" (js-name-inner n))]
+;; ═══════ 디스패치 ═══════
+[FUNC cg :params [n]
+ :body (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) "sexpr") (cg-sexpr n)]
+     [(= (get n :kind) "block") (cg-block n)]
+     [(= (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"])]
+[FUNC js-esc-for-template :params [s]
+ :body (let [[s1 (replace s "\\" "\\\\")]]
+     (replace s1 "`" "\`"))]
+[FUNC cg-template-string :params [n]
+ :body (str "`" (js-esc-for-template (get n :value)) "`")]
+[FUNC cg-try :params [n]
+ :body (let [[body (get n :body)]
+       [catch-node (get n :catch)]
+       [finally-node (get n :finally)]
+       [body-code (cg body)]
+       [catch-code (if (null? catch-node) "" (cg-catch-clause catch-node))]
+       [finally-code (if (null? finally-node) "" (str "finally{" (cg finally-node) "}"))]
+       ]
+     (str "(()=>{try{return " body-code "}catch(err){" catch-code "}" finally-code "})()"))]
+[FUNC cg-catch-clause :params [catch-node]
+ :body (let [[param (if (= (get catch-node :kind) "sexpr")
+             (let [[args (get catch-node :args)]]
+              (if (> (length args) 0)
+               (js-name (str (get (get args 0) :name)))
+               "err"))
+             "err")]
+       [body (if (= (get catch-node :kind) "sexpr")
+            (let [[args (get catch-node :args)]]
+             (if (> (length args) 1)
+              (cg (get args 1))
+              "null"))
+            (cg catch-node))]]
+     (str "let " param "=err;return " body ";"))]
+[FUNC cg-literal-dispatch :params [t v]
+ :body (cond
+     [(= t "number") 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"])]
+[FUNC cg-literal :params [n]
+ :body (cg-literal-dispatch (get n :type) (get n :value))]
+[FUNC cg-block-dispatch :params [t fields]
+ :body (cond
+     [(= t "Array")
+      (str "[" (cg-args (get fields "items")) "]")]
+     [(= t "Map")
+      (str "({" (cg-map-entries fields) "})")]
+     [true "null"])]
+[FUNC cg-block :params [n]
+ :body (let [[t (get n :type)] [fields (get n :fields)]]
+     (if (= t "FUNC")
+      (cg-func-block n)
+      (cg-block-dispatch t fields)))]
+;; Map literal: 두 AST 형태 지원
+;;  1) bootstrap parser: fields = JS Map, map_entries 로 [[k,v] ...]
+;;  2) self-parser: fields = {items: [k1,v1,k2,v2,...]} (평탄한 쌍 리스트)
+;; Map fields 형태 감지:
+;;  bootstrap: JS Map{"key1"→node, "key2"→node, ...}
+;;  self-parser: plain obj {items: [kw-node1, val-node1, kw-node2, val-node2, ...]}
+;;  자기참조 bootstrap 형태에서 "items" 키가 있어도 그 값은 단일 node 이지 list 아님.
+[FUNC cg-map-entries-dispatch :params [items-val fields]
+ :body (if (array? items-val)
+     ;; self-parser: items = [key-node val-node key-node val-node ...]
+     (cg-map-flat-loop items-val 0 "")
+     ;; bootstrap parser: fields = Map{key -> val-node}
+     ;; map-entries 를 호출해서 [[k,v], [k,v], ...] 변환 후 처리
+     (cg-map-loop (map-entries fields) 0 ""))]
+[FUNC cg-map-entries :params [fields]
+ :body (cg-map-entries-dispatch (get fields "items") fields)]
+[FUNC cg-map-loop-inner :params [entries i acc e]
+ :body (let [[k (get e 0)]
+       [v (cg (get e 1))]
+       [pair (str (js-esc k) ":" v)]]
+     (cg-map-loop entries (+ i 1)
+            (if (= i 0) pair (str acc "," pair))))]
+[FUNC cg-map-loop :params [entries i acc]
+ :body (if (>= i (length entries)) acc
+     (cg-map-loop-inner entries i acc (get entries i)))]
+;; self-parser 형태: items = [kw-node val-node kw-node val-node ...]
+[FUNC cg-map-flat-loop-inner :params [items i acc k-n v-n]
+ :body (let [[k-str (cg-keyword-key k-n)]
+       [v-js (str (cg v-n))]
+       [pair (str k-str ":" v-js)]]
+     (cg-map-flat-loop items (+ i 2)
+              (if (= i 0) pair (str acc "," pair))))]
+[FUNC cg-map-flat-loop :params [items i acc]
+ :body (if (>= i (length items)) acc
+     (cg-map-flat-loop-inner items i acc (get items i) (get items (+ i 1))))]
+;; keyword/literal 에서 키 문자열 추출
+[FUNC cg-keyword-key :params [n]
+ :body (cond [(= (get n :kind) "keyword") (js-esc (get n :name))]
+       [(= (get n :kind) "literal") (js-esc (str (get n :value)))]
+       [true "\"_anon\""])]
+;; [FUNC name :params [a b] :body expr]
+;;  → const name = (a, b) => expr;
+[FUNC cg-func-block-inner :params [name fields pnode body]
+ :body (let [[pitems (if (null? pnode) (list) (get (get pnode :fields) "items"))]
+       [ps (extract-params pitems)]]
+     (str "const " name " = (" ps ")=>" (cg body) ";"))]
+[FUNC cg-func-block :params [n]
+ :body (let [[name (js-name (get n :name))]
+       [fields (get n :fields)]]
+     (cg-func-block-inner name fields (get fields "params") (get fields "body")))]
+;; ═══════ 특수폼 ═══════
+[FUNC cg-if :params [args]
+ :body (str "(" (cg (get args 0)) "?" (cg (get args 1)) ":"
+       (if (>= (length args) 3) (cg (get args 2)) "null") ")")]
+[FUNC cg-fn :params [args]
+ :body (let [[pnode (get args 0)] [body (get args 1)]
+       [ps (extract-params (get (get pnode :fields) "items"))]]
+     (str "((" ps ")=>" (cg body) ")"))]
+[FUNC cg-defn :params [args]
+ :body (let [[name-n (get args 0)] [pnode (get args 1)] [body (get args 2)]
+       [name (extract-name name-n)]
+       [ps (extract-params (get (get pnode :fields) "items"))]
+       [warning (if (fl-reserved? name) (str "// ⚠️ RESERVED NAME: " name) "")]]
+     (str warning (if (fl-reserved? name) "\n" "") "const " name " = (" ps ")=>" (cg body)))]
+[FUNC cg-define :params [args]
+ :body (if (= (length args) 2)
+     (str "const " (extract-name (get args 0)) " = " (cg (get args 1)))
+     (cg-defn args))]
+[FUNC cg-let :params [args]
+ :body (let [[bnode (get args 0)]
+       [items (get (get bnode :fields) "items")]
+       [first-item (if (null? items) null (get items 0))]
+       [inner-items (if (null? first-item) null
+                (if (and (= (get first-item :kind) "block")
+                    (= (get first-item :type) "Array"))
+                 (get (get first-item :fields) "items")
+                 null))]
+       [nested (and (not (null? inner-items))
+              (> (length inner-items) 0)
+              (= (get (get inner-items 0) :kind) "block")
+              (= (get (get inner-items 0) :type) "Array"))]
+       [bindings (if nested (cg-let-2d items 0 "" 0) (cg-let-1d items 0 "" 0))]
+       [body-args (slice args 1 (length args))]
+       [body-js (cg-do-body body-args 0 "")]]
+     (str "((()=>{" bindings body-js "})())"))]
+[FUNC cg-let-binding :params [pat-node val-js tmpvar]
+ :body (let [[kind (get pat-node :kind)]
+       [type (get pat-node :type)]]
+  (cond
+   [(= kind "variable")
+    (str "let " (js-name (get pat-node :name)) "=" val-js ";")]
+   [(and (= kind "block") (= type "Map"))
+    ;; Map 패턴: 필드들을 순회하며 바인딩 생성
+    ;; val-js와 tmpvar이 같으면 (배열에서 추출됨) 다시 선언하지 않음
+    (let [[pat-fields (get pat-node :fields)]
+       [pat-entries (map-entries pat-fields)]
+       [pat-bindings (cg-map-pattern-bindings-from-entries pat-entries tmpvar 0 "")]]
+     (str
+      (if (= val-js tmpvar) "" (str "let " tmpvar "=" val-js ";"))
+      pat-bindings))]
+   [(and (= kind "block") (= type "Array"))
+    ;; array pattern: 배열 값에서 첫 항목을 추출해서 패턴과 매칭
+    (let [[items (get (get pat-node :fields) "items")]
+       [first-pat (if (null? items) nil (get items 0))]
+       [tmpvar-next (str tmpvar "_inner")]]
+     (if (null? first-pat) ""
+      (str "let " tmpvar "=" val-js "[0];"
+       (cg-let-binding first-pat tmpvar tmpvar-next))))]
+   [true
+    (str "let " (extract-name pat-node) "=" val-js ";")]))]
+[FUNC cg-let-1d :params [items i acc counter]
+ :body (if (>= i (length items)) acc
+     (let [[pat-n (get items i)] [v-n (get items (+ i 1))]
+        [val (cg v-n)]
+        [tmpvar (str "__v" (if (= counter 0) "" counter))]]
+      (cg-let-1d items (+ i 2) (str acc (cg-let-binding pat-n val tmpvar)) (+ counter 1))))]
+[FUNC cg-let-2d :params [items i acc counter]
+ :body (if (>= i (length items)) acc
+     (let [[pair (get items i)]
+        [pitems (get (get pair :fields) "items")]
+        [k-n (get pitems 0)] [v-n (get pitems 1)]
+        [val (cg v-n)]
+        [tmpvar (str "__v" (if (= counter 0) "" counter))]]
+      (cg-let-2d items (+ i 1) (str acc (cg-let-binding k-n val tmpvar)) (+ counter 1))))]
+[FUNC cg-do :params [args]
+ :body (if (= (length args) 0) "null"
+     (str "(()=>{" (cg-do-body args 0 "") "})()"))]
+[FUNC cg-do-body :params [args i acc]
+ :body (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 ";"))))]
+[FUNC get-clause-items :params [clause]
+ :body (let [[fields (get clause :fields)]
+       [items (get fields "items")]]
+     (if (array? items) items
+      (list (get fields 0) (get fields 1))))]
+[FUNC cg-cond :params [args]
+ :body (cg-cond-loop args 0)]
+[FUNC cg-cond-loop :params [args i]
+ :body (loop [j (- (length args) 1) acc "null"]
+     (if (< j 0) acc
+      (let [[clause (get args j)]
+         [citems (get-clause-items clause)]
+         [test (cg (get citems 0))] [result (cg (get citems 1))]]
+       (recur (- j 1) (str "(" test "?" result ":" acc ")")))))]
+[FUNC cg-and :params [args]
+ :body (if (= (length args) 0) "true"
+     (str "(" (and-loop args 0 "") ")")) ]
+[FUNC and-loop :params [args i acc]
+ :body (if (>= i (length args)) acc
+     (let [[c (str (cg (get args i)))]]
+      (and-loop args (+ i 1)
+           (if (= i 0) c (str acc "&&" c)))))]
+[FUNC cg-or :params [args]
+ :body (if (= (length args) 0) "false"
+     (str "(" (or-loop args 0 "") ")")) ]
+[FUNC or-loop :params [args i acc]
+ :body (if (>= i (length args)) acc
+     (let [[c (str (cg (get args i)))]]
+      (or-loop args (+ i 1)
+           (if (= i 0) c (str acc "||" c)))))]
+[FUNC cg-quote :params [args]
+ :body (if (= (length args) 0) "null" (js-esc (str (cg (get args 0)))))]
+;; (set! x v) → (x=v)
+[FUNC cg-set! :params [args]
+ :body (str "(" (extract-name (get args 0)) "=" (cg (get args 1)) ")")]
+;; (throw msg) → (()=>{throw new Error(msg)})()
+[FUNC cg-throw :params [args]
+ :body (let [[m (if (= (length args) 0) "\"error\"" (cg (get args 0)))]]
+     (str "(()=>{throw new Error(String(" m "))})()"))]
+;; (while cond body...) → (()=>{while(cond){body;}})()
+[FUNC cg-while :params [args]
+ :body (let [[cond (cg (get args 0))]
+       [body-args (slice args 1 (length args))]
+       [body (while-body body-args 0 "")]]
+     (str "(()=>{while(" cond "){" body "}})()"))]
+[FUNC while-body :params [args i acc]
+ :body (if (>= i (length args)) acc
+     (while-body args (+ i 1) (str acc (cg (get args i)) ";")))]
+;; (loop [[i 0] [acc 0]] body-with-recur)
+;;  → mutable let + while(true) { const __r=...; if(__r?.__recur){[i,acc]=__r.a;continue;} return __r; }
+;; recur 는 { __recur:true, a:[v1,v2,...] } 를 반환
+[FUNC cg-loop :params [args]
+ :body (let [[bnode (get args 0)]
+       [items (get (get bnode :fields) "items")]
+       [first (if (null? items) null (get items 0))]
+       [nested (if (null? first) false
+             (and (= (get first :kind) "block")
+               (= (get first :type) "Array")))]
+       [bindings (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-args (slice args 1 (length args))]
+       [body-js (cg-do-body body-args 0 "")]]
+     (str "((()=>{" bindings
+        "while(true){let __r=(()=>{" body-js "})();"
+        "if(__r&&__r.__recur){[" names "]=__r.a;continue;}"
+        "return __r;}})())"))]
+[FUNC loop-inits-1d :params [items i acc]
+ :body (if (>= i (length items)) acc
+     (let [[k (get items i)] [v (get items (+ i 1))]]
+      (loop-inits-1d items (+ i 2)
+              (str acc "let " (extract-name k) "=" (cg v) ";"))))]
+[FUNC loop-inits-2d :params [items i acc]
+ :body (if (>= i (length items)) acc
+     (let [[pair (get items i)]
+        [pit (get (get pair :fields) "items")]]
+      (loop-inits-2d items (+ i 1)
+              (str acc "let " (extract-name (get pit 0)) "=" (cg (get pit 1)) ";"))))]
+[FUNC loop-names-1d :params [items i acc]
+ :body (if (>= i (length items)) acc
+     (let [[k (get items i)] [n (extract-name k)]]
+      (loop-names-1d items (+ i 2)
+              (if (= (length acc) 0) n (str acc "," n)))))]
+[FUNC loop-names-2d :params [items i acc]
+ :body (if (>= i (length items)) acc
+     (let [[pair (get items i)]
+        [pit (get (get pair :fields) "items")]
+        [n (extract-name (get pit 0))]]
+      (loop-names-2d items (+ i 1)
+              (if (= (length acc) 0) n (str acc "," n)))))]
+;; (recur v1 v2 ...) → {__recur:true, a:[v1,v2,...]}
+[FUNC cg-recur :params [args]
+ :body (str "{__recur:true,a:[" (cg-args args) "]}")]
+;; ═══════ match (pattern-match node) ═══════
+;; (match value
+;;  (pat1 body1)
+;;  (pat2 body2)
+;;  (default body))
+;;
+;; → ((__v)=>{
+;;   if(<test1>){let b=__v; return <body1>;}
+;;   if(<test2>){return <body2>;}
+;;   return <default>;
+;;  })(value)
+[FUNC cg-match :params [n]
+ :body (let [[val (cg (get n :value))]
+       [cases (get n :cases)]
+       [default-n (get n :defaultCase)]
+       [default (if (null? default-n) "null" (cg default-n))]
+       [cases-js (match-cases-loop cases 0 "")]]
+     (str "((__v)=>{" cases-js "return " default ";})(" val ")"))]
+;; 각 case: if (pattern-test) { bindings; if (guard) { return body; } }
+;;  guard 가 binding 변수를 참조할 수 있어 bindings 를 먼저 실행
+[FUNC match-cases-loop :params [cases i acc]
+ :body (if (>= i (length cases)) acc
+     (let [[c (get cases i)]
+        [pat (get c :pattern)]
+        [body (cg (get c :body))]
+        [guard-n (get c :guard)]
+        [test (pattern-test pat "__v")]
+        [bind (pattern-bindings pat "__v")]
+        [guard-js (if (null? guard-n) "true" (cg guard-n))]
+        [inner (if (null? guard-n)
+             (str bind "return " body ";")
+             (str bind "if(" guard-js "){return " body ";}"))]]
+      (match-cases-loop cases (+ i 1)
+       (str acc "if(" test "){" inner "}"))))]
+;; pattern-test: JS expression that returns truthy if pat matches __v
+[FUNC pattern-test-dispatch :params [k pat v]
+ :body (cond
+     [(= k "wildcard-pattern") "true"]
+     [(= k "variable-pattern") "true"]
+     [(= k "literal-pattern")
+      (str "(" v "===" (literal-to-js (get pat :type) (get pat :value)) ")")]
+     [(= k "or-pattern") (or-pattern-test (get pat :patterns) v 0 "")]
+     [(= k "range-pattern")
+      (str "(" v ">=" (get pat :min) "&&" v "<=" (get pat :max) ")")]
+     [(= k "struct-pattern")
+      (struct-pattern-test (get pat :fields) v 0 nil "")]
+     [true "false"])]
+[FUNC pattern-test :params [pat v]
+ :body (pattern-test-dispatch (get pat :kind) pat v)]
+[FUNC literal-to-js :params [t v]
+ :body (cond [(= t "number") v]
+       [(= t "string") (js-esc v)]
+       [(= t "symbol")
+        (cond [(= v "true") "true"] [(= v "false") "false"] [(= v "null") "null"]
+           [true (js-esc v)])]
+       [true "null"])]
+[FUNC or-pattern-test :params [pats v i acc]
+ :body (if (>= i (length pats)) (if (= (length acc) 0) "false" (str "(" acc ")"))
+     (let [[t (pattern-test (get pats i) v)]]
+      (or-pattern-test pats v (+ i 1)
+       (if (= (length acc) 0) t (str acc "||" t))))) ]
+;; struct-pattern-test: Test all fields match
+;; fields는 {key: pattern, ...} 형태의 객체
+[FUNC struct-pattern-test :params [fields v i keys acc]
+ :body (if (nil? keys)
+     (let [[ks (json_keys fields)]]
+      (struct-pattern-test fields v 0 ks ""))
+     (if (>= i (length keys))
+      (if (= (length acc) 0)
+       (str "(" v "!==null&&typeof " v "===\"object\")")
+       (str "(" v "!==null&&typeof " v "===\"object\"&&" acc ")"))
+      (let [[k (get keys i)]
+         [pat (get fields k)]
+         [k-clean (if (= (char-at k 0) ":") (substring k 1) k)]
+         [t (pattern-test pat (str v "[" (js-esc k-clean) "]"))]]
+       (struct-pattern-test fields v (+ i 1) keys
+        (if (= (length acc) 0) t (str acc "&&" t))))))]
+;; pattern-bindings: JS statement that binds pattern variables from __v
+[FUNC pattern-bindings-dispatch :params [k pat v]
+ :body (cond
+     [(or (= k "variable-pattern") (= k "variable"))
+      (str "let " (js-name (get pat :name)) "=" v ";")]
+     [(or (= k "struct-pattern") (= k "block"))
+      (struct-pattern-bindings (get pat :fields) v 0 nil "")]
+     [true ""])]
+;; bootstrap Map 지원: map-entries 호출해서 [[k,v], ...] 형태로 변환
+[FUNC struct-pattern-bindings-from-entries :params [entries v i acc]
+ :body (if (>= i (length entries)) acc
+     (let [[e (get entries i)]
+        [k (get e 0)]
+        [pat (get e 1)]
+        [k-clean (if (= (char-at k 0) ":") (substring k 1) k)]
+        [access (str v "[" (js-esc k-clean) "]")]
+        [pat-kind (get pat :kind)]
+        [binding (cond
+         [(= pat-kind "variable")
+          (str "let " (js-name (get pat :name)) "=" access ";")]
+         [(= pat-kind "block")
+          (let [[v_next (str v "_" i)]]
+           (str "let " v_next "=" access ";" (struct-pattern-bindings-from-entries (map-entries (get pat :fields)) v_next 0 "")))]
+         [true ""])]
+        [binding (if (= (length binding) 0) "" binding)]]
+      (struct-pattern-bindings-from-entries entries v (+ i 1)
+       (str acc binding))))]
+;; cg-map-pattern-bindings-from-entries: entries 형태의 패턴 필드들을 처리
+[FUNC cg-map-pattern-bindings-from-entries :params [entries v i acc]
+ :body (if (>= i (length entries)) acc
+     (let [[e (get entries i)]
+        [k (get e 0)]
+        [pat (get e 1)]
+        [k-clean (if (= (char-at k 0) ":") (substring k 1) k)]
+        [access (str v "[" (js-esc k-clean) "]")]
+        [binding (pattern-bindings-dispatch (get pat :kind) pat access)]]
+      (cg-map-pattern-bindings-from-entries entries v (+ i 1)
+       (str acc binding))))]
+;; struct-pattern-bindings: Collect bindings from all fields
+;; bootstrap parser: fields = Map{...} → map-entries로 변환
+;; self-parser: fields = plain obj {field: pattern, ...} → json_keys로 처리
+[FUNC struct-pattern-bindings :params [fields v i keys acc]
+ :body (if (nil? keys)
+     (let [[ks (json_keys fields)]]
+      (if (empty? ks)
+       ;; Map인 경우: json_keys가 빈 배열 반환 → map-entries 사용
+       (struct-pattern-bindings-from-entries (map-entries fields) v 0 "")
+       ;; plain object인 경우: json_keys로 계속 진행
+       (struct-pattern-bindings fields v 0 ks "")))
+     (if (>= i (length keys))
+      acc
+      (let [[k (get keys i)]
+         [pat (get fields k)]
+         [k-clean (if (= (char-at k 0) ":") (substring k 1) k)]
+         [field-bindings (pattern-bindings pat (str v "[" (js-esc k-clean) "]"))]]
+       (struct-pattern-bindings fields v (+ i 1) keys
+        (str acc field-bindings)))))]
+[FUNC pattern-bindings :params [pat v]
+ :body (pattern-bindings-dispatch (get pat :kind) pat v)]
+;; (compose f g h) → ((__x)=>f(g(h(__x)))) right-to-left
+;;  마지막 arg (h) 먼저 적용, 맨 처음 (f) 가 바깥
+[FUNC cg-compose :params [args]
+ :body (str "((__x)=>" (compose-nest args (- (length args) 1) "__x") ")")]
+[FUNC compose-nest :params [args i acc]
+ :body (if (< i 0) acc
+     (let [[f (str (cg (get args i)))]]
+      (compose-nest args (- i 1) (str f "(" acc ")")))) ]
+;; (pipe f g h) → ((__x)=>h(g(f(__x)))) left-to-right
+;;  첫 arg (f) 먼저 적용, 마지막 (h) 이 바깥
+[FUNC cg-pipe :params [args]
+ :body (str "((__x)=>" (pipe-nest args 0 "__x") ")")]
+[FUNC pipe-nest :params [args i acc]
+ :body (if (>= i (length args)) acc
+     (let [[f (str (cg (get args i)))]]
+      (pipe-nest args (+ i 1) (str f "(" acc ")")))) ]
+;; (-> x step1 step2) thread-first: step(acc, args...)
+;;  step 이 symbol → step(acc); step 이 sexpr → (op acc args...)
+[FUNC cg-thread-first :params [args]
+ :body (let [[init (str (cg (get args 0)))]]
+     (thread-first-loop args 1 init))]
+[FUNC thread-first-loop :params [args i acc]
+ :body (if (>= i (length args)) acc
+     (thread-first-loop args (+ i 1)
+               (thread-apply (get args i) acc true))) ]
+;; (->> x step1 step2) thread-last: step(args..., acc)
+[FUNC cg-thread-last :params [args]
+ :body (let [[init (str (cg (get args 0)))]]
+     (thread-last-loop args 1 init))]
+[FUNC thread-last-loop :params [args i acc]
+ :body (if (>= i (length args)) acc
+     (thread-last-loop args (+ i 1)
+              (thread-apply (get args i) acc false))) ]
+;; thread-apply: step, acc, first? → new acc
+[FUNC thread-apply :params [step acc fst]
+ :body (cond
+     [(= (get step :kind) "sexpr")
+      (let [[op (js-name (get step :op))] [a (get step :args)]]
+       (if fst
+        (str op "(" acc (if (= (length a) 0) "" (str "," (cg-args a))) ")")
+        (str op "(" (if (= (length a) 0) "" (str (cg-args a) ",")) acc ")")))]
+     [true
+      (str (cg step)) "(" acc ")")])]
+;; (call f 1 2) → f(1,2)
+[FUNC cg-call-form :params [args]
+ :body (let [[fn (str (cg (get args 0)))]
+       [rest (slice args 1 (length args))]]
+     (str fn "(" (cg-args rest) ")"))]
+;; (async body...) → (async()=>{...})()
+;; 반환: Promise
+[FUNC cg-async :params [args]
+ :body (str "(async()=>{" (cg-do-body args 0 "") "})()")]
+;; (await p) → await p (런타임에 async context 필요)
+[FUNC cg-await :params [args]
+ :body (str "(await " (cg (get args 0)) ")")]
+;; (defstruct Name field1 field2 ...)
+;;  → const Name = (field1, field2, ...) => ({__struct:"Name", field1, field2, ...});
+[FUNC cg-defstruct :params [args]
+ :body (let [[name-n (get args 0)]
+       [name (extract-name name-n)]
+       [fields (slice args 1 (length args))]
+       [params (struct-field-list fields 0 "")]
+       [init  (struct-init-list fields 0 "")]]
+     (str "const " name " = (" params ")=>({__struct:\"" name "\"," init "})"))]
+[FUNC struct-field-list :params [fs i acc]
+ :body (if (>= i (length fs)) acc
+     (let [[n (extract-name (get fs i))]]
+      (struct-field-list fs (+ i 1)
+                (if (= (length acc) 0) n (str acc "," n)))))]
+[FUNC struct-init-list :params [fs i acc]
+ :body (if (>= i (length fs)) acc
+     (let [[n (extract-name (get fs i))]]
+      (struct-init-list fs (+ i 1)
+               (if (= (length acc) 0) n (str acc "," n)))))]
+;; ═══════ 연산/인자 ═══════
+[FUNC cg-args :params [args] :body (args-loop args 0 "")]
+[FUNC args-loop :params [args i acc]
+ :body (if (>= i (length args)) acc
+     (let [[c (str (cg (get args i)))]]
+      (args-loop args (+ i 1)
+            (if (= i 0) c (str acc "," c)))))]
+[FUNC cg-binop :params [args op zero]
+ :body (cond [(= (length args) 0) zero]
+       [(= (length args) 1) (str (cg (get args 0)))]
+       [true (str "(" (binop-loop args 0 "" op) ")")])]
+[FUNC binop-loop :params [args i acc op]
+ :body (if (>= i (length args)) acc
+     (let [[c (str (cg (get args i)))]]
+      (binop-loop args (+ i 1)
+            (if (= i 0) c (str acc op c)) op)))]
+[FUNC cg-pair :params [args op]
+ :body (str "(" (cg (get args 0)) op (cg (get args 1)) ")")]
+[FUNC cg-sub :params [args]
+ :body (cond [(= (length args) 0) "0"]
+       [(= (length args) 1) (str "(-" (cg (get args 0)) ")")]
+       [true (str "(" (binop-loop args 0 "" "-") ")")])]
+;; ═══════ 파라미터/이름 추출 ═══════
+[FUNC extract-name :params [n]
+ :body (cond [(= (get n :kind) "variable") (js-name (get n :name))]
+       [(= (get n :kind) "literal") (js-name (get n :value))]
+       [true "_anon"])]
+[FUNC extract-params :params [items]
+ :body (param-loop items 0 "")]
+[FUNC param-loop :params [items i acc]
+ :body (if (null? items) acc
+     (if (>= i (length items)) acc
+      (let [[cur (get items i)]
+         [cur-val (if (= (get cur :kind) "literal") (get cur :value) "")]]
+       (if (= cur-val "&")
+        ;; rest-args: '&' 다음 항목 이름 앞에 '...' 붙여 emit, i+2 로 점프
+        (if (>= (+ i 1) (length items)) acc
+         (let [[rest-name (extract-name (get items (+ i 1)))]
+            [entry (str "..." rest-name)]]
+          (param-loop items (+ i 2)
+                (if (= i 0) entry (str acc "," entry)))))
+        (let [[name (extract-name cur)]]
+         (param-loop items (+ i 1)
+               (if (= i 0) name (str acc "," name))))))))]
+;; ═══════ stdlib native → JS 매핑 ═══════
+[FUNC cg-native-dispatch :params [op as]
+ :body (cond
+      ;; ─── String (15) ───
+      [(= op "str") (str "_fl_str(" as ")")]
+      [(= op "concat") (str "_fl_str(" as ")")]
+      [(= op "length") (str "_fl_length(" as ")")]
+      [(= op "substring") (str "_fl_substring(" as ")")]
+      [(= op "char-at") (str "_fl_char_at(" as ")")]
+      [(= op "replace") (str "_fl_replace(" as ")")]
+      [(= op "starts-with?") (str "_fl_starts_with(" as ")")]
+      [(= op "ends-with?") (str "_fl_ends_with(" as ")")]
+      [(= op "contains?") (str "_fl_contains(" as ")")]
+      [(= op "split") (str "_fl_split(" as ")")]
+      [(= op "join") (str "_fl_join(" as ")")]
+      [(= op "trim") (str "_fl_trim(" as ")")]
+      [(= op "upper") (str "_fl_upper(" as ")")]
+      [(= op "lower") (str "_fl_lower(" as ")")]
+      [(= op "repeat") (str "_fl_repeat(" as ")")]
+      [(= op "index-of") (str "_fl_index_of(" as ")")]
+      ;; ─── List (15) ───
+      [(= op "first") (str "_fl_first(" as ")")]
+      [(= op "last") (str "_fl_last(" as ")")]
+      [(= op "rest") (str "_fl_rest(" as ")")]
+      [(= op "append") (str "_fl_append(" as ")")]
+      [(= op "slice") (str "_fl_slice(" as ")")]
+      [(= op "list") (str "[" as "]")]
+      [(= op "map") (str "_fl_map(" as ")")]
+      [(= op "filter") (str "_fl_filter(" as ")")]
+      [(= op "reduce") (str "_fl_reduce(" as ")")]
+      [(= op "find") (str "_fl_find(" as ")")]
+      [(= op "every?") (str "_fl_every(" as ")")]
+      [(= op "some?") (str "_fl_some(" as ")")]
+      [(= op "sort") (str "_fl_sort(" as ")")]
+      [(= op "reverse") (str "_fl_reverse(" as ")")]
+      [(= op "flatten") (str "_fl_flatten(" as ")")]
+      [(= op "distinct") (str "_fl_distinct(" as ")")]
+      [(= op "range") (str "_fl_range(" as ")")]
+      [(= op "take") (str "_fl_take(" as ")")]
+      [(= op "drop") (str "_fl_drop(" as ")")]
+      [(= op "count") (str "_fl_length(" as ")")]
+      ;; ─── Map (8) ───
+      [(= op "get") (str "_fl_get(" as ")")]
+      [(= op "keys") (str "_fl_keys(" as ")")]
+      [(= op "values") (str "_fl_values(" as ")")]
+      [(= op "entries") (str "_fl_entries(" as ")")]
+      [(= op "has-key?") (str "_fl_has_key(" as ")")]
+      [(= op "map-set") (str "_fl_map_set(" as ")")]
+      [(= op "map-delete") (str "_fl_map_delete(" as ")")]
+      [(= op "merge") (str "_fl_merge(" as ")")]
+      [(= op "json_set") (str "_fl_map_set(" as ")")]
+      ;; ─── JSON (4) ───
+      [(= op "json-parse") (str "JSON.parse(" as ")")]
+      [(= op "json-stringify") (str "JSON.stringify(" as ")")]
+      [(= op "json_parse") (str "JSON.parse(" as ")")]
+      [(= op "json_stringify") (str "JSON.stringify(" as ")")]
+      ;; ─── Type predicates (10) ───
+      [(= op "null?") (str "(" as "==null)")]
+      [(= op "nil?") (str "_fl_nil_q(" as ")")]
+      [(= op "nil-or-empty?") (str "_fl_nil_or_empty_q(" as ")")]
+      [(= op "not") (str "(!" as ")")]
+      [(= op "empty?") (str "_fl_empty_q(" as ")")]
+      [(= op "true?") (str "(" as "===true)")]
+      [(= op "false?") (str "(" as "===false)")]
+      [(= op "string?") (str "(typeof " as "===\"string\")")]
+      [(= op "number?") (str "(typeof " as "===\"number\")")]
+      [(= op "list?") (str "Array.isArray(" as ")")]
+      [(= op "array?") (str "Array.isArray(" as ")")]
+      [(= op "map?") (str "_fl_is_map(" as ")")]
+      [(= op "fn?") (str "(typeof " as "===\"function\")")]
+      [(= op "boolean?") (str "(typeof " as "===\"boolean\")")]
+      [(= op "type-of") (str "_fl_type_of(" as ")")]
+      ;; ─── Math (15) ───
+      [(= op "min") (str "Math.min(" as ")")]
+      [(= op "max") (str "Math.max(" as ")")]
+      [(= op "abs") (str "Math.abs(" as ")")]
+      [(= op "sqrt") (str "Math.sqrt(" as ")")]
+      [(= op "pow") (str "Math.pow(" as ")")]
+      [(= op "floor") (str "Math.floor(" as ")")]
+      [(= op "ceil") (str "Math.ceil(" as ")")]
+      [(= op "round") (str "Math.round(" as ")")]
+      [(= op "mod") (cg-pair args "%")]
+      [(= op "neg") (str "(-" as ")")]
+      [(= op "sign") (str "Math.sign(" as ")")]
+      [(= op "random") (str "Math.random()")]
+      [(= op "log") (str "Math.log(" as ")")]
+      [(= op "exp") (str "Math.exp(" as ")")]
+      [(= op "sin") (str "Math.sin(" as ")")]
+      [(= op "cos") (str "Math.cos(" as ")")]
+      [(= op "str-to-num") (str "Number(" as ")")]
+      [(= op "num-to-str") (str "String(" as ")")]
+      ;; ─── I/O (7) ───
+      [(= op "println") (str "console.log(" as ")")]
+      [(= op "print") (str "process.stdout.write(String(" as "))")]
+      [(= op "file_read") (str "_fl_file_read(" as ")")]
+      [(= op "file_write") (str "_fl_file_write(" as ")")]
+      [(= op "file_exists") (str "_fl_file_exists(" as ")")]
+      [(= op "exit") (str "process.exit(" as ")")]
+      [(= op "shell_capture") (str "_fl_shell_capture(" as ")")]
+      ;; ─── Time (10) ───
+      [(= op "now") (str "now()")]
+      [(= op "now_ms") (str "now_ms()")]
+      [(= op "now_iso") (str "now_iso()")]
+      [(= op "now_unix") (str "now_unix()")]
+      [(= op "time_diff") (str "((t1,t2)=>t2-t1)(" as ")")]
+      [(= op "time_since") (str "((ts)=>Date.now()-ts)(" as ")")]
+      [(= op "sleep_ms") (str "((ms)=>{const start=Date.now();while(Date.now()-start<ms){}})(" as ")")]
+      [(= op "timer_start") (str "{__timer:{label:" as ",start:Date.now(),laps:[]}}")]
+      [(= op "timer_elapsed") (str "((t)=>Date.now()-t.__timer.start)(" as ")")]
+      [(= op "timer_lap") (str "((t,l)=>{t.__timer.laps.push({label:l,ms:Date.now()-t.__timer.start});return t;})(" as ")")]
+      ;; ─── String 추가 (starts-with?, ends-with?, contains?, split, join, trim, upper, lower, repeat, index-of) ───
+      [(= op "starts-with?") (str "_fl_starts_with(" as ")")]
+      [(= op "ends-with?") (str "_fl_ends_with(" as ")")]
+      [(= op "contains?") (str "_fl_contains(" as ")")]
+      [(= op "split") (str "_fl_split(" as ")")]
+      [(= op "join") (str "_fl_join(" as ")")]
+      [(= op "trim") (str "_fl_trim(" as ")")]
+      [(= op "upper") (str "_fl_upper(" as ")")]
+      [(= op "lower") (str "_fl_lower(" as ")")]
+      [(= op "repeat") (str "_fl_repeat(" as ")")]
+      [(= op "index-of") (str "_fl_index_of(" as ")")]
+      ;; ─── List 추가 (map, filter, reduce, find, every?, some?, sort, reverse, flatten, distinct, range, take, drop, count) ───
+      [(= op "map") (str "_fl_map(" as ")")]
+      [(= op "filter") (str "_fl_filter(" as ")")]
+      [(= op "reduce") (str "_fl_reduce(" as ")")]
+      [(= op "find") (str "_fl_find(" as ")")]
+      [(= op "every?") (str "_fl_every(" as ")")]
+      [(= op "some?") (str "_fl_some(" as ")")]
+      [(= op "sort") (str "_fl_sort(" as ")")]
+      [(= op "reverse") (str "_fl_reverse(" as ")")]
+      [(= op "flatten") (str "_fl_flatten(" as ")")]
+      [(= op "distinct") (str "_fl_distinct(" as ")")]
+      ;; ─── Database (8, placeholder for JS env) ───
+      [(= op "pg_exec") (str "_fl_pg_exec(" as ")")]
+      [(= op "pg_query") (str "_fl_pg_query(" as ")")]
+      [(= op "pg_connect") (str "_fl_pg_connect(" as ")")]
+      [(= op "mariadb_exec") (str "_fl_mariadb_exec(" as ")")]
+      [(= op "mariadb_query") (str "_fl_mariadb_query(" as ")")]
+      [(= op "mariadb_one") (str "_fl_mariadb_one(" as ")")]
+      [(= op "db_query") (str "_fl_db_query(" as ")")]
+      [(= op "db_exec") (str "_fl_db_exec(" as ")")]
+      ;; ─── Server/HTTP (placeholder) ───
+      [(= op "server_post") (str "_fl_server_post(" as ")")]
+      [(= op "server_get") (str "_fl_server_get(" as ")")]
+      [(= op "server_put") (str "_fl_server_put(" as ")")]
+      [(= op "server_delete") (str "_fl_server_delete(" as ")")]
+      [(= op "server_start") (str "_fl_server_start(" as ")")]
+      [(= op "server_stop") (str "_fl_server_stop(" as ")")]
+      [(= op "http_get") (str "_fl_http_get(" as ")")]
+      [(= op "http_post") (str "_fl_http_post(" as ")")]
+      [(= op "ws_send") (str "_fl_ws_send(" as ")")]
+      [true (str (js-name (if (= (char-at op 0) "$") (substring op 1 (length op)) op)) "(" as ")")])]
+[FUNC cg-native :params [op args]
+ :body (cg-native-dispatch op (cg-args args))]
+[FUNC cg-call :params [op args]
+ :body (let [[fn-name (js-name (if (= (char-at op 0) "$") (substring op 1 (length op)) op))]]
+     (str fn-name "(" (cg-args args) ")"))]
+;; ═══════ sexpr 메인 dispatch ═══════
+[FUNC cg-sexpr-dispatch :params [op args]
+ :body (cond
+     [(= op "if")   (cg-if args)]
+     [(= op "fn")   (cg-fn args)]
+     [(= op "defn")  (cg-defn args)]
+     [(= op "define") (cg-define args)]
+     [(= op "let")   (cg-let args)]
+     [(= op "do")   (cg-do args)]
+     [(= op "begin")  (cg-do args)]
+     [(= op "cond")  (cg-cond args)]
+     [(= op "and")   (cg-and args)]
+     [(= op "or")   (cg-or args)]
+     [(= op "quote")  (cg-quote args)]
+     [(= op "set!")  (cg-set! args)]
+     [(= op "throw")  (cg-throw args)]
+     [(= op "try")   (cg-try args)]
+     [(= op "while")  (cg-while args)]
+     [(= op "loop")  (cg-loop args)]
+     [(= op "recur")  (cg-recur args)]
+     [(= op "defstruct") (cg-defstruct args)]
+     [(= op "compose") (cg-compose args)]
+     [(= op "pipe")  (cg-pipe args)]
+     [(= op "->")   (cg-thread-first args)]
+     [(= op "->>")   (cg-thread-last args)]
+     [(= op "|>")   (cg-thread-first args)]
+     [(= op "call")  (cg-call-form args)]
+     [(= op "async")  (cg-async args)]
+     [(= op "await")  (cg-await args)]
+     [(= op "+")    (cg-binop args "+" "0")]
+     [(= op "-")    (cg-sub args)]
+     [(= op "*")    (cg-binop args "*" "1")]
+     [(= op "/")    (cg-pair args "/")]
+     [(= op "%")    (cg-pair args "%")]
+     [(= op "<")    (cg-pair args "<")]
+     [(= op ">")    (cg-pair args ">")]
+     [(= op "<=")   (cg-pair args "<=")]
+     [(= op ">=")   (cg-pair args ">=")]
+     [(= op "=")    (cg-pair args "===")]
+     [(= op "!=")   (cg-pair args "!==")]
+     [true       (cg-native op args)])]
+[FUNC cg-sexpr :params [n]
+ :body (cg-sexpr-dispatch (get n :op) (get n :args))]
+;; ═══════ 런타임 prelude (생성 JS 앞에 삽입) ═══════
+;; 분할 구조: 각 부분을 따로 정의하여 stack overflow 방지
+[FUNC prelude-string :params []
+ :body (str
+  "const _fl_str = (...xs) => xs.map(x => x==null?'null':String(x)).join('');"
+  "const _fl_length = (x) => (x==null ? 0 : x.length);"
+  "const _fl_substring = (s, a, b) => (b==null ? s.slice(a) : s.slice(a, b));"
+  "const _fl_char_at = (s, i) => (s[i] || null);"
+  "const _fl_replace = (s, a, b) => s.split(a).join(b);"
+  "const _fl_starts_with = (s, p) => s.startsWith(p);"
+  "const _fl_ends_with = (s, p) => s.endsWith(p);"
+  "const _fl_contains = (s, p) => s.includes(p);"
+  "const _fl_split = (s, sep) => s.split(sep);"
+  "const _fl_join = (l, sep) => l.join(sep==null?'':sep);"
+  "const _fl_trim = (s) => s.trim();"
+  "const _fl_upper = (s) => s.toUpperCase();"
+  "const _fl_lower = (s) => s.toLowerCase();"
+  "const _fl_repeat = (s, n) => s.repeat(n);"
+  "const _fl_index_of = (s, p) => s.indexOf(p);")]
+[FUNC prelude-list :params []
+ :body (str
+  "const _fl_first = (l) => (l==null || l.length===0 ? null : l[0]);"
+  "const _fl_last = (l) => (l==null || l.length===0 ? null : l[l.length-1]);"
+  "const _fl_rest = (l) => (l==null || l.length===0 ? [] : l.slice(1));"
+  "const _fl_append = (...xs) => xs.reduce((acc, x) => Array.isArray(x) ? [...acc, ...x] : [...acc, x], []);"
+  "const _fl_slice = (l, a, b) => l.slice(a, b);"
+  "const _fl_map = (f, l) => l.map(x => f(x));"
+  "const _fl_filter = (f, l) => l.filter(x => f(x));"
+  "const _fl_reduce = (f, init, l) => l.reduce((acc, x) => f(acc, x), init);"
+  "const _fl_find = (f, l) => (l.find(x => f(x)) ?? null);"
+  "const _fl_every = (f, l) => l.every(x => f(x));"
+  "const _fl_some = (f, l) => l.some(x => f(x));"
+  "const _fl_sort = (l, cmp) => [...l].sort(cmp || ((a,b)=>a<b?-1:a>b?1:0));"
+  "const _fl_reverse = (l) => [...l].reverse();"
+  "const _fl_flatten = (l) => l.flat(Infinity);"
+  "const _fl_distinct = (l) => [...new Set(l)];"
+  "const _fl_range = (a, b, s) => { let r=[]; let step=s||1; for(let i=a;i<b;i+=step)r.push(i); return r; };"
+  "const _fl_take = (n, l) => l.slice(0, n);"
+  "const _fl_drop = (n, l) => l.slice(n);")]
+[FUNC prelude-map :params []
+ :body (str
+  "const _fl_get = (o, k) => (o==null ? null : (o[k]===undefined ? null : o[k]));"
+  "const _fl_keys = (o) => (o==null ? [] : Object.keys(o));"
+  "const _fl_values = (o) => (o==null ? [] : Object.values(o));"
+  "const _fl_entries = (o) => (o==null ? [] : Object.entries(o).map(([k,v])=>[k,v]));"
+  "const _fl_has_key = (o, k) => (o!=null && k in o);"
+  "const _fl_map_set = (o, k, v) => ({...o, [k]: v});"
+  "const _fl_map_delete = (o, k) => { const c={...o}; delete c[k]; return c; };"
+  "const _fl_merge = (...os) => Object.assign({}, ...os);"
+  "const _fl_is_map = (x) => (x!=null && typeof x==='object' && !Array.isArray(x));"
+  "const _fl_type_of = (x) => (x==null?'null':Array.isArray(x)?'list':typeof x);"
+  "const map_entries = (m) => m instanceof Map ? [...m.entries()] : (m && typeof m === 'object' && !Array.isArray(m) ? Object.entries(m) : []);"
+  "const map_keys = (m) => m instanceof Map ? [...m.keys()] : (m && typeof m === 'object' && !Array.isArray(m) ? Object.keys(m) : []);"
+  "const map_values = (m) => m instanceof Map ? [...m.values()] : (m && typeof m === 'object' && !Array.isArray(m) ? Object.values(m) : []);")]
+[FUNC prelude-time-regex :params []
+ :body (str
+  "const now = () => Date.now();"
+  "const now_ms = () => Date.now();"
+  "const now_iso = () => new Date().toISOString();"
+  "const now_unix = () => Math.floor(Date.now()/1000);"
+  "const regex_match = (s, p) => new RegExp(p).test(s);"
+  "const regex_find = (s, p) => { const m = s.match(new RegExp(p)); return m ? m[0] : null; };"
+  "const regex_find_all = (s, p) => s.match(new RegExp(p, 'g')) || [];"
+  "const regex_replace = (s, p, r) => s.replace(new RegExp(p, 'g'), r);"
+  "const regex_split = (s, p) => s.split(new RegExp(p));"
+  "const regex_count = (s, p) => (s.match(new RegExp(p, 'g')) || []).length;"
+  "const regex_extract = (s, p) => { const m = s.match(new RegExp(p)); return m ? m.slice(1) : []; };")]
+[FUNC prelude-io-misc :params []
+ :body (str
+  "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_shell_capture = (cmd) => { try { const {execSync}=require('child_process'); return {stdout:execSync(cmd,{encoding:'utf8'}),stderr:'',code:0}; } catch(e) { return {stdout:'',stderr:String(e),code:1}; } };"
+  "const _fl_empty_q = (x) => (x==null || x.length===0);"
+  "const _fl_nil_q = (x) => (x == null || x === undefined);"
+  "const _fl_nil_or_empty_q = (x) => (x == null || x === undefined || (x && x.length === 0));"
+  "const __argv__ = process.argv.slice(2);")]
+[FUNC prelude-db-server :params []
+ :body (str
+  "const _fl_pg_exec = (db,sql,...args) => null;"
+  "const _fl_pg_query = (db,sql,...args) => [];"
+  "const _fl_pg_connect = (cfg) => null;"
+  "const _fl_mariadb_exec = (db,sql,...args) => null;"
+  "const _fl_mariadb_query = (db,sql,...args) => [];"
+  "const _fl_mariadb_one = (db,sql,...args) => null;"
+  "const _fl_db_query = (path,sql,...args) => [];"
+  "const _fl_db_exec = (path,sql,...args) => null;"
+  "const _fl_server_post = (path,fn) => null;"
+  "const _fl_server_get = (path,fn) => null;"
+  "const _fl_server_put = (path,fn) => null;"
+  "const _fl_server_delete = (path,fn) => null;"
+  "const _fl_server_start = (port) => null;"
+  "const _fl_server_stop = () => null;"
+  "const _fl_http_get = (url) => '';"
+  "const _fl_http_post = (url,body) => '';"
+  "const _fl_ws_send = (sid,data) => null;")]
+[FUNC prelude-parts :params []
+ :body [(prelude-string) (prelude-list) (prelude-map) (prelude-time-regex) (prelude-io-misc) (prelude-db-server)]]
+[FUNC runtime-prelude :params []
+ :body (str "const nil = null;" (reduce (fn [acc part] (str acc part)) "" (prelude-parts)))]
+;; ═══════ 최상위 ═══════
+[FUNC fl->js-code :params [ast]
+ :body (reduce (fn [acc node] (str acc (cg node) ";\n")) "" ast)]
+[FUNC fl->js-with-prelude :params [ast]
+ :body (let [[p (runtime-prelude)]]
+     (let [[c (fl->js-code ast)]]
+      (str p "\n" c)))]
+;; ═══════ driver ═══════
+;; 사용법: node bootstrap.js run self/codegen.fl <input.fl> [<output.js>]
+;; 인자 없이 실행하면 FUNC 등록만 하고 종료.
+[FUNC compile-file :params [input output]
+ :body (let [[src  (file_read input)]
+       [tokens (lex src)]
+       [ast  (parse tokens)]
+       [js   (fl->js-with-prelude ast)]]
+     (file_write output js)
+     (println (str "compiled " input " -> " output " size=" (length js))))]
+(if (null? __argv__) null
+ (if (= (length __argv__) 0) null
+  (compile-file (get __argv__ 0)
+         (if (>= (length __argv__) 2) (get __argv__ 1)
+           (str (get __argv__ 0) ".out.js")))))