conjure-js 0.0.13 → 0.0.14

package/src/core/core-module.ts

@@ -1,303 +0,0 @@
-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/stdlib/js-namespace.ts

@@ -1,344 +0,0 @@
-// js namespace — ambient JS interop utilities.
-// Installed automatically alongside clojure.core. No explicit require needed.
-// Users inject host globals (js/Math, js/console, etc.) via createSession({ hostBindings }).
-import { EvaluationError } from '../errors'
-import { v } from '../factories'
-import { cljToJs, jsToClj } from '../evaluator/js-interop'
-import type { RuntimeModule, VarMap } from '../module'
-import type { CljValue, Env, EvaluationContext } from '../types'
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Convert a Clojure key value to a JS object key string.
- * Strings, keywords, and numbers are allowed — JS coerces numbers anyway.
- */
-function resolveJsKey(key: CljValue, fnName: string): string {
-  if (key.kind === 'string') return key.value
-  if (key.kind === 'keyword') return key.name.slice(1) // strip leading ':'
-  if (key.kind === 'number') return String(key.value)  // JS coerces obj[0] to obj["0"]
-  throw new EvaluationError(
-    `${fnName}: key must be a string, keyword, or number, got ${key.kind}`,
-    { key }
-  )
-}
-
-/**
- * Extract the raw value from a target CljValue for use in js/get and js/set!.
- * Mirrors extractRawTarget in js-interop.ts: CljJsValue, CljString, CljNumber,
- * CljBoolean are all valid targets — JS auto-boxes primitives for property access.
- * Nil and other Clojure types are rejected.
- */
-function extractJsTarget(val: CljValue, fnName: string): unknown {
-  switch (val.kind) {
-    case 'js-value': return val.value
-    case 'string':
-    case 'number':
-    case 'boolean': return val.value
-    case 'nil':
-      throw new EvaluationError(
-        `${fnName}: cannot access properties on nil`,
-        { val }
-      )
-    default:
-      throw new EvaluationError(
-        `${fnName}: expected a js-value or primitive, got ${val.kind}`,
-        { val }
-      )
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Module
-// ---------------------------------------------------------------------------
-
-export function makeJsModule(): RuntimeModule {
-  return {
-    id: 'conjure-js/js-namespace',
-    declareNs: [
-      {
-        name: 'js',
-        vars(_ctx): VarMap {
-          const map = new Map<string, { value: CljValue }>()
-
-          // (js/get obj key) / (js/get obj key not-found)
-          // Dynamic property access. Primitives (string, number, boolean) are valid
-          // targets — same auto-boxing JS applies. Optional not-found default is returned
-          // when the property is absent (undefined), allowing idiomatic nil defaults.
-          map.set('get', {
-            value: v.nativeFn('js/get', (obj: CljValue, key: CljValue, ...rest: CljValue[]) => {
-              const raw = extractJsTarget(obj, 'js/get') as Record<string, unknown>
-              const jsKey = resolveJsKey(key, 'js/get')
-              const result = raw[jsKey]
-              if (result === undefined && rest.length > 0) return rest[0]
-              return jsToClj(result)
-            }),
-          })
-
-          // (js/set! obj key val) — mutate a property; returns val
-          map.set('set!', {
-            value: v.nativeFnCtx(
-              'js/set!',
-              (ctx: EvaluationContext, callEnv: Env, obj: CljValue, key: CljValue, val: CljValue) => {
-                const raw = extractJsTarget(obj, 'js/set!') as Record<string, unknown>
-                const jsKey = resolveJsKey(key, 'js/set!')
-                raw[jsKey] = cljToJs(val, ctx, callEnv)
-                return val
-              }
-            ),
-          })
-
-          // (js/call fn & args) — call a JS function with no this binding
-          map.set('call', {
-            value: v.nativeFnCtx(
-              'js/call',
-              (ctx: EvaluationContext, callEnv: Env, fn: CljValue, ...args: CljValue[]) => {
-                const rawFn = fn.kind === 'js-value' ? fn.value : undefined
-                if (typeof rawFn !== 'function') {
-                  throw new EvaluationError(
-                    `js/call: expected a js-value wrapping a function, got ${fn.kind}`,
-                    { fn }
-                  )
-                }
-                const jsArgs = args.map((a) => cljToJs(a, ctx, callEnv))
-                return jsToClj((rawFn as (...a: unknown[]) => unknown)(...jsArgs))
-              }
-            ),
-          })
-
-          // (js/typeof x) — typeof equivalent for CljValues.
-          // Clojure primitives have unambiguous JS typeof values; js-value delegates to
-          // the raw typeof. Functions and other Clojure types throw — they're not at the
-          // JS boundary.
-          map.set('typeof', {
-            value: v.nativeFn('js/typeof', (x: CljValue) => {
-              switch (x.kind) {
-                case 'nil':     return v.string('object')   // typeof null === 'object'
-                case 'number':  return v.string('number')
-                case 'string':  return v.string('string')
-                case 'boolean': return v.string('boolean')
-                case 'js-value': return v.string(typeof x.value)
-                default:
-                  throw new EvaluationError(
-                    `js/typeof: cannot determine JS type of Clojure ${x.kind}`,
-                    { x }
-                  )
-              }
-            }),
-          })
-
-          // (js/instanceof? obj cls) — obj instanceof cls
-          map.set('instanceof?', {
-            value: v.nativeFn('js/instanceof?', (obj: CljValue, cls: CljValue) => {
-              if (obj.kind !== 'js-value') {
-                throw new EvaluationError(
-                  `js/instanceof?: expected js-value, got ${obj.kind}`,
-                  { obj }
-                )
-              }
-              if (cls.kind !== 'js-value') {
-                throw new EvaluationError(
-                  `js/instanceof?: expected js-value constructor, got ${cls.kind}`,
-                  { cls }
-                )
-              }
-              return v.boolean(
-                obj.value instanceof (cls.value as new (...a: unknown[]) => unknown)
-              )
-            }),
-          })
-
-          // (js/array? x) — Array.isArray on the raw value
-          map.set('array?', {
-            value: v.nativeFn('js/array?', (x: CljValue) => {
-              if (x.kind !== 'js-value') return v.boolean(false)
-              return v.boolean(Array.isArray(x.value))
-            }),
-          })
-
-          // (js/null? x) — true if x is nil (JS null comes in as CljNil)
-          map.set('null?', {
-            value: v.nativeFn('js/null?', (x: CljValue) => {
-              return v.boolean(x.kind === 'nil')
-            }),
-          })
-
-          // (js/undefined? x) — true if x is CljJsValue wrapping undefined
-          map.set('undefined?', {
-            value: v.nativeFn('js/undefined?', (x: CljValue) => {
-              return v.boolean(x.kind === 'js-value' && x.value === undefined)
-            }),
-          })
-
-          // (js/some? x) — true if x is neither null (nil) nor undefined
-          map.set('some?', {
-            value: v.nativeFn('js/some?', (x: CljValue) => {
-              if (x.kind === 'nil') return v.boolean(false)
-              if (x.kind === 'js-value' && x.value === undefined) return v.boolean(false)
-              return v.boolean(true)
-            }),
-          })
-
-          // (js/get-in obj path) / (js/get-in obj path not-found)
-          // Deep property access. path must be a CljVector of string/keyword/number keys.
-          map.set('get-in', {
-            value: v.nativeFn('js/get-in', (obj: CljValue, path: CljValue, ...rest: CljValue[]) => {
-              if (path.kind !== 'vector') {
-                throw new EvaluationError(
-                  `js/get-in: path must be a vector, got ${path.kind}`,
-                  { path }
-                )
-              }
-              // Validate root eagerly — nil root is always an error
-              if (obj.kind === 'nil') {
-                throw new EvaluationError(
-                  'js/get-in: cannot access properties on nil',
-                  { obj }
-                )
-              }
-              const notFound = rest.length > 0 ? rest[0] : v.jsValue(undefined)
-              let current: CljValue = obj
-              for (const key of path.value) {
-                if (current.kind === 'nil') return notFound
-                if (current.kind === 'js-value' && current.value === undefined) return notFound
-                const raw = extractJsTarget(current, 'js/get-in') as Record<string, unknown>
-                const jsKey = resolveJsKey(key, 'js/get-in')
-                current = jsToClj((raw as Record<string, unknown>)[jsKey])
-              }
-              if (current.kind === 'js-value' && current.value === undefined && rest.length > 0) {
-                return notFound
-              }
-              return current
-            }),
-          })
-
-          // (js/prop key) / (js/prop key not-found)
-          // Returns a single-arg function that reads the given property from an object.
-          // Use with map/filter: (map (js/prop "name") users)
-          map.set('prop', {
-            value: v.nativeFn('js/prop', (key: CljValue, ...rest: CljValue[]) => {
-              const notFound = rest.length > 0 ? rest[0] : v.nil()
-              return v.nativeFn('js/prop-accessor', (obj: CljValue) => {
-                const raw = extractJsTarget(obj, 'js/prop') as Record<string, unknown>
-                const jsKey = resolveJsKey(key, 'js/prop')
-                const result = raw[jsKey]
-                if (result === undefined) return notFound
-                return jsToClj(result)
-              })
-            }),
-          })
-
-          // (js/method key & partialArgs)
-          // Returns a function that calls the named method on an object, prepending any partial args.
-          // (map (js/method "trim") strings)
-          // (map (js/method "toFixed" 2) numbers)
-          map.set('method', {
-            value: v.nativeFn('js/method', (key: CljValue, ...partialArgs: CljValue[]) => {
-              return v.nativeFnCtx(
-                'js/method-caller',
-                (ctx: EvaluationContext, callEnv: Env, obj: CljValue, ...callArgs: CljValue[]) => {
-                  const rawObj = extractJsTarget(obj, 'js/method') as Record<string, unknown>
-                  const jsKey = resolveJsKey(key, 'js/method')
-                  const method = rawObj[jsKey]
-                  if (typeof method !== 'function') {
-                    throw new EvaluationError(
-                      `js/method: property '${jsKey}' is not callable`,
-                      { jsKey }
-                    )
-                  }
-                  const allArgs = [...partialArgs, ...callArgs].map((a) => cljToJs(a, ctx, callEnv))
-                  return jsToClj((method as (...a: unknown[]) => unknown).apply(rawObj, allArgs))
-                }
-              )
-            }),
-          })
-
-          // (js/merge obj1 obj2 ...) — Object.assign into a fresh object
-          map.set('merge', {
-            value: v.nativeFnCtx(
-              'js/merge',
-              (ctx: EvaluationContext, callEnv: Env, ...args: CljValue[]) => {
-                const result = Object.assign({}, ...args.map((a) => cljToJs(a, ctx, callEnv)))
-                return v.jsValue(result)
-              }
-            ),
-          })
-
-          // (js/seq arr) — JS array → Clojure vector with elements converted via jsToClj
-          map.set('seq', {
-            value: v.nativeFn('js/seq', (arr: CljValue) => {
-              if (arr.kind !== 'js-value' || !Array.isArray(arr.value)) {
-                throw new EvaluationError(
-                  `js/seq: expected a js-value wrapping an array, got ${arr.kind}`,
-                  { arr }
-                )
-              }
-              return v.vector((arr.value as unknown[]).map(jsToClj))
-            }),
-          })
-
-          // (js/array & args) — variadic args → JS array as CljJsValue
-          map.set('array', {
-            value: v.nativeFnCtx(
-              'js/array',
-              (ctx: EvaluationContext, callEnv: Env, ...args: CljValue[]) => {
-                return v.jsValue(args.map((a) => cljToJs(a, ctx, callEnv)))
-              }
-            ),
-          })
-
-          // (js/obj key val key val ...) — variadic key-val pairs → JS plain object as CljJsValue
-          map.set('obj', {
-            value: v.nativeFnCtx(
-              'js/obj',
-              (ctx: EvaluationContext, callEnv: Env, ...args: CljValue[]) => {
-                if (args.length % 2 !== 0) {
-                  throw new EvaluationError(
-                    'js/obj: requires even number of arguments',
-                    { count: args.length }
-                  )
-                }
-                const result: Record<string, unknown> = {}
-                for (let i = 0; i < args.length; i += 2) {
-                  const jsKey = resolveJsKey(args[i], 'js/obj')
-                  result[jsKey] = cljToJs(args[i + 1], ctx, callEnv)
-                }
-                return v.jsValue(result)
-              }
-            ),
-          })
-
-          // (js/keys obj) — Object.keys equivalent → Clojure vector of strings
-          map.set('keys', {
-            value: v.nativeFn('js/keys', (obj: CljValue) => {
-              const raw = extractJsTarget(obj, 'js/keys') as Record<string, unknown>
-              return v.vector(Object.keys(raw).map(v.string))
-            }),
-          })
-
-          // (js/values obj) — Object.values equivalent → Clojure vector, elements via jsToClj
-          map.set('values', {
-            value: v.nativeFn('js/values', (obj: CljValue) => {
-              const raw = extractJsTarget(obj, 'js/values') as Record<string, unknown>
-              return v.vector(Object.values(raw).map(jsToClj))
-            }),
-          })
-
-          // (js/entries obj) — Object.entries equivalent → vector of [key value] pairs
-          map.set('entries', {
-            value: v.nativeFn('js/entries', (obj: CljValue) => {
-              const raw = extractJsTarget(obj, 'js/entries') as Record<string, unknown>
-              return v.vector(
-                Object.entries(raw).map(([k, val]) => v.vector([v.string(k), jsToClj(val)]))
-              )
-            }),
-          })
-
-          return map
-        },
-      },
-    ],
-  }
-}