defn- marks :private; ns-publics drops private vars

defn- now adds :private to the var metadata (like Clojure), and ns-publics
filters those out while ns-interns/ns-map keep them — they were all the same
unfiltered scan before. A lib that introspects ns-publics (honeysql asserts
every public helper has a docstring, and that the clause set matches the public
helpers) saw the private defn- helpers and failed; now honeysql 636/8 -> 638/6
(the rest are map key-order).

host/chez/ns.ss

@@ -128,17 +128,23 @@
     (list->cseq (map intern-ns! (vector->list (hashtable-keys seen))))))
 
 ;; ns-publics / ns-map / ns-interns: a {sym -> var-cell} jolt map built by scanning
-;; the var-table for defined cells in the namespace. (Private vars are not tracked
-;; yet, so ns-publics == ns-interns.) ns-aliases is an empty map (map? is true).
-(define (ns-vars-pmap nm)
+;; the var-table for defined cells in the namespace. ns-interns/ns-map keep every
+;; var; ns-publics drops the ones marked ^:private (defn-/def ^:private), like the
+;; JVM. ns-aliases is an empty map (map? is true).
+(define (var-private? c)
+  (let ((m (hashtable-ref var-meta-table c #f)))
+    (and m (jolt-truthy? (jolt-get m (keyword #f "private"))))))
+(define (ns-vars-pmap-when nm keep?)
   (let ((m (jolt-hash-map)))
     (vector-for-each
       (lambda (c)
-        (when (and (string=? (var-cell-ns c) nm) (var-cell-defined? c))
+        (when (and (string=? (var-cell-ns c) nm) (var-cell-defined? c) (keep? c))
           (set! m (jolt-assoc m (jolt-symbol #f (var-cell-name c)) c))))
       (hashtable-values var-table))
     m))
-(define (jolt-ns-publics desig) (ns-vars-pmap (ns-desig->name desig)))
+(define (ns-vars-pmap nm) (ns-vars-pmap-when nm (lambda (c) #t)))
+(define (jolt-ns-publics desig) (ns-vars-pmap-when (ns-desig->name desig) (lambda (c) (not (var-private? c)))))
+(define (jolt-ns-interns desig) (ns-vars-pmap (ns-desig->name desig)))
 
 ;; ns-aliases: the {alias-sym -> ns-value} registered under `desig`
 ;; (default the current ns) via require :as / alias. Reads ns-alias-table.
@@ -322,8 +328,8 @@
 (def-var! "clojure.core" "in-ns" jolt-in-ns)
 (def-var! "clojure.core" "all-ns" jolt-all-ns)
 (def-var! "clojure.core" "ns-publics" jolt-ns-publics)
-(def-var! "clojure.core" "ns-map" jolt-ns-publics)
-(def-var! "clojure.core" "ns-interns" jolt-ns-publics)
+(def-var! "clojure.core" "ns-map" jolt-ns-interns)
+(def-var! "clojure.core" "ns-interns" jolt-ns-interns)
 (def-var! "clojure.core" "ns-aliases" jolt-ns-aliases)
 (def-var! "clojure.core" "ns-refers" jolt-ns-refers)
 (def-var! "clojure.core" "ns-imports" jolt-ns-imports)

jolt-core/clojure/core/00-syntax.clj

@@ -403,9 +403,11 @@
       `(def ~(with-meta fn-only-name meta-map) (fn ~(with-meta fn-only-name nil) ~@body))
       `(def ~fn-only-name (fn ~fn-only-name ~@body)))))
 
-;; Jolt doesn't enforce privacy, so defn- is just defn (matching how Clojure's own
-;; defn- delegates to defn with :private metadata).
-(defmacro defn- [fn-name & body] `(defn ~fn-name ~@body))
+;; defn- marks the var :private (like Clojure). Jolt doesn't restrict access, but
+;; ns-publics filters private vars out — a lib that introspects ns-publics (e.g.
+;; honeysql's "all helpers have docstrings") sees only the public ones.
+(defmacro defn- [fn-name & body]
+  `(defn ~(with-meta fn-name (assoc (if (meta fn-name) (meta fn-name) {}) :private true)) ~@body))
 
 ;; A fresh jolt symbol inside a macro body (a bare (gensym) returns a host symbol
 ;; the destructurer rejects). This defn compiles fine: by the time a tier triggers

test/chez/corpus.edn

@@ -3314,4 +3314,6 @@
   {:suite "metadata / immutability" :label "with-meta on a lazy seq carries metadata" :expected "true" :actual "(= {:k 5} (meta (with-meta (lazy-seq (list 1)) {:k 5})))"}
   {:suite "edn / deferred tags" :label "a :readers override wins over the built-in #inst (not eagerly built)" :expected "true" :actual "(= [:I \"x\"] (clojure.edn/read-string {:readers {(quote inst) (fn [v] [:I v])}} \"#inst \\\"x\\\"\"))"}
   {:suite "edn / deferred tags" :label "a normal #inst still constructs without an override" :expected "true" :actual "(= #inst \"2020-01-01T00:00:00.000-00:00\" (clojure.edn/read-string \"#inst \\\"2020-01-01T00:00:00.000-00:00\\\"\"))"}
+  {:suite "vars / privacy" :label "defn- marks the var :private" :expected "true" :actual "(do (defn- p [] 1) (true? (:private (meta (var p)))))"}
+  {:suite "vars / privacy" :label "ns-publics drops private vars; ns-interns keeps them" :expected "[true false true]" :actual "(do (defn pub [] 1) (defn- priv [] 2) [(contains? (ns-publics (quote user)) (quote pub)) (contains? (ns-publics (quote user)) (quote priv)) (contains? (ns-interns (quote user)) (quote priv))])"}
 ]