@px-petals/roku.motion-web 1.0.0 → 1.1.0

package/script/luau/load/load.js

@@ -0,0 +1,362 @@
+/**
+ * The Luau bytecode loader: bytes in, a module of protos out. It follows
+ * `lvmload.cpp` for the layout and reads versions 3 to 14 with type-info
+ * versions 1 to 3 (8 on: 64-bit integer constants and classes are refused, 12 on:
+ * proto sizes, feedback slots and inline cost are read and dropped); the VM runs the result.
+ *
+ * The input starts at the version byte. Rive stores scripts with one wrapper
+ * byte before it, and the caller strips that byte. A leading 0 byte is how
+ * Luau carries a compile error as the rest of the bytes, and loads as a
+ * thrown error with that text.
+ *
+ * Constants are decoded into Lua values: `undefined` is nil, strings are
+ * byte strings (one char per byte, 0 to 255), vectors are `Vector`. Three
+ * kinds stay descriptors for the VM to expand: imports, table templates
+ * (DUPTABLE) and closures (DUPCLOSURE).
+ */
+
+import { CONSTANT, OP, PROTO_INLINABLE, OP_LENGTH, TYPE_VERSION_MAX, TYPE_VERSION_MIN, VERSION_MAX, VERSION_MIN } from './load.ops.js'
+import { Vector } from '../vm/vm.value.js'
+
+/**
+ * @typedef {object} Proto
+ * @property {number}      id          index in the module's proto table
+ * @property {number}      maxStack    registers the function needs
+ * @property {number}      numParams
+ * @property {number}      numUpvals
+ * @property {boolean}     isVararg
+ * @property {number}      flags
+ * @property {Uint8Array | null} typeInfo  raw type bytes, as stored
+ * @property {Int32Array}  code        instruction words
+ * @property {any[]}       k           constants
+ * @property {Proto[]}     protos      child protos, by NEWCLOSURE index
+ * @property {number}      lineDefined
+ * @property {string}      name        debug name, '' when stripped
+ * @property {Int32Array | null} lines  source line of each instruction word, null when stripped
+ * @property {{ name: string, start: number, end: number, reg: number }[]} locals
+ * @property {string[]}    upvalNames
+ * @property {string}      chunk       the module's chunk name
+ */
+
+/**
+ * @typedef {object} Module
+ * @property {number}   version       bytecode version
+ * @property {number}   typesVersion  type-info version, 0 before bytecode version 4
+ * @property {string[]} strings       the string table
+ * @property {Proto[]}  protos        every proto, in file order
+ * @property {Proto}    main          the main chunk's proto
+ * @property {number}   size          bytes read; equals the input's length for a well-formed module
+ */
+
+/** An import constant: the path of constants that GETIMPORT walks from the globals */
+export class Import {
+  /** @param {number} id the packed id: path length in the top 2 bits, three 10-bit constant indices below */
+  constructor(id) {
+    this.id = id
+  }
+}
+
+/** A DUPTABLE template: the keys the table starts with, and the values for those given one */
+export class TableTemplate {
+  /**
+   * @param {any[]} keys
+   * @param {any[]} values
+   */
+  constructor(keys, values) {
+    this.keys = keys
+    this.values = values
+  }
+}
+
+/** A DUPCLOSURE target: the child proto that becomes the closure */
+export class ClosureRef {
+  /** @param {Proto} proto */
+  constructor(proto) {
+    this.proto = proto
+  }
+}
+
+// Reader
+// ■■■■■■
+
+/** A cursor over the bytes; reading past the end throws */
+class Reader {
+  /** @param {Uint8Array} bytes */
+  constructor(bytes) {
+    this.bytes = bytes
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+    this.pos = 0
+  }
+
+  /** @param {number} n */
+  need(n) {
+    if (this.pos + n > this.bytes.length) throw new Error('luau: truncated bytecode at byte ' + this.pos)
+  }
+
+  u8() {
+    this.need(1)
+    return this.bytes[this.pos++]
+  }
+
+  /** A 32-bit word, signed (the instruction decoders want it that way) */
+  u32() {
+    this.need(4)
+    const v = this.view.getInt32(this.pos, true)
+    this.pos += 4
+    return v
+  }
+
+  f32() {
+    this.need(4)
+    const v = this.view.getFloat32(this.pos, true)
+    this.pos += 4
+    return v
+  }
+
+  f64() {
+    this.need(8)
+    const v = this.view.getFloat64(this.pos, true)
+    this.pos += 8
+    return v
+  }
+
+  /** A variable-length unsigned integer, 7 bits a byte, low first */
+  varint() {
+    let result = 0
+    let scale = 1
+    let byte
+    do {
+      byte = this.u8()
+      result += (byte & 127) * scale
+      scale *= 128
+    } while (byte & 128)
+    return result
+  }
+
+  /**
+   * @param   {number} n
+   * @returns {string} n bytes as a byte string
+   */
+  str(n) {
+    this.need(n)
+    let out = ''
+    for (let i = 0; i < n; i += 4096) {
+      const end = Math.min(n, i + 4096)
+      out += String.fromCharCode.apply(null, /** @type {any} */ (this.bytes.subarray(this.pos + i, this.pos + end)))
+    }
+    this.pos += n
+    return out
+  }
+}
+
+// Load
+// ■■■■
+
+/**
+ * @param   {Uint8Array} bytes  Luau bytecode from its version byte on
+ * @param   {string}     [chunk]  the chunk name errors carry
+ * @returns {Module}
+ */
+export function loadBytecode(bytes, chunk) {
+  const name = chunk || '?'
+  const r = new Reader(bytes)
+  const version = r.u8()
+  if (version === 0) throw new Error(name + r.str(bytes.length - 1))
+  if (version < VERSION_MIN || version > VERSION_MAX) {
+    throw new Error(name + ': bytecode version mismatch (expected [' + VERSION_MIN + '..' + VERSION_MAX + '], got ' + version + ')')
+  }
+
+  let typesVersion = 0
+  if (version >= 4) {
+    typesVersion = r.u8()
+    if (typesVersion < TYPE_VERSION_MIN || typesVersion > TYPE_VERSION_MAX) {
+      throw new Error(name + ': bytecode type version mismatch (expected [' + TYPE_VERSION_MIN + '..' + TYPE_VERSION_MAX + '], got ' + typesVersion + ')')
+    }
+  }
+
+  const stringCount = r.varint()
+  /** @type {string[]} */
+  const strings = []
+  for (let i = 0; i < stringCount; i++) strings.push(r.str(r.varint()))
+
+  /** @param {number} id */
+  const string = (id) => (id === 0 ? '' : strings[id - 1])
+
+  // userdata type names, which the VM has no use for
+  if (typesVersion === 3) {
+    let index = r.u8()
+    while (index !== 0) {
+      r.varint()
+      index = r.u8()
+    }
+  }
+
+  const protoCount = r.varint()
+  /** @type {Proto[]} */
+  const protos = []
+  for (let i = 0; i < protoCount; i++) protos.push(readProto(r, i, version, string, protos, name))
+
+  const mainId = r.varint()
+  if (mainId >= protos.length) throw new Error(name + ': main proto ' + mainId + ' out of range')
+  return { version, typesVersion, strings, protos, main: protos[mainId], size: r.pos }
+}
+
+/**
+ * @param   {Reader}   r
+ * @param   {number}   id
+ * @param   {number}   version
+ * @param   {(id: number) => string} string
+ * @param   {Proto[]}  protos  the protos read so far
+ * @param   {string}   chunk
+ * @returns {Proto}
+ */
+function readProto(r, id, version, string, protos, chunk) {
+  // version 12 on: each proto is prefixed with its size, so a reader can skip what it does not know
+  const protoSize = version >= 12 ? r.varint() : 0
+  const protoStart = r.pos
+  const maxStack = r.u8()
+  const numParams = r.u8()
+  const numUpvals = r.u8()
+  const isVararg = r.u8() !== 0
+  let flags = 0
+  let typeInfo = null
+  if (version >= 4) {
+    flags = r.u8()
+    const typeSize = r.varint()
+    if (typeSize > 0) {
+      r.need(typeSize)
+      // a copy: typed arrays' slice is ES2015, subarray and the constructor are older
+      typeInfo = new Uint8Array(r.bytes.subarray(r.pos, r.pos + typeSize))
+      r.pos += typeSize
+    }
+  }
+
+  const sizeCode = r.varint()
+  const code = new Int32Array(sizeCode)
+  for (let i = 0; i < sizeCode; i++) code[i] = r.u32()
+
+  const sizeK = r.varint()
+  /** @type {any[]} */
+  const k = []
+  for (let i = 0; i < sizeK; i++) {
+    const tag = r.u8()
+    if (tag === CONSTANT.nil) k.push(undefined)
+    else if (tag === CONSTANT.boolean) k.push(r.u8() !== 0)
+    else if (tag === CONSTANT.number) k.push(r.f64())
+    else if (tag === CONSTANT.string) k.push(string(r.varint()))
+    else if (tag === CONSTANT.import) k.push(new Import(r.u32()))
+    else if (tag === CONSTANT.vector) {
+      const x = r.f32()
+      const y = r.f32()
+      const z = r.f32()
+      r.f32()
+      k.push(new Vector(x, y, z))
+    } else if (tag === CONSTANT.table) {
+      const n = r.varint()
+      const keys = []
+      const values = []
+      for (let j = 0; j < n; j++) {
+        keys.push(k[r.varint()])
+        // the shape only: the code that follows sets each value
+        values.push(0)
+      }
+      k.push(new TableTemplate(keys, values))
+    } else if (tag === CONSTANT.tableWithConstants) {
+      const n = r.varint()
+      const keys = []
+      const values = []
+      for (let j = 0; j < n; j++) {
+        keys.push(k[r.varint()])
+        const index = r.u32()
+        values.push(index >= 0 ? k[index] : 0)
+      }
+      k.push(new TableTemplate(keys, values))
+    } else if (tag === CONSTANT.closure) {
+      const fid = r.varint()
+      if (fid >= protos.length) throw new Error(chunk + ': closure constant names proto ' + fid + ' before it is read')
+      k.push(new ClosureRef(protos[fid]))
+    } else throw new Error(chunk + ': unknown constant kind ' + tag)
+  }
+
+  const sizeP = r.varint()
+  const children = []
+  for (let i = 0; i < sizeP; i++) {
+    const fid = r.varint()
+    if (fid >= protos.length) throw new Error(chunk + ': child proto ' + fid + ' is not read yet')
+    children.push(protos[fid])
+  }
+
+  const lineDefined = r.varint()
+  const name = string(r.varint())
+
+  /** @type {Int32Array | null} */
+  let lines = null
+  if (r.u8() !== 0) {
+    const gapLog2 = r.u8()
+    const offsets = new Uint8Array(sizeCode)
+    let last = 0
+    for (let i = 0; i < sizeCode; i++) {
+      last = (last + r.u8()) & 255
+      offsets[i] = last
+    }
+    const intervals = ((sizeCode - 1) >> gapLog2) + 1
+    const absolute = []
+    let line = 0
+    for (let i = 0; i < intervals; i++) {
+      line += r.u32()
+      absolute.push(line)
+    }
+    lines = new Int32Array(sizeCode)
+    for (let i = 0; i < sizeCode; i++) lines[i] = absolute[i >> gapLog2] + offsets[i]
+  }
+
+  const locals = []
+  const upvalNames = []
+  if (r.u8() !== 0) {
+    const n = r.varint()
+    for (let i = 0; i < n; i++) {
+      const varName = string(r.varint())
+      const start = r.varint()
+      const end = r.varint()
+      locals.push({ name: varName, start, end, reg: r.u8() })
+    }
+    const nu = r.varint()
+    for (let i = 0; i < nu; i++) upvalNames.push(string(r.varint()))
+  }
+
+  if (version >= 11) {
+    // feedback slots: a call target (pc) or a construct site (shape), unused here
+    const slots = r.varint()
+    for (let i = 0; i < slots; i++) {
+      r.u8()
+      r.varint()
+    }
+  }
+  // the inline cost of a small function, unused here
+  if (version >= 12 && (flags & PROTO_INLINABLE) !== 0) r.varint()
+  if (version >= 12) r.pos = protoStart + protoSize
+
+  checkCode(code, children.length, chunk, id)
+
+  return { id, maxStack, numParams, numUpvals, isVararg, flags, typeInfo, code, k, protos: children, lineDefined, name, lines, locals, upvalNames, chunk }
+}
+
+/**
+ * Walks the instruction stream so a bad opcode or a cut-off AUX word fails at
+ * load, not in the middle of a run.
+ *
+ * @param {Int32Array} code
+ * @param {number} sizeP
+ * @param {string} chunk
+ * @param {number} id
+ */
+function checkCode(code, sizeP, chunk, id) {
+  for (let pc = 0; pc < code.length;) {
+    const op = code[pc] & 255
+    const length = OP_LENGTH[op]
+    if (length === 0) throw new Error(chunk + ': proto ' + id + ' has unknown opcode ' + op + ' at ' + pc)
+    if (pc + length > code.length) throw new Error(chunk + ': proto ' + id + ' ends inside an instruction at ' + pc)
+    if (op === OP.NEWCLOSURE && (code[pc] >> 16) >= sizeP) throw new Error(chunk + ': proto ' + id + ' makes a closure of a missing child at ' + pc)
+    pc += length
+  }
+}

