makeRtc(rt: any, globalObj: any, globalEnv: any?) → any

Runtime companion. `makeRtc(rt, globalObj)` binds the JS-semantics operations compiled code calls into to a specific realm. JS values ARE realm values: undefined = values.undefined, null = values.null, numbers/strings/booleans native, objects = JSObject. Luau nil is never a JS value. `globalEnv` is the interpreter Env whose `vars` map holds the script-scope cells (top-level var/let/const/function bindings). Compiled code reads and writes the SAME cells the interpreter uses, so bindings persist across runs and across engine tiers on one VM. When absent, a private cell table is created (standalone use).

toUint32(v: any) → number

toInt32(v: any) → number

truthy(v: any) → boolean

Every hot operation opens with a native-type fast path: the overwhelming majority of dynamic operands are already numbers/booleans/strings, and the full abstract-operation path only runs for objects and mixed types.

add(l: any, r: any) → any

sub(l: any, r: any) → any

mul(l: any, r: any) → any

div(l: any, r: any) → any

mod(l: any, r: any) → any return math

pow(l: any, r: any) → any return toNumber

band(l: any, r: any) → any return toInt32

bor(l: any, r: any) → any return toInt32

bxor(l: any, r: any) → any return toInt32

shl(l: any, r: any) → any return toInt32

shr(l: any, r: any) → any return toInt32

ushr(l: any, r: any) → any return toUint32

seq(l: any, r: any) → boolean

Primitive same-type equality is native (NaN ~= NaN holds in both languages); everything else takes the abstract operation.

sneq(l: any, r: any) → boolean return not rtc

eq(l: any, r: any) → boolean

neq(l: any, r: any) → boolean return not rtc

relational(op: string, l: any, r: any) → boolean

lt(l: any, r: any) → boolean return relational

gt(l: any, r: any) → boolean return relational

le(l: any, r: any) → boolean return relational

ge(l: any, r: any) → boolean return relational

instanceOf(l: any, r: any) → boolean return rt

inOp(key: any, obj: any) → boolean

imul(a: any, b: any) → number

Math.imul: exact low-32-bit product (double multiplication loses precision past 2^53, so the multiply splits at 16 bits).

max2(a: any, b: any) → number

Two-argument Math.max/min with JS NaN propagation.

min2(a: any, b: any) → number

neg(v: any) → number return

pos(v: any) → number return toNumber

bnot(v: any) → number return toInt32

lnot(v: any) → boolean return not rt

typeof(v: any) → string return rt

get(obj: any, key: string) → any

Member read mirroring the interpreter's getMember: nullish guard, string indexing / length / StringProto, Number/Boolean protos, else realm get. An own data property on a plain object is the overwhelmingly common case, so it resolves in two table reads before the full dispatch.

iget(obj: any, idx: number) → any

Integer-indexed read: strings index characters, arrays hit the dense fast path, everything else routes through the string-key member read.

getc(obj: any, key: any) → any

Computed read: a numeric key takes the integer path, otherwise the key is coerced to a property key string.

set(obj: any, key: string, v: any) → any

iset(obj: any, idx: number, v: any) → any

setc(obj: any, key: any, v: any) → any

gget(name: string) → any

Unresolved-name access, mirroring the interpreter's lookupVar/assignVar: script-scope cells shadow the global object; a read of a name that is in neither is a ReferenceError; an assignment to one creates a global-object property.

gset(name: string, v: any) → any

gtypeof(name: string) → string

`typeof x` on an undeclared global is "undefined", not a ReferenceError.

constErr( ) → void

Script-scope declaration: `var` keeps an existing cell (redeclaration is a no-op); lexical kinds bind a fresh cell.

gdeclare(name: string, kind: string) → void

ginit(name: string, v: any) → any

