conjure-js 0.0.13 → 0.0.14

package/src/core/modules/core/index.ts

@@ -0,0 +1,131 @@
+import type {
+  RuntimeModule,
+  VarDeclaration,
+  VarMap,
+  ModuleContext,
+} from '../../module'
+import type { CljMap } 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 { printFunctions, printVars } from './stdlib/print'
+// --- 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,
+  ...printFunctions,
+  // --- ASYNC (experimental) ---
+  ...asyncFunctions,
+  // --- END ASYNC ---
+}
+
+const nativeDynamicVars = {
+  ...printVars,
+}
+
+/**
+ * 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 } : {}) })
+          }
+
+          // Dynamic vars
+          for (const [name, value] of Object.entries(nativeDynamicVars)) {
+            map.set(name, { value, dynamic: true })
+          }
+
+          return map
+        },
+      },
+    ],
+  }
+}

package/src/core/{stdlib → modules/core/stdlib}/arithmetic.ts

@@ -1,9 +1,9 @@
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import { toSeq } from '../transformations'
-import type { CljList, CljNumber, CljValue, CljVector } from '../types'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
+import { toSeq } from '../../../transformations'
+import type { CljList, CljNumber, CljValue, CljVector } from '../../../types'
 
 export const arithmeticFunctions: Record<string, CljValue> = {
   '+': v

package/src/core/{stdlib → modules/core/stdlib}/async-fns.ts

@@ -4,12 +4,12 @@
  * To revert: delete this file and remove the import from core-module.ts.
  */
 
