vm.call(name, ...args)

CLAUDE.md

@@ -169,6 +169,43 @@ Auto-wrapping handles:
 - Sync and async functions
 - Arrays, objects, primitives, null, RegExp
 
+### Calling Reef Functions from TypeScript
+
+Use `vm.call()` to invoke Reef functions from TypeScript:
+
+```typescript
+const bytecode = toBytecode(`
+  MAKE_FUNCTION (x y=10) .add
+  STORE add
+  HALT
+
+  .add:
+    LOAD x
+    LOAD y
+    ADD
+    RETURN
+`)
+
+const vm = new VM(bytecode)
+await vm.run()
+
+// Positional arguments
+const result1 = await vm.call('add', 5, 3)  // → 8
+
+// Named arguments (pass final object)
+const result2 = await vm.call('add', 5, { y: 20 })  // → 25
+
+// All named arguments
+const result3 = await vm.call('add', { x: 10, y: 15 })  // → 25
+```
+
+**How it works**:
+- Looks up function in VM scope
+- Converts it to a callable JavaScript function using `fnFromValue`
+- Automatically converts arguments to ReefVM Values
+- Executes the function in a fresh VM context
+- Converts result back to JavaScript types
+
 ### Label Usage (Preferred)
 Use labels instead of numeric offsets for readability:
 ```

GUIDE.md

@@ -676,6 +676,55 @@ CALL                ; atOptions receives {debug: true, port: 8080}
 
 Named arguments that match fixed parameter names are bound to those parameters. Remaining unmatched named arguments are collected into the `atXxx` parameter as a plain JavaScript object.
 
+### Calling Reef Functions from TypeScript
+
+Once you have Reef functions defined in the VM, you can call them from TypeScript using `vm.call()`:
+
+```typescript
+const bytecode = toBytecode(`
+  MAKE_FUNCTION (name greeting="Hello") .greet
+  STORE greet
+  HALT
+
+  .greet:
+    LOAD greeting
+    PUSH " "
+    LOAD name
+    PUSH "!"
+    STR_CONCAT #4
+    RETURN
+`)
+
+const vm = new VM(bytecode)
+await vm.run()
+
+// Call with positional arguments
+const result1 = await vm.call('greet', 'Alice')
+// Returns: "Hello Alice!"
+
+// Call with named arguments (pass as final object)
+const result2 = await vm.call('greet', 'Bob', { greeting: 'Hi' })
+// Returns: "Hi Bob!"
+
+// Call with only named arguments
+const result3 = await vm.call('greet', { name: 'Carol', greeting: 'Hey' })
+// Returns: "Hey Carol!"
+```
+
+**How it works**:
+- `vm.call(functionName, ...args)` looks up the function in the VM's scope
+- Converts it to a callable JavaScript function
+- Calls it with the provided arguments (automatically converted to ReefVM Values)
+- Returns the result (automatically converted back to JavaScript types)
+
+**Named arguments**: Pass a plain object as the final argument to provide named arguments. If the last argument is a non-array object, it's treated as named arguments. All preceding arguments are treated as positional.
+
+**Type conversion**: Arguments and return values are automatically converted between JavaScript types and ReefVM Values:
+- Primitives: `number`, `string`, `boolean`, `null`
+- Arrays: converted recursively
+- Objects: converted to ReefVM dicts
+- Functions: Reef functions are converted to callable JavaScript functions
+
 ### Empty Stack
 - RETURN with empty stack returns null
 - HALT with empty stack returns null

README.md

@@ -48,7 +48,9 @@ Commands: `clear`, `reset`, `exit`.
 - Exception handling (PUSH_TRY, PUSH_FINALLY, POP_TRY, THROW) with nested try/finally blocks and call stack unwinding
 - Native function interop with auto-wrapping for native TypeScript types
 - Native functions stored in scope, called via LOAD + CALL
+- Native functions support `atXxx` parameters (e.g., `atOptions`) to collect unmatched named args
 - Pass functions directly to `run(bytecode, { fnName: fn })` or `new VM(bytecode, { fnName: fn })`
+- Call Reef functions from TypeScript with `vm.call(name, ...args)` with automatic type conversion
 
 ## Design Decisions
 

src/function.ts

@@ -1,4 +1,5 @@
 import { type Value, type NativeFunction, fromValue, toValue } from "./value"
+import { VM } from "./vm"
 
 export type ParamInfo = {
   params: string[]
@@ -9,10 +10,10 @@ export type ParamInfo = {
 
 const WRAPPED_MARKER = Symbol('reef-wrapped')
 
-export function wrapNative(fn: Function): (...args: Value[]) => Promise<Value> {
-  const wrapped = async (...values: Value[]) => {
-    const nativeArgs = values.map(fromValue)
-    const result = await fn(...nativeArgs)
+export function wrapNative(vm: VM, fn: Function): (this: VM, ...args: Value[]) => Promise<Value> {
+  const wrapped = async function (this: VM, ...values: Value[]) {
+    const nativeArgs = values.map(arg => fromValue(arg, vm))
+    const result = await fn.call(this, ...nativeArgs)
     return toValue(result)
   }
 

src/value.ts

@@ -1,4 +1,6 @@
+import { OpCode } from "./opcode"
 import { Scope } from "./scope"
+import { VM } from "./vm"
 
 export type NativeFunction = (...args: Value[]) => Promise<Value> | Value
 
@@ -154,23 +156,22 @@ export function isEqual(a: Value, b: Value): boolean {
   }
 }
 
-export function fromValue(v: Value): any {
+export function fromValue(v: Value, vm?: VM): any {
   switch (v.type) {
     case 'null':
-      return null
     case 'boolean':
-      return v.value
     case 'number':
-      return v.value
     case 'string':
       return v.value
     case 'array':
-      return v.value.map(fromValue)
+      return v.value.map(x => fromValue(x, vm))
     case 'dict':
-      return Object.fromEntries(v.value.entries().map(([k, v]) => [k, fromValue(v)]))
+      return Object.fromEntries(v.value.entries().map(([k, v]) => [k, fromValue(v, vm)]))
     case 'regex':
       return v.value
     case 'function':
+      if (!vm || !(vm instanceof VM)) throw new Error('VM is required for function conversion')
+      return fnFromValue(v, vm)
     case 'native':
       return '<function>'
   }
@@ -179,3 +180,45 @@ export function fromValue(v: Value): any {
 export function toNull(): Value {
   return toValue(null)
 }
+
+export function fnFromValue(fn: Value, vm: VM): Function {
+  if (fn.type !== 'function')
+    throw new Error('Value is not a function')
+
+  return async function (...args: any[]) {
+    let positional: any[] = args
+    let named: Record<string, any> = {}
+
+    if (args.length > 0 && !Array.isArray(args[args.length - 1]) && args[args.length - 1].constructor === Object) {
+      named = args[args.length - 1]
+      positional = args.slice(0, -1)
+    }
+
+    const newVM = new VM({
+      instructions: vm.instructions,
+      constants: vm.constants,
+      labels: vm.labels
+    })
+    newVM.scope = fn.parentScope
+
+    newVM.stack.push(fn)
+    newVM.stack.push(...positional.map(toValue))
+    for (const [key, val] of Object.entries(named)) {
+      newVM.stack.push(toValue(key))
+      newVM.stack.push(toValue(val))
+    }
+    newVM.stack.push(toValue(positional.length))
+    newVM.stack.push(toValue(Object.keys(named).length))
+
+    const targetDepth = newVM.callStack.length
+    await newVM.execute({ op: OpCode.CALL })
+    newVM.pc++
+
+    while (newVM.callStack.length > targetDepth && newVM.pc < newVM.instructions.length) {
+      await newVM.execute(newVM.instructions[newVM.pc]!)
+      newVM.pc++
+    }
+
+    return fromValue(newVM.stack.pop() || toNull(), vm)
+  }
+}

src/vm.ts

@@ -3,9 +3,11 @@ import type { ExceptionHandler } from "./exception"
 import { type Frame } from "./frame"
 import { OpCode } from "./opcode"
 import { Scope } from "./scope"
-import { type Value, type NativeFunction, toValue, toNumber, isTrue, isEqual, toString, fromValue } from "./value"
+import { type Value, type NativeFunction, toValue, toNumber, isTrue, isEqual, toString, fromValue, fnFromValue } from "./value"
 import { extractParamInfo, wrapNative, isWrapped, getOriginalFunction } from "./function"
 
+type Fn = (this: VM, ...args: any[]) => any
+
 export class VM {
   pc = 0
   stopped = false
@@ -18,7 +20,7 @@ export class VM {
   labels: Map<number, string> = new Map()
   nativeFunctions: Map<string, NativeFunction> = new Map()
 
-  constructor(bytecode: Bytecode, functions?: Record<string, Function>) {
+  constructor(bytecode: Bytecode, functions?: Record<string, Fn>) {
     this.instructions = bytecode.instructions
     this.constants = bytecode.constants
     this.labels = bytecode.labels || new Map()
@@ -29,8 +31,18 @@ export class VM {
         this.registerFunction(name, functions[name]!)
   }
 
-  registerFunction(name: string, fn: Function) {
-    const wrapped = isWrapped(fn) ? fn as NativeFunction : wrapNative(fn)
+  async call(name: string, ...args: any) {
+    const value = this.scope.get(name)
+
+    if (!value) throw new Error(`Can't find ${name}`)
+    if (value.type !== 'function') throw new Error(`Can't call ${name}`)
+
+    const fn = fnFromValue(value, this)
+    return await fn(...args)
+  }
+
+  registerFunction(name: string, fn: Fn) {
+    const wrapped = isWrapped(fn) ? fn as NativeFunction : wrapNative(this, fn)
     this.scope.set(name, { type: 'native', fn: wrapped, value: '<function>' })
   }
 
