@loom-dev/luau 0.0.0-stage → 0.14.0

package/dist/mount-2LXSpSYv.js

@@ -0,0 +1,1444 @@
+import { CFrame, Color3, ColorSequence, ColorSequenceKeypoint, Content, DateTime, Enum, EnumItem, Font, LoomSignal, NumberRange, NumberSequence, NumberSequenceKeypoint, Random, Rect, RobloxEnum, TweenInfo, UDim, UDim2, Vector2, Vector3, createInstance, enumTypeName, game, heartbeat, isLoomInstance, isLuaTuple, robloxEquals } from "@loom-dev/runtime";
+import createLuauModule from "../wasm/luau-vm.mjs";
+import { initLayout } from "@loom-dev/layout";
+import { createWorld } from "@loom-dev/react";
+//#region src/prelude.ts
+/**
+* `prelude.ts` — the Luau half of the globals.
+*
+* Runs once on the main state before the globals freeze, with a table of host
+* primitives as its argument (see `install` in `bindings.ts`). What lives here
+* is what is simplest to say in Luau itself: the `task` library on top of
+* `coroutine` and the host's resume points, and the `print`/`warn` that
+* `tostring` their arguments the way the engine does.
+*/
+const PRELUDE = `
+local host = ...
+
+local function thread(f)
+	return if type(f) == "thread" then f else coroutine.create(f)
+end
+
+local task = {}
+
+function task.spawn(f, ...)
+	local co = thread(f)
+	local ok, err = coroutine.resume(co, ...)
+	if not ok then
+		host.report(tostring(err), debug.traceback(co))
+	end
+	return co
+end
+
+function task.defer(f, ...)
+	local co = thread(f)
+	host.defer(co, ...)
+	return co
+end
+
+function task.delay(seconds, f, ...)
+	local co = thread(f)
+	host.delay(seconds or 0, co, ...)
+	return co
+end
+
+task.wait = host.wait
+
+function task.cancel(co)
+	coroutine.close(co)
+end
+
+function task.synchronize() end
+function task.desynchronize() end
+
+_G.task = task
+
+-- The engine's additions to \`debug\`: the MicroProfiler labels and the memory
+-- categories. loom has neither profiler, so they record nothing. Ripple wraps
+-- every Heartbeat step in a profile label.
+function debug.profilebegin(_label) end
+function debug.profileend() end
+function debug.setmemorycategory(_tag) return "" end
+function debug.resetmemorycategory() end
+function debug.getmemorycategory() return "" end
+wait = task.wait
+spawn = task.defer
+delay = task.delay
+tick = host.tick
+time = host.time
+elapsedTime = host.time
+
+local function join(...)
+	local n = select("#", ...)
+	local parts = table.create(n)
+	for i = 1, n do
+		parts[i] = tostring((select(i, ...)))
+	end
+	return table.concat(parts, " ")
+end
+
+function print(...)
+	host.print(join(...))
+end
+
+function warn(...)
+	host.warn(join(...))
+end
+
+function require(module)
+	-- A string path resolves from the requiring script: the caller's own
+	-- environment holds it as \`script\`.
+	local from = if type(module) == "string" then getfenv(2).script else nil
+	local ok, value = host.require(module, from)
+	if not ok then
+		error(value, 2)
+	end
+	return value
+end
+`;
+//#endregion
+//#region src/project.ts
+/**
+* `project.ts` — a Rojo project as live instances, and the client's startup.
+*
+* The preview plugin reads a project from disk (`default.project.json`, or the
+* Rojo template's `src/{client,server,shared}` when there is none) and hands it
+* over as a `LuauProjectNode` tree with every script's source inlined. Here it
+* becomes real instances under the runtime's `game`: Folders, ModuleScripts,
+* LocalScripts and Scripts in their services, with each script's source kept
+* beside it — Roblox does not let a LocalScript read `Source`, and neither
+* does loom.
+*
+* `startClient` then does what a joining client does: run the LocalScripts in
+* ReplicatedFirst, copy StarterGui into PlayerGui and StarterPlayerScripts into
+* PlayerScripts, and run the LocalScripts that land there. Server Scripts are
+* instantiated (so `require` and `FindFirstChild` see them) but never run — a
+* preview is one client.
+*/
+const SOURCES = /* @__PURE__ */ new WeakMap();
+/** Attach `source` to a script instance (what `require` and `startClient` run). */
+function setScriptSource(script, source) {
+	SOURCES.set(script, source);
+}
+/** The source behind a script instance, if loom has one for it. */
+function getScriptSource(script) {
+	return SOURCES.get(script);
+}
+/**
+* `Clone`, keeping every script's source. The runtime copies instances but
+* knows nothing about loom's source registry, so the two trees are walked side
+* by side — `Clone` keeps child order and drops the non-Archivable ones.
+*/
+function cloneWithSources(original) {
+	const copy = original.Clone();
+	if (copy !== void 0) copySources(original, copy);
+	return copy;
+}
+function copySources(from, to) {
+	const source = SOURCES.get(from);
+	if (source !== void 0) SOURCES.set(to, source);
+	const kept = from.GetChildren().filter((child) => child.Archivable !== false);
+	const copies = to.GetChildren();
+	kept.forEach((child, i) => {
+		const copy = copies[i];
+		if (copy !== void 0) copySources(child, copy);
+	});
+}
+const instantiated = /* @__PURE__ */ new WeakSet();
+/**
+* Build `project` into the runtime's `game`, once per project object. A node
+* whose name and class match an instance that already exists (a service,
+* `StarterPlayerScripts`) is merged into it rather than duplicated.
+*/
+function instantiateProject(project) {
+	if (instantiated.has(project)) return;
+	instantiated.add(project);
+	for (const child of project.tree.children ?? []) populate(game.GetService(child.name), child);
+}
+function populate(parent, node) {
+	for (const child of node.children ?? []) {
+		const existing = parent.FindFirstChild(child.name);
+		const instance = existing?.ClassName === child.className ? existing : createInstance(child.className, child.name);
+		if (child.source !== void 0) setScriptSource(instance, child.source);
+		populate(instance, child);
+		instance.Parent = parent;
+	}
+}
+/**
+* The client's startup, in Roblox order: ReplicatedFirst's LocalScripts, then
+* StarterGui copied into PlayerGui, then StarterPlayerScripts copied into
+* PlayerScripts. Returns every LocalScript that should run, in that order.
+*/
+function startClient() {
+	const player = game.GetService("Players").LocalPlayer;
+	const playerGui = player.WaitForChild("PlayerGui");
+	let playerScripts = player.FindFirstChildOfClass("PlayerScripts");
+	if (playerScripts === void 0) {
+		playerScripts = createInstance("PlayerScripts", "PlayerScripts");
+		playerScripts.Parent = player;
+	}
+	const scripts = [];
+	collect(game.GetService("ReplicatedFirst"), scripts);
+	for (const child of game.GetService("StarterGui").GetChildren()) {
+		const copy = cloneWithSources(child);
+		if (copy === void 0) continue;
+		copy.Parent = playerGui;
+		collect(copy, scripts);
+	}
+	const starterScripts = game.GetService("StarterPlayer").FindFirstChild("StarterPlayerScripts");
+	for (const child of starterScripts?.GetChildren() ?? []) {
+		const copy = cloneWithSources(child);
+		if (copy === void 0) continue;
+		copy.Parent = playerScripts;
+		collect(copy, scripts);
+	}
+	return scripts;
+}
+/** `root` and its descendants' runnable LocalScripts, in tree order. */
+function collect(root, into) {
+	for (const instance of [root, ...root.GetDescendants()]) {
+		if (instance.ClassName !== "LocalScript" || instance.Disabled === true) continue;
+		const source = SOURCES.get(instance);
+		if (source !== void 0) into.push({
+			script: instance,
+			source
+		});
+	}
+}
+//#endregion
+//#region src/vm.ts
+/**
+* `vm.ts` — `LuauVM`, the Luau virtual machine (upstream Luau compiled to
+* WASM, see `native/`) with a JavaScript-shaped API on top of its stack.
+*
+* The VM knows nothing about Roblox. It moves values across the boundary and
+* runs threads; `bindings.ts`-style layers decide what Luau sees:
+*
+* - Luau → JS: nil is `undefined`, booleans/numbers/strings are themselves, a
+*   host userdata is the JS object it was made from, and tables, functions and
+*   threads arrive as `LuauTable`/`LuauFunction`/`LuauThread` references.
+* - JS → Luau: a JS function becomes a host function; an object the
+*   classifier recognises becomes host userdata dispatched through its
+*   `HostClass` (the same object is always the same userdata, so `==` and
+*   table keys behave); plain arrays and objects are copied into new tables.
+*
+* Yielding is Roblox's model: a host function that returns a `Suspend` yields
+* the calling thread, and the thread runs again when the `Suspend` resumes it —
+* whoever resumed the thread in the first place.
+*/
+const KIND_NIL = 0;
+const KIND_BOOLEAN = 1;
+const KIND_NUMBER = 2;
+const KIND_STRING = 3;
+const KIND_TABLE = 4;
+const KIND_FUNCTION = 5;
+const KIND_HOST = 6;
+const KIND_THREAD = 7;
+const LUA_OK = 0;
+const LUA_YIELD = 1;
+/** `LUA_GLOBALSINDEX`: `-LUAI_MAXCSTACK - 2002`, with Luau's default 8000. */
+const LUA_GLOBALSINDEX = -10002;
+const LUA_COSUS = 1;
+const LB_ERROR = -1;
+const LB_YIELD = -2;
+/** An error raised in Luau, or by a host function on Luau's behalf. */
+var LuauError = class extends Error {
+	value;
+	traceback;
+	name = "LuauError";
+	constructor(message, value = message, traceback) {
+		super(message);
+		this.value = value;
+		this.traceback = traceback;
+	}
+};
+/** Several return values from a host function. */
+var Tuple = class {
+	values;
+	constructor(values) {
+		this.values = values;
+	}
+};
+/** Return several values from a host function. */
+function tuple(...values) {
+	return new Tuple(values);
+}
+/**
+* Returned by a host function to yield the thread that called it. `wait` runs
+* once the thread has actually suspended and receives the function that
+* resumes it with the host function's results.
+*/
+var Suspend = class {
+	wait;
+	constructor(wait) {
+		this.wait = wait;
+	}
+};
+const METAMETHODS = [
+	"__index",
+	"__newindex",
+	"__namecall",
+	"__call",
+	"__tostring",
+	"__eq",
+	"__lt",
+	"__le",
+	"__len",
+	"__unm",
+	"__add",
+	"__sub",
+	"__mul",
+	"__div",
+	"__idiv",
+	"__mod",
+	"__pow"
+];
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/** A reference that keeps a Luau value alive until the JS side is collected. */
+var LuauRef = class {
+	vm;
+	ref;
+	constructor(vm, ref) {
+		this.vm = vm;
+		this.ref = ref;
+		vm.track(this, ref);
+	}
+};
+/** A Luau function. `call` runs it to completion; `spawn` gives it a thread. */
+var LuauFunction = class extends LuauRef {
+	call(...args) {
+		return this.vm.call(this, args);
+	}
+	spawn(...args) {
+		return this.vm.spawn(this, args);
+	}
+};
+/** A Luau table, read and written raw (no metamethods). */
+var LuauTable = class extends LuauRef {
+	get(key) {
+		return this.vm.tableGet(this, key);
+	}
+	set(key, value) {
+		this.vm.tableSet(this, key, value);
+	}
+	/** `#t`. */
+	get length() {
+		return this.vm.tableLength(this);
+	}
+	/** Every key/value pair, in `next` order. */
+	entries() {
+		return this.vm.tableEntries(this);
+	}
+	/** `t[1]` … `t[#t]`. */
+	array() {
+		const out = [];
+		const n = this.length;
+		for (let i = 1; i <= n; i++) out.push(this.get(i));
+		return out;
+	}
+};
+/** A Luau coroutine. */
+var LuauThread = class extends LuauRef {};
+/** A Luau value JS has no use for beyond handing it back (vector, buffer, …). */
+var LuauOpaque = class extends LuauRef {
+	typeName;
+	constructor(vm, ref, typeName) {
+		super(vm, ref);
+		this.typeName = typeName;
+	}
+};
+var LuauVM = class LuauVM {
+	/** Instantiate the WASM module and open a fresh Luau state. */
+	static async create(options = {}) {
+		let vm;
+		const module = await createLuauModule({
+			lbHostCall: (L, id) => vm.hostCall(L, id),
+			lbHostRelease: (handle) => vm?.hostRelease(handle),
+			...options.locateFile ? { locateFile: options.locateFile } : {},
+			...options.wasmBinary ? { wasmBinary: options.wasmBinary } : {}
+		});
+		vm = new LuauVM(module, options);
+		return vm;
+	}
+	M;
+	L;
+	classify;
+	onError;
+	budgetMs;
+	sharedTables;
+	entries = [];
+	functionIds = /* @__PURE__ */ new Map();
+	debugNames = /* @__PURE__ */ new Map();
+	handles = /* @__PURE__ */ new Map();
+	handleOf = /* @__PURE__ */ new Map();
+	nextHandle = 1;
+	metatables = /* @__PURE__ */ new Map();
+	metamethodIds = /* @__PURE__ */ new Map();
+	refs = new FinalizationRegistry((ref) => {
+		if (!this.closed) this.M._lb_unref(this.L, ref);
+	});
+	scratch = 0;
+	scratchSize = 0;
+	lenPtr;
+	depth = 0;
+	frozen = false;
+	closed = false;
+	/** `run`'s `onFinish` for each thread still on its way to the end. */
+	finishers = /* @__PURE__ */ new Map();
+	constructor(module, options) {
+		this.M = module;
+		this.L = module._lb_open();
+		this.classify = options.classify ?? (() => void 0);
+		this.onError = options.onError ?? ((error) => console.error(error.message));
+		this.budgetMs = options.budgetMs ?? 0;
+		this.sharedTables = options.sharedTables ?? [];
+		this.lenPtr = module._malloc(4);
+		for (const name of METAMETHODS) this.metamethodIds.set(name, this.register(this.metamethod(name)));
+	}
+	/** Define a global. Only before the first script runs (globals freeze then). */
+	setGlobal(name, value) {
+		if (this.frozen) throw new Error(`loom luau: globals are frozen; cannot set ${name}`);
+		this.push(this.L, value);
+		this.M._lb_setglobal(this.L, this.cstr(name));
+	}
+	getGlobal(name) {
+		const base = this.M._lb_gettop(this.L);
+		this.M._lb_getglobal(this.L, this.cstr(name));
+		const value = this.read(this.L, -1);
+		this.M._lb_settop(this.L, base);
+		return value;
+	}
+	/**
+	* Freeze the globals and the standard libraries, Roblox style. Runs on its
+	* own before the first script; scripts then see the frozen set through
+	* their own writable environment.
+	*/
+	freeze() {
+		if (this.frozen) return;
+		this.frozen = true;
+		this.M._lb_sandbox(this.L);
+		if (this.sharedTables.length === 0) return;
+		this.M._lb_setreadonly(this.L, LUA_GLOBALSINDEX, 0);
+		for (const name of this.sharedTables) {
+			this.M._lb_newtable(this.L, 0, 0);
+			this.M._lb_setglobal(this.L, this.cstr(name));
+		}
+		this.M._lb_setreadonly(this.L, LUA_GLOBALSINDEX, 1);
+	}
+	/** Compile `source` into a function, or throw the syntax error. */
+	load(source, chunkname = "=loom") {
+		const base = this.M._lb_gettop(this.L);
+		const status = this.loadOnto(this.L, source, chunkname);
+		const value = this.read(this.L, -1);
+		this.M._lb_settop(this.L, base);
+		if (status !== LUA_OK) throw new LuauError(String(value));
+		return value;
+	}
+	/**
+	* Run `source` as a script: its own thread with its own global environment
+	* (the frozen globals plus `globals`), the way Roblox runs a Script or
+	* LocalScript. Returns how the thread first came back; `onFinish` hears how
+	* it ended, after however many yields (`require` of a module that yields).
+	*/
+	run(source, options = {}) {
+		this.freeze();
+		const co = this.M._lb_newthread(this.L);
+		const ref = this.M._lb_ref(this.L, -1);
+		this.M._lb_settop(this.L, -2);
+		try {
+			this.M._lb_sandboxthread(co);
+			for (const [name, value] of Object.entries(options.globals ?? {})) {
+				this.push(co, value);
+				this.M._lb_setglobal(co, this.cstr(name));
+			}
+			if (this.loadOnto(co, source, options.chunkname ?? "=loom") !== LUA_OK) {
+				const error = new LuauError(String(this.read(co, -1)));
+				this.M._lb_settop(co, 0);
+				this.onError(error);
+				const result = {
+					status: "error",
+					error
+				};
+				options.onFinish?.(result);
+				return result;
+			}
+			if (options.onFinish) this.finishers.set(co, options.onFinish);
+			return this.resume(co, 0);
+		} finally {
+			this.M._lb_unref(this.L, ref);
+		}
+	}
+	/**
+	* Call a Luau function to completion and return its results. A function
+	* that yields throws here — give it a thread with `spawn` instead.
+	*/
+	call(fn, args = []) {
+		const L = this.L;
+		const base = this.M._lb_gettop(L);
+		this.ensureStack(L, args.length + 1);
+		this.M._lb_getref(L, fn.ref);
+		for (const arg of args) this.push(L, arg);
+		if (this.enter(() => this.M._lb_pcall(L, args.length, -1)) !== LUA_OK) {
+			const message = this.read(L, -1);
+			this.M._lb_settop(L, base);
+			throw new LuauError(String(message), message);
+		}
+		const results = this.readRange(L, base + 1, this.M._lb_gettop(L));
+		this.M._lb_settop(L, base);
+		return results;
+	}
+	/** Run a Luau function in a new thread (`task.spawn`). */
+	spawn(fn, args = []) {
+		const co = this.M._lb_newthread(this.L);
+		const ref = this.M._lb_ref(this.L, -1);
+		this.M._lb_settop(this.L, -2);
+		try {
+			this.ensureStack(co, args.length + 1);
+			this.M._lb_getref(co, fn.ref);
+			for (const arg of args) this.push(co, arg);
+			return this.resume(co, args.length);
+		} finally {
+			this.M._lb_unref(this.L, ref);
+		}
+	}
+	/**
+	* Resume a Luau thread (`task.defer`'s and `task.delay`'s, made with
+	* `coroutine.create`). A thread that cannot be resumed — finished, running,
+	* or closed by `task.cancel` — is left alone and gives `undefined`.
+	*/
+	resumeThread(thread, args = []) {
+		const co = this.threadOf(thread);
+		if (this.M._lb_costatus(this.L, co) !== LUA_COSUS) return void 0;
+		this.ensureStack(co, args.length);
+		for (const arg of args) this.push(co, arg);
+		return this.resume(co, args.length);
+	}
+	/** Hand an error to `onError`, as if it had escaped a thread. */
+	report(error) {
+		this.onError(error);
+	}
+	/** Collect garbage now (tests use it to observe userdata release). */
+	collect() {
+		this.M._lb_gc(this.L);
+	}
+	/** Close the state. Every reference into it is dead afterwards. */
+	close() {
+		if (this.closed) return;
+		this.M._lb_close(this.L);
+		this.closed = true;
+	}
+	/** Whether `close` has run: every entry into Luau throws afterwards. */
+	get isClosed() {
+		return this.closed;
+	}
+	/** How many JS objects Luau currently holds as userdata. */
+	get liveHostObjects() {
+		return this.handles.size;
+	}
+	/** @internal */
+	track(owner, ref) {
+		this.refs.register(owner, ref);
+	}
+	/** @internal */
+	tableGet(table, key) {
+		const L = this.L;
+		const base = this.M._lb_gettop(L);
+		this.M._lb_getref(L, table.ref);
+		this.push(L, key);
+		this.M._lb_rawget(L, -2);
+		const value = this.read(L, -1);
+		this.M._lb_settop(L, base);
+		return value;
+	}
+	/** @internal */
+	tableSet(table, key, value) {
+		const L = this.L;
+		const base = this.M._lb_gettop(L);
+		this.M._lb_getref(L, table.ref);
+		this.push(L, key);
+		this.push(L, value);
+		this.M._lb_rawset(L, -3);
+		this.M._lb_settop(L, base);
+	}
+	/** @internal */
+	tableLength(table) {
+		const L = this.L;
+		this.M._lb_getref(L, table.ref);
+		const n = this.M._lb_objlen(L, -1);
+		this.M._lb_settop(L, -2);
+		return n;
+	}
+	/** @internal */
+	tableEntries(table) {
+		const L = this.L;
+		const base = this.M._lb_gettop(L);
+		this.M._lb_getref(L, table.ref);
+		this.M._lb_pushnil(L);
+		const out = [];
+		while (this.M._lb_next(L, base + 1) !== 0) {
+			out.push([this.read(L, -2), this.read(L, -1)]);
+			this.M._lb_settop(L, -2);
+		}
+		this.M._lb_settop(L, base);
+		return out;
+	}
+	/** Resume `co` with the top `nargs` values of its stack. */
+	resume(co, nargs) {
+		const result = this.resumeOnce(co, nargs);
+		if (result.status !== "yielded") {
+			const finish = this.finishers.get(co);
+			if (finish) {
+				this.finishers.delete(co);
+				finish(result);
+			}
+		}
+		return result;
+	}
+	resumeOnce(co, nargs) {
+		const status = this.enter(() => this.M._lb_resume(co, 0, nargs));
+		if (status === LUA_OK) {
+			const values = this.readRange(co, 1, this.M._lb_gettop(co));
+			this.M._lb_settop(co, 0);
+			return {
+				status: "done",
+				values
+			};
+		}
+		if (status === LUA_YIELD) {
+			this.M._lb_settop(co, 0);
+			return { status: "yielded" };
+		}
+		const value = this.read(co, -1);
+		const traceback = this.M.UTF8ToString(this.M._lb_debugtrace(co));
+		this.M._lb_settop(co, 0);
+		const error = new LuauError(String(value), value, traceback);
+		this.onError(error);
+		return {
+			status: "error",
+			error
+		};
+	}
+	/**
+	* A host function returned `suspend` on thread `co`. Keep the thread alive
+	* and hand `wait` its resume function once Luau has unwound — only then is
+	* the thread really suspended, whoever resumed it.
+	*/
+	/** The `lua_State*` behind a thread reference. */
+	threadOf(thread) {
+		if (thread.vm !== this) throw new TypeError("loom luau: a thread from another VM");
+		this.M._lb_getref(this.L, thread.ref);
+		const co = this.M._lb_tothread(this.L, -1);
+		this.M._lb_settop(this.L, -2);
+		return co;
+	}
+	suspend(co, suspend) {
+		const ref = this.M._lb_refthread(co);
+		let resumed = false;
+		queueMicrotask(() => {
+			suspend.wait((...values) => {
+				if (resumed || this.closed) return;
+				resumed = true;
+				try {
+					if (this.M._lb_costatus(this.L, co) !== LUA_COSUS) return;
+					this.ensureStack(co, values.length);
+					for (const value of values) this.push(co, value);
+					this.resume(co, values.length);
+				} finally {
+					this.M._lb_unref(this.L, ref);
+				}
+			});
+		});
+	}
+	/** Run `fn` as one entry into Luau, under the run-time budget. */
+	enter(fn) {
+		if (this.closed) throw new Error("loom luau: the VM is closed");
+		if (this.depth === 0 && this.budgetMs > 0) this.M._lb_budget(this.budgetMs);
+		this.depth++;
+		try {
+			return fn();
+		} finally {
+			this.depth--;
+			if (this.depth === 0) this.M._lb_budget(0);
+		}
+	}
+	register(entry) {
+		this.entries.push(entry);
+		return this.entries.length - 1;
+	}
+	hostCall(L, id) {
+		const entry = this.entries[id];
+		const args = this.readRange(L, 1, this.M._lb_gettop(L));
+		try {
+			const result = entry(L, args);
+			if (result instanceof Suspend) {
+				this.suspend(L, result);
+				return LB_YIELD;
+			}
+			return this.pushResults(L, result);
+		} catch (error) {
+			this.push(L, errorValue(error));
+			return LB_ERROR;
+		}
+	}
+	pushResults(L, result) {
+		if (result === void 0) return 0;
+		if (result instanceof Tuple) {
+			this.ensureStack(L, result.values.length);
+			for (const value of result.values) this.push(L, value);
+			return result.values.length;
+		}
+		this.push(L, result);
+		return 1;
+	}
+	hostRelease(handle) {
+		const entry = this.handles.get(handle);
+		if (entry === void 0) return;
+		entry.count--;
+		if (entry.count > 0) return;
+		this.handles.delete(handle);
+		this.handleOf.delete(entry.value);
+	}
+	/** The host function behind metamethod `name`, shared by every class. */
+	metamethod(name) {
+		const self = (args) => {
+			const value = args[0];
+			return [value, this.classOf(value)];
+		};
+		const binary = (op) => (_, args) => {
+			const cls = this.classOf(args[0]) ?? this.classOf(args[1]);
+			const hook = cls?.[op];
+			if (hook === void 0) throw new LuauError(`attempt to perform arithmetic (${op}) on ${cls?.name ?? "userdata"}`);
+			return hook.call(cls, args[0], args[1]);
+		};
+		switch (name) {
+			case "__index": return (_, args) => {
+				const [value, cls] = self(args);
+				if (cls.index === void 0) throw new LuauError(`${String(args[1])} is not a valid member of ${cls.name}`);
+				return cls.index(value, args[1]);
+			};
+			case "__newindex": return (_, args) => {
+				const [value, cls] = self(args);
+				if (cls.newindex === void 0) throw new LuauError(`${String(args[1])} cannot be assigned to`);
+				cls.newindex(value, args[1], args[2]);
+			};
+			case "__namecall": return (L, args) => {
+				const method = this.M.UTF8ToString(this.M._lb_namecall(L));
+				const [value, cls] = self(args);
+				if (cls.namecall === void 0) throw new LuauError(`${method} is not a valid member of ${cls.name}`);
+				return cls.namecall(value, method, args.slice(1));
+			};
+			case "__call": return (_, args) => {
+				const [value, cls] = self(args);
+				if (cls.call === void 0) throw new LuauError(`attempt to call a ${cls.name} value`);
+				return cls.call(value, args.slice(1));
+			};
+			case "__tostring": return (_, args) => {
+				const [value, cls] = self(args);
+				return cls.tostring?.(value) ?? cls.name;
+			};
+			case "__eq": return (_, args) => {
+				const [value, cls] = self(args);
+				return cls.eq?.(value, args[1]) ?? value === args[1];
+			};
+			case "__len": return (_, args) => {
+				const [value, cls] = self(args);
+				if (cls.len === void 0) throw new LuauError(`attempt to get length of a ${cls.name} value`);
+				return cls.len(value);
+			};
+			case "__unm": return (_, args) => {
+				const [value, cls] = self(args);
+				if (cls.unm === void 0) throw new LuauError(`attempt to perform arithmetic (unm) on ${cls.name}`);
+				return cls.unm(value);
+			};
+			default: return binary(name.slice(2));
+		}
+	}
+	classOf(value) {
+		if (typeof value !== "object" || value === null) return void 0;
+		const handle = this.handleOf.get(value);
+		return handle === void 0 ? void 0 : this.handles.get(handle)?.cls;
+	}
+	metatableFor(cls) {
+		const existing = this.metatables.get(cls);
+		if (existing !== void 0) return existing;
+		const L = this.L;
+		this.M._lb_newtable(L, 0, METAMETHODS.length + 2);
+		for (const name of METAMETHODS) {
+			this.M._lb_pushfunction(L, this.metamethodIds.get(name), this.debugName(name));
+			this.M._lb_setfield(L, -2, this.cstr(name));
+		}
+		this.pushString(L, cls.name);
+		this.M._lb_setfield(L, -2, this.cstr("__type"));
+		this.pushString(L, "The metatable is locked");
+		this.M._lb_setfield(L, -2, this.cstr("__metatable"));
+		this.M._lb_setreadonly(L, -1, 1);
+		const ref = this.M._lb_ref(L, -1);
+		this.M._lb_settop(L, -2);
+		this.metatables.set(cls, ref);
+		return ref;
+	}
+	read(L, idx) {
+		switch (this.M._lb_kind(L, idx)) {
+			case KIND_NIL: return;
+			case KIND_BOOLEAN: return this.M._lb_toboolean(L, idx) !== 0;
+			case KIND_NUMBER: return this.M._lb_tonumber(L, idx);
+			case KIND_STRING: {
+				const ptr = this.M._lb_tostring(L, idx, this.lenPtr);
+				const len = this.M.HEAPU32[this.lenPtr >> 2];
+				return decoder.decode(this.M.HEAPU8.subarray(ptr, ptr + len));
+			}
+			case KIND_HOST: return this.handles.get(this.M._lb_tohost(L, idx))?.value;
+			case KIND_TABLE: return new LuauTable(this, this.M._lb_ref(L, idx));
+			case KIND_FUNCTION: return new LuauFunction(this, this.M._lb_ref(L, idx));
+			case KIND_THREAD: return new LuauThread(this, this.M._lb_ref(L, idx));
+			default: return new LuauOpaque(this, this.M._lb_ref(L, idx), this.M.UTF8ToString(this.M._lb_typeof(L, idx)));
+		}
+	}
+	readRange(L, from, to) {
+		const out = [];
+		for (let i = from; i <= to; i++) out.push(this.read(L, i));
+		return out;
+	}
+	push(L, value) {
+		this.ensureStack(L, 3);
+		switch (typeof value) {
+			case "undefined":
+				this.M._lb_pushnil(L);
+				return;
+			case "boolean":
+				this.M._lb_pushboolean(L, value ? 1 : 0);
+				return;
+			case "number":
+				this.M._lb_pushnumber(L, value);
+				return;
+			case "bigint":
+				this.M._lb_pushnumber(L, Number(value));
+				return;
+			case "string":
+				this.pushString(L, value);
+				return;
+			case "function":
+				this.M._lb_pushfunction(L, this.functionId(value), this.debugName(value.name || "host"));
+				return;
+			case "symbol": throw new TypeError("loom luau: a symbol cannot cross into Luau");
+		}
+		if (value === null) {
+			this.M._lb_pushnil(L);
+			return;
+		}
+		if (value instanceof LuauRef) {
+			if (value.vm !== this) throw new TypeError("loom luau: a value from another VM cannot cross into this one");
+			this.M._lb_getref(L, value.ref);
+			return;
+		}
+		const cls = this.classify(value);
+		if (cls !== void 0) {
+			this.pushHost(L, value, cls);
+			return;
+		}
+		if (Array.isArray(value)) {
+			this.M._lb_newtable(L, value.length, 0);
+			value.forEach((item, i) => {
+				this.push(L, item);
+				this.M._lb_rawseti(L, -2, i + 1);
+			});
+			return;
+		}
+		const proto = Object.getPrototypeOf(value);
+		if (proto === Object.prototype || proto === null) {
+			const fields = Object.entries(value);
+			this.M._lb_newtable(L, 0, fields.length);
+			for (const [key, item] of fields) {
+				this.pushString(L, key);
+				this.push(L, item);
+				this.M._lb_rawset(L, -3);
+			}
+			return;
+		}
+		throw new TypeError(`loom luau: no HostClass for ${proto?.constructor?.name ?? "object"}; cannot cross into Luau`);
+	}
+	pushHost(L, value, cls) {
+		let handle = this.handleOf.get(value);
+		if (handle === void 0) {
+			handle = this.nextHandle++;
+			this.handleOf.set(value, handle);
+			this.handles.set(handle, {
+				value,
+				cls,
+				count: 0
+			});
+		}
+		const entry = this.handles.get(handle);
+		entry.count++;
+		if (this.M._lb_pushhost(L, handle, this.metatableFor(cls)) === 0) entry.count--;
+	}
+	functionId(fn) {
+		let id = this.functionIds.get(fn);
+		if (id === void 0) {
+			id = this.register((_, args) => fn(...args));
+			this.functionIds.set(fn, id);
+		}
+		return id;
+	}
+	ensureStack(L, n) {
+		if (this.M._lb_checkstack(L, n) === 0) throw new LuauError("stack overflow");
+	}
+	loadOnto(L, source, chunkname) {
+		const name = encoder.encode(`${chunkname}\0`);
+		const namePtr = this.M._malloc(name.length);
+		this.M.HEAPU8.set(name, namePtr);
+		try {
+			const bytes = encoder.encode(source);
+			const ptr = this.reserve(bytes.length);
+			this.M.HEAPU8.set(bytes, ptr);
+			return this.M._lb_load(L, namePtr, ptr, bytes.length);
+		} finally {
+			this.M._free(namePtr);
+		}
+	}
+	pushString(L, value) {
+		const bytes = encoder.encode(value);
+		const ptr = this.reserve(bytes.length);
+		this.M.HEAPU8.set(bytes, ptr);
+		this.M._lb_pushstring(L, ptr, bytes.length);
+	}
+	/** A NUL-terminated copy of `value` in the scratch buffer (overwritten by the next use). */
+	cstr(value) {
+		const bytes = encoder.encode(`${value}\0`);
+		const ptr = this.reserve(bytes.length);
+		this.M.HEAPU8.set(bytes, ptr);
+		return ptr;
+	}
+	/** A permanent NUL-terminated string: Luau keeps C function debug names by pointer. */
+	debugName(name) {
+		let ptr = this.debugNames.get(name);
+		if (ptr === void 0) {
+			const bytes = encoder.encode(`${name}\0`);
+			ptr = this.M._malloc(bytes.length);
+			this.M.HEAPU8.set(bytes, ptr);
+			this.debugNames.set(name, ptr);
+		}
+		return ptr;
+	}
+	reserve(size) {
+		if (size > this.scratchSize) {
+			if (this.scratch !== 0) this.M._free(this.scratch);
+			this.scratchSize = Math.max(size, 256, this.scratchSize * 2);
+			this.scratch = this.M._malloc(this.scratchSize);
+		}
+		return this.scratch;
+	}
+};
+/** What a JS exception becomes when it is raised into Luau. */
+function errorValue(error) {
+	if (error instanceof LuauError) return error.value;
+	if (error instanceof Error) return error.message;
+	return error;
+}
+//#endregion
+//#region src/bindings.ts
+/**
+* `bindings.ts` — Roblox, as Luau sees it, over `@loom-dev/runtime`.
+*
+* Nothing here re-implements Roblox: every Instance, datatype, enum and signal
+* a Luau script touches is the same JS object the react and vide adapters use,
+* reached through a `HostClass`. What this file decides is only the Luau shape
+* of each — which members are visible, what a method's result becomes, and
+* which calls yield — plus the `task` library and the globals around it.
+*/
+/** Every runtime datatype class, under its Roblox name. */
+const DATATYPES = {
+	UDim,
+	UDim2,
+	Vector2,
+	Vector3,
+	Color3,
+	ColorSequence,
+	ColorSequenceKeypoint,
+	NumberSequence,
+	NumberSequenceKeypoint,
+	NumberRange,
+	Content,
+	Rect,
+	CFrame,
+	TweenInfo,
+	Font,
+	Random,
+	DateTime
+};
+/** Roblox members are PascalCase; the JS-side `add`, `toString`, … are not members. */
+const isMember = (key) => typeof key === "string" && /^[A-Z]/.test(key);
+function createRobloxBindings() {
+	let vm;
+	const current = () => {
+		if (vm === void 0) throw new Error("loom luau: bindings used before install");
+		return vm;
+	};
+	const connections = /* @__PURE__ */ new WeakSet();
+	const methodWrappers = /* @__PURE__ */ new Map();
+	const method = (cls, name) => {
+		const key = `${cls.name}.${name}`;
+		let wrapper = methodWrappers.get(key);
+		if (wrapper === void 0) {
+			wrapper = (self, ...args) => cls.namecall?.(self, name, args);
+			methodWrappers.set(key, wrapper);
+		}
+		return wrapper;
+	};
+	const datatypeClasses = /* @__PURE__ */ new Map();
+	for (const [name, ctor] of Object.entries(DATATYPES)) datatypeClasses.set(ctor, datatypeClass(name));
+	function datatypeClass(name) {
+		const cls = {
+			name,
+			index(self, key) {
+				if (!isMember(key) || !(key in self)) throw new LuauError(`${String(key)} is not a valid member of ${name}`);
+				const value = self[key];
+				return typeof value === "function" ? method(cls, key) : value;
+			},
+			newindex(_, key) {
+				throw new LuauError(`${String(key)} cannot be assigned to`);
+			},
+			namecall(self, member, args) {
+				const fn = isMember(member) ? self[member] : void 0;
+				if (typeof fn !== "function") throw new LuauError(`${member} is not a valid member of ${name}`);
+				const result = fn.apply(self, args);
+				return Array.isArray(result) ? new Tuple(result) : result;
+			},
+			tostring: (self) => String(self),
+			eq: (a, b) => robloxEquals(a, b),
+			unm(self) {
+				if (typeof self.mul !== "function") return arithmeticError("unm", self, void 0);
+				return self.mul(-1);
+			},
+			add: (a, b) => arithmetic("add", a, b),
+			sub: (a, b) => arithmetic("sub", a, b),
+			mul: (a, b) => arithmetic("mul", a, b),
+			div: (a, b) => arithmetic("div", a, b)
+		};
+		return cls;
+	}
+	function arithmetic(op, a, b) {
+		const left = a;
+		if (typeof left?.[op] === "function") return left[op](b);
+		const right = b;
+		if (op === "mul" && typeof a === "number" && typeof right?.mul === "function") return right.mul(a);
+		return arithmeticError(op, a, b);
+	}
+	function arithmeticError(op, a, b) {
+		throw new LuauError(`attempt to perform arithmetic (${op}) on ${typeName(a)} and ${typeName(b)}`);
+	}
+	/** `UDim2.new`, `Color3.fromRGB`, `Vector2.zero`, … as a plain table. */
+	function library(ctor) {
+		const lib = {};
+		for (const key of Object.getOwnPropertyNames(ctor)) {
+			if (key === "length" || key === "name" || key === "prototype") continue;
+			const value = ctor[key];
+			lib[key] = typeof value === "function" ? (...args) => value.apply(ctor, args) : value;
+		}
+		return lib;
+	}
+	const EnumsClass = {
+		name: "Enums",
+		index(self, key) {
+			const value = typeof key === "string" ? self[key] : void 0;
+			if (value instanceof RobloxEnum) return value;
+			if (key === "GetEnums") return method(EnumsClass, key);
+			throw new LuauError(`${String(key)} is not a valid member of "Enum"`);
+		},
+		namecall(self, member) {
+			if (member === "GetEnums") return self.GetEnums();
+			throw new LuauError(`${member} is not a valid member of "Enum"`);
+		},
+		tostring: () => "Enums"
+	};
+	const EnumClass = {
+		name: "Enum",
+		index(self, key) {
+			const value = typeof key === "string" ? self[key] : void 0;
+			if (value instanceof EnumItem) return value;
+			if (key === "GetEnumItems" || key === "FromName" || key === "FromValue") return method(EnumClass, key);
+			throw new LuauError(`${String(key)} is not a valid EnumItem`);
+		},
+		namecall(self, member, args) {
+			switch (member) {
+				case "GetEnumItems": return self.GetEnumItems();
+				case "FromName": return self.FromName(args[0]);
+				case "FromValue": return self.FromValue(args[0]);
+			}
+			throw new LuauError(`${member} is not a valid member of ${String(self)}`);
+		},
+		tostring: (self) => String(self)
+	};
+	const EnumItemClass = {
+		name: "EnumItem",
+		index(self, key) {
+			if (key === "Name" || key === "Value" || key === "EnumType") return self[key];
+			if (key === "IsA") return method(EnumItemClass, key);
+			throw new LuauError(`${String(key)} is not a valid member of "${String(self)}"`);
+		},
+		namecall(self, member, args) {
+			if (member === "IsA") return enumTypeName(self) === args[0];
+			throw new LuauError(`${member} is not a valid member of "${String(self)}"`);
+		},
+		tostring: (self) => String(self)
+	};
+	const SignalClass = {
+		name: "RBXScriptSignal",
+		index(_, key) {
+			if (key === "Connect" || key === "ConnectParallel" || key === "Once" || key === "Wait") return method(SignalClass, key);
+			throw new LuauError(`${String(key)} is not a valid member of RBXScriptSignal`);
+		},
+		namecall(self, member, args) {
+			switch (member) {
+				case "Connect":
+				case "ConnectParallel":
+				case "Once": {
+					const fn = args[0];
+					const handler = (...values) => {
+						const vm = current();
+						if (!vm.isClosed) vm.spawn(fn, values);
+					};
+					const connection = member === "Once" ? self.Once(handler) : self.Connect(handler);
+					connections.add(connection);
+					return connection;
+				}
+				case "Wait": return new Suspend((resume) => {
+					self.Once((...values) => resume(...values));
+				});
+			}
+			throw new LuauError(`${member} is not a valid member of RBXScriptSignal`);
+		},
+		tostring: () => "Signal"
+	};
+	const ConnectionClass = {
+		name: "RBXScriptConnection",
+		index(self, key) {
+			if (key === "Connected") return self.Connected;
+			if (key === "Disconnect") return method(ConnectionClass, key);
+			throw new LuauError(`${String(key)} is not a valid member of RBXScriptConnection`);
+		},
+		namecall(self, member) {
+			if (member === "Disconnect") return self.Disconnect();
+			throw new LuauError(`${member} is not a valid member of RBXScriptConnection`);
+		},
+		tostring: () => "Connection"
+	};
+	const InstanceClass = {
+		name: "Instance",
+		index(self, key) {
+			if (typeof key !== "string") throw new LuauError(`${String(key)} is not a valid member of ${self.ClassName}`);
+			const value = self[key];
+			if (typeof value === "function") return method(InstanceClass, key);
+			if (value !== void 0) return value;
+			return self.FindFirstChild(key);
+		},
+		newindex(self, key, value) {
+			self[key] = value;
+		},
+		namecall(self, member, args) {
+			if (member === "WaitForChild") return waitForChild(self, args[0], args[1]);
+			if (member === "GetAttributes") return Object.fromEntries(self.GetAttributes());
+			const fn = self[member];
+			if (typeof fn !== "function") throw new LuauError(`${member} is not a valid member of ${self.ClassName} "${self.Name}"`);
+			const result = fn(...args.map((arg) => arg instanceof LuauFunction ? (...values) => {
+				const vm = current();
+				if (vm.isClosed) return void 0;
+				const ended = vm.spawn(arg, values);
+				return ended.status === "done" ? ended.values[0] : void 0;
+			} : arg));
+			if (isLuaTuple(result)) return new Tuple(result);
+			if (result instanceof Promise) return new Suspend((resume) => {
+				result.then((value) => resume(value));
+			});
+			return result;
+		},
+		tostring: (self) => self.Name
+	};
+	const modules = /* @__PURE__ */ new Map();
+	/**
+	* `require(moduleScript)`, as `(ok, valueOrMessage)` for the prelude's
+	* `require` to raise from. A module runs once per VM, in its own thread, with
+	* itself as `script`. Whoever requires it while it is still yielding waits
+	* for it; requiring it again from inside its own first run is the recursion
+	* Roblox reports.
+	*/
+	function requireModule(module, from) {
+		if (typeof module === "string") {
+			const resolved = resolveRequirePath(module, from);
+			if (typeof resolved === "string") return tuple(false, resolved);
+			module = resolved;
+		}
+		if (!isLoomInstance(module) || !module.IsA("ModuleScript")) return tuple(false, "Attempted to call require with invalid argument(s).");
+		const loaded = modules.get(module);
+		if (loaded !== void 0) return settle(module, loaded);
+		const source = getScriptSource(module);
+		if (source === void 0) return tuple(false, `${module.GetFullName()} has no source loom can run`);
+		modules.set(module, { state: "running" });
+		if (current().run(source, {
+			chunkname: `=${module.GetFullName()}`,
+			globals: { script: module },
+			onFinish: (ended) => finishModule(module, ended)
+		}).status === "yielded") modules.set(module, {
+			state: "waiting",
+			waiters: []
+		});
+		return settle(module, modules.get(module));
+	}
+	/** `module`'s thread ended: keep what it returned and wake whoever waits on it. */
+	function finishModule(module, result) {
+		const before = modules.get(module);
+		let after = { state: "failed" };
+		if (result.status === "done") if (result.values.length === 1) after = {
+			state: "done",
+			value: result.values[0]
+		};
+		else current().report(new LuauError(`${module.GetFullName()}: Module code did not return exactly one value`));
+		modules.set(module, after);
+		if (before?.state === "waiting") for (const wake of before.waiters) wake();
+	}
+	/** What a `require` of `module`, currently `loaded`, hands back. */
+	function settle(module, loaded) {
+		switch (loaded.state) {
+			case "done": return tuple(true, loaded.value);
+			case "failed": return tuple(false, "Requested module experienced an error while loading");
+			case "running": return tuple(false, "Requested module was required recursively");
+			case "waiting": return new Suspend((resume) => {
+				loaded.waiters.push(() => {
+					resume(...settle(module, modules.get(module)).values);
+				});
+			});
+		}
+	}
+	/** The real `WaitForChild`: yield until the child turns up, or `timeout` runs out. */
+	function waitForChild(parent, name, timeout) {
+		const existing = parent.FindFirstChild(name);
+		if (existing !== void 0) return existing;
+		return new Suspend((resume) => {
+			let timer;
+			const connection = parent.ChildAdded.Connect((child) => {
+				if (child.Name !== name) return;
+				connection.Disconnect();
+				if (timer !== void 0) clearTimeout(timer);
+				resume(child);
+			});
+			if (timeout !== void 0) timer = setTimeout(() => {
+				connection.Disconnect();
+				resume(void 0);
+			}, timeout * 1e3);
+		});
+	}
+	const classify = (value) => {
+		if (isLoomInstance(value)) return InstanceClass;
+		if (value instanceof LoomSignal) return SignalClass;
+		if (connections.has(value)) return ConnectionClass;
+		if (value instanceof EnumItem) return EnumItemClass;
+		if (value instanceof RobloxEnum) return EnumClass;
+		if (value === Enum) return EnumsClass;
+		return datatypeClasses.get(value.constructor);
+	};
+	function install(target) {
+		vm = target;
+		for (const [name, ctor] of Object.entries(DATATYPES)) target.setGlobal(name, library(ctor));
+		target.setGlobal("Enum", Enum);
+		target.setGlobal("game", game);
+		target.setGlobal("workspace", game.Workspace);
+		target.setGlobal("Instance", { new: (className, parent) => {
+			const instance = createInstance(className);
+			if (parent !== void 0) instance.Parent = parent;
+			return instance;
+		} });
+		const started = performance.now();
+		target.load(PRELUDE, "=loom.prelude").call({
+			wait,
+			defer: (thread, ...args) => {
+				queueMicrotask(() => target.resumeThread(thread, args));
+			},
+			delay: (seconds, thread, ...args) => {
+				afterSeconds(seconds, () => target.resumeThread(thread, args));
+			},
+			report: (message, traceback) => {
+				target.report(new LuauError(message, message, traceback));
+			},
+			print: (line) => console.log(line),
+			warn: (line) => console.warn(line),
+			require: requireModule,
+			tick: () => Date.now() / 1e3,
+			time: () => (performance.now() - started) / 1e3
+		});
+	}
+	return {
+		classify,
+		install
+	};
+}
+/**
+* Require-by-string, the engine's way: `@self/x` starts at the requiring
+* script itself, `./x` at its parent, `../x` one above that (each further
+* `..` climbs one more), and `@game/x` at the DataModel. Returns the instance
+* the path names, or the error message when it names none.
+*/
+function resolveRequirePath(path, from) {
+	const parts = path.split("/");
+	const head = parts.shift();
+	if (head === "@game") return walkPath(game, parts, path, "game");
+	if (head !== "@self" && head !== "." && head !== "..") return `require("${path}"): a path must start with "./", "../", "@self/" or "@game/"`;
+	if (!isLoomInstance(from)) return `require("${path}"): cannot resolve a path outside a script`;
+	const parent = from.Parent;
+	return walkPath(head === "@self" ? from : head === "." ? parent : parent?.Parent, parts, path, from.GetFullName());
+}
+/** Follow `parts` (child names, or `..` for a parent) down from `at`. */
+function walkPath(at, parts, path, origin) {
+	for (const part of parts) {
+		if (at === void 0) break;
+		if (part === "" || part === ".") continue;
+		at = part === ".." ? at.Parent : at.FindFirstChild(part);
+	}
+	return at ?? `require("${path}"): no module at that path from ${origin}`;
+}
+/** `task.wait`: yield until the first Heartbeat after `seconds`, return the time waited. */
+function wait(seconds) {
+	const started = performance.now();
+	return new Suspend((resume) => {
+		afterSeconds(seconds ?? 0, () => resume((performance.now() - started) / 1e3));
+	});
+}
+/** Run `fn` on the first Heartbeat at least `seconds` from now — Roblox's resume point. */
+function afterSeconds(seconds, fn) {
+	const deadline = performance.now() + Math.max(seconds, 0) * 1e3;
+	const connection = heartbeat.Connect(() => {
+		if (performance.now() < deadline) return;
+		connection.Disconnect();
+		fn();
+	});
+}
+function typeName(value) {
+	if (value === void 0 || value === null) return "nil";
+	if (typeof value !== "object") return typeof value;
+	return Object.entries(DATATYPES).find(([, ctor]) => value.constructor === ctor)?.[0] ?? "userdata";
+}
+//#endregion
+//#region src/mount.ts
+/**
+* `mount.ts` — run a Luau LocalScript into a live loom preview.
+*
+* A Luau script builds instances imperatively and parents them under
+* `PlayerGui`, so what it needs from loom is exactly the react adapter's
+* world: the runtime PlayerGui as root, encoded → laid out → painted on every
+* dirty frame. `createWorld` is reused as-is; nothing in the layout engine or
+* the renderer knows the tree came from Luau.
+*/
+/** Print an escaped error the way the engine's output does: message, then stack. */
+function printError(error) {
+	console.error(`${error.message}${error.traceback ? `\n${error.traceback}` : ""}`);
+}
+/** A fresh VM with Roblox's globals installed, ready to run scripts. */
+async function createLuauVM(setup = {}) {
+	const bindings = createRobloxBindings();
+	const vm = await LuauVM.create({
+		classify: bindings.classify,
+		budgetMs: setup.budgetMs ?? 5e3,
+		sharedTables: ["_G", "shared"],
+		...setup.wasmBinary ? { wasmBinary: setup.wasmBinary } : {},
+		onError: setup.onError ?? printError
+	});
+	bindings.install(vm);
+	return vm;
+}
+const HOST_ID = "loom-root";
+/**
+* Where the world paints. An explicit `target` is the mount itself, as with
+* react's `render`; without one each mount gets its own container under the
+* preview viewport (`#loom-root`, created if the page lacks it), as react's
+* `createRoot` and vide's `mount` do, so independent mounts don't clobber.
+*/
+function resolveMount(target) {
+	if (target) return {
+		mount: target,
+		owned: false
+	};
+	let viewport = document.getElementById(HOST_ID);
+	if (!viewport) {
+		viewport = document.createElement("div");
+		viewport.id = HOST_ID;
+		viewport.style.position = "relative";
+		viewport.style.width = "100vw";
+		viewport.style.height = "100vh";
+		viewport.style.overflow = "hidden";
+		document.body.appendChild(viewport);
+	}
+	const mount = document.createElement("div");
+	mount.style.position = "absolute";
+	mount.style.inset = "0";
+	viewport.appendChild(mount);
+	return {
+		mount,
+		owned: true
+	};
+}
+/**
+* Run `source` as a LocalScript in a fresh VM and paint what it builds. The
+* script sits inside the world's default ScreenGui, so the common
+* `script.Parent` idiom lands its UI on screen, and anything it parents to
+* `Players.LocalPlayer.PlayerGui` renders as its own layer.
+*/
+async function mountLuau(source, options = {}) {
+	if (options.computeLayout === void 0) await initLayout();
+	const vm = await createLuauVM(options);
+	const { mount, owned } = resolveMount(options.target);
+	const world = createWorld(mount, options);
+	const name = options.name ?? "LocalScript";
+	const script = createInstance("LocalScript", name);
+	script.Parent = world.defaultGui;
+	const result = vm.run(source, {
+		chunkname: `=${name}`,
+		globals: { script }
+	});
+	world.flushSync();
+	return {
+		vm,
+		world,
+		script,
+		result,
+		unmount() {
+			world.dispose();
+			vm.close();
+			if (owned) mount.remove();
+		}
+	};
+}
+/**
+* Start a Rojo project the way a client joins a place: build the tree into
+* `game`, then run every LocalScript a client runs (ReplicatedFirst, the
+* StarterGui copy in PlayerGui, the StarterPlayerScripts copy in
+* PlayerScripts) in one VM, so `require` shares each module between them.
+*/
+async function runLuauProject(project, options = {}) {
+	if (options.computeLayout === void 0) await initLayout();
+	const vm = await createLuauVM(options);
+	const { mount, owned } = resolveMount(options.target);
+	const world = createWorld(mount, options);
+	instantiateProject(project);
+	const scripts = startClient().map(({ script, source }) => ({
+		script,
+		result: vm.run(source, {
+			chunkname: `=${script.GetFullName()}`,
+			globals: { script }
+		})
+	}));
+	world.flushSync();
+	return {
+		vm,
+		world,
+		scripts,
+		unmount() {
+			world.dispose();
+			vm.close();
+			if (owned) mount.remove();
+		}
+	};
+}
+//#endregion
+export { setScriptSource as _, LuauError as a, LuauTable as c, Suspend as d, Tuple as f, instantiateProject as g, getScriptSource as h, createRobloxBindings as i, LuauThread as l, cloneWithSources as m, mountLuau as n, LuauFunction as o, tuple as p, runLuauProject as r, LuauOpaque as s, createLuauVM as t, LuauVM as u };
+
+//# sourceMappingURL=mount-2LXSpSYv.js.map