diff --git a/TeXmacs/plugins/goldfish/goldfish/liii/hash-table.scm b/TeXmacs/plugins/goldfish/goldfish/liii/hash-table.scm
index 8607f3accd..5fed0dde83 100644
--- a/TeXmacs/plugins/goldfish/goldfish/liii/hash-table.scm
+++ b/TeXmacs/plugins/goldfish/goldfish/liii/hash-table.scm
@@ -27,7 +27,7 @@
     hash-table-size hash-table-keys hash-table-values hash-table-entries
     hash-table-find hash-table-count hash-table-fold
     hash-table-for-each hash-table-map->list
-    hash-table->alist
+    hash-table->alist hash-table-copy
     )
   (begin
     ) ; end of begin
diff --git a/TeXmacs/plugins/goldfish/goldfish/liii/hashlib.scm b/TeXmacs/plugins/goldfish/goldfish/liii/hashlib.scm
index f9106908c8..bf8021265b 100644
--- a/TeXmacs/plugins/goldfish/goldfish/liii/hashlib.scm
+++ b/TeXmacs/plugins/goldfish/goldfish/liii/hashlib.scm
@@ -14,12 +14,17 @@
 ; under the License.
 ;
 (define-library (liii hashlib)
-  (export md5 sha1 sha256)
+  (export md5 sha1 sha256
+          md5-by-file sha1-by-file sha256-by-file)
   (begin
 
     (define (md5 str) (g_md5 str))
     (define (sha1 str) (g_sha1 str))
     (define (sha256 str) (g_sha256 str))
 
+    (define (md5-by-file path) (g_md5-by-file path))
+    (define (sha1-by-file path) (g_sha1-by-file path))
+    (define (sha256-by-file path) (g_sha256-by-file path))
+
     ) ; end of begin
   ) ; end of define-library
