@isentinel/weld 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1613 @@
+import { n as validateConfig } from "./schema-Cp_hoJ0u.mjs";
+import { type } from "arktype";
+import { loadConfig } from "c12";
+import process from "node:process";
+import { parseArgs } from "node:util";
+import { loadRojoProject, mapFsPathToDataModel } from "@isentinel/rojo-utils";
+import fs from "node:fs";
+import path from "node:path";
+import { GenMapping, addMapping, setSourceContent, toEncodedMap } from "@jridgewell/gen-mapping";
+import { generateDtsBundle } from "dts-bundle-generator";
+import { createEnv } from "@t3-oss/env-core";
+import { spawnLute, writeTemporaryLuauScript } from "@isentinel/luau-ast";
+import { defuFn } from "defu";
+import color from "tinyrainbow";
+//#region src/codegen/bundle-generator.ts
+/**
+* Generate bundled output with flattened chunks.
+*
+* @param chunks - Chunks in topological order.
+* @param entrySource - Rewritten entry point source (inlined at top level).
+* @param options - Optional bundle generation options.
+* @returns The complete bundled Luau source.
+*/
+function generateChunkedBundle(chunks, entrySource, options = {}) {
+	const { entryInfo, onMapping } = options;
+	const lines = bundlePrelude(options);
+	for (const chunk of chunks) {
+		if (chunk.modules.length === 0) continue;
+		appendWrappedChunk({
+			chunk,
+			lines,
+			onMapping
+		});
+	}
+	const trimmedEntry = entrySource.replace(/\n$/, "");
+	const entryStartLine = lines.length + 1;
+	lines.push(trimmedEntry, "");
+	if (entryInfo !== void 0 && onMapping !== void 0) emitLineMappings({
+		content: entryInfo.originalContent,
+		lineCount: countLines(trimmedEntry),
+		onMapping,
+		sourcePath: entryInfo.sourcePath,
+		startLine: entryStartLine
+	});
+	return lines.join("\n");
+}
+function bundlePrelude(options) {
+	const lines = [];
+	if (options.includeTsGlobal !== false) lines.push("local TS = _G[script]", "");
+	lines.push("local __WELD_MODULES = {", "	cache = {} :: any,", "}", "");
+	return lines;
+}
+function countLines(source) {
+	return source.split("\n").length;
+}
+function emitLineMappings(input) {
+	const { content, lineCount, onMapping, sourcePath, startLine } = input;
+	for (let index = 0; index < lineCount; index++) onMapping({
+		content,
+		generatedLine: startLine + index,
+		originalLine: index + 1,
+		sourcePath
+	});
+}
+/**
+* Sum totalLocals across all modules in a chunk. Returns 0 if no module has
+* totalLocals set (debug mode off).
+*
+* @param chunk - The chunk to sum.
+* @returns Total locals across the chunk's modules.
+*/
+function sumChunkLocals(chunk) {
+	let total = 0;
+	for (const module_ of chunk.modules) total += module_.totalLocals ?? 0;
+	return total;
+}
+function appendChunkModuleBody(input) {
+	const { lines, module_, onMapping } = input;
+	if (module_.totalLocals !== void 0) lines.push(`\t-- [${module_.id}] Variables in scope: ${String(module_.totalLocals)}`);
+	const moduleStartLine = lines.length + 1;
+	const moduleLines = module_.source.split("\n");
+	for (const sourceLine of moduleLines) lines.push(`\t${sourceLine}`);
+	if (onMapping !== void 0 && module_.sourcePath !== void 0 && module_.originalContent !== void 0) emitLineMappings({
+		content: module_.originalContent,
+		lineCount: moduleLines.length,
+		onMapping,
+		sourcePath: module_.sourcePath,
+		startLine: moduleStartLine
+	});
+}
+/**
+* Append a chunk wrapped in a do-block to isolate its locals.
+*
+* @param input - Output lines array, the chunk to append, and optional source-map callback.
+*/
+function appendWrappedChunk(input) {
+	const { chunk, lines, onMapping } = input;
+	const chunkTotal = sumChunkLocals(chunk);
+	if (chunkTotal > 0) lines.push(`-- Chunk ${String(chunk.id)}: ${String(chunkTotal)} locals (${String(chunk.modules.length)} modules)`);
+	lines.push("do");
+	for (const module_ of chunk.modules) appendChunkModuleBody({
+		lines,
+		module_,
+		onMapping
+	});
+	for (const module_ of chunk.modules) lines.push(`\tfunction __WELD_MODULES.${module_.id}() return _${module_.id} end`);
+	lines.push("end", "");
+}
+//#endregion
+//#region src/codegen/transforms/rename-locals.ts
+/**
+* Build a byte-offset-to-char-offset mapping for a source string.
+* Lute reports byte offsets but JS string operations use char offsets.
+* They differ when the source contains multibyte UTF-8 characters.
+*
+* @param source - The source string.
+* @returns A function that converts byte offsets to char offsets.
+*/
+function buildByteToCharMap(source) {
+	const encoder = new TextEncoder();
+	const bytes = encoder.encode(source);
+	const byteToChar = new Int32Array(bytes.length + 1);
+	let charIndex = 0;
+	let byteIndex = 0;
+	for (const codePoint of source) {
+		const charBytes = encoder.encode(codePoint).length;
+		for (let offset = 0; offset < charBytes; offset++) byteToChar[byteIndex + offset] = charIndex;
+		byteIndex += charBytes;
+		charIndex += codePoint.length;
+	}
+	byteToChar[byteIndex] = charIndex;
+	return (byteOffset) => byteToChar[byteOffset];
+}
+/**
+* Apply all local renames to the source, working in descending offset order.
+*
+* @param source - Original source.
+* @param options - Rename configuration.
+* @returns Source with renamed locals.
+*/
+function applyRenames(source, options) {
+	const { locals, prefix, toChar } = options;
+	const allOccurrences = [];
+	for (const binding of locals) for (const loc of binding.locations) allOccurrences.push({
+		name: binding.name,
+		end: toChar(loc.end),
+		start: toChar(loc.start)
+	});
+	allOccurrences.sort((first, second) => second.start - first.start);
+	let result = source;
+	for (const occurrence of allOccurrences) {
+		const replacement = `${prefix}_${occurrence.name}`;
+		result = result.slice(0, occurrence.start) + replacement + result.slice(occurrence.end);
+	}
+	return result;
+}
+/**
+* Rewrite the trailing top-level return to an export capture assignment.
+*
+* @param source - Source with renames applied.
+* @param prefix - Module prefix for the export capture variable.
+* @returns The rewritten source.
+*/
+function rewriteReturn(source, prefix) {
+	let result = source;
+	const lastReturnIndex = result.lastIndexOf("\nreturn ");
+	if (lastReturnIndex !== -1) result = `${result.slice(0, lastReturnIndex + 1)}local _${prefix} = ${result.slice(lastReturnIndex + 8)}`;
+	else if (result.startsWith("return ")) result = `local _${prefix} = ${result.slice(7)}`;
+	return result;
+}
+/** Prefix top-level local variables and rewrite trailing return to export capture. */
+const renameLocals = {
+	name: "rename-locals",
+	apply(source, context) {
+		const toChar = buildByteToCharMap(source);
+		return rewriteReturn(applyRenames(source, {
+			locals: context.locals,
+			prefix: context.moduleId,
+			toChar
+		}), context.moduleId);
+	}
+};
+//#endregion
+//#region src/codegen/transforms/regex-utils.ts
+/**
+* Escape special regex characters in a string.
+*
+* @param text - The string to escape.
+* @returns The escaped string safe for use in a regex.
+*/
+function escapeRegex(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/codegen/transforms/rewrite-internal-imports.ts
+/**
+* Build a regex pattern that matches the call site for a resolved import.
+*
+* @param resolved - The resolved import metadata, including kind and args.
+* @returns A RegExp matching the corresponding source call.
+*/
+function buildImportPattern(resolved) {
+	if (resolved.kind === "require") {
+		/* c8 ignore next -- args[0] is always present for resolved require kinds (filtered upstream) */
+		const argument = escapeRegex(resolved.args[0] ?? "");
+		return new RegExp(`require\\(\\s*${argument}\\s*\\)`);
+	}
+	const joined = resolved.args.map((argument) => escapeRegex(argument)).join(",\\s*");
+	return new RegExp(`TS\\.import\\(${joined}\\)`);
+}
+/**
+* Replace all `TS.import()` calls with module references.
+*
+* @param source - Source with TS boilerplate already stripped.
+* @param resolvedImports - Resolved imports to apply.
+* @returns The rewritten source and count of successful replacements.
+*/
+function rewriteImports(source, resolvedImports) {
+	let result = source;
+	let rewriteCount = 0;
+	for (const resolved of resolvedImports) {
+		const pattern = buildImportPattern(resolved);
+		const replacement = resolved.intraChunk === true ? `_${resolved.moduleId}` : `__WELD_MODULES.${resolved.moduleId}()`;
+		const rewritten = result.replace(pattern, replacement);
+		if (rewritten !== result) rewriteCount++;
+		result = rewritten;
+	}
+	return {
+		rewriteCount,
+		source: result
+	};
+}
+/** Replace `TS.import()` calls with `__WELD_MODULES` references or direct local access. */
+const rewriteInternalImports = {
+	name: "rewrite-internal-imports",
+	apply(source, context) {
+		const { rewriteCount, source: rewritten } = rewriteImports(source, context.resolvedImports);
+		if (rewriteCount !== context.resolvedImports.length) throw new Error(`rewrite count mismatch: expected ${String(context.resolvedImports.length)}, got ${String(rewriteCount)}`);
+		return rewritten;
+	}
+};
+//#endregion
+//#region src/codegen/transforms/strip-boilerplate.ts
+const TS_BOILERPLATE_PATTERN = /local\s+TS\s*=\s*_G\[script]\n?/;
+/** Strip the `local TS = _G[script]` boilerplate line. */
+const stripBoilerplate = {
+	name: "strip-boilerplate",
+	apply(source) {
+		return source.replace(TS_BOILERPLATE_PATTERN, "");
+	}
+};
+//#endregion
+//#region src/codegen/transforms/validate-no-script-refs.ts
+/**
+* Matches all Luau comments in left-to-right order:
+* - Block comments with any `=` delimiter count: `--[=*[ ... ]=*]`
+* - Single-line comments: `--` to end of line.
+*
+* Order matters: block pattern is tried first at each `--` position.
+* If `--[[` appears inside a `-- single-line comment`, the single-line
+* pattern matches first (consuming to EOL), preventing a false block open.
+*/
+const COMMENT_PATTERN = /--\[(=*)\[[\s\S]*?]\1]|--[^\n]*/g;
+/**
+* Matches only the external passthrough shape
+* `TS.import(script, TS.getModule(<args>)[.sub.path]*)`, tolerating the
+* dotted subpath chain roblox-ts emits for nested module paths like
+* `TS.getModule(script, "@rbxts", "vide").src`. Internal calls like
+* `TS.import(script, script.Parent, "dep")` are intentionally *not* matched
+* so a leftover internal import that was not rewritten still fails validation.
+*/
+const TS_IMPORT_PATTERN = /TS\.import\(\s*script\s*,\s*TS\.getModule\([^()]*\)(?:\.\w+)*\s*\)/g;
+function stripValidatedRegions(source) {
+	return source.replace(COMMENT_PATTERN, "").replace(TS_IMPORT_PATTERN, "");
+}
+//#endregion
+//#region src/codegen/defaults.ts
+/** Pipeline for non-entry modules: rename locals, strip boilerplate, rewrite imports, validate. */
+const MODULE_PIPELINE = [
+	renameLocals,
+	stripBoilerplate,
+	rewriteInternalImports,
+	{
+		name: "validate-no-script-refs",
+		apply(source) {
+			if (/\bscript\b/.test(stripValidatedRegions(source))) throw new Error("non-boilerplate script reference found");
+			return source;
+		}
+	}
+];
+/** Pipeline for entry point modules: no rename (locals stay global), no validate (script refs are legal). */
+const ENTRY_PIPELINE = [stripBoilerplate, rewriteInternalImports];
+/**
+* Path-mode non-entry pipeline. Skips validateNoScriptRefs because handwritten
+* Luau modules legitimately reference `script`. Skips stripBoilerplate because
+* there is no `local TS = _G[script]` line to remove.
+*/
+const PATH_MODULE_PIPELINE = [renameLocals, rewriteInternalImports];
+/** Path-mode entry pipeline. */
+const PATH_ENTRY_PIPELINE = [rewriteInternalImports];
+//#endregion
+//#region src/codegen/module-id.ts
+const ALPHABET_SIZE = 26;
+/**
+* 'a'.charCodeAt(0).
+*/
+const CHAR_CODE_A = 97;
+/**
+* Generate a short alphabetic ID from a zero-based index using base-26
+* encoding with lowercase letters.
+*
+* @param index - Zero-based module index.
+* @returns A lowercase alphabetic identifier.
+*/
+function generateId(index) {
+	let result = "";
+	let remaining = index;
+	do {
+		result = String.fromCharCode(CHAR_CODE_A + remaining % ALPHABET_SIZE) + result;
+		remaining = Math.floor(remaining / ALPHABET_SIZE) - 1;
+	} while (remaining >= 0);
+	return result;
+}
+/**
+* Assign short IDs to modules in the given order.
+*
+* @param sortedFilePaths - File paths in deterministic sort order.
+* @returns A map from file path to short alphabetic ID.
+*/
+function assignModuleIds(sortedFilePaths) {
+	const result = /* @__PURE__ */ new Map();
+	for (const [index, filePath] of sortedFilePaths.entries()) result.set(filePath, generateId(index));
+	return result;
+}
+//#endregion
+//#region src/codegen/pipeline.ts
+/**
+* Run a sequence of transforms over source code.
+*
+* @param source - Input source code.
+* @param options - Pipeline configuration.
+* @returns The final transformed source.
+*/
+function runPipeline(source, options) {
+	const { context, transforms } = options;
+	return transforms.reduce((current, transform) => transform.apply(current, context), source);
+}
+//#endregion
+//#region src/utils/path.ts
+/**
+* Convert Windows backslash paths to POSIX forward slashes.
+*
+* @param value - Path to normalize.
+* @returns The path with forward slashes.
+*/
+function toPosix(value) {
+	return value.replaceAll("\\", "/");
+}
+const LUAU_EXTENSIONS = [".luau", ".lua"];
+//#endregion
+//#region src/codegen/sourcemap-emitter.ts
+/**
+* Emit a Source Map V3 JSON object from a list of line-to-line mappings.
+*
+* Sources are emitted as paths relative to {@link EmitSourceMapInput.sourcemapDirectory}
+* with forward slashes. Line numbers are 1-based for both ends.
+*
+* @param input - The mappings, output path, and sourcemap directory.
+* @returns A Source Map V3 JSON object.
+*/
+function emitSourceMap(input) {
+	const map = new GenMapping({ file: path.basename(input.outputPath) });
+	const relativeBySource = /* @__PURE__ */ new Map();
+	for (const entry of input.entries) {
+		let relativeSource = relativeBySource.get(entry.sourcePath);
+		if (relativeSource === void 0) {
+			relativeSource = toPosix(path.relative(input.sourcemapDirectory, entry.sourcePath));
+			relativeBySource.set(entry.sourcePath, relativeSource);
+			setSourceContent(map, relativeSource, entry.content);
+		}
+		addMapping(map, {
+			generated: {
+				column: 0,
+				line: entry.generatedLine
+			},
+			original: {
+				column: 0,
+				line: entry.originalLine
+			},
+			source: relativeSource
+		});
+	}
+	return toEncodedMap(map);
+}
+//#endregion
+//#region src/declarations/declaration-bundler.ts
+/**
+* Map a .luau file path to its co-located .d.ts declaration file path.
+*
+* For `init.luau`, tries `init.d.ts` first, then falls back to `index.d.ts`
+* (roblox-ts renames `index.ts` → `init.luau`, but tsc emits `index.d.ts`).
+*
+* @param luauPath - Absolute posix-normalized path to a .luau file.
+* @returns Absolute path to the corresponding .d.ts file.
+*/
+function luauToDtsPath(luauPath) {
+	const direct = toPosix(luauPath.replace(/\.luau$/, ".d.ts"));
+	if (fs.existsSync(direct)) return direct;
+	const checked = [direct];
+	if (path.basename(luauPath) === "init.luau") {
+		const indexPath = toPosix(path.join(path.dirname(luauPath), "index.d.ts"));
+		checked.push(indexPath);
+		if (fs.existsSync(indexPath)) return indexPath;
+	}
+	throw new Error(`No declaration file found for ${luauPath} (checked: ${checked.join(", ")})`);
+}
+/**
+* Bundle .d.ts declaration files for a Luau entry module.
+*
+* Maps the entry .luau to its co-located .d.ts, then uses dts-bundle-generator
+* to produce a single merged declaration file.
+*
+* @param config - Declaration bundle configuration.
+* @returns The bundle result with output path.
+*/
+function bundleDeclarations(config) {
+	const bundled = generateDtsBundle([{
+		filePath: luauToDtsPath(config.entryLuauPath),
+		libraries: config.importedLibraries && config.importedLibraries.length > 0 ? { importedLibraries: [...config.importedLibraries] } : void 0,
+		output: { noBanner: true }
+	}], {})[0];
+	fs.mkdirSync(path.dirname(config.outputPath), { recursive: true });
+	fs.writeFileSync(config.outputPath, bundled);
+	return { outputPath: config.outputPath };
+}
+createEnv({
+	emptyStringAsUndefined: true,
+	runtimeEnv: process.env,
+	server: { WELD_DEBUG: type("string | undefined") }
+});
+const FALSY_VALUES = new Set(["0", "false"]);
+/**
+* Whether debug mode is enabled via the WELD_DEBUG environment variable.
+*
+* @returns True when WELD_DEBUG is set to a truthy value.
+*/
+function isDebug() {
+	const value = process.env["WELD_DEBUG"];
+	if (value === void 0 || value === "") return false;
+	return !FALSY_VALUES.has(value);
+}
+//#endregion
+//#region src/extraction/schema.ts
+/** Schema for a single require/import entry extracted from a Luau file. */
+const requireInfoSchema = type({
+	args: "string[]",
+	kind: "'require' | 'ts_import' | 'ts_import_external'"
+}).as();
+/** Schema for a top-level local binding with source locations. */
+const topLevelLocalSchema = type({
+	name: "string",
+	locations: type({
+		end: "number",
+		start: "number"
+	}).array()
+}).as();
+/** Schema for per-file extraction data from the Lute analysis. */
+const fileAnalysisSchema = type({
+	"maxLocalsInScope": "number",
+	"path": "string",
+	"renamedSource?": "string",
+	"requires": requireInfoSchema.array(),
+	"topLevelLocals?": topLevelLocalSchema.array(),
+	"totalLocals": "number"
+}).as();
+/** Schema for the timing summary emitted as the final NDJSON line. */
+const timingSummarySchema = type({
+	discoverMs: "number",
+	fileCount: "number",
+	parseMs: "number",
+	walkMs: "number",
+	wallMs: "number"
+}).as();
+//#endregion
+//#region src/extraction/ndjson-parser.ts
+const TIMING_PREFIX = "__TIMING__";
+/**
+* Parse NDJSON stdout from the Lute extraction process.
+*
+* @param stdout - Raw stdout string with one JSON object per line.
+* @returns Parsed extraction result with file analyses and optional timing.
+*/
+function parseNdjsonOutput(stdout) {
+	const lines = stdout.split("\n");
+	const analyses = [];
+	let timing;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed === "") continue;
+		if (trimmed.startsWith(TIMING_PREFIX)) {
+			const result = timingSummarySchema(safeParse(trimmed.slice(10), trimmed));
+			if (result instanceof type.errors) throw new Error(`Invalid timing data on line: ${trimmed}\n${result.summary}`);
+			timing = result;
+			continue;
+		}
+		const result = fileAnalysisSchema(safeParse(trimmed, trimmed));
+		if (result instanceof type.errors) throw new Error(`Invalid file analysis on line: ${trimmed}\n${result.summary}`);
+		analyses.push(result);
+	}
+	return {
+		analyses,
+		timing
+	};
+}
+/**
+* Parse a JSON string, throwing a descriptive error on failure.
+*
+* @param json - JSON string to parse.
+* @param originalLine - Original line for error context.
+* @returns The parsed value.
+*/
+function safeParse(json, originalLine) {
+	try {
+		return JSON.parse(json);
+	} catch {
+		throw new Error(`Invalid JSON on line: ${originalLine}`);
+	}
+}
+//#endregion
+//#region src/extraction/lute-spawner.ts
+/**
+* Spawn the Lute extraction process and return parsed results.
+*
+* @param luauRoot - Root directory containing Luau source files.
+* @param scriptPath - Optional override path to the extract.luau script.
+* @returns Parsed extraction result with file analyses and optional timing.
+*/
+function spawnLuteExtractor(luauRoot, scriptPath) {
+	const resolvedScript = scriptPath ?? writeTemporaryLuauScript("--- Weld extraction script: discovers Luau files, parses each with Lute's\n--- syntax.parse(), walks the full CST to find require()/TS.import() calls\n--- and count local variables per scope. Outputs one NDJSON line per file\n--- to stdout, followed by a __TIMING__-prefixed timing summary.\n---\n--- Usage: lute run extract.luau -- <luau-root>\n---\n--- CST shape (Lute returns full CST, not stripped AST):\n---   - Values/variables/arguments are wrapped: {node: <actual>}\n---   - Names are token objects: {text: \"name\"}\n---   - Strings: {tag: \"string\", token: {text: \"value\"}}\n---   - Locals: {tag: \"local\", local: {name: {text: \"x\"}}, token: {text: \"x\"}}\n---   - Globals: {tag: \"global\", name: {text: \"script\"}}\n---   - Index chains: {tag: \"indexname\", expression: <base>, index: {text: \"Parent\"}}\n---   - Calls: {tag: \"call\", func: <expr>, arguments: [{node: <arg>}, ...]}\n\nlocal fs = require(\"@std/fs\")\nlocal json = require(\"@std/json\")\nlocal process = require(\"@std/process\")\nlocal syntax = require(\"@std/syntax\")\n\n--------------------------------------------------------------------------------\n-- Argument parsing\n--------------------------------------------------------------------------------\n\nlocal args = process.args\nlocal pastSeparator = false\nlocal userArgs: { string } = {}\nfor _, arg in args do\n	if pastSeparator then\n		table.insert(userArgs, arg)\n	elseif arg == \"--\" then\n		pastSeparator = true\n	end\nend\n\nlocal luauRoot = userArgs[1]\nif not luauRoot then\n	error(\"Usage: lute run extract.luau -- <luau-root>\")\nend\n\nluauRoot = string.gsub(luauRoot, \"\\\\\", \"/\")\nif string.sub(luauRoot, -1) == \"/\" then\n	luauRoot = string.sub(luauRoot, 1, -2)\nend\n\n--------------------------------------------------------------------------------\n-- File discovery\n--------------------------------------------------------------------------------\n\nlocal function discoverFiles(directory: string, relativeTo: string, results: { string })\n	local ok, entries = pcall(fs.listDirectory, directory)\n	if not ok then\n		return\n	end\n\n	for _, entry in entries do\n		local fullPath = directory .. \"/\" .. entry.name\n		if entry.type == \"dir\" then\n			-- Skip node_modules, coverage dirs, and dot directories\n			if entry.name == \"node_modules\" or entry.name == \".jest-roblox\" then\n				continue\n			end\n\n			if string.sub(entry.name, 1, 1) == \".\" then\n				continue\n			end\n\n			discoverFiles(fullPath, relativeTo, results)\n		elseif\n			entry.type == \"file\"\n			and (string.sub(entry.name, -5) == \".luau\" or string.sub(entry.name, -4) == \".lua\")\n		then\n			local relative = string.sub(fullPath, #relativeTo + 2)\n			table.insert(results, relative)\n		end\n	end\nend\n\n--------------------------------------------------------------------------------\n-- CST helpers\n--------------------------------------------------------------------------------\n\ntype RequireInfo = {\n	kind: \"require\" | \"ts_import\" | \"ts_import_external\",\n	args: { string },\n}\n\ntype SourceLocation = {\n	start: number,\n	[\"end\"]: number,\n}\n\ntype TopLevelLocal = {\n	name: string,\n	locations: { SourceLocation },\n}\n\n--- Build a table mapping 1-based line numbers to 0-based byte offsets of each\n--- line's start position. Used to convert CST line/column positions to byte\n--- offsets.\nlocal function buildLineOffsets(source: string): { number }\n	local offsets: { number } = { 0 } -- line 1 starts at byte 0\n	local pos = 1\n	while pos <= #source do\n		local nl = string.find(source, \"\\n\", pos, true)\n		if not nl then\n			break\n		end\n		-- Next line starts at the byte after the newline\n		table.insert(offsets, nl) -- 0-based offset: nl is 1-based pos of \\n, next char is at nl (0-based)\n		pos = nl + 1\n	end\n	return offsets\nend\n\n--- Convert a CST location (1-based line/column) to a 0-based byte offset range.\nlocal function locationToByteRange(location: any, lineOffsets: { number }): SourceLocation\n	local beginLine = location.beginLine :: number\n	local beginCol = location.beginColumn :: number\n	local endLine = location.endLine :: number\n	local endCol = location.endColumn :: number\n	local startOffset = lineOffsets[beginLine] + beginCol - 1\n	local endOffset = lineOffsets[endLine] + endCol - 1\n	return { start = startOffset, [\"end\"] = endOffset }\nend\n\n--- Create a unique key for a declaration binding based on its location.\nlocal function bindingKey(location: any): string\n	return `{location.beginLine}:{location.beginColumn}`\nend\n\n--- Unwrap a CST node wrapper ({node: X} -> X).\nlocal function unwrap(wrapper: any): any\n	if type(wrapper) == \"table\" and wrapper.node ~= nil then\n		return wrapper.node\n	end\n\n	return wrapper\nend\n\n--- Get the text name from a CST name/token reference.\nlocal function getName(node: any): string?\n	if type(node) ~= \"table\" then\n		return nil\n	end\n\n	if node.text ~= nil then\n		return node.text :: string\n	end\n\n	if node.name ~= nil and type(node.name) == \"table\" then\n		return (node.name :: any).text\n	end\n\n	return nil\nend\n\n--- Reconstruct a path expression into a readable string.\nlocal function exprToString(node: any): string?\n	if type(node) ~= \"table\" then\n		return nil\n	end\n\n	if node.tag == \"string\" then\n		local text: string? = if node.token then (node.token :: any).text else node.text\n		if text then\n			return `\"{text}\"`\n		end\n\n		return nil\n	end\n\n	if node.tag == \"global\" then\n		return getName(node)\n	end\n\n	if node.tag == \"local\" then\n		if node.token then\n			return getName(node.token)\n		end\n\n		if node[\"local\"] then\n			return getName(node[\"local\"])\n		end\n\n		return nil\n	end\n\n	if node.tag == \"indexname\" then\n		local base = exprToString(node.expression)\n		local index = getName(node.index)\n		if base and index then\n			return `{base}.{index}`\n		end\n\n		return index\n	end\n\n	return nil\nend\n\n--- Extract all arguments from a CST call's argument list as readable strings.\nlocal function extractCallArgs(arguments: any): { string }\n	local result: { string } = {}\n	if type(arguments) ~= \"table\" then\n		return result\n	end\n\n	for _, argWrapper in arguments do\n		local arg = unwrap(argWrapper)\n		if type(arg) == \"table\" then\n			local repr = exprToString(arg)\n			if repr then\n				table.insert(result, repr)\n			end\n		end\n	end\n\n	return result\nend\n\n--- Check if a CST node is a TS.getModule(...) call.\nlocal function isGetModuleCall(node: any): boolean\n	if type(node) ~= \"table\" or node.tag ~= \"call\" then\n		return false\n	end\n\n	local func = node.func\n	if not func or func.tag ~= \"indexname\" then\n		return false\n	end\n\n	local baseName = exprToString(func.expression)\n	local indexName = getName(func.index)\n	return baseName == \"TS\" and indexName == \"getModule\"\nend\n\n--- Extract TS.getModule arguments and any sub-path chain from a CST node.\n--- For `TS.getModule(script, \"@rbxts\", \"vide\").src`, returns {\"@rbxts\", \"vide\", \"src\"}.\n--- Returns nil if the node does not contain a TS.getModule call.\nlocal function extractGetModuleArgs(node: any): { string }?\n	-- Walk down indexname chain to find the base call\n	local subPathSegments: { string } = {}\n	local current = node\n\n	while type(current) == \"table\" and current.tag == \"indexname\" do\n		local indexName = getName(current.index)\n		if indexName then\n			table.insert(subPathSegments, 1, indexName)\n		end\n		current = current.expression\n	end\n\n	-- Base must be a TS.getModule(...) call\n	if not isGetModuleCall(current) then\n		return nil\n	end\n\n	-- Extract string literal args from getModule (skip first arg: script)\n	local result: { string } = {}\n	if current.arguments and type(current.arguments) == \"table\" then\n		local skipFirst = true\n		for _, argWrapper in current.arguments do\n			if skipFirst then\n				skipFirst = false\n				continue\n			end\n			local arg = unwrap(argWrapper)\n			if type(arg) == \"table\" and arg.tag == \"string\" then\n				local text: string? = if arg.token then (arg.token :: any).text else arg.text\n				if text then\n					table.insert(result, text)\n				end\n			end\n		end\n	end\n\n	-- Append sub-path segments\n	for _, segment in subPathSegments do\n		table.insert(result, segment)\n	end\n\n	return result\nend\n\n--- Check if a CST call node is require() or TS.import() and record it.\nlocal function checkCall(callNode: any, requires: { RequireInfo })\n	if type(callNode) ~= \"table\" or callNode.tag ~= \"call\" then\n		return\n	end\n\n	local func = callNode.func\n	if not func then\n		return\n	end\n\n	-- require(...) -- global or local\n	if func.tag == \"global\" or func.tag == \"local\" then\n		local funcName = exprToString(func)\n		if funcName == \"require\" then\n			local info: RequireInfo = {\n				kind = \"require\",\n				args = extractCallArgs(callNode.arguments),\n			}\n			table.insert(requires, info)\n			return\n		end\n	end\n\n	-- TS.import(...) -- indexname where base is \"TS\" and index is \"import\"\n	if func.tag == \"indexname\" then\n		local baseName = exprToString(func.expression)\n		local indexName = getName(func.index)\n\n		if baseName == \"TS\" and indexName == \"import\" then\n			-- Check if any argument contains TS.getModule (external dep)\n			local externalArgs: { string }? = nil\n			if callNode.arguments and type(callNode.arguments) == \"table\" then\n				for _, argWrapper in callNode.arguments do\n					local arg = unwrap(argWrapper)\n					local moduleArgs = extractGetModuleArgs(arg)\n					if moduleArgs then\n						externalArgs = moduleArgs\n						break\n					end\n				end\n			end\n\n			if externalArgs then\n				local info: RequireInfo = {\n					kind = \"ts_import_external\",\n					args = externalArgs,\n				}\n				table.insert(requires, info)\n			else\n				local info: RequireInfo = {\n					kind = \"ts_import\",\n					args = extractCallArgs(callNode.arguments),\n				}\n				table.insert(requires, info)\n			end\n		end\n	end\nend\n\n--- Table for tracking top-level local references during expression walking.\n--- Maps binding key (line:col) to the TopLevelLocal entry.\ntype TopLevelTracker = {\n	--- Map from binding key to TopLevelLocal entry.\n	bindings: { [string]: TopLevelLocal },\n	--- Precomputed line-start byte offsets.\n	lineOffsets: { number },\n}\n\n--- Forward declaration for mutual recursion (walkExpression uses walkBlock)\nlocal walkBlock: (block: any, requires: { RequireInfo }, tracker: TopLevelTracker?, rootBlock: boolean?) -> (number, number)\n\n--------------------------------------------------------------------------------\n-- Full expression walker\n--------------------------------------------------------------------------------\n\n--- Walk an expression recursively, checking for calls at every position.\n--- This is the key difference from the spike: we walk ALL expression positions.\n--- When tracker is provided, also records byte offsets for top-level local refs.\nlocal function walkExpression(expr: any, requires: { RequireInfo }, tracker: TopLevelTracker?)\n	if type(expr) ~= \"table\" then\n		return\n	end\n\n	-- Track local references when a tracker is active\n	if tracker and expr.tag == \"local\" and expr.kind == \"expr\" then\n		local binding = expr[\"local\"]\n		if type(binding) == \"table\" and binding.location then\n			local key = bindingKey(binding.location)\n			local entry = tracker.bindings[key]\n			if entry then\n				local range = locationToByteRange(expr.location, tracker.lineOffsets)\n				table.insert(entry.locations, range)\n			end\n		end\n	end\n\n	-- Always check if this expression itself is a call\n	checkCall(expr, requires)\n\n	-- Recurse into sub-expressions based on tag\n	local tag = expr.tag\n\n	if tag == \"call\" then\n		-- Walk the function expression (could be a nested call)\n		if expr.func then\n			walkExpression(expr.func, requires, tracker)\n		end\n\n		-- Walk each argument (nested calls in arguments)\n		if expr.arguments and type(expr.arguments) == \"table\" then\n			for _, argWrapper in expr.arguments do\n				walkExpression(unwrap(argWrapper), requires, tracker)\n			end\n		end\n	elseif tag == \"indexname\" or tag == \"index\" then\n		if expr.expression then\n			walkExpression(expr.expression, requires, tracker)\n		end\n\n		if tag == \"index\" and expr.index then\n			walkExpression(unwrap(expr.index), requires, tracker)\n		end\n	elseif tag == \"binary\" then\n		if expr.lhsOperand then\n			walkExpression(unwrap(expr.lhsOperand), requires, tracker)\n		end\n\n		if expr.rhsOperand then\n			walkExpression(unwrap(expr.rhsOperand), requires, tracker)\n		end\n	elseif tag == \"unary\" then\n		if expr.operand then\n			walkExpression(unwrap(expr.operand), requires, tracker)\n		end\n	elseif tag == \"group\" then\n		if expr.expression then\n			walkExpression(unwrap(expr.expression), requires, tracker)\n		end\n	elseif tag == \"table\" then\n		if expr.entries and type(expr.entries) == \"table\" then\n			for _, entry in expr.entries do\n				local e = unwrap(entry)\n				if type(e) == \"table\" then\n					-- Table entry value\n					if e.value then\n						walkExpression(unwrap(e.value), requires, tracker)\n					end\n\n					-- Table entry key (indexexpr)\n					if e.key then\n						walkExpression(unwrap(e.key), requires, tracker)\n					end\n				end\n			end\n		end\n	elseif tag == \"ifelse\" then\n		-- Ternary: if cond then a else b\n		if expr.condition then\n			walkExpression(unwrap(expr.condition), requires, tracker)\n		end\n\n		if expr.thenExpr then\n			walkExpression(unwrap(expr.thenExpr), requires, tracker)\n		end\n\n		if expr.elseExpr then\n			walkExpression(unwrap(expr.elseExpr), requires, tracker)\n		end\n\n		-- elseif chains in if-expressions\n		if expr.elseifs and type(expr.elseifs) == \"table\" then\n			for _, elseifEntry in expr.elseifs do\n				if type(elseifEntry) == \"table\" then\n					if elseifEntry.condition then\n						walkExpression(unwrap(elseifEntry.condition), requires, tracker)\n					end\n\n					if elseifEntry.thenExpr then\n						walkExpression(unwrap(elseifEntry.thenExpr), requires, tracker)\n					end\n				end\n			end\n		end\n	elseif tag == \"function\" then\n		-- Anonymous function expression: walk the body for require calls\n		-- but mark as non-root so locals inside aren't tracked as top-level.\n		if expr.body and type(expr.body) == \"table\" and expr.body.statements then\n			walkBlock(expr.body, requires, tracker, false)\n		end\n	elseif tag == \"cast\" then\n		if expr.operand then\n			walkExpression(unwrap(expr.operand), requires, tracker)\n		end\n	end\nend\n\n--------------------------------------------------------------------------------\n-- Statement/block walker\n--------------------------------------------------------------------------------\n\n--- Count local declarations in a CST statement.\nlocal function countLocals(stat: any): number\n	if stat.tag == \"local\" then\n		if stat.variables and type(stat.variables) == \"table\" then\n			return #stat.variables\n		end\n\n		return 1\n	elseif stat.tag == \"localfunction\" then\n		return 1\n	end\n\n	return 0\nend\n\n--- Register a top-level local declaration in the tracker.\nlocal function registerTopLevelLocal(\n	tracker: TopLevelTracker,\n	name: string,\n	declLocation: any\n)\n	local key = bindingKey(declLocation)\n	local range = locationToByteRange(declLocation, tracker.lineOffsets)\n	local entry: TopLevelLocal = {\n		name = name,\n		locations = { range },\n	}\n	tracker.bindings[key] = entry\nend\n\n--- Walk a block's statements, extracting requires and counting locals.\n--- Uses iterative stack-based traversal for the block level to avoid stack limits.\n--- When tracker is provided, records top-level local declarations from the root\n--- block (first stack entry only) and all references throughout the tree.\nwalkBlock = function(block: any, requires: { RequireInfo }, tracker: TopLevelTracker?, rootBlock: boolean?): (number, number)\n	local maxLocals = 0\n	local totalLocals = 0\n	local isInitialRoot = if rootBlock == nil then true else rootBlock\n\n	type StackEntry = { statements: any, locals: number, isRoot: boolean }\n	local stack: { StackEntry } = {}\n	table.insert(stack, { statements = block.statements or {}, locals = 0, isRoot = isInitialRoot })\n\n	while #stack > 0 do\n		local entry = table.remove(stack, #stack) :: StackEntry\n		local statements = entry.statements\n		local scopeLocals = entry.locals\n		local isRoot = entry.isRoot\n\n		if type(statements) ~= \"table\" then\n			continue\n		end\n\n		for _, stat in statements do\n			if type(stat) ~= \"table\" then\n				continue\n			end\n\n			local localCount = countLocals(stat)\n			scopeLocals += localCount\n			totalLocals += localCount\n\n			-- Register top-level locals when tracking (root block only)\n			if tracker and isRoot then\n				if stat.tag == \"local\" and stat.variables then\n					for _, varWrapper in stat.variables do\n						local v = unwrap(varWrapper)\n						if type(v) == \"table\" and v.name and v.location then\n							local varName = getName(v.name)\n							if varName then\n								registerTopLevelLocal(tracker, varName, v.location)\n							end\n						end\n					end\n				elseif stat.tag == \"localfunction\" and stat.name then\n					local funcName = getName(stat.name.name or stat.name)\n					local funcLoc = stat.name.location\n					if funcName and funcLoc then\n						registerTopLevelLocal(tracker, funcName, funcLoc)\n					end\n				end\n			end\n\n			-- Walk values in local/assign statements\n			if (stat.tag == \"local\" or stat.tag == \"assign\") and stat.values then\n				for _, valueWrapper in stat.values do\n					walkExpression(unwrap(valueWrapper), requires, tracker)\n				end\n			end\n\n			-- Walk assignment targets (for destructuring/indexing)\n			if stat.tag == \"assign\" and stat.variables then\n				for _, varWrapper in stat.variables do\n					walkExpression(unwrap(varWrapper), requires, tracker)\n				end\n			end\n\n			-- Expression statements (bare calls)\n			if stat.tag == \"expression\" and stat.expression then\n				walkExpression(stat.expression, requires, tracker)\n			end\n\n			-- Return statements (CST uses \"expressions\" not \"values\")\n			if stat.tag == \"return\" and stat.expressions then\n				for _, valueWrapper in stat.expressions do\n					walkExpression(unwrap(valueWrapper), requires, tracker)\n				end\n			end\n\n			-- For-in: walk the expression list\n			if stat.tag == \"forin\" and stat.values then\n				for _, valueWrapper in stat.values do\n					walkExpression(unwrap(valueWrapper), requires, tracker)\n				end\n			end\n\n			-- Numeric for: walk start/end/step\n			if stat.tag == \"for\" then\n				if stat.from then\n					walkExpression(unwrap(stat.from), requires, tracker)\n				end\n\n				if stat.to then\n					walkExpression(unwrap(stat.to), requires, tracker)\n				end\n\n				if stat.step then\n					walkExpression(unwrap(stat.step), requires, tracker)\n				end\n			end\n\n			-- While/repeat: walk condition\n			if stat.tag == \"while\" and stat.condition then\n				walkExpression(unwrap(stat.condition), requires, tracker)\n			end\n\n			if stat.tag == \"repeat\" and stat.condition then\n				walkExpression(unwrap(stat.condition), requires, tracker)\n			end\n\n			-- If statement conditions\n			if stat.tag == \"conditional\" and stat.condition then\n				walkExpression(unwrap(stat.condition), requires, tracker)\n			end\n\n			-- Non-local function statements: track name references.\n			-- Handles both `function foo(...)` (direct local) and\n			-- `function Foo.bar(...)` / `function Foo:baz(...)` (indexname\n			-- where the base expression is a local reference).\n			if stat.tag == \"function\" and stat.name and tracker then\n				local nameNode = stat.name\n				-- Direct local: `function foo(...)`\n				if nameNode.tag == \"local\" or (nameNode.token and nameNode[\"local\"]) then\n					local nameToken = nameNode.token :: any\n					local nameLocal = nameNode[\"local\"] :: any\n					if nameToken and nameLocal and type(nameLocal) == \"table\" then\n						local declLoc = nameLocal.location\n						if nameToken.location and declLoc then\n							local key = bindingKey(declLoc)\n							local existing = tracker.bindings[key]\n							if existing then\n								local range = locationToByteRange(nameToken.location, tracker.lineOffsets)\n								table.insert(existing.locations, range)\n							end\n						end\n					end\n				end\n				-- Indexname: `function Foo.bar(...)` — walk the base expression\n				if nameNode.tag == \"indexname\" and nameNode.expression then\n					walkExpression(nameNode.expression, requires, tracker)\n				end\n			end\n\n			-- Push nested blocks onto the stack (never root)\n			if stat.body and type(stat.body) == \"table\" and stat.body.statements then\n				table.insert(stack, { statements = stat.body.statements, locals = 0, isRoot = false })\n			end\n\n			if stat.thenBlock and type(stat.thenBlock) == \"table\" and stat.thenBlock.statements then\n				table.insert(stack, { statements = stat.thenBlock.statements, locals = 0, isRoot = false })\n			end\n\n			if stat.elseBlock and type(stat.elseBlock) == \"table\" and stat.elseBlock.statements then\n				table.insert(stack, { statements = stat.elseBlock.statements, locals = 0, isRoot = false })\n			end\n\n			if stat.elseifs and type(stat.elseifs) == \"table\" then\n				for _, elseif_ in stat.elseifs do\n					if type(elseif_) == \"table\" then\n						-- Walk elseif condition\n						if elseif_.condition then\n							walkExpression(unwrap(elseif_.condition), requires, tracker)\n						end\n\n						local thenBlock = elseif_.thenBlock\n						if type(thenBlock) == \"table\" and thenBlock.statements then\n							table.insert(stack, { statements = thenBlock.statements, locals = 0, isRoot = false })\n						end\n					end\n				end\n			end\n\n			-- Function bodies (localfunction and function statements)\n			if stat.func and type(stat.func) == \"table\" then\n				local funcBody = stat.func.body\n				if type(funcBody) == \"table\" and funcBody.statements then\n					table.insert(stack, { statements = funcBody.statements, locals = 0, isRoot = false })\n				end\n			end\n		end\n\n		if scopeLocals > maxLocals then\n			maxLocals = scopeLocals\n		end\n	end\n\n	return maxLocals, totalLocals\nend\n\n--------------------------------------------------------------------------------\n-- Per-file analysis\n--------------------------------------------------------------------------------\n\nlocal function analyzeSource(source: string, filePath: string): (any, number, number)\n	local parseStart = os.clock()\n	local parseResult = syntax.parse(source)\n	local parseTime = os.clock() - parseStart\n\n	local requires: { RequireInfo } = {}\n\n	-- Build tracker for top-level local collection\n	local lineOffsets = buildLineOffsets(source)\n	local tracker: TopLevelTracker = {\n		bindings = {},\n		lineOffsets = lineOffsets,\n	}\n\n	local walkStart = os.clock()\n	local maxLocals, totalLocals = walkBlock(parseResult.root, requires, tracker)\n	local walkTime = os.clock() - walkStart\n\n	-- Serialize requires for JSON\n	local reqs: json.Array = {} :: any\n	for _, req in requires do\n		table.insert(reqs :: any, {\n			kind = req.kind,\n			args = req.args :: json.Array,\n		})\n	end\n\n	-- Serialize topLevelLocals for JSON\n	local topLocals: json.Array = {} :: any\n	for _, entry in tracker.bindings do\n		local locs: json.Array = {} :: any\n		for _, loc in entry.locations do\n			table.insert(locs :: any, {\n				start = loc.start,\n				[\"end\"] = loc[\"end\"],\n			})\n		end\n		table.insert(topLocals :: any, {\n			name = entry.name,\n			locations = locs,\n		})\n	end\n\n	local analysis = {\n		path = filePath,\n		requires = reqs,\n		maxLocalsInScope = maxLocals,\n		totalLocals = totalLocals,\n		topLevelLocals = topLocals,\n	}\n\n	return analysis, parseTime, walkTime\nend\n\n--------------------------------------------------------------------------------\n-- Main\n--------------------------------------------------------------------------------\n\n-- Discover files\nlocal discoverStart = os.clock()\nlocal files: { string } = {}\ndiscoverFiles(luauRoot, luauRoot, files)\nlocal discoverTime = os.clock() - discoverStart\n\n-- Parse + extract, stream NDJSON\nlocal totalStart = os.clock()\nlocal totalParseMs = 0\nlocal totalWalkMs = 0\n\nfor _, relativePath in files do\n	local fullPath = luauRoot .. \"/\" .. relativePath\n	local source = fs.readFileToString(fullPath)\n	local analysis, parseTime, walkTime = analyzeSource(source, relativePath)\n\n	totalParseMs += parseTime * 1000\n	totalWalkMs += walkTime * 1000\n\n	print(json.serialize(analysis))\nend\n\nlocal totalTime = os.clock() - totalStart\n\n-- Final line: timing summary prefixed so Node can distinguish it\nprint(\"__TIMING__\" .. json.serialize({\n	fileCount = #files,\n	discoverMs = discoverTime * 1000,\n	parseMs = totalParseMs,\n	walkMs = totalWalkMs,\n	wallMs = totalTime * 1000,\n}))\n", "extract");
+	return parseNdjsonOutput(spawnLute({
+		args: [luauRoot],
+		maxBuffer: 10 * 1024 * 1024,
+		scriptPath: resolvedScript,
+		timeout: 3e4
+	}));
+}
+//#endregion
+//#region src/graph/chunk-assigner.ts
+/** Default soft cap for locals per chunk. */
+const DEFAULT_SOFT_CAP = 150;
+/** Default hard cap for locals per chunk. */
+const DEFAULT_HARD_CAP = 180;
+/** Fan-in threshold: modules imported by this many or more get penalized. */
+const HIGH_FAN_IN_THRESHOLD = 3;
+/** Modules with fewer locals than this get a merge bonus. */
+const SMALL_MODULE_THRESHOLD = 10;
+/** Modules with more locals than this get a merge penalty. */
+const LARGE_MODULE_THRESHOLD = 50;
+/**
+* Assign modules to chunks using greedy DFS packing with merge scoring.
+* Walks the dependency graph in post-order, greedily merging modules into
+* chunks based on fan-in, module size, and local variable budgets.
+*
+* @param options - Chunk assignment configuration.
+* @returns The chunk assignment with ordered chunks and module mapping.
+*/
+function assignChunks(options) {
+	const { graph, localCounts } = options;
+	const softCap = options.softCap ?? DEFAULT_SOFT_CAP;
+	const hardCap = options.hardCap ?? DEFAULT_HARD_CAP;
+	const state = packModules({
+		fanIn: computeFanIn(graph),
+		graph,
+		hardCap,
+		localCounts,
+		modules: dfsOrderDfs(graph).filter((module_) => module_ !== graph.entryPoint),
+		softCap
+	});
+	const entryLocals = localCounts.get(graph.entryPoint);
+	const entryChunk = createChunk({
+		chunkId: state.chunks.length,
+		moduleLocals: entryLocals,
+		modulePath: graph.entryPoint
+	});
+	state.chunks.push(entryChunk);
+	state.moduleToChunk.set(graph.entryPoint, entryChunk.id);
+	return {
+		chunks: state.chunks,
+		moduleToChunk: state.moduleToChunk
+	};
+}
+/**
+* Create a new chunk with the given module.
+*
+* @param options - Chunk creation options.
+* @returns The new chunk.
+*/
+function createChunk(options) {
+	return {
+		id: options.chunkId,
+		modules: [options.modulePath],
+		totalLocals: options.moduleLocals + 1
+	};
+}
+/**
+* Start a new chunk in the pack state.
+*
+* @param state - Mutable pack state.
+* @param options - Module to start the chunk with.
+*/
+function startChunk(state, options) {
+	const chunk = createChunk({
+		chunkId: state.chunks.length,
+		...options
+	});
+	state.currentChunk = chunk;
+	state.currentChunkModules = new Set([options.modulePath]);
+	state.chunks.push(chunk);
+	state.moduleToChunk.set(options.modulePath, chunk.id);
+}
+function computeDependencyBonus({ chunkModules, graph, modulePath }) {
+	const node = graph.nodes.get(modulePath);
+	for (const edge of node.imports) if (chunkModules.has(edge.resolvedPath)) return 1;
+	return 0;
+}
+function computeMergeScore(input) {
+	const { chunkModules, fanIn, graph, moduleLocals, modulePath } = input;
+	let score = 0;
+	if (fanIn === 1) score += 2;
+	if (moduleLocals < SMALL_MODULE_THRESHOLD) score += 1;
+	score += computeDependencyBonus({
+		chunkModules,
+		graph,
+		modulePath
+	});
+	if (fanIn >= HIGH_FAN_IN_THRESHOLD) score -= 2;
+	if (moduleLocals > LARGE_MODULE_THRESHOLD) score -= 1;
+	return score;
+}
+/**
+* Try to pack one module into the current chunk or start a new one.
+*
+* @param state - Mutable pack state.
+* @param input - Module packing parameters.
+*/
+function packOneModule(state, input) {
+	const { fanIn, graph, hardCap, localCounts, modulePath, softCap } = input;
+	const moduleLocals = localCounts.get(modulePath);
+	if (state.currentChunk === void 0) {
+		startChunk(state, {
+			moduleLocals,
+			modulePath
+		});
+		return;
+	}
+	const estimated = state.currentChunk.totalLocals + moduleLocals + 1;
+	const score = computeMergeScore({
+		chunkModules: state.currentChunkModules,
+		fanIn: fanIn.get(modulePath),
+		graph,
+		moduleLocals,
+		modulePath
+	});
+	if (estimated <= softCap && score >= 0 || estimated <= hardCap && score > 0) {
+		state.currentChunk.modules.push(modulePath);
+		state.currentChunk.totalLocals = estimated;
+		state.currentChunkModules.add(modulePath);
+		state.moduleToChunk.set(modulePath, state.currentChunk.id);
+	} else startChunk(state, {
+		moduleLocals,
+		modulePath
+	});
+}
+/**
+* Pack modules into chunks using merge scoring.
+*
+* @param input - Packing configuration.
+* @returns Mutable pack state with chunks and mappings.
+*/
+function packModules(input) {
+	const { fanIn, graph, hardCap, localCounts, modules, softCap } = input;
+	const state = {
+		chunks: [],
+		currentChunk: void 0,
+		currentChunkModules: /* @__PURE__ */ new Set(),
+		moduleToChunk: /* @__PURE__ */ new Map()
+	};
+	for (const modulePath of modules) packOneModule(state, {
+		fanIn,
+		graph,
+		hardCap,
+		localCounts,
+		modulePath,
+		softCap
+	});
+	return state;
+}
+/**
+* Compute fan-in for each module (how many other modules import it).
+*
+* @param graph - The dependency graph.
+* @returns Map from file path to fan-in count.
+*/
+function computeFanIn(graph) {
+	const fanIn = /* @__PURE__ */ new Map();
+	for (const path of graph.nodes.keys()) fanIn.set(path, 0);
+	for (const node of graph.nodes.values()) for (const edge of node.imports) fanIn.set(edge.resolvedPath, fanIn.get(edge.resolvedPath) + 1);
+	return fanIn;
+}
+/**
+* Walk the graph in dfsOrder DFS from the entry point.
+* Visits leaves first, entry last.
+*
+* @param graph - The dependency graph.
+* @returns Module paths in dfsOrder.
+*/
+function dfsOrderDfs(graph) {
+	const visited = /* @__PURE__ */ new Set();
+	const order = [];
+	function visit(path) {
+		if (visited.has(path)) return;
+		visited.add(path);
+		const node = graph.nodes.get(path);
+		for (const edge of node.imports) visit(edge.resolvedPath);
+		order.push(path);
+	}
+	visit(graph.entryPoint);
+	return order;
+}
+//#endregion
+//#region src/graph/dependency-graph.ts
+/**
+* Build a directed dependency graph from file analyses and module resolution.
+* Discovers reachable modules via DFS, resolves TS.import calls, and produces
+* a topologically sorted ordering.
+*
+* @param options - Graph building configuration.
+* @returns The dependency graph with topologically sorted modules.
+*/
+function buildDependencyGraph(options) {
+	const { analyses, entryFilePath, resolve, resolveRequire } = options;
+	const nodes = discoverReachableModules({
+		analysisByPath: indexAnalyses(analyses),
+		entryFilePath,
+		resolve,
+		resolveRequire
+	});
+	return {
+		entryPoint: entryFilePath,
+		nodes,
+		sorted: topologicalSort(nodes)
+	};
+}
+/**
+* Index file analyses by path for O(1) lookup.
+*
+* @param analyses - Array of file analyses to index.
+* @returns Map from file path to its analysis.
+*/
+function indexAnalyses(analyses) {
+	const map = /* @__PURE__ */ new Map();
+	for (const entry of analyses) map.set(entry.path, entry);
+	return map;
+}
+/* c8 ignore start -- only true-branch path is reached in practice; defensive */
+function stripQuotes(text) {
+	if (text.length >= 2 && text.startsWith("\"") && text.endsWith("\"")) return text.slice(1, -1);
+	return text;
+}
+/* c8 ignore stop */
+function resolvePlainRequire(request, options) {
+	if (request.args.length === 0) return;
+	if (options.resolveRequire === void 0) throw new Error(`plain require() not supported in bundled modules: ${options.filePath}`);
+	const requireString = stripQuotes(request.args[0]);
+	const result = options.resolveRequire(options.filePath, requireString);
+	if (result.kind === "passthrough") return;
+	return {
+		args: request.args,
+		kind: "require",
+		resolvedPath: result.path
+	};
+}
+/**
+* Resolve a single require/import request into an optional ImportEdge.
+*
+* @param request - The extracted require/import metadata.
+* @param options - File path and resolver functions.
+* @returns The resolved edge, or `undefined` for passthrough/external imports.
+*/
+function resolveSingleImport(request, options) {
+	if (request.kind === "ts_import_external") return;
+	if (request.kind === "require") return resolvePlainRequire(request, options);
+	/* c8 ignore next 5 -- defensive: ts_import without resolve is a misconfiguration the dispatch path normally rules out */
+	if (options.resolve === void 0) throw new Error(`TS.import resolution invoked without a resolve callback: ${options.filePath}`);
+	const resolvedPath = options.resolve(options.filePath, request.args);
+	return {
+		args: request.args,
+		kind: "ts_import",
+		resolvedPath
+	};
+}
+/**
+* Resolve every require/import in a file's analysis into import edges.
+*
+* @param options - File analysis and resolver functions.
+* @returns Array of resolved import edges.
+*/
+function resolveImports(options) {
+	const imports = [];
+	for (const request of options.fileAnalysis.requires) {
+		const edge = resolveSingleImport(request, options);
+		if (edge !== void 0) imports.push(edge);
+	}
+	return imports;
+}
+/**
+* DFS visit a single node: resolve imports, detect cycles, recurse.
+*
+* @param state - Shared DFS traversal state.
+* @param filePath - Path of the module to visit.
+*/
+function dfsVisit(state, filePath) {
+	if (state.visited.has(filePath)) return;
+	if (state.onStack.has(filePath)) {
+		const cycle = [...state.onStack, filePath];
+		const start = cycle.indexOf(filePath);
+		throw new Error(`Circular dependency detected: ${cycle.slice(start).join(" -> ")}`);
+	}
+	const fileAnalysis = state.analysisByPath.get(filePath);
+	if (!fileAnalysis) throw new Error(`No analysis found for module: ${filePath}`);
+	state.onStack.add(filePath);
+	const imports = resolveImports({
+		fileAnalysis,
+		filePath,
+		resolve: state.resolve,
+		resolveRequire: state.resolveRequire
+	});
+	for (const edge of imports) dfsVisit(state, edge.resolvedPath);
+	state.onStack.delete(filePath);
+	state.visited.add(filePath);
+	state.nodes.set(filePath, {
+		filePath,
+		imports
+	});
+}
+/**
+* DFS from the entry point to discover all reachable modules,
+* detect cycles, and build the adjacency list.
+*
+* @param options - Entry path, indexed analyses, and resolver function.
+* @returns Map of reachable module nodes.
+*/
+function discoverReachableModules(options) {
+	const state = {
+		analysisByPath: options.analysisByPath,
+		nodes: /* @__PURE__ */ new Map(),
+		onStack: /* @__PURE__ */ new Set(),
+		resolve: options.resolve,
+		resolveRequire: options.resolveRequire,
+		visited: /* @__PURE__ */ new Set()
+	};
+	dfsVisit(state, options.entryFilePath);
+	return state.nodes;
+}
+/**
+* Compute in-degree for each node based on import edges.
+*
+* @param nodes - Adjacency list of reachable modules.
+* @returns Map from file path to its in-degree count.
+*/
+function computeInDegrees(nodes) {
+	const inDegree = /* @__PURE__ */ new Map();
+	for (const path of nodes.keys()) inDegree.set(path, 0);
+	for (const node of nodes.values()) for (const edge of node.imports) inDegree.set(edge.resolvedPath, inDegree.get(edge.resolvedPath) + 1);
+	return inDegree;
+}
+/**
+* Drain the Kahn queue: pop zero-in-degree nodes, decrement neighbors.
+*
+* @param options - Kahn's algorithm state.
+* @returns Nodes in dependents-first order.
+*/
+function drainKahnQueue(options) {
+	const { inDegree, nodes, queue } = options;
+	const sorted = [];
+	while (queue.length > 0) {
+		const path = queue.shift();
+		sorted.push(path);
+		const node = nodes.get(path);
+		for (const edge of node.imports) {
+			const updated = inDegree.get(edge.resolvedPath) - 1;
+			inDegree.set(edge.resolvedPath, updated);
+			if (updated === 0) queue.push(edge.resolvedPath);
+		}
+	}
+	return sorted;
+}
+/**
+* Topologically sort module nodes using Kahn's algorithm.
+* Returns dependencies before dependents (leaf modules first, entry last).
+*
+* @param nodes - Adjacency list of reachable modules.
+* @returns Topologically sorted file paths with dependencies first.
+*/
+function topologicalSort(nodes) {
+	const inDegree = computeInDegrees(nodes);
+	const queue = [];
+	for (const [path, degree] of inDegree) if (degree === 0) queue.push(path);
+	return drainKahnQueue({
+		inDegree,
+		nodes,
+		queue
+	}).reverse();
+}
+//#endregion
+//#region src/resolution/ts-import-parser.ts
+const PARENT_PATTERN = /\.Parent/g;
+/**
+* Parse the argument list of a `TS.import` call into a structured result.
+*
+* @param args - Raw argument strings extracted from the Luau AST.
+* @returns The parsed import with parent count and path segments.
+*/
+function parseTsImport(args) {
+	if (args.length < 3) throw new Error(`TS.import requires at least 3 arguments (script, base, segment), got ${String(args.length)}`);
+	const basePath = args[1];
+	const rawSegments = args.slice(2);
+	return {
+		parentCount: basePath.match(PARENT_PATTERN)?.length ?? 0,
+		segments: rawSegments.map((segment) => segment.replace(/^"/, "").replace(/"$/, ""))
+	};
+}
+//#endregion
+//#region src/resolution/module-resolver.ts
+/**
+* Create a module resolver that wires TS.import parsing, Rojo path
+* resolution, and reverse mapping to resolve imports to filesystem paths.
+*
+* @param getRbxPath - Function that maps a file path to its RbxPath.
+* @param reverseMapper - Reverse mapper for looking up filesystem paths.
+* @returns A ModuleResolver instance.
+*/
+function createModuleResolver(getRbxPath, reverseMapper) {
+	return { resolve(fromFilePath, tsImportArgs) {
+		const callerRbxPath = getRbxPath(fromFilePath);
+		if (callerRbxPath === void 0) throw new Error(`Cannot resolve RbxPath for caller: ${fromFilePath}`);
+		const { parentCount, segments } = parseTsImport([...tsImportArgs]);
+		if (parentCount > callerRbxPath.length) throw new Error(`Parent traversal count (${String(parentCount)}) exceeds caller RbxPath depth (${String(callerRbxPath.length)}) for: ${fromFilePath}`);
+		const targetRbxPath = [...callerRbxPath.slice(0, callerRbxPath.length - parentCount), ...segments];
+		const resolved = reverseMapper.resolve(targetRbxPath);
+		if (resolved === void 0) throw new Error(`Cannot resolve target module: ${targetRbxPath.join(".")} (from ${fromFilePath})`);
+		return resolved;
+	} };
+}
+//#endregion
+//#region src/resolution/path-require-resolver.ts
+const PATH_SEPARATOR = "/";
+const PASSTHROUGH_PREFIXES = new Set(["@rbx", "@std"]);
+const INIT_BASENAMES = new Set(["init.lua", "init.luau"]);
+/**
+* Build a resolver that mirrors Roblox's runtime string-require semantics on
+* the filesystem: `./` and `../` resolve relative to the caller, `@self/x`
+* resolves to a sibling of an init module, and `@std/*` / `@rbx/*` are
+* passed through (left unchanged in emitted output).
+*
+* @returns A function that resolves a single `require(...)` string.
+*/
+function createPathRequireResolver() {
+	const resolutionCache = /* @__PURE__ */ new Map();
+	return function resolve(fromFilePath, requireString) {
+		const parts = requireString.split(PATH_SEPARATOR);
+		const firstPart = parts[0];
+		if (PASSTHROUGH_PREFIXES.has(firstPart)) return { kind: "passthrough" };
+		validateFirstPart(fromFilePath, firstPart);
+		const targetWithoutExtension = walkParts(fromFilePath, parts);
+		const resolved = resolveFileWithExtension(targetWithoutExtension, resolutionCache);
+		if (resolved === void 0) throw new Error(`cannot resolve require("${requireString}") from ${fromFilePath}: no .luau or .lua file at ${targetWithoutExtension}`);
+		return {
+			kind: "resolved",
+			path: resolved
+		};
+	};
+}
+function validateFirstPart(fromFilePath, firstPart) {
+	if (firstPart === "") throw new Error(`paths beginning with '/' are not supported (from ${fromFilePath})`);
+	if (firstPart === "@game") throw new Error(`@game-prefixed requires are not bundleable (from ${fromFilePath})`);
+	if (firstPart === "@self" && !INIT_BASENAMES.has(path.basename(fromFilePath))) throw new Error(`@self requires are only valid from init.luau / init.lua (from ${fromFilePath})`);
+	if (firstPart !== "." && firstPart !== ".." && firstPart !== "@self" && !firstPart.startsWith("@")) throw new Error(`bare require("${firstPart}") is not supported; use a relative path (from ${fromFilePath})`);
+}
+function ensureLeadingZone(state, part) {
+	if (!state.inLeadingDotZone) throw new Error(`'${part}' is only allowed at the beginning of a require path`);
+}
+function processPart(state, part) {
+	if (part === "") return;
+	if (part === "." || part === "@self") {
+		ensureLeadingZone(state, part);
+		state.inLeadingDotZone = false;
+		return;
+	}
+	if (part === "..") {
+		ensureLeadingZone(state, part);
+		state.currentDirectory = toPosix(path.dirname(state.currentDirectory));
+		return;
+	}
+	state.currentDirectory = toPosix(path.join(state.currentDirectory, part));
+	state.inLeadingDotZone = false;
+}
+function walkParts(fromFilePath, parts) {
+	const state = {
+		currentDirectory: toPosix(path.dirname(fromFilePath)),
+		inLeadingDotZone: true
+	};
+	for (const part of parts) processPart(state, part);
+	return state.currentDirectory;
+}
+function resolveFileWithExtension(targetWithoutExtension, cache) {
+	const cached = cache.get(targetWithoutExtension);
+	if (cached !== void 0 || cache.has(targetWithoutExtension)) return cached;
+	for (const extension of LUAU_EXTENSIONS) {
+		const candidate = targetWithoutExtension + extension;
+		if (fs.existsSync(candidate)) {
+			cache.set(targetWithoutExtension, candidate);
+			return candidate;
+		}
+	}
+	cache.set(targetWithoutExtension, void 0);
+}
+//#endregion
+//#region src/resolution/rbxpath-reverse-mapper.ts
+/**
+* Serialize an RbxPath array into a string suitable for use as a Map key.
+*
+* @param rbxPath - The RbxPath segments to serialize.
+* @returns The serialized string key.
+*/
+function serializeRbxPath(rbxPath) {
+	return rbxPath.join("\0");
+}
+/**
+* Build a reverse map from RbxPath to filesystem path.
+* Calls `getRbxPath` on each discovered file.
+*
+* @param discoveredFiles - Absolute paths of all discovered files.
+* @param getRbxPath - Function that maps a file path to its RbxPath.
+* @returns A ReverseMapper for looking up filesystem paths by RbxPath.
+*/
+function createReverseMapper(discoveredFiles, getRbxPath) {
+	const map = /* @__PURE__ */ new Map();
+	for (const filePath of discoveredFiles) {
+		const rbxPath = getRbxPath(filePath);
+		if (rbxPath === void 0) continue;
+		map.set(serializeRbxPath(rbxPath), filePath);
+	}
+	return { resolve(rbxPath) {
+		return map.get(serializeRbxPath(rbxPath));
+	} };
+}
+//#endregion
+//#region src/bundler.ts
+const LOCALS_WARNING_THRESHOLD = 200;
+/**
+* Bundle a Luau entry point and its dependencies into a single file.
+*
+* @param config - Bundle configuration.
+* @returns The bundle result with output path, module count, timing, and warnings.
+*/
+function bundle(config) {
+	const outputPath = toPosix(path.resolve(config.output));
+	if (config.declaration === true && !outputPath.endsWith(".luau")) throw new Error(`--declaration requires output path ending in .luau, got: ${outputPath}`);
+	const totalStart = performance.now();
+	const phases = runBundlePhases({
+		config,
+		entryPath: toPosix(path.resolve(config.entry)),
+		outputPath
+	});
+	return {
+		declarationOutputPath: phases.declarationOutputPath,
+		moduleCount: phases.graph.sorted.length,
+		outputPath,
+		sourceMapPath: phases.sourceMapPath,
+		timing: {
+			...phases.timing,
+			totalMs: performance.now() - totalStart
+		},
+		warnings: collectLocalsWarnings(phases.rawAnalyses)
+	};
+}
+function writeSourceMapIfRequested(config, context) {
+	if (config.requireMode !== "path" || context.entries.length === 0) return;
+	const sourceMapPath = `${context.outputPath}.map`;
+	const map = emitSourceMap({
+		entries: context.entries,
+		outputPath: context.outputPath,
+		sourcemapDirectory: toPosix(path.dirname(context.outputPath))
+	});
+	fs.writeFileSync(sourceMapPath, JSON.stringify(map));
+	return sourceMapPath;
+}
+function emitDeclarations(config, options) {
+	if (config.declaration !== true) return {};
+	const start = performance.now();
+	const dtsOutputPath = options.outputPath.replace(/init\.luau$/, "index.d.ts").replace(/\.luau$/, ".d.ts");
+	const result = bundleDeclarations({
+		entryLuauPath: options.entryPath,
+		importedLibraries: config.external,
+		outputPath: dtsOutputPath
+	});
+	return {
+		declarationMs: performance.now() - start,
+		declarationOutputPath: result.outputPath
+	};
+}
+function writeBundleArtifacts(input) {
+	const { codegen, config, entryPath, outputPath } = input;
+	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+	fs.writeFileSync(outputPath, codegen.output);
+	const sourceMapPath = writeSourceMapIfRequested(config, {
+		entries: codegen.sourceMapEntries,
+		outputPath
+	});
+	return {
+		...emitDeclarations(config, {
+			entryPath,
+			outputPath
+		}),
+		sourceMapPath
+	};
+}
+function toAbsoluteAnalyses(analyses, luauRoot) {
+	return analyses.map((a) => ({
+		...a,
+		path: toPosix(path.join(luauRoot, a.path))
+	}));
+}
+function extractAndValidate(options) {
+	const { entryPath } = options;
+	const luauRoot = options.luauRoot !== void 0 && options.luauRoot !== "" ? toPosix(path.resolve(options.luauRoot)) : path.dirname(entryPath);
+	const extractionStart = performance.now();
+	const extraction = spawnLuteExtractor(luauRoot);
+	const extractionMs = performance.now() - extractionStart;
+	const entryRelativePath = toPosix(path.relative(luauRoot, entryPath));
+	if (!extraction.analyses.some((analysis) => analysis.path === entryRelativePath)) throw new Error(`Entry file not found in extraction data: ${entryPath}`);
+	return {
+		absoluteAnalyses: toAbsoluteAnalyses(extraction.analyses, luauRoot),
+		extractionMs,
+		rawAnalyses: extraction.analyses
+	};
+}
+function buildPathModeGraph(analyses, entryPath) {
+	return buildDependencyGraph({
+		analyses,
+		entryFilePath: entryPath,
+		resolveRequire: createPathRequireResolver()
+	});
+}
+function createRbxPathResolver(project, projectDirectory) {
+	return (filePath) => {
+		const posixPath = toPosix(filePath);
+		const dataModelPath = mapFsPathToDataModel(toPosix(path.relative(projectDirectory, posixPath)), project.tree);
+		if (dataModelPath === void 0) return;
+		if (dataModelPath === "") return ["game"];
+		return ["game", ...dataModelPath.split("/")];
+	};
+}
+function buildTsImportGraph(options) {
+	const { analyses, config, entryPath } = options;
+	if (config.project === void 0 || config.project === "") throw new Error("project is required when requireMode is 'ts-import'");
+	const getRbxPath = createRbxPathResolver(loadRojoProject(config.project), toPosix(path.dirname(path.resolve(config.project))));
+	const resolver = createModuleResolver(getRbxPath, createReverseMapper(analyses.map((a) => a.path), getRbxPath));
+	return buildDependencyGraph({
+		analyses,
+		entryFilePath: entryPath,
+		resolve: (from, args) => resolver.resolve(from, args)
+	});
+}
+function resolveModules(config, analyses, entryPath) {
+	if (config.requireMode === "path") return buildPathModeGraph(analyses, entryPath);
+	return buildTsImportGraph({
+		analyses,
+		config,
+		entryPath
+	});
+}
+function buildAnalysisLookups(analyses) {
+	const localCounts = /* @__PURE__ */ new Map();
+	const topLevelLocals = /* @__PURE__ */ new Map();
+	for (const analysis of analyses) {
+		const nonBoilerplate = (analysis.topLevelLocals ?? []).filter((local) => local.name !== "TS");
+		localCounts.set(analysis.path, nonBoilerplate.length);
+		topLevelLocals.set(analysis.path, nonBoilerplate);
+	}
+	return {
+		localCounts,
+		topLevelLocals
+	};
+}
+function buildResolvedImports(graph, options) {
+	const { chunkMapping, filePath, moduleIds } = options;
+	const node = graph.nodes.get(filePath);
+	const sourceChunk = chunkMapping.get(filePath);
+	return node.imports.map((edge) => {
+		const targetChunk = chunkMapping.get(edge.resolvedPath);
+		const intraChunk = sourceChunk !== void 0 && targetChunk !== void 0 && sourceChunk === targetChunk;
+		return {
+			args: [...edge.args],
+			intraChunk: intraChunk || void 0,
+			kind: edge.kind,
+			moduleId: moduleIds.get(edge.resolvedPath)
+		};
+	});
+}
+function renameAndRewriteWithRaw(input, rawSource) {
+	const { chunkAssignment, graph, moduleId, moduleIds, modulePath, pipeline, topLevelLocals } = input;
+	return runPipeline(rawSource, {
+		context: {
+			isEntryPoint: false,
+			locals: topLevelLocals,
+			moduleId,
+			resolvedImports: buildResolvedImports(graph, {
+				chunkMapping: chunkAssignment.moduleToChunk,
+				filePath: modulePath,
+				moduleIds
+			})
+		},
+		transforms: pipeline
+	});
+}
+function processChunkedModule(input) {
+	const rawSource = fs.readFileSync(input.modulePath, "utf-8");
+	return {
+		id: input.moduleId,
+		originalContent: rawSource,
+		source: renameAndRewriteWithRaw(input, rawSource),
+		sourcePath: input.modulePath,
+		totalLocals: isDebug() ? input.totalLocals : void 0
+	};
+}
+function buildBundleChunks(options) {
+	const { chunkAssignment, graph, lookups, moduleIds, pipeline } = options;
+	return chunkAssignment.chunks.filter((chunk) => !chunk.modules.includes(graph.entryPoint)).map((chunk) => {
+		const modules = chunk.modules.map((modulePath) => {
+			return processChunkedModule({
+				chunkAssignment,
+				graph,
+				moduleId: moduleIds.get(modulePath),
+				moduleIds,
+				modulePath,
+				pipeline,
+				topLevelLocals: lookups.topLevelLocals.get(modulePath),
+				totalLocals: lookups.localCounts.get(modulePath)
+			});
+		});
+		return {
+			id: chunk.id,
+			modules
+		};
+	});
+}
+function rewriteEntrySource(options) {
+	const { chunkAssignment, entryPath, graph, moduleIds, pipeline } = options;
+	const entrySource = fs.readFileSync(entryPath, "utf-8");
+	return {
+		originalContent: entrySource,
+		rewritten: runPipeline(entrySource, {
+			context: {
+				isEntryPoint: true,
+				locals: [],
+				moduleId: "",
+				resolvedImports: buildResolvedImports(graph, {
+					chunkMapping: chunkAssignment.moduleToChunk,
+					filePath: entryPath,
+					moduleIds
+				})
+			},
+			transforms: pipeline
+		})
+	};
+}
+function pickPipelines(requireMode) {
+	if (requireMode === "path") return {
+		entry: PATH_ENTRY_PIPELINE,
+		module: PATH_MODULE_PIPELINE
+	};
+	return {
+		entry: ENTRY_PIPELINE,
+		module: MODULE_PIPELINE
+	};
+}
+function assembleBundle(input) {
+	const sourceMapEntries = [];
+	return {
+		output: generateChunkedBundle(input.chunks, input.entry.rewritten, {
+			entryInfo: {
+				originalContent: input.entry.originalContent,
+				sourcePath: input.entryPath
+			},
+			includeTsGlobal: input.requireMode !== "path",
+			onMapping: (mapping) => {
+				sourceMapEntries.push(mapping);
+			}
+		}),
+		sourceMapEntries
+	};
+}
+function generateOutput(options) {
+	const { analyses, entryPath, graph, requireMode } = options;
+	const moduleIds = assignModuleIds(graph.sorted.filter((mp) => mp !== entryPath));
+	const lookups = buildAnalysisLookups(analyses);
+	const chunkAssignment = assignChunks({
+		graph,
+		localCounts: lookups.localCounts
+	});
+	const pipelines = pickPipelines(requireMode);
+	return assembleBundle({
+		chunks: buildBundleChunks({
+			chunkAssignment,
+			graph,
+			lookups,
+			moduleIds,
+			pipeline: pipelines.module
+		}),
+		entry: rewriteEntrySource({
+			chunkAssignment,
+			entryPath,
+			graph,
+			moduleIds,
+			pipeline: pipelines.entry
+		}),
+		entryPath,
+		requireMode
+	});
+}
+function runCodegen(input) {
+	const start = performance.now();
+	return {
+		codegen: generateOutput({
+			analyses: input.analyses,
+			entryPath: input.entryPath,
+			graph: input.graph,
+			requireMode: input.config.requireMode ?? "ts-import"
+		}),
+		codegenMs: performance.now() - start
+	};
+}
+function runBundlePhases(input) {
+	const { config, entryPath, outputPath } = input;
+	const { absoluteAnalyses, extractionMs, rawAnalyses } = extractAndValidate({
+		entryPath,
+		luauRoot: config.luauRoot
+	});
+	const resolutionStart = performance.now();
+	const graph = resolveModules(config, absoluteAnalyses, entryPath);
+	const resolutionMs = performance.now() - resolutionStart;
+	const { codegen, codegenMs } = runCodegen({
+		analyses: absoluteAnalyses,
+		config,
+		entryPath,
+		graph
+	});
+	const written = writeBundleArtifacts({
+		codegen,
+		config,
+		entryPath,
+		outputPath
+	});
+	return {
+		declarationOutputPath: written.declarationOutputPath,
+		graph,
+		rawAnalyses,
+		sourceMapPath: written.sourceMapPath,
+		timing: {
+			codegenMs,
+			declarationMs: written.declarationMs,
+			extractionMs,
+			resolutionMs
+		}
+	};
+}
+function collectLocalsWarnings(analyses) {
+	const warnings = [];
+	for (const analysis of analyses) if (analysis.totalLocals > LOCALS_WARNING_THRESHOLD) warnings.push(`${analysis.path}: ${String(analysis.totalLocals)} locals exceeds ${String(LOCALS_WARNING_THRESHOLD)} threshold`);
+	return warnings;
+}
+//#endregion
+//#region src/config/loader.ts
+/**
+* Load and validate a weld config file using c12 discovery.
+*
+* @param configPath - Explicit path to a config file, or undefined for auto-discovery.
+* @param cwd - Working directory for config discovery.
+* @returns The validated config.
+* @rejects When the config file is not found, invalid, or extends resolution fails.
+*/
+async function loadConfig$1(configPath, cwd = process.cwd()) {
+	const { config, extendWarnings } = await loadRawConfig(configPath, cwd);
+	if (extendWarnings.length > 0) {
+		const extendsPath = extendWarnings[0]?.match(/`([^`]+)`/)?.[1];
+		throw new Error(`Failed to resolve extends: "${String(extendsPath)}". If the file exists, try adding the file extension (e.g. ".ts").`);
+	}
+	return validateConfig(resolveFunctionValues(config));
+}
+function merger(...sources) {
+	return defuFn(...sources.filter(Boolean));
+}
+function interceptExtendWarnings(originalWarn, extendWarnings) {
+	return (...args) => {
+		const message = args.join(" ");
+		if (message.includes("Cannot extend config")) {
+			extendWarnings.push(message);
+			return;
+		}
+		originalWarn.apply(console, args);
+	};
+}
+function isNotFoundError(err) {
+	return err instanceof Error && err.message.includes("cannot be resolved");
+}
+async function loadRawConfig(configPath, cwd) {
+	const extendWarnings = [];
+	const originalWarn = console.warn;
+	try {
+		console.warn = interceptExtendWarnings(originalWarn, extendWarnings);
+		return {
+			config: (await loadConfig({
+				name: "weld",
+				configFile: configPath,
+				configFileRequired: configPath !== void 0,
+				cwd,
+				dotenv: false,
+				globalRc: false,
+				merger,
+				omit$Keys: true,
+				packageJson: false,
+				rcFile: false
+			})).config,
+			extendWarnings
+		};
+	} catch (err) {
+		if (configPath !== void 0 && isNotFoundError(err)) throw new Error(`Config file not found: ${configPath}`, { cause: err });
+		throw err;
+	} finally {
+		console.warn = originalWarn;
+	}
+}
+function isMergerFunction(value) {
+	return typeof value === "function";
+}
+function resolveFunctionValues(config) {
+	const resolved = {};
+	for (const [key, value] of Object.entries(config)) resolved[key] = isMergerFunction(value) ? value(void 0) : value;
+	return resolved;
+}
+//#endregion
+//#region src/utils/logger.ts
+const LABEL_WIDTH = 12;
+/**
+* Format a duration in milliseconds for display. Values below 1000 are shown
+* as whole milliseconds (e.g. "456ms"). Values at or above 1000 are shown as
+* seconds with one decimal place (e.g. "1.2s").
+*
+* @param ms - Duration in milliseconds.
+* @returns Formatted time string.
+*/
+function formatTime(ms) {
+	if (ms >= 1e3) return `${(ms / 1e3).toFixed(1)}s`;
+	return `${Math.round(ms)}ms`;
+}
+/**
+* Log a warning message to stderr with a yellow warning symbol.
+*
+* @param message - Warning text to display.
+*/
+function logWarning(message) {
+	process.stderr.write(`${color.yellow("⚠")} ${message}\n`);
+}
+/**
+* Log an error with formatted output to stderr. Accepts both string messages
+* and Error objects.
+*
+* @param error - The error to display.
+*/
+function logError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	process.stderr.write(`${color.red("✖")} ${message}\n`);
+}
+/**
+* Log a successful bundle result to stderr, including module count, output
+* path, and a timing breakdown.
+*
+* @param result - Bundle result information.
+*/
+function logResult(result) {
+	const { declarationOutputPath, moduleCount, outputPath, timing } = result;
+	const lines = [
+		["Extraction", timing.extractionMs],
+		["Resolution", timing.resolutionMs],
+		["Codegen", timing.codegenMs]
+	];
+	if (timing.declarationMs !== void 0) lines.push(["Declaration", timing.declarationMs]);
+	const timeValues = [...lines.map(([, ms]) => formatTime(ms)), formatTime(timing.totalMs)];
+	const maxTimeWidth = Math.max(...timeValues.map((value) => value.length));
+	process.stderr.write(`${color.green("✓")} Bundled ${String(moduleCount)} modules → ${outputPath}\n`);
+	if (declarationOutputPath !== void 0) process.stderr.write(`${color.green("✓")} Declaration → ${declarationOutputPath}\n`);
+	process.stderr.write("\n");
+	for (const [label, ms] of lines) {
+		const formattedTime = formatTime(ms).padStart(maxTimeWidth);
+		process.stderr.write(`  ${label.padEnd(LABEL_WIDTH)} ${formattedTime}\n`);
+	}
+	process.stderr.write(color.dim(`  ${"─".repeat(LABEL_WIDTH + 1 + maxTimeWidth)}\n`));
+	const totalFormatted = formatTime(timing.totalMs).padStart(maxTimeWidth);
+	process.stderr.write(`  ${"Total".padEnd(LABEL_WIDTH)} ${totalFormatted}\n`);
+}
+//#endregion
+//#region src/cli.ts
+/**
+* Entry point for the weld bundler CLI.
+*
+* @param args - CLI arguments to parse.
+*/
+async function main(args = process.argv.slice(2)) {
+	try {
+		const cliOptions = parseBundleArgs(args);
+		const result = bundle(mergeConfig(await loadConfig$1(cliOptions.config), cliOptions));
+		logResult(result);
+		for (const warning of result.warnings) logWarning(warning);
+		process.exitCode = 0;
+	} catch (err) {
+		logError(err);
+		process.exitCode = 1;
+	}
+}
+function mergeConfig(fileConfig, cli) {
+	const entry = cli.entry ?? fileConfig.entry;
+	const project = cli.project ?? fileConfig.project;
+	const output = cli.output ?? fileConfig.output;
+	const luauRoot = cli.luauRoot ?? fileConfig.luauRoot;
+	const requireMode = cli.requireMode ?? fileConfig.requireMode ?? "ts-import";
+	if (entry === void 0 || entry === "") throw new Error("--entry is required (via CLI or config file)");
+	if (requireMode === "ts-import" && (project === void 0 || project === "")) throw new Error("--project is required (via CLI or config file)");
+	if (output === void 0 || output === "") throw new Error("--output is required (via CLI or config file)");
+	const external = cli.external.length > 0 ? cli.external : fileConfig.external;
+	return {
+		declaration: cli.declaration ?? fileConfig.declaration ?? false,
+		entry,
+		external,
+		luauRoot,
+		output,
+		project: requireMode === "path" ? void 0 : project,
+		requireMode
+	};
+}
+function parseRequireMode(raw) {
+	if (raw === void 0) return;
+	if (raw !== "ts-import" && raw !== "path") throw new Error(`--require-mode must be 'ts-import' or 'path' (got: ${raw})`);
+	return raw;
+}
+/**
+* Parse CLI arguments into bundle options.
+*
+* @param args - Raw CLI argument strings.
+* @returns Parsed CLI options.
+*/
+function parseBundleArgs(args) {
+	const { values } = parseArgs({
+		args,
+		options: {
+			"config": {
+				short: "c",
+				type: "string"
+			},
+			"declaration": {
+				short: "d",
+				type: "boolean"
+			},
+			"entry": {
+				short: "e",
+				type: "string"
+			},
+			"external": {
+				multiple: true,
+				type: "string"
+			},
+			"luau-root": { type: "string" },
+			"output": {
+				short: "o",
+				type: "string"
+			},
+			"project": {
+				short: "p",
+				type: "string"
+			},
+			"require-mode": {
+				short: "r",
+				type: "string"
+			}
+		},
+		strict: true
+	});
+	return {
+		config: values.config,
+		declaration: values.declaration,
+		entry: values.entry,
+		external: values.external ?? [],
+		luauRoot: values["luau-root"],
+		output: values.output,
+		project: values.project,
+		requireMode: parseRequireMode(values["require-mode"])
+	};
+}
+//#endregion
+export { main };
+
+//# sourceMappingURL=cli.mjs.map