conjure-js 0.0.8 → 0.0.10

package/dist-cli/conjure-js.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // src/bin/cli.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, realpathSync } from "node:fs";
 import { dirname as dirname2, resolve as resolve3 } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
@@ -24,7 +24,8 @@ var valueKeywords = {
   atom: "atom",
   reduced: "reduced",
   volatile: "volatile",
-  regex: "regex"
+  regex: "regex",
+  var: "var"
 };
 var tokenKeywords = {
   LParen: "LParen",
@@ -45,7 +46,8 @@ var tokenKeywords = {
   Symbol: "Symbol",
   AnonFnStart: "AnonFnStart",
   Deref: "Deref",
-  Regex: "Regex"
+  Regex: "Regex",
+  VarQuote: "VarQuote"
 };
 var tokenSymbols = {
   Quote: "quote",
@@ -108,6 +110,12 @@ class EnvError extends Error {
     this.name = "EnvError";
   }
 }
+function derefValue(val) {
+  return val.kind === "var" ? val.value : val;
+}
+function makeNamespace(name) {
+  return { name, vars: new Map, aliases: new Map, readerAliases: new Map };
+}
 function makeEnv(outer) {
   return {
     bindings: new Map,
@@ -117,9 +125,12 @@ function makeEnv(outer) {
 function lookup(name, env) {
   let current = env;
   while (current) {
-    if (current.bindings.has(name)) {
-      return current.bindings.get(name);
-    }
+    const raw = current.bindings.get(name);
+    if (raw !== undefined)
+      return derefValue(raw);
+    const v = current.ns?.vars.get(name);
+    if (v !== undefined)
+      return v.value;
     current = current.outer;
   }
   throw new EvaluationError(`Symbol ${name} not found`, { name });
@@ -127,9 +138,25 @@ function lookup(name, env) {
 function tryLookup(name, env) {
   let current = env;
   while (current) {
-    if (current.bindings.has(name)) {
-      return current.bindings.get(name);
-    }
+    const raw = current.bindings.get(name);
+    if (raw !== undefined)
+      return derefValue(raw);
+    const v = current.ns?.vars.get(name);
+    if (v !== undefined)
+      return v.value;
+    current = current.outer;
+  }
+  return;
+}
+function lookupVar(name, env) {
+  let current = env;
+  while (current) {
+    const raw = current.bindings.get(name);
+    if (raw !== undefined && raw.kind === "var")
+      return raw;
+    const v = current.ns?.vars.get(name);
+    if (v !== undefined)
+      return v;
     current = current.outer;
   }
   return;
@@ -161,7 +188,7 @@ function getRootEnv(env) {
 function getNamespaceEnv(env) {
   let current = env;
   while (current) {
-    if (current.namespace)
+    if (current.ns)
       return current;
     current = current.outer;
   }
@@ -204,6 +231,7 @@ var cljRegex = (pattern, flags = "") => ({
   pattern,
   flags
 });
+var cljVar = (ns, name, value, meta) => ({ kind: "var", ns, name, value, meta });
 var cljAtom = (value) => ({ kind: "atom", value });
 var cljReduced = (value) => ({
   kind: "reduced",
@@ -651,7 +679,8 @@ var specialFormKeywords = {
   recur: "recur",
   defmulti: "defmulti",
   defmethod: "defmethod",
-  try: "try"
+  try: "try",
+  var: "var"
 };
 function keywordToDispatchFn(kw) {
   return cljNativeFunction(`kw:${kw.name}`, (...args) => {
@@ -777,7 +806,15 @@ function evaluateDef(list, env, ctx) {
   }
   if (list.value[2] === undefined)
     return cljNil();
-  define(name.name, ctx.evaluate(list.value[2], env), getNamespaceEnv(env));
+  const nsEnv = getNamespaceEnv(env);
+  const cljNs = nsEnv.ns;
+  const newValue = ctx.evaluate(list.value[2], env);
+  const existing = cljNs.vars.get(name.name);
+  if (existing) {
+    existing.value = newValue;
+  } else {
+    cljNs.vars.set(name.name, cljVar(cljNs.name, name.name, newValue));
+  }
   return cljNil();
 }
 var evaluateNs = (_list, _env, _ctx) => {
@@ -939,6 +976,38 @@ function evaluateDefmethod(list, env, ctx) {
   define(mmName.name, updated, getNamespaceEnv(env));
   return cljNil();
 }
+function evaluateVar(list, env, _ctx) {
+  const sym = list.value[1];
+  if (!isSymbol(sym)) {
+    throw new EvaluationError("var expects a symbol", { list });
+  }
+  const slashIdx = sym.name.indexOf("/");
+  if (slashIdx > 0 && slashIdx < sym.name.length - 1) {
+    const alias = sym.name.slice(0, slashIdx);
+    const localName = sym.name.slice(slashIdx + 1);
+    const nsEnv = getNamespaceEnv(env);
+    const aliasCljNs = nsEnv.ns?.aliases.get(alias);
+    if (aliasCljNs) {
+      const v3 = aliasCljNs.vars.get(localName);
+      if (!v3)
+        throw new EvaluationError(`Var ${sym.name} not found`, { sym });
+      return v3;
+    }
+    const targetEnv = getRootEnv(env).resolveNs?.(alias) ?? null;
+    if (!targetEnv) {
+      throw new EvaluationError(`No such namespace: ${alias}`, { sym });
+    }
+    const v2 = lookupVar(localName, targetEnv);
+    if (!v2)
+      throw new EvaluationError(`Var ${sym.name} not found`, { sym });
+    return v2;
+  }
+  const v = lookupVar(sym.name, env);
+  if (!v) {
+    throw new EvaluationError(`Unable to resolve var: ${sym.name} in this context`, { sym });
+  }
+  return v;
+}
 var specialFormEvaluatorEntries = {
   try: evaluateTry,
   quote: evaluateQuote,
@@ -953,7 +1022,8 @@ var specialFormEvaluatorEntries = {
   loop: evaluateLoop,
   recur: evaluateRecur,
   defmulti: evaluateDefmulti,
-  defmethod: evaluateDefmethod
+  defmethod: evaluateDefmethod,
+  var: evaluateVar
 };
 function evaluateSpecialForm(symbol, list, env, ctx) {
   const evalFn = specialFormEvaluatorEntries[symbol];
@@ -995,6 +1065,7 @@ var isAtom = (value) => value.kind === "atom";
 var isReduced = (value) => value.kind === "reduced";
 var isVolatile = (value) => value.kind === "volatile";
 var isRegex = (value) => value.kind === "regex";
+var isVar = (value) => value.kind === "var";
 var isCollection = (value) => isVector(value) || isMap(value) || isList(value);
 var isSeqable = (value) => isCollection(value) || value.kind === "string";
 var equalityHandlers = {
@@ -1036,7 +1107,8 @@ var equalityHandlers = {
   [valueKeywords.atom]: (a, b) => a === b,
   [valueKeywords.reduced]: (a, b) => isEqual(a.value, b.value),
   [valueKeywords.volatile]: (a, b) => a === b,
-  [valueKeywords.regex]: (a, b) => a === b
+  [valueKeywords.regex]: (a, b) => a === b,
+  [valueKeywords.var]: (a, b) => a === b
 };
 var isEqual = (a, b) => {
   if (a.kind !== b.kind)
@@ -1118,6 +1190,8 @@ function printString(value) {
       const prefix = value.flags ? `(?${value.flags})` : "";
       return `#"${prefix}${escaped}"`;
     }
+    case valueKeywords.var:
+      return `#'${value.ns}/${value.name}`;
     default:
       throw new EvaluationError(`unhandled value type: ${value.kind}`, {
         value
@@ -2041,6 +2115,8 @@ var metaFunctions = {
     if (val.kind === "function" || val.kind === "native-function") {
       return val.meta ?? cljNil();
     }
+    if (val.kind === "var")
+      return val.meta ?? cljNil();
     return cljNil();
   }), "Returns the metadata map of a value, or nil if the value has no metadata.", [["val"]]),
   "with-meta": withDoc(cljNativeFunction("with-meta", (val, m) => {
@@ -2257,7 +2333,18 @@ function evaluateWithContext(expr, env, ctx) {
           const alias = expr.name.slice(0, slashIdx);
           const sym = expr.name.slice(slashIdx + 1);
           const nsEnv = getNamespaceEnv(env);
-          const targetEnv = nsEnv.aliases?.get(alias) ?? getRootEnv(env).resolveNs?.(alias) ?? null;
+          const aliasCljNs = nsEnv.ns?.aliases.get(alias);
+          if (aliasCljNs) {
+            const v = aliasCljNs.vars.get(sym);
+            if (v === undefined) {
+              throw new EvaluationError(`Symbol ${expr.name} not found`, {
+                symbol: expr.name,
+                env
+              });
+            }
+            return v.value;
+          }
+          const targetEnv = getRootEnv(env).resolveNs?.(alias) ?? null;
           if (!targetEnv) {
             throw new EvaluationError(`No such namespace or alias: ${alias}`, {
               symbol: expr.name,
@@ -2819,6 +2906,7 @@ var utilFunctions = {
       map: ":map",
       function: ":function",
       regex: ":regex",
+      var: ":var",
       "native-function": ":function"
     };
     const name = kindToKeyword[x.kind];
@@ -2951,6 +3039,28 @@ var utilFunctions = {
   }), "Coerces to boolean. Everything is true except false and nil.", [["x"]])
 };
 
+// src/core/stdlib/vars.ts
+var varFunctions = {
+  "var?": withDoc(cljNativeFunction("var?", (x) => cljBoolean(isVar(x))), "Returns true if x is a Var.", [["x"]]),
+  "var-get": withDoc(cljNativeFunction("var-get", (x) => {
+    if (!isVar(x)) {
+      throw new EvaluationError(`var-get expects a Var, got ${x.kind}`, { x });
+    }
+    return x.value;
+  }), "Returns the value in the Var object.", [["x"]]),
+  "alter-var-root": withDoc(cljNativeFunctionWithContext("alter-var-root", (ctx, callEnv, varVal, f, ...args) => {
+    if (!isVar(varVal)) {
+      throw new EvaluationError(`alter-var-root expects a Var as its first argument, got ${varVal.kind}`, { varVal });
+    }
+    if (!isAFunction(f)) {
+      throw new EvaluationError(`alter-var-root expects a function as its second argument, got ${f.kind}`, { f });
+    }
+    const newVal = ctx.applyFunction(f, [varVal.value, ...args], callEnv);
+    varVal.value = newVal;
+    return newVal;
+  }), "Atomically alters the root binding of var v by applying f to its current value plus any additional args.", [["v", "f", "&", "args"]])
+};
+
 // src/core/core-env.ts
 var nativeFunctions = {
   ...arithmeticFunctions,
@@ -2963,7 +3073,8 @@ var nativeFunctions = {
   ...transducerFunctions,
   ...regexFunctions,
   ...stringFunctions,
-  ...utilFunctions
+  ...utilFunctions,
+  ...varFunctions
 };
 function loadCoreFunctions(env, output) {
   for (const [key, value] of Object.entries(nativeFunctions)) {
@@ -3287,6 +3398,10 @@ function parseDispatch(ctx) {
   if (next === '"') {
     return parseRegexLiteral(ctx, start);
   }
+  if (next === "'") {
+    scanner.advance();
+    return { kind: tokenKeywords.VarQuote, start, end: scanner.position() };
+  }
   if (next === "{") {
     throw new TokenizerError("Set literals are not yet supported", start);
   }
@@ -3497,6 +3612,16 @@ var readUnquote = (ctx) => {
   }
   return { kind: valueKeywords.list, value: [cljSymbol("unquote"), value] };
 };
+var readVarQuote = (ctx) => {
+  const scanner = ctx.scanner;
+  const token = scanner.peek();
+  if (!token) {
+    throw new ReaderError("Unexpected end of input while parsing var quote", scanner.position());
+  }
+  scanner.advance();
+  const value = readForm(ctx);
+  return cljList([cljSymbol("var"), value]);
+};
 var readDeref = (ctx) => {
   const scanner = ctx.scanner;
   const token = scanner.peek();
@@ -3818,6 +3943,8 @@ function readForm(ctx) {
       return readAnonFn(ctx);
     case tokenKeywords.Deref:
       return readDeref(ctx);
+    case tokenKeywords.VarQuote:
+      return readVarQuote(ctx);
     case tokenKeywords.Regex:
       return readRegex(ctx);
     default:
@@ -4764,10 +4891,7 @@ function processRequireSpec(spec, currentEnv, registry, resolveNamespace) {
             position: i2
           });
         }
-        if (!currentEnv.readerAliases) {
-          currentEnv.readerAliases = new Map;
-        }
-        currentEnv.readerAliases.set(alias.name, nsName);
+        currentEnv.ns.readerAliases.set(alias.name, nsName);
         i2++;
       } else {
         throw new EvaluationError(`:as-alias specs only support :as-alias, got ${kw.name}`, { spec });
@@ -4798,10 +4922,7 @@ function processRequireSpec(spec, currentEnv, registry, resolveNamespace) {
           position: i
         });
       }
-      if (!currentEnv.aliases) {
-        currentEnv.aliases = new Map;
-      }
-      currentEnv.aliases.set(alias.name, targetEnv);
+      currentEnv.ns.aliases.set(alias.name, targetEnv.ns);
       i++;
     } else if (kw.name === ":refer") {
       i++;
@@ -4819,13 +4940,18 @@ function processRequireSpec(spec, currentEnv, registry, resolveNamespace) {
             sym
           });
         }
-        let value;
-        try {
-          value = lookup(sym.name, targetEnv);
-        } catch {
-          throw new EvaluationError(`Symbol ${sym.name} not found in namespace ${nsName}`, { nsName, symbol: sym.name });
+        const v = lookupVar(sym.name, targetEnv);
+        if (v !== undefined) {
+          currentEnv.ns.vars.set(sym.name, v);
+        } else {
+          let value;
+          try {
+            value = lookup(sym.name, targetEnv);
+          } catch {
+            throw new EvaluationError(`Symbol ${sym.name} not found in namespace ${nsName}`, { nsName, symbol: sym.name });
+          }
+          define(sym.name, value, currentEnv);
         }
-        define(sym.name, value, currentEnv);
       }
       i++;
     } else {
@@ -4833,21 +4959,31 @@ function processRequireSpec(spec, currentEnv, registry, resolveNamespace) {
     }
   }
 }
+function cloneBindings(bindings) {
+  const out = new Map;
+  for (const [k, v] of bindings) {
+    out.set(k, v.kind === "var" ? { ...v } : v);
+  }
+  return out;
+}
 function cloneEnv(env, memo) {
   if (memo.has(env))
     return memo.get(env);
   const cloned = {
-    bindings: new Map(env.bindings),
-    outer: null,
-    namespace: env.namespace
+    bindings: cloneBindings(env.bindings),
+    outer: null
   };
+  if (env.ns) {
+    cloned.ns = {
+      name: env.ns.name,
+      vars: new Map([...env.ns.vars].map(([k, v]) => [k, { ...v }])),
+      aliases: new Map,
+      readerAliases: new Map(env.ns.readerAliases)
+    };
+  }
   memo.set(env, cloned);
   if (env.outer)
     cloned.outer = cloneEnv(env.outer, memo);
-  if (env.aliases)
-    cloned.aliases = new Map([...env.aliases].map(([k, v]) => [k, cloneEnv(v, memo)]));
-  if (env.readerAliases)
-    cloned.readerAliases = new Map(env.readerAliases);
   return cloned;
 }
 function cloneRegistry(registry) {
@@ -4855,6 +4991,16 @@ function cloneRegistry(registry) {
   const next = new Map;
   for (const [name, env] of registry)
     next.set(name, cloneEnv(env, memo));
+  for (const [name, env] of registry) {
+    const clonedEnv = next.get(name);
+    if (env.ns && clonedEnv.ns) {
+      for (const [alias, origNs] of env.ns.aliases) {
+        const targetCloned = next.get(origNs.name);
+        if (targetCloned?.ns)
+          clonedEnv.ns.aliases.set(alias, targetCloned.ns);
+      }
+    }
+  }
   return next;
 }
 function buildSessionApi(state, options) {
@@ -4902,7 +5048,7 @@ function buildSessionApi(state, options) {
   function ensureNs(name) {
     if (!registry.has(name)) {
       const nsEnv = makeEnv(coreEnv);
-      nsEnv.namespace = name;
+      nsEnv.ns = makeNamespace(name);
       registry.set(name, nsEnv);
     }
     return registry.get(name);
@@ -4912,6 +5058,9 @@ function buildSessionApi(state, options) {
     currentNs = name;
   }
   function getNs(name) {
+    return registry.get(name)?.ns ?? null;
+  }
+  function getNsEnv(name) {
     return registry.get(name) ?? null;
   }
   define("require", cljNativeFunction("require", (...args) => {
@@ -4969,13 +5118,17 @@ function buildSessionApi(state, options) {
     evaluate(source) {
       try {
         const tokens = tokenize(source);
-        const env = getNs(currentNs);
+        const declaredNs = extractNsNameFromTokens(tokens);
+        if (declaredNs) {
+          ensureNs(declaredNs);
+          currentNs = declaredNs;
+        }
+        const env = getNsEnv(currentNs);
         const aliasMap = extractAliasMapFromTokens(tokens);
-        env.aliases?.forEach((nsEnv, alias) => {
-          if (nsEnv.namespace)
-            aliasMap.set(alias, nsEnv.namespace);
+        env.ns?.aliases.forEach((ns, alias) => {
+          aliasMap.set(alias, ns.name);
         });
-        env.readerAliases?.forEach((nsName, alias) => {
+        env.ns?.readerAliases.forEach((nsName, alias) => {
           aliasMap.set(alias, nsName);
         });
         const forms = readForms(tokens, currentNs, aliasMap);
@@ -5003,7 +5156,7 @@ function buildSessionApi(state, options) {
     },
     evaluateForms(forms) {
       try {
-        const env = getNs(currentNs);
+        const env = getNsEnv(currentNs);
         let result = cljNil();
         for (const form of forms) {
           const expanded = ctx.expandAll(form, env);
@@ -5028,6 +5181,9 @@ function buildSessionApi(state, options) {
       while (env) {
         for (const key of env.bindings.keys())
           seen.add(key);
+        if (env.ns)
+          for (const key of env.ns.vars.keys())
+            seen.add(key);
         env = env.outer;
       }
       const candidates = [...seen];
@@ -5041,11 +5197,11 @@ function buildSessionApi(state, options) {
 function createSession(options) {
   const registry = new Map;
   const coreEnv = makeEnv();
-  coreEnv.namespace = "clojure.core";
+  coreEnv.ns = makeNamespace("clojure.core");
   loadCoreFunctions(coreEnv, options?.output);
   registry.set("clojure.core", coreEnv);
   const userEnv = makeEnv(coreEnv);
-  userEnv.namespace = "user";
+  userEnv.ns = makeNamespace("user");
   registry.set("user", userEnv);
   const session = buildSessionApi({ registry, currentNs: "user" }, options);
   const coreLoader = builtInNamespaceSources["clojure.core"];
@@ -5121,8 +5277,8 @@ function discoverSourceRoots(startDir) {
 
 // src/bin/nrepl.ts
 import * as net from "net";
-import { readFileSync as readFileSync2, writeFileSync, unlinkSync, existsSync as existsSync2 } from "node:fs";
-import { join as join2, resolve as resolve2 } from "node:path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync, existsSync as existsSync3 } from "node:fs";
+import { join as join2 } from "node:path";
 
 // src/bin/bencode.ts
 import * as stream from "stream";
@@ -5275,15 +5431,13 @@ class BDecoderStream extends stream.Transform {
 }
 
 // src/bin/version.ts
-var VERSION = "0.0.8";
+var VERSION = "0.0.10";
 
-// src/bin/nrepl.ts
-var CONJURE_VERSION = VERSION;
-function makeSessionId() {
-  return crypto.randomUUID();
-}
-function injectHostFunctions(session) {
-  const coreEnv = session.getNs("clojure.core");
+// src/host/node.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+function injectNodeHostFunctions(session) {
+  const coreEnv = session.registry.get("clojure.core");
   define("slurp", cljNativeFunction("slurp", (pathVal) => {
     const filePath = resolve2(valueToString(pathVal));
     if (!existsSync2(filePath)) {
@@ -5310,15 +5464,22 @@ function injectHostFunctions(session) {
     return cljNil();
   }), coreEnv);
 }
-function createManagedSession(id, snapshot, encoder) {
+
+// src/bin/nrepl.ts
+var CONJURE_VERSION = VERSION;
+function makeSessionId() {
+  return crypto.randomUUID();
+}
+function createManagedSession(id, snapshot, encoder, sourceRoots) {
   let currentMsgId = "";
   const session = createSessionFromSnapshot(snapshot, {
     output: (text) => {
       send(encoder, { id: currentMsgId, session: id, out: text });
     },
-    readFile: (filePath) => readFileSync2(filePath, "utf8")
+    readFile: (filePath) => readFileSync3(filePath, "utf8"),
+    sourceRoots
   });
-  injectHostFunctions(session);
+  injectNodeHostFunctions(session);
   return {
     id,
     session,
@@ -5327,7 +5488,8 @@ function createManagedSession(id, snapshot, encoder) {
     },
     set currentMsgId(v) {
       currentMsgId = v;
-    }
+    },
+    nsToFile: new Map
   };
 }
 function send(encoder, msg) {
@@ -5341,10 +5503,10 @@ function done(encoder, id, sessionId, extra = {}) {
     ...extra
   });
 }
-function handleClone(msg, sessions, snapshot, encoder) {
+function handleClone(msg, sessions, snapshot, encoder, sourceRoots) {
   const id = msg["id"] ?? "";
   const newId = makeSessionId();
-  const managed = createManagedSession(newId, snapshot, encoder);
+  const managed = createManagedSession(newId, snapshot, encoder, sourceRoots);
   sessions.set(newId, managed);
   done(encoder, id, undefined, { "new-session": newId });
 }
@@ -5358,6 +5520,9 @@ function handleDescribe(msg, encoder) {
       close: {},
       complete: {},
       describe: {},
+      eldoc: {},
+      info: {},
+      lookup: {},
       "load-file": {}
     },
     versions: {
@@ -5401,6 +5566,9 @@ function handleLoadFile(msg, managed, encoder) {
     }
     const nsHint = fileName.replace(/\.clj$/, "").replace(/\//g, ".") || undefined;
     const loadedNs = managed.session.loadFile(source, nsHint);
+    if (filePath && loadedNs) {
+      managed.nsToFile.set(loadedNs, filePath);
+    }
     managed.session.setNs(loadedNs);
     done(encoder, id, managed.id, {
       value: "nil",
@@ -5432,17 +5600,159 @@ function handleClose(msg, sessions, encoder) {
   sessions.delete(sessionId);
   send(encoder, { id, session: sessionId, status: ["done"] });
 }
+function resolveSymbol(sym, managed, contextNs) {
+  const ns = contextNs ?? managed.session.currentNs;
+  const slashIdx = sym.indexOf("/");
+  if (slashIdx > 0) {
+    const qualifier = sym.slice(0, slashIdx);
+    const localName2 = sym.slice(slashIdx + 1);
+    const nsEnvFull2 = managed.session.registry.get(qualifier);
+    if (nsEnvFull2) {
+      const value2 = tryLookup(localName2, nsEnvFull2);
+      if (value2 !== undefined)
+        return { value: value2, resolvedNs: qualifier, localName: localName2 };
+    }
+    const currentNsData = managed.session.getNs(ns);
+    const aliasedNs = currentNsData?.aliases.get(qualifier);
+    if (aliasedNs) {
+      const v = aliasedNs.vars.get(localName2);
+      if (v !== undefined)
+        return { value: v.value, resolvedNs: aliasedNs.name, localName: localName2 };
+    }
+    return null;
+  }
+  const localName = sym;
+  const nsEnvFull = managed.session.registry.get(ns);
+  if (!nsEnvFull)
+    return null;
+  const value = tryLookup(sym, nsEnvFull);
+  if (value === undefined)
+    return null;
+  const varObj = lookupVar(sym, nsEnvFull);
+  let resolvedNs;
+  if (varObj) {
+    resolvedNs = varObj.ns;
+  } else if (value.kind === "function" || value.kind === "macro") {
+    resolvedNs = getNamespaceEnv(value.env).ns?.name ?? ns;
+  } else if (value.kind === "native-function") {
+    const i = value.name.indexOf("/");
+    resolvedNs = i > 0 ? value.name.slice(0, i) : ns;
+  } else {
+    resolvedNs = ns;
+  }
+  return { value, resolvedNs, localName };
+}
+function extractMeta(value) {
+  const type = value.kind === "macro" ? "macro" : value.kind === "function" || value.kind === "native-function" ? "function" : "var";
+  const meta = value.kind === "function" ? value.meta : value.kind === "native-function" ? value.meta : undefined;
+  let doc = "";
+  let arglistsStr = "";
+  let eldocArgs = null;
+  if (meta) {
+    const docEntry = meta.entries.find(([k]) => k.kind === "keyword" && k.name === ":doc");
+    if (docEntry && docEntry[1].kind === "string")
+      doc = docEntry[1].value;
+    const argsEntry = meta.entries.find(([k]) => k.kind === "keyword" && k.name === ":arglists");
+    if (argsEntry && argsEntry[1].kind === "vector") {
+      const arglists = argsEntry[1];
+      arglistsStr = "(" + arglists.value.map((al) => printString(al)).join(" ") + ")";
+      eldocArgs = arglists.value.map((al) => {
+        if (al.kind !== "vector")
+          return [printString(al)];
+        return al.value.map((p) => p.kind === "symbol" ? p.name : printString(p));
+      });
+    }
+  }
+  if (arglistsStr === "" && (value.kind === "function" || value.kind === "macro")) {
+    const arityStrs = value.arities.map((arity) => {
+      const params = arity.params.map((p) => printString(p));
+      if (arity.restParam)
+        params.push("&", printString(arity.restParam));
+      return "[" + params.join(" ") + "]";
+    });
+    arglistsStr = "(" + arityStrs.join(" ") + ")";
+    eldocArgs = value.arities.map((arity) => {
+      const params = arity.params.map((p) => printString(p));
+      if (arity.restParam)
+        params.push("&", printString(arity.restParam));
+      return params;
+    });
+  }
+  return { doc, arglistsStr, eldocArgs, type };
+}
+function handleInfo(msg, managed, encoder) {
+  const id = msg["id"] ?? "";
+  const sym = msg["sym"];
+  const nsOverride = msg["ns"];
+  if (!sym) {
+    done(encoder, id, managed.id, { status: ["no-info", "done"] });
+    return;
+  }
+  const resolved = resolveSymbol(sym, managed, nsOverride);
+  if (!resolved) {
+    const nsFile = managed.nsToFile.get(sym);
+    if (nsFile) {
+      done(encoder, id, managed.id, {
+        ns: sym,
+        name: sym,
+        type: "namespace",
+        file: nsFile
+      });
+      return;
+    }
+    done(encoder, id, managed.id, { status: ["no-info", "done"] });
+    return;
+  }
+  const meta = extractMeta(resolved.value);
+  const file = managed.nsToFile.get(resolved.resolvedNs);
+  done(encoder, id, managed.id, {
+    ns: resolved.resolvedNs,
+    name: resolved.localName,
+    doc: meta.doc,
+    "arglists-str": meta.arglistsStr,
+    type: meta.type,
+    ...file ? { file } : {}
+  });
+}
+function handleLookup(msg, managed, encoder) {
+  handleInfo(msg, managed, encoder);
+}
+function handleEldoc(msg, managed, encoder) {
+  const id = msg["id"] ?? "";
+  const sym = msg["sym"];
+  const nsOverride = msg["ns"];
+  if (!sym) {
+    done(encoder, id, managed.id, { status: ["no-eldoc", "done"] });
+    return;
+  }
+  const resolved = resolveSymbol(sym, managed, nsOverride);
+  if (!resolved) {
+    done(encoder, id, managed.id, { status: ["no-eldoc", "done"] });
+    return;
+  }
+  const meta = extractMeta(resolved.value);
+  if (!meta.eldocArgs) {
+    done(encoder, id, managed.id, { status: ["no-eldoc", "done"] });
+    return;
+  }
+  done(encoder, id, managed.id, {
+    name: resolved.localName,
+    ns: resolved.resolvedNs,
+    type: meta.type,
+    eldoc: meta.eldocArgs
+  });
+}
 function handleUnknown(msg, encoder) {
   const id = msg["id"] ?? "";
   send(encoder, { id, status: ["unknown-op", "done"] });
 }
-function handleMessage(msg, sessions, snapshot, encoder, defaultSession) {
+function handleMessage(msg, sessions, snapshot, encoder, defaultSession, sourceRoots) {
   const op = msg["op"];
   const sessionId = msg["session"];
   const managed = sessionId ? sessions.get(sessionId) ?? defaultSession : defaultSession;
   switch (op) {
     case "clone":
-      handleClone(msg, sessions, snapshot, encoder);
+      handleClone(msg, sessions, snapshot, encoder, sourceRoots);
       break;
     case "describe":
       handleDescribe(msg, encoder);
@@ -5459,6 +5769,15 @@ function handleMessage(msg, sessions, snapshot, encoder, defaultSession) {
     case "close":
       handleClose(msg, sessions, encoder);
       break;
+    case "info":
+      handleInfo(msg, managed, encoder);
+      break;
+    case "lookup":
+      handleLookup(msg, managed, encoder);
+      break;
+    case "eldoc":
+      handleEldoc(msg, managed, encoder);
+      break;
     default:
       handleUnknown(msg, encoder);
   }
@@ -5468,7 +5787,7 @@ function startNreplServer(options = {}) {
   const host = options.host ?? "127.0.0.1";
   const warmSession = createSession({
     sourceRoots: options.sourceRoots,
-    readFile: (filePath) => readFileSync2(filePath, "utf8")
+    readFile: (filePath) => readFileSync3(filePath, "utf8")
   });
   const snapshot = snapshotSession(warmSession);
   const server = net.createServer((socket) => {
@@ -5478,10 +5797,10 @@ function startNreplServer(options = {}) {
     socket.pipe(decoder);
     const sessions = new Map;
     const defaultId = makeSessionId();
-    const defaultSession = createManagedSession(defaultId, snapshot, encoder);
+    const defaultSession = createManagedSession(defaultId, snapshot, encoder, options.sourceRoots);
     sessions.set(defaultId, defaultSession);
     decoder.on("data", (msg) => {
-      handleMessage(msg, sessions, snapshot, encoder, defaultSession);
+      handleMessage(msg, sessions, snapshot, encoder, defaultSession, options.sourceRoots);
     });
     socket.on("error", () => {});
     socket.on("close", () => {
@@ -5490,14 +5809,15 @@ function startNreplServer(options = {}) {
   });
   const portFile = join2(process.cwd(), ".nrepl-port");
   server.listen(port, host, () => {
-    writeFileSync(portFile, String(port), "utf8");
+    writeFileSync2(portFile, String(port), "utf8");
     process.stdout.write(`Conjure nREPL server v${VERSION} started on port ${port}
 `);
   });
   const cleanup = () => {
-    if (existsSync2(portFile))
+    if (existsSync3(portFile))
       unlinkSync(portFile);
   };
+  server.on("close", cleanup);
   process.on("exit", cleanup);
   process.on("SIGINT", () => {
     cleanup();
@@ -5519,41 +5839,13 @@ function makeCliIo() {
 `)
   };
 }
-function injectHostFunctions2(session) {
-  const coreEnv = session.getNs("clojure.core");
-  define("slurp", cljNativeFunction("slurp", (pathVal) => {
-    const filePath = resolve3(valueToString(pathVal));
-    if (!existsSync3(filePath)) {
-      throw new Error(`slurp: file not found: ${filePath}`);
-    }
-    return cljString(readFileSync3(filePath, "utf8"));
-  }), coreEnv);
-  define("spit", cljNativeFunction("spit", (pathVal, content) => {
-    const filePath = resolve3(valueToString(pathVal));
-    writeFileSync2(filePath, valueToString(content), "utf8");
-    return cljNil();
-  }), coreEnv);
-  define("load", cljNativeFunction("load", (pathVal) => {
-    const filePath = resolve3(valueToString(pathVal));
-    if (!existsSync3(filePath)) {
-      throw new Error(`load: file not found: ${filePath}`);
-    }
-    const source = readFileSync3(filePath, "utf8");
-    const inferred = inferSourceRoot(filePath, source);
-    if (inferred)
-      session.addSourceRoot(inferred);
-    const loadedNs = session.loadFile(source);
-    session.setNs(loadedNs);
-    return cljNil();
-  }), coreEnv);
-}
 function createCliSession(sourceRoots, io) {
   const session = createSession({
     output: (text) => io.writeLine(text),
     sourceRoots,
-    readFile: (filePath) => readFileSync3(filePath, "utf8")
+    readFile: (filePath) => readFileSync4(filePath, "utf8")
   });
-  injectHostFunctions2(session);
+  injectNodeHostFunctions(session);
   return session;
 }
 function getSourceRoots(filePath) {
@@ -5572,12 +5864,12 @@ function printUsage(io) {
 }
 function runFile(fileArg, io = makeCliIo()) {
   const filePath = resolve3(fileArg);
-  if (!existsSync3(filePath)) {
+  if (!existsSync4(filePath)) {
     io.writeError(`File not found: ${fileArg}`);
     return 1;
   }
   try {
-    const source = readFileSync3(filePath, "utf8");
+    const source = readFileSync4(filePath, "utf8");
     const inferredRoot = inferSourceRoot(filePath, source);
     const sourceRoots = inferredRoot ? [...new Set([inferredRoot, ...getSourceRoots(filePath)])] : getSourceRoots(filePath);
     const session = createCliSession(sourceRoots, io);