@@ -476,7 +488,7 @@ export class VM {
               namedDict.set(key, value)
             }
             // Convert dict to plain JavaScript object for the native function
-            const namedObj = fromValue({ type: 'dict', value: namedDict })
+            const namedObj = fromValue({ type: 'dict', value: namedDict }, this)
             nativeArgs.push(toValue(namedObj))
           }
 
@@ -489,7 +501,7 @@ export class VM {
           }
 
           // Call the native function with bound args
-          const result = await fn.fn(...nativeArgs)
+          const result = await fn.fn.call(this, ...nativeArgs)
           this.stack.push(result)
           break
         }

tests/native.test.ts

@@ -646,3 +646,685 @@ test("@named pattern - collects only unmatched named args", async () => {
     expect(result.value.get('extra2')).toEqual(toValue('value2'))
   }
 })
+
+test("Native function receives Reef function as callback - basic map", async () => {
+  const bytecode = toBytecode(`
+    ; Define a Reef function that doubles a number
+    MAKE_FUNCTION (x) .double_body
+    STORE double
+    JUMP .skip_double
+    .double_body:
+      LOAD x
+      PUSH 2
+      MUL
+      RETURN
+    .skip_double:
+
+    ; Call native 'map' with array and Reef function
+    LOAD map
+    PUSH 1
+    PUSH 2
+    PUSH 3
+    MAKE_ARRAY #3
+    LOAD double
+    PUSH 2
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  // Native function that takes an array and a callback
+  vm.registerFunction('map', async (array: any[], callback: Function) => {
+    const results = []
+    for (const item of array) {
+      results.push(await callback(item))
+    }
+    return results
+  })
+
+  const result = await vm.run()
+  expect(result.type).toBe('array')
+  if (result.type === 'array') {
+    console.log(result.value)
+    expect(result.value).toEqual([
+      toValue(2),
+      toValue(4),
+      toValue(6)
+    ])
+  } else {
+    expect(true).toBe(false)
+  }
+})
+
+test("Native function receives Reef function - iterator pattern with each", async () => {
+  const bytecode = toBytecode(`
+    ; Define a Reef function that adds to a sum
+    MAKE_FUNCTION (item) .add_to_sum_body
+    STORE add_to_sum
+    JUMP .skip_add_to_sum
+    .add_to_sum_body:
+      LOAD sum
+      LOAD item
+      ADD
+      STORE sum
+      RETURN
+    .skip_add_to_sum:
+
+    ; Initialize sum
+    PUSH 0
+    STORE sum
+
+    ; Call native 'each' with array and Reef function
+    LOAD each
+    PUSH 10
+    PUSH 20
+    PUSH 30
+    MAKE_ARRAY #3
+    LOAD add_to_sum
+    PUSH 2
+    PUSH 0
+    CALL
+
+    ; Return the sum
+    LOAD sum
+  `)
+
+  const vm = new VM(bytecode)
+
+  // Native 'each' function (like Ruby's each)
+  vm.registerFunction('each', async (array: any[], callback: Function) => {
+    for (const item of array) {
+      await callback(item)
+    }
+    return null
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'number', value: 60 })
+})
+
+test("Native function receives Reef function - filter pattern", async () => {
+  const bytecode = toBytecode(`
+    ; Define a Reef function that checks if number > 5
+    MAKE_FUNCTION (x) .is_greater_body
+    STORE is_greater
+    JUMP .skip_is_greater
+    .is_greater_body:
+      LOAD x
+      PUSH 5
+      GT
+      RETURN
+    .skip_is_greater:
+
+    ; Call native 'filter' with array and Reef function
+    LOAD filter
+    PUSH 3
+    PUSH 7
+    PUSH 2
+    PUSH 9
+    PUSH 1
+    MAKE_ARRAY #5
+    LOAD is_greater
+    PUSH 2
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  // Native filter function
+  vm.registerFunction('filter', async (array: any[], predicate: Function) => {
+    const results = []
+    for (const item of array) {
+      if (await predicate(item)) {
+        results.push(item)
+      }
+    }
+    return results
+  })
+
+  const result = await vm.run()
+  expect(result.type).toBe('array')
+  if (result.type === 'array') {
+    expect(result.value).toEqual([
+      toValue(7),
+      toValue(9)
+    ])
+  }
+})
+
+test("Native function receives Reef function - closure capturing", async () => {
+  const bytecode = toBytecode(`
+    ; Store a multiplier in scope
+    PUSH 10
+    STORE multiplier
+
+    ; Define a Reef function that uses the closure variable
+    MAKE_FUNCTION (x) .multiply_body
+    STORE multiply_by_ten
+    JUMP .skip_multiply
+    .multiply_body:
+      LOAD x
+      LOAD multiplier
+      MUL
+      RETURN
+    .skip_multiply:
+
+    ; Call native 'map' with the closure function
+    LOAD map
+    PUSH 1
+    PUSH 2
+    PUSH 3
+    MAKE_ARRAY #3
+    LOAD multiply_by_ten
+    PUSH 2
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('map', async (array: any[], callback: Function) => {
+    const results = []
+    for (const item of array) {
+      results.push(await callback(item))
+    }
+    return results
+  })
+
+  const result = await vm.run()
+  expect(result.type).toBe('array')
+  if (result.type === 'array') {
+    expect(result.value).toEqual([
+      toValue(10),
+      toValue(20),
+      toValue(30)
+    ])
+  }
+})
+
+test("Native function receives Reef function - multiple arguments", async () => {
+  const bytecode = toBytecode(`
+    ; Define a Reef function that takes two args
+    MAKE_FUNCTION (a b) .add_body
+    STORE add
+    JUMP .skip_add
+    .add_body:
+      LOAD a
+      LOAD b
+      ADD
+      RETURN
+    .skip_add:
+
+    ; Call native 'reduce' with array, initial value, and Reef function
+    LOAD reduce
+    PUSH 1
+    PUSH 2
+    PUSH 3
+    PUSH 4
+    MAKE_ARRAY #4
+    PUSH 0
+    LOAD add
+    PUSH 3
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  // Native reduce function (accumulator, array, callback)
+  vm.registerFunction('reduce', async (array: any[], initial: any, callback: Function) => {
+    let acc = initial
+    for (const item of array) {
+      acc = await callback(acc, item)
+    }
+    return acc
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'number', value: 10 })
+})
+
+test("Native function receives Reef function - returns non-primitive", async () => {
+  const bytecode = toBytecode(`
+    ; Define a Reef function that returns a dict
+    MAKE_FUNCTION (name) .make_user_body
+    STORE make_user
+    JUMP .skip_make_user
+    .make_user_body:
+      PUSH "name"
+      LOAD name
+      PUSH "active"
+      PUSH true
+      MAKE_DICT #2
+      RETURN
+    .skip_make_user:
+
+    ; Call native 'map' to create users
+    LOAD map
+    PUSH "Alice"
+    PUSH "Bob"
+    MAKE_ARRAY #2
+    LOAD make_user
+    PUSH 2
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('map', async (array: any[], callback: Function) => {
+    const results = []
+    for (const item of array) {
+      results.push(await callback(item))
+    }
+    return results
+  })
+
+  const result = await vm.run()
+  expect(result.type).toBe('array')
+  if (result.type === 'array') {
+    expect(result.value.length).toBe(2)
+
+    const first = result.value[0]
+    expect(first?.type).toBe('dict')
+    if (first?.type === 'dict') {
+      expect(first.value.get('name')).toEqual(toValue('Alice'))
+      expect(first.value.get('active')).toEqual(toValue(true))
+    }
+
+    const second = result.value[1]
+    expect(second?.type).toBe('dict')
+    if (second?.type === 'dict') {
+      expect(second.value.get('name')).toEqual(toValue('Bob'))
+      expect(second.value.get('active')).toEqual(toValue(true))
+    }
+  }
+})
+
+test("Native function calls Reef function - basic", async () => {
+  const bytecode = toBytecode(`
+    ; Define a Reef function that doubles a number
+    MAKE_FUNCTION (x) .double_body
+    STORE double
+    JUMP .skip_double
+    .double_body:
+      LOAD x
+      PUSH 2
+      MUL
+      RETURN
+    .skip_double:
+
+    ; Call native function that will call the Reef function
+    LOAD process
+    PUSH 5
+    PUSH 1
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('process', async function (n: number) {
+    return await this.call('double', n)
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'number', value: 10 })
+})
+
+test("Native function calls multiple Reef functions", async () => {
+  const bytecode = toBytecode(`
+    ; Define helper functions
+    MAKE_FUNCTION (x) .double_body
+    STORE double
+    JUMP .skip_double
+    .double_body:
+      LOAD x
+      PUSH 2
+      MUL
+      RETURN
+    .skip_double:
+
+    MAKE_FUNCTION (x) .triple_body
+    STORE triple
+    JUMP .skip_triple
+    .triple_body:
+      LOAD x
+      PUSH 3
+      MUL
+      RETURN
+    .skip_triple:
+
+    ; Call native orchestrator
+    LOAD orchestrate
+    PUSH 5
+    PUSH 1
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('orchestrate', async function (n: number) {
+    const doubled = await this.call('double', n)
+    const tripled = await this.call('triple', n)
+
+    return doubled + tripled  // 10 + 15 = 25
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'number', value: 25 })
+})
+
+test("Native function conditionally calls Reef functions", async () => {
+  const bytecode = toBytecode(`
+    ; Define validation functions
+    MAKE_FUNCTION (x) .is_positive_body
+    STORE is_positive
+    JUMP .skip_is_positive
+    .is_positive_body:
+      LOAD x
+      PUSH 0
+      GT
+      RETURN
+    .skip_is_positive:
+
+    MAKE_FUNCTION (x) .negate_body
+    STORE negate
+    JUMP .skip_negate
+    .negate_body:
+      PUSH 0
+      LOAD x
+      SUB
+      RETURN
+    .skip_negate:
+
+    ; Test with positive number
+    LOAD validate
+    PUSH 5
+    PUSH 1
+    PUSH 0
+    CALL
+    STORE result1
+
+    ; Test with negative number
+    LOAD validate
+    PUSH -3
+    PUSH 1
+    PUSH 0
+    CALL
+    STORE result2
+
+    ; Return sum
+    LOAD result1
+    LOAD result2
+    ADD
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('validate', async function (n: number) {
+    const isPositive = await this.call('is_positive', n)
+
+    if (isPositive) {
+      return n  // Already positive
+    } else {
+      return await this.call('negate', n)  // Make it positive
+    }
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'number', value: 8 })  // 5 + 3
+})
+
+test("Native function calls Reef function with closure", async () => {
+  const bytecode = toBytecode(`
+    ; Set up a multiplier in scope
+    PUSH 10
+    STORE multiplier
+
+    ; Define a Reef function that uses the closure variable
+    MAKE_FUNCTION (x) .multiply_body
+    STORE multiply_by_ten
+    JUMP .skip_multiply
+    .multiply_body:
+      LOAD x
+      LOAD multiplier
+      MUL
+      RETURN
+    .skip_multiply:
+
+    ; Native function calls the closure
+    LOAD transform
+    PUSH 7
+    PUSH 1
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('transform', async function (n: number) {
+    return await this.call('multiply_by_ten', n)
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'number', value: 70 })
+})
+
+test("Native function uses Reef function as filter predicate", async () => {
+  const bytecode = toBytecode(`
+    ; Define a predicate function
+    MAKE_FUNCTION (x) .is_even_body
+    STORE is_even
+    JUMP .skip_is_even
+    .is_even_body:
+      LOAD x
+      PUSH 2
+      MOD
+      PUSH 0
+      EQ
+      RETURN
+    .skip_is_even:
+
+    ; Call native filter
+    LOAD filter_evens
+    PUSH 1
+    PUSH 2
+    PUSH 3
+    PUSH 4
+    PUSH 5
+    MAKE_ARRAY #5
+    PUSH 1
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('filter_evens', async function (array: any[]) {
+    const results = []
+    for (const item of array) {
+      if (await this.call('is_even', item)) {
+        results.push(item)
+      }
+    }
+    return results
+  })
+
+  const result = await vm.run()
+  expect(result.type).toBe('array')
+  if (result.type === 'array') {
+    expect(result.value).toEqual([
+      toValue(2),
+      toValue(4)
+    ])
+  }
+})
+
+test("Reef calls native calls Reef - roundtrip", async () => {
+  const bytecode = toBytecode(`
+    ; Reef function that squares a number
+    MAKE_FUNCTION (x) .square_body
+    STORE square
+    JUMP .skip_square
+    .square_body:
+      LOAD x
+      LOAD x
+      MUL
+      RETURN
+    .skip_square:
+
+    ; Reef function that calls native which calls back to Reef
+    MAKE_FUNCTION (x) .process_body
+    STORE process
+    JUMP .skip_process
+    .process_body:
+      LOAD native_helper
+      LOAD x
+      PUSH 1
+      PUSH 0
+      CALL
+      RETURN
+    .skip_process:
+
+    ; Call the Reef function
+    LOAD process
+    PUSH 3
+    PUSH 1
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('native_helper', async function (n: number) {
+    const squared = await this.call('square', n)
+    return squared + 1  // Add 1 to the squared result
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'number', value: 10 })  // 3^2 + 1 = 10
+})
+
+test("Native function calls Reef function with multiple arguments", async () => {
+  const bytecode = toBytecode(`
+    ; Reef function that adds three numbers
+    MAKE_FUNCTION (a b c) .add_three_body
+    STORE add_three
+    JUMP .skip_add_three
+    .add_three_body:
+      LOAD a
+      LOAD b
+      ADD
+      LOAD c
+      ADD
+      RETURN
+    .skip_add_three:
+
+    ; Native function that calls it
+    LOAD calculate
+    PUSH 0
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('calculate', async function () {
+    return await this.call('add_three', 10, 20, 30)
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'number', value: 60 })
+})
+
+test("Native function calls Reef function that returns complex type", async () => {
+  const bytecode = toBytecode(`
+    ; Reef function that creates a user dict
+    MAKE_FUNCTION (name age) .make_user_body
+    STORE make_user
+    JUMP .skip_make_user
+    .make_user_body:
+      PUSH "name"
+      LOAD name
+      PUSH "age"
+      LOAD age
+      PUSH "active"
+      PUSH true
+      MAKE_DICT #3
+      RETURN
+    .skip_make_user:
+
+    ; Native function calls it
+    LOAD create_user
+    PUSH 0
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('create_user', async function () {
+    return await this.call('make_user', "Alice", 30)
+  })
+
+  const result = await vm.run()
+  expect(result.type).toBe('dict')
+  if (result.type === 'dict') {
+    expect(result.value.get('name')).toEqual(toValue('Alice'))
+    expect(result.value.get('age')).toEqual(toValue(30))
+    expect(result.value.get('active')).toEqual(toValue(true))
+  }
+})
+
+test("Native function calls non-existent Reef function - throws error", async () => {
+  const bytecode = toBytecode(`
+    LOAD bad_caller
+    PUSH 0
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode)
+
+  vm.registerFunction('bad_caller', async function () {
+    return await this.call('nonexistent', 42)
+  })
+
+  await expect(vm.run()).rejects.toThrow()
+})
+
+test("Native function calls Reef function with named arguments", async () => {
+  const bytecode = toBytecode(`
+    ; Reef function with default parameters
+    MAKE_FUNCTION (name greeting='Hello') .greet_body 
+    STORE greet
+    JUMP .skip_greet
+    .greet_body:
+      LOAD greeting
+      PUSH " "
+      LOAD name
+      PUSH "!"
+      STR_CONCAT #4
+      RETURN
+    .skip_greet:
+
+    LOAD call_greet
+    PUSH 0
+    PUSH 0
+    CALL
+  `)
+
+  const vm = new VM(bytecode, {
+    call_greet: async function () {
+      // Call with named argument as last positional (object)
+      return await this.call('greet', "Alice", { greeting: "Hi" })
+    }
+  })
+
+  const result = await vm.run()
+  expect(result).toEqual({ type: 'string', value: "Hi Alice!" })
+})