Declaration initializer: writes the cell directly, bypassing the const assignment guard (a const's own initialization is not an assignment).

budget(n: number?, limit: number?, yieldMode: boolean?) → any

budgetRestore(prev: any) → void

budgetState( ) → any

The calling coroutine's budget state, seeding the plain guard when absent — loop back-edges fetch it once and decrement inline.

tickPark(st: any) → void

Slow path for an exhausted inline-decremented budget: raise, or park and refill under yield mode.

tick(n: number) → void

isCallable(fn: any) → boolean

call(fn: any, thisVal: any, args: { any }) → any

mcall(obj: any, key: string, args: { any }) → any

mcallc(obj: any, key: any, args: { any }) → any

callv(fn: any, thisVal: any, ...: ?) → any

Vararg calling convention: arguments travel as Luau varargs instead of a per-call table. A compiled callee exposes its raw closure on `__direct` (signature (this, p1..pK)) and the varargs pass straight through — Luau drops extras and leaves missing params nil, which the callee head converts to undefined. Only a non-direct callee (host, interpreter, generator/async wrapper) materializes the args table.

mcallv(obj: any, key: string, ...: ?) → any

mcallcv(obj: any, key: any, ...: ?) → any

newv(ctor: any, ...: ?) → any

Vararg `new`: a class constructor carrying `__directCtor` constructs in one call with no args table; everything else funnels into rtc.new (the table materializes only on that fallback).

new(ctor: any, args: { any }) → any

func(impl: (any, { any }) → void

Wrap a compiled Luau closure (signature impl(thisVal, args)) as a JS function object living in the realm. A call arriving on a thread with no budget state (a timer or host callback outside any run) seeds a plain guard: a runaway callback raises RangeError like the interpreter's synchronous bodies. Parking belongs exclusively to loop-spawned async bodies — a synchronous callback runs inline on the thread that pumps the timers, and parking there would suspend the pump its own resume depends on.

call(_rt: any, thisVal: any, argList: { any }) → void

funcD(direct: any, name: string, length: number, nparams: number) → any

Wrap a direct-convention compiled closure (signature (this, p1..pK)). Compiled call sites dispatch `__direct` with varargs — no args table, no budget check: direct dispatch is only reachable from inside compiled code, whose thread was seeded at its entry boundary. The `call` slot is that boundary: host, interpreter, stdlib, and timer callers arrive here with an args table, get the budget seed, and the list unpacks into the direct closure. `nparams` is the declared parameter count: the unpack width. A direct closure can observe at most its declared parameters (no `arguments`, no rest), and a fixed width stays correct when a caller-built list carries nil holes for skipped arguments (`#` would truncate there).

call(_rt: any, thisVal: any, argList: { any }) → void

arg(args: { any }, i: number) → any

arr(elems: { any }) → any

arrFin(arr: any, n: number) → void

Array-literal length finalizer: trailing holes extend the length past the last written index without creating properties.

obj( ) → any

objLit(vals: any, keyList: { string }) → any

A plain object literal in one construction: `vals` becomes the props table directly and `keyList` the insertion-ordered keys (duplicates already collapsed at compile time). A value that is undefined simply has no vals entry while its key stays listed — present-with-undefined.

throw(v: any) → void

isJsThrow(e: any) → void

spread(v: any) → void

Expand an iterable into a Luau array of JS values (array spread, call spread, and array destructuring share this).

dguard(v: any) → void

Destructuring support, mirroring the interpreter's bindPattern. A nullish destructuring source is a TypeError.

relem(source: any, index: number) → any

One element of a destructured source: array/object by index, string by character, anything else undefined.

dget(source: any, key: string) → any

One property of a destructured source (string keys resolve through the member read so string sources get their prototype methods).

restArr(v: any, start: number) → any

Array-rest: the elements of `v` from index `start` on, as a new array.

restObj(v: any, consumed: { [string]: boolean }) → any

Object-rest: the enumerable own keys of `v` not in `consumed`.

restArgs(args: { any }, start: number) → any

Rest parameter: the tail of the call's argument list from `start` (1-based).

isCallableObj(v: any) → boolean

classCtx(name: string, superVal: any) → any

Validate the heritage clause and build the class context: prototype object, super constructor, derived flag.

runFields(ctx: any, instance: any) → void

Run the instance field initializers against a revealed instance.

classBuild(ctx: any, ctorImpl: any, ctorLen: number, fields: any, directN: number?) → any

Build the constructor function object and wire the prototype chain. `ctorImpl(this, args)` is the compiled constructor body (nil for the default constructor); in a derived class it receives rtc.TDZ as `this` and must reveal it via super(). `directN` marks a positional-convention constructor body: the impl's signature is (this, p1..pN) instead of (this, argList). Only base (non-derived) constructors take it; classBuild then exposes `__directCtor` so rtc.newv constructs with zero intermediate tables.

call(_rt2: any, _thisVal: any, _args: { any }) → void

construct(_rt2: any, args: { any }, _newTarget: any) → void

superNew(ctx: any, args: { any }) → any

super(...) inside a derived constructor: construct through the super constructor, adopt the instance under this class's prototype, run the field initializers, and reveal it as `this`.

superGet(ctx: any, static: boolean, key: string) → any

super.<key> read: through the home object's parent with the current `this` untouched. Instance members resolve through the prototype's parent; static members through the super constructor.

superCall(ctx: any, static: boolean, key: string, thisVal: any, args: { any }) → any

thisChk(v: any) → any

Guard a `this` read in a derived constructor before super() has run.

ctorRet(v: any, thisVal: any) → any

An explicit `return v` from a derived constructor: an object result overrides; anything else yields the revealed `this`.

installAccessor(target: any, key: string, half: string, fn: any) → void

Install one accessor half (a JS function) onto a target, merging with an existing accessor entry for the other half.

ctorFastW(instance: any) → boolean

Constructor write fast-path eligibility, sampled once at constructor entry: true when no object on the instance's prototype chain owns an accessor. Field writes emitted under this flag also compare rt.accGen against its entry sample, so any accessor install or prototype mutation mid-body reroutes the remaining writes through rt.set.

classMethod(ctx: any, static: boolean, key: string, fn: any) → void

classAcc(ctx: any, static: boolean, key: string, half: string, fn: any) → void

classSField(ctx: any, key: string, init: any) → void

objAcc(obj: any, key: string, half: string, fn: any) → void

Object-literal accessor property.

await(v: any) → any

Async functions and generators. Compiled bodies are ordinary Luau, so they suspend with coroutine.yield exactly like the interpreter's async machinery, sharing the same VM loop and promise module. Await: resolve the operand to a promise (one microtask tick even for non-thenables, per spec) and suspend this coroutine until settlement.

asyncFunc(impl: (any, { any }) → void

An async call runs its body in a loop-spawned coroutine and returns a result promise: the synchronous prefix runs during the call, the body suspends at its first await, a JS throw becomes the rejection, and a returned value or thenable is adopted.

call(_rt2: any, thisVal: any, args: { any }) → void

yield(v: any) → any

yield / yield*: runs on the generator's coroutine; the value sent into the matching next() becomes the expression's result.

yieldStar(v: any) → any

genFunc(impl: (any, { any }) → void

A generator call builds a suspended body on its own coroutine; next() resumes it to the next yield. The generator object carries next/return and registers with the realm's iterator protocol.

call(_rt2: any, thisVal: any, args: { any }) → void

step(sendVal: any) → void

call(_rt3: any, _this3: any, nargs: { any }) → void

call(_rt3: any, _this3: any, nargs: { any }) → void

importCall(spec: any) → any

import() expression: resolve through the realm's dynamic-import hook and hand back a settled promise of the namespace (module bodies evaluate synchronously, so the promise is born resolved or rejected).

importMeta(url: string) → any

import.meta: an object carrying the module's url.

regex(pattern: string, flags: string) → any

A regex literal constructs a fresh RegExp through the realm's RegExp constructor, so each evaluation yields an independent object with its own lastIndex.

iter(v: any) → void

for-of driver: returns a step function yielding (hasValue, value). Arrays iterate by live index (length re-read each step), mirroring the interpreter's array-first iteration; strings yield characters; anything else consults the realm's iterator registry.

keys(v: any) → void

for-in driver: enumerable keys of the object and its prototype chain.

jsName(name: string) → string

propIsPlain(name: string) → boolean

bail(node: any, why: string?) → never

isSimpleNode(node: any) → boolean

A node whose evaluation is order-independent and side-effect-free, safe to inline into an operand position without a temp.

newGen( ) → any

emit(self: any, line: string) → void

newTemp(self: any) → string

Transient temp from the function's register pool. Pool slots are declared once at the function head and reassigned; the counter resets at each statement, so a statement's operand temps recycle the same few registers instead of exhausting Luau's 200-local limit on large bodies. A pool value never outlives its statement's own emission.

persistTemp(self: any) → string

Construct-persistent temp: a dedicated local whose value survives across nested statement execution (loop step functions, switch state, try results). Never recycled.

markPoolSlot(self: any) → void

Record where the pool declaration belongs (after the function preamble); `finishPool` inserts it once the body is generated and the high-water mark is known.

finishPool(self: any) → void

pushScope(self: any) → void

popScope(self: any) → void

declare(self: any, name: string, kind: string?) → void

`kind` distinguishes const bindings (assignment traps) from mutable ones.

isConstLocal(self: any, name: string) → boolean

Is the nearest declaration of `name` a const binding?

isLocal(self: any, name: string) → boolean

currentScopeHas(self: any, name: string) → boolean

Declared in the innermost scope specifically — lexical declarations shadow an outer binding by emitting a fresh Luau local, so the check that guards redeclaration must not look past the current scope.

scanPatternNames(pat: any, out: { string }) → void

Hoisting scan: collect var + function-declaration names reachable in a function/program body without descending into nested functions.

scanVarsList(body: { any }, out: { string }) → void

scanVarsStmt(stmt: any, out: { string }) → void

numericExpr(node: any, numVars: { [string]: boolean }) → boolean

inferTypes(body: { any }) → void

Scan one function body (not descending into nested function bodies except to spot assignments that capture and mutate outer names) and return (numVars, arrVars): the names provably number- and array-typed throughout.

demote(name: string) → void

recordAssign(name: string, rhs: any) → void

scanNestedFn(node: any) → void

Inside a nested function only mutations of outer names matter.

scanExpr(node: any) → void

scanStmt(node: any) → void

referencesArguments(node: any) → boolean

Does a function body reference `arguments`? Arrows inherit the outer binding, so the scan descends into arrow functions but not into nested non-arrow functions (which bind their own).

directEligible(node: any) → boolean

Shared direct-convention parameter eligibility: no rest param, no duplicate plain names, a bounded count, and no `arguments` reference in a non-arrow body. Used by function emission and by class emission when deciding whether a constructor body can take the positional convention.

scanLexical(body: { any }, out: { string }) → void

Direct block-level lexical declarations (let/const/class/function names) that become locals scoped to this block.

expr(self: any, node: any) → string

Expressions Compile a node to a Luau expression string, emitting any needed preceding statements. Guarantees left-to-right evaluation for callers that sequence operands through `operand`.

operand(self: any, node: any) → string

Evaluate a node into a simple operand (inline for trivial nodes, otherwise a hoisted temp) so an ordered operand list keeps left-to-right evaluation.

arrayLit(self: any, node: any) → string

objectLit(self: any, node: any) → string

rtNumKey(n: number) → string

isSuperNode(node: any) → boolean

emitSetNamed(self: any, obj: string, name: string, v: string) → void

Emit a named member write: an overwrite of an existing own data property lands directly in the props slot with zero calls (own presence shadows any proto setter); everything else — new keys, accessors, frozen/proxy/array/ typed-array receivers, primitives — takes the full runtime write.

memberGet(self: any, node: any) → string

argList(self: any, args: { any }) → string

Build a Luau table-constructor of the argument values, expanding spreads.

argParts(self: any, args: { any }) → string

Arguments as a bare operand list for the vararg calling convention. Returns nil when the call needs the table form (spread, or a list big enough to pressure the register file).

call(self: any, node: any) → string

isNum(self: any, node: any) → boolean

Is this expression provably number-typed under the current function's inferred locals?

isArr(self: any, node: any) → boolean

boolTest(self: any, node: any) → string

Compile a test-position expression to a Luau boolean: comparisons and logical not are already boolean; everything else goes through rtc.truthy.

binary(self: any, node: any) → string

numGuard( ) → string

operand() results are re-read-safe (literals, locals, temps; globals hoist), so the guard can reference them twice. A side that is a number literal or a proven-number expression needs no runtime check.

emitArmInto(self: any, node: any, dest: string) → void

Emit an arm's value into an existing destination temp. A Cond or Logical in arm position threads the destination down instead of allocating its own temp, so right-nested ternary/guard chains cost one register per chain. The arm's scratch temps die once the result lands, so the counter rewinds.

logicalInto(self: any, node: any, dest: string) → void

condInto(self: any, node: any, dest: string) → void

logical(self: any, node: any) → string

Short-circuit operators compile to a temp filled by if-statements, so the right operand is only evaluated when needed and no closure is allocated.

cond(self: any, node: any) → string

unary(self: any, node: any) → string

assign(self: any, node: any) → string

Assignment as an expression: returns the assigned value.

patBind(self: any, pat: any, srcT: string, mode: string) → void

Recursive destructuring emission. `srcT` is a Luau temp holding the current source value; `mode` picks the leaf binding form: "local" — declare (or assign an already-declared) Luau local "gvar" — program-level var: assign the hoisted script-scope cell "ginit" — program-level let/const: initialize the script-scope cell "assign" — plain assignment (locals, globals, and member targets)

resolveLocal(self: any, name: string) → void

Resolve a name to its storage: the scope index it binds in (nearest-first) and its kind, or nil when unbound (a global reference).

varRef(self: any, name: string) → string

The Luau expression for a bound name. A module compiled in spill mode keeps its module-scope bindings in the `_L` table (one upvalue for every nested function, no per-binding local/upvalue registers); everything else is a plain local.

identRef(self: any, name: string) → string

emitDenseWrite(self: any, obj: string, key: string, v: string) → void

Inline dense-array element write for a proven array binding and numeric index: overwrites hit the slot, appends push the dense boundary and bump the length property (always present on the key list from newArray on); gaps and non-integer indices take the runtime write.

emitAssignIdent(self: any, name: string, valueExpr: string) → void

update(self: any, node: any, asExpr: boolean) → string

++/-- : returns old value (postfix) or new value (prefix).

template(self: any, node: any) → string

funcExpr(self: any, node: any, opts: any?) → string

opts.classCtx = { ctxT, static } enables super resolution in the body; opts.ctor = { ctxT, derived } marks a constructor body (this-TDZ guards, return-through-ctorRet, super() revealing `this`); opts.raw emits a plain Luau closure instead of a realm function object (constructor impls).

classExpr(self: any, node: any) → string

Compile a class (declaration or expression) to an IIFE producing the constructor. Member bodies compile as realm functions with the class context bound for super resolution; the constructor compiles as a raw closure invoked by the runtime's construct path.

memberKeyExpr(member: any) → string

fieldInit(valueNode: any, static: boolean) → string

A field initializer compiles to a plain closure over `this`, with the class context available for super and the class-name binding captured.

stmt(self: any, node: any) → void

Statements

varDecl(self: any, node: any) → void

funcDecl(self: any, node: any) → void

exprStmt(self: any, node: any) → void

discardExpr(self: any, e: any) → void

Evaluate an expression for effect only. A call compiles to a bare Luau call statement; anything else assigns a recycled pool slot (a fresh `local _` per statement would exhaust the register file on large bodies).

assignEffect(self: any, node: any) → void

Assignment executed for side effect (statement position).

ifStmt(self: any, node: any) → void

countNodes(node: any) → number

Approximate interpreter step count of a subtree: one step per AST node, excluding nested function bodies (their steps are consumed when called). Loop back-edges tick this amount so the step budget trips at roughly the same script size on both tiers.

hasDirectContinue(node: any) → boolean

Does this statement subtree contain a Continue that would bind to the loop being compiled (not to a nested loop, and not inside a nested function)?

noComp(self: any, fn: () → void

Loop bodies do not feed the program completion value (the interpreter's While/DoWhile/For all complete with no value); clear the accumulator while compiling one.

emitLoopBudget(self: any, cost: number) → string

The loop's budget back-edge: the coroutine's state is fetched once ahead of the loop, and each iteration decrements inline with a rare slow call.

whileStmt(self: any, node: any) → void

loopBodyWithTail(self: any, body: any, emitTail: () → void

A loop whose Luau body has trailing statements after the JS body (a for update, a do-while test) cannot use a bare Luau `continue` — it would skip them. When the JS body continues directly, wrap it in a one-shot repeat so continue compiles to breaking the wrapper, landing on the trailing code.

doWhileStmt(self: any, node: any) → void

forStmt(self: any, node: any) → void

stmtForUpdate(self: any, expr: any) → void

forOfStmt(self: any, node: any) → void

forInStmt(self: any, node: any) → void

bindForHead(self: any, left: any, valueTmp: string) → void

Bind the loop variable of a for-of/for-in head to the Luau temp holding the current value/key.

tryStmt(self: any, node: any) → void

switchStmt(self: any, node: any) → void

stmtOrBlock(self: any, node: any) → void

blockBody(self: any, body: { any }) → boolean

A block body: pre-declare its lexical bindings, initialize function declarations (hoisted: callable before their source position), then compile the remaining statements. Compilation stops after a Luau control terminator (return/break/continue) — Luau forbids statements after one in a block, and the dropped JS statements are unreachable. Returns true when the emitted block ended in a terminator.

block(self: any, body: { any }) → boolean

compile(source: string, sourceName: string?) → void

Entry points

collectDeclNames(decl: any, out: { string }) → void

Collect the bound names of a declaration statement (VarDecl patterns, function/class ids) — the names an `export <decl>` exposes.

compileModule(source: string, id: string, importNames: { string }, parsedAst: any?) → void

Compile a module body to a Luau chunk. The chunk takes (rtc, imports) — `imports` maps local import names to their resolved values — and returns { exports = { exportedName = value }, hasDefault, default }: the same completion snapshot the interpreter's evalModuleBody builds. Module-level bindings are chunk locals (module scope dies with the module), so the function-level type inference applies to module code. `parsedAst` (when the caller already parsed the module) skips the re-parse.

loadChunk(luau: string, name: string) → void

loadModule(source: string, id: string, importNames: { string }, parsedAst: any?) → void

Compile and load a module body; the chunk takes (rtc, imports).

load(source: string, sourceName: string?) → void

Compile and load: returns a chunk taking the runtime companion `rtc`.

runOn(rt: any, globalObj: any, source: string, sourceName: string?) → any

Convenience: compile `source` and run it against realm `rt` + `globalObj`, returning the JS completion value (not marshaled).