package/script/luau/load/load.ops.js

@@ -0,0 +1,79 @@
+/**
+ * Luau's opcodes, in the order Bytecode.h numbers them (the numbers are baked
+ * into compiled bytecode), and how long each instruction is: one 32-bit word,
+ * or two when an AUX word follows.
+ */
+
+// Opcodes
+// ■■■■■■■■
+
+/** Opcode names by number, for bytecode versions 3 to 14 (the experimental and userdata ones between are not carried) */
+export const OP_NAMES = [
+  'NOP', 'BREAK', 'LOADNIL', 'LOADB', 'LOADN', 'LOADK', 'MOVE', 'GETGLOBAL', 'SETGLOBAL', 'GETUPVAL',
+  'SETUPVAL', 'CLOSEUPVALS', 'GETIMPORT', 'GETTABLE', 'SETTABLE', 'GETTABLEKS', 'SETTABLEKS', 'GETTABLEN', 'SETTABLEN', 'NEWCLOSURE',
+  'NAMECALL', 'CALL', 'RETURN', 'JUMP', 'JUMPBACK', 'JUMPIF', 'JUMPIFNOT', 'JUMPIFEQ', 'JUMPIFLE', 'JUMPIFLT',
+  'JUMPIFNOTEQ', 'JUMPIFNOTLE', 'JUMPIFNOTLT', 'ADD', 'SUB', 'MUL', 'DIV', 'MOD', 'POW', 'ADDK',
+  'SUBK', 'MULK', 'DIVK', 'MODK', 'POWK', 'AND', 'OR', 'ANDK', 'ORK', 'CONCAT',
+  'NOT', 'MINUS', 'LENGTH', 'NEWTABLE', 'DUPTABLE', 'SETLIST', 'FORNPREP', 'FORNLOOP', 'FORGLOOP', 'FORGPREP_INEXT',
+  'FASTCALL3', 'FORGPREP_NEXT', 'NATIVECALL', 'GETVARARGS', 'DUPCLOSURE', 'PREPVARARGS', 'LOADKX', 'JUMPX', 'FASTCALL', 'COVERAGE',
+  'CAPTURE', 'SUBRK', 'DIVRK', 'FASTCALL1', 'FASTCALL2', 'FASTCALL2K', 'FORGPREP', 'JUMPXEQKNIL', 'JUMPXEQKB', 'JUMPXEQKN',
+  'JUMPXEQKS', 'IDIV', 'IDIVK',
+]
+
+/**
+ * Opcodes past the contiguous table, after the userdata and experimental ones:
+ * CALLFB (a CALL and a feedback slot word) and FASTPCALL (a fast-call hint for
+ * pcall and xpcall), which the compiler emits from bytecode version 14
+ */
+const OP_LATE = { CALLFB: 87, FASTPCALL: 89 }
+
+/** Opcode numbers by name */
+export const OP = /** @type {Record<string, number>} */ ({})
+for (let i = 0; i < OP_NAMES.length; i++) OP[OP_NAMES[i]] = i
+for (const name in OP_LATE) OP[name] = OP_LATE[/** @type {'CALLFB'} */ (name)]
+
+/** Opcodes followed by an AUX word */
+const WITH_AUX = [
+  'GETGLOBAL', 'SETGLOBAL', 'GETIMPORT', 'GETTABLEKS', 'SETTABLEKS', 'NAMECALL', 'JUMPIFEQ', 'JUMPIFLE', 'JUMPIFLT',
+  'JUMPIFNOTEQ', 'JUMPIFNOTLE', 'JUMPIFNOTLT', 'NEWTABLE', 'SETLIST', 'FORGLOOP', 'FASTCALL3', 'LOADKX', 'FASTCALL2',
+  'FASTCALL2K', 'JUMPXEQKNIL', 'JUMPXEQKB', 'JUMPXEQKN', 'JUMPXEQKS',
+]
+
+/** Instruction length in words, by opcode number; 0 for a number that is no opcode */
+export const OP_LENGTH = /** @type {number[]} */ ([])
+for (let i = 0; i < 256; i++) OP_LENGTH.push(i < OP_NAMES.length || i === OP_LATE.FASTPCALL || i === OP_LATE.CALLFB ? 1 : 0)
+for (let i = 0; i < WITH_AUX.length; i++) OP_LENGTH[OP[WITH_AUX[i]]] = 2
+OP_LENGTH[OP_LATE.CALLFB] = 2
+
+// Constants
+// ■■■■■■■■■
+
+/** Constant table entry tags */
+export const CONSTANT = {
+  nil: 0,
+  boolean: 1,
+  number: 2,
+  string: 3,
+  import: 4,
+  table: 5,
+  closure: 6,
+  vector: 7,
+  tableWithConstants: 8,
+  integer: 9,
+  classShape: 10,
+  vectorD: 11,
+}
+
+/** Proto flag: the function is small enough to inline (bytecode version 12 on stores its cost) */
+export const PROTO_INLINABLE = 1 << 3
+
+/** Upvalue capture kinds (CAPTURE's A) */
+export const CAPTURE = { val: 0, ref: 1, upval: 2 }
+
+/** Oldest and newest bytecode version this loader reads */
+export const VERSION_MIN = 3
+export const VERSION_MAX = 14
+
+/** Type-info versions this loader reads */
+export const TYPE_VERSION_MIN = 1
+export const TYPE_VERSION_MAX = 3

