luau-obfuscator 1.0.0 → 1.0.1

package/src/passes/StringsToExpressions.ts

@@ -1,18 +1,36 @@
-import type { Program, Expression } from "luau-parser"
+import type { Program, Expression, Statement } from "luau-parser"
 import { transformExpressions } from "./walk"
-import { numberLiteral, binary, call, member, identifier } from "./nodeFactory"
+import {
+    numberLiteral, binary, call, member, identifier, table, positionalField, index,
+    localStatement, localFunctionStatement, functionParam, functionBody, functionExpression,
+    block, ifStatement, ifClause, returnStatement, paren, unary, stringLiteral,
+    numericForStatement, assignmentStatement,
+} from "./nodeFactory"
 
 export interface StringsToExpressionsOptions {
     /** 청크 하나에 들어가는 바이트 개수 최소값 */
     min: number
     /** 청크 하나에 들어가는 바이트 개수 최대값 */
     max: number
+    /**
+     * 0~1. 청크를 소스 순서 그대로 이어붙이는 대신, 순서를 섞어 저장해두고
+     * for 루프나 재귀 함수로 원래 순서를 되짚어가며 런타임에 조립할 확률.
+     * 소스에 보이는 조각 순서와 실제 결합 순서가 달라지므로, 단순 텍스트 상의
+     * concat 체인 스캔만으로는 원문을 복원할 수 없다. 기본값 0.6.
+     */
+    controlFlowProbability?: number
 }
 
+const CONTROL_FLOW_PROBABILITY_DEFAULT = 0.6
+
 function randomInt(min: number, max: number): number {
     return Math.floor(Math.random() * (max - min + 1)) + min
 }
 
