co.multiply.remontoire.api — co.multiply/remontoire 0.1.1

Your toolkit in this running system — the namespace evaluated code reaches for. It is aliased as __r in every namespace your evals touch, so __r/… resolves wherever you navigate. The alias is for eval code only; never write it into committed source.

doc clj macro

(doc name)

Prints documentation for a var or special form given its name, or for a spec if given a keyword. Printed, not returned — the eval response carries it as output. The name resolves in the current namespace, and an unresolvable one prints nothing rather than throwing — qualify (__r/failure, __q/catch) when in doubt.

evals clj

(evals)

One map per live registry entry, oldest first — id, status, peer, time. The registry is shared across every session on this JVM, so entries another session minted appear too, tagged :by with their owner's id prefix — attribution, not isolation: what you didn't make is labeled, never hidden, and (res id) reaches it all the same.

failure clj

(failure id)

The rendered failure of eval id: the exception chain and the interesting frames, the eval machinery's own frames subtracted — the same rendering a failed eval response carries. A rendering, not the throwable — for programmatic access, (__q/get-ex (res id)) is the exception itself as a value, cancellation included, and ex-data works from there. Reading a failure is delivery, like any res. When id did not fail, says how it stands instead — safe for any state.

file clj

(file ns)

The source file of a namespace, verbatim, as a string — comments and (comment …) blocks included: the whole of what is written, where outline shows what is live. Takes the designators outline takes. Returned rather than printed, for composing — str/split-lines, a drop-while down to a section — and (println (file 'some.ns)) is the reading form: printed output arrives verbatim where a returned string renders with its newlines escaped. Mind the size on unfamiliar namespaces — (count (file 'x)) is cheap, and slicing before returning beats returning the whole of a large file. Throws, plainly, for a namespace with no file on the classpath.

introduce! clj

(introduce! s)

Describe this session on the roster — what it is for, in its own words: (__r/introduce! "debugging the payment retry storm"). A commit message for a session: other tenants reading (sessions) see who is here and why, instead of an anonymous id owning entries.

manual clj

(manual)

The manual, in one call — read it before your first real eval. Prints the prose half: the conceptual model of this environment — what an id is, what retention can be relied on, how sessions share the one JVM, and the async semantics that otherwise surprise silently. Returns the API reference as data: this namespace's outline, public vars with their full docstrings — live, so it is the running build's truth where anything delivered at connection time may since have gone stale (§4). Publics only; privates stay readable through a real outline. Reading it also marks this session as informed, which retires the unread note from its responses. Once per conversation is enough — servers sharing a build share a manual.

nses clj

(nses)

(nses match)

Every loaded namespace, as a sorted vector of symbols — the system at a glance, and the top of the drilldown: nses to find the namespace, outline to read it, doc and source for its vars. An optional match keeps only matching names: a string (case-insensitive substring), a regex, or a symbol matched as its name — so (nses "session") searches, and (nses 'co.multiply.quiescent) answers whether a namespace is really loaded. Plain data, made for composing — filter it, count it, map outline over it. The view is the running system's: what has actually been loaded, not everything on the classpath.

out clj

(out id)

What eval id has printed so far — usable mid-run, since the capture fills as the work speaks. Both streams, *out* and *err*, interleaved in arrival order — warnings and stack traces land here beside the data. A read about the entry, not of its result: it neither refreshes nor delivers.

outline clj

(outline ns)

(outline ns opts)

A namespace at a glance: {:ns … :doc … :vars […]}, one entry per var — name, arglists, :line, :macro/:private/:dynamic flags, a multimethod's dispatch values — in source order, privates included and marked, because the point is the gist of the namespace, not just its API. Designate the namespace by symbol, by an alias visible from the calling namespace, or with the namespace itself: (outline '__r). Bare output is small enough for any namespace, with the ns docstring's first sentence for orientation; {:include-docstrings true} carries every docstring whole — one roundtrip for a full overview when the namespace is small or important. {:match "evict"} (string, case-insensitive, or regex) keeps only vars whose name or docstring matches; docstring hits quote their matching lines as :matched, so the answer shows its evidence. :line says where to start reading when the signature isn't enough. The view is the running system's own — after a hot reload it shows what is live, not what is on disk.

release! clj

(release!)

(release! period?)

Punctuation: mark the leg of work behind this session absorbed and evictable, instead of sifting the conversation for what has been read and what might still be running. (release!) is a comma — every settled, unread entry this session owns is released; running entries are left alone and stay live concerns, settled news included. (release! true) is a period — running entries are cancelled too. Returns {:released [ids] :cancelled [ids]}: what was absorbed versus what was stopped — the report is the audit. Also the polite goodbye, in a system whose clients rarely send one: punctuate when a leg of work ends, and the claims lapse now rather than at the 24 h silence expiry. The eval performing the release is exempt from its own period — punctuation ends the leg behind you, not the sentence being spoken.

res clj

(res id)

The task for eval id. Deref for the value — safe to repeat — or compose: (__q/cancel (res 12)) cancels, handlers chain onto it. To read an exception, (__q/get-ex (res 12)) is it as a value — failure or cancellation alike, nil otherwise; catch also reads a failure, but a cancelled entry passes cancellation through catch to whatever eval composes on it. Reading is delivery: it refreshes the entry and admits it to the evictable pool once settled.

scoped-fn clj

(scoped-fn f)

bound-fn* for scope: capture the current scope — output attribution included — and return a fn of the same arguments that re-establishes it wherever it runs. For work that escapes the task tree: raw threads, executor callbacks, futures launched from inside a nested task. Not needed for Quiescent tasks, which carry scope themselves, nor for a future launched from top-level eval code, which Clojure conveyance covers.

See co.multiply.scoped for lower level scope propagation utilities if this function proves insufficient.

sessions clj

(sessions)

Who is connected to this JVM: one map per live session — :sid, :idle-s since it last spoke, :client name and version, its :note when it introduced itself, how many :entries it owns — with :you marking the caller's own row. The roster answers what would otherwise take guesswork: whose entries are these, when was that session last alive, which id am I now.

source clj macro

(source name)

Prints the source of a var, given its name: what is written, where outline and doc show what is live — after a hot reload the two can differ. Printed, not returned — the eval response carries it as output. The name resolves in the current namespace — qualify (__r/failure, __q/catch) when in doubt — and the defining file must be on the classpath, which holds for anything shipped as source; otherwise, and for an unresolvable name, it prints Source not found.