luau-obfuscator 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luau-obfuscator",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "luau obfuscator for roblox",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/src/passes/Vmify.ts

@@ -37,6 +37,13 @@ export interface VmifyOptions {
      * Math.random. 재현 가능한 빌드가 필요하면(테스트 등) 시드 고정 PRNG를 넘길 것.
      */
     random?: () => number
+    /**
+     * 디버그 빌드. 켜면 각 인스트럭션에 원본 소스 줄 번호를, CALL에는 호출 대상 이름을
+     * 함께 직렬화하고, 런타임 CALL 핸들러가 non-callable 값을 부르려 할 때 그냥
+     * "attempt to call a nil value"가 아니라 "[vmdebug] ... '대상이름' (source line N)"으로
+     * 원본 위치를 찍어준다. 산출물이 조금 커지고 VM 시그니처가 노출되므로 진단용으로만 쓸 것.
+     */
+    debug?: boolean
 }
 
 /**
@@ -59,10 +66,11 @@ export function runVmify(program: Program, options: VmifyOptions): void {
     const builtinGlobals = options.builtinGlobals ?? DEFAULT_BUILTIN_GLOBALS
     const random = options.random ?? Math.random
 
+    const debug = options.debug ?? false
     const opcodeMap = createOpcodeMap(random)
     const names = generateVmNames(random)
 
-    const compiler = new VmCompiler(program, builtinGlobals, opcodeMap)
+    const compiler = new VmCompiler(program, builtinGlobals, opcodeMap, debug)
     const topProto = compiler.compile()
 
     // builtinGlobals(시드 목록)가 아니라 실제로 프로그램이 참조한 전역 전체로 브릿지를
@@ -74,12 +82,12 @@ export function runVmify(program: Program, options: VmifyOptions): void {
         usedGlobalNames.map((name) => namedField(name, identifier(name))),
     )
 
-    const runtimeSource = buildVmRuntimeSource(names, opcodeMap)
+    const runtimeSource = buildVmRuntimeSource(names, opcodeMap, debug)
     const runtimeProgram = luauparser.parse(runtimeSource)
     const runtimeStatements: Statement[] = runtimeProgram.body.statements
     markRuntimeNumbersAsStructural(runtimeProgram.body)
 
-    const protoLiteral = serializeProto(topProto, names)
+    const protoLiteral = serializeProto(topProto, names, debug)
 
     const newBody: Statement[] = [
         localStatement(names.globals, globalsTable),

package/src/passes/vmify/compiler.ts

@@ -33,6 +33,8 @@ interface FuncState {
     upvalIndexByBinding: Map<BindingId, number>
     breakPatchStack: number[][]
     continuePatchStack: number[][]
+    /** debug 빌드에서 emit()이 인스트럭션에 박아넣을 "현재 컴파일 중인 소스 줄". */
+    curLine?: number
 }
 
 export class VmCompiler {
@@ -64,6 +66,7 @@ export class VmCompiler {
         private program: Program,
         builtinGlobals: readonly string[] = DEFAULT_BUILTIN_GLOBALS,
         private opcodeMap?: OpcodeMap,
+        private debug = false,
     ) {
         this.analysis = luauparser.analyzeScopes(program, { builtinGlobals })
         this.enclosing = buildEnclosingFunctionMap(program)
@@ -115,10 +118,34 @@ export class VmCompiler {
         // 물리 번호로 바꿔서 저장한다. 직접 VmCompiler를 쓰는 테스트/디버깅 코드가
         // opcodeMap 없이 호출할 수도 있으니 없으면 항등(그대로) 매핑으로 폴백.
         const physicalOp = this.opcodeMap ? this.opcodeMap[op] : op
-        state.proto.code.push({ op: physicalOp, a, b, c, comment } as Instr)
+        state.proto.code.push({ op: physicalOp, a, b, c, comment, dbgLine: this.debug ? state.curLine : undefined } as Instr)
         return state.proto.code.length - 1
     }
 
+    /** debug 빌드: 방금 emit한 CALL 인스트럭션에 "호출 대상 표현식 문자열"과 그 소스 줄을
+     *  박아넣는다(런타임이 non-callable을 잡았을 때 사람이 읽을 위치를 찍게). */
+    private stampCall(state: FuncState, idx: number, callExpr: Expression, calleeExpr: Expression): void {
+        if (!this.debug) return
+        const instr = state.proto.code[idx]
+        instr.dbgName = this.describeExpr(calleeExpr)
+        const line = (calleeExpr as { line?: { start: number } }).line ?? (callExpr as { line?: { start: number } }).line
+        if (line) instr.dbgLine = line.start
+    }
+
+    /** 표현식을 사람이 읽을 짧은 문자열로. 위치 추적용이라 완벽할 필요는 없음. */
+    private describeExpr(e: Expression): string {
+        switch (e.type) {
+            case "Identifier": return e.name
+            case "MemberExpression": return `${this.describeExpr(e.object)}.${e.property.name}`
+            case "MethodCallExpression": return `${this.describeExpr(e.object)}:${e.method.name}(...)`
+            case "IndexExpression": return `${this.describeExpr(e.object)}[...]`
+            case "CallExpression": return `${this.describeExpr(e.callee)}(...)`
+            case "ParenthesizedExpression": return `(${this.describeExpr(e.expression)})`
+            case "StringLiteral": return `"${String(e.value).slice(0, 20)}"`
+            default: return `<${e.type}>`
+        }
+    }
+
     private konst(state: FuncState, value: ConstValue): number {
         return internConst(state.proto, value)
     }
@@ -219,6 +246,7 @@ export class VmCompiler {
     }
 
     private compileStatement(stmt: Statement, state: FuncState): void {
+        if (this.debug && (stmt as { line?: { start: number } }).line) state.curLine = (stmt as { line: { start: number } }).line.start
         switch (stmt.type) {
             case "LocalStatement": {
                 // 순서 중요: 로컬(및 캡처된 것의 박스)을 "먼저" 선언해서 레지스터를 확정한 뒤에
@@ -253,11 +281,39 @@ export class VmCompiler {
                 return
             }
             case "AssignmentStatement": {
-                const valueRegs = stmt.values.map((e) => this.compileExpr(e, state))
-                stmt.targets.forEach((target, i) => {
-                    const srcReg = valueRegs[i] ?? valueRegs[valueRegs.length - 1]
-                    this.compileAssignTarget(target, srcReg, state)
-                })
+                // LocalStatement와 동일한 다중값 규칙을 따라야 한다: 우변의 "마지막" 식이
+                // Call/MethodCall/Vararg면 남는 대상 개수만큼 펼쳐야 하고(`a, b = f()` →
+                // a=1번째, b=2번째 반환값), 그 외엔 각자 1개씩. 예전 구현은 각 값을 따로
+                // compileExpr해서 대상 개수보다 값이 적으면 "마지막 값 하나를 재사용"했는데,
+                // 그 바람에 `Tools, Manager = Nova.Create()`에서 Manager가 2번째 반환값이
+                // 아니라 Tools(1번째)를 그대로 받아 "attempt to call a nil value"로 터졌다.
+                //
+                // 모든 우변을 먼저 연속 레지스터 블록(base..)에 계산한 뒤 대상에 대입한다 —
+                // 이 순서라야 `a, b = b, a`(스왑)처럼 대입 전에 우변을 전부 평가하는
+                // Lua 의미가 보존된다.
+                const targets = stmt.targets
+                const values = stmt.values
+                const base = state.regs.top()
+                if (values.length > 0) {
+                    for (let i = 0; i < values.length - 1; i++) {
+                        this.compileExprTo(values[i], state, base + i)
+                    }
+                    const lastIdx = values.length - 1
+                    const remaining = Math.max(targets.length - lastIdx, 1)
+                    this.compileExprMultiInto(values[lastIdx], state, base + lastIdx, remaining)
+                }
+                // 값보다 대상이 많으면 나머지 대상은 nil.
+                const produced = values.length === 0 ? 0 : (values.length - 1) + Math.max(targets.length - (values.length - 1), 1)
+                for (let i = produced; i < targets.length; i++) {
+                    this.emit(state, Opcode.LOADNIL, base + i, base + i, 0)
+                }
+                // 대입: 대상 프리픽스(테이블/키) 평가용 임시가 아직 안 쓴 값 슬롯을 덮지
+                // 않도록, 매 대입 전에 freereg를 값 블록 위(base+targets.length)로 올려둔다.
+                for (let i = 0; i < targets.length; i++) {
+                    state.regs.freeTemp(base + targets.length)
+                    this.compileAssignTarget(targets[i], base + i, state)
+                }
+                state.regs.freeTemp(base)
                 return
             }
             case "CompoundAssignmentStatement":
@@ -635,7 +691,7 @@ export class VmCompiler {
         // CallExpression과 동일한 이유로 top()을 미리 캐싱하지 않고 callee의 반환값을 base로 씀.
         const base = this.compileExpr(callExpr.callee, state)
         this.compileArgsContiguous(callExpr.arguments, state, base + 1)
-        this.emit(state, Opcode.CALL, base, callExpr.arguments.length + 1, wantCount + 1)
+        this.stampCall(state, this.emit(state, Opcode.CALL, base, callExpr.arguments.length + 1, wantCount + 1), callExpr, callExpr.callee)
         return base
     }
 
@@ -694,7 +750,7 @@ export class VmCompiler {
         if (expr.type === "CallExpression") {
             const calleeReg = this.compileExpr(expr.callee, state)
             const b = this.compileCallArgsAndGetB(expr.arguments, state, calleeReg + 1)
-            this.emit(state, Opcode.CALL, calleeReg, b, wantCount + 1)
+            this.stampCall(state, this.emit(state, Opcode.CALL, calleeReg, b, wantCount + 1), expr, expr.callee)
             for (let i = 0; i < wantCount; i++) {
                 if (calleeReg + i !== base + i) this.emit(state, Opcode.MOVE, base + i, calleeReg + i, 0)
             }
@@ -709,7 +765,7 @@ export class VmCompiler {
             state.regs.allocTemp()
             const argB = this.compileCallArgsAndGetB(expr.arguments, state, fnSlot + 2)
             const b = argB === 0 ? 0 : expr.arguments.length + 2
-            this.emit(state, Opcode.CALL, fnSlot, b, wantCount + 1)
+            this.stampCall(state, this.emit(state, Opcode.CALL, fnSlot, b, wantCount + 1), expr, expr)
             for (let i = 0; i < wantCount; i++) {
                 if (fnSlot + i !== base + i) this.emit(state, Opcode.MOVE, base + i, fnSlot + i, 0)
             }
@@ -740,7 +796,7 @@ export class VmCompiler {
             if (calleeReg !== base) this.emit(state, Opcode.MOVE, base, calleeReg, 0)
             state.regs.freeTemp(base + 1)
             const b = this.compileCallArgsAndGetB(expr.arguments, state, base + 1)
-            this.emit(state, Opcode.CALL, base, b, 0)
+            this.stampCall(state, this.emit(state, Opcode.CALL, base, b, 0), expr, expr.callee)
             return
         }
         if (expr.type === "MethodCallExpression") {
@@ -756,7 +812,7 @@ export class VmCompiler {
             state.regs.freeTemp(base + 2)
             const argB = this.compileCallArgsAndGetB(expr.arguments, state, base + 2)
             const b = argB === 0 ? 0 : expr.arguments.length + 2
-            this.emit(state, Opcode.CALL, base, b, 0)
+            this.stampCall(state, this.emit(state, Opcode.CALL, base, b, 0), expr, expr)
             return
         }
         if (expr.type === "VarargExpression") {
@@ -785,6 +841,7 @@ export class VmCompiler {
     }
 
     private compileExpr(expr: Expression, state: FuncState, discard = false): number {
+        if (this.debug && (expr as { line?: { start: number } }).line) state.curLine = (expr as { line: { start: number } }).line.start
         switch (expr.type) {
             case "NilLiteral": {
                 const r = state.regs.allocTemp()
@@ -914,7 +971,8 @@ export class VmCompiler {
                 // 쓴 임시 레지스터 때문에 함수 값 자체는 그 다음 슬롯에 옴).
                 const base = this.compileExpr(expr.callee, state)
                 const b = this.compileCallArgsAndGetB(expr.arguments, state, base + 1)
-                this.emit(state, Opcode.CALL, base, b, discard ? 1 : 2)
+                const callIdx = this.emit(state, Opcode.CALL, base, b, discard ? 1 : 2)
+                this.stampCall(state, callIdx, expr, expr.callee)
                 state.regs.freeTemp(base + (discard ? 0 : 1))
                 return base
             }
@@ -928,7 +986,8 @@ export class VmCompiler {
                 // self가 항상 고정으로 하나 더 붙으므로: 열려있으면(0) 그대로 0(런타임이
                 // multiTop까지 다 잡아줌, self도 그 범위 안에 포함됨), 아니면 +1(self 몫).
                 const b = argB === 0 ? 0 : expr.arguments.length + 2
-                this.emit(state, Opcode.CALL, fnSlot, b, discard ? 1 : 2)
+                const callIdx = this.emit(state, Opcode.CALL, fnSlot, b, discard ? 1 : 2)
+                this.stampCall(state, callIdx, expr, expr)
                 state.regs.freeTemp(fnSlot + (discard ? 0 : 1))
                 return fnSlot
             }

package/src/passes/vmify/opcodes.ts

@@ -50,6 +50,10 @@ export interface Instr {
     c: number
     /** JMP/EQ/LT/LE/TEST/CALL 등에서 사람이 읽을 디버깅용 주석. 런타임엔 안 쓰임. */
     comment?: string
+    /** debug 빌드에서만: 이 인스트럭션이 나온 원본 소스(입력 .luau) 줄 번호. */
+    dbgLine?: number
+    /** debug 빌드에서만: CALL이면 호출 대상 표현식을 사람이 읽을 문자열로(예: "print", "obj:method"). */
+    dbgName?: string
 }
 
 /** RK 인코딩 헬퍼: 상수는 음수(-idx-1), 레지스터는 그대로 양수. */

package/src/passes/vmify/runtime.ts

@@ -2,17 +2,24 @@ import { Opcode, type OpcodeMap } from "./opcodes"
 import type { VmNames } from "./names"
 
 /**
- * VM 런타임 v3 — opcode마다 독립된 핸들러 함수를 만들고 서로 tail call로 이어지는
- * 구조는 v2와 동일하다. 다만 이제 모든 전역 식별자(__vm_execute, __vm_handlers, ...)와
- * frame/Instr/Proto의 테이블 필드 키가 고정 문자열이 아니라, 빌드마다 무작위로 뽑힌
- * names(names.ts)와 opcode 번호 재배치 opcodeMap(opcodes.ts)을 받아 그때그때
- * 소스를 새로 찍어낸다.
+ * VM 런타임 v4 — opcode마다 독립된 핸들러 함수를 만드는 구조는 v3와 동일하다.
+ * 모든 전역 식별자(__vm_execute, __vm_handlers, ...)와 frame/Instr/Proto의 테이블
+ * 필드 키가 고정 문자열이 아니라, 빌드마다 무작위로 뽑힌 names(names.ts)와 opcode 번호
+ * 재배치 opcodeMap(opcodes.ts)을 받아 그때그때 소스를 새로 찍어낸다.
  *
- * 왜 이렇게 하나:
- *  - Luau는 proper tail call을 보장하므로(스택 안 쌓임, 성능도 loop와 동급),
- *    "재귀처럼 보이지만 실제론 loop"인 구조를 공짜로 얻을 수 있다.
+ * v3와의 결정적 차이 — dispatch를 tail call 재귀가 아니라 while 루프로 돌린다:
+ *  - v3는 "Luau가 proper tail call을 보장하므로 return dispatch(frame, pc+1)가
+ *    스택을 안 쌓는다"는 전제로 각 핸들러가 dispatch를 꼬리 호출로 이어붙였다.
+ *    그런데 Luau는 (Lua 5.x와 달리) proper tail call을 하지 않는다. 정확한 스택
+ *    트레이스/디버깅을 위해 의도적으로 뺐다. 그래서 명령어 하나 실행할 때마다
+ *    dispatch 프레임이 실제로 하나씩 쌓였고, 명령어 수백 개짜리 함수만 돌려도
+ *    stack overflow가 났다.
+ *  - v4에서는 dispatch가 while 루프를 돌며 핸들러를 호출한다. 핸들러는 dispatch를
+ *    부르지 않고 "다음 pc(숫자)"를 반환하고, RETURN만 결과 패킷(table.pack 결과)을
+ *    반환한다. 루프는 반환값이 숫자면 pc를 갱신하고, 테이블이면 그걸 풀어서 반환한다.
+ *    이제 함수 하나를 끝까지 도는 동안 스택 깊이는 일정하다.
  *  - "거대한 while+if-chain" 자체가 디컴파일러가 제일 먼저 찾는 VM 시그니처인데,
- *    이 구조는 그 패턴이 아예 없다.
+ *    루프 본문이 if-chain이 아니라 handlers[op](...) 단일 디스패치라 그 패턴은 아니다.
  *  - opcode 번호 + 식별자 이름을 빌드마다 다르게 뽑기 때문에, 한 번 리버싱해서
  *    "MOVE=0, __vm_execute라는 함수가 진입점" 같은 지식을 얻어도 다음 산출물에는
  *    그대로 안 먹힌다 — 매번 새로 분석해야 함.
@@ -21,16 +28,28 @@ import type { VmNames } from "./names"
  * (compiler.ts가 emit() 시점에 같은 opcodeMap으로 인스트럭션에 번호를 박아 넣으므로
  * 반드시 컴파일과 런타임 생성에 동일한 opcodeMap 인스턴스를 넘겨야 함).
  */
-export function buildVmRuntimeSource(names: VmNames, opcodeMap: OpcodeMap): string {
+export function buildVmRuntimeSource(names: VmNames, opcodeMap: OpcodeMap, debug = false): string {
     const N = names
     const op = (o: Opcode) => opcodeMap[o]
 
     return `
 local ${N.handlers} = {}
 
+-- 각 핸들러는 "다음 pc(숫자)"를 반환한다. RETURN 핸들러만 table.pack 결과(테이블)를
+-- 반환하며, 그게 함수 실행 종료 신호다. Luau는 proper tail call을 하지 않으므로
+-- 핸들러들이 서로 꼬리 호출로 이어지면 명령어당 스택 프레임이 쌓여 터진다 — 그래서
+-- 여기서 while 루프로 돌려 스택 깊이를 함수 실행 내내 일정하게 유지한다.
 local function ${N.dispatch}(${N.frame}, pc)
-    local instr = ${N.frame}.${N.code}[pc]
-    return ${N.handlers}[instr[1]](${N.frame}, pc, instr)
+    local ${N.handlers} = ${N.handlers}
+    while true do
+        local instr = ${N.frame}.${N.code}[pc]
+        local next = ${N.handlers}[instr[1]](${N.frame}, pc, instr)
+        if type(next) == "number" then
+            pc = next
+        else
+            return table.unpack(next, 1, next.n)
+        end
+    end
 end
 
 local function ${N.rk}(${N.frame}, x)
@@ -44,67 +63,67 @@ end
 -- MOVE
 ${N.handlers}[${op(Opcode.MOVE)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.R}[instr[3]]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- LOADK
 ${N.handlers}[${op(Opcode.LOADK)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.K}[instr[3] + 1]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- LOADBOOL
 ${N.handlers}[${op(Opcode.LOADBOOL)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = (instr[3] ~= 0)
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- LOADNIL
 ${N.handlers}[${op(Opcode.LOADNIL)}] = function(${N.frame}, pc, instr)
     for i = instr[2], instr[3] do ${N.frame}.${N.R}[i] = nil end
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- GETUPVAL
 ${N.handlers}[${op(Opcode.GETUPVAL)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.upvals}[instr[3] + 1]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- SETUPVAL
 ${N.handlers}[${op(Opcode.SETUPVAL)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.upvals}[instr[3] + 1] = ${N.frame}.${N.R}[instr[2]]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- GETGLOBAL (b는 RK가 아니라 상수풀 순수 인덱스)
 ${N.handlers}[${op(Opcode.GETGLOBAL)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.globals}[${N.frame}.${N.K}[instr[3] + 1]]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- SETGLOBAL
 ${N.handlers}[${op(Opcode.SETGLOBAL)}] = function(${N.frame}, pc, instr)
     ${N.globals}[${N.frame}.${N.K}[instr[3] + 1]] = ${N.frame}.${N.R}[instr[2]]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- GETTABLE
 ${N.handlers}[${op(Opcode.GETTABLE)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.frame}.${N.R}[instr[3]][${N.rk}(${N.frame}, instr[4])]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- SETTABLE
 ${N.handlers}[${op(Opcode.SETTABLE)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]][${N.rk}(${N.frame}, instr[3])] = ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- NEWTABLE
 ${N.handlers}[${op(Opcode.NEWTABLE)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = {}
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- SELF  (R[a] = R[b][key]; R[a+1] = R[b])
@@ -112,90 +131,90 @@ ${N.handlers}[${op(Opcode.SELF)}] = function(${N.frame}, pc, instr)
     local obj = ${N.frame}.${N.R}[instr[3]]
     ${N.frame}.${N.R}[instr[2]] = obj[${N.rk}(${N.frame}, instr[4])]
     ${N.frame}.${N.R}[instr[2] + 1] = obj
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- ADD SUB MUL DIV MOD POW
 ${N.handlers}[${op(Opcode.ADD)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) + ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 ${N.handlers}[${op(Opcode.SUB)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) - ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 ${N.handlers}[${op(Opcode.MUL)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) * ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 ${N.handlers}[${op(Opcode.DIV)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) / ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 ${N.handlers}[${op(Opcode.MOD)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) % ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 ${N.handlers}[${op(Opcode.POW)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) ^ ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- IDIV (Luau 바닥 나눗셈)
 ${N.handlers}[${op(Opcode.IDIV)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) // ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- CONCAT
 ${N.handlers}[${op(Opcode.CONCAT)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) .. ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- UNM
 ${N.handlers}[${op(Opcode.UNM)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = -${N.frame}.${N.R}[instr[3]]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- NOT
 ${N.handlers}[${op(Opcode.NOT)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = not ${N.frame}.${N.R}[instr[3]]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- LEN
 ${N.handlers}[${op(Opcode.LEN)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = #${N.frame}.${N.R}[instr[3]]
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- JMP (pc += a)
 ${N.handlers}[${op(Opcode.JMP)}] = function(${N.frame}, pc, instr)
-    return ${N.dispatch}(${N.frame}, pc + instr[2])
+    return pc + instr[2]
 end
 
 -- EQ LT LE (값 생성형 비교)
 ${N.handlers}[${op(Opcode.EQ)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) == ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 ${N.handlers}[${op(Opcode.LT)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) < ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 ${N.handlers}[${op(Opcode.LE)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = ${N.rk}(${N.frame}, instr[3]) <= ${N.rk}(${N.frame}, instr[4])
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- TEST (if (not R[a]) != (c!=0) then pc += 2 else pc += 1 — 보통 다음 명령은 JMP)
 ${N.handlers}[${op(Opcode.TEST)}] = function(${N.frame}, pc, instr)
     if (not ${N.frame}.${N.R}[instr[2]]) ~= (instr[4] ~= 0) then
-        return ${N.dispatch}(${N.frame}, pc + 2)
+        return pc + 2
     end
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- CALL
@@ -210,7 +229,13 @@ ${N.handlers}[${op(Opcode.CALL)}] = function(${N.frame}, pc, instr)
     end
     local args = table.create(nargs)
     for i = 1, nargs do args[i] = ${N.frame}.${N.R}[a + i] end
-    local rets = table.pack(fn(table.unpack(args, 1, nargs)))
+${debug ? `    if type(fn) ~= "function" then
+        local mt = getmetatable(fn)
+        if not (mt and mt.__call) then
+            error(("[vmdebug] attempt to call a %s value: '%s' (source line %d)"):format(type(fn), tostring(instr[6]), tonumber(instr[5]) or -1), 0)
+        end
+    end
+` : ""}    local rets = table.pack(fn(table.unpack(args, 1, nargs)))
     if c == 1 then
         -- discard
     elseif c == 0 then
@@ -220,23 +245,27 @@ ${N.handlers}[${op(Opcode.CALL)}] = function(${N.frame}, pc, instr)
         local want = c - 1
         for i = 1, want do ${N.frame}.${N.R}[a + i - 1] = rets[i] end
     end
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- RETURN
+-- 다른 핸들러는 "다음 pc(숫자)"를 반환하지만, RETURN만은 결과값을 table.pack으로 싸서
+-- 테이블을 반환한다 — dispatch 루프는 반환값이 숫자가 아니면 이걸 함수 종료 신호로 보고
+-- table.unpack(next, 1, next.n)으로 풀어 최종 반환한다. table.pack이 n을 채워 주므로
+-- 중간 nil이 있어도 반환 개수가 정확히 보존된다.
 ${N.handlers}[${op(Opcode.RETURN)}] = function(${N.frame}, pc, instr)
     local a, b = instr[2], instr[3]
     if b == 0 then
-        return table.unpack(${N.frame}.${N.R}, a, (${N.frame}.${N.multiTop} or (a + 1)) - 1)
+        return table.pack(table.unpack(${N.frame}.${N.R}, a, (${N.frame}.${N.multiTop} or (a + 1)) - 1))
     end
-    return table.unpack(${N.frame}.${N.R}, a, a + b - 2)
+    return table.pack(table.unpack(${N.frame}.${N.R}, a, a + b - 2))
 end
 
 -- FORPREP
 ${N.handlers}[${op(Opcode.FORPREP)}] = function(${N.frame}, pc, instr)
     local a = instr[2]
     ${N.frame}.${N.R}[a] = ${N.frame}.${N.R}[a] - ${N.frame}.${N.R}[a + 2]
-    return ${N.dispatch}(${N.frame}, pc + instr[3])
+    return pc + instr[3]
 end
 
 -- FORLOOP
@@ -252,9 +281,9 @@ ${N.handlers}[${op(Opcode.FORLOOP)}] = function(${N.frame}, pc, instr)
     end
     if ok then
         ${N.frame}.${N.R}[a + 3] = ${N.frame}.${N.R}[a]
-        return ${N.dispatch}(${N.frame}, pc + instr[3])
+        return pc + instr[3]
     end
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- CLOSURE
@@ -274,7 +303,7 @@ ${N.handlers}[${op(Opcode.CLOSURE)}] = function(${N.frame}, pc, instr)
     ${N.frame}.${N.R}[instr[2]] = function(...)
         return ${N.execute}(childProto, capturedUpvals, ...)
     end
-    return ${N.dispatch}(${N.frame}, pc + 1 + n)
+    return pc + 1 + n
 end
 
 -- VARARG
@@ -286,7 +315,7 @@ ${N.handlers}[${op(Opcode.VARARG)}] = function(${N.frame}, pc, instr)
     if instr[3] == 0 then
         ${N.frame}.${N.multiTop} = instr[2] + count
     end
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 -- SETLIST
@@ -299,7 +328,7 @@ ${N.handlers}[${op(Opcode.SETLIST)}] = function(${N.frame}, pc, instr)
     for i = 0, n - 1 do
         tbl[startIdx + i] = ${N.frame}.${N.R}[valuesBase + i]
     end
-    return ${N.dispatch}(${N.frame}, pc + 1)
+    return pc + 1
 end
 
 function ${N.execute}(proto, upvals, ...)

package/src/passes/vmify/serialize.ts

@@ -26,16 +26,22 @@ function serializeConstValue(v: ConstValue): Expression {
  * 테이블을 바로 찾아낼 수 있기 때문. runtime.ts가 같은 names로 instr.<key>를 읽으므로
  * 반드시 컴파일 시점에 쓴 것과 동일한 VmNames 인스턴스를 넘겨야 한다.
  */
-function serializeInstrs(proto: Proto): Expression {
-    const fields: TableField[] = proto.code.map((instr) =>
-        positionalField(
-            table([
-                positionalField(vmNumberLiteral(instr.op as number)),
-                positionalField(vmNumberLiteral(instr.a)),
-                positionalField(vmNumberLiteral(instr.b)),
-                positionalField(vmNumberLiteral(instr.c)),
-            ]),
-        ))
+function serializeInstrs(proto: Proto, debug: boolean): Expression {
+    const fields: TableField[] = proto.code.map((instr) => {
+        const tuple = [
+            positionalField(vmNumberLiteral(instr.op as number)),
+            positionalField(vmNumberLiteral(instr.a)),
+            positionalField(vmNumberLiteral(instr.b)),
+            positionalField(vmNumberLiteral(instr.c)),
+        ]
+        if (debug) {
+            // [5] = 소스 줄(없으면 0), [6] = 호출 대상 이름(없으면 ""). 런타임이 non-callable을
+            // 잡았을 때 이 두 값으로 원본 위치를 찍는다. instr[1..4]는 그대로라 안 건드림.
+            tuple.push(positionalField(numberLiteral(instr.dbgLine ?? 0)))
+            tuple.push(positionalField(stringLiteral(instr.dbgName ?? "")))
+        }
+        return positionalField(table(tuple))
+    })
     return table(fields)
 }
 
@@ -52,15 +58,15 @@ function serializeUpvalDescs(proto: Proto, names: VmNames): Expression {
 
 /** Proto 하나를 { numParams=.., hasVarargs=.., maxRegs=.., code={...}, consts={...}, upvalDescs={...}, protos={...} }로
  *  (필드 키는 전부 names에서 온 무작위 이름). */
-export function serializeProto(proto: Proto, names: VmNames): Expression {
+export function serializeProto(proto: Proto, names: VmNames, debug = false): Expression {
     const fields: TableField[] = [
         namedField(names.numParams, vmNumberLiteral(proto.numParams)),
         namedField(names.hasVarargs, booleanLiteral(proto.hasVarargs)),
         namedField(names.maxRegs, vmNumberLiteral(proto.maxRegs)),
-        namedField(names.code, serializeInstrs(proto)),
+        namedField(names.code, serializeInstrs(proto, debug)),
         namedField(names.consts, serializeConsts(proto.consts)),
         namedField(names.upvalDescs, serializeUpvalDescs(proto, names)),
-        namedField(names.protos, table(proto.protos.map((p) => positionalField(serializeProto(p, names))))),
+        namedField(names.protos, table(proto.protos.map((p) => positionalField(serializeProto(p, names, debug))))),
     ]
     return table(fields)
 }