+function randomName(): string {
+    return "_" + globalThis.crypto.randomUUID().replace(/-/g, "")
+}
+
 /** Luau 소스는 UTF-8 바이트 스트림이므로 charCodeAt이 아니라 실제 UTF-8 바이트로 변환.
  *  Buffer(Node 전용) 대신 표준 TextEncoder 사용 — 브라우저/번들러 환경에서도 동작. */
 function toUtf8Bytes(value: string): number[] {
@@ -35,6 +53,7 @@ function stringCharCall(bytes: number[]): Expression {
     return call(member(identifier("string"), "char"), bytes.map(numberLiteral))
 }
 
+/** 기존 방식: 청크를 소스에 보이는 순서 그대로 ".."로 이어붙임. */
 function buildConcatChain(chunks: number[][]): Expression {
     let expr: Expression = stringCharCall(chunks[0])
     for (let i = 1; i < chunks.length; i++) {
@@ -43,7 +62,146 @@ function buildConcatChain(chunks: number[][]): Expression {
     return expr
 }
 
+/** [0, n)의 무작위 순열 (Fisher-Yates) */
+function shuffledIndices(n: number): number[] {
+    const arr = Array.from({ length: n }, (_, i) => i)
+    for (let i = n - 1; i > 0; i--) {
+        const j = randomInt(0, i)
+        ;[arr[i], arr[j]] = [arr[j], arr[i]]
+    }
+    return arr
+}
+
+/** (function() ... end)() — 문(statement)들을 하나의 표현식으로 감싸는 즉시실행 함수. */
+function iife(statements: Statement[]): Expression {
+    return call(paren(functionExpression(functionBody([], block(statements)))), [])
+}
+
+/**
+ * 청크들을 뒤섞어 store 테이블에 저장하고, 원래 순서를 가리키는 order 테이블을 따로 둔다.
+ * store에 나타나는 물리적 순서 == 원문 순서가 아니므로, 소스를 눈으로 읽거나
+ * 텍스트 패턴만으로 concat해서는 원문이 나오지 않는다 — order를 통해 런타임에
+ * 역참조해야만 올바른 순서가 나온다.
+ */
+function buildShuffledTables(chunks: number[][]): { storeVar: string; orderVar: string; stmts: Statement[] } {
+    const n = chunks.length
+    const storageOrder = shuffledIndices(n) // storageOrder[slot] = 원본 청크 인덱스
+    const storeVar = randomName()
+    const orderVar = randomName()
+
+    const storeFields = storageOrder.map((originalIdx) => positionalField(stringCharCall(chunks[originalIdx])))
+
+    // order[originalIdx] = slot(1-based) — 원본 위치 k에 해당하는 조각이 store의 몇 번째에 있는지
+    const order = new Array<number>(n)
+    for (let slot = 0; slot < n; slot++) {
+        order[storageOrder[slot]] = slot + 1
+    }
+    const orderFields = order.map((slot) => positionalField(numberLiteral(slot)))
+
+    return {
+        storeVar,
+        orderVar,
+        stmts: [
+            localStatement(storeVar, table(storeFields)),
+            localStatement(orderVar, table(orderFields)),
+        ],
+    }
+}
+
+/**
+ *   (function()
+ *       local store = { ... 뒤섞인 순서의 string.char(...) 조각들 ... }
+ *       local order = { ... }
+ *       local acc = ""
+ *       for i = 1, #order do
+ *           acc = acc .. store[order[i]]
+ *       end
+ *       return acc
+ *   end)()
+ */
+function buildForLoopStringExpr(chunks: number[][]): Expression {
+    const { storeVar, orderVar, stmts } = buildShuffledTables(chunks)
+    const accVar = randomName()
+    const iVar = randomName()
+
+    return iife([
+        ...stmts,
+        localStatement(accVar, stringLiteral("")),
+        numericForStatement(
+            iVar,
+            numberLiteral(1),
+            unary("#", identifier(orderVar)),
+            block([
+                assignmentStatement(
+                    [identifier(accVar)],
+                    [
+                        binary(
+                            "..",
+                            identifier(accVar),
+                            index(identifier(storeVar), index(identifier(orderVar), identifier(iVar))),
+                        ),
+                    ],
+                ),
+            ]),
+        ),
+        returnStatement([identifier(accVar)]),
+    ])
+}
+
+/**
+ *   (function()
+ *       local store = { ... }
+ *       local order = { ... }
+ *       local function build(i, acc)
+ *           if i > #order then
+ *               return acc
+ *           end
+ *           return build(i + 1, acc .. store[order[i]])
+ *       end
+ *       return build(1, "")
+ *   end)()
+ */
+function buildRecursiveStringExpr(chunks: number[][]): Expression {
+    const { storeVar, orderVar, stmts } = buildShuffledTables(chunks)
+    const recName = randomName()
+    const iParam = randomName()
+    const accParam = randomName()
+
+    const body = block([
+        ifStatement([
+            ifClause(
+                binary(">", identifier(iParam), unary("#", identifier(orderVar))),
+                block([returnStatement([identifier(accParam)])]),
+            ),
+        ]),
+        returnStatement([
+            call(identifier(recName), [
+                binary("+", identifier(iParam), numberLiteral(1)),
+                binary(
+                    "..",
+                    identifier(accParam),
+                    index(identifier(storeVar), index(identifier(orderVar), identifier(iParam))),
+                ),
+            ]),
+        ]),
+    ])
+
+    return iife([
+        ...stmts,
+        localFunctionStatement(recName, functionBody([functionParam(iParam), functionParam(accParam)], body)),
+        returnStatement([call(identifier(recName), [numberLiteral(1), stringLiteral("")])]),
+    ])
+}
+
+type ControlFlowStrategy = "forLoop" | "recursive"
+
+function pickControlFlowStrategy(): ControlFlowStrategy {
+    return Math.random() < 0.5 ? "forLoop" : "recursive"
+}
+
 export function runStringsToExpressions(program: Program, options: StringsToExpressionsOptions): void {
+    const controlFlowProbability = options.controlFlowProbability ?? CONTROL_FLOW_PROBABILITY_DEFAULT
+
     transformExpressions(program, (expr) => {
         if (expr.type !== "StringLiteral") return
         if (expr.value.length === 0) return
@@ -51,6 +209,13 @@ export function runStringsToExpressions(program: Program, options: StringsToExpr
         const bytes = toUtf8Bytes(expr.value)
         const chunks = splitByteChunks(bytes, options.min, options.max)
 
+        // 청크가 하나뿐이면 순서를 흩뜨려도 얻는 게 없으니 그냥 원래 방식대로.
+        if (chunks.length > 1 && Math.random() < controlFlowProbability) {
+            return pickControlFlowStrategy() === "forLoop"
+                ? buildForLoopStringExpr(chunks)
+                : buildRecursiveStringExpr(chunks)
+        }
+
         return buildConcatChain(chunks)
     })
 }

package/src/passes/StripTypes.ts

@@ -1,192 +1,192 @@
-import type {
-    Program, Block, Statement, Expression, FunctionBody,
-} from "luau-parser"
-
-/**
- * 파이프라인 맨 앞에서 실행되어야 하는 패스.
- *
- * 이후 패스들(GlobalMapping, RenameVariables 등)은 값 트리만 순회하고
- * `typeof(x)`, `x :: T` 같은 타입 노드 내부의 expression은 건드리지 않는다.
- * 타입을 나중까지 들고 있으면 값 쪽 식별자는 바뀌는데 타입 쪽 참조는 원래
- * 이름 그대로 남아 출력물이 타입체크 불가능한 상태가 된다
- * (`typeof(runtimeValue)`가 obfuscate 이후에도 원본 이름을 참조하는 것이 그 예).
- *
- * 그래서 타입 정보 자체를 파이프라인 시작 시점에 전부 지워서 이 클래스의
- * 버그를 원천 차단한다:
- *  - TypeAliasStatement / ExportTypeAliasStatement 문 자체를 블록에서 제거
- *  - TypedIdentifier / FunctionParameter 의 typeAnnotation 제거
- *  - FunctionBody 의 generics / varargTypeAnnotation / returnType 제거
- *  - `expr :: T` (TypeAssertionExpression) 은 T를 버리고 expr로 치환
- */
-export function runStripTypes(program: Program): void {
-    stripBlock(program.body)
-}
-
-function stripBlock(block: Block): void {
-    const kept: Statement[] = []
-    for (const stmt of block.statements) {
-        if (stmt.type === "TypeAliasStatement" || stmt.type === "ExportTypeAliasStatement") {
-            continue
-        }
-        stripStatement(stmt)
-        kept.push(stmt)
-    }
-    block.statements = kept
-}
-
-function stripFunctionBody(func: FunctionBody): void {
-    func.generics = []
-    for (const param of func.params) delete param.typeAnnotation
-    delete func.varargTypeAnnotation
-    delete func.returnType
-    stripBlock(func.body)
-}
-
-function stripStatement(stmt: Statement): void {
-    switch (stmt.type) {
-        case "LocalStatement":
-            for (const name of stmt.names) delete name.typeAnnotation
-            for (let i = 0; i < stmt.init.length; i++) stmt.init[i] = stripExpr(stmt.init[i])
-            return
-
-        case "LocalFunctionStatement":
-            stripFunctionBody(stmt.func)
-            return
-
-        case "FunctionDeclarationStatement":
-            stripFunctionBody(stmt.func)
-            return
-
-        case "AssignmentStatement":
-            for (let i = 0; i < stmt.targets.length; i++) stmt.targets[i] = stripExpr(stmt.targets[i])
-            for (let i = 0; i < stmt.values.length; i++) stmt.values[i] = stripExpr(stmt.values[i])
-            return
-
-        case "CompoundAssignmentStatement":
-            stmt.target = stripExpr(stmt.target)
-            stmt.value = stripExpr(stmt.value)
-            return
-
-        case "CallStatement":
-            stmt.expression = stripExpr(stmt.expression) as typeof stmt.expression
-            return
-
-        case "DoStatement":
-            stripBlock(stmt.body)
-            return
-
-        case "WhileStatement":
-            stmt.condition = stripExpr(stmt.condition)
-            stripBlock(stmt.body)
-            return
-
-        case "RepeatStatement":
-            stripBlock(stmt.body)
-            stmt.condition = stripExpr(stmt.condition)
-            return
-
-        case "IfStatement":
-            for (const clause of stmt.clauses) {
-                clause.condition = stripExpr(clause.condition)
-                stripBlock(clause.body)
-            }
-            if (stmt.alternate) stripBlock(stmt.alternate)
-            return
-
-        case "NumericForStatement":
-            delete stmt.variable.typeAnnotation
-            stmt.start = stripExpr(stmt.start)
-            stmt.end = stripExpr(stmt.end)
-            if (stmt.step) stmt.step = stripExpr(stmt.step)
-            stripBlock(stmt.body)
-            return
-
-        case "GenericForStatement":
-            for (const v of stmt.variables) delete v.typeAnnotation
-            for (let i = 0; i < stmt.iterators.length; i++) stmt.iterators[i] = stripExpr(stmt.iterators[i])
-            stripBlock(stmt.body)
-            return
-
-        case "ReturnStatement":
-            for (let i = 0; i < stmt.arguments.length; i++) stmt.arguments[i] = stripExpr(stmt.arguments[i])
-            return
-
-        case "BreakStatement":
-        case "ContinueStatement":
-            return
-    }
-}
-
-function stripExpr(expr: Expression): Expression {
-    switch (expr.type) {
-        case "InterpolatedStringExpression":
-            for (const part of expr.parts) {
-                if (part.kind === "expression") part.expression = stripExpr(part.expression)
-            }
-            return expr
-
-        case "FunctionExpression":
-            stripFunctionBody(expr.func)
-            return expr
-
-        case "TableExpression":
-            for (const field of expr.fields) {
-                if (field.type === "TableFieldPositional") {
-                    field.value = stripExpr(field.value)
-                } else if (field.type === "TableFieldNamed") {
-                    field.value = stripExpr(field.value)
-                } else if (field.type === "TableFieldComputed") {
-                    field.key = stripExpr(field.key)
-                    field.value = stripExpr(field.value)
-                }
-            }
-            return expr
-
-        case "BinaryExpression":
-            expr.left = stripExpr(expr.left)
-            expr.right = stripExpr(expr.right)
-            return expr
-
-        case "UnaryExpression":
-            expr.argument = stripExpr(expr.argument)
-            return expr
-
-        case "MemberExpression":
-            expr.object = stripExpr(expr.object)
-            return expr
-
-        case "IndexExpression":
-            expr.object = stripExpr(expr.object)
-            expr.index = stripExpr(expr.index)
-            return expr
-
-        case "CallExpression":
-            expr.callee = stripExpr(expr.callee)
-            for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i])
-            return expr
-
-        case "MethodCallExpression":
-            expr.object = stripExpr(expr.object)
-            for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i])
-            return expr
-
-        case "ParenthesizedExpression":
-            expr.expression = stripExpr(expr.expression)
-            return expr
-
-        case "TypeAssertionExpression":
-            // `expr :: T` -> T를 버리고 expr만 남김 (괄호로 감싸서 우선순위 보존)
-            return stripExpr(expr.expression)
-
-        case "IfElseExpression":
-            for (const clause of expr.clauses) {
-                clause.condition = stripExpr(clause.condition)
-                clause.body = stripExpr(clause.body)
-            }
-            expr.alternate = stripExpr(expr.alternate)
-            return expr
-
-        default:
-            return expr
-    }
+import type {
+    Program, Block, Statement, Expression, FunctionBody,
+} from "luau-parser"
+
+/**
+ * 파이프라인 맨 앞에서 실행되어야 하는 패스.
+ *
+ * 이후 패스들(GlobalMapping, RenameVariables 등)은 값 트리만 순회하고
+ * `typeof(x)`, `x :: T` 같은 타입 노드 내부의 expression은 건드리지 않는다.
+ * 타입을 나중까지 들고 있으면 값 쪽 식별자는 바뀌는데 타입 쪽 참조는 원래
+ * 이름 그대로 남아 출력물이 타입체크 불가능한 상태가 된다
+ * (`typeof(runtimeValue)`가 obfuscate 이후에도 원본 이름을 참조하는 것이 그 예).
+ *
+ * 그래서 타입 정보 자체를 파이프라인 시작 시점에 전부 지워서 이 클래스의
+ * 버그를 원천 차단한다:
+ *  - TypeAliasStatement / ExportTypeAliasStatement 문 자체를 블록에서 제거
+ *  - TypedIdentifier / FunctionParameter 의 typeAnnotation 제거
+ *  - FunctionBody 의 generics / varargTypeAnnotation / returnType 제거
+ *  - `expr :: T` (TypeAssertionExpression) 은 T를 버리고 expr로 치환
+ */
+export function runStripTypes(program: Program): void {
+    stripBlock(program.body)
+}
+
+function stripBlock(block: Block): void {
+    const kept: Statement[] = []
+    for (const stmt of block.statements) {
+        if (stmt.type === "TypeAliasStatement" || stmt.type === "ExportTypeAliasStatement") {
+            continue
+        }
+        stripStatement(stmt)
+        kept.push(stmt)
+    }
+    block.statements = kept
+}
+
+function stripFunctionBody(func: FunctionBody): void {
+    func.generics = []
+    for (const param of func.params) delete param.typeAnnotation
+    delete func.varargTypeAnnotation
+    delete func.returnType
+    stripBlock(func.body)
+}
+
+function stripStatement(stmt: Statement): void {
+    switch (stmt.type) {
+        case "LocalStatement":
+            for (const name of stmt.names) delete name.typeAnnotation
+            for (let i = 0; i < stmt.init.length; i++) stmt.init[i] = stripExpr(stmt.init[i])
+            return
+
+        case "LocalFunctionStatement":
+            stripFunctionBody(stmt.func)
+            return
+
+        case "FunctionDeclarationStatement":
+            stripFunctionBody(stmt.func)
+            return
+
+        case "AssignmentStatement":
+            for (let i = 0; i < stmt.targets.length; i++) stmt.targets[i] = stripExpr(stmt.targets[i])
+            for (let i = 0; i < stmt.values.length; i++) stmt.values[i] = stripExpr(stmt.values[i])
+            return
+
+        case "CompoundAssignmentStatement":
+            stmt.target = stripExpr(stmt.target)
+            stmt.value = stripExpr(stmt.value)
+            return
+
+        case "CallStatement":
+            stmt.expression = stripExpr(stmt.expression) as typeof stmt.expression
+            return
+
+        case "DoStatement":
+            stripBlock(stmt.body)
+            return
+
+        case "WhileStatement":
+            stmt.condition = stripExpr(stmt.condition)
+            stripBlock(stmt.body)
+            return
+
+        case "RepeatStatement":
+            stripBlock(stmt.body)
+            stmt.condition = stripExpr(stmt.condition)
+            return
+
+        case "IfStatement":
+            for (const clause of stmt.clauses) {
+                clause.condition = stripExpr(clause.condition)
+                stripBlock(clause.body)
+            }
+            if (stmt.alternate) stripBlock(stmt.alternate)
+            return
+
+        case "NumericForStatement":
+            delete stmt.variable.typeAnnotation
+            stmt.start = stripExpr(stmt.start)
+            stmt.end = stripExpr(stmt.end)
+            if (stmt.step) stmt.step = stripExpr(stmt.step)
+            stripBlock(stmt.body)
+            return
+
+        case "GenericForStatement":
+            for (const v of stmt.variables) delete v.typeAnnotation
+            for (let i = 0; i < stmt.iterators.length; i++) stmt.iterators[i] = stripExpr(stmt.iterators[i])
+            stripBlock(stmt.body)
+            return
+
+        case "ReturnStatement":
+            for (let i = 0; i < stmt.arguments.length; i++) stmt.arguments[i] = stripExpr(stmt.arguments[i])
+            return
+
+        case "BreakStatement":
+        case "ContinueStatement":
+            return
+    }
+}
+
+function stripExpr(expr: Expression): Expression {
+    switch (expr.type) {
+        case "InterpolatedStringExpression":
+            for (const part of expr.parts) {
+                if (part.kind === "expression") part.expression = stripExpr(part.expression)
+            }
+            return expr
+
+        case "FunctionExpression":
+            stripFunctionBody(expr.func)
+            return expr
+
+        case "TableExpression":
+            for (const field of expr.fields) {
+                if (field.type === "TableFieldPositional") {
+                    field.value = stripExpr(field.value)
+                } else if (field.type === "TableFieldNamed") {
+                    field.value = stripExpr(field.value)
+                } else if (field.type === "TableFieldComputed") {
+                    field.key = stripExpr(field.key)
+                    field.value = stripExpr(field.value)
+                }
+            }
+            return expr
+
+        case "BinaryExpression":
+            expr.left = stripExpr(expr.left)
+            expr.right = stripExpr(expr.right)
+            return expr
+
+        case "UnaryExpression":
+            expr.argument = stripExpr(expr.argument)
+            return expr
+
+        case "MemberExpression":
+            expr.object = stripExpr(expr.object)
+            return expr
+
+        case "IndexExpression":
+            expr.object = stripExpr(expr.object)
+            expr.index = stripExpr(expr.index)
+            return expr
+
+        case "CallExpression":
+            expr.callee = stripExpr(expr.callee)
+            for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i])
+            return expr
+
+        case "MethodCallExpression":
+            expr.object = stripExpr(expr.object)
+            for (let i = 0; i < expr.arguments.length; i++) expr.arguments[i] = stripExpr(expr.arguments[i])
+            return expr
+
+        case "ParenthesizedExpression":
+            expr.expression = stripExpr(expr.expression)
+            return expr
+
+        case "TypeAssertionExpression":
+            // `expr :: T` -> T를 버리고 expr만 남김 (괄호로 감싸서 우선순위 보존)
+            return stripExpr(expr.expression)
+
+        case "IfElseExpression":
+            for (const clause of expr.clauses) {
+                clause.condition = stripExpr(clause.condition)
+                clause.body = stripExpr(clause.body)
+            }
+            expr.alternate = stripExpr(expr.alternate)
+            return expr
+
+        default:
+            return expr
+    }
 }

