conjure-js 0.0.11 → 0.0.13

package/src/core/stdlib/hof.ts

@@ -1,108 +1,27 @@
 // Higher-order functions: map, filter, reduce, apply, partial, comp,
 // map-indexed, identity
-import {
-  isAFunction,
-  isCallable,
-  isNil,
-  isReduced,
-  isSeqable,
-} from '../assertions'
+import { is } from '../assertions'
 import { EvaluationError } from '../errors'
-import {
-  cljNativeFunction,
-  cljNativeFunctionWithContext,
-  withDoc,
-} from '../factories'
+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> = {
-  // map: cljNativeFunctionWithContext(
-  //   'map',
-  //   (
-  //     ctx: EvaluationContext,
-  //     fn: CljValue | undefined,
-  //     collection: CljValue | undefined
-  //   ): CljValue => {
-  //     if (fn === undefined) {
-  //       throw new EvaluationError(
-  //         `map expects a function as first argument, got nil`,
-  //         { fn }
-  //       )
-  //     }
-  //     if (!isAFunction(fn)) {
-  //       throw new EvaluationError(
-  //         `map expects a function as first argument, got ${printString(fn)}`,
-  //         { fn }
-  //       )
-  //     }
-  //     if (collection === undefined) {
-  //       return cljNil()
-  //     }
-  //     if (!isCollection(collection)) {
-  //       throw new EvaluationError(
-  //         `map expects a collection, got ${printString(collection)}`,
-  //         { collection }
-  //       )
-  //     }
-
-  //     const wrap = isVector(collection) ? cljVector : cljList
-  //     return wrap(
-  //       toSeq(collection).map((item) => ctx.applyFunction(fn, [item]))
-  //     )
-  //   }
-  // ),
-  // filter: cljNativeFunctionWithContext(
-  //   'filter',
-  //   (
-  //     ctx: EvaluationContext,
-  //     fn: CljValue | undefined,
-  //     collection: CljValue | undefined
-  //   ): CljValue => {
-  //     if (fn === undefined) {
-  //       throw new EvaluationError(
-  //         `filter expects a function as first argument, got nil`,
-  //         { fn }
-  //       )
-  //     }
-  //     if (!isAFunction(fn)) {
-  //       throw new EvaluationError(
-  //         `filter expects a function as first argument, got ${printString(fn)}`,
-  //         { fn }
-  //       )
-  //     }
-  //     if (collection === undefined) {
-  //       return cljNil()
-  //     }
-  //     if (!isCollection(collection)) {
-  //       throw new EvaluationError(
-  //         `filter expects a collection, got ${printString(collection)}`,
-  //         { collection }
-  //       )
-  //     }
-
-  //     const wrap = isVector(collection) ? cljVector : cljList
-  //     return wrap(
-  //       toSeq(collection).filter((item) =>
-  //         isTruthy(ctx.applyFunction(fn, [item]))
-  //       )
-  //     )
-  //   }
-  // ),
-  reduce: withDoc(
-    cljNativeFunctionWithContext(
+  reduce: v
+    .nativeFnCtx(
       'reduce',
-      (
+      function reduce(
         ctx: EvaluationContext,
         callEnv: Env,
         fn: CljValue,
         ...rest: CljValue[]
-      ) => {
-        if (fn === undefined || !isAFunction(fn)) {
-          throw new EvaluationError(
+      ) {
+        if (fn === undefined || !is.aFunction(fn)) {
+          throw EvaluationError.atArg(
             `reduce expects a function as first argument${fn !== undefined ? `, got ${printString(fn)}` : ''}`,
-            { fn }
+            { fn },
+            0
           )
         }
         if (rest.length === 0 || rest.length > 2) {
@@ -127,10 +46,12 @@ export const hofFunctions: Record<string, CljValue> = {
           return init!
         }
 
-        if (!isSeqable(collection)) {
-          throw new EvaluationError(
+        if (!is.seqable(collection)) {
+          // collection is at args[rest.length]: 1 for (reduce f coll), 2 for (reduce f init coll)
+          throw EvaluationError.atArg(
             `reduce expects a collection or string, got ${printString(collection)}`,
-            { collection }
+            { collection },
+            rest.length
           )
         }
 
@@ -147,7 +68,7 @@ export const hofFunctions: Record<string, CljValue> = {
           let acc = items[0]
           for (let i = 1; i < items.length; i++) {
             const result = ctx.applyFunction(fn, [acc, items[i]], callEnv)
-            if (isReduced(result)) return result.value
+            if (is.reduced(result)) return result.value
             acc = result
           }
           return acc
@@ -156,21 +77,22 @@ export const hofFunctions: Record<string, CljValue> = {
         let acc = init!
         for (const item of items) {
           const result = ctx.applyFunction(fn, [acc, item], callEnv)
-          if (isReduced(result)) return result.value
+          if (is.reduced(result)) return result.value
           acc = result
         }
         return acc
       }
+    )
+    .doc(
+      'Reduces a collection to a single value by iteratively applying f. (reduce f coll) or (reduce f init coll).',
+      [
+        ['f', 'coll'],
+        ['f', 'val', 'coll'],
+      ]
     ),
-    'Reduces a collection to a single value by iteratively applying f. (reduce f coll) or (reduce f init coll).',
-    [
-      ['f', 'coll'],
-      ['f', 'val', 'coll'],
-    ]
-  ),
 
-  apply: withDoc(
-    cljNativeFunctionWithContext(
+  apply: v
+    .nativeFnCtx(
       'apply',
       (
         ctx: EvaluationContext,
@@ -178,10 +100,11 @@ export const hofFunctions: Record<string, CljValue> = {
         fn: CljValue | undefined,
         ...rest: CljValue[]
       ) => {
-        if (fn === undefined || !isCallable(fn)) {
-          throw new EvaluationError(
+        if (fn === undefined || !is.callable(fn)) {
+          throw EvaluationError.atArg(
             `apply expects a callable as first argument${fn !== undefined ? `, got ${printString(fn)}` : ''}`,
-            { fn }
+            { fn },
+            0
           )
         }
         if (rest.length === 0) {
@@ -190,37 +113,41 @@ export const hofFunctions: Record<string, CljValue> = {
           })
         }
         const lastArg = rest[rest.length - 1]
-        if (!isNil(lastArg) && !isSeqable(lastArg)) {
-          throw new EvaluationError(
+        if (!is.nil(lastArg) && !is.seqable(lastArg)) {
+          // last arg is at index rest.length (fn=0, rest[0]=1, ..., rest[n-1]=n)
+          throw EvaluationError.atArg(
             `apply expects a collection or string as last argument, got ${printString(lastArg)}`,
-            { lastArg }
+            { lastArg },
+            rest.length
           )
         }
 
         const args = [
           ...rest.slice(0, -1),
-          ...(isNil(lastArg) ? [] : toSeq(lastArg)),
+          ...(is.nil(lastArg) ? [] : toSeq(lastArg)),
         ]
         return ctx.applyCallable(fn, args, callEnv)
       }
+    )
+    .doc(
+      'Calls f with the elements of the last argument (a collection) as its arguments, optionally prepended by fixed args.',
+      [
+        ['f', 'args'],
+        ['f', '&', 'args'],
+      ]
     ),
-    'Calls f with the elements of the last argument (a collection) as its arguments, optionally prepended by fixed args.',
-    [
-      ['f', 'args'],
-      ['f', '&', 'args'],
-    ]
-  ),
 
-  partial: withDoc(
-    cljNativeFunction('partial', (fn: CljValue, ...preArgs: CljValue[]) => {
-      if (fn === undefined || !isCallable(fn)) {
-        throw new EvaluationError(
+  partial: v
+    .nativeFn('partial', (fn: CljValue, ...preArgs: CljValue[]) => {
+      if (fn === undefined || !is.callable(fn)) {
+        throw EvaluationError.atArg(
           `partial expects a callable as first argument${fn !== undefined ? `, got ${printString(fn)}` : ''}`,
-          { fn }
+          { fn },
+          0
         )
       }
       const capturedFn = fn
-      return cljNativeFunctionWithContext(
+      return v.nativeFnCtx(
         'partial',
         (ctx: EvaluationContext, callEnv: Env, ...moreArgs: CljValue[]) => {
           return ctx.applyCallable(
@@ -230,24 +157,27 @@ export const hofFunctions: Record<string, CljValue> = {
           )
         }
       )
-    }),
-    'Returns a function that calls f with pre-applied args prepended to any additional arguments.',
-    [['f', '&', 'args']]
-  ),
+    })
+    .doc(
+      'Returns a function that calls f with pre-applied args prepended to any additional arguments.',
+      [['f', '&', 'args']]
+    ),
 
-  comp: withDoc(
-    cljNativeFunction('comp', (...fns: CljValue[]) => {
+  comp: v
+    .nativeFn('comp', (...fns: CljValue[]) => {
       if (fns.length === 0) {
-        return cljNativeFunction('identity', (x: CljValue) => x)
+        return v.nativeFn('identity', (x: CljValue) => x)
       }
-      if (fns.some((f) => !isCallable(f))) {
-        throw new EvaluationError(
+      const badIdx = fns.findIndex((f) => !is.callable(f))
+      if (badIdx !== -1) {
+        throw EvaluationError.atArg(
           'comp expects functions or other callable values (keywords, maps)',
-          { fns }
+          { fns },
+          badIdx
         )
       }
       const capturedFns = fns
-      return cljNativeFunctionWithContext(
+      return v.nativeFnCtx(
         'composed',
         (ctx: EvaluationContext, callEnv: Env, ...args: CljValue[]) => {
           let result = ctx.applyCallable(
@@ -261,47 +191,18 @@ export const hofFunctions: Record<string, CljValue> = {
           return result
         }
       )
-    }),
-    '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']]
-  ),
-
-  // 'map-indexed': cljNativeFunctionWithContext(
-  //   'map-indexed',
-  //   (ctx: EvaluationContext, fn: CljValue, coll: CljValue): CljValue => {
-  //     if (fn === undefined || !isAFunction(fn)) {
-  //       throw new EvaluationError(
-  //         `map-indexed expects a function as first argument${fn !== undefined ? `, got ${printString(fn)}` : ''}`,
-  //         { fn }
-  //       )
-  //     }
-  //     if (coll === undefined || !isCollection(coll)) {
-  //       throw new EvaluationError(
-  //         `map-indexed expects a collection as second argument${coll !== undefined ? `, got ${printString(coll)}` : ''}`,
-  //         { coll }
-  //       )
-  //     }
-  //     const items = toSeq(coll)
-  //     const wrap = isVector(coll) ? cljVector : cljList
-  //     return wrap(
-  //       items.map((item, idx) =>
-  //         ctx.applyFunction(fn as CljFunction | CljNativeFunction, [
-  //           cljNumber(idx),
-  //           item,
-  //         ])
-  //       )
-  //     )
-  //   }
-  // ),
+    })
+    .doc(
+      '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: CljValue) => {
+  identity: v
+    .nativeFn('identity', (x: CljValue) => {
       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']]
-  ),
+    })
+    .doc('Returns its single argument unchanged.', [['x']]),
 }

package/src/core/stdlib/js-namespace.ts

@@ -0,0 +1,344 @@
+// 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
+        },
+      },
+    ],
+  }
+}