@tilua/compiler 8.0.0 → 9.0.0

package/dist/{chunk-TOP7NC3Z.js → chunk-VUIF62OE.js}

@@ -384,6 +384,10 @@ var SharedRuntime = class {
     return { declare, define };
   }
 };
+function moduleArguments(context, name) {
+  const loader2 = context.loader?.(name);
+  return loader2 ? [string(name), loader2] : [string(name)];
+}
 function lower(program2, scopes, options = {}) {
   const result2 = new Lowerer(program2, scopes, options).run();
   dropUnreachable(result2.statements);
@@ -700,6 +704,7 @@ var Lowerer = class {
       const plugin3 = lowerings[i].plugin;
       if (!plugin3.methodCall) continue;
       const answer = plugin3.methodCall({
+        options: lowerings[i].options ?? {},
         method,
         receiver,
         receiverGlobal,
@@ -731,6 +736,7 @@ var Lowerer = class {
       const plugin3 = lowerings[i].plugin;
       if (!plugin3.globalCall) continue;
       const answer = plugin3.globalCall({
+        options: lowerings[i].options ?? {},
         name,
         at: this.callSite(node.callee),
         get arguments() {
@@ -750,6 +756,7 @@ var Lowerer = class {
     if (name === void 0) return void 0;
     for (let i = lowerings.length - 1; i >= 0; i--) {
       const answer = lowerings[i].plugin.globalValue?.({
+        options: lowerings[i].options ?? {},
         name,
         at: this.callSite(node),
         use: (runtime2) => this.loweringRuntime(i, runtime2)
@@ -1003,12 +1010,12 @@ end`).body.statements, out);
         local2 = this.names.fresh(moduleName(key));
         moduleLocals.set(key, local2);
         locals.push(local2);
-        requires.push(assign([identifier(local2)], [call(context.require, [string(key)])]));
+        requires.push(assign([identifier(local2)], [call(context.require, moduleArguments(context, key))]));
       }
       return local2;
     };
     const load = (key) => {
-      if (!moduleLocals.has(key)) requires.push(callStatement(call(context.require, [string(key)])));
+      if (!moduleLocals.has(key)) requires.push(callStatement(call(context.require, moduleArguments(context, key))));
     };
     const exportBinding = (node, exported) => {
       const binding = node && this.bindingByDeclaration.get(node);
@@ -1117,20 +1124,22 @@ end`).body.statements, out);
         continue;
       }
       if (declaration.type === "ClassDeclaration") {
-        body.push(...this.classDeclaration(declaration, "assign"));
+        body.push(...this.classDeclaration(declaration, "assign").map((s) => this.from(s, declaration)));
         continue;
       }
       switch (declaration.type) {
+        // Stamped with where they were written, as any statement is:
+        // an error in a top-level `const` names its line.
         case "VariableDeclaration":
-          body.push(...this.variableDeclaration(declaration, "assign"));
+          body.push(...this.variableDeclaration(declaration, "assign").map((s) => this.from(s, declaration)));
           break;
         case "ExportDefaultStatement": {
           const exported = declaration.declaration;
           if (exported.type === "ClassDeclaration") {
-            body.push(...this.classDeclaration(exported, "assign"));
-            body.push(assign([member(exportsTable(), "default")], [this.reference(exported.name)]));
+            body.push(...this.classDeclaration(exported, "assign").map((s) => this.from(s, exported)));
+            body.push(this.from(assign([member(exportsTable(), "default")], [this.reference(exported.name)]), declaration));
           } else {
-            body.push(assign([member(exportsTable(), "default")], [this.expression(exported)]));
+            body.push(this.from(assign([member(exportsTable(), "default")], [this.expression(exported)]), declaration));
           }
           break;
         }
@@ -1168,7 +1177,7 @@ end`).body.statements, out);
       this.report(source, `Cannot find module '${source.value}'`);
       return nil();
     }
-    return call(context.import ?? context.require, [string(key)]);
+    return call(context.import ?? context.require, moduleArguments(context, key));
   }
   isRewritten(node) {
     const binding = this.bindingByDeclaration.get(node);
@@ -1367,9 +1376,9 @@ end`).body.statements, out);
         return this.assignment(node);
       case "CompoundAssignmentStatement": {
         if (node.operator === "??=") return this.nullishAssignment(node);
-        const join = node.operator === "+=" ? this.options.types?.joins.get(node) : void 0;
-        if (join === "dynamic") return this.dynamicAddition(node);
-        const operator = join === "concat" ? "..=" : node.operator;
+        const join2 = node.operator === "+=" ? this.options.types?.joins.get(node) : void 0;
+        if (join2 === "dynamic") return this.dynamicAddition(node);
+        const operator = join2 === "concat" ? "..=" : node.operator;
         if (!this.syntax.has("compoundAssignment")) return this.compoundAssignment51(node, operator);
         return [{
           type: "CompoundAssignmentStatement",
@@ -2055,9 +2064,9 @@ end
           return call(this.helper("instanceof"), [this.keptToOne(left), this.keptToOne(right)]);
         }
         if (node.operator === "+") {
-          const join = this.options.types?.joins.get(node);
-          if (join === "concat") return binary("..", left, right);
-          if (join === "dynamic") return call(this.helper("add"), [this.keptToOne(left), this.keptToOne(right)]);
+          const join2 = this.options.types?.joins.get(node);
+          if (join2 === "concat") return binary("..", left, right);
+          if (join2 === "dynamic") return call(this.helper("add"), [this.keptToOne(left), this.keptToOne(right)]);
         }
         if (!this.syntax.has("floorDivision") && node.operator === "//") return this.floorDivide(left, right);
         return binary(node.operator, left, right);
@@ -2774,7 +2783,7 @@ async function loadLowerings(modules) {
         });
         continue;
       }
-      lowerings.push({ plugin: plugin3, from: module.from, library: module.library });
+      lowerings.push({ plugin: plugin3, from: module.from, library: module.library, options: module.options });
     } catch (error) {
       problems.push({
         file: module.file,
@@ -2786,8 +2795,8 @@ async function loadLowerings(modules) {
 }
 
 // src/bundle.ts
-import { readFileSync as readFileSync3, statSync } from "fs";
-import { basename, dirname, extname, posix, relative, resolve as resolve2 } from "path";
+import { readdirSync, readFileSync as readFileSync3, statSync } from "fs";
+import { basename, dirname, extname, isAbsolute, join, posix, relative, resolve as resolve2 } from "path";
 import {
   parse,
   analyzeScopes,
@@ -2804,7 +2813,7 @@ import {
   LexError,
   luauString as luauString4
 } from "@tilua/parser";
-import { parse as parseLuau2, parseExpressionFromSource as parseExpressionFromSource2, print } from "luau-parser";
+import { parse as parseLuau2, parseExpressionFromSource as parseExpressionFromSource2, print as print2 } from "luau-parser";
 
 // src/treeshake.ts
 function walk(node, visit, parent) {
@@ -3072,23 +3081,29 @@ function ownExport(f, name) {
 // src/linemap.ts
 import { luauString as luauString3 } from "@tilua/parser";
 function statementsOf(node) {
-  const out = [];
-  const visit = (value) => {
+  return statementTree(node).statements;
+}
+function statementTree(node) {
+  const statements = [];
+  const parents = [];
+  const visit = (value, parent) => {
     if (!value || typeof value !== "object") return;
-    if (Array.isArray(value)) return void value.forEach(visit);
+    if (Array.isArray(value)) return void value.forEach((item) => visit(item, parent));
     const record = value;
+    let inside = parent;
     if (typeof record.type === "string" && record.type.endsWith("Statement")) {
-      out.push(value);
+      inside = statements.push(value) - 1;
+      parents.push(parent);
     }
     for (const [key, child] of Object.entries(record)) {
-      if (key !== "line" && key !== "column") visit(child);
+      if (key !== "line" && key !== "column") visit(child, inside);
     }
   };
-  visit(node);
-  return out;
+  visit(node, -1);
+  return { statements, parents };
 }
 function buildLineMap(emitted, printed, origins) {
-  const before = statementsOf(emitted);
+  const { statements: before, parents } = statementTree(emitted);
   const after = statementsOf(printed);
   if (before.length !== after.length) return /* @__PURE__ */ new Map();
   const map = /* @__PURE__ */ new Map();
@@ -3099,26 +3114,102 @@ function buildLineMap(emitted, printed, origins) {
     const line = after[i].line.start;
     if (!map.has(line)) map.set(line, origin);
   }
+  const holds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < before.length; i++) {
+    if (!origins.has(before[i])) continue;
+    for (let up = parents[i]; up >= 0 && !holds.has(up); up = parents[up]) holds.add(up);
+  }
+  for (let i = 0; i < before.length; i++) {
+    const origin = origins.get(before[i]);
+    if (!origin || holds.has(i)) continue;
+    for (let line = after[i].line.start + 1; line <= after[i].line.end; line++) {
+      if (!map.has(line)) map.set(line, origin);
+    }
+  }
   return map;
 }
-function lineMapSource(map) {
+var VLQ_DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function vlq(n) {
+  let value = n < 0 ? -n * 2 + 1 : n * 2;
+  let out = "";
+  do {
+    const digit = value % 32;
+    value = Math.floor(value / 32);
+    out += VLQ_DIGITS[value > 0 ? digit + 32 : digit];
+  } while (value > 0);
+  return out;
+}
+function lineMapSource(map, unpack) {
   const entries = [...map.entries()].sort((a, b) => a[0] - b[0]);
-  const quoted = (s) => luauString3(s.replace(/\\/g, "/"));
-  return `{${entries.map(([line, o]) => `[${line}]={${quoted(o.file)},${o.line}}`).join(",")}}`;
+  const files = [];
+  const indexes = /* @__PURE__ */ new Map();
+  let data = "";
+  let line = 0, file = 0, source = 0;
+  for (const [at, origin] of entries) {
+    const name = origin.file.replace(/\\/g, "/");
+    if (!indexes.has(name)) indexes.set(name, files.push(name));
+    const index2 = indexes.get(name);
+    data += vlq(at - line) + vlq(index2 - file) + vlq(origin.line - source);
+    line = at;
+    file = index2;
+    source = origin.line;
+  }
+  return `${unpack}({${files.map(luauString3).join(",")}},${luauString3(data)})`;
+}
+
+// src/output.ts
+import { print, PrintError } from "luau-parser";
+var WRITTEN = /* @__PURE__ */ new Set([
+  "compoundAssignment",
+  "continue",
+  "ifExpression",
+  "floorDivision",
+  "attributes",
+  "numberLiterals"
+]);
+function printOptions(syntax, format = {}) {
+  return {
+    syntax: [...syntax].some((s) => WRITTEN.has(s)) ? "luau" : "lua51",
+    compact: format.minify ?? false,
+    ...format.indent !== void 0 && { indent: format.indent }
+  };
+}
+function printOutput(node, options) {
+  try {
+    return { code: print(node, options) };
+  } catch (error) {
+    if (!(error instanceof PrintError)) throw error;
+    return {
+      problem: `The output cannot be written as Lua 5.1: ${error.message.replace(/ \(\d+:\d+\)$/, "")}. Nothing in 'types' says the project's Lua has it \u2014 "luau" does, and "roblox" brings "luau"`
+    };
+  }
 }
 
 // src/bundle.ts
+var WRITTEN_BY_TILUA = "-- Written by tilua";
 async function bundle(options) {
-  const entry = resolve2(options.entry);
   const diagnostics = [];
+  const from = options.entry !== void 0 ? resolve2(options.entry) : resolve2(options.root ?? process.cwd(), "tilua.config.json");
   const inline = options.config !== void 0 && typeof options.config !== "string";
-  const { config, problems } = resolveConfig(options.config, entry, options.root ?? (inline ? dirname(entry) : process.cwd()));
+  const { config, problems } = resolveConfig(options.config, from, options.root ?? (inline ? dirname(from) : process.cwd()));
   for (const p of problems) diagnostics.push({ file: p.file, message: p.message, line: p.line ?? 1, column: p.column ?? 1, category: "config" });
-  const root = resolve2(options.root ?? config?.directory ?? dirname(entry));
+  const root = resolve2(options.root ?? config?.directory ?? dirname(from));
   const nameOf = (file) => relative(root, file).replace(/\\/g, "/").replace(/\.tilua$/, "");
+  const mode = options.output ?? config?.output ?? "single";
+  const perFile = mode === "files";
+  const rootDir = resolve2(config?.rootDir ?? root);
+  const entry = options.entry !== void 0 ? resolve2(options.entry) : void 0;
+  const anchor = entry ?? config?.path ?? from;
+  const stop = (message, file = anchor) => ({
+    files: [],
+    modules: [],
+    diagnostics: [...diagnostics, { file, message, line: 1, column: 1, category: "config" }]
+  });
+  if (!perFile && entry === void 0) return stop('No entry to build: only "output": "files" builds without one');
   const sources = /* @__PURE__ */ new Map();
   const directives = /* @__PURE__ */ new Map();
-  const queue = [entry];
+  const queue = perFile ? tiluaFiles(rootDir) : [entry];
+  if (perFile && !queue.length) return stop(`No .tilua file under ${relative(process.cwd(), rootDir) || "."}`);
   while (queue.length) {
     const file = queue.shift();
     if (sources.has(file)) continue;
@@ -3136,6 +3227,22 @@ async function bundle(options) {
       if (target && !target.endsWith(".d.tilua")) queue.push(target);
     }
   }
+  if (perFile) {
+    const outside = [...sources.keys()].filter((file) => isOutside(rootDir, file));
+    if (outside.length) {
+      return {
+        files: [],
+        modules: [],
+        diagnostics: [...diagnostics, ...outside.map((file) => ({
+          file,
+          message: `This file is imported, but it is outside rootDir (${relative(root, rootDir) || "."}), where every file of "files" output has to be`,
+          line: 1,
+          column: 1,
+          category: "module"
+        }))]
+      };
+    }
+  }
   const analysis = analyzeModules([...sources.values()], config);
   const { lowerings, problems: loweringProblems } = await loadLowerings(analysis.lowerings);
   for (const p of loweringProblems) {
@@ -3146,18 +3253,56 @@ async function bundle(options) {
   const G = names.fresh("G");
   const requireExpression = member(identifier(G), "require");
   const importExpression = member(identifier(G), "import");
-  const mode = options.output ?? config?.output ?? "single";
   const byPath = syntaxOf(lowerings).has("requireByPath");
+  if (perFile && !byPath) {
+    return stop(`"output": "files" needs a Lua that requires a file by its path, which Lua 5.1 does not \u2014 add "luau" to 'types' ("roblox" loads it)`, config?.path ?? anchor);
+  }
+  const outputPath = (file) => relative(rootDir, file).replace(/\\/g, "/").replace(/\.tilua$/, ".luau");
+  const fileOfModule = new Map([...sources.values()].map((s) => [s.name, s.file]));
+  const outDir = resolve2(options.outDir ?? config?.outDir ?? rootDir);
+  const written = (file) => join(outDir, outputPath(file));
+  let host;
+  let runtimeFile = join(outDir, "_tilua.luau");
+  if (perFile) {
+    const outputs = [...sources.keys()].map(written);
+    const taken = new Set(outputs.map(pathKey));
+    for (let n = 2; taken.has(pathKey(runtimeFile)); n++) runtimeFile = join(outDir, `_tilua${n}.luau`);
+    for (let i = lowerings.length - 1; i >= 0 && !host; i--) {
+      const { plugin: plugin3, options: own } = lowerings[i];
+      host = plugin3.files?.({ options: own ?? {}, directory: config?.directory ?? root, outDir, files: outputs, runtime: runtimeFile });
+    }
+    for (const problem of host?.problems ?? []) {
+      diagnostics.push({
+        file: problem.file ?? config?.path ?? anchor,
+        message: problem.message,
+        line: 1,
+        column: 1,
+        category: "config",
+        ...problem.severity === "warning" && { severity: "warning" }
+      });
+    }
+    if (host?.runtime !== void 0) {
+      if (isOutside(outDir, resolve2(host.runtime))) return stop(`The runtime has to go inside outDir, not at ${host.runtime}`);
+      if (taken.has(pathKey(host.runtime))) return stop(`The runtime cannot go at ${host.runtime}: a module's file is there`);
+      runtimeFile = resolve2(host.runtime);
+    }
+  }
+  const placeOf = (file) => host?.place?.(file) ?? placeInFolder(relative(outDir, file));
+  const requireFrom = (from2, to) => pathBetween(placeOf(from2), placeOf(to), host?.root);
+  const isScript = (file) => host?.script?.(file) ?? false;
   const modules = /* @__PURE__ */ new Map();
   const origins = /* @__PURE__ */ new WeakMap();
   const shared = new SharedRuntime(names);
   const shaking = options.treeShaking ?? config?.treeShaking ?? false;
+  const format = { indent: options.indent ?? config?.indent, minify: options.minify ?? config?.minify ?? false };
+  const printing = printOptions(syntaxOf(lowerings), format);
+  const mapping = !format.minify && (options.lineMap ?? config?.lineMap ?? true);
   const resolveIn = (file) => (specifier) => {
     const found = resolveModulePath(file, specifier, config);
     return found !== void 0 && sources.has(found) ? found : void 0;
   };
-  const shaken = shaking ? treeShake([...sources.values()].map((s) => ({ file: s.file, program: s.program, scopes: s.scopes, resolve: resolveIn(s.file) })), entry) : void 0;
-  const pending = [entry];
+  const shaken = shaking && entry !== void 0 && !perFile ? treeShake([...sources.values()].map((s) => ({ file: s.file, program: s.program, scopes: s.scopes, resolve: resolveIn(s.file) })), entry) : void 0;
+  const pending = perFile ? [...sources.keys()] : [entry];
   while (pending.length) {
     const file = pending.shift();
     if (modules.has(file)) continue;
@@ -3190,9 +3335,16 @@ async function bundle(options) {
         import: importExpression,
         // One file has one line map. Several have one each, and a
         // module reads the one of the file it is in.
-        lines: mode === "single" ? `${G}.lines` : `${G}.maps[${luauString4(source.name)}]`,
-        fail: `${G}.fail`,
+        lines: !mapping ? void 0 : mode === "single" ? `${G}.lines` : `${G}.maps[${luauString4(source.name)}]`,
+        fail: mapping ? `${G}.fail` : void 0,
         arrays: `${G}.arrays`,
+        // The file a module is in, required from this one by its
+        // path, written out.
+        loader: !perFile ? void 0 : (name) => {
+          const target = fileOfModule.get(name);
+          if (target === void 0) return void 0;
+          return parseExpressionFromSource2(`function() return require(${luauString4(requireFrom(written(file), written(target)))}) end`);
+        },
         resolve: (specifier, dynamic) => {
           const found = resolveModulePath(file, specifier, config);
           if (!found || found.endsWith(".d.tilua") || !sources.has(found)) return void 0;
@@ -3244,6 +3396,102 @@ async function bundle(options) {
     return { files: [], modules: moduleNames, diagnostics };
   }
   if (shaking) shared.shake(lowered.flatMap((m) => m.statements));
+  const unwritable = (problem) => ({
+    files: [],
+    modules: moduleNames,
+    diagnostics: [...diagnostics, { file: anchor, message: problem, line: 1, column: 1, category: "config" }]
+  });
+  const write = (node) => {
+    const printed2 = printOutput(node, printing);
+    return "problem" in printed2 ? printed2 : printed2.code;
+  };
+  if (perFile) {
+    const imported = [];
+    for (const [file, source] of sources) {
+      for (const { specifier, line, column } of importSites(source.program)) {
+        const target = resolveIn(file)(specifier);
+        if (target === void 0 || !isScript(written(target))) continue;
+        imported.push({
+          file,
+          line,
+          column,
+          category: "module",
+          message: `'${specifier}' is a script the game runs, which nothing can import: move what it shares into a module of its own`
+        });
+      }
+    }
+    if (imported.length) return { files: [], modules: moduleNames, diagnostics: [...diagnostics, ...imported] };
+    const runtimePath = relative(outDir, runtimeFile).replace(/\\/g, "/");
+    const files2 = [];
+    for (const [file, module] of modules) {
+      const path = outputPath(file);
+      const at = written(file);
+      const script = isScript(at);
+      const prelude = host?.prelude?.(at);
+      const body = [
+        ...prelude !== void 0 ? parseLuau2(prelude).body.statements : [],
+        ...parseLuau2(`local ${G} = require(${luauString4(requireFrom(at, runtimeFile))})`).body.statements
+      ];
+      for (let i = 0; i < module.shared.length; i += 100) {
+        const some = module.shared.slice(i, i + 100);
+        body.push(local(some, some.map((name) => member(member(identifier(G), "shared"), name))));
+      }
+      if (module.usesScriptArgs) body.push(...parseLuau2(`local scriptArgs = ${G}.scriptArgs`).body.statements);
+      body.push(assign(
+        [index(member(identifier(G), "modules"), string(module.name))],
+        [moduleTable(module)]
+      ));
+      const value = `${G}.${mapping ? "run" : "require"}(${luauString4(module.name)})`;
+      const returned2 = module.info.exports && !script ? entryReturn(lowerings, module.name, value, () => analysis.exportsOf(file)) : { statements: [], value };
+      if ("problem" in returned2) return stop(returned2.problem.message, file);
+      const ending = parseLuau2(`${returned2.statements.join("\n")}
+return ${returned2.value}`).body.statements;
+      const chunk = program(body);
+      if (mapping) {
+        const text = write(chunk);
+        if (typeof text !== "string") return unwritable(text.problem);
+        const lines = buildLineMap(chunk, parseLuau2(text), origins);
+        const named = host?.place?.(at) ? `${placeOf(at).join("/")}.luau` : path;
+        body.push(...mapRegistration(G, { path: named, modules: [module] }, lineMapSource(lines, `${G}.lineMap`)));
+      }
+      body.push(...ending);
+      const code = write(chunk);
+      if (typeof code !== "string") return unwritable(code.problem);
+      const from2 = relative(dirname(at), file).replace(/\\/g, "/");
+      files2.push({ path, code: `${code}
+${WRITTEN_BY_TILUA} from ${from2}: edit that file, not this one.
+`, modules: [module.name] });
+    }
+    const runtimeProgram = parseLuau2(runtime(G, {
+      several: true,
+      perFile: true,
+      byPath,
+      files: /* @__PURE__ */ new Map(),
+      imports: lowered.some((m) => m.dynamicImports.size > 0),
+      mapping
+    }));
+    const helpers2 = shared.chunk(new Set(lowered.flatMap((m) => m.shared)));
+    const helperNames = helpers2.declare.flatMap((statement) => statement.type === "LocalStatement" ? statement.names.map((n) => n.name) : []);
+    runtimeProgram.body.statements.unshift(...helpers2.declare);
+    runtimeProgram.body.statements.push(...helpers2.define);
+    if (helperNames.length) {
+      runtimeProgram.body.statements.push(assign(
+        [member(identifier(G), "shared")],
+        [table(helperNames.map((name) => field(name, identifier(name))))]
+      ));
+    }
+    if (lowered.some((m) => m.usesScriptArgs)) {
+      runtimeProgram.body.statements.push(...parseLuau2(`${G}.scriptArgs = {}
+${G}.arrays[${G}.scriptArgs] = true`).body.statements);
+    }
+    runtimeProgram.body.statements.push(returns([identifier(G)]));
+    const runtimeCode = write(runtimeProgram);
+    if (typeof runtimeCode !== "string") return unwritable(runtimeCode.problem);
+    files2.push({ path: runtimePath, code: `${runtimeCode}
+${WRITTEN_BY_TILUA}: the runtime every file of the project requires.
+`, modules: [] });
+    return { code: files2[0].code, files: files2, modules: moduleNames, diagnostics };
+  }
   const several = mode !== "single";
   const layout = layoutOf(mode, modules.get(entry), lowered, options.outFile);
   const usesScriptArgs = lowered.some((m) => m.usesScriptArgs);
@@ -3255,7 +3503,8 @@ async function bundle(options) {
     several,
     byPath,
     files: elsewhere,
-    imports: lowered.some((m) => m.dynamicImports.size > 0)
+    imports: lowered.some((m) => m.dynamicImports.size > 0),
+    mapping
   }));
   const assignment = program2.body.statements[1];
   if (usesScriptArgs) {
@@ -3272,27 +3521,38 @@ async function bundle(options) {
   program2.body.statements.unshift(...helpers.declare);
   const ok = names.fresh("ok");
   const result2 = names.fresh("result");
-  const entryStatements = parseLuau2(`
+  const entryName = luauString4(sources.get(entry).name);
+  const returnsExports = modules.get(entry).info.exports;
+  const returned = returnsExports ? entryReturn(lowerings, sources.get(entry).name, mapping ? result2 : `${G}.require(${entryName})`, () => analysis.exportsOf(entry)) : void 0;
+  if (returned && "problem" in returned) return stop(returned.problem.message);
+  const declarations = returned?.statements.join("\n") ?? "";
+  const entryStatements = parseLuau2(!mapping ? `${declarations}
+${returned ? `return ${returned.value}` : `${G}.require(${entryName})`}` : `
 local ${ok}, ${result2} = xpcall(function()
-    return ${G}.require(${luauString4(sources.get(entry).name)})
+    return ${G}.require(${entryName})
 end, ${G}.fail)
 if not ${ok} then
     error(${result2}, 0)
 end
-${modules.get(entry).info.exports ? `return ${result2}` : ""}
+${declarations}
+${returned ? `return ${returned.value}` : ""}
 `).body.statements;
   program2.body.statements.push(...entryStatements);
-  const map = buildLineMap(program2, parseLuau2(print(program2)), origins);
-  if (map.size || several) {
+  let printed = write(program2);
+  if (typeof printed !== "string") return unwritable(printed.problem);
+  const map = mapping ? buildLineMap(program2, parseLuau2(printed), origins) : /* @__PURE__ */ new Map();
+  if (mapping && (map.size || several)) {
     const mapStatements = [assign(
       [member(identifier(G), "lines")],
-      [parseExpressionFromSource2(lineMapSource(map))]
+      [parseExpressionFromSource2(lineMapSource(map, `${G}.lineMap`))]
     )];
     if (several) mapStatements.push(...mapRegistration(G, layout[0], `${G}.lines`));
     program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, ...mapStatements);
   }
   program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, ...helpers.define);
-  const files = [{ path: layout[0].path, code: print(program2) + "\n", modules: layout[0].modules.map((m) => m.name) }];
+  printed = write(program2);
+  if (typeof printed !== "string") return unwritable(printed.problem);
+  const files = [{ path: layout[0].path, code: printed + "\n", modules: layout[0].modules.map((m) => m.name) }];
   for (const file of layout.slice(1)) {
     const fileHelpers = shared.chunk(new Set(file.modules.flatMap((m) => m.shared)));
     const body = [...fileHelpers.declare];
@@ -3304,12 +3564,35 @@ ${modules.get(entry).info.exports ? `return ${result2}` : ""}
       ));
     }
     const chunk = program([returns([functionExpression(functionBody([G], body))])]);
-    const lines = buildLineMap(chunk, parseLuau2(print(chunk)), origins);
-    body.push(...mapRegistration(G, file, lineMapSource(lines)), ...fileHelpers.define);
-    files.push({ path: file.path, code: print(chunk) + "\n", modules: file.modules.map((m) => m.name) });
+    if (mapping) {
+      const lines = buildLineMap(chunk, parseLuau2(print2(chunk, printing)), origins);
+      body.push(...mapRegistration(G, file, lineMapSource(lines, `${G}.lineMap`)));
+    }
+    body.push(...fileHelpers.define);
+    const code = write(chunk);
+    if (typeof code !== "string") return unwritable(code.problem);
+    files.push({ path: file.path, code: code + "\n", modules: file.modules.map((m) => m.name) });
   }
   return { code: files[0].code, files, modules: moduleNames, diagnostics };
 }
+function entryReturn(lowerings, module, value, exports) {
+  const syntax = [...syntaxOf(lowerings)];
+  for (let i = lowerings.length - 1; i >= 0; i--) {
+    const { plugin: plugin3, from, options } = lowerings[i];
+    if (!plugin3.entryExports) continue;
+    const answer = plugin3.entryExports({ options: options ?? {}, module, value, exports: exports(), syntax });
+    if (!answer) continue;
+    const statements = [...answer.statements ?? []];
+    try {
+      parseLuau2(`${statements.join("\n")}
+return ${answer.value}`);
+    } catch (error) {
+      return { problem: { message: `'${from}' answered entryExports with Luau that does not parse: ${error.message}` } };
+    }
+    return { statements, value: answer.value };
+  }
+  return { statements: [], value };
+}
 function moduleTable(module) {
   const { names: exported, links, stars } = module.info;
   const fields = [];
@@ -3329,10 +3612,6 @@ function layoutOf(mode, entry, modules, outFile) {
   const entryStem = outFile !== void 0 ? basename(outFile, extname(outFile)) : posix.basename(entry.name);
   const others = modules.filter((m) => m !== entry);
   if (mode === "single") return [{ path: `${entryStem}${extension}`, modules: [entry, ...others] }];
-  if (mode === "modules") {
-    const pathOf = (m) => `${m.name.split("/").map((part) => part === ".." ? "__" : part).join("/")}${extension}`;
-    return [entry, ...others].map((m) => ({ path: pathOf(m), modules: [m] }));
-  }
   const byName = new Map(modules.map((m) => [m.name, m]));
   const reach = (root) => {
     const seen = /* @__PURE__ */ new Set();
@@ -3368,11 +3647,70 @@ function layoutOf(mode, entry, modules, outFile) {
   return files;
 }
 function loadPath(entryPath, file, byPath) {
-  const path = posix.relative(posix.dirname(entryPath), file);
-  if (!byPath) return path;
+  return byPath ? requirePath(entryPath, file) : posix.relative(posix.dirname(entryPath), file);
+}
+function placeInFolder(path) {
+  const parts = path.replace(/\\/g, "/").replace(/\.luau?$/, "").split("/").filter((part) => part !== "");
+  if (parts.at(-1) === "init") parts.pop();
+  return parts;
+}
+function pathBetween(from, to, root) {
+  if (root !== void 0 && from[0] !== to[0]) return `${root}/${to.join("/")}`;
+  if (to.length > from.length && from.every((part, i) => to[i] === part)) return `@self/${to.slice(from.length).join("/")}`;
+  const base = from.slice(0, -1);
+  let shared = 0;
+  while (shared < base.length && shared < to.length - 1 && base[shared] === to[shared]) shared++;
+  const up = base.length - shared;
+  return `${up === 0 ? "./" : "../".repeat(up)}${to.slice(shared).join("/")}`;
+}
+function importSites(program2) {
+  const sites = [];
+  for (const statement of program2.body.statements) {
+    if (statement.type === "ImportStatement" || statement.type === "ExportAllStatement" || statement.type === "ExportNamedStatement" && statement.source) {
+      const source = statement.source;
+      sites.push({ specifier: source.value, line: source.line.start, column: source.column.start });
+    }
+  }
+  for (const node of importExpressions(program2)) {
+    if (node.source.type === "StringLiteral") sites.push({ specifier: node.source.value, line: node.source.line.start, column: node.source.column.start });
+  }
+  return sites;
+}
+function pathKey(path) {
+  const full = resolve2(path);
+  return process.platform === "win32" ? full.toLowerCase() : full;
+}
+function requirePath(from, to) {
+  const path = posix.relative(posix.dirname(from), to);
   const bare = path.slice(0, path.length - posix.extname(path).length);
   return bare.startsWith("../") ? bare : `./${bare}`;
 }
+function tiluaFiles(folder) {
+  const found = [];
+  const walk2 = (at) => {
+    let entries;
+    try {
+      entries = readdirSync(at, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of entries) {
+      if (item.name.startsWith(".")) continue;
+      const path = join(at, item.name);
+      if (item.isDirectory()) {
+        if (item.name !== "node_modules") walk2(path);
+      } else if (item.name.endsWith(".tilua") && !item.name.endsWith(".d.tilua")) {
+        found.push(path);
+      }
+    }
+  };
+  walk2(folder);
+  return found.sort();
+}
+function isOutside(folder, file) {
+  const path = relative(folder, file);
+  return path === "" || path.startsWith("..") || isAbsolute(path);
+}
 function mapRegistration(G, file, map) {
   const extension = posix.extname(file.path);
   const parts = file.path.slice(0, file.path.length - extension.length).split(/[/.]/).filter((part) => part !== "");
@@ -3403,7 +3741,8 @@ function loader(G, byPath) {
         require(file)(${G})`;
 }
 function runtime(G, options) {
-  const { several } = options;
+  const { several, mapping } = options;
+  const perFile = options.perFile ?? false;
   const files = [...options.files].map(([name, file]) => `[${luauString4(name)}] = ${luauString4(file)}`).join(", ");
   return `
 local ${G}
@@ -3411,7 +3750,7 @@ ${G} = {
     modules = {},
     -- Every array the program made, so \`typeof\` can tell one from an object.
     -- The keys are held weakly: being written down keeps no array alive.
-    arrays = setmetatable({}, { __mode = "k" }),
+    arrays = setmetatable({}, { __mode = "k" }),${mapping ? `
     -- Filled in just before the entry runs: bundle line -> { file, line }.
     lines = nil,
     -- What an error nothing caught says, in the project's files: the bundle's
@@ -3579,32 +3918,96 @@ ${several ? `
         end
         return mapped .. "\\n" .. table.concat(frames, "\\n")
     end,
-    records = {},${several ? `
+    -- A line map as it is written: the files it names, and base-64 VLQ
+    -- numbers, three to a line \u2014 how far down the bundle, which file, how far
+    -- down that file, each counted from the line before. It is read out the
+    -- first time a line is looked up, which is when something went wrong.
+    lineMap = function(files, data)
+        local map = {}
+        return setmetatable(map, { __index = function(_, key)
+            setmetatable(map, nil)
+            local digits = {}
+            for i = 1, 64 do
+                digits[("${VLQ_DIGITS}"):byte(i)] = i - 1
+            end
+            local at = 1
+            local function read()
+                local value, scale = 0, 1
+                repeat
+                    local digit = digits[data:byte(at)]
+                    at = at + 1
+                    value = value + digit % 32 * scale
+                    scale = scale * 32
+                until digit < 32
+                if value % 2 == 1 then
+                    return -math.floor(value / 2)
+                end
+                return math.floor(value / 2)
+            end
+            local line, file, source = 0, 0, 0
+            while at <= #data do
+                line = line + read()
+                file = file + read()
+                source = source + read()
+                map[line] = { files[file], source }
+            end
+            return map[key]
+        end })
+    end,` : ""}
+    records = {},${several && !perFile ? `
     -- The file each module outside this one is in, as \`load\` is handed it.
     files = { ${files} },
-    loaded = {},
+    loaded = {},` : ""}${several && mapping ? `
     -- Every file's line map: by the module, and by the file's name.
     maps = {},
-    sources = {},
+    sources = {},` : ""}${several && !perFile ? `
     -- Another of the bundle's files: a function that adds its modules here.
     load = function(file)
         if ${G}.loaded[file] then
             return
         end
         ${G}.loaded[file] = true${loader(G, options.byPath)}
+    end,` : ""}${perFile && mapping ? `
+    -- What a file returns: its module's exports. The first file asked for
+    -- runs under \`xpcall\`, so an error nothing caught is reported in the
+    -- project's files; the files it requires in turn are inside that already.
+    running = false,
+    run = function(name)
+        if ${G}.running then
+            return ${G}.require(name)
+        end
+        ${G}.running = true
+        local ok, result = xpcall(${G}.require, ${G}.fail, name)
+        ${G}.running = false
+        if not ok then
+            error(result, 0)
+        end
+        return result
     end,` : ""}${options.imports ? `
     -- \`import("./x")\`: the module's exports, asked for where the code runs
     -- rather than before its module does. \`require\` does the rest \u2014 and
     -- loads the file the module is in, if it is not this one.
-    import = function(name)
-        return ${G}.require(name)
+    import = function(name${perFile ? ", load" : ""})
+        return ${G}.require(name${perFile ? ", load" : ""})
     end,` : ""}
-    require = function(name)
+    require = function(name${perFile ? ", load" : ""})
         local record = ${G}.records[name]
         if record ~= nil then
             return record.exports
         end
-        local module = ${G}.modules[name]${several ? `
+        local module = ${G}.modules[name]${perFile ? `
+        -- Its file has not run: requiring it adds the module, and runs it.
+        if module == nil and load ~= nil then
+            load()
+            record = ${G}.records[name]
+            if record ~= nil then
+                return record.exports
+            end
+            module = ${G}.modules[name]
+        end
+        if module == nil then
+            error(("Cannot find module '%s': nothing has loaded the file it is in"):format(name), 2)
+        end` : several ? `
         if module == nil then
             ${G}.load(${G}.files[name])
             module = ${G}.modules[name]
@@ -3710,7 +4113,7 @@ var moduleAnalyses = /* @__PURE__ */ new Map();
 function analyzeModules(modules, config) {
   const out = [];
   const analyses = /* @__PURE__ */ new Map();
-  const libraries = config ? resolveTypeLibraries(config) : { files: [], lowerings: [], problems: [] };
+  const libraries = config ? resolveTypeLibraries(config) : { files: [], lowerings: [], options: [], problems: [] };
   for (const p of libraries.problems) out.push({ file: p.file, message: p.message, line: p.line ?? 1, column: p.column ?? 1, category: "config" });
   const libs = libraries.files.map(parsedLibrary);
   const noLib = config?.noLib ?? false;
@@ -3749,7 +4152,7 @@ function analyzeModules(modules, config) {
       const at = d.node;
       said.push({ file, message: d.message, line: at.line.start, column: at.column.start, category: "type", severity: d.severity });
     }
-    const result2 = { types, diagnostics: said };
+    const result2 = { types, diagnostics: said, scopes };
     if (partials === before) {
       analyzed.set(file, result2);
       const read3 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
@@ -3806,7 +4209,16 @@ function analyzeModules(modules, config) {
     analyses.set(module.file, types);
     out.push(...diagnostics);
   }
-  return { types: analyses, diagnostics: out, lowerings: [...libraries.lowerings] };
+  const exportsOf = (file) => {
+    const cached = exportsCache.get(file);
+    if (cached) return cached;
+    const module = byFile.get(file);
+    const { types, scopes } = analyzeModule(file, module.program);
+    const exports = moduleExports(module.program, scopes, types, resolverFor(file));
+    exportsCache.set(file, exports);
+    return exports;
+  };
+  return { types: analyses, diagnostics: out, lowerings: [...libraries.lowerings], exportsOf };
 }
 function allStatements(statements) {
   const out = [];
@@ -3828,7 +4240,11 @@ function allStatements(statements) {
 export {
   resolveConfig,
   program,
+  syntaxOf,
   lower,
+  printOptions,
+  printOutput,
   loadLowerings,
+  WRITTEN_BY_TILUA,
   bundle
 };