package/src/passes/Vmify.ts

@@ -0,0 +1,73 @@
+import type { Program, Statement } from "luau-parser"
+import { luauparser } from "luau-parser"
+import { VmCompiler, DEFAULT_BUILTIN_GLOBALS } from "./vmify/compiler"
+import { serializeProto } from "./vmify/serialize"
+import { buildVmRuntimeSource } from "./vmify/runtime"
+import { createOpcodeMap } from "./vmify/opcodes"
+import { generateVmNames } from "./vmify/names"
+import {
+    localStatement, identifier, call, table, namedField, returnStatement, vararg,
+} from "./nodeFactory"
+
+export interface VmifyOptions {
+    /**
+     * VM 밖에서 값을 그대로 참조해야 하는 전역 이름 목록(GETGLOBAL/SETGLOBAL 대상).
+     * Luau엔 getfenv가 없어서 "임의의 전역 읽기"를 흉내낼 수 없기 때문에,
+     * 여기 나열된 이름들만 브리지 테이블에 실제 값으로 미리 채워 넣는다.
+     * 나열되지 않은 전역을 참조하면 컴파일은 되지만 런타임에 nil이 나온다 — 실사용 전
+     * 반드시 프로그램에서 실제로 쓰는 전역 이름을 전부 이 목록에 채워야 함(TODO: 컴파일러가
+     * ScopeAnalysis.globalsByName을 이용해 자동으로 목록을 뽑아주도록 개선 가능).
+     */
+    builtinGlobals?: readonly string[]
+    /**
+     * opcode 번호 셔플 + 전역/필드 이름 무작위화에 쓸 난수 생성기. 지정하지 않으면
+     * Math.random. 재현 가능한 빌드가 필요하면(테스트 등) 시드 고정 PRNG를 넘길 것.
+     */
+    random?: () => number
+}
+
+/**
+ * program 전체를 바이트코드로 컴파일하고, program.body를 다음 구조로 치환한다:
+ *
+ *   local <globals> = { print = print, game = game, ... }
+ *   <런타임 인터프리터 함수 정의 — 식별자/opcode 번호는 매 빌드 무작위>
+ *   local <protoRoot> = { ...직렬화된 바이트코드... }
+ *   return <execute>(<protoRoot>, {}, ...)
+ *
+ * opcode 번호(opcodes.ts:createOpcodeMap)와 전역/필드 이름(names.ts:generateVmNames)을
+ * 매 빌드 새로 뽑기 때문에, 컴파일된 청크와 런타임 인터프리터가 산출물마다 구조적으로
+ * 달라진다 — "이 VM은 opcode 6이 GETGLOBAL이다" 같은 지식이 다음 빌드에는 안 통함.
+ *
+ * 주의: 이 패스는 pipeline.ts상 반드시 "가장 먼저"(StripTypes 다음) 실행돼야 한다 —
+ * 컴파일이 끝나면 원본 statement/expression 노드 대부분이 바이트코드 숫자로 바뀌어
+ * 사라지므로, 이후 패스(RenameVariables, EncryptStrings 등)가 손댈 원본 AST가 없다.
+ */
+export function runVmify(program: Program, options: VmifyOptions): void {
+    const globalNames = options.builtinGlobals ?? DEFAULT_BUILTIN_GLOBALS
+    const random = options.random ?? Math.random
+
+    const opcodeMap = createOpcodeMap(random)
+    const names = generateVmNames(random)
+
+    const compiler = new VmCompiler(program, globalNames, opcodeMap)
+    const topProto = compiler.compile()
+
+    const globalsTable = table(
+        globalNames.map((name) => namedField(name, identifier(name))),
+    )
+
+    const runtimeSource = buildVmRuntimeSource(names, opcodeMap)
+    const runtimeProgram = luauparser.parse(runtimeSource)
+    const runtimeStatements: Statement[] = runtimeProgram.body.statements
+
+    const protoLiteral = serializeProto(topProto, names)
+
+    const newBody: Statement[] = [
+        localStatement(names.globals, globalsTable),
+        ...runtimeStatements,
+        localStatement(names.protoRoot, protoLiteral),
+        returnStatement([call(identifier(names.execute), [identifier(names.protoRoot), table([]), vararg()])]),
+    ]
+
+    program.body.statements = newBody
+}