Logos.Runtime -- the per-embedding-instance, :public ETS-backed namespace registry. Never a global singleton: every embedder of Logos calls Logos.Runtime.new/1 (or the Logos.new_runtime/0 convenience) to get its own isolated table, so multiple independent Logos instances can coexist in the same VM without seeing each other's namespaces or vars. An earlier version of this codebase instead kept a single bare, module-level, :named_table ETS table shared by the whole VM; this module replaced that global-singleton design.

Storage shape

One ETS table (:set, :public, not :named_table -- named tables would be exactly the kind of accidental global-singleton trap this module exists to avoid) holds every piece of registry state, keyed by tagged tuples so unrelated concerns never collide:

• {:ns, name} -> %{meta:, aliases:, refers:, auto_refer_core?:, var_names:} -- one row per namespace. var_names is a MapSet of the bare names interned directly in this namespace (not refers/aliases), kept alongside the namespace row so require :refer/use can enumerate "every public var this namespace defines" without a table scan.
• {:var, ns, name} -> %{value:, meta:} -- one row per Logos.Var. Logos.Var itself (lib/logos/var.ex) is just the %{ns, name} identity pair; its value/meta genuinely live here, in the :public table, so a process spawned via spawn/spawn-link/ spawn-monitor can read/write a Var directly without round-tripping through an owning process -- this is the concrete mechanism :public was chosen for.
• :current_ns -> the default current-namespace name (String.t(), always "user" from new/1), consulted only as the fallback for a BEAM process that has never called set_current_ns!/2 itself. {:current_ns, pid} -> a per-process override: real Clojure's *ns* is thread-local, so the BEAM-native equivalent is process-local. current_ns/1 checks {:current_ns, self()} first and only falls back to the shared :current_ns default row if this process has never set its own -- so two processes (in-ns ...)-ing concurrently against the same Runtime (e.g. after one spawns the other) no longer stomp on each other. A freshly spawned process simply inherits the shared default ("user", or whatever the last unscoped set_current_ns!/2 caller -- realistically only ever the one process that ran before any spawn happened -- last wrote) until it calls in-ns itself, matching a fresh Clojure thread's *ns* starting from a sane default rather than literally inheriting its parent's dynamic binding (real Clojure threads don't inherit *ns* bindings either without explicit bound-fn/binding plumbing). Known accepted tradeoff: {:current_ns, pid} rows are never cleaned up when a process exits -- a long-running embedder that spawns enormous numbers of short-lived processes which each call in-ns will accumulate ETS rows forever. Not fixed here (would need a monitor-and-delete per spawned process, adding real overhead to every spawn for a leak that's bounded by "total processes ever spawned across the Runtime's lifetime", not unbounded within a single process) -- flagged here as a potential future fix if it ever matters in practice.
• :loading -> a MapSet.t(String.t()) of namespace names currently mid-require, for circular-require detection. See start_loading!/2/finish_loading!/2.
• :gensym_counter -> an integer counter for gensym.
• :load_paths -> a fixed (set once at new/1, never mutated) list of directory strings require/use search on disk for a namespace not already in-memory. See load_paths/1 and Logos.Primitives' load_ns!/2.
• :data_readers -> a %{tag_text => {module, function}} map backing #tag value tagged literals (priv/grammar/logos.aether's tagged_literal rule, resolved at read time by Logos.Reader.Actions's handle_rule(:tagged_literal, ...)). Seeded at new/1 with "inst"/"uuid" (Logos.DataReaders); register_data_reader!/3 (the register-data-reader! primitive's backing call) adds more, always resolved through Logos.Interop.Allowlist first -- never an arbitrary Logos closure, the same sandboxing chokepoint import uses.

Granular per-var/per-ns rows (rather than one giant nested map for the whole registry) are deliberate: two concurrent defs into two different Vars never contend on the same ETS row. Two concurrent writes to the same Var (or the same namespace's aliases/refers/ var_names) are still a read-modify-write race in this implementation (ordinary :ets.lookup + :ets.insert, not :ets.update_element with a match spec). This is a known, currently-unaddressed race now that spawn/spawn-link/spawn-monitor make concurrent writers real: two processes racing to def the same Var, or to alias!/refer! into the same namespace, can lose one write. In practice the stdlib's atom (see concurrency.logos) sidesteps this entirely by funneling all mutation of a given piece of state through one owning process rather than relying on this table's own atomicity.