package/script/luau/luau.convert.js

@@ -0,0 +1,259 @@
+/**
+ * Values between the host and Lua. Strings cross as UTF-8 (Lua strings are
+ * byte strings); arrays and plain objects become tables and tables become
+ * arrays or objects; host functions become Lua functions and Lua functions
+ * become host functions.
+ */
+
+import { EMPTY, LuaClosure, LuaTable, LuaThrow, NativeFunction, Vector } from './vm/vm.value.js'
+import { tostring } from './vm/vm.meta.js'
+
+/** @typedef {import('./vm/vm.js').VM} VM */
+
+/** An error from Lua code, as the host sees it */
+export class LuauError {
+  /**
+   * @param {string} message  the error value as text, with its position when there is one
+   * @param {any}    value    the error value, converted for the host
+   * @param {number} line     the source line it was raised at, 0 when unknown
+   * @param {string} chunk    the chunk that line is in
+   */
+  constructor(message, value, line, chunk) {
+    this.name = 'LuauError'
+    this.message = message
+    this.value = value
+    this.line = line
+    this.chunk = chunk
+    this.stack = new Error(message).stack
+  }
+
+  toString() {
+    return 'LuauError: ' + this.message
+  }
+}
+
+/**
+ * @param   {VM}       vm
+ * @param   {LuaThrow} e
+ * @returns {LuauError}
+ */
+export function luauError(vm, e) {
+  const message = typeof e.value === 'string' ? decodeUtf8(e.value) : decodeUtf8(tostring(vm, e.value))
+  return new LuauError(message, toJs(vm, e.value), e.line, e.chunk)
+}
+
+/** Several results from a host function: `return multi(a, b)` */
+export class Multi {
+  /** @param {any[]} values */
+  constructor(values) {
+    this.values = values
+  }
+}
+
+/**
+ * @param   {...any} values
+ * @returns {Multi}
+ */
+export function multi(...values) {
+  return new Multi(values)
+}
+
+/**
+ * @param   {string} s  a JS string
+ * @returns {string}    the same text as UTF-8 bytes, one char per byte
+ */
+export function encodeUtf8(s) {
+  let ascii = true
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) > 127) {
+      ascii = false
+      break
+    }
+  }
+  if (ascii) return s
+  let out = ''
+  for (let i = 0; i < s.length; i++) {
+    let c = s.charCodeAt(i)
+    if (c >= 0xd800 && c < 0xdc00 && i + 1 < s.length) {
+      const d = s.charCodeAt(i + 1)
+      if (d >= 0xdc00 && d < 0xe000) {
+        c = 0x10000 + ((c - 0xd800) << 10) + (d - 0xdc00)
+        i++
+      }
+    }
+    if (c < 0x80) out += String.fromCharCode(c)
+    else if (c < 0x800) out += String.fromCharCode(0xc0 | (c >> 6), 0x80 | (c & 63))
+    else if (c < 0x10000) out += String.fromCharCode(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63))
+    else out += String.fromCharCode(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63))
+  }
+  return out
+}
+
+/**
+ * @param   {string} s  a byte string
+ * @returns {string}    its UTF-8 decoding; bytes that are not valid UTF-8 become themselves
+ */
+export function decodeUtf8(s) {
+  let ascii = true
+  for (let i = 0; i < s.length; i++) {
+    if (s.charCodeAt(i) > 127) {
+      ascii = false
+      break
+    }
+  }
+  if (ascii) return s
+  let out = ''
+  for (let i = 0; i < s.length;) {
+    const c = s.charCodeAt(i)
+    let need = 0
+    let cp = c
+    if (c >= 0xf0 && c < 0xf8) {
+      need = 3
+      cp = c & 7
+    } else if (c >= 0xe0) {
+      need = c < 0xf0 ? 2 : -1
+      cp = c & 15
+    } else if (c >= 0xc0) {
+      need = 1
+      cp = c & 31
+    }
+    let ok = need > 0 && i + need < s.length
+    if (ok) {
+      for (let n = 1; n <= need; n++) {
+        const d = s.charCodeAt(i + n)
+        if ((d & 0xc0) !== 0x80) {
+          ok = false
+          break
+        }
+        cp = (cp << 6) | (d & 63)
+      }
+    }
+    if (!ok) {
+      out += String.fromCharCode(c)
+      i++
+      continue
+    }
+    i += need + 1
+    if (cp >= 0x10000) {
+      cp -= 0x10000
+      out += String.fromCharCode(0xd800 + (cp >> 10), 0xdc00 + (cp & 1023))
+    } else out += String.fromCharCode(cp)
+  }
+  return out
+}
+
+/**
+ * A host value as a Lua value. Lua values pass through; `null` is nil.
+ *
+ * @param   {VM}  vm
+ * @param   {any} v
+ * @param   {number} [depth]
+ * @returns {any}
+ */
+export function toLua(vm, v, depth) {
+  const d = depth || 0
+  if (v === null || v === undefined) return undefined
+  switch (typeof v) {
+    case 'boolean':
+    case 'number': return v
+    case 'string': return encodeUtf8(v)
+    case 'function': return hostFunction(vm, v)
+    default: break
+  }
+  if (v instanceof LuaTable || v instanceof Vector || v instanceof LuaClosure || v instanceof NativeFunction) return v
+  if (d > 64) throw new Error('luau: value nested too deeply to convert')
+  const t = new LuaTable()
+  if (Array.isArray(v)) {
+    const items = []
+    for (let i = 0; i < v.length; i++) items.push(toLua(vm, v[i], d + 1))
+    t.setRange(1, items, 0, items.length)
+  } else {
+    for (const key in v) {
+      const value = toLua(vm, v[key], d + 1)
+      if (value !== undefined) t.set(encodeUtf8(key), value)
+    }
+  }
+  return t
+}
+
+/**
+ * A host function as a Lua function. Arguments and the result convert; an
+ * error it throws becomes a Lua error.
+ *
+ * @param   {VM}       vm
+ * @param   {Function} fn
+ * @returns {NativeFunction}
+ */
+export function hostFunction(vm, fn) {
+  return new NativeFunction(fn.name || 'host', function (vm2, args) {
+    const jsArgs = []
+    for (let i = 0; i < args.length; i++) jsArgs.push(toJs(vm2, args[i]))
+    let result
+    try {
+      result = fn.apply(null, jsArgs)
+    } catch (e) {
+      if (e instanceof LuaThrow) throw e
+      const err = /** @type {any} */ (e)
+      if (err instanceof LuauError) throw new LuaThrow(encodeUtf8(err.message), 0)
+      throw new LuaThrow(encodeUtf8(err && err.message !== undefined ? String(err.message) : String(err)), 1)
+    }
+    if (result instanceof Multi) {
+      const out = []
+      for (let i = 0; i < result.values.length; i++) out.push(toLua(vm2, result.values[i]))
+      return out
+    }
+    return result === undefined ? EMPTY : toLua(vm2, result)
+  })
+}
+
+/**
+ * A Lua value as a host value: strings decode, a table whose keys are 1..n
+ * becomes an array and any other an object, a function becomes a host
+ * function (which returns nothing, its one result, or an array of them). A
+ * vector, and a function a host function made, stay as they are.
+ *
+ * @param   {VM}  vm
+ * @param   {any} v
+ * @param   {number} [depth]
+ * @returns {any}
+ */
+export function toJs(vm, v, depth) {
+  const d = depth || 0
+  if (typeof v === 'string') return decodeUtf8(v)
+  if (v instanceof LuaTable) {
+    if (d > 64) throw new Error('luau: table nested too deeply to convert')
+    if (v.hk.length - v.dead === 0) {
+      const out = []
+      for (let i = 0; i < v.arr.length; i++) out.push(toJs(vm, v.arr[i], d + 1))
+      return out
+    }
+    /** @type {Record<string, any>} */
+    const obj = {}
+    let pos = 0
+    for (;;) {
+      const next = v.advance(pos)
+      if (next === null) break
+      pos = next
+      obj[decodeUtf8(typeof v.ck === 'string' ? v.ck : tostring(vm, v.ck))] = toJs(vm, v.cv, d + 1)
+    }
+    return obj
+  }
+  if (v instanceof LuaClosure || v instanceof NativeFunction) {
+    return function () {
+      const args = []
+      for (let i = 0; i < arguments.length; i++) args.push(toLua(vm, arguments[i]))
+      let res
+      try {
+        res = vm.call(v, args)
+      } catch (e) {
+        throw e instanceof LuaThrow ? luauError(vm, e) : e
+      }
+      if (res.length === 0) return undefined
+      if (res.length === 1) return toJs(vm, res[0])
+      const out = []
+      for (let i = 0; i < res.length; i++) out.push(toJs(vm, res[i]))
+      return out
+    }
+  }
+  return v
+}