conjure-js 0.0.12 → 0.0.13

package/src/core/core-module.ts

@@ -0,0 +1,303 @@
+import type {
+  RuntimeModule,
+  VarDeclaration,
+  VarMap,
+  ModuleContext,
+} from './module'
+import { buildPrintContext, prettyPrintString, printString, withPrintContext } from './printer'
+import { derefValue } from './env'
+import { valueToString } from './transformations'
+import type { CljMap, CljValue, Env, EvaluationContext } from './types'
+import { arithmeticFunctions } from './stdlib/arithmetic'
+import { atomFunctions } from './stdlib/atoms'
+import { mapsSetsFunctions } from './stdlib/maps-sets'
+import { seqFunctions } from './stdlib/seq'
+import { vectorFunctions } from './stdlib/vectors'
+import { errorFunctions } from './stdlib/errors'
+import { hofFunctions } from './stdlib/hof'
+import { metaFunctions } from './stdlib/meta'
+import { predicateFunctions } from './stdlib/predicates'
+import { regexFunctions } from './stdlib/regex'
+import { stringFunctions } from './stdlib/strings'
+import { transducerFunctions } from './stdlib/transducers'
+import { utilFunctions } from './stdlib/utils'
+import { lazyFunctions } from './stdlib/lazy'
+import { varFunctions } from './stdlib/vars'
+// --- ASYNC (experimental) ---
+import { asyncFunctions } from './stdlib/async-fns'
+import { v } from './factories'
+import { is } from './assertions'
+import { EvaluationError } from './errors'
+import { cljToJs as cljToJsDeep, jsToClj as jsToCljDeep, type FunctionApplier } from './conversions'
+// --- END ASYNC ---
+
+// ---------------------------------------------------------------------------
+// Native function registry — installed as the initial clojure.core binding
+// set by createRuntime.
+//
+// INTENTIONAL BOOTSTRAP OVERRIDES:
+// Several functions below are redefined by clojure.core.clj after bootstrap.
+// They serve as scaffolding during the bootstrap phase only. The Clojure
+// source versions (lazy / transducer-aware) become authoritative once loaded.
+// Overridden by clojure.core.clj:
+//   concat      → lazy recursive version (shadows eager native)
+//   map         → lazy + transducer 2-arity
+//   filter      → lazy + transducer 2-arity
+//   take        → lazy + stateful transducer
+//   drop        → lazy + stateful transducer
+//   take-while  → lazy + stateless transducer
+//   drop-while  → lazy + stateful transducer
+//   map-indexed → lazy + stateful transducer
+//   keep        → lazy + transducer
+//   keep-indexed→ lazy + stateful transducer
+//   mapcat      → lazy + transducer
+//   partition-by→ lazy + stateful transducer
+//   iterate     → lazy infinite sequence
+//   repeatedly  → lazy infinite sequence
+//   cycle       → lazy infinite sequence
+//   repeat      → lazy infinite (delegates to repeat* for finite arity)
+//   range       → lazy infinite (delegates to range* for finite arity)
+//   into        → 2-arity uses reduce+conj; 3-arity uses transduce
+//   sequence    → materialise via into
+//   completing  → 0-arity init + 1-arity completion wrapper
+//   newline     → redefined as (defn newline [] (println ""))
+//   not         → redefined as pure Clojure (if x false true)
+//   dorun       → redefined in Clojure
+//   doall       → redefined in Clojure
+//
+// Dynamic vars declared here (NOT overridden by clojure.core.clj):
+//   *out*       → nil by default; bound by with-out-str to capture stdout
+//   *err*       → nil by default; bound by with-err-str to capture stderr
+//   *print-length*, *print-level* → print control
+//
+// range* and repeat* are intentionally kept — clojure.core.clj calls them
+// explicitly as private native helpers for finite-arity range/repeat.
+// ---------------------------------------------------------------------------
+
+const nativeFunctions = {
+  ...arithmeticFunctions,
+  ...atomFunctions,
+  ...seqFunctions,
+  ...vectorFunctions,
+  ...mapsSetsFunctions,
+  ...errorFunctions,
+  ...predicateFunctions,
+  ...hofFunctions,
+  ...metaFunctions,
+  ...transducerFunctions,
+  ...regexFunctions,
+  ...stringFunctions,
+  ...utilFunctions,
+  ...varFunctions,
+  ...lazyFunctions,
+  // --- ASYNC (experimental) ---
+  ...asyncFunctions,
+  // --- END ASYNC ---
+}
+
+
+/**
+ * Emit text to the current output channel.
+ * If *out* is dynamically bound to a callable (e.g. inside with-out-str),
+ * invoke it. Otherwise fall back to ctx.io.stdout.
+ *
+ * NOTE: We look up *out* via ctx.resolveNs('clojure.core') rather than
+ * tryLookup(callEnv) because Clojure functions close over the original
+ * snapshot env. After a snapshot restore, those closure envs point to the
+ * old CljVar objects, not the session's freshly cloned ones. resolveNs goes
+ * through the runtime registry and always returns the session's own var.
+ */
+function emitToOut(ctx: EvaluationContext, callEnv: Env, text: string): void {
+  const outVar = ctx.resolveNs('clojure.core')?.vars.get('*out*')
+  const out = outVar ? derefValue(outVar) : undefined
+  if (out && (out.kind === 'function' || out.kind === 'native-function')) {
+    ctx.applyCallable(out, [v.string(text)], callEnv)
+  } else {
+    ctx.io.stdout(text)
+  }
+}
+
+/**
+ * Emit text to the current error channel.
+ * If *err* is dynamically bound to a callable (e.g. inside with-err-str),
+ * invoke it. Otherwise fall back to ctx.io.stderr.
+ * Same snapshot-env rationale as emitToOut.
+ */
+function emitToErr(ctx: EvaluationContext, callEnv: Env, text: string): void {
+  const errVar = ctx.resolveNs('clojure.core')?.vars.get('*err*')
+  const err = errVar ? derefValue(errVar) : undefined
+  if (err && (err.kind === 'function' || err.kind === 'native-function')) {
+    ctx.applyCallable(err, [v.string(text)], callEnv)
+  } else {
+    ctx.io.stderr(text)
+  }
+}
+
+/**
+ * Returns the full clojure.core RuntimeModule.
+ *
+ * IO functions (println, print, newline, pr, prn, pprint) read ctx.io.stdout
+ * at call time instead of closing over an emit callback. This means:
+ * - No output parameter needed here
+ * - Snapshot clones automatically use the correct output without reinstalling
+ *   any IO vars (restoreRuntime no longer needs makeIOModule)
+ */
+export function makeCoreModule(): RuntimeModule {
+  return {
+    id: 'clojure/core',
+    declareNs: [
+      {
+        name: 'clojure.core',
+        vars(_ctx: ModuleContext): VarMap {
+          const map = new Map<string, VarDeclaration>()
+
+          // Pure stdlib functions (all have .meta via .doc())
+          for (const [name, fn] of Object.entries(nativeFunctions)) {
+            const meta = (fn as { meta?: CljMap }).meta
+            map.set(name, { value: fn, ...(meta ? { meta } : {}) })
+          }
+
+          // IO functions — route through emitToOut/emitToErr so that
+          // *out*/*err* dynamic bindings (e.g. inside with-out-str) are honoured.
+          map.set('println', {
+            value: v.nativeFnCtx(
+              'println',
+              (ctx, callEnv, ...args: CljValue[]) => {
+                withPrintContext(buildPrintContext(ctx), () => {
+                  emitToOut(
+                    ctx,
+                    callEnv,
+                    args.map(valueToString).join(' ') + '\n'
+                  )
+                })
+                return v.nil()
+              }
+            ),
+          })
+          map.set('print', {
+            value: v.nativeFnCtx(
+              'print',
+              (ctx, callEnv, ...args: CljValue[]) => {
+                withPrintContext(buildPrintContext(ctx), () => {
+                  emitToOut(ctx, callEnv, args.map(valueToString).join(' '))
+                })
+                return v.nil()
+              }
+            ),
+          })
+          map.set('newline', {
+            value: v.nativeFnCtx('newline', (ctx, callEnv) => {
+              emitToOut(ctx, callEnv, '\n')
+              return v.nil()
+            }),
+          })
+          map.set('pr', {
+            value: v.nativeFnCtx('pr', (ctx, callEnv, ...args: CljValue[]) => {
+              withPrintContext(buildPrintContext(ctx), () => {
+                emitToOut(
+                  ctx,
+                  callEnv,
+                  args.map((v) => printString(v)).join(' ')
+                )
+              })
+              return v.nil()
+            }),
+          })
+          map.set('prn', {
+            value: v.nativeFnCtx('prn', (ctx, callEnv, ...args: CljValue[]) => {
+              withPrintContext(buildPrintContext(ctx), () => {
+                emitToOut(
+                  ctx,
+                  callEnv,
+                  args.map((v) => printString(v)).join(' ') + '\n'
+                )
+              })
+              return v.nil()
+            }),
+          })
+          map.set('pprint', {
+            value: v.nativeFnCtx(
+              'pprint',
+              (ctx, callEnv, form: CljValue, widthArg?: CljValue) => {
+                if (form === undefined) return v.nil()
+                const maxWidth =
+                  widthArg?.kind === 'number' ? widthArg.value : 80
+                withPrintContext(buildPrintContext(ctx), () => {
+                  emitToOut(
+                    ctx,
+                    callEnv,
+                    prettyPrintString(form, maxWidth) + '\n'
+                  )
+                })
+                return v.nil()
+              }
+            ),
+          })
+          map.set('warn', {
+            value: v.nativeFnCtx(
+              'warn',
+              (ctx, callEnv, ...args: CljValue[]) => {
+                withPrintContext(buildPrintContext(ctx), () => {
+                  emitToErr(
+                    ctx,
+                    callEnv,
+                    args.map(valueToString).join(' ') + '\n'
+                  )
+                })
+                return v.nil()
+              }
+            ),
+          })
+
+          // Dynamic output-channel vars. IO functions check these first before
+          // falling back to ctx.io.stdout / ctx.io.stderr. Bound by with-out-str
+          // and with-err-str macros defined in clojure.core.
+          map.set('*out*', { value: v.nil(), dynamic: true })
+          map.set('*err*', { value: v.nil(), dynamic: true })
+
+          // Dynamic print-control vars
+          map.set('*print-length*', { value: v.nil(), dynamic: true })
+          map.set('*print-level*', { value: v.nil(), dynamic: true })
+
+          // Compatibility var for IDE tooling
+          map.set('*compiler-options*', { value: v.map([]) })
+
+          // JS interop — deep conversion functions
+          map.set('clj->js', {
+            value: v.nativeFnCtx('clj->js', (ctx: EvaluationContext, callEnv: Env, val: CljValue) => {
+              if (is.jsValue(val)) return val
+              const applier: FunctionApplier = {
+                applyFunction: (fn, args) => ctx.applyCallable(fn, args, callEnv),
+              }
+              return v.jsValue(cljToJsDeep(val, applier))
+            }),
+          })
+
+          map.set('js->clj', {
+            value: v.nativeFn('js->clj', (val: CljValue, opts?: CljValue) => {
+              if (val.kind === 'nil') return val
+              if (!is.jsValue(val)) {
+                throw new EvaluationError(
+                  `js->clj expects a js-value, got ${val.kind}`,
+                  { val }
+                )
+              }
+              const keywordizeKeys = (() => {
+                if (!opts || opts.kind !== 'map') return false
+                for (const [k, flag] of opts.entries) {
+                  if (k.kind === 'keyword' && k.name === ':keywordize-keys') {
+                    return flag.kind !== 'boolean' || flag.value !== false
+                  }
+                }
+                return false
+              })()
+              return jsToCljDeep(val.value, { keywordizeKeys })
+            }),
+          })
+
+          return map
+        },
+      },
+    ],
+  }
+}

package/src/core/env.ts

@@ -1,6 +1,6 @@
 import { EvaluationError } from './errors'
 import type { CljNamespace, CljMap, CljValue, CljVar, Env } from './types'
-import { cljVar } from './factories'
+import { v } from './factories'
 
 class EnvError extends Error {
   context: any
@@ -20,7 +20,13 @@ export function derefValue(val: CljValue): CljValue {
 }
 
 export function makeNamespace(name: string): CljNamespace {
-  return { name, vars: new Map(), aliases: new Map(), readerAliases: new Map() }
+  return {
+    kind: 'namespace',
+    name,
+    vars: new Map(),
+    aliases: new Map(),
+    readerAliases: new Map(),
+  }
 }
 
 export function makeEnv(outer?: Env): Env {
@@ -34,8 +40,11 @@ export function lookup(name: string, env: Env): CljValue {
   let current: Env | null = env
   while (current) {
     const raw = current.bindings.get(name)
-    if (raw !== undefined) return derefValue(raw)
+    // Local bindings are stored as plain values — do NOT auto-deref.
+    // A var stored in a local binding (e.g. from `(var foo)`) is a first-class value.
+    if (raw !== undefined) return raw
     const v = current.ns?.vars.get(name)
+    // Namespace vars are always auto-deref'd: `foo` resolves to the var's current value.
     if (v !== undefined) return derefValue(v)
     current = current.outer
   }
@@ -46,7 +55,7 @@ export function tryLookup(name: string, env: Env): CljValue | undefined {
   let current: Env | null = env
   while (current) {
     const raw = current.bindings.get(name)
-    if (raw !== undefined) return derefValue(raw)
+    if (raw !== undefined) return raw
     const v = current.ns?.vars.get(name)
     if (v !== undefined) return derefValue(v)
     current = current.outer
@@ -59,14 +68,19 @@ export function tryLookup(name: string, env: Env): CljValue | undefined {
  * Re-def: mutates the existing var's value in place.
  * New def: creates a new CljVar and stores it in ns.vars.
  */
-export function internVar(name: string, value: CljValue, nsEnv: Env, meta?: CljMap) {
+export function internVar(
+  name: string,
+  value: CljValue,
+  nsEnv: Env,
+  meta?: CljMap
+) {
   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))
+    ns.vars.set(name, v.var(ns.name, name, value, meta))
   }
 }
 

package/src/core/evaluator/apply.ts

@@ -1,4 +1,4 @@
-import { isAFunction, isEqual, isKeyword, isMap } from '../assertions'
+import { is } from '../assertions'
 import { EvaluationError } from '../errors'
 import { cljNil } from '../factories'
 import { printString } from '../printer'
@@ -11,6 +11,7 @@ import type {
   EvaluationContext,
 } from '../types'
 import { bindParams, RecurSignal, resolveArity } from './arity'
+import { cljToJs, jsToClj } from './js-interop'
 
 export function applyFunctionWithContext(
   fn: CljFunction | CljNativeFunction,
@@ -58,6 +59,23 @@ export function applyFunctionWithContext(
   )
 }
 
+export function applyMacroWithContext(
+  macro: CljMacro,
+  rawArgs: CljValue[],
+  ctx: EvaluationContext
+): CljValue {
+  const arity = resolveArity(macro.arities, rawArgs.length)
+  const localEnv = bindParams(
+    arity.params,
+    arity.restParam,
+    rawArgs,
+    macro.env,
+    ctx,
+    macro.env
+  )
+  return ctx.evaluateForms(arity.body, localEnv)
+}
+
 /**
  * Invokes any IFn value — functions, native functions, keywords, and maps.
  * Used by comp, partial, and any other HOF that needs to call an arbitrary
@@ -69,25 +87,39 @@ export function applyCallableWithContext(
   ctx: EvaluationContext,
   callEnv: Env
 ): CljValue {
-  if (isAFunction(fn)) {
+  if (is.aFunction(fn)) {
     return applyFunctionWithContext(fn, args, ctx, callEnv)
   }
-  if (isKeyword(fn)) {
+  if (is.jsValue(fn)) {
+    if (typeof fn.value !== 'function') {
+      throw new EvaluationError(
+        `js-value is not callable: ${typeof fn.value}`,
+        { fn, args }
+      )
+    }
+    const jsArgs = args.map((a) => cljToJs(a, ctx, callEnv))
+    const rawResult = (fn.value as (...a: unknown[]) => unknown)(...jsArgs)
+    return jsToClj(rawResult)
+  }
+  if (is.keyword(fn)) {
     const target = args[0]
     const defaultVal = args.length > 1 ? args[1] : cljNil()
-    if (isMap(target)) {
-      const entry = target.entries.find(([k]) => isEqual(k, fn))
+    if (is.map(target)) {
+      const entry = target.entries.find(([k]) => is.equal(k, fn))
       return entry ? entry[1] : defaultVal
     }
     return defaultVal
   }
-  if (isMap(fn)) {
+  if (is.map(fn)) {
     if (args.length === 0) {
-      throw new EvaluationError('Map used as function requires at least one argument', { fn, args })
+      throw new EvaluationError(
+        'Map used as function requires at least one argument',
+        { fn, args }
+      )
     }
     const key = args[0]
     const defaultVal = args.length > 1 ? args[1] : cljNil()
-    const entry = fn.entries.find(([k]) => isEqual(k, key))
+    const entry = fn.entries.find(([k]) => is.equal(k, key))
     return entry ? entry[1] : defaultVal
   }
   throw new EvaluationError(`${printString(fn)} is not a callable value`, {
@@ -95,20 +127,3 @@ export function applyCallableWithContext(
     args,
   })
 }
-
-export function applyMacroWithContext(
-  macro: CljMacro,
-  rawArgs: CljValue[],
-  ctx: EvaluationContext
-): CljValue {
-  const arity = resolveArity(macro.arities, rawArgs.length)
-  const localEnv = bindParams(
-    arity.params,
-    arity.restParam,
-    rawArgs,
-    macro.env,
-    ctx,
-    macro.env
-  )
-  return ctx.evaluateForms(arity.body, localEnv)
-}

package/src/core/evaluator/arity.ts

@@ -1,4 +1,4 @@
-import { isList, isMap, isSymbol, isVector } from '../assertions'
+import { is } from '../assertions'
 import { extend } from '../env'
 import { EvaluationError } from '../errors'
 import { cljList, cljNil } from '../factories'
@@ -23,14 +23,14 @@ export function parseParamVector(
   args: CljVector,
   env: Env
 ): { params: DestructurePattern[]; restParam: DestructurePattern | null } {
-  const ampIdx = args.value.findIndex((a) => isSymbol(a) && a.name === '&')
+  const ampIdx = args.value.findIndex((a) => is.symbol(a) && a.name === '&')
   let params: DestructurePattern[] = []
   let restParam: DestructurePattern | null = null
   if (ampIdx === -1) {
     params = args.value as DestructurePattern[]
   } else {
     const ampsCount = args.value.filter(
-      (a) => isSymbol(a) && a.name === '&'
+      (a) => is.symbol(a) && a.name === '&'
     ).length
     if (ampsCount > 1) {
       throw new EvaluationError('& can only appear once', { args, env })
@@ -58,23 +58,23 @@ export function parseArities(forms: CljValue[], env: Env): Arity[] {
     )
   }
 
-  if (isVector(forms[0])) {
+  if (is.vector(forms[0])) {
     const paramVec = forms[0]
     const { params, restParam } = parseParamVector(paramVec, env)
     return [{ params, restParam, body: forms.slice(1) }]
   }
 
-  if (isList(forms[0])) {
+  if (is.list(forms[0])) {
     const arities: Arity[] = []
     for (const form of forms) {
-      if (!isList(form) || form.value.length === 0) {
+      if (!is.list(form) || form.value.length === 0) {
         throw new EvaluationError(
           'Multi-arity clause must be a list starting with a parameter vector',
           { form, env }
         )
       }
       const paramVec = form.value[0]
-      if (!isVector(paramVec)) {
+      if (!is.vector(paramVec)) {
         throw new EvaluationError(
           'First element of arity clause must be a parameter vector',
           { paramVec, env }
@@ -134,7 +134,7 @@ export function bindParams(
   if (restParam !== null) {
     const restArgs = args.slice(params.length)
     let restValue: CljValue
-    if (isMap(restParam) && restArgs.length > 0) {
+    if (is.map(restParam) && restArgs.length > 0) {
       const entries: [CljValue, CljValue][] = []
       for (let i = 0; i < restArgs.length; i += 2) {
         entries.push([restArgs[i], restArgs[i + 1] ?? cljNil()])