conjure-js 0.0.11 → 0.0.12

package/dist-cli/conjure-js.mjs

@@ -47,7 +47,8 @@ var tokenKeywords = {
   AnonFnStart: "AnonFnStart",
   Deref: "Deref",
   Regex: "Regex",
-  VarQuote: "VarQuote"
+  VarQuote: "VarQuote",
+  Meta: "Meta"
 };
 var tokenSymbols = {
   Quote: "quote",
@@ -86,12 +87,18 @@ class ReaderError extends Error {
 class EvaluationError extends Error {
   context;
   pos;
+  data;
   constructor(message, context, pos) {
     super(message);
     this.name = "EvaluationError";
     this.context = context;
     this.pos = pos;
   }
+  static atArg(message, context, argIndex) {
+    const err = new EvaluationError(message, context);
+    err.data = { argIndex };
+    return err;
+  }
 }
 
 class CljThrownSignal {
@@ -101,6 +108,72 @@ class CljThrownSignal {
   }
 }
 
+// src/core/factories.ts
+var cljNumber = (value) => ({ kind: "number", value });
+var cljString = (value) => ({ kind: "string", value });
+var cljBoolean = (value) => ({ kind: "boolean", value });
+var cljKeyword = (name) => ({ kind: "keyword", name });
+var cljNil = () => ({ kind: "nil", value: null });
+var cljSymbol = (name) => ({ kind: "symbol", name });
+var cljList = (value) => ({ kind: "list", value });
+var cljVector = (value) => ({ kind: "vector", value });
+var cljMap = (entries) => ({ kind: "map", entries });
+var cljMultiArityFunction = (arities, env) => ({
+  kind: "function",
+  arities,
+  env
+});
+var cljNativeFunction = (name, fn) => ({ kind: "native-function", name, fn });
+var cljNativeFunctionWithContext = (name, fn) => ({
+  kind: "native-function",
+  name,
+  fn: () => {
+    throw new EvaluationError("Native function called without context", {
+      name
+    });
+  },
+  fnWithContext: fn
+});
+var cljMultiArityMacro = (arities, env) => ({
+  kind: "macro",
+  arities,
+  env
+});
+var cljRegex = (pattern, flags = "") => ({
+  kind: "regex",
+  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",
+  value
+});
+var cljVolatile = (value) => ({
+  kind: "volatile",
+  value
+});
+var withDoc = (fn, doc, arglists) => ({
+  ...fn,
+  meta: cljMap([
+    [cljKeyword(":doc"), cljString(doc)],
+    ...arglists ? [
+      [
+        cljKeyword(":arglists"),
+        cljVector(arglists.map((args) => cljVector(args.map(cljSymbol))))
+      ]
+    ] : []
+  ])
+});
+var cljMultiMethod = (name, dispatchFn, methods, defaultMethod) => ({
+  kind: "multi-method",
+  name,
+  dispatchFn,
+  methods,
+  defaultMethod
+});
+
 // src/core/env.ts
 class EnvError extends Error {
   context;
@@ -111,7 +184,12 @@ class EnvError extends Error {
   }
 }
 function derefValue(val) {
-  return val.kind === "var" ? val.value : val;
+  if (val.kind !== "var")
+    return val;
+  if (val.dynamic && val.bindingStack && val.bindingStack.length > 0) {
+    return val.bindingStack[val.bindingStack.length - 1];
+  }
+  return val.value;
 }
 function makeNamespace(name) {
   return { name, vars: new Map, aliases: new Map, readerAliases: new Map };
@@ -130,7 +208,7 @@ function lookup(name, env) {
       return derefValue(raw);
     const v = current.ns?.vars.get(name);
     if (v !== undefined)
-      return v.value;
+      return derefValue(v);
     current = current.outer;
   }
   throw new EvaluationError(`Symbol ${name} not found`, { name });
@@ -143,11 +221,22 @@ function tryLookup(name, env) {
       return derefValue(raw);
     const v = current.ns?.vars.get(name);
     if (v !== undefined)
-      return v.value;
+      return derefValue(v);
     current = current.outer;
   }
   return;
 }
+function internVar(name, value, nsEnv, meta) {
+  const ns = nsEnv.ns;
+  const existing = ns.vars.get(name);
+  if (existing) {
+    existing.value = value;
+    if (meta)
+      existing.meta = meta;
+  } else {
+    ns.vars.set(name, cljVar(ns.name, name, value, meta));
+  }
+}
 function lookupVar(name, env) {
   let current = env;
   while (current) {
@@ -195,71 +284,43 @@ function getNamespaceEnv(env) {
   return getRootEnv(env);
 }
 
-// src/core/factories.ts
-var cljNumber = (value) => ({ kind: "number", value });
-var cljString = (value) => ({ kind: "string", value });
-var cljBoolean = (value) => ({ kind: "boolean", value });
-var cljKeyword = (name) => ({ kind: "keyword", name });
-var cljNil = () => ({ kind: "nil", value: null });
-var cljSymbol = (name) => ({ kind: "symbol", name });
-var cljList = (value) => ({ kind: "list", value });
-var cljVector = (value) => ({ kind: "vector", value });
-var cljMap = (entries) => ({ kind: "map", entries });
-var cljMultiArityFunction = (arities, env) => ({
-  kind: "function",
-  arities,
-  env
-});
-var cljNativeFunction = (name, fn) => ({ kind: "native-function", name, fn });
-var cljNativeFunctionWithContext = (name, fn) => ({
-  kind: "native-function",
-  name,
-  fn: () => {
-    throw new EvaluationError("Native function called without context", {
-      name
-    });
-  },
-  fnWithContext: fn
-});
-var cljMultiArityMacro = (arities, env) => ({
-  kind: "macro",
-  arities,
-  env
-});
-var cljRegex = (pattern, flags = "") => ({
-  kind: "regex",
-  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",
-  value
-});
-var cljVolatile = (value) => ({
-  kind: "volatile",
-  value
-});
-var withDoc = (fn, doc, arglists) => ({
-  ...fn,
-  meta: cljMap([
-    [cljKeyword(":doc"), cljString(doc)],
-    ...arglists ? [
-      [
-        cljKeyword(":arglists"),
-        cljVector(arglists.map((args) => cljVector(args.map(cljSymbol))))
-      ]
-    ] : []
-  ])
-});
-var cljMultiMethod = (name, dispatchFn, methods, defaultMethod) => ({
-  kind: "multi-method",
-  name,
-  dispatchFn,
-  methods,
-  defaultMethod
-});
+// src/core/positions.ts
+function setPos(val, pos) {
+  Object.defineProperty(val, "_pos", {
+    value: pos,
+    enumerable: false,
+    writable: true,
+    configurable: true
+  });
+}
+function getPos(val) {
+  return val._pos;
+}
+function getLineCol(source, offset) {
+  const lines = source.split(`
+`);
+  let pos = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const lineEnd = pos + lines[i].length;
+    if (offset <= lineEnd) {
+      return { line: i + 1, col: offset - pos, lineText: lines[i] };
+    }
+    pos = lineEnd + 1;
+  }
+  const last = lines[lines.length - 1];
+  return { line: lines.length, col: last.length, lineText: last };
+}
+function formatErrorContext(source, pos, opts) {
+  const { line, col, lineText } = getLineCol(source, pos.start);
+  const absLine = line + (opts?.lineOffset ?? 0);
+  const absCol = line === 1 ? col + (opts?.colOffset ?? 0) : col;
+  const span = Math.max(1, pos.end - pos.start);
+  const caret = " ".repeat(col) + "^".repeat(span);
+  return `
+  at line ${absLine}, col ${absCol + 1}:
+  ${lineText}
+  ${caret}`;
+}
 
 // src/core/evaluator/destructure.ts
 function toSeqSafe(value) {
@@ -665,6 +726,16 @@ function validateForm(form, inTail) {
 }
 
 // src/core/evaluator/special-forms.ts
+function hasDynamicMeta(meta) {
+  if (!meta)
+    return false;
+  for (const [k, v] of meta.entries) {
+    if (k.kind === "keyword" && k.name === ":dynamic" && v.kind === "boolean" && v.value === true) {
+      return true;
+    }
+  }
+  return false;
+}
 var specialFormKeywords = {
   quote: "quote",
   def: "def",
@@ -680,7 +751,9 @@ var specialFormKeywords = {
   defmulti: "defmulti",
   defmethod: "defmethod",
   try: "try",
-  var: "var"
+  var: "var",
+  binding: "binding",
+  "set!": "set!"
 };
 function keywordToDispatchFn(kw) {
   return cljNativeFunction(`kw:${kw.name}`, (...args) => {
@@ -795,6 +868,27 @@ function evaluateQuote(list, _env, _ctx) {
 function evalQuasiquote(list, env, ctx) {
   return evaluateQuasiquote(list.value[1], env, new Map, ctx);
 }
+function buildVarMeta(symMeta, ctx, nameVal) {
+  const pos = nameVal ? getPos(nameVal) : undefined;
+  const hasPosInfo = pos && ctx.currentSource;
+  if (!symMeta && !hasPosInfo)
+    return;
+  const posEntries = [];
+  if (hasPosInfo) {
+    const { line, col } = getLineCol(ctx.currentSource, pos.start);
+    const lineOffset = ctx.currentLineOffset ?? 0;
+    const colOffset = ctx.currentColOffset ?? 0;
+    posEntries.push([cljKeyword(":line"), cljNumber(line + lineOffset)]);
+    posEntries.push([cljKeyword(":column"), cljNumber(line === 1 ? col + colOffset : col)]);
+    if (ctx.currentFile) {
+      posEntries.push([cljKeyword(":file"), cljString(ctx.currentFile)]);
+    }
+  }
+  const POS_KEYS = new Set([":line", ":column", ":file"]);
+  const baseEntries = (symMeta?.entries ?? []).filter(([k]) => !(k.kind === "keyword" && POS_KEYS.has(k.name)));
+  const allEntries = [...baseEntries, ...posEntries];
+  return allEntries.length > 0 ? cljMap(allEntries) : undefined;
+}
 function evaluateDef(list, env, ctx) {
   const name = list.value[1];
   if (name.kind !== "symbol") {
@@ -809,11 +903,20 @@ function evaluateDef(list, env, ctx) {
   const nsEnv = getNamespaceEnv(env);
   const cljNs = nsEnv.ns;
   const newValue = ctx.evaluate(list.value[2], env);
+  const varMeta = buildVarMeta(name.meta, ctx, name);
   const existing = cljNs.vars.get(name.name);
   if (existing) {
     existing.value = newValue;
+    if (varMeta) {
+      existing.meta = varMeta;
+      if (hasDynamicMeta(varMeta))
+        existing.dynamic = true;
+    }
   } else {
-    cljNs.vars.set(name.name, cljVar(cljNs.name, name.name, newValue));
+    const v = cljVar(cljNs.name, name.name, newValue, varMeta);
+    if (hasDynamicMeta(varMeta))
+      v.dynamic = true;
+    cljNs.vars.set(name.name, v);
   }
   return cljNil();
 }
@@ -872,7 +975,7 @@ function evaluateDefmacro(list, env, _ctx) {
   }
   const arities = parseArities(list.value.slice(2), env);
   const macro = cljMultiArityMacro(arities, env);
-  define(name.name, macro, getRootEnv(env));
+  internVar(name.name, macro, getNamespaceEnv(env));
   return cljNil();
 }
 function evaluateLoop(list, env, ctx) {
@@ -944,7 +1047,7 @@ function evaluateDefmulti(list, env, ctx) {
     dispatchFn = evaluated;
   }
   const mm = cljMultiMethod(mmName.name, dispatchFn, []);
-  define(mmName.name, mm, getNamespaceEnv(env));
+  internVar(mmName.name, mm, getNamespaceEnv(env));
   return cljNil();
 }
 function evaluateDefmethod(list, env, ctx) {
@@ -973,7 +1076,12 @@ function evaluateDefmethod(list, env, ctx) {
       { dispatchVal, fn: methodFn }
     ]);
   }
-  define(mmName.name, updated, getNamespaceEnv(env));
+  const v = lookupVar(mmName.name, env);
+  if (v) {
+    v.value = updated;
+  } else {
+    define(mmName.name, updated, getNamespaceEnv(env));
+  }
   return cljNil();
 }
 function evaluateVar(list, env, _ctx) {
@@ -1008,6 +1116,66 @@ function evaluateVar(list, env, _ctx) {
   }
   return v;
 }
+function evaluateBinding(list, env, ctx) {
+  const bindings = list.value[1];
+  if (!isVector(bindings)) {
+    throw new EvaluationError("binding requires a vector of bindings", {
+      list,
+      env
+    });
+  }
+  if (bindings.value.length % 2 !== 0) {
+    throw new EvaluationError("binding vector must have an even number of forms", { list, env });
+  }
+  const body = list.value.slice(2);
+  const boundVars = [];
+  for (let i = 0;i < bindings.value.length; i += 2) {
+    const sym = bindings.value[i];
+    if (!isSymbol(sym)) {
+      throw new EvaluationError("binding left-hand side must be a symbol", { sym });
+    }
+    const newVal = ctx.evaluate(bindings.value[i + 1], env);
+    const v = lookupVar(sym.name, env);
+    if (!v) {
+      throw new EvaluationError(`No var found for symbol '${sym.name}' in binding form`, { sym });
+    }
+    if (!v.dynamic) {
+      throw new EvaluationError(`Cannot use binding with non-dynamic var ${v.ns}/${v.name}. Mark it dynamic with (def ^:dynamic ${sym.name} ...)`, { sym });
+    }
+    v.bindingStack ??= [];
+    v.bindingStack.push(newVal);
+    boundVars.push(v);
+  }
+  try {
+    return ctx.evaluateForms(body, env);
+  } finally {
+    for (const v of boundVars) {
+      v.bindingStack.pop();
+    }
+  }
+}
+function evaluateSet(list, env, ctx) {
+  if (list.value.length !== 3) {
+    throw new EvaluationError(`set! requires exactly 2 arguments, got ${list.value.length - 1}`, { list, env });
+  }
+  const symForm = list.value[1];
+  if (!isSymbol(symForm)) {
+    throw new EvaluationError(`set! first argument must be a symbol, got ${symForm.kind}`, { symForm, env });
+  }
+  const v = lookupVar(symForm.name, env);
+  if (!v) {
+    throw new EvaluationError(`Unable to resolve var: ${symForm.name} in this context`, { symForm, env });
+  }
+  if (!v.dynamic) {
+    throw new EvaluationError(`Cannot set! non-dynamic var ${v.ns}/${v.name}. Mark it with ^:dynamic.`, { symForm, env });
+  }
+  if (!v.bindingStack || v.bindingStack.length === 0) {
+    throw new EvaluationError(`Cannot set! ${v.ns}/${v.name} — no active binding. Use set! only inside a (binding [...] ...) form.`, { symForm, env });
+  }
+  const newVal = ctx.evaluate(list.value[2], env);
+  v.bindingStack[v.bindingStack.length - 1] = newVal;
+  return newVal;
+}
 var specialFormEvaluatorEntries = {
   try: evaluateTry,
   quote: evaluateQuote,
@@ -1023,7 +1191,9 @@ var specialFormEvaluatorEntries = {
   recur: evaluateRecur,
   defmulti: evaluateDefmulti,
   defmethod: evaluateDefmethod,
-  var: evaluateVar
+  var: evaluateVar,
+  binding: evaluateBinding,
+  "set!": evaluateSet
 };
 function evaluateSpecialForm(symbol, list, env, ctx) {
   const evalFn = specialFormEvaluatorEntries[symbol];
@@ -1209,10 +1379,9 @@ var arithmeticFunctions = {
     if (nums.length === 0) {
       return cljNumber(0);
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("+ expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("+ expects all arguments to be numbers", { args: nums }, badIdx);
     }
     return nums.reduce((acc, arg) => {
       return cljNumber(acc.value + arg.value);
@@ -1224,10 +1393,9 @@ var arithmeticFunctions = {
         args: nums
       });
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("- expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("- expects all arguments to be numbers", { args: nums }, badIdx);
     }
     return nums.slice(1).reduce((acc, arg) => {
       return cljNumber(acc.value - arg.value);
@@ -1237,10 +1405,9 @@ var arithmeticFunctions = {
     if (nums.length === 0) {
       return cljNumber(1);
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("* expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("* expects all arguments to be numbers", { args: nums }, badIdx);
     }
     return nums.slice(1).reduce((acc, arg) => {
       return cljNumber(acc.value * arg.value);
@@ -1252,14 +1419,15 @@ var arithmeticFunctions = {
         args: nums
       });
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("/ expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("/ expects all arguments to be numbers", { args: nums }, badIdx);
     }
-    return nums.slice(1).reduce((acc, arg) => {
+    return nums.slice(1).reduce((acc, arg, reduceIdx) => {
       if (arg.value === 0) {
-        throw new EvaluationError("division by zero", { args: nums });
+        const err = new EvaluationError("division by zero", { args: nums });
+        err.data = { argIndex: reduceIdx + 1 };
+        throw err;
       }
       return cljNumber(acc.value / arg.value);
     }, nums[0]);
@@ -1270,10 +1438,9 @@ var arithmeticFunctions = {
         args: nums
       });
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("> expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("> expects all arguments to be numbers", { args: nums }, badIdx);
     }
     for (let i = 1;i < nums.length; i++) {
       if (nums[i].value >= nums[i - 1].value) {
@@ -1288,10 +1455,9 @@ var arithmeticFunctions = {
         args: nums
       });
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("< expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("< expects all arguments to be numbers", { args: nums }, badIdx);
     }
     for (let i = 1;i < nums.length; i++) {
       if (nums[i].value <= nums[i - 1].value) {
@@ -1306,10 +1472,9 @@ var arithmeticFunctions = {
         args: nums
       });
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError(">= expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg(">= expects all arguments to be numbers", { args: nums }, badIdx);
     }
     for (let i = 1;i < nums.length; i++) {
       if (nums[i].value > nums[i - 1].value) {
@@ -1324,10 +1489,9 @@ var arithmeticFunctions = {
         args: nums
       });
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("<= expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("<= expects all arguments to be numbers", { args: nums }, badIdx);
     }
     for (let i = 1;i < nums.length; i++) {
       if (nums[i].value < nums[i - 1].value) {
@@ -1351,13 +1515,13 @@ var arithmeticFunctions = {
   }), "Compares adjacent arguments left to right, returns true if all values are structurally equal, false otherwise.", [["&", "vals"]]),
   inc: withDoc(cljNativeFunction("inc", (x) => {
     if (x === undefined || x.kind !== "number") {
-      throw new EvaluationError(`inc expects a number${x !== undefined ? `, got ${printString(x)}` : ""}`, { x });
+      throw EvaluationError.atArg(`inc expects a number${x !== undefined ? `, got ${printString(x)}` : ""}`, { x }, 0);
     }
     return cljNumber(x.value + 1);
   }), "Returns the argument incremented by 1. Throws on non-number arguments.", [["x"]]),
   dec: withDoc(cljNativeFunction("dec", (x) => {
     if (x === undefined || x.kind !== "number") {
-      throw new EvaluationError(`dec expects a number${x !== undefined ? `, got ${printString(x)}` : ""}`, { x });
+      throw EvaluationError.atArg(`dec expects a number${x !== undefined ? `, got ${printString(x)}` : ""}`, { x }, 0);
     }
     return cljNumber(x.value - 1);
   }), "Returns the argument decremented by 1. Throws on non-number arguments.", [["x"]]),
@@ -1367,10 +1531,9 @@ var arithmeticFunctions = {
         args: nums
       });
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("max expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("max expects all arguments to be numbers", { args: nums }, badIdx);
     }
     return nums.reduce((best, arg) => arg.value > best.value ? arg : best);
   }), "Returns the largest of the arguments. Throws on non-number arguments.", [["&", "nums"]]),
@@ -1380,53 +1543,54 @@ var arithmeticFunctions = {
         args: nums
       });
     }
-    if (nums.some((arg) => arg.kind !== "number")) {
-      throw new EvaluationError("min expects all arguments to be numbers", {
-        args: nums
-      });
+    const badIdx = nums.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("min expects all arguments to be numbers", { args: nums }, badIdx);
     }
     return nums.reduce((best, arg) => arg.value < best.value ? arg : best);
   }), "Returns the smallest of the arguments. Throws on non-number arguments.", [["&", "nums"]]),
   mod: withDoc(cljNativeFunction("mod", (n, d) => {
     if (n === undefined || n.kind !== "number") {
-      throw new EvaluationError(`mod expects a number as first argument${n !== undefined ? `, got ${printString(n)}` : ""}`, { n });
+      throw EvaluationError.atArg(`mod expects a number as first argument${n !== undefined ? `, got ${printString(n)}` : ""}`, { n }, 0);
     }
     if (d === undefined || d.kind !== "number") {
-      throw new EvaluationError(`mod expects a number as second argument${d !== undefined ? `, got ${printString(d)}` : ""}`, { d });
+      throw EvaluationError.atArg(`mod expects a number as second argument${d !== undefined ? `, got ${printString(d)}` : ""}`, { d }, 1);
     }
     if (d.value === 0) {
-      throw new EvaluationError("mod: division by zero", { n, d });
+      const err = new EvaluationError("mod: division by zero", { n, d });
+      err.data = { argIndex: 1 };
+      throw err;
     }
     const result = n.value % d.value;
     return cljNumber(result < 0 ? result + Math.abs(d.value) : result);
   }), "Returns the remainder of the first argument divided by the second argument. Throws on non-number arguments or division by zero.", [["n", "d"]]),
   "even?": withDoc(cljNativeFunction("even?", (n) => {
     if (n === undefined || n.kind !== "number") {
-      throw new EvaluationError(`even? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n });
+      throw EvaluationError.atArg(`even? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n }, 0);
     }
     return cljBoolean(n.value % 2 === 0);
   }), "Returns true if the argument is an even number, false otherwise.", [["n"]]),
   "odd?": withDoc(cljNativeFunction("odd?", (n) => {
     if (n === undefined || n.kind !== "number") {
-      throw new EvaluationError(`odd? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n });
+      throw EvaluationError.atArg(`odd? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n }, 0);
     }
     return cljBoolean(Math.abs(n.value) % 2 !== 0);
   }), "Returns true if the argument is an odd number, false otherwise.", [["n"]]),
   "pos?": withDoc(cljNativeFunction("pos?", (n) => {
     if (n === undefined || n.kind !== "number") {
-      throw new EvaluationError(`pos? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n });
+      throw EvaluationError.atArg(`pos? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n }, 0);
     }
     return cljBoolean(n.value > 0);
   }), "Returns true if the argument is a positive number, false otherwise.", [["n"]]),
   "neg?": withDoc(cljNativeFunction("neg?", (n) => {
     if (n === undefined || n.kind !== "number") {
-      throw new EvaluationError(`neg? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n });
+      throw EvaluationError.atArg(`neg? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n }, 0);
     }
     return cljBoolean(n.value < 0);
   }), "Returns true if the argument is a negative number, false otherwise.", [["n"]]),
   "zero?": withDoc(cljNativeFunction("zero?", (n) => {
     if (n === undefined || n.kind !== "number") {
-      throw new EvaluationError(`zero? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n });
+      throw EvaluationError.atArg(`zero? expects a number${n !== undefined ? `, got ${printString(n)}` : ""}`, { n }, 0);
     }
     return cljBoolean(n.value === 0);
   }), "Returns true if the argument is zero, false otherwise.", [["n"]])
@@ -1444,14 +1608,14 @@ var atomFunctions = {
       return value.value;
     if (isReduced(value))
       return value.value;
-    throw new EvaluationError(`deref expects an atom, volatile, or reduced value, got ${value.kind}`, { value });
+    throw EvaluationError.atArg(`deref expects an atom, volatile, or reduced value, got ${value.kind}`, { value }, 0);
   }), "Returns the wrapped value from an atom, volatile, or reduced value.", [["value"]]),
   "swap!": withDoc(cljNativeFunctionWithContext("swap!", (ctx, callEnv, atomVal, fn, ...extraArgs) => {
     if (!isAtom(atomVal)) {
-      throw new EvaluationError(`swap! expects an atom as its first argument, got ${atomVal.kind}`, { atomVal });
+      throw EvaluationError.atArg(`swap! expects an atom as its first argument, got ${atomVal.kind}`, { atomVal }, 0);
     }
     if (!isAFunction(fn)) {
-      throw new EvaluationError(`swap! expects a function as its second argument, got ${fn.kind}`, { fn });
+      throw EvaluationError.atArg(`swap! expects a function as its second argument, got ${fn.kind}`, { fn }, 1);
     }
     const newVal = ctx.applyFunction(fn, [atomVal.value, ...extraArgs], callEnv);
     atomVal.value = newVal;
@@ -1459,7 +1623,7 @@ var atomFunctions = {
   }), "Applies fn to the current value of the atom, replacing the current value with the result. Returns the new value.", [["atomVal", "fn", "&", "extraArgs"]]),
   "reset!": withDoc(cljNativeFunction("reset!", (atomVal, newVal) => {
     if (!isAtom(atomVal)) {
-      throw new EvaluationError(`reset! expects an atom as its first argument, got ${atomVal.kind}`, { atomVal });
+      throw EvaluationError.atArg(`reset! expects an atom as its first argument, got ${atomVal.kind}`, { atomVal }, 0);
     }
     atomVal.value = newVal;
     return newVal;
@@ -1563,7 +1727,7 @@ var collectionFunctions = {
     if (coll.kind === "nil")
       return cljNil();
     if (!isSeqable(coll)) {
-      throw new EvaluationError(`seq expects a collection, string, or nil, got ${printString(coll)}`, { collection: coll });
+      throw EvaluationError.atArg(`seq expects a collection, string, or nil, got ${printString(coll)}`, { collection: coll }, 0);
     }
     const items = toSeq(coll);
     return items.length === 0 ? cljNil() : cljList(items);
@@ -1572,9 +1736,7 @@ var collectionFunctions = {
     if (collection.kind === "nil")
       return cljNil();
     if (!isSeqable(collection)) {
-      throw new EvaluationError("first expects a collection or string", {
-        collection
-      });
+      throw EvaluationError.atArg("first expects a collection or string", { collection }, 0);
     }
     const entries = toSeq(collection);
     return entries.length === 0 ? cljNil() : entries[0];
@@ -1583,9 +1745,7 @@ var collectionFunctions = {
     if (collection.kind === "nil")
       return cljList([]);
     if (!isSeqable(collection)) {
-      throw new EvaluationError("rest expects a collection or string", {
-        collection
-      });
+      throw EvaluationError.atArg("rest expects a collection or string", { collection }, 0);
     }
     if (isList(collection)) {
       if (collection.value.length === 0) {
@@ -1606,7 +1766,7 @@ var collectionFunctions = {
       const chars = toSeq(collection);
       return cljList(chars.slice(1));
     }
-    throw new EvaluationError(`rest expects a collection or string, got ${printString(collection)}`, { collection });
+    throw EvaluationError.atArg(`rest expects a collection or string, got ${printString(collection)}`, { collection }, 0);
   }), "Returns a sequence of the given collection or string excluding the first element.", [["coll"]]),
   conj: withDoc(cljNativeFunction("conj", (collection, ...args) => {
     if (!collection) {
@@ -1616,7 +1776,7 @@ var collectionFunctions = {
       return collection;
     }
     if (!isCollection(collection)) {
-      throw new EvaluationError(`conj expects a collection, got ${printString(collection)}`, { collection });
+      throw EvaluationError.atArg(`conj expects a collection, got ${printString(collection)}`, { collection }, 0);
     }
     if (isList(collection)) {
       const newItems = [];
@@ -1632,11 +1792,12 @@ var collectionFunctions = {
       const newEntries = [...collection.entries];
       for (let i = 0;i < args.length; i += 1) {
         const pair = args[i];
+        const pairArgIndex = i + 1;
         if (pair.kind !== "vector") {
-          throw new EvaluationError(`conj on maps expects each argument to be a vector key-pair for maps, got ${printString(pair)}`, { pair });
+          throw EvaluationError.atArg(`conj on maps expects each argument to be a vector key-pair for maps, got ${printString(pair)}`, { pair }, pairArgIndex);
         }
         if (pair.value.length !== 2) {
-          throw new EvaluationError(`conj on maps expects each argument to be a vector key-pair for maps, got ${printString(pair)}`, { pair });
+          throw EvaluationError.atArg(`conj on maps expects each argument to be a vector key-pair for maps, got ${printString(pair)}`, { pair }, pairArgIndex);
         }
         const key = pair.value[0];
         const keyIdx = newEntries.findIndex((entry) => isEqual(entry[0], key));
@@ -1652,10 +1813,10 @@ var collectionFunctions = {
   }), "Appends args to the given collection. Lists append in reverse order to the head, vectors append to the tail.", [["collection", "&", "args"]]),
   cons: withDoc(cljNativeFunction("cons", (x, xs) => {
     if (!isCollection(xs)) {
-      throw new EvaluationError(`cons expects a collection as second argument, got ${printString(xs)}`, { xs });
+      throw EvaluationError.atArg(`cons expects a collection as second argument, got ${printString(xs)}`, { xs }, 1);
     }
     if (isMap(xs)) {
-      throw new EvaluationError("cons on maps is not supported, use vectors instead", { xs });
+      throw EvaluationError.atArg("cons on maps is not supported, use vectors instead", { xs }, 1);
     }
     const wrap = isList(xs) ? cljList : cljVector;
     const newItems = [x, ...xs.value];
@@ -1672,7 +1833,7 @@ var collectionFunctions = {
       throw new EvaluationError("assoc on lists is not supported, use vectors instead", { collection });
     }
     if (!isCollection(collection)) {
-      throw new EvaluationError(`assoc expects a collection, got ${printString(collection)}`, { collection });
+      throw EvaluationError.atArg(`assoc expects a collection, got ${printString(collection)}`, { collection }, 0);
     }
     if (args.length < 2) {
       throw new EvaluationError("assoc expects at least two arguments", {
@@ -1689,10 +1850,10 @@ var collectionFunctions = {
       for (let i = 0;i < args.length; i += 2) {
         const index = args[i];
         if (index.kind !== "number") {
-          throw new EvaluationError(`assoc on vectors expects each key argument to be a index (number), got ${printString(index)}`, { index });
+          throw EvaluationError.atArg(`assoc on vectors expects each key argument to be a index (number), got ${printString(index)}`, { index }, i + 1);
         }
         if (index.value > newValues.length) {
-          throw new EvaluationError(`assoc index ${index.value} is out of bounds for vector of length ${newValues.length}`, { index, collection });
+          throw EvaluationError.atArg(`assoc index ${index.value} is out of bounds for vector of length ${newValues.length}`, { index, collection }, i + 1);
         }
         newValues[index.value] = args[i + 1];
       }
@@ -1719,10 +1880,10 @@ var collectionFunctions = {
       throw new EvaluationError("dissoc expects a collection as first argument", { collection });
     }
     if (isList(collection)) {
-      throw new EvaluationError("dissoc on lists is not supported, use vectors instead", { collection });
+      throw EvaluationError.atArg("dissoc on lists is not supported, use vectors instead", { collection }, 0);
     }
     if (!isCollection(collection)) {
-      throw new EvaluationError(`dissoc expects a collection, got ${printString(collection)}`, { collection });
+      throw EvaluationError.atArg(`dissoc expects a collection, got ${printString(collection)}`, { collection }, 0);
     }
     if (isVector(collection)) {
       if (collection.value.length === 0) {
@@ -1732,10 +1893,10 @@ var collectionFunctions = {
       for (let i = 0;i < args.length; i += 1) {
         const index = args[i];
         if (index.kind !== "number") {
-          throw new EvaluationError(`dissoc on vectors expects each key argument to be a index (number), got ${printString(index)}`, { index });
+          throw EvaluationError.atArg(`dissoc on vectors expects each key argument to be a index (number), got ${printString(index)}`, { index }, i + 1);
         }
         if (index.value >= newValues.length) {
-          throw new EvaluationError(`dissoc index ${index.value} is out of bounds for vector of length ${newValues.length}`, { index, collection });
+          throw EvaluationError.atArg(`dissoc index ${index.value} is out of bounds for vector of length ${newValues.length}`, { index, collection }, i + 1);
         }
         newValues.splice(index.value, 1);
       }
@@ -1799,7 +1960,9 @@ var collectionFunctions = {
     if (index < 0 || index >= items.length) {
       if (notFound !== undefined)
         return notFound;
-      throw new EvaluationError(`nth index ${index} is out of bounds for collection of length ${items.length}`, { coll, n });
+      const err = new EvaluationError(`nth index ${index} is out of bounds for collection of length ${items.length}`, { coll, n });
+      err.data = { argIndex: 1 };
+      throw err;
     }
     return items[index];
   }), "Returns the nth element of the given collection. If not-found is provided, it is returned if the index is out of bounds, otherwise an error is thrown.", [["coll", "n", "not-found"]]),
@@ -1838,27 +2001,27 @@ var collectionFunctions = {
   }), "Returns the last element of the given collection.", [["coll"]]),
   reverse: withDoc(cljNativeFunction("reverse", (coll) => {
     if (coll === undefined || !isList(coll) && !isVector(coll)) {
-      throw new EvaluationError(`reverse expects a list or vector${coll !== undefined ? `, got ${printString(coll)}` : ""}`, { coll });
+      throw EvaluationError.atArg(`reverse expects a list or vector${coll !== undefined ? `, got ${printString(coll)}` : ""}`, { coll }, 0);
     }
     return cljList([...coll.value].reverse());
   }), "Returns a new sequence with the elements of the given collection in reverse order.", [["coll"]]),
   "empty?": withDoc(cljNativeFunction("empty?", (coll) => {
     if (coll === undefined) {
-      throw new EvaluationError("empty? expects one argument", {});
+      throw EvaluationError.atArg("empty? expects one argument", {}, 0);
     }
     if (coll.kind === "nil")
       return cljBoolean(true);
     if (!isSeqable(coll)) {
-      throw new EvaluationError(`empty? expects a collection, string, or nil, got ${printString(coll)}`, { coll });
+      throw EvaluationError.atArg(`empty? expects a collection, string, or nil, got ${printString(coll)}`, { coll }, 0);
     }
     return cljBoolean(toSeq(coll).length === 0);
   }), "Returns true if coll has no items. Accepts collections, strings, and nil.", [["coll"]]),
   "contains?": withDoc(cljNativeFunction("contains?", (coll, key) => {
     if (coll === undefined) {
-      throw new EvaluationError("contains? expects a collection as first argument", {});
+      throw EvaluationError.atArg("contains? expects a collection as first argument", {}, 0);
     }
     if (key === undefined) {
-      throw new EvaluationError("contains? expects a key as second argument", {});
+      throw EvaluationError.atArg("contains? expects a key as second argument", {}, 1);
     }
     if (coll.kind === "nil")
       return cljBoolean(false);
@@ -1870,11 +2033,11 @@ var collectionFunctions = {
         return cljBoolean(false);
       return cljBoolean(key.value >= 0 && key.value < coll.value.length);
     }
-    throw new EvaluationError(`contains? expects a map, vector, or nil, got ${printString(coll)}`, { coll });
+    throw EvaluationError.atArg(`contains? expects a map, vector, or nil, got ${printString(coll)}`, { coll }, 0);
   }), "Returns true if key is present in coll. For maps checks key existence (including keys with nil values). For vectors checks index bounds.", [["coll", "key"]]),
   repeat: withDoc(cljNativeFunction("repeat", (n, x) => {
     if (n === undefined || n.kind !== "number") {
-      throw new EvaluationError(`repeat expects a number as first argument${n !== undefined ? `, got ${printString(n)}` : ""}`, { n });
+      throw EvaluationError.atArg(`repeat expects a number as first argument${n !== undefined ? `, got ${printString(n)}` : ""}`, { n }, 0);
     }
     return cljList(Array(n.value).fill(x));
   }), "Returns a sequence of n copies of x.", [["n", "x"]]),
@@ -1882,8 +2045,9 @@ var collectionFunctions = {
     if (args.length === 0 || args.length > 3) {
       throw new EvaluationError("range expects 1, 2, or 3 arguments: (range n), (range start end), or (range start end step)", { args });
     }
-    if (args.some((a) => a.kind !== "number")) {
-      throw new EvaluationError("range expects number arguments", { args });
+    const badIdx = args.findIndex((a) => a.kind !== "number");
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("range expects number arguments", { args }, badIdx);
     }
     let start;
     let end;
@@ -1902,7 +2066,7 @@ var collectionFunctions = {
       step = args[2].value;
     }
     if (step === 0) {
-      throw new EvaluationError("range step cannot be zero", { args });
+      throw EvaluationError.atArg("range step cannot be zero", { args }, args.length - 1);
     }
     const result = [];
     if (step > 0) {
@@ -1918,13 +2082,13 @@ var collectionFunctions = {
   }), "Returns a sequence of numbers from start (inclusive) to end (exclusive), incrementing by step. If step is positive, the sequence is generated from start to end, otherwise it is generated from end to start.", [["n"], ["start", "end"], ["start", "end", "step"]]),
   keys: withDoc(cljNativeFunction("keys", (m) => {
     if (m === undefined || !isMap(m)) {
-      throw new EvaluationError(`keys expects a map${m !== undefined ? `, got ${printString(m)}` : ""}`, { m });
+      throw EvaluationError.atArg(`keys expects a map${m !== undefined ? `, got ${printString(m)}` : ""}`, { m }, 0);
     }
     return cljVector(m.entries.map(([k]) => k));
   }), "Returns a vector of the keys of the given map.", [["m"]]),
   vals: withDoc(cljNativeFunction("vals", (m) => {
     if (m === undefined || !isMap(m)) {
-      throw new EvaluationError(`vals expects a map${m !== undefined ? `, got ${printString(m)}` : ""}`, { m });
+      throw EvaluationError.atArg(`vals expects a map${m !== undefined ? `, got ${printString(m)}` : ""}`, { m }, 0);
     }
     return cljVector(m.entries.map(([, v]) => v));
   }), "Returns a vector of the values of the given map.", [["m"]]),
@@ -1935,9 +2099,7 @@ var collectionFunctions = {
       valueKeywords.map,
       valueKeywords.string
     ].includes(countable.kind)) {
-      throw new EvaluationError(`count expects a countable value, got ${printString(countable)}`, {
-        countable
-      });
+      throw EvaluationError.atArg(`count expects a countable value, got ${printString(countable)}`, { countable }, 0);
     }
     switch (countable.kind) {
       case valueKeywords.list:
@@ -2006,7 +2168,7 @@ var errorFunctions = {
 var hofFunctions = {
   reduce: withDoc(cljNativeFunctionWithContext("reduce", (ctx, callEnv, fn, ...rest) => {
     if (fn === undefined || !isAFunction(fn)) {
-      throw new EvaluationError(`reduce expects a function as first argument${fn !== undefined ? `, got ${printString(fn)}` : ""}`, { fn });
+      throw EvaluationError.atArg(`reduce expects a function as first argument${fn !== undefined ? `, got ${printString(fn)}` : ""}`, { fn }, 0);
     }
     if (rest.length === 0 || rest.length > 2) {
       throw new EvaluationError("reduce expects 2 or 3 arguments: (reduce f coll) or (reduce f init coll)", { fn });
@@ -2021,7 +2183,7 @@ var hofFunctions = {
       return init;
     }
     if (!isSeqable(collection)) {
-      throw new EvaluationError(`reduce expects a collection or string, got ${printString(collection)}`, { collection });
+      throw EvaluationError.atArg(`reduce expects a collection or string, got ${printString(collection)}`, { collection }, rest.length);
     }
     const items = toSeq(collection);
     if (!hasInit) {
@@ -2053,7 +2215,7 @@ var hofFunctions = {
   ]),
   apply: withDoc(cljNativeFunctionWithContext("apply", (ctx, callEnv, fn, ...rest) => {
     if (fn === undefined || !isCallable(fn)) {
-      throw new EvaluationError(`apply expects a callable as first argument${fn !== undefined ? `, got ${printString(fn)}` : ""}`, { fn });
+      throw EvaluationError.atArg(`apply expects a callable as first argument${fn !== undefined ? `, got ${printString(fn)}` : ""}`, { fn }, 0);
     }
     if (rest.length === 0) {
       throw new EvaluationError("apply expects at least 2 arguments", {
@@ -2062,7 +2224,7 @@ var hofFunctions = {
     }
     const lastArg = rest[rest.length - 1];
     if (!isNil(lastArg) && !isSeqable(lastArg)) {
-      throw new EvaluationError(`apply expects a collection or string as last argument, got ${printString(lastArg)}`, { lastArg });
+      throw EvaluationError.atArg(`apply expects a collection or string as last argument, got ${printString(lastArg)}`, { lastArg }, rest.length);
     }
     const args = [
       ...rest.slice(0, -1),
@@ -2075,7 +2237,7 @@ var hofFunctions = {
   ]),
   partial: withDoc(cljNativeFunction("partial", (fn, ...preArgs) => {
     if (fn === undefined || !isCallable(fn)) {
-      throw new EvaluationError(`partial expects a callable as first argument${fn !== undefined ? `, got ${printString(fn)}` : ""}`, { fn });
+      throw EvaluationError.atArg(`partial expects a callable as first argument${fn !== undefined ? `, got ${printString(fn)}` : ""}`, { fn }, 0);
     }
     const capturedFn = fn;
     return cljNativeFunctionWithContext("partial", (ctx, callEnv, ...moreArgs) => {
@@ -2086,8 +2248,9 @@ var hofFunctions = {
     if (fns.length === 0) {
       return cljNativeFunction("identity", (x) => x);
     }
-    if (fns.some((f) => !isCallable(f))) {
-      throw new EvaluationError("comp expects functions or other callable values (keywords, maps)", { fns });
+    const badIdx = fns.findIndex((f) => !isCallable(f));
+    if (badIdx !== -1) {
+      throw EvaluationError.atArg("comp expects functions or other callable values (keywords, maps)", { fns }, badIdx);
     }
     const capturedFns = fns;
     return cljNativeFunctionWithContext("composed", (ctx, callEnv, ...args) => {
@@ -2100,7 +2263,7 @@ var hofFunctions = {
   }), "Returns the composition of fns, applied right-to-left. (comp f g) is equivalent to (fn [x] (f (g x))). Accepts any callable: functions, keywords, and maps.", [[], ["f"], ["f", "g"], ["f", "g", "&", "fns"]]),
   identity: withDoc(cljNativeFunction("identity", (x) => {
     if (x === undefined) {
-      throw new EvaluationError("identity expects one argument", {});
+      throw EvaluationError.atArg("identity expects one argument", {}, 0);
     }
     return x;
   }), "Returns its single argument unchanged.", [["x"]])
@@ -2110,31 +2273,51 @@ var hofFunctions = {
 var metaFunctions = {
   meta: withDoc(cljNativeFunction("meta", (val) => {
     if (val === undefined) {
-      throw new EvaluationError("meta expects one argument", {});
+      throw EvaluationError.atArg("meta expects one argument", {}, 0);
     }
-    if (val.kind === "function" || val.kind === "native-function") {
+    if (val.kind === "function" || val.kind === "native-function" || val.kind === "var" || val.kind === "list" || val.kind === "vector" || val.kind === "map" || val.kind === "symbol" || val.kind === "atom") {
       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) => {
     if (val === undefined) {
-      throw new EvaluationError("with-meta expects two arguments", {});
+      throw EvaluationError.atArg("with-meta expects two arguments", {}, 0);
     }
     if (m === undefined) {
-      throw new EvaluationError("with-meta expects two arguments", {});
+      throw EvaluationError.atArg("with-meta expects two arguments", {}, 1);
     }
     if (m.kind !== "map" && m.kind !== "nil") {
-      throw new EvaluationError(`with-meta expects a map as second argument, got ${printString(m)}`, { m });
+      throw EvaluationError.atArg(`with-meta expects a map as second argument, got ${printString(m)}`, { m }, 1);
     }
-    if (val.kind !== "function" && val.kind !== "native-function") {
-      throw new EvaluationError(`with-meta only supports functions, got ${printString(val)}`, { val });
+    const metaSupported = val.kind === "function" || val.kind === "native-function" || val.kind === "list" || val.kind === "vector" || val.kind === "map" || val.kind === "symbol";
+    if (!metaSupported) {
+      throw EvaluationError.atArg(`with-meta does not support ${val.kind}, got ${printString(val)}`, { val }, 0);
     }
     const meta = m.kind === "nil" ? undefined : m;
     return { ...val, meta };
-  }), "Returns a new value with the metadata map m applied to val.", [["val", "m"]])
+  }), "Returns a new value with the metadata map m applied to val.", [["val", "m"]]),
+  "alter-meta!": withDoc(cljNativeFunctionWithContext("alter-meta!", (ctx, callEnv, ref, f, ...args) => {
+    if (ref === undefined) {
+      throw EvaluationError.atArg("alter-meta! expects at least two arguments", {}, 0);
+    }
+    if (f === undefined) {
+      throw EvaluationError.atArg("alter-meta! expects at least two arguments", {}, 1);
+    }
+    if (ref.kind !== "var" && ref.kind !== "atom") {
+      throw EvaluationError.atArg(`alter-meta! expects a Var or Atom as first argument, got ${ref.kind}`, {}, 0);
+    }
+    if (!isAFunction(f)) {
+      throw EvaluationError.atArg(`alter-meta! expects a function as second argument, got ${f.kind}`, {}, 1);
+    }
+    const currentMeta = ref.meta ?? cljNil();
+    const newMeta = ctx.applyCallable(f, [currentMeta, ...args], callEnv);
+    if (newMeta.kind !== "map" && newMeta.kind !== "nil") {
+      throw new EvaluationError(`alter-meta! function must return a map or nil, got ${newMeta.kind}`, {});
+    }
+    ref.meta = newMeta.kind === "nil" ? undefined : newMeta;
+    return newMeta;
+  }), "Applies f to ref's current metadata (with optional args), sets the result as the new metadata, and returns it.", [["ref", "f", "&", "args"]])
 };
 
 // src/core/evaluator/apply.ts
@@ -2233,45 +2416,12 @@ function macroExpandAllWithContext(form, env, ctx) {
   return expanded.every((e, i) => e === form.value[i]) ? form : cljList(expanded);
 }
 
-// src/core/positions.ts
-function setPos(val, pos) {
-  Object.defineProperty(val, "_pos", {
-    value: pos,
-    enumerable: false,
-    writable: true,
-    configurable: true
-  });
-}
-function getPos(val) {
-  return val._pos;
-}
-function getLineCol(source, offset) {
-  const lines = source.split(`
-`);
-  let pos = 0;
-  for (let i = 0;i < lines.length; i++) {
-    const lineEnd = pos + lines[i].length;
-    if (offset <= lineEnd) {
-      return { line: i + 1, col: offset - pos, lineText: lines[i] };
-    }
-    pos = lineEnd + 1;
-  }
-  const last = lines[lines.length - 1];
-  return { line: lines.length, col: last.length, lineText: last };
-}
-function formatErrorContext(source, pos) {
-  const { line, col, lineText } = getLineCol(source, pos.start);
-  const span = Math.max(1, pos.end - pos.start);
-  const caret = " ".repeat(col) + "^".repeat(span);
-  return `
-  at line ${line}, col ${col + 1}:
-  ${lineText}
-  ${caret}`;
-}
-
 // src/core/evaluator/collections.ts
 function evaluateVector(vector, env, ctx) {
-  return cljVector(vector.value.map((v) => ctx.evaluate(v, env)));
+  const evaluated = vector.value.map((v) => ctx.evaluate(v, env));
+  if (vector.meta)
+    return { kind: "vector", value: evaluated, meta: vector.meta };
+  return cljVector(evaluated);
 }
 function evaluateMap(map, env, ctx) {
   let entries = [];
@@ -2280,6 +2430,8 @@ function evaluateMap(map, env, ctx) {
     const evaluatedValue = ctx.evaluate(value, env);
     entries.push([evaluatedKey, evaluatedValue]);
   }
+  if (map.meta)
+    return { kind: "map", entries, meta: map.meta };
   return cljMap(entries);
 }
 
@@ -2311,7 +2463,19 @@ function evaluateList(list, env, ctx) {
     throw new EvaluationError(`${name} is not callable`, { list, env });
   }
   const args = list.value.slice(1).map((v) => ctx.evaluate(v, env));
-  return ctx.applyCallable(evaledFirst, args, env);
+  try {
+    return ctx.applyCallable(evaledFirst, args, env);
+  } catch (e) {
+    if (e instanceof EvaluationError && e.data?.argIndex !== undefined && !e.pos) {
+      const argForm = list.value[e.data.argIndex + 1];
+      if (argForm) {
+        const pos = getPos(argForm);
+        if (pos)
+          e.pos = pos;
+      }
+    }
+    throw e;
+  }
 }
 
 // src/core/evaluator/evaluate.ts
@@ -2447,13 +2611,13 @@ var predicateFunctions = {
   "coll?": withDoc(cljNativeFunction("coll?", (x) => cljBoolean(x !== undefined && isCollection(x))), "Returns true if the value is a collection, false otherwise.", [["x"]]),
   some: withDoc(cljNativeFunction("some", (pred, coll) => {
     if (pred === undefined || !isAFunction(pred)) {
-      throw new EvaluationError(`some expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ""}`, { pred });
+      throw EvaluationError.atArg(`some expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ""}`, { pred }, 0);
     }
     if (coll === undefined) {
       return cljNil();
     }
     if (!isSeqable(coll)) {
-      throw new EvaluationError(`some expects a collection or string as second argument, got ${printString(coll)}`, { coll });
+      throw EvaluationError.atArg(`some expects a collection or string as second argument, got ${printString(coll)}`, { coll }, 1);
     }
     for (const item of toSeq(coll)) {
       const result = applyFunction(pred, [item]);
@@ -2465,10 +2629,10 @@ var predicateFunctions = {
   }), "Returns the first truthy result of applying pred to each item in coll, or nil if no item satisfies pred.", [["pred", "coll"]]),
   "every?": withDoc(cljNativeFunction("every?", (pred, coll) => {
     if (pred === undefined || !isAFunction(pred)) {
-      throw new EvaluationError(`every? expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ""}`, { pred });
+      throw EvaluationError.atArg(`every? expects a function as first argument${pred !== undefined ? `, got ${printString(pred)}` : ""}`, { pred }, 0);
     }
     if (coll === undefined || !isSeqable(coll)) {
-      throw new EvaluationError(`every? expects a collection or string as second argument${coll !== undefined ? `, got ${printString(coll)}` : ""}`, { coll });
+      throw EvaluationError.atArg(`every? expects a collection or string as second argument${coll !== undefined ? `, got ${printString(coll)}` : ""}`, { coll }, 1);
     }
     for (const item of toSeq(coll)) {
       if (isFalsy(applyFunction(pred, [item]))) {
@@ -2875,13 +3039,13 @@ var utilFunctions = {
   }), "Returns a concatenated string representation of the given values.", [["&", "args"]]),
   subs: withDoc(cljNativeFunction("subs", (s, start, end) => {
     if (s === undefined || s.kind !== "string") {
-      throw new EvaluationError(`subs expects a string as first argument${s !== undefined ? `, got ${printString(s)}` : ""}`, { s });
+      throw EvaluationError.atArg(`subs expects a string as first argument${s !== undefined ? `, got ${printString(s)}` : ""}`, { s }, 0);
     }
     if (start === undefined || start.kind !== "number") {
-      throw new EvaluationError(`subs expects a number as second argument${start !== undefined ? `, got ${printString(start)}` : ""}`, { start });
+      throw EvaluationError.atArg(`subs expects a number as second argument${start !== undefined ? `, got ${printString(start)}` : ""}`, { start }, 1);
     }
     if (end !== undefined && end.kind !== "number") {
-      throw new EvaluationError(`subs expects a number as optional third argument${end !== undefined ? `, got ${printString(end)}` : ""}`, { end });
+      throw EvaluationError.atArg(`subs expects a number as optional third argument${end !== undefined ? `, got ${printString(end)}` : ""}`, { end }, 2);
     }
     const from = start.value;
     const to = end?.value;
@@ -2921,7 +3085,7 @@ var utilFunctions = {
     }
     const prefix = args[0];
     if (prefix !== undefined && prefix.kind !== "string") {
-      throw new EvaluationError(`gensym prefix must be a string${prefix !== undefined ? `, got ${printString(prefix)}` : ""}`, { prefix });
+      throw EvaluationError.atArg(`gensym prefix must be a string${prefix !== undefined ? `, got ${printString(prefix)}` : ""}`, { prefix }, 0);
     }
     const p = prefix?.kind === "string" ? prefix.value : "G";
     return cljSymbol(makeGensym(p));
@@ -2932,9 +3096,8 @@ var utilFunctions = {
         form
       });
     }
-    const rootEnv = getRootEnv(callEnv);
-    const expanded = ctx.expandAll(form, rootEnv);
-    return ctx.evaluate(expanded, rootEnv);
+    const expanded = ctx.expandAll(form, callEnv);
+    return ctx.evaluate(expanded, callEnv);
   }), "Evaluates the given form in the global environment and returns the result.", [["form"]]),
   "macroexpand-1": withDoc(cljNativeFunctionWithContext("macroexpand-1", (ctx, callEnv, form) => {
     if (!isList(form) || form.value.length === 0)
@@ -2942,7 +3105,7 @@ var utilFunctions = {
     const head = form.value[0];
     if (!isSymbol(head))
       return form;
-    const macroValue = tryLookup(head.name, getRootEnv(callEnv));
+    const macroValue = tryLookup(head.name, callEnv);
     if (macroValue === undefined)
       return form;
     if (!isMacro(macroValue))
@@ -2950,7 +3113,6 @@ var utilFunctions = {
     return ctx.applyMacro(macroValue, form.value.slice(1));
   }), "If the head of the form is a macro, expands it and returns the resulting forms. Otherwise, returns the form unchanged.", [["form"]]),
   macroexpand: withDoc(cljNativeFunctionWithContext("macroexpand", (ctx, callEnv, form) => {
-    const rootEnv = getRootEnv(callEnv);
     let current = form;
     while (true) {
       if (!isList(current) || current.value.length === 0)
@@ -2958,7 +3120,7 @@ var utilFunctions = {
       const head = current.value[0];
       if (!isSymbol(head))
         return current;
-      const macroValue = tryLookup(head.name, rootEnv);
+      const macroValue = tryLookup(head.name, callEnv);
       if (macroValue === undefined)
         return current;
       if (!isMacro(macroValue))
@@ -2970,7 +3132,7 @@ var utilFunctions = {
     "",
     "Note neither macroexpand-1 nor macroexpand will expand macros in sub-forms"
   ]), [["form"]]),
-  "macroexpand-all": withDoc(cljNativeFunctionWithContext("macroexpand-all", (ctx, callEnv, form) => ctx.expandAll(form, getRootEnv(callEnv))), joinLines([
+  "macroexpand-all": withDoc(cljNativeFunctionWithContext("macroexpand-all", (ctx, callEnv, form) => ctx.expandAll(form, callEnv)), joinLines([
     "Fully expands all macros in a form recursively — including in sub-forms.",
     "",
     "Unlike macroexpand, this descends into every sub-expression.",
@@ -2978,7 +3140,7 @@ var utilFunctions = {
   ]), [["form"]]),
   namespace: withDoc(cljNativeFunction("namespace", (x) => {
     if (x === undefined) {
-      throw new EvaluationError("namespace expects an argument", { x });
+      throw EvaluationError.atArg("namespace expects an argument", { x }, 0);
     }
     let raw;
     if (isKeyword(x)) {
@@ -2986,7 +3148,7 @@ var utilFunctions = {
     } else if (isSymbol(x)) {
       raw = x.name;
     } else {
-      throw new EvaluationError(`namespace expects a keyword or symbol, got ${printString(x)}`, { x });
+      throw EvaluationError.atArg(`namespace expects a keyword or symbol, got ${printString(x)}`, { x }, 0);
     }
     const slashIdx = raw.indexOf("/");
     if (slashIdx <= 0)
@@ -2995,7 +3157,7 @@ var utilFunctions = {
   }), "Returns the namespace string of a qualified keyword or symbol, or nil if the argument is not qualified.", [["x"]]),
   name: withDoc(cljNativeFunction("name", (x) => {
     if (x === undefined) {
-      throw new EvaluationError("name expects an argument", { x });
+      throw EvaluationError.atArg("name expects an argument", { x }, 0);
     }
     let raw;
     if (isKeyword(x)) {
@@ -3005,7 +3167,7 @@ var utilFunctions = {
     } else if (x.kind === "string") {
       return x;
     } else {
-      throw new EvaluationError(`name expects a keyword, symbol, or string, got ${printString(x)}`, { x });
+      throw EvaluationError.atArg(`name expects a keyword, symbol, or string, got ${printString(x)}`, { x }, 0);
     }
     const slashIdx = raw.indexOf("/");
     return cljString(slashIdx >= 0 ? raw.slice(slashIdx + 1) : raw);
@@ -3017,13 +3179,13 @@ var utilFunctions = {
       });
     }
     if (args[0].kind !== "string") {
-      throw new EvaluationError(`keyword expects a string, got ${printString(args[0])}`, { args });
+      throw EvaluationError.atArg(`keyword expects a string, got ${printString(args[0])}`, { args }, 0);
     }
     if (args.length === 1) {
       return cljKeyword(`:${args[0].value}`);
     }
     if (args[1].kind !== "string") {
-      throw new EvaluationError(`keyword second argument must be a string, got ${printString(args[1])}`, { args });
+      throw EvaluationError.atArg(`keyword second argument must be a string, got ${printString(args[1])}`, { args }, 1);
     }
     return cljKeyword(`:${args[0].value}/${args[1].value}`);
   }), joinLines([
@@ -3078,14 +3240,14 @@ var nativeFunctions = {
 };
 function loadCoreFunctions(env, output) {
   for (const [key, value] of Object.entries(nativeFunctions)) {
-    define(key, value, env);
+    internVar(key, value, env);
   }
   const emit = output ?? ((text) => console.log(text));
-  define("println", cljNativeFunction("println", (...args) => {
+  internVar("println", cljNativeFunction("println", (...args) => {
     emit(args.map(valueToString).join(" "));
     return cljNil();
   }), env);
-  define("print", cljNativeFunction("print", (...args) => {
+  internVar("print", cljNativeFunction("print", (...args) => {
     emit(args.map(valueToString).join(" "));
     return cljNil();
   }), env);
@@ -3201,7 +3363,8 @@ var isNumber = (char) => {
 var isDot = (char) => char === ".";
 var isKeywordStart = (char) => char === ":";
 var isHash = (char) => char === "#";
-var isDelimiter = (char) => isLParen(char) || isRParen(char) || isLBracket(char) || isRBracket(char) || isLBrace(char) || isRBrace(char) || isBacktick(char) || isSingleQuote(char) || isAt(char);
+var isCaret = (char) => char === "^";
+var isDelimiter = (char) => isLParen(char) || isRParen(char) || isLBracket(char) || isRBracket(char) || isLBrace(char) || isRBrace(char) || isBacktick(char) || isSingleQuote(char) || isAt(char) || isCaret(char);
 var parseWhitespace = (ctx) => {
   const scanner = ctx.scanner;
   const start = scanner.position();
@@ -3347,6 +3510,12 @@ var parseDerefToken = (ctx) => {
   scanner.advance();
   return { kind: "Deref", start, end: scanner.position() };
 };
+var parseMetaToken = (ctx) => {
+  const scanner = ctx.scanner;
+  const start = scanner.position();
+  scanner.advance();
+  return { kind: "Meta", start, end: scanner.position() };
+};
 var parseRegexLiteral = (ctx, start) => {
   const scanner = ctx.scanner;
   scanner.advance();
@@ -3463,6 +3632,7 @@ var tokenParseEntries = [
   ],
   [isTilde, parseTilde],
   [isAt, parseDerefToken],
+  [isCaret, parseMetaToken],
   [isHash, parseDispatch]
 ];
 function parseNextToken(ctx) {
@@ -3612,6 +3782,35 @@ var readUnquote = (ctx) => {
   }
   return { kind: valueKeywords.list, value: [cljSymbol("unquote"), value] };
 };
+var readMeta = (ctx) => {
+  const scanner = ctx.scanner;
+  const token = scanner.peek();
+  if (!token) {
+    throw new ReaderError("Unexpected end of input while parsing metadata", scanner.position());
+  }
+  scanner.advance();
+  const metaForm = readForm(ctx);
+  const target = readForm(ctx);
+  let metaEntries;
+  if (metaForm.kind === "keyword") {
+    metaEntries = [[metaForm, cljBoolean(true)]];
+  } else if (metaForm.kind === "map") {
+    metaEntries = metaForm.entries;
+  } else if (metaForm.kind === "symbol") {
+    metaEntries = [[cljKeyword(":tag"), metaForm]];
+  } else {
+    throw new ReaderError("Metadata must be a keyword, map, or symbol", token);
+  }
+  if (target.kind === "symbol" || target.kind === "list" || target.kind === "vector" || target.kind === "map") {
+    const existingEntries = target.meta ? target.meta.entries : [];
+    const result = { ...target, meta: cljMap([...existingEntries, ...metaEntries]) };
+    const pos = getPos(target);
+    if (pos)
+      setPos(result, pos);
+    return result;
+  }
+  return target;
+};
 var readVarQuote = (ctx) => {
   const scanner = ctx.scanner;
   const token = scanner.peek();
@@ -3945,6 +4144,8 @@ function readForm(ctx) {
       return readDeref(ctx);
     case tokenKeywords.VarQuote:
       return readVarQuote(ctx);
+    case tokenKeywords.Meta:
+      return readMeta(ctx);
     case tokenKeywords.Regex:
       return readRegex(ctx);
     default:
@@ -3979,6 +4180,13 @@ var clojure_coreSource = `(ns clojure.core)
       \`(def ~name (with-meta (fn ~@rest-decl) {:doc ~doc :arglists '~arglists}))
       \`(def ~name (with-meta (fn ~@rest-decl) {:arglists '~arglists})))))
 
+
+(defn vary-meta
+  "Returns an object of the same type and value as obj, with
+  (apply f (meta obj) args) as its metadata."
+  [obj f & args]
+  (with-meta obj (apply f (meta obj) args)))
+
 (defn next
   "Returns a seq of the items after the first. Calls seq on its
   argument.  If there are no more items, returns nil."
@@ -5009,11 +5217,11 @@ function buildSessionApi(state, options) {
   const coreEnv = registry.get("clojure.core");
   coreEnv.resolveNs = (name) => registry.get(name) ?? null;
   const emitFn = options?.output ?? ((text) => console.log(text));
-  define("println", cljNativeFunction("println", (...args) => {
+  internVar("println", cljNativeFunction("println", (...args) => {
     emitFn(args.map(valueToString).join(" "));
     return cljNil();
   }), coreEnv);
-  define("print", cljNativeFunction("print", (...args) => {
+  internVar("print", cljNativeFunction("print", (...args) => {
     emitFn(args.map(valueToString).join(" "));
     return cljNil();
   }), coreEnv);
@@ -5063,14 +5271,14 @@ function buildSessionApi(state, options) {
   function getNsEnv(name) {
     return registry.get(name) ?? null;
   }
-  define("require", cljNativeFunction("require", (...args) => {
+  internVar("require", cljNativeFunction("require", (...args) => {
     const currentEnv = registry.get(currentNs);
     for (const arg of args) {
       processRequireSpec(arg, currentEnv, registry, resolveNamespace);
     }
     return cljNil();
   }), coreEnv);
-  define("resolve", cljNativeFunction("resolve", (sym) => {
+  internVar("resolve", cljNativeFunction("resolve", (sym) => {
     if (!isSymbol(sym))
       return cljNil();
     const slashIdx = sym.name.indexOf("/");
@@ -5093,16 +5301,25 @@ function buildSessionApi(state, options) {
       }
     }
   }
-  function loadFile(source, nsName) {
+  function loadFile(source, nsName, filePath) {
     const tokens = tokenize(source);
     const targetNs = extractNsNameFromTokens(tokens) ?? nsName ?? "user";
     const aliasMap = extractAliasMapFromTokens(tokens);
     const forms = readForms(tokens, targetNs, aliasMap);
     const env = ensureNs(targetNs);
+    ctx.currentSource = source;
+    ctx.currentFile = filePath;
+    ctx.currentLineOffset = 0;
+    ctx.currentColOffset = 0;
     processNsRequires(forms, env);
-    for (const form of forms) {
-      const expanded = ctx.expandAll(form, env);
-      ctx.evaluate(expanded, env);
+    try {
+      for (const form of forms) {
+        const expanded = ctx.expandAll(form, env);
+        ctx.evaluate(expanded, env);
+      }
+    } finally {
+      ctx.currentSource = undefined;
+      ctx.currentFile = undefined;
     }
     return targetNs;
   }
@@ -5115,7 +5332,11 @@ function buildSessionApi(state, options) {
     getNs,
     loadFile,
     addSourceRoot,
-    evaluate(source) {
+    evaluate(source, opts) {
+      ctx.currentSource = source;
+      ctx.currentFile = opts?.file;
+      ctx.currentLineOffset = opts?.lineOffset ?? 0;
+      ctx.currentColOffset = opts?.colOffset ?? 0;
       try {
         const tokens = tokenize(source);
         const declaredNs = extractNsNameFromTokens(tokens);
@@ -5149,9 +5370,15 @@ function buildSessionApi(state, options) {
           });
         }
         if ((e instanceof EvaluationError || e instanceof ReaderError) && e.pos) {
-          e.message += formatErrorContext(source, e.pos);
+          e.message += formatErrorContext(source, e.pos, {
+            lineOffset: ctx.currentLineOffset,
+            colOffset: ctx.currentColOffset
+          });
         }
         throw e;
+      } finally {
+        ctx.currentSource = undefined;
+        ctx.currentFile = undefined;
       }
     },
     evaluateForms(forms) {
@@ -5431,7 +5658,7 @@ class BDecoderStream extends stream.Transform {
 }
 
 // src/bin/version.ts
-var VERSION = "0.0.11";
+var VERSION = "0.0.12";
 
 // src/host/node.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
@@ -5534,8 +5761,10 @@ function handleEval(msg, managed, encoder) {
   const id = msg["id"] ?? "";
   const code = msg["code"] ?? "";
   managed.currentMsgId = id;
+  const lineOffset = typeof msg["line"] === "number" ? msg["line"] - 1 : 0;
+  const colOffset = typeof msg["column"] === "number" ? msg["column"] - 1 : 0;
   try {
-    const result = managed.session.evaluate(code);
+    const result = managed.session.evaluate(code, { lineOffset, colOffset });
     done(encoder, id, managed.id, {
       value: printString(result),
       ns: managed.session.currentNs
@@ -5565,7 +5794,7 @@ function handleLoadFile(msg, managed, encoder) {
       }
     }
     const nsHint = fileName.replace(/\.clj$/, "").replace(/\//g, ".") || undefined;
-    const loadedNs = managed.session.loadFile(source, nsHint);
+    const loadedNs = managed.session.loadFile(source, nsHint, filePath || undefined);
     if (filePath && loadedNs) {
       managed.nsToFile.set(loadedNs, filePath);
     }
@@ -5705,13 +5934,30 @@ function handleInfo(msg, managed, encoder) {
   }
   const meta = extractMeta(resolved.value);
   const file = managed.nsToFile.get(resolved.resolvedNs);
+  let varLine;
+  let varColumn;
+  let varFile;
+  if (resolved.value.kind === "var" && resolved.value.meta) {
+    for (const [k, v] of resolved.value.meta.entries) {
+      if (k.kind !== "keyword")
+        continue;
+      if (k.name === ":line" && v.kind === "number")
+        varLine = v.value;
+      if (k.name === ":column" && v.kind === "number")
+        varColumn = v.value;
+      if (k.name === ":file" && v.kind === "string")
+        varFile = v.value;
+    }
+  }
   done(encoder, id, managed.id, {
     ns: resolved.resolvedNs,
     name: resolved.localName,
     doc: meta.doc,
     "arglists-str": meta.arglistsStr,
     type: meta.type,
-    ...file ? { file } : {}
+    ...varFile ?? file ? { file: varFile ?? file } : {},
+    ...varLine !== undefined ? { line: varLine } : {},
+    ...varColumn !== undefined ? { column: varColumn } : {}
   });
 }
 function handleLookup(msg, managed, encoder) {