diff --git a/TeXmacs/plugins/goldfish/goldfish/liii/http.scm b/TeXmacs/plugins/goldfish/goldfish/liii/http.scm
index 0207721b16..d599b8df7f 100644
--- a/TeXmacs/plugins/goldfish/goldfish/liii/http.scm
+++ b/TeXmacs/plugins/goldfish/goldfish/liii/http.scm
@@ -7,7 +7,8 @@
 (import (liii hash-table)
         (liii alist))
 (export http-head http-get http-post http-ok?
-        http-stream-get http-stream-post)
+        http-stream-get http-stream-post
+        http-async-get http-async-post http-async-head http-poll http-wait-all)
 (begin
 
 (define (http-ok? r)
@@ -65,6 +66,43 @@
          (g_http-stream-post url params data '(("Content-Type" . "text/plain")) proxy userdata callback))
         (else (g_http-stream-post url params data headers proxy userdata callback))))
 
+;; Async HTTP API wrapper functions
+
+(define* (http-async-get url callback (params '()) (headers '()) (proxy '()))
+  (when (not (alist? params))
+    (type-error params "is not a association list"))
+  (when (not (alist? proxy))
+    (type-error proxy "is not a association list"))
+  (when (not (procedure? callback))
+    (type-error callback "is not a procedure"))
+  (g_http-async-get url params headers proxy callback))
+
+(define* (http-async-post url callback (params '()) (data "") (headers '()) (proxy '()))
+  (when (not (alist? params))
+    (type-error params "is not a association list"))
+  (when (not (alist? proxy))
+    (type-error proxy "is not a association list"))
+  (when (not (procedure? callback))
+    (type-error callback "is not a procedure"))
+  (cond ((and (string? data) (> (string-length data) 0) (null? headers))
+         (g_http-async-post url params data '(("Content-Type" . "text/plain")) proxy callback))
+        (else (g_http-async-post url params data headers proxy callback))))
+
+(define* (http-async-head url callback (params '()) (headers '()) (proxy '()))
+  (when (not (alist? params))
+    (type-error params "is not a association list"))
+  (when (not (alist? proxy))
+    (type-error proxy "is not a association list"))
+  (when (not (procedure? callback))
+    (type-error callback "is not a procedure"))
+  (g_http-async-head url params headers proxy callback))
+
+(define (http-poll)
+  (g_http-poll))
+
+(define* (http-wait-all (timeout -1))
+  (g_http-wait-all timeout))
+
 ) ; end of begin
 ) ; end of define-library
 
diff --git a/TeXmacs/plugins/goldfish/goldfish/scheme/time.scm b/TeXmacs/plugins/goldfish/goldfish/scheme/time.scm
index 3630dfb9c3..bbdebf90e2 100644
--- a/TeXmacs/plugins/goldfish/goldfish/scheme/time.scm
+++ b/TeXmacs/plugins/goldfish/goldfish/scheme/time.scm
@@ -15,15 +15,26 @@
 ;
 
 (define-library (scheme time)
-  (export current-second current-jiffy jiffies-per-second)
+  (import (only (scheme base) let-values s7-round))
+  (export current-second current-jiffy jiffies-per-second
+          get-time-of-day monotonic-nanosecond
+          system-clock-resolution steady-clock-resolution)
   (begin
 
     (define (jiffies-per-second) 1000000)
 
-    (define (current-second) (g_current-second))
+    (define get-time-of-day g_get-time-of-day)
+    (define monotonic-nanosecond g_monotonic-nanosecond)
+    (define system-clock-resolution g_system-clock-resolution)
+    (define steady-clock-resolution g_steady-clock-resolution)
+
+    (define (current-second)
+      (let-values (((sec usec) (get-time-of-day)))
+        (+ sec (exact->inexact (/ usec 1000000)))))
 
     (define (current-jiffy)
-      (round (* (current-second) (jiffies-per-second))))
+      ;; NOTE: use the s7-round to ensure that a natural number is returned.
+      (s7-round (* (current-second) (jiffies-per-second))))
 
     ) ; end of begin
   ) ; end of define-library
diff --git a/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-125.scm b/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-125.scm
index 690540b7de..30b12ed017 100644
--- a/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-125.scm
+++ b/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-125.scm
@@ -22,7 +22,7 @@
           hash-table-update! hash-table-update!/default hash-table-pop! hash-table-clear!
           hash-table-size hash-table-keys hash-table-values hash-table-entries hash-table-find
           hash-table-count hash-table-fold hash-table-for-each hash-table-map->list
-          hash-table->alist)
+          hash-table->alist hash-table-copy)
   (begin
 
     (define (assert-hash-table-type ht f)
@@ -148,4 +148,14 @@
 
     (define hash-table->alist
       (typed-lambda ((ht hash-table?))
-        (append-map (lambda (x) (list (car x) (cdr x))) (map values ht))))))
+        (append-map (lambda (x) (list (car x) (cdr x))) (map values ht))))
+
+    (define hash-table-copy
+      (typed-lambda ((ht hash-table?) . rest)
+        (let ((new-ht (make-hash-table))
+              (mutable? (if (null? rest) #t (car rest))))
+          (hash-table-for-each
+           (lambda (k v)
+             (hash-table-set! new-ht k v))
+           ht)
+          new-ht)))))
diff --git a/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-165.scm b/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-165.scm
new file mode 100644
index 0000000000..f84f7e0b5e
--- /dev/null
+++ b/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-165.scm
@@ -0,0 +1,378 @@
+;
+; Copyright (C) 2026 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+;; Based on Marc Nieper-Wißkirchen MIT implementation
+
+;; Copyright (C) Marc Nieper-Wißkirchen (2019).  All Rights Reserved.
+
+;; Permission is hereby granted, free of charge, to any person
+;; obtaining a copy of this software and associated documentation
+;; files (the "Software"), to deal in the Software without
+;; restriction, including without limitation the rights to use, copy,
+;; modify, merge, publish, distribute, sublicense, and/or sell copies
+;; of the Software, and to permit persons to whom the Software is
+;; furnished to do so, subject to the following conditions:
+
+;; The above copyright notice and this permission notice (including
+;; the next paragraph) shall be included in all copies or substantial
+;; portions of the Software.
+
+;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+;; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+;; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+;; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+;; SOFTWARE.
+
+(define-library (srfi srfi-165)
+  (import (srfi srfi-1)
+          (srfi srfi-128)
+          (srfi srfi-125))
+  (export
+     make-computation-environment-variable
+     make-computation-environment
+     computation-environment-ref
+     computation-environment-update
+     computation-environment-update!
+     computation-environment-copy
+
+     make-computation
+     computation-run
+     computation-ask
+     computation-local
+
+     computation-pure
+     computation-each
+     computation-each-in-list
+     computation-bind
+     computation-sequence
+     computation-forked
+     computation-bind/forked
+
+     computation-fn
+     computation-with
+     computation-with!
+
+     default-computation
+
+     define-computation-type
+     make-hash-table
+     variable-comparator)
+  (begin
+
+    ;; Box 模拟（暂时无 SRFI-111）
+    (define (box x) (cons x 'box))
+    (define (unbox b) (car b))
+    (define (set-box! b x) (set-car! b x))
+
+    (define-record-type <computation-environment-variable>
+      (make-environment-variable name default immutable? id)
+      computation-environment-variable?
+      (name environment-variable-name)
+      (default environment-variable-default)
+      (immutable? environment-variable-immutable?)
+      (id environment-variable-id))
+
+    (define make-computation-environment-variable
+      (let ((count 0))
+        (lambda (name default immutable?)
+          (set! count (+ count 1))
+          (make-environment-variable name default immutable? (- count)))))
+
+    (define (computation-environment? obj)
+      (and (vector? obj)
+           (> (vector-length obj) 2)
+           (hash-table? (vector-ref obj 0))
+           (list? (vector-ref obj 1))))
+
+    (define (predefined? var)
+      (not (negative? (environment-variable-id var))))
+
+    (define variable-comparator
+      (make-comparator computation-environment-variable?
+                       eq?
+                       (lambda (x y)
+                         (< (environment-variable-id x)
+                            (environment-variable-id y)))
+                       (lambda (x . y)
+                         (environment-variable-id x))))
+
+    ;; Alist 替代 mapping
+    (define (local-ref alist var default-thunk success)
+      (let ((pair (assq var alist)))
+        (if pair
+            (success (cdr pair))
+            (default-thunk))))
+
+    (define (local-set alist var box)
+      (cons (cons var box) alist))
+
+    (define (local-for-each proc alist)
+      (for-each (lambda (p) (proc (car p) (cdr p))) alist))
+
+    (define (environment-global env)
+      (vector-ref env 0))
+
+    (define (environment-local env)
+      (vector-ref env 1))
+
+    (define (environment-set-global! env global)
+      (vector-set! env 0 global))
+
+    (define (environment-set-local! env local)
+      (vector-set! env 1 local))
+
+    (define (environment-cell-set! env var box)
+      (vector-set! env (+ 2 (environment-variable-id var)) box))
+
+    (define (environment-cell env var)
+      (vector-ref env (+ 2 (environment-variable-id var))))
+
+    (define default-computation
+      (make-computation-environment-variable 'default-computation #f #f))
+
+    (define-macro (define-computation-type make-environment run . vars)
+      (letrec ((process-vars 
+                (lambda (vars n acc)
+                  (if (null? vars)
+                      (reverse acc)
+                      (let ((v (car vars))
+                            (rest (cdr vars)))
+                        (cond
+                         ((and (pair? v) (pair? (cdr v)) (pair? (cddr v))
+                               (string=? (caddr v) "immutable"))
+                          (let ((var (car v))
+                                (default (cadr v)))
+                            (process-vars rest (+ n 1)
+                                          (cons (list var default #t n) acc))))
+                         ((and (pair? v) (pair? (cdr v)))
+                          (let ((var (car v))
+                                (default (cadr v)))
+                            (process-vars rest (+ n 1)
+                                          (cons (list var default #f n) acc))))
+                         (else
+                          (process-vars rest (+ n 1)
+                                        (cons (list v #f #f n) acc)))))))))
+        (let* ((processed (process-vars vars 0 '()))
+               (n (length processed))
+               (default-syms (map (lambda (x) (gensym "default")) processed))
+               (env-sym (gensym "env")))
+          `(begin
+             ,@(map (lambda (p ds) `(define ,ds ,(cadr p)))
+                    processed default-syms)
+             ,@(map (lambda (p ds)
+                      `(define ,(car p)
+                         (,make-environment-variable ',(car p) ,ds ,(caddr p) ,(cadddr p))))
+                    processed default-syms)
+             (define (,make-environment)
+               (let ((,env-sym (make-vector ,(+ n 2))))
+                 (,environment-set-global! ,env-sym (make-hash-table variable-comparator))
+                 (,environment-set-local! ,env-sym '())
+                 ,@(map (lambda (p ds)
+                          `(vector-set! ,env-sym ,(+ (cadddr p) 2) (,box ,ds)))
+                        processed default-syms)
+                 ,env-sym))
+             (define (,run computation)
+               (,execute computation (,make-environment)))))))
+
+    (define (computation-environment-ref env var)
+      (if (predefined? var)
+          (unbox (environment-cell env var))
+          (local-ref
+           (environment-local env)
+           var
+           (lambda ()
+             (hash-table-ref/default (environment-global env)
+                                     var
+                                     (environment-variable-default var)))
+           unbox)))
+
+    (define (computation-environment-update env . arg*)
+      (let ((new-env (vector-copy env)))
+        (let loop ((arg* arg*)
+                   (local (environment-local env)))
+          (if (null? arg*)
+              (begin
+                (environment-set-local! new-env local)
+                new-env)
+              (let ((var (car arg*))
+                    (val (cadr arg*)))
+                (if (predefined? var)
+                    (begin
+                      (environment-cell-set! new-env var (box val))
+                      (loop (cddr arg*) local))
+                    (loop (cddr arg*) (local-set local var (box val)))))))))
+
+    ;; TODO: check immutable?
+    (define (computation-environment-update! env var val)
+      (if (predefined? var)
+          (set-box! (environment-cell env var) val)
+          (local-ref (environment-local env)
+                     var
+                     (lambda ()
+                       (hash-table-set! (environment-global env) var val))
+                     (lambda (cell)
+                       (set-box! cell val)))))
+
+    (define (computation-environment-copy env)
+      (let ((global (hash-table-copy (environment-global env) #t)))
+        (local-for-each (lambda (var cell)
+                          (hash-table-set! global var (unbox cell)))
+                        (environment-local env))
+        (let ((new-env (make-vector (vector-length env))))
+          (environment-set-global! new-env global)
+          (environment-set-local! new-env '())
+          (do ((i (- (vector-length env) 1) (- i 1)))
+              ((< i 2) new-env)
+            (vector-set! new-env i (box (unbox (vector-ref env i))))))))
+
+    (define (execute computation env)
+      (let ((coerce (if (procedure? computation)
+                        values
+                        (or (computation-environment-ref env default-computation)
+                            (error "not a computation" computation)))))
+        ((coerce computation) env)))
+
+    (define (make-computation proc)
+      (lambda (env)
+        (proc (lambda (c) (execute c env)))))
+
+    (define (computation-pure . args)
+      (make-computation
+       (lambda (compute)
+         (apply values args))))
+
+    (define (computation-each a . a*)
+      (computation-each-in-list (cons a a*)))
+
+    (define (computation-each-in-list a*)
+      (make-computation
+       (lambda (compute)
+         (let loop ((a (car a*)) (a* (cdr a*)))
+           (if (null? a*)
+               (compute a)
+               (begin
+                 (compute a)
+                 (loop (car a*) (cdr a*))))))))
+
+    (define (computation-bind a . f*)
+      (make-computation
+       (lambda (compute)
+         (let loop ((a a) (f* f*))
+           (if (null? f*)
+               (compute a)
+               (loop (call-with-values
+                         (lambda () (compute a))
+                       (car f*))
+                     (cdr f*)))))))
+
+    (define (computation-ask)
+      (lambda (env)
+        env))
+
+    (define (computation-local updater computation)
+      (lambda (env)
+        (computation (updater env))))
+
+    (define-macro (computation-fn . args)
+      (let ((clauses (car args))
+            (body (cdr args)))
+        (define (parse-clauses clauses)
+          (map (lambda (c)
+                 (if (pair? c)
+                     (let ((id (car c))
+                           (var (cadr c)))
+                       (list id var (gensym "tmp")))
+                     (let ((id c))
+                       (list id id (gensym "tmp")))))
+               clauses))
+        (let* ((parsed (parse-clauses clauses))
+               (env-sym (gensym "env"))
+               (ids (map car parsed))
+               (vars (map cadr parsed))
+               (tmps (map caddr parsed)))
+          `(let ,(map list tmps vars)
+             (computation-bind
+              (computation-ask)
+              (lambda (,env-sym)
+                (let ,(map (lambda (id tmp)
+                             `(,id (computation-environment-ref ,env-sym ,tmp)))
+                           ids tmps)
+                  ,@body)))))))
+
+    (define-macro (computation-with . args)
+      (let ((bindings (car args))
+            (comps (cdr args)))
+        (let ((var-tmps (map (lambda (b) (gensym "var")) bindings))
+              (val-tmps (map (lambda (b) (gensym "val")) bindings))
+              (comp-tmps (map (lambda (c) (gensym "comp")) comps)))
+          `(let ,(append (map (lambda (b vt) `(,vt ,(car b))) bindings var-tmps)
+                         (map (lambda (b vt) `(,vt ,(cadr b))) bindings val-tmps)
+                         (map (lambda (c ct) `(,ct ,c)) comps comp-tmps))
+             (computation-local
+              (lambda (env)
+                (computation-environment-update env 
+                  ,@(apply append (map list var-tmps val-tmps))))
+              (computation-each ,@comp-tmps))))))
+
+    (define-macro (computation-with! . bindings)
+      (let ((var-tmps (map (lambda (b) (gensym "var")) bindings))
+            (val-tmps (map (lambda (b) (gensym "val")) bindings))
+            (env-sym (gensym "env")))
+        `(let ,(append (map (lambda (b vt) `(,vt ,(car b))) bindings var-tmps)
+                       (map (lambda (b vt) `(,vt ,(cadr b))) bindings val-tmps))
+           (computation-bind
+            (computation-ask)
+            (lambda (,env-sym)
+              ,@(map (lambda (vt val-t)
+                       `(computation-environment-update! ,env-sym ,vt ,val-t))
+                     var-tmps val-tmps)
+              (computation-pure (if #f #f)))))))
+
+    (define (computation-forked a . a*)
+      (make-computation
+       (lambda (compute)
+         (let loop ((a a) (a* a*))
+           (if (null? a*)
+               (compute a)
+               (begin
+                 (compute (computation-local
+                           (lambda (env)
+                             (computation-environment-copy env))
+                           a))
+                 (loop (car a*) (cdr a*))))))))
+
+    (define (computation-bind/forked computation . proc*)
+      (apply computation-bind
+             (computation-local computation-environment-copy computation)
+             proc*))
+
+    (define (computation-sequence fmt*)
+      (fold-right
+       (lambda (fmt res)
+         (computation-bind
+          res
+          (lambda (vals)
+            (computation-bind
+             fmt
+             (lambda (val)
+               (computation-pure (cons val vals)))))))
+       (computation-pure '()) fmt*))
+
+    (define-computation-type make-computation-environment computation-run)))
+
diff --git a/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-19.scm b/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-19.scm
new file mode 100644
index 0000000000..95b7572180
--- /dev/null
+++ b/TeXmacs/plugins/goldfish/goldfish/srfi/srfi-19.scm
@@ -0,0 +1,680 @@
+;
+; Copyright (C) 2026 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+;;
+;; SRFI-19 Implementation for Goldfish Scheme
+;;
+;; This is a heavily modified implementation of SRFI-19 "Time Data Types
+;; and Procedures". While based on the original reference implementation,
+;; nearly every function has been rewritten for performance, clarity, or
+;; to adapt to Goldfish Scheme's idioms.
+;;
+;; ======================================================================
+;; SRFI-19: Time Data Types and Procedures.
+;;
+;; Copyright (C) I/NET, Inc. (2000, 2002, 2003). All Rights Reserved.
+;;
+;; Permission is hereby granted, free of charge, to any person obtaining
+;; a copy of this software and associated documentation files (the
+;; "Software"), to deal in the Software without restriction, including
+;; without limitation the rights to use, copy, modify, merge, publish,
+;; distribute, sublicense, and/or sell copies of the Software, and to
+;; permit persons to whom the Software is furnished to do so, subject to
+;; the following conditions:
+;;
+;; The above copyright notice and this permission notice shall be
+;; included in all copies or substantial portions of the Software.
+;;
+;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+;; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+;; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+;; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+(define-library (srfi srfi-19)
+  (import (rename (scheme time)
+                  (get-time-of-day      glue:get-time-of-day)
+                  (monotonic-nanosecond glue:monotonic-nanosecond))
+          (only (srfi srfi-13) string-pad string-tokenize string-trim-right)
+          (only (srfi srfi-8) receive)
+          (only (scheme base) open-output-string open-input-string get-output-string
+                              floor/)
+          (liii error))
+  (export
+    ;; Constants
+    TIME-DURATION TIME-MONOTONIC TIME-PROCESS
+    TIME-TAI      TIME-THREAD    TIME-UTC
+    ;; Time object and accessors
+    make-time time?
+    time-type      time-nanosecond      time-second
+    set-time-type! set-time-nanosecond! set-time-second!
+    copy-time
+    ;; Time comparison procedures
+    time<=? time<? time=? time>=? time>?
+    ;; Time arithmetic procedures
+    time-difference
+    ;; Current time and clock resolution
+    current-date current-julian-day current-time time-resolution
+    ;; Date object and accessors
+    make-date date?
+    date-nanosecond date-second date-minute date-hour
+    date-day        date-month  date-year   date-zone-offset
+    date-year-day
+    date-week-day date-week-number
+    ;; Time/Date/Julian Day/Modified Julian Day Converters
+    time-utc->date date->time-utc
+    ;; Date to String/String to Date Converters
+    date->string)
+  (begin
+
+    ;; ====================
+    ;; Constants
+    ;; ====================
+
+    (define TIME-DURATION  'time-duration)
+    (define TIME-MONOTONIC 'time-monotonic)
+    (define TIME-PROCESS   'time-process)
+    (define TIME-TAI       'time-tai)
+    (define TIME-THREAD    'time-thread)
+    (define TIME-UTC       'time-utc)
+
+    (define priv:LOCALE-DECIMAL-POINT ".")
+
+    (define priv:LOCALE-ABBR-WEEKDAY-VECTOR (vector "Sun" "Mon" "Tue" "Wed"
+                                                    "Thu" "Fri" "Sat"))
+    (define priv:LOCALE-LONG-WEEKDAY-VECTOR (vector "Sunday" "Monday"
+                                                    "Tuesday" "Wednesday"
+                                                    "Thursday" "Friday"
+                                                    "Saturday"))
+    ;; note empty string in 0th place.
+    (define priv:LOCALE-ABBR-MONTH-VECTOR   (vector "" "Jan" "Feb" "Mar"
+                                                    "Apr" "May" "Jun" "Jul"
+                                                    "Aug" "Sep" "Oct" "Nov"
+                                                    "Dec"))
+    (define priv:LOCALE-LONG-MONTH-VECTOR   (vector "" "January" "February"
+                                                    "March" "April" "May"
+                                                    "June" "July" "August"
+                                                    "September" "October"
+                                                    "November" "December"))
+
+    (define priv:LOCALE-PM "PM")
+    (define priv:LOCALE-AM "AM")
+
+    ;; See `date->string` below
+    (define priv:LOCALE-DATE-TIME-FORMAT   "~a ~b ~d ~H:~M:~S~z ~Y")
+    (define priv:LOCALE-SHORT-DATE-FORMAT  "~m/~d/~y")
+    (define priv:LOCALE-TIME-FORMAT        "~H:~M:~S")
+    (define priv:ISO-8601-DATE-TIME-FORMAT "~Y-~m-~dT~H:~M:~S~z")
+
+    (define priv:NANO            (expt 10 9))
+    (define priv:SID             86400)     ; seconds in a day
+    (define priv:SIHD            43200)     ; seconds in a half day
+    (define priv:TAI-EPOCH-IN-JD 4881175/2) ; julian day number for 'the epoch'
+
+    ;; ====================
+    ;; Time object and accessors
+    ;; ====================
+
+    (define-record-type <time>
+      (%make-time type nanosecond second)
+      time?
+      (type       time-type       set-time-type!)
+      (nanosecond time-nanosecond set-time-nanosecond!)
+      (second     time-second     set-time-second!))
+
+    (define (make-time type nanosecond second)
+      (unless (and (integer? nanosecond)
+                   (integer? second))
+        (error 'wrong-type-arg "nanosecond and second should be integer"))
+      (unless (member type (map car priv:TIME-DISPATCH))
+        (value-error "unsupported time type" type))
+      (%make-time type nanosecond second))
+
+    (define (copy-time time)
+      (make-time (time-type       time)
+                 (time-nanosecond time)
+                 (time-second     time)))
+
+    ;; ====================
+    ;; Time comparison procedures
+    ;; ====================
+
+    (define (priv:check-same-time-type time1 time2)
+      (unless (and (time? time1) (time? time2))
+        (error 'wrong-type-arg "time comparison: time1 and time2 must be time objects"
+               (list time1 time2)))
+      (unless (eq? (time-type time1) (time-type time2))
+        (error 'wrong-type-arg "time comparison: time types must match"
+               (list (time-type time1) (time-type time2)))))
+
+    (define (priv:time-compare time1 time2)
+      (priv:check-same-time-type time1 time2)
+      (let ((delta (- (priv:time->nanoseconds time1)
+                      (priv:time->nanoseconds time2))))
+        (cond
+          ((< delta 0) -1)
+          ((> delta 0) 1)
+          (else 0))))
+
+    (define (time<? time1 time2)
+      (< (priv:time-compare time1 time2) 0))
+
+    (define (time<=? time1 time2)
+      (<= (priv:time-compare time1 time2) 0))
+
+    (define (time=? time1 time2)
+      (= (priv:time-compare time1 time2) 0))
+
+    (define (time>=? time1 time2)
+      (>= (priv:time-compare time1 time2) 0))
+
+    (define (time>? time1 time2)
+      (> (priv:time-compare time1 time2) 0))
+
+    ;; ====================
+    ;; Time arithmetic procedures
+    ;; ====================
+
+    (define (priv:time->nanoseconds time)
+      (+ (* (time-second time) priv:NANO)
+         (time-nanosecond time)))
+
+    (define (priv:time-difference time1 time2 time3)
+      (unless (and (time? time1) (time? time2))
+        (error 'wrong-type-arg "time-difference: time1 and time2 must be time objects" (list time1 time2)))
+      (unless (eq? (time-type time1) (time-type time2))
+        (error 'wrong-type-arg "time-difference: time types must match"
+               (list (time-type time1) (time-type time2))))
+      (receive (secs nanos)
+               (floor/ (- (priv:time->nanoseconds time1)
+                          (priv:time->nanoseconds time2))
+                       priv:NANO)
+        (set-time-second! time3 secs)
+        (set-time-nanosecond! time3 nanos))
+      time3)
+
+    (define (time-difference time1 time2)
+      (priv:time-difference time1 time2 (%make-time TIME-DURATION 0 0)))
+
+    ;; ====================
+    ;; Current time and clock resolution
+    ;; ====================
+
+    (define (priv:us->ns us) (* us 1000))
+
+    ;; NOTE:
+    ;; 此函数使用静态的闰秒偏移表 `priv:leap-second-table`
+    ;; 来计算 TAI（国际原子时）与 UTC 之间的差值。
+    ;; 该表包含了自1972年UTC系统引入闰秒机制以来，所有闰秒生效的时刻（Unix时间戳）
+    ;; 以及从该时刻起，TAI 领先 UTC 的总秒数。
+    ;;
+    ;; 表格结构：((生效时间戳1 . 总偏移量1) (生效时间戳2 . 总偏移量2) ...)
+    ;; 数据排列：最新的条目（时间戳最大）在前。
+    ;; 数据来源：基于巴黎天文台等机构维护的闰秒历史记录生成。
+    ;;
+    ;; 工作原理：对于给定的 UTC 时间戳 `s`，函数从新到旧遍历此表，
+    ;; 找到第一个 `生效时间戳 <= s` 的条目，并使用其对应的总偏移量。
+    ;; 如果 `s` 早于表格中的最早记录（1972年之前），则返回初始偏移量 10 秒。
+    ;;
+    ;; 当前限制：
+    ;; 1. 此表为静态数据。未来若有新的闰秒引入（如 IANA 文件所示，有效期至 2026-06-28），
+    ;;    需要手动更新此表，在列表最前面添加新条目。
+    ;; 2. 更动态的实现应考虑从外部权威源
+    ;;   （如 https://hpiers.obspm.fr/iers/bul/bulc/ntp/leap-seconds.list）
+    ;;    在程序启动时或定期加载并解析闰秒数据。
+    ;;
+    ;; 参考资料：
+    ;; - IANA 闰秒数据文件: https://data.iana.org/time-zones/tzdb/leapseconds
+    ;; - 巴黎天文台闰秒文件：https://hpiers.obspm.fr/iers/bul/bulc/ntp/leap-seconds.list
+    (define priv:leap-second-table
+      '((1483228800 . 37)   ; 2017-01-01 00:00:00 UTC 起，TAI-UTC = 37 秒
+        (1435708800 . 36)   ; 2015-07-01 00:00:00 UTC 起，TAI-UTC = 36 秒
+        (1341100800 . 35)   ; 2012-07-01 00:00:00 UTC 起，TAI-UTC = 35 秒
+        (1230768000 . 34)   ; 2009-01-01 00:00:00 UTC 起，TAI-UTC = 34 秒
+        (1136073600 . 33)   ; 2006-01-01 00:00:00 UTC 起，TAI-UTC = 33 秒
+        (915148800  . 32)   ; 1999-01-01 00:00:00 UTC 起，TAI-UTC = 32 秒
+        (867715200  . 31)   ; 1997-07-01 00:00:00 UTC 起，TAI-UTC = 31 秒
+        (820454400  . 30)   ; 1996-01-01 00:00:00 UTC 起，TAI-UTC = 30 秒
+        (773020800  . 29)   ; 1994-07-01 00:00:00 UTC 起，TAI-UTC = 29 秒
+        (741484800  . 28)   ; 1993-07-01 00:00:00 UTC 起，TAI-UTC = 28 秒
+        (709948800  . 27)   ; 1992-07-01 00:00:00 UTC 起，TAI-UTC = 27 秒
+        (662688000  . 26)   ; 1991-01-01 00:00:00 UTC 起，TAI-UTC = 26 秒
+        (631152000  . 25)   ; 1990-01-01 00:00:00 UTC 起，TAI-UTC = 25 秒
+        (567993600  . 24)   ; 1988-01-01 00:00:00 UTC 起，TAI-UTC = 24 秒
+        (489024000  . 23)   ; 1985-07-01 00:00:00 UTC 起，TAI-UTC = 23 秒
+        (425865600  . 22)   ; 1983-07-01 00:00:00 UTC 起，TAI-UTC = 22 秒
+        (394329600  . 21)   ; 1982-07-01 00:00:00 UTC 起，TAI-UTC = 21 秒
+        (362793600  . 20)   ; 1981-07-01 00:00:00 UTC 起，TAI-UTC = 20 秒
+        (315532800  . 19)   ; 1980-01-01 00:00:00 UTC 起，TAI-UTC = 19 秒
+        (283996800  . 18)   ; 1979-01-01 00:00:00 UTC 起，TAI-UTC = 18 秒
+        (252460800  . 17)   ; 1978-01-01 00:00:00 UTC 起，TAI-UTC = 17 秒
+        (220924800  . 16)   ; 1977-01-01 00:00:00 UTC 起，TAI-UTC = 16 秒
+        (189302400  . 15)   ; 1976-01-01 00:00:00 UTC 起，TAI-UTC = 15 秒
+        (157766400  . 14)   ; 1975-01-01 00:00:00 UTC 起，TAI-UTC = 14 秒
+        (126230400  . 13)   ; 1974-01-01 00:00:00 UTC 起，TAI-UTC = 13 秒
+        (94694400   . 12)   ; 1973-01-01 00:00:00 UTC 起，TAI-UTC = 12 秒
+        (78796800   . 11)   ; 1972-07-01 00:00:00 UTC 起，TAI-UTC = 11 秒
+        (63072000   . 10))) ; 1972-01-01 00:00:00 UTC 起，TAI-UTC = 10 秒
+                            ; 注：1972年之前，UTC与TAI的理论差也为10秒，但当时无正式闰秒机制。
+    (define (priv:leap-second-delta s)
+      (let lp ((table priv:leap-second-table))
+        (cond
+          ((null? table)       10) ; 理论值
+          ((>= s (caar table)) (cdar table))
+          (else                (lp (cdr table))))))
+
+    (define (priv:current-time-monotonic)
+      (receive (s ns) (floor/ (glue:monotonic-nanosecond) 1000000000) ; 1e9
+       (make-time TIME-MONOTONIC ns s)))
+
+    (define (priv:current-time-process)
+      (error "unimplemented time"))
+
+    (define (priv:current-time-tai)
+      (receive (s us) (glue:get-time-of-day)
+        (make-time TIME-TAI
+                   (priv:us->ns us)
+                   (+ s (priv:leap-second-delta s)))))
+
+    (define (priv:current-time-thread)
+      (error "unimplemented time"))
+
+    (define (priv:current-time-utc)
+      (receive (s us) (glue:get-time-of-day)
+        (make-time TIME-UTC (priv:us->ns us) s)))
+
+    (define priv:TIME-DISPATCH
+       `((,TIME-MONOTONIC . (,priv:current-time-monotonic . ,steady-clock-resolution))
+         ; (,TIME-PROCESS   . (,priv:current-time-process   . ,0))
+         (,TIME-TAI       . (,priv:current-time-tai       . ,system-clock-resolution))
+         ; (,TIME-THREAD    . (,priv:current-time-thread    . ,0))
+         (,TIME-UTC       . (,priv:current-time-utc       . ,system-clock-resolution))))
+    (define (priv:query-time-dispatch clock-type querier)
+      (let ((entry (assq clock-type priv:TIME-DISPATCH)))
+        (if entry
+          (querier entry)
+          (error 'wrong-type-arg "unsupported time type" clock-type))))
+
+    ;; ====================
+
+    (define* (current-date (tz-offset 'TODO-GET-LOCAL-TZ-FROM-OS))
+      (error 'todo "TODO"))
+
+    (define (current-julian-day)
+      (error 'todo "TODO"))
+
+    (define* (current-time (clock-type TIME-UTC))
+      ((priv:query-time-dispatch clock-type cadr)))
+
+    (define* (time-resolution (clock-type TIME-UTC))
+      (priv:query-time-dispatch clock-type cddr))
+
+    ;; ====================
+    ;; Date object and accessors
+    ;; ====================
+
+    ;; Date objects are immutable once created
+    (define-record-type <date>
+      (%make-date nanosecond second minute hour day month year zone-offset)
+      date?
+      (nanosecond  date-nanosecond)
+      (second      date-second)
+      (minute      date-minute)
+      (hour        date-hour)
+      (day         date-day)
+      (month       date-month)
+      (year        date-year)
+      (zone-offset date-zone-offset))
+
+    (define (make-date nanosecond second minute hour day month year zone-offset)
+      ;; TODO: more guards maybe
+      (unless (and (integer? nanosecond) (integer? second)
+                   (integer? minute)     (integer? hour)
+                   (integer? day)        (integer? month)
+                   (integer? year)       (integer? zone-offset))
+        (error 'wrong-type-arg "The date fields need to be integer"))
+      (%make-date nanosecond second minute hour day month year zone-offset))
+
+    ;; ====================
+
+    (define (priv:leap-year? year)
+      (cond
+        ((zero? (modulo year 400)) #t)
+        ((zero? (modulo year 100)) #f)
+        ((zero? (modulo year 4))   #t)
+        (else                      #f)))
+
+    (define priv:MONTH-ASSOC '((0 . 0)   (1 . 31)  (2 . 59)   (3 . 90)
+                               (4 . 120) (5 . 151) (6 . 181)  (7 . 212)
+                               (8 . 243) (9 . 273) (10 . 304) (11 . 334)))
+
+    (define (priv:year-day day month year)
+      (let ((days-pr (assoc (- month 1) priv:MONTH-ASSOC)))
+        (unless days-pr
+          (value-error "invalid month specified" month))
+        ;; 闰2月，所以2月之后，且当年是闰年的，要多一天
+        (if (and (priv:leap-year? year) (> month 2))
+          (+ day (cdr days-pr) 1)
+          (+ day (cdr days-pr)))))
+
+    ;; ====================
+
+    (define (priv:week-day day month year)
+      (let* ((yy (if (negative? year) (+ year 1) year))
+             (a (quotient (- 14 month) 12))
+             (y (- yy a))
+             (m (+ month (* 12 a) -2)))
+        (modulo (+ day
+                   y
+                   (floor-quotient y 4)
+                   (- (floor-quotient y 100))
+                   (floor-quotient y 400)
+                   (floor-quotient (* 31 m) 12))
+                7)))
+
+    (define (priv:days-before-first-week date day-of-week-starting-week)
+      (let* ((first-day (make-date 0 0 0 0
+                                   1
+                                   1
+                                   (date-year date)
+                                   0))
+             (fdweek-day (date-week-day first-day)))
+        (modulo (- day-of-week-starting-week fdweek-day)
+                7)))
+
+    (define (date-year-day date)
+      (priv:year-day (date-day   date)
+                     (date-month date)
+                     (date-year  date)))
+
+    (define (date-week-day date)
+      (priv:week-day (date-day   date)
+                     (date-month date)
+                     (date-year  date)))
+
+    (define (date-week-number date day-of-week-starting-week)
+      (floor-quotient
+        (- (date-year-day date)
+           1
+           (priv:days-before-first-week date day-of-week-starting-week))
+        7))
+
+    ;; ====================
+    ;; Time/Date/Julian Day/Modified Julian Day Converters
+    ;; ====================
+
+    (define (priv:days-since-epoch year month day)
+      ;; Howard Hinnant's days_from_civil algorithm, inverse of civil-from-days
+      (let* ((y (- year (if (<= month 2) 1 0)))
+             (era (if (>= y 0)
+                    (floor-quotient y 400)
+                    (floor-quotient (- y 399) 400)))
+             (yoe (- y (* era 400)))
+             (m (+ month (if (> month 2) -3 9))) ; March=0, ..., February=11
+             (doy (+ (floor-quotient (+ (* 153 m) 2) 5) (- day 1)))
+             (doe (+ (* yoe 365)
+                     (floor-quotient yoe 4)
+                     (- (floor-quotient yoe 100))
+                     doy)))
+        (- (+ (* era 146097) doe) 719468)))
+
+    (define (priv:civil-from-days days)
+      ;; Howard Hinnant's algorithm, adapted for proleptic Gregorian calendar
+      (let* ((z (+ days 719468))
+             (era (if (>= z 0)
+                    (floor-quotient z 146097)
+                    (floor-quotient (- z 146096) 146097)))
+             (doe (- z (* era 146097))) ; [0, 146096]
+             (yoe (floor-quotient (- doe (floor-quotient doe 1460)
+                                    (- (floor-quotient doe 36524))
+                                    (floor-quotient doe 146096))
+                                  365))
+             (y (+ yoe (* era 400)))
+             (doy (- doe (+ (* 365 yoe)
+                            (floor-quotient yoe 4)
+                            (- (floor-quotient yoe 100)))))
+             (mp (floor-quotient (+ (* 5 doy) 2) 153))
+             (d (+ (- doy (floor-quotient (+ (* 153 mp) 2) 5)) 1))
+             (m (+ mp (if (< mp 10) 3 -9)))
+             (y (if (<= m 2) (+ y 1) y)))
+        (values y m d)))
+
+    ;; TODO: spec says default tz-offset should be local time zone.
+    ;; We don't have a local tz interface yet, so default is 0 (UTC).
+    (define* (time-utc->date time-utc (tz-offset 0))
+      (unless (and (time? time-utc) (eq? (time-type time-utc) TIME-UTC))
+        (error 'wrong-type-arg "time-utc->date: time-utc must be a TIME-UTC object" time-utc))
+      (unless (integer? tz-offset)
+        (error 'wrong-type-arg "time-utc->date: tz-offset must be an integer" tz-offset))
+      (let* ((sec (+ (time-second time-utc) tz-offset))
+             (nsec (time-nanosecond time-utc)))
+        (receive (days day-sec) (floor/ sec priv:SID)
+          (receive (year month day) (priv:civil-from-days days)
+            (receive (hour rem1) (floor/ day-sec 3600)
+              (receive (minute second) (floor/ rem1 60)
+                (make-date nsec second minute hour day month year tz-offset)))))))
+
+    (define (date->time-utc date)
+      (unless (date? date)
+        (error 'wrong-type-arg "date->time-utc: date must be a date object" date))
+      (let* ((days (priv:days-since-epoch (date-year date)
+                                          (date-month date)
+                                          (date-day date)))
+             (local-sec (+ (* days priv:SID)
+                           (* (date-hour date) 3600)
+                           (* (date-minute date) 60)
+                           (date-second date)))
+             (utc-sec (- local-sec (date-zone-offset date))))
+        (make-time TIME-UTC (date-nanosecond date) utc-sec)))
+
+    ;; ====================
+    ;; Date to String/String to Date Converters
+    ;; ====================
+
+    (define (priv:locale-abbr-weekday n)
+      (vector-ref priv:LOCALE-ABBR-WEEKDAY-VECTOR n))
+    (define (priv:locale-long-weekday n)
+      (vector-ref priv:LOCALE-LONG-WEEKDAY-VECTOR n))
+    (define (priv:locale-abbr-month n)
+      (vector-ref priv:LOCALE-ABBR-MONTH-VECTOR n))
+    (define (priv:locale-long-month n)
+      (vector-ref priv:LOCALE-LONG-MONTH-VECTOR n))
+
+    ;; Only handles positive integers `n`. Internal use only.
+    (define (priv:padding n pad-with len)
+      (let* ((str     (number->string n))
+             (str-len (string-length str)))
+        (cond
+          ((or (> str-len len) (not pad-with)) str)
+          (else (string-pad str len pad-with)))))
+
+    (define (priv:locale-am/pm hr)
+      (if (> hr 11) priv:LOCALE-PM priv:LOCALE-AM))
+
+    (define (priv:date-week-number-iso date)
+      (let* ((year (date-year date))
+             (jan1-wday (priv:week-day 1 1 year))
+             (offset (if (> jan1-wday 4) 0 1))
+             ;; 调整值：补偿 1-based 和 周日归属
+             (adjusted (+ (date-year-day date) jan1-wday -2))
+             (raw-week (+ (floor-quotient adjusted 7) offset)))
+        (cond ((zero? raw-week)
+               (priv:date-week-number-iso 
+                (make-date 0 0 0 0 31 12 (- year 1) 0)))
+
+              ((and (= raw-week 53)
+                    (<= (priv:week-day 1 1 (+ year 1)) 4))
+               1)
+
+              (else raw-week))))
+
+    (define (priv:last-n-digits i n)
+      (modulo i (expt 10 n)))
+
+    (define (priv:tz-printer offset port)
+      (cond
+        ((zero? offset)     (display "Z" port))
+        ((negative? offset) (display "-" port))
+        (else               (display "+" port)))
+      (unless (zero? offset)
+        (let ((hours   (abs (quotient offset (* 60 60))))
+              (minutes (abs (quotient (remainder offset (* 60 60)) 60))))
+          (display (priv:padding hours   #\0 2) port)
+          (display (priv:padding minutes #\0 2) port))))
+
+    (define (priv:directives/formatter char format-string)
+      (lambda (date pad-with port)
+        (case char
+          ((#\~) (display #\~ port))
+          ((#\a) (display (priv:locale-abbr-weekday (date-week-day date))
+                          port))
+          ((#\A) (display (priv:locale-long-weekday (date-week-day date))
+                          port))
+          ((#\b #\h) (display (priv:locale-abbr-month (date-month date))
+                              port))
+          ((#\B) (display (priv:locale-long-month (date-month date))
+                          port))
+          ((#\c) (display (date->string date priv:LOCALE-DATE-TIME-FORMAT)
+                          port))
+          ((#\d) (display (priv:padding (date-day date) #\0 2)
+                          port))
+          ((#\D) (display (date->string date "~m/~d/~y")
+                          port))
+          ((#\e) (display (priv:padding (date-day date) #\space 2)
+                          port))
+          ;; ref Guile
+          ((#\f) (receive (s ns)
+                          (floor/ (+ (* (date-second date) priv:NANO)
+                                     (date-nanosecond date))
+                                  priv:NANO)
+                   (display (number->string s) port)
+                   (display priv:LOCALE-DECIMAL-POINT port)
+                   (let ((str (priv:padding ns #\0 9)))
+                     (display (substring str 0 1) port)
+                     (display (string-trim-right str #\0 1) port))))
+          ((#\H) (display (priv:padding (date-hour date)
+                                        pad-with 2)
+                          port))
+          ((#\I) (display (priv:padding (+ 1 (modulo (- (date-hour date) 1) 12))
+                                        pad-with
+                                        2)
+                          port))
+          ((#\j) (display (priv:padding (date-year-day date)
+                                        pad-with 3)
+                          port))
+          ((#\k) (display (priv:padding (date-hour date)
+                                        #\space 2)
+                          port))
+          ((#\l) (display (priv:padding (+ 1 (modulo (- (date-hour date) 1) 12))
+                                        #\space
+                                        2)
+                          port))
+          ((#\m) (display (priv:padding (date-month date)
+                                        pad-with 2)
+                          port))
+          ((#\M) (display (priv:padding (date-minute date)
+                                        pad-with 2)
+                          port))
+          ((#\n) (newline port))
+          ((#\N) (display (priv:padding (date-nanosecond date)
+                                        pad-with 9)
+                          port))
+          ((#\p) (display (priv:locale-am/pm (date-hour date)) port))
+          ((#\r) (display (date->string date "~I:~M:~S ~p") port))
+
+          ((#\s) (error "Not Implement"))
+          ((#\S) (let ((sec-delta (if (> (date-nanosecond date) priv:NANO)
+                                    1 0)))
+                   (display (priv:padding (+ (date-second date) sec-delta)
+                                          pad-with 2)
+                            port)))
+
+          ((#\t) (display #\tab port))
+          ((#\T) (display (date->string date "~H:~M:~S") port))
+          ((#\U) (let* ((week>0?   (> (priv:days-before-first-week date 0) 0))
+                        (week-num  (date-week-number date 0))
+                        (week-num* (if week>0? (+ week-num 1) week-num)))
+                   (display (priv:padding week-num* #\0 2) port)))
+
+          ((#\V) (display (priv:padding (priv:date-week-number-iso date)
+                                        #\0 2) port))
+          ((#\w) (display (date-week-day date) port))
+          ((#\W) (let* ((week>1?   (> (priv:days-before-first-week date 1) 0))
+                        (week-num  (date-week-number date 1))
+                        (week-num* (if week>1? (+ week-num 1) week-num)))
+                   (display (priv:padding week-num* #\0 2) port)))
+          ((#\x) (display (date->string date priv:LOCALE-SHORT-DATE-FORMAT) port))
+          ((#\X) (display (date->string date priv:LOCALE-TIME-FORMAT) port))
+          ((#\y) (display (priv:padding (priv:last-n-digits (date-year date) 2)
+                                        pad-with 2)
+                          port))
+          ((#\Y) (display (priv:padding (date-year date) pad-with 4)
+                          port))
+          ((#\z) (priv:tz-printer (date-zone-offset date) port))
+          ((#\Z) (error "Not Implement"))
+          ((#\1) (display (date->string date "~Y-~m-~d") port))
+          ((#\2) (display (date->string date "~H:~M:~S~z") port))
+          ((#\3) (display (date->string date "~H:~M:~S") port))
+          ((#\4) (display (date->string date "~Y-~m-~dT~H:~M:~S~z") port))
+          ((#\5) (display (date->string date "~Y-~m-~dT~H:~M:~S") port))
+          (else (priv:bad-format-error format-string)))))
+
+    (define (priv:bad-format-error format-string)
+      (value-error "bad date format string" format-string))
+
+    (define (priv:date-printer date format-string format-string-port port)
+      (let ((current-char (read-char format-string-port))
+            (pad-char     (peek-char format-string-port)))
+        (cond
+          ((eof-object? current-char) (values))
+
+          ((and (eof-object? pad-char)
+                ;; unfinished directives
+                (char=? current-char #\~))
+           (priv:bad-format-error format-string))
+
+          ((and (char=? current-char #\~)
+                (or (char=? pad-char #\-) (char=? pad-char #\_)))
+           (let ((pad-pad-char (begin (read-char format-string-port)
+                                      (peek-char format-string-port))))
+             (if (eof-object? pad-pad-char)
+               (priv:bad-format-error format-string)
+               (let ((formatter (priv:directives/formatter pad-pad-char format-string))
+                     (pad-with  (if (char=? pad-char #\-) #f #\space)))
+                 (begin (formatter date pad-with port)
+                        (priv:date-printer date format-string
+                                           format-string-port port))))))
+
+          ((char=? current-char #\~)
+           (let ((formatter (priv:directives/formatter pad-char format-string)))
+             (begin (formatter date #\0 port)
+                    (read-char format-string-port) ; consume
+                    (priv:date-printer date format-string
+                                       format-string-port port))))
+
+          (else
+            (display current-char port)
+            (priv:date-printer date format-string
+                               format-string-port port)))))
+
+    (define* (date->string date (format-string "~c"))
+      (let ((str-port (open-output-string)))
+        (priv:date-printer date format-string
+                   (open-input-string format-string)
+                   str-port)
+        (get-output-string str-port)))))
diff --git a/TeXmacs/plugins/goldfish/src/goldfish.hpp b/TeXmacs/plugins/goldfish/src/goldfish.hpp
index dc7f807fbe..c7dae31064 100644
--- a/TeXmacs/plugins/goldfish/src/goldfish.hpp
+++ b/TeXmacs/plugins/goldfish/src/goldfish.hpp
@@ -58,7 +58,7 @@
 #include <isocline.h>
 #endif
 
-#define GOLDFISH_VERSION "17.11.25"
+#define GOLDFISH_VERSION "17.11.26"
 
 #define GOLDFISH_PATH_MAXN TB_PATH_MAXN
 
@@ -359,6 +359,303 @@ glue_http_stream (s7_scheme* sc) {
   glue_http_stream_post(sc);
 }
 
+// -------------------------------- Async HTTP --------------------------------
+// Data structure to store async HTTP request state
+struct AsyncHttpRequest {
+  s7_scheme* sc;
+  s7_pointer callback;
+  int gc_loc;
+  std::shared_ptr<cpr::Session> session;  // Keep session alive
+  cpr::AsyncResponse async_response;
+  bool completed;
+  cpr::Response response;
+  std::mutex mutex;
+  
+  AsyncHttpRequest(s7_scheme* scheme, s7_pointer cb, int gc_protect_loc, 
+                   std::shared_ptr<cpr::Session> sess, cpr::AsyncResponse&& ar)
+    : sc(scheme), callback(cb), gc_loc(gc_protect_loc), 
+      session(std::move(sess)), async_response(std::move(ar)), completed(false) {}
+};
+
+// Global list of pending async requests
+static std::mutex g_async_requests_mutex;
+static std::vector<std::shared_ptr<AsyncHttpRequest>> g_async_requests;
+
+// Check if any async requests have completed and process their callbacks
+// This function should be called periodically from the main thread
+// Returns the number of callbacks executed
+static int
+process_async_http_callbacks () {
+  std::vector<std::shared_ptr<AsyncHttpRequest>> completed_requests;
+  
+  // Find completed requests
+  {
+    std::lock_guard<std::mutex> lock(g_async_requests_mutex);
+    for (auto it = g_async_requests.begin(); it != g_async_requests.end(); ) {
+      bool is_ready = false;
+      {
+        std::lock_guard<std::mutex> req_lock((*it)->mutex);
+        if (!(*it)->completed) {
+          // Check if the future is ready (non-blocking)
+          if ((*it)->async_response.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
+            (*it)->response = (*it)->async_response.get();
+            (*it)->completed = true;
+            is_ready = true;
+          }
+        }
+      }
+      
+      if (is_ready) {
+        completed_requests.push_back(*it);
+        it = g_async_requests.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+  
+  // Execute callbacks for completed requests (outside the lock)
+  for (auto& req : completed_requests) {
+    s7_pointer ht = response2hashtable(req->sc, req->response);
+    s7_call(req->sc, req->callback, s7_cons(req->sc, ht, s7_nil(req->sc)));
+    s7_gc_unprotect_at(req->sc, req->gc_loc);
+  }
+  
+  return static_cast<int>(completed_requests.size());
+}
+
+// Start an async HTTP GET request
+static s7_pointer
+f_http_async_get (s7_scheme* sc, s7_pointer args) {
+  const char* url = s7_string(s7_car(args));
+  s7_pointer params = s7_cadr(args);
+  s7_pointer headers = s7_caddr(args);
+  s7_pointer proxy = s7_cadddr(args);
+  s7_pointer callback = s7_car(s7_cddddr(args));
+  
+  if (!s7_is_procedure(callback)) {
+    return s7_error(sc, s7_make_symbol(sc, "type-error"),
+                    s7_list(sc, 2, s7_make_string(sc, "http-async-get: callback must be a procedure"), callback));
+  }
+  
+  cpr::Parameters cpr_params = to_cpr_parameters(sc, params);
+  cpr::Header cpr_headers = to_cpr_headers(sc, headers);
+  cpr::Proxies cpr_proxies = to_cpr_proxies(sc, proxy);
+  
+  // Protect callback from GC
+  int gc_loc = s7_gc_protect(sc, callback);
+  
+  // Create session on heap with shared_ptr to keep it alive
+  auto session = std::make_shared<cpr::Session>();
+  session->SetUrl(cpr::Url(url));
+  session->SetParameters(cpr_params);
+  session->SetHeader(cpr_headers);
+  if (s7_is_list(sc, proxy) && !s7_is_null(sc, proxy)) {
+    session->SetProxies(cpr_proxies);
+  }
+  
+  // Start async request using libcpr's built-in thread pool
+  // Session is captured by shared_ptr, so it stays alive until async operation completes
+  auto async_resp = session->GetAsync();
+  
+  // Store the request (session is also stored to keep reference)
+  auto req = std::make_shared<AsyncHttpRequest>(sc, callback, gc_loc, session, std::move(async_resp));
+  {
+    std::lock_guard<std::mutex> lock(g_async_requests_mutex);
+    g_async_requests.push_back(req);
+  }
+  
+  return s7_make_boolean(sc, true);
+}
+
+inline void
+glue_http_async_get (s7_scheme* sc) {
+  s7_pointer cur_env = s7_curlet(sc);
+  const char* name = "g_http-async-get";
+  const char* doc = "(g_http-async-get url params headers proxy callback) => boolean, start async http get. callback receives response hashtable. Use g_http-poll to check for completion.";
+  auto func = s7_make_typed_function(sc, name, f_http_async_get, 5, 0, false, doc, NULL);
+  s7_define(sc, cur_env, s7_make_symbol(sc, name), func);
+}
+
+// Start an async HTTP POST request
+static s7_pointer
+f_http_async_post (s7_scheme* sc, s7_pointer args) {
+  const char* url = s7_string(s7_car(args));
+  s7_pointer params = s7_cadr(args);
+  const char* body = s7_string(s7_caddr(args));
+  s7_pointer headers = s7_cadddr(args);
+  s7_pointer proxy = s7_car(s7_cddddr(args));
+  s7_pointer callback = s7_cadr(s7_cddddr(args));
+  
+  if (!s7_is_procedure(callback)) {
+    return s7_error(sc, s7_make_symbol(sc, "type-error"),
+                    s7_list(sc, 2, s7_make_string(sc, "http-async-post: callback must be a procedure"), callback));
+  }
+  
+  cpr::Parameters cpr_params = to_cpr_parameters(sc, params);
+  cpr::Header cpr_headers = to_cpr_headers(sc, headers);
+  cpr::Proxies cpr_proxies = to_cpr_proxies(sc, proxy);
+  
+  // Protect callback from GC
+  int gc_loc = s7_gc_protect(sc, callback);
+  
+  // Create session on heap with shared_ptr to keep it alive
+  auto session = std::make_shared<cpr::Session>();
+  session->SetUrl(cpr::Url(url));
+  session->SetParameters(cpr_params);
+  session->SetBody(cpr::Body(body));
+  session->SetHeader(cpr_headers);
+  if (s7_is_list(sc, proxy) && !s7_is_null(sc, proxy)) {
+    session->SetProxies(cpr_proxies);
+  }
+  
+  // Start async request using libcpr's built-in thread pool
+  auto async_resp = session->PostAsync();
+  
+  // Store the request (session is also stored to keep reference)
+  auto req = std::make_shared<AsyncHttpRequest>(sc, callback, gc_loc, session, std::move(async_resp));
+  {
+    std::lock_guard<std::mutex> lock(g_async_requests_mutex);
+    g_async_requests.push_back(req);
+  }
+  
+  return s7_make_boolean(sc, true);
+}
+
+inline void
+glue_http_async_post (s7_scheme* sc) {
+  s7_pointer cur_env = s7_curlet(sc);
+  const char* name = "g_http-async-post";
+  const char* doc = "(g_http-async-post url params body headers proxy callback) => boolean, start async http post. callback receives response hashtable. Use g_http-poll to check for completion.";
+  auto func = s7_make_typed_function(sc, name, f_http_async_post, 6, 0, false, doc, NULL);
+  s7_define(sc, cur_env, s7_make_symbol(sc, name), func);
+}
+
+// Start an async HTTP HEAD request
+static s7_pointer
+f_http_async_head (s7_scheme* sc, s7_pointer args) {
+  const char* url = s7_string(s7_car(args));
+  s7_pointer params = s7_cadr(args);
+  s7_pointer headers = s7_caddr(args);
+  s7_pointer proxy = s7_cadddr(args);
+  s7_pointer callback = s7_car(s7_cddddr(args));
+  
+  if (!s7_is_procedure(callback)) {
+    return s7_error(sc, s7_make_symbol(sc, "type-error"),
+                    s7_list(sc, 2, s7_make_string(sc, "http-async-head: callback must be a procedure"), callback));
+  }
+  
+  cpr::Parameters cpr_params = to_cpr_parameters(sc, params);
+  cpr::Header cpr_headers = to_cpr_headers(sc, headers);
+  cpr::Proxies cpr_proxies = to_cpr_proxies(sc, proxy);
+  
+  // Protect callback from GC
+  int gc_loc = s7_gc_protect(sc, callback);
+  
+  // Create session on heap with shared_ptr to keep it alive
+  auto session = std::make_shared<cpr::Session>();
+  session->SetUrl(cpr::Url(url));
+  session->SetParameters(cpr_params);
+  session->SetHeader(cpr_headers);
+  if (s7_is_list(sc, proxy) && !s7_is_null(sc, proxy)) {
+    session->SetProxies(cpr_proxies);
+  }
+  
+  // Start async request using libcpr's built-in thread pool
+  auto async_resp = session->HeadAsync();
+  
+  // Store the request (session is also stored to keep reference)
+  auto req = std::make_shared<AsyncHttpRequest>(sc, callback, gc_loc, session, std::move(async_resp));
+  {
+    std::lock_guard<std::mutex> lock(g_async_requests_mutex);
+    g_async_requests.push_back(req);
+  }
+  
+  return s7_make_boolean(sc, true);
+}
+
+inline void
+glue_http_async_head (s7_scheme* sc) {
+  s7_pointer cur_env = s7_curlet(sc);
+  const char* name = "g_http-async-head";
+  const char* doc = "(g_http-async-head url params headers proxy callback) => boolean, start async http head. callback receives response hashtable. Use g_http-poll to check for completion.";
+  auto func = s7_make_typed_function(sc, name, f_http_async_head, 5, 0, false, doc, NULL);
+  s7_define(sc, cur_env, s7_make_symbol(sc, name), func);
+}
+
+// Poll for completed async HTTP requests and execute their callbacks
+static s7_pointer
+f_http_poll (s7_scheme* sc, s7_pointer args) {
+  int executed = process_async_http_callbacks();
+  return s7_make_integer(sc, executed);
+}
+
+inline void
+glue_http_poll (s7_scheme* sc) {
+  s7_pointer cur_env = s7_curlet(sc);
+  const char* name = "g_http-poll";
+  const char* doc = "(g_http-poll) => integer, check for completed async http requests and execute their callbacks. Returns number of callbacks executed.";
+  auto func = s7_make_typed_function(sc, name, f_http_poll, 0, 0, false, doc, NULL);
+  s7_define(sc, cur_env, s7_make_symbol(sc, name), func);
+}
+
+// Wait for all pending async HTTP requests to complete (blocking)
+static s7_pointer
+f_http_wait_all (s7_scheme* sc, s7_pointer args) {
+  s7_double timeout_sec = -1.0; // -1 means wait forever
+  if (s7_is_real(s7_car(args))) {
+    timeout_sec = s7_real(s7_car(args));
+  }
+  
+  auto start = std::chrono::steady_clock::now();
+  bool has_pending = true;
+  int total_executed = 0;
+  
+  while (has_pending) {
+    int executed = process_async_http_callbacks();
+    total_executed += executed;
+    
+    // Check if there are still pending requests
+    {
+      std::lock_guard<std::mutex> lock(g_async_requests_mutex);
+      has_pending = !g_async_requests.empty();
+    }
+    
+    if (has_pending) {
+      // Check timeout
+      if (timeout_sec >= 0) {
+        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+          std::chrono::steady_clock::now() - start).count() / 1000.0;
+        if (elapsed >= timeout_sec) {
+          break; // Timeout
+        }
+      }
+      // Small sleep to avoid busy waiting
+      std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+  }
+  
+  return s7_make_integer(sc, total_executed);
+}
+
+inline void
+glue_http_wait_all (s7_scheme* sc) {
+  s7_pointer cur_env = s7_curlet(sc);
+  const char* name = "g_http-wait-all";
+  const char* doc = "(g_http-wait-all [timeout-seconds]) => integer, wait for all pending async http requests to complete. timeout < 0 means wait forever. Returns number of callbacks executed.";
+  auto func = s7_make_typed_function(sc, name, f_http_wait_all, 0, 1, false, doc, NULL);
+  s7_define(sc, cur_env, s7_make_symbol(sc, name), func);
+}
+
+inline void
+glue_http_async (s7_scheme* sc) {
+  glue_http_async_get(sc);
+  glue_http_async_post(sc);
+  glue_http_async_head(sc);
+  glue_http_poll(sc);
+  glue_http_wait_all(sc);
+}
+
 
 inline s7_pointer
 string_vector_to_s7_vector (s7_scheme* sc, vector<string> v) {
@@ -404,26 +701,60 @@ glue_goldfish (s7_scheme* sc) {
              s7_make_typed_function (sc, s_delete_file, f_delete_file, 1, 0, false, d_delete_file, NULL));
 }
 
+// old `f_current_second` TODO: use std::chrono::tai_clock::now() when using C++ 20
+//                        NOTE(jinser): use a new name for tai
+// `current-second` impl by g_get-time-of-day now
 static s7_pointer
-f_current_second (s7_scheme* sc, s7_pointer args) {
-  // TODO: use std::chrono::tai_clock::now() when using C++ 20
-  tb_timeval_t tp= {0};
-  tb_gettimeofday (&tp, tb_null);
-  s7_double res= (time_t) tp.tv_sec + (tp.tv_usec / 1000000.0);
-  return s7_make_real (sc, res);
+f_get_time_of_day (s7_scheme* sc, s7_pointer args) {
+  using namespace std::chrono;
+  auto now = time_point_cast<microseconds>(system_clock::now());
+  auto since_epoch = now.time_since_epoch();
+  auto sec = duration_cast<seconds>(since_epoch);
+
+  s7_pointer vs = s7_list(sc, 2,
+                          s7_make_integer(sc, sec.count()),
+                          s7_make_integer(sc, (since_epoch - sec).count()));
+  return s7_values(sc, vs);
+}
+
+static s7_pointer
+f_monotonic_nanosecond (s7_scheme* sc, s7_pointer args) {
+  using namespace std::chrono;
+  auto now = steady_clock::now();
+  auto duration = now.time_since_epoch();
+  auto count = duration_cast<std::chrono::nanoseconds>(duration).count();
+  return s7_make_integer(sc, count);
+}
+
+template<typename Clock>
+constexpr int64_t clock_resolution_ns() {
+  typedef std::chrono::duration<double, std::nano> NS;
+  NS ns = typename Clock::duration(1);
+  return ns.count();
 }
 
 inline void
 glue_scheme_time (s7_scheme* sc) {
   s7_pointer cur_env= s7_curlet (sc);
 
-  const char* s_current_second= "g_current-second";
-  const char* d_current_second= "(g_current-second): () => double, return the "
-                                "current unix timestamp in double";
-  s7_define (sc, cur_env, s7_make_symbol (sc, s_current_second),
-             s7_make_typed_function (sc, s_current_second, f_current_second, 0, 0, false, d_current_second, NULL));
+  const char* s_get_time_of_day= "g_get-time-of-day";
+  const char* d_get_time_of_day= "(g_get-time-of-day): () => (integer, integer), return the "
+                                "current second and microsecond in integer";
+  s7_define (sc, cur_env, s7_make_symbol (sc, s_get_time_of_day),
+             s7_make_typed_function (sc, s_get_time_of_day, f_get_time_of_day, 0, 0, false, d_get_time_of_day, NULL));
+
+  const char* s_monotonic_nanosecond= "g_monotonic-nanosecond";
+  const char* d_monotonic_nanosecond= "(g_monotonic-nanosecond): () => integer, returns the steady clock's monotonic nanoseconds since an unspecified epoch";
+  s7_define (sc, cur_env, s7_make_symbol (sc, s_monotonic_nanosecond),
+             s7_make_typed_function (sc, s_monotonic_nanosecond, f_monotonic_nanosecond, 0, 0, false, d_monotonic_nanosecond, NULL));
+
+  s7_define_constant_with_environment (sc, cur_env, "g_system-clock-resolution",
+                                       s7_make_integer(sc, clock_resolution_ns<std::chrono::system_clock>()));
+  s7_define_constant_with_environment (sc, cur_env, "g_steady-clock-resolution",
+                                       s7_make_integer(sc, clock_resolution_ns<std::chrono::steady_clock>()));
 }
 
+
 static s7_pointer
 f_get_environment_variable (s7_scheme* sc, s7_pointer args) {
 #ifdef _MSC_VER
@@ -872,83 +1203,219 @@ glue_liii_uuid (s7_scheme* sc) {
   glue_uuid4 (sc);
 }
 
-static s7_pointer f_md5(s7_scheme* sc, s7_pointer args) {
-    const char* searchString = s7_string(s7_car(args));
-    tb_size_t len = tb_strlen(searchString);
-    tb_byte_t ob[16];
-    tb_char_t hex_output[33] = {0};
-    tb_md5_t md5;
-    tb_md5_init(&md5, 0); 
-    if (len > 0) {
-        tb_md5_spak(&md5, (tb_byte_t const*)searchString, len);
+inline void
+hash_bytes_to_hex (const tb_byte_t* bytes, tb_size_t length, tb_char_t* hex_output) {
+  static const tb_char_t hex_digits[]= "0123456789abcdef";
+  for (tb_size_t i= 0; i < length; ++i) {
+    hex_output[i * 2]    = hex_digits[bytes[i] >> 4];
+    hex_output[i * 2 + 1]= hex_digits[bytes[i] & 0x0f];
+  }
+  hex_output[length * 2]= '\0';
+}
+
+static bool
+md5_file_to_hex (const char* path, tb_char_t* hex_output) {
+  if (!path) {
+    return false;
+  }
+
+  tb_file_ref_t file= tb_file_init (path, TB_FILE_MODE_RO);
+  if (file == tb_null) {
+    return false;
+  }
+
+  tb_md5_t md5;
+  tb_md5_init (&md5, 0);
+
+  tb_size_t size  = tb_file_size (file);
+  tb_size_t offset= 0;
+  tb_byte_t buffer[4096];
+  while (offset < size) {
+    tb_size_t want     = ((size - offset) > sizeof (buffer)) ? sizeof (buffer) : (size - offset);
+    tb_size_t real_size= tb_file_read (file, buffer, want);
+    if (real_size == 0) {
+      tb_file_exit (file);
+      return false;
     }
-    tb_md5_exit(&md5, ob, 16);
-    for (tb_size_t i = 0; i < 16; ++i) {
-        tb_snprintf(hex_output + (i << 1), 3, "%02x", ob[i]);
+    tb_md5_spak (&md5, buffer, real_size);
+    offset += real_size;
+  }
+
+  tb_file_exit (file);
+
+  tb_byte_t digest[16];
+  tb_md5_exit (&md5, digest, sizeof (digest));
+  hash_bytes_to_hex (digest, sizeof (digest), hex_output);
+  return true;
+}
+
+static bool
+sha_file_to_hex (const char* path, tb_size_t mode, tb_size_t digest_size, tb_char_t* hex_output) {
+  if (!path) {
+    return false;
+  }
+
+  tb_file_ref_t file= tb_file_init (path, TB_FILE_MODE_RO);
+  if (file == tb_null) {
+    return false;
+  }
+
+  tb_sha_t sha;
+  tb_sha_init (&sha, mode);
+
+  tb_size_t size  = tb_file_size (file);
+  tb_size_t offset= 0;
+  tb_byte_t buffer[4096];
+  while (offset < size) {
+    tb_size_t want     = ((size - offset) > sizeof (buffer)) ? sizeof (buffer) : (size - offset);
+    tb_size_t real_size= tb_file_read (file, buffer, want);
+    if (real_size == 0) {
+      tb_file_exit (file);
+      return false;
     }
-    return s7_make_string(sc, hex_output);
+    tb_sha_spak (&sha, buffer, real_size);
+    offset += real_size;
+  }
+
+  tb_file_exit (file);
+
+  tb_byte_t digest[32];
+  tb_sha_exit (&sha, digest, digest_size);
+  hash_bytes_to_hex (digest, digest_size, hex_output);
+  return true;
+}
+
+static s7_pointer
+f_md5 (s7_scheme* sc, s7_pointer args) {
+  const char* search_string= s7_string (s7_car (args));
+  tb_size_t   len          = tb_strlen (search_string);
+  tb_byte_t   digest[16];
+  tb_char_t   hex_output[33]= {0};
+  tb_md5_t    md5;
+
+  tb_md5_init (&md5, 0);
+  if (len > 0) {
+    tb_md5_spak (&md5, (tb_byte_t const*) search_string, len);
+  }
+  tb_md5_exit (&md5, digest, sizeof (digest));
+  hash_bytes_to_hex (digest, sizeof (digest), hex_output);
+  return s7_make_string (sc, hex_output);
 }
 
-inline void 
-glue_md5(s7_scheme* sc) {
-  const char* name = "g_md5";
-  const char* desc = "(g_md5 str) => string";
-  glue_define(sc, name, desc, f_md5, 1, 0);
+inline void
+glue_md5 (s7_scheme* sc) {
+  const char* name= "g_md5";
+  const char* desc= "(g_md5 str) => string";
+  glue_define (sc, name, desc, f_md5, 1, 0);
 }
 
-static s7_pointer f_sha1(s7_scheme* sc, s7_pointer args) {
-    const char* searchString = s7_string(s7_car(args));
-    tb_size_t len = tb_strlen(searchString);
-    tb_byte_t ob[20]; // SHA1 produces 20 bytes
-    tb_char_t hex_output[41] = {0}; // 20 bytes * 2 hex digits per byte + null terminator
-    tb_sha_t sha;
-    tb_sha_init(&sha, 160); // TB_SHA_MODE_SHA1_160 = 160
-    if (len > 0) {
-        tb_sha_spak(&sha, (tb_byte_t const*)searchString, len);
-    }
-    tb_sha_exit(&sha, ob, 20);
-    for (tb_size_t i = 0; i < 20; ++i) {
-        tb_snprintf(hex_output + (i << 1), 3, "%02x", ob[i]);
-    }
-    return s7_make_string(sc, hex_output);
+static s7_pointer
+f_md5_file (s7_scheme* sc, s7_pointer args) {
+  const char* path= s7_string (s7_car (args));
+  tb_char_t   hex_output[33]= {0};
+  if (!md5_file_to_hex (path, hex_output)) {
+    return s7_make_boolean (sc, false);
+  }
+  return s7_make_string (sc, hex_output);
 }
 
 inline void
-glue_sha1(s7_scheme* sc) {
-  const char* name = "g_sha1";
-  const char* desc = "(g_sha1 str) => string";
-  glue_define(sc, name, desc, f_sha1, 1, 0);
+glue_md5_file (s7_scheme* sc) {
+  const char* name= "g_md5-by-file";
+  const char* desc= "(g_md5-by-file path) => string|#f";
+  glue_define (sc, name, desc, f_md5_file, 1, 0);
 }
 
-static s7_pointer f_sha256(s7_scheme* sc, s7_pointer args) {
-    const char* searchString = s7_string(s7_car(args));
-    tb_size_t len = tb_strlen(searchString);
-    tb_byte_t ob[32]; // SHA256 produces 32 bytes
-    tb_char_t hex_output[65] = {0}; // 32 bytes * 2 hex digits per byte + null terminator
-    tb_sha_t sha;
-    tb_sha_init(&sha, 256); // TB_SHA_MODE_SHA2_256 = 256
-    if (len > 0) {
-        tb_sha_spak(&sha, (tb_byte_t const*)searchString, len);
-    }
-    tb_sha_exit(&sha, ob, 32);
-    for (tb_size_t i = 0; i < 32; ++i) {
-        tb_snprintf(hex_output + (i << 1), 3, "%02x", ob[i]);
-    }
-    return s7_make_string(sc, hex_output);
+static s7_pointer
+f_sha1 (s7_scheme* sc, s7_pointer args) {
+  const char* search_string= s7_string (s7_car (args));
+  tb_size_t   len          = tb_strlen (search_string);
+  tb_byte_t   digest[20];
+  tb_char_t   hex_output[41]= {0};
+  tb_sha_t    sha;
+
+  tb_sha_init (&sha, 160);
+  if (len > 0) {
+    tb_sha_spak (&sha, (tb_byte_t const*) search_string, len);
+  }
+  tb_sha_exit (&sha, digest, sizeof (digest));
+  hash_bytes_to_hex (digest, sizeof (digest), hex_output);
+  return s7_make_string (sc, hex_output);
 }
 
 inline void
-glue_sha256(s7_scheme* sc) {
-  const char* name = "g_sha256";
-  const char* desc = "(g_sha256 str) => string";
-  glue_define(sc, name, desc, f_sha256, 1, 0);
+glue_sha1 (s7_scheme* sc) {
+  const char* name= "g_sha1";
+  const char* desc= "(g_sha1 str) => string";
+  glue_define (sc, name, desc, f_sha1, 1, 0);
+}
+
+static s7_pointer
+f_sha1_file (s7_scheme* sc, s7_pointer args) {
+  const char* path= s7_string (s7_car (args));
+  tb_char_t   hex_output[41]= {0};
+  if (!sha_file_to_hex (path, 160, 20, hex_output)) {
+    return s7_make_boolean (sc, false);
+  }
+  return s7_make_string (sc, hex_output);
+}
+
+inline void
+glue_sha1_file (s7_scheme* sc) {
+  const char* name= "g_sha1-by-file";
+  const char* desc= "(g_sha1-by-file path) => string|#f";
+  glue_define (sc, name, desc, f_sha1_file, 1, 0);
+}
+
+static s7_pointer
+f_sha256 (s7_scheme* sc, s7_pointer args) {
+  const char* search_string= s7_string (s7_car (args));
+  tb_size_t   len          = tb_strlen (search_string);
+  tb_byte_t   digest[32];
+  tb_char_t   hex_output[65]= {0};
+  tb_sha_t    sha;
+
+  tb_sha_init (&sha, 256);
+  if (len > 0) {
+    tb_sha_spak (&sha, (tb_byte_t const*) search_string, len);
+  }
+  tb_sha_exit (&sha, digest, sizeof (digest));
+  hash_bytes_to_hex (digest, sizeof (digest), hex_output);
+  return s7_make_string (sc, hex_output);
+}
+
+inline void
+glue_sha256 (s7_scheme* sc) {
+  const char* name= "g_sha256";
+  const char* desc= "(g_sha256 str) => string";
+  glue_define (sc, name, desc, f_sha256, 1, 0);
+}
+
+static s7_pointer
+f_sha256_file (s7_scheme* sc, s7_pointer args) {
+  const char* path= s7_string (s7_car (args));
+  tb_char_t   hex_output[65]= {0};
+  if (!sha_file_to_hex (path, 256, 32, hex_output)) {
+    return s7_make_boolean (sc, false);
+  }
+  return s7_make_string (sc, hex_output);
+}
+
+inline void
+glue_sha256_file (s7_scheme* sc) {
+  const char* name= "g_sha256-by-file";
+  const char* desc= "(g_sha256-by-file path) => string|#f";
+  glue_define (sc, name, desc, f_sha256_file, 1, 0);
 }
 
 inline void
 glue_liii_hashlib (s7_scheme* sc) {
   glue_md5 (sc);
+  glue_md5_file (sc);
   glue_sha1 (sc);
+  glue_sha1_file (sc);
   glue_sha256 (sc);
+  glue_sha256_file (sc);
 }
 
 
@@ -1398,6 +1865,7 @@ glue_for_community_edition (s7_scheme* sc) {
   glue_liii_hashlib (sc);
   glue_http (sc);
   glue_http_stream (sc);
+  glue_http_async (sc);
 }
 
 static void
@@ -2068,4 +2536,3 @@ repl_for_community_edition (s7_scheme* sc, int argc, char** argv) {
 }
 
 } // namespace goldfish
-
diff --git a/bin/bump_goldfish b/bin/bump_goldfish
index 4228216918..a92fa4099a 100755
--- a/bin/bump_goldfish
+++ b/bin/bump_goldfish
@@ -5,12 +5,13 @@ var tag = $args[0]
 var tmp = (mktemp -d '/tmp/goldfish-'$tag'-XXX')
 echo $tmp
 
-git clone --branch $tag --single-branch https://gitee.com/XmacsLabs/goldfish $tmp
+git clone --branch $tag --single-branch https://github.com/MoganLab/goldfish $tmp
 
 rm -rf TeXmacs/plugins/goldfish/src/*
 rm -rf TeXmacs/plugins/goldfish/goldfish/liii/*
 rm -rf TeXmacs/plugins/goldfish/goldfish/scheme/*
 rm -rf TeXmacs/plugins/goldfish/goldfish/srfi/*
+rm -rf TeXmacs/plugins/goldfish/goldfish/guenchi/*
 
 cp $tmp/src/goldfish.cpp TeXmacs/plugins/goldfish/src/
 cp $tmp/src/goldfish.hpp TeXmacs/plugins/goldfish/src/
diff --git a/devel/200_21.md b/devel/200_21.md
index 97dd3a69c9..8f51f8c9fe 100644
--- a/devel/200_21.md
+++ b/devel/200_21.md
@@ -10,6 +10,11 @@ xmake run stem
 ./bin/bump_goldfish v17.11.xx
 ```
 
+## 2026/02/13 升级到Goldfish Scheme v17.11.26
+
+### what
+Bump version v17.11.26
+
 ## 2026/02/03 升级到Goldfish Scheme v17.11.25
 ### what
 Bump version v17.11.25