-import { v } from '../factories'
-import { CljThrownSignal, EvaluationError } from '../errors'
-import { is } from '../assertions'
-import { printString } from '../printer'
-import { toSeq } from '../transformations'
-import type { EvaluationContext, CljValue, Env } from '../types'
+import { v } from '../../../factories'
+import { CljThrownSignal, EvaluationError } from '../../../errors'
+import { is } from '../../../assertions'
+import { printString } from '../../../printer'
+import { toSeq } from '../../../transformations'
+import type { EvaluationContext, CljValue, Env } from '../../../types'
 
 export const asyncFunctions: Record<string, CljValue> = {
   // (then val f) — apply f when resolved, or immediately if val is not pending

package/src/core/{stdlib → modules/core/stdlib}/atoms.ts

@@ -1,20 +1,20 @@
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import { realizeDelay } from '../transformations'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
+import { realizeDelay } from '../../../transformations'
 import type {
   CljAtom,
   CljFunction,
   CljNativeFunction,
   CljValue,
   Env,
-} from '../types'
+} from '../../../types'
 
 function validateAtom(
   a: CljAtom,
   newVal: CljValue,
-  ctx: import('../types').EvaluationContext,
+  ctx: import('../../../types').EvaluationContext,
   callEnv: Env
 ) {
   if (a.validator && is.aFunction(a.validator)) {

package/src/core/{stdlib → modules/core/stdlib}/errors.ts

@@ -1,7 +1,7 @@
-import { CljThrownSignal, EvaluationError } from '../errors'
-import { v } from '../factories'
-import { is } from '../assertions'
-import type { CljValue } from '../types'
+import { CljThrownSignal, EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { is } from '../../../assertions'
+import type { CljValue } from '../../../types'
 
 export const errorFunctions = {
   throw: v

package/src/core/{stdlib → modules/core/stdlib}/hof.ts

@@ -1,11 +1,11 @@
 // Higher-order functions: map, filter, reduce, apply, partial, comp,
 // map-indexed, identity
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import { toSeq } from '../transformations'
-import type { CljValue, Env, EvaluationContext } from '../types'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
+import { toSeq } from '../../../transformations'
+import type { CljValue, Env, EvaluationContext } from '../../../types'
 
 export const hofFunctions: Record<string, CljValue> = {
   reduce: v

package/src/core/{stdlib → modules/core/stdlib}/lazy.ts

@@ -1,7 +1,7 @@
-import { is } from '../assertions'
-import { v } from '../factories'
-import { realizeDelay, realizeLazySeq } from '../transformations'
-import type { CljValue } from '../types'
+import { is } from '../../../assertions'
+import { v } from '../../../factories'
+import { realizeDelay, realizeLazySeq } from '../../../transformations'
+import type { CljValue } from '../../../types'
 
 export const lazyFunctions = {
   force: v

package/src/core/{stdlib → modules/core/stdlib}/maps-sets.ts

@@ -5,12 +5,12 @@
 // here because their primary semantic is associative (key→value update/remove);
 // the vector branch is an edge case within the same dispatch.
 
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import { toSeq } from '../transformations'
-import { type CljNumber, type CljValue } from '../types'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
+import { toSeq } from '../../../transformations'
+import { type CljNumber, type CljValue } from '../../../types'
 
 export const mapsSetsFunctions: Record<string, CljValue> = {
   'hash-map': v

package/src/core/{stdlib → modules/core/stdlib}/meta.ts

@@ -1,15 +1,15 @@
 // Metadata: with-meta, meta, alter-meta!
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
 import type {
   CljAtom,
   CljMap,
   CljValue,
   Env,
   EvaluationContext,
-} from '../types'
+} from '../../../types'
 
 export const metaFunctions: Record<string, CljValue> = {
   meta: v

package/src/core/{stdlib → modules/core/stdlib}/predicates.ts

@@ -1,12 +1,12 @@
 // Predicates & logical: nil?, true?, false?, truthy?, falsy?, not, not=,
 // number?, string?, boolean?, vector?, list?, map?, keyword?, symbol?, fn?,
 // coll?, some, every?
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import { toSeq } from '../transformations'
-import type { CljNumber, CljValue, Env, EvaluationContext } from '../types'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
+import { toSeq } from '../../../transformations'
+import type { CljNumber, CljValue, Env, EvaluationContext } from '../../../types'
 
 export const predicateFunctions: Record<string, CljValue> = {
   'nil?': v
@@ -287,7 +287,7 @@ export const predicateFunctions: Record<string, CljValue> = {
       return v.boolean(
         x !== undefined &&
           x.kind === 'number' &&
-          Number.isInteger((x as import('../types').CljNumber).value)
+          Number.isInteger((x as import('../../../types').CljNumber).value)
       )
     })
     .doc('Return true if x is a fixed precision integer.', [['x']]),

package/src/core/modules/core/stdlib/print.ts

@@ -0,0 +1,108 @@
+import { derefValue } from '../../../env'
+import { v } from '../../../factories'
+import {
+  buildPrintContext,
+  prettyPrintString,
+  printString,
+  withPrintContext,
+} from '../../../printer'
+import { valueToString } from '../../../transformations'
+import type { CljValue, Env, EvaluationContext } from '../../../types'
+
+/**
+ * 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)
+  }
+}
+
+export const printFunctions: Record<string, CljValue> = {
+  println: v.nativeFnCtx('println', (ctx, callEnv, ...args: CljValue[]) => {
+    withPrintContext(buildPrintContext(ctx), () => {
+      emitToOut(ctx, callEnv, args.map(valueToString).join(' ') + '\n')
+    })
+    return v.nil()
+  }),
+  print: v.nativeFnCtx('print', (ctx, callEnv, ...args: CljValue[]) => {
+    withPrintContext(buildPrintContext(ctx), () => {
+      emitToOut(ctx, callEnv, args.map(valueToString).join(' '))
+    })
+    return v.nil()
+  }),
+  newline: v.nativeFnCtx('newline', (ctx, callEnv) => {
+    emitToOut(ctx, callEnv, '\n')
+    return v.nil()
+  }),
+  pr: v.nativeFnCtx('pr', (ctx, callEnv, ...args: CljValue[]) => {
+    withPrintContext(buildPrintContext(ctx), () => {
+      emitToOut(ctx, callEnv, args.map((v) => printString(v)).join(' '))
+    })
+    return v.nil()
+  }),
+  prn: v.nativeFnCtx('prn', (ctx, callEnv, ...args: CljValue[]) => {
+    withPrintContext(buildPrintContext(ctx), () => {
+      emitToOut(ctx, callEnv, args.map((v) => printString(v)).join(' ') + '\n')
+    })
+    return v.nil()
+  }),
+  pprint: 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()
+    }
+  ),
+  warn: v.nativeFnCtx('warn', (ctx, callEnv, ...args: CljValue[]) => {
+    withPrintContext(buildPrintContext(ctx), () => {
+      emitToErr(ctx, callEnv, args.map(valueToString).join(' ') + '\n')
+    })
+    return v.nil()
+  }),
+}
+
+export const printVars: Record<string, CljValue> = {
+  // 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.
+  '*out*': v.nil(),
+  '*err*': v.nil(),
+  // Dynamic print-control vars
+  '*print-length*': v.nil(),
+  '*print-level*': v.nil(),
+  // Compatibility var for IDE tooling
+  '*compiler-options*': v.map([]),
+}

package/src/core/{stdlib → modules/core/stdlib}/regex.ts

@@ -1,10 +1,10 @@
 // Regex stdlib: regexp?, re-pattern, re-find, re-matches, re-seq
 // Also exports str-split* used internally by clojure.string/split.
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import type { CljRegex, CljValue } from '../types'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
+import type { CljRegex, CljValue } from '../../../types'
 
 // ---------------------------------------------------------------------------
 // Inline-flag extraction

package/src/core/{stdlib → modules/core/stdlib}/seq.ts

@@ -6,13 +6,12 @@
 // construction protocol (prepend for lists, append for vectors, kv-pair for maps,
 // element dedup for sets).
 
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import { realizeLazySeq, toSeq } from '../transformations'
+import { is } from '../../../assertions.ts'
+import { EvaluationError } from '../../../errors.ts'
+import { v } from '../../../factories.ts'
+import { printString } from '../../../printer.ts'
+import { realizeLazySeq, toSeq } from '../../../transformations.ts'
 import {
-  valueKeywords,
   type CljList,
   type CljMap,
   type CljNumber,
@@ -20,7 +19,8 @@ import {
   type CljString,
   type CljValue,
   type CljVector,
-} from '../types'
+} from '../../../types.ts'
+import { valueKeywords } from '../../../keywords.ts'
 
 export const seqFunctions: Record<string, CljValue> = {
   list: v

package/src/core/{stdlib → modules/core/stdlib}/strings.ts

@@ -1,10 +1,10 @@
 // Native string helpers used by clojure.string.
 // All public API lives in src/clojure/string.clj; these are private helpers.
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import { valueToString } from '../transformations'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
+import { valueToString } from '../../../transformations'
 import type {
   CljFunction,
   CljNativeFunction,
@@ -12,7 +12,7 @@ import type {
   CljValue,
   Env,
   EvaluationContext,
-} from '../types'
+} from '../../../types'
 
 // ---------------------------------------------------------------------------
 // Internal helpers

package/src/core/{stdlib → modules/core/stdlib}/transducers.ts

@@ -1,17 +1,17 @@
 // Transducer protocol primitives: reduced, volatile!, transduce
 
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { joinLines, printString } from '../printer'
-import { toSeq } from '../transformations'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { joinLines, printString } from '../../../printer'
+import { toSeq } from '../../../transformations'
 import type {
   CljFunction,
   CljNativeFunction,
   CljValue,
   Env,
   EvaluationContext,
-} from '../types'
+} from '../../../types'
 
 export const transducerFunctions: Record<string, CljValue> = {
   // ── Reduced sentinel ────────────────────────────────────────────────────

package/src/core/{stdlib → modules/core/stdlib}/utils.ts

@@ -1,15 +1,15 @@
 // Miscellaneous utilities: str, type, gensym, eval, macroexpand-1, macroexpand,
 // namespace, name, keyword
-import { is } from '../assertions'
-import { tryLookup } from '../env'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { makeGensym } from '../gensym'
-import { buildPrintContext, joinLines, prettyPrintString, printString, withPrintContext } from '../printer'
-import { readForms } from '../reader'
-import { tokenize } from '../tokenizer'
-import { valueToString } from '../transformations'
-import type { CljValue, Env, EvaluationContext } from '../types'
+import { is } from '../../../assertions'
+import { tryLookup } from '../../../env'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { makeGensym } from '../../../gensym'
+import { buildPrintContext, joinLines, prettyPrintString, printString, withPrintContext } from '../../../printer'
+import { readForms } from '../../../reader'
+import { tokenize } from '../../../tokenizer'
+import { valueToString } from '../../../transformations'
+import type { CljValue, Env, EvaluationContext } from '../../../types'
 
 export const utilFunctions: Record<string, CljValue> = {
   str: v

package/src/core/{stdlib → modules/core/stdlib}/vars.ts

@@ -1,7 +1,7 @@
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import type { CljValue } from '../types'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import type { CljValue } from '../../../types'
 
 export const varFunctions: Record<string, CljValue> = {
   'var?': v

package/src/core/{stdlib → modules/core/stdlib}/vectors.ts

@@ -3,12 +3,12 @@
 // These functions are exclusively concerned with vectors (or lists treated as
 // a stack for peek/pop). Pure vector construction and stack operations.
 
-import { is } from '../assertions'
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { printString } from '../printer'
-import { toSeq } from '../transformations'
-import { type CljValue } from '../types'
+import { is } from '../../../assertions'
+import { EvaluationError } from '../../../errors'
+import { v } from '../../../factories'
+import { printString } from '../../../printer'
+import { toSeq } from '../../../transformations'
+import { type CljValue } from '../../../types'
 
 export const vectorFunctions: Record<string, CljValue> = {
   vector: v