@tilua/compiler 8.0.0 → 9.0.0

package/dist/cli.cjs

@@ -13,7 +13,7 @@ var import_node_path3 = require("path");
 var import_node_fs3 = require("fs");
 var import_node_path2 = require("path");
 var import_parser7 = require("@tilua/parser");
-var import_luau_parser2 = require("luau-parser");
+var import_luau_parser3 = require("luau-parser");
 
 // src/config.ts
 var import_node_path = require("path");
@@ -50,10 +50,10 @@ var parenthesized = (expression) => ({ type: "ParenthesizedExpression", expressi
 var table = (fields) => ({ type: "TableExpression", fields, ...span() });
 var field = (key, value) => (0, import_parser2.isLuauName)(key) ? { type: "TableFieldNamed", name: identifier(key), value } : { type: "TableFieldComputed", key: string(key), value };
 var block = (statements) => ({ type: "Block", statements, ...span() });
-var local = (names, init) => ({
+var local = (names, init2) => ({
   type: "LocalStatement",
   names: names.map((name) => ({ type: "TypedIdentifier", name, ...span() })),
-  init,
+  init: init2,
   ...span()
 });
 var assign = (targets, values) => ({ type: "AssignmentStatement", targets, values, ...span() });
@@ -401,6 +401,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);
@@ -442,9 +446,9 @@ var Lowerer = class {
       if (Array.isArray(value)) return void value.forEach(visit);
       const node = value;
       if (node.type === "VariableDeclaration" && node.name?.type === "IdentifierPattern" && node.name.name) {
-        let init = node.init;
-        while (init?.type === "ParenthesizedExpression") init = init.expression;
-        if (init?.type === "ClassExpression") this.classExpressionNames.set(init, node.name.name);
+        let init2 = node.init;
+        while (init2?.type === "ParenthesizedExpression") init2 = init2.expression;
+        if (init2?.type === "ClassExpression") this.classExpressionNames.set(init2, node.name.name);
       }
       for (const [key, child] of Object.entries(value)) if (key !== "line" && key !== "column") visit(child);
     };
@@ -717,6 +721,7 @@ var Lowerer = class {
       const plugin3 = lowerings[i].plugin;
       if (!plugin3.methodCall) continue;
       const answer = plugin3.methodCall({
+        options: lowerings[i].options ?? {},
         method,
         receiver,
         receiverGlobal,
@@ -748,6 +753,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() {
@@ -767,6 +773,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)
@@ -1020,12 +1027,12 @@ end`).body.statements, out2);
         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);
@@ -1134,20 +1141,22 @@ end`).body.statements, out2);
         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;
         }
@@ -1185,7 +1194,7 @@ end`).body.statements, out2);
       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);
@@ -1384,9 +1393,9 @@ end`).body.statements, out2);
         return this.assignment(node);
       case "CompoundAssignmentStatement": {
         if (node.operator === "??=") return this.nullishAssignment(node);
-        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;
+        const join3 = node.operator === "+=" ? this.options.types?.joins.get(node) : void 0;
+        if (join3 === "dynamic") return this.dynamicAddition(node);
+        const operator = join3 === "concat" ? "..=" : node.operator;
         if (!this.syntax.has("compoundAssignment")) return this.compoundAssignment51(node, operator);
         return [{
           type: "CompoundAssignmentStatement",
@@ -1650,11 +1659,11 @@ end`).body.statements, out2);
    *  carries neither. */
   classRuntimeStatements() {
     if (!this.classHelpers) return [];
-    const { build, accessors } = this.classHelpers;
+    const { build: build2, accessors } = this.classHelpers;
     const metamethods = `{ ${CLASS_METAMETHODS.map((name) => `"${name}"`).join(", ")} }`;
     const out2 = [];
-    this.define([build, accessors], (0, import_luau_parser.parse)(`
-local function ${build}(base, name)
+    this.define([build2, accessors], (0, import_luau_parser.parse)(`
+local function ${build2}(base, name)
     local class = { __getters = {}, __setters = {} }
     class.__index = class
     class.ClassObject = class
@@ -1713,9 +1722,9 @@ end
   /** `declare` names the local the class table goes in; without it the
    *  table is assigned to `self`, which a module has already declared. */
   classStatements(node, self, declare) {
-    const { build, accessors } = this.classRuntime();
+    const { build: build2, accessors } = this.classRuntime();
     const called = node.name?.name ?? (node.type === "ClassExpression" ? this.classExpressionNames.get(node) : void 0) ?? "";
-    const create = call(identifier(build), [
+    const create = call(identifier(build2), [
       node.superclass ? this.reference(node.superclass) : nil(),
       string(called)
     ]);
@@ -2072,9 +2081,9 @@ end
           return call(this.helper("instanceof"), [this.keptToOne(left), this.keptToOne(right)]);
         }
         if (node.operator === "+") {
-          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)]);
+          const join3 = this.options.types?.joins.get(node);
+          if (join3 === "concat") return binary("..", left, right);
+          if (join3 === "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);
@@ -3041,23 +3050,29 @@ function ownExport(f, name) {
 // src/linemap.ts
 var import_parser6 = require("@tilua/parser");
 function statementsOf(node) {
-  const out2 = [];
-  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")) {
-      out2.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 out2;
+  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();
@@ -3068,12 +3083,75 @@ 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 out2 = "";
+  do {
+    const digit = value % 32;
+    value = Math.floor(value / 32);
+    out2 += VLQ_DIGITS[value > 0 ? digit + 32 : digit];
+  } while (value > 0);
+  return out2;
+}
+function lineMapSource(map, unpack) {
   const entries = [...map.entries()].sort((a, b) => a[0] - b[0]);
-  const quoted = (s) => (0, import_parser6.luauString)(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(import_parser6.luauString).join(",")}},${(0, import_parser6.luauString)(data)})`;
+}
+
+// src/output.ts
+var import_luau_parser2 = require("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: (0, import_luau_parser2.print)(node, options) };
+  } catch (error) {
+    if (!(error instanceof import_luau_parser2.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/lowering.ts
@@ -3092,7 +3170,7 @@ async function loadLowerings(modules) {
         });
         continue;
       }
-      lowerings.push({ plugin: plugin3, from: module2.from, library: module2.library });
+      lowerings.push({ plugin: plugin3, from: module2.from, library: module2.library, options: module2.options });
     } catch (error) {
       problems.push({
         file: module2.file,
@@ -3104,17 +3182,30 @@ async function loadLowerings(modules) {
 }
 
 // src/bundle.ts
+var WRITTEN_BY_TILUA = "-- Written by tilua";
 async function bundle(options) {
-  const entry2 = (0, import_node_path2.resolve)(options.entry);
   const diagnostics = [];
+  const from = options.entry !== void 0 ? (0, import_node_path2.resolve)(options.entry) : (0, import_node_path2.resolve)(options.root ?? process.cwd(), "tilua.config.json");
   const inline = options.config !== void 0 && typeof options.config !== "string";
-  const { config: config2, problems } = resolveConfig(options.config, entry2, options.root ?? (inline ? (0, import_node_path2.dirname)(entry2) : process.cwd()));
+  const { config: config2, problems } = resolveConfig(options.config, from, options.root ?? (inline ? (0, import_node_path2.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 = (0, import_node_path2.resolve)(options.root ?? config2?.directory ?? (0, import_node_path2.dirname)(entry2));
+  const root = (0, import_node_path2.resolve)(options.root ?? config2?.directory ?? (0, import_node_path2.dirname)(from));
   const nameOf = (file) => (0, import_node_path2.relative)(root, file).replace(/\\/g, "/").replace(/\.tilua$/, "");
+  const mode = options.output ?? config2?.output ?? "single";
+  const perFile = mode === "files";
+  const rootDir = (0, import_node_path2.resolve)(config2?.rootDir ?? root);
+  const entry2 = options.entry !== void 0 ? (0, import_node_path2.resolve)(options.entry) : void 0;
+  const anchor = entry2 ?? config2?.path ?? from;
+  const stop = (message, file = anchor) => ({
+    files: [],
+    modules: [],
+    diagnostics: [...diagnostics, { file, message, line: 1, column: 1, category: "config" }]
+  });
+  if (!perFile && entry2 === 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 = [entry2];
+  const queue = perFile ? tiluaFiles(rootDir) : [entry2];
+  if (perFile && !queue.length) return stop(`No .tilua file under ${(0, import_node_path2.relative)(process.cwd(), rootDir) || "."}`);
   while (queue.length) {
     const file = queue.shift();
     if (sources.has(file)) continue;
@@ -3132,6 +3223,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 (${(0, import_node_path2.relative)(root, rootDir) || "."}), where every file of "files" output has to be`,
+          line: 1,
+          column: 1,
+          category: "module"
+        }))]
+      };
+    }
+  }
   const analysis = analyzeModules([...sources.values()], config2);
   const { lowerings, problems: loweringProblems } = await loadLowerings(analysis.lowerings);
   for (const p of loweringProblems) {
@@ -3142,23 +3249,61 @@ 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 ?? config2?.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)`, config2?.path ?? anchor);
+  }
+  const outputPath = (file) => (0, import_node_path2.relative)(rootDir, file).replace(/\\/g, "/").replace(/\.tilua$/, ".luau");
+  const fileOfModule = new Map([...sources.values()].map((s) => [s.name, s.file]));
+  const outDir = (0, import_node_path2.resolve)(options.outDir ?? config2?.outDir ?? rootDir);
+  const written = (file) => (0, import_node_path2.join)(outDir, outputPath(file));
+  let host;
+  let runtimeFile = (0, import_node_path2.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 = (0, import_node_path2.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: config2?.directory ?? root, outDir, files: outputs, runtime: runtimeFile });
+    }
+    for (const problem of host?.problems ?? []) {
+      diagnostics.push({
+        file: problem.file ?? config2?.path ?? anchor,
+        message: problem.message,
+        line: 1,
+        column: 1,
+        category: "config",
+        ...problem.severity === "warning" && { severity: "warning" }
+      });
+    }
+    if (host?.runtime !== void 0) {
+      if (isOutside(outDir, (0, import_node_path2.resolve)(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 = (0, import_node_path2.resolve)(host.runtime);
+    }
+  }
+  const placeOf = (file) => host?.place?.(file) ?? placeInFolder((0, import_node_path2.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 ?? config2?.treeShaking ?? false;
+  const format = { indent: options.indent ?? config2?.indent, minify: options.minify ?? config2?.minify ?? false };
+  const printing = printOptions(syntaxOf(lowerings), format);
+  const mapping = !format.minify && (options.lineMap ?? config2?.lineMap ?? true);
   const resolveIn = (file) => (specifier) => {
     const found = (0, import_parser7.resolveModulePath)(file, specifier, config2);
     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) })), entry2) : void 0;
-  const pending = [entry2];
+  const shaken = shaking && entry2 !== void 0 && !perFile ? treeShake([...sources.values()].map((s) => ({ file: s.file, program: s.program, scopes: s.scopes, resolve: resolveIn(s.file) })), entry2) : void 0;
+  const pending = perFile ? [...sources.keys()] : [entry2];
   while (pending.length) {
     const file = pending.shift();
     if (modules.has(file)) continue;
     const source = sources.get(file);
-    const shown = (0, import_node_path2.relative)(root, file).replace(/\\/g, "/");
+    const shown2 = (0, import_node_path2.relative)(root, file).replace(/\\/g, "/");
     const imports = /* @__PURE__ */ new Set();
     const dynamicImports = /* @__PURE__ */ new Set();
     const lowered2 = lower(source.program, source.scopes, {
@@ -3167,7 +3312,7 @@ async function bundle(options) {
       lowerings,
       noLib: config2?.noLib,
       source: source.text,
-      file: shown,
+      file: shown2,
       shared,
       shaken: shaken && {
         ...shaken.modules.get(file),
@@ -3186,9 +3331,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[${(0, import_parser7.luauString)(source.name)}]`,
-        fail: `${G}.fail`,
+        lines: !mapping ? void 0 : mode === "single" ? `${G}.lines` : `${G}.maps[${(0, import_parser7.luauString)(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 (0, import_luau_parser3.parseExpressionFromSource)(`function() return require(${(0, import_parser7.luauString)(requireFrom(written(file), written(target)))}) end`);
+        },
         resolve: (specifier, dynamic) => {
           const found = (0, import_parser7.resolveModulePath)(file, specifier, config2);
           if (!found || found.endsWith(".d.tilua") || !sources.has(found)) return void 0;
@@ -3202,7 +3354,7 @@ async function bundle(options) {
     for (const d of lowered2.diagnostics) diagnostics.push({ file, ...d, category: "module" });
     for (const statement of allStatements(lowered2.statements)) {
       const line = lowered2.origins.get(statement);
-      if (line !== void 0) origins.set(statement, { file: shown, line });
+      if (line !== void 0) origins.set(statement, { file: shown2, line });
     }
     modules.set(file, {
       name: source.name,
@@ -3240,6 +3392,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 = (0, import_node_path2.relative)(outDir, runtimeFile).replace(/\\/g, "/");
+    const files2 = [];
+    for (const [file, module2] of modules) {
+      const path = outputPath(file);
+      const at = written(file);
+      const script = isScript(at);
+      const prelude = host?.prelude?.(at);
+      const body = [
+        ...prelude !== void 0 ? (0, import_luau_parser3.parse)(prelude).body.statements : [],
+        ...(0, import_luau_parser3.parse)(`local ${G} = require(${(0, import_parser7.luauString)(requireFrom(at, runtimeFile))})`).body.statements
+      ];
+      for (let i = 0; i < module2.shared.length; i += 100) {
+        const some = module2.shared.slice(i, i + 100);
+        body.push(local(some, some.map((name) => member(member(identifier(G), "shared"), name))));
+      }
+      if (module2.usesScriptArgs) body.push(...(0, import_luau_parser3.parse)(`local scriptArgs = ${G}.scriptArgs`).body.statements);
+      body.push(assign(
+        [index(member(identifier(G), "modules"), string(module2.name))],
+        [moduleTable(module2)]
+      ));
+      const value = `${G}.${mapping ? "run" : "require"}(${(0, import_parser7.luauString)(module2.name)})`;
+      const returned2 = module2.info.exports && !script ? entryReturn(lowerings, module2.name, value, () => analysis.exportsOf(file)) : { statements: [], value };
+      if ("problem" in returned2) return stop(returned2.problem.message, file);
+      const ending = (0, import_luau_parser3.parse)(`${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, (0, import_luau_parser3.parse)(text), origins);
+        const named = host?.place?.(at) ? `${placeOf(at).join("/")}.luau` : path;
+        body.push(...mapRegistration(G, { path: named, modules: [module2] }, lineMapSource(lines, `${G}.lineMap`)));
+      }
+      body.push(...ending);
+      const code = write(chunk);
+      if (typeof code !== "string") return unwritable(code.problem);
+      const from2 = (0, import_node_path2.relative)((0, import_node_path2.dirname)(at), file).replace(/\\/g, "/");
+      files2.push({ path, code: `${code}
+${WRITTEN_BY_TILUA} from ${from2}: edit that file, not this one.
+`, modules: [module2.name] });
+    }
+    const runtimeProgram = (0, import_luau_parser3.parse)(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(...(0, import_luau_parser3.parse)(`${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(entry2), lowered, options.outFile);
   const usesScriptArgs = lowered.some((m) => m.usesScriptArgs);
@@ -3247,17 +3495,18 @@ async function bundle(options) {
   for (const file of layout.slice(1)) {
     for (const module2 of file.modules) elsewhere.set(module2.name, loadPath(layout[0].path, file.path, byPath));
   }
-  const program2 = (0, import_luau_parser2.parse)(runtime(G, {
+  const program2 = (0, import_luau_parser3.parse)(runtime(G, {
     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) {
     program2.body.statements.unshift(local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: { type: "VarargExpression" } }])]));
-    program2.body.statements.push(...(0, import_luau_parser2.parse)(`${G}.arrays[scriptArgs] = true`).body.statements);
-    if (several) program2.body.statements.push(...(0, import_luau_parser2.parse)(`${G}.scriptArgs = scriptArgs`).body.statements);
+    program2.body.statements.push(...(0, import_luau_parser3.parse)(`${G}.arrays[scriptArgs] = true`).body.statements);
+    if (several) program2.body.statements.push(...(0, import_luau_parser3.parse)(`${G}.scriptArgs = scriptArgs`).body.statements);
   }
   const modulesTable = assignment.type === "AssignmentStatement" && assignment.values[0].type === "TableExpression" ? assignment.values[0].fields.find((f) => f.type === "TableFieldNamed" && f.name.name === "modules")?.value : void 0;
   if (!modulesTable) throw new Error("@tilua/compiler: the bundle runtime has no modules table");
@@ -3268,31 +3517,42 @@ async function bundle(options) {
   program2.body.statements.unshift(...helpers.declare);
   const ok = names.fresh("ok");
   const result2 = names.fresh("result");
-  const entryStatements = (0, import_luau_parser2.parse)(`
+  const entryName = (0, import_parser7.luauString)(sources.get(entry2).name);
+  const returnsExports = modules.get(entry2).info.exports;
+  const returned = returnsExports ? entryReturn(lowerings, sources.get(entry2).name, mapping ? result2 : `${G}.require(${entryName})`, () => analysis.exportsOf(entry2)) : void 0;
+  if (returned && "problem" in returned) return stop(returned.problem.message);
+  const declarations = returned?.statements.join("\n") ?? "";
+  const entryStatements = (0, import_luau_parser3.parse)(!mapping ? `${declarations}
+${returned ? `return ${returned.value}` : `${G}.require(${entryName})`}` : `
 local ${ok}, ${result2} = xpcall(function()
-    return ${G}.require(${(0, import_parser7.luauString)(sources.get(entry2).name)})
+    return ${G}.require(${entryName})
 end, ${G}.fail)
 if not ${ok} then
     error(${result2}, 0)
 end
-${modules.get(entry2).info.exports ? `return ${result2}` : ""}
+${declarations}
+${returned ? `return ${returned.value}` : ""}
 `).body.statements;
   program2.body.statements.push(...entryStatements);
-  const map = buildLineMap(program2, (0, import_luau_parser2.parse)((0, import_luau_parser2.print)(program2)), origins);
-  if (map.size || several) {
+  let printed = write(program2);
+  if (typeof printed !== "string") return unwritable(printed.problem);
+  const map = mapping ? buildLineMap(program2, (0, import_luau_parser3.parse)(printed), origins) : /* @__PURE__ */ new Map();
+  if (mapping && (map.size || several)) {
     const mapStatements = [assign(
       [member(identifier(G), "lines")],
-      [(0, import_luau_parser2.parseExpressionFromSource)(lineMapSource(map))]
+      [(0, import_luau_parser3.parseExpressionFromSource)(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: (0, import_luau_parser2.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];
-    if (file.modules.some((m) => m.usesScriptArgs)) body.push(...(0, import_luau_parser2.parse)(`local scriptArgs = ${G}.scriptArgs`).body.statements);
+    if (file.modules.some((m) => m.usesScriptArgs)) body.push(...(0, import_luau_parser3.parse)(`local scriptArgs = ${G}.scriptArgs`).body.statements);
     for (const module2 of file.modules) {
       body.push(assign(
         [index(member(identifier(G), "modules"), string(module2.name))],
@@ -3300,12 +3560,35 @@ ${modules.get(entry2).info.exports ? `return ${result2}` : ""}
       ));
     }
     const chunk = program([returns([functionExpression(functionBody([G], body))])]);
-    const lines = buildLineMap(chunk, (0, import_luau_parser2.parse)((0, import_luau_parser2.print)(chunk)), origins);
-    body.push(...mapRegistration(G, file, lineMapSource(lines)), ...fileHelpers.define);
-    files.push({ path: file.path, code: (0, import_luau_parser2.print)(chunk) + "\n", modules: file.modules.map((m) => m.name) });
+    if (mapping) {
+      const lines = buildLineMap(chunk, (0, import_luau_parser3.parse)((0, import_luau_parser3.print)(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, module2, value, exports2) {
+  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: module2, value, exports: exports2(), syntax });
+    if (!answer) continue;
+    const statements = [...answer.statements ?? []];
+    try {
+      (0, import_luau_parser3.parse)(`${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(module2) {
   const { names: exported, links, stars } = module2.info;
   const fields = [];
@@ -3325,10 +3608,6 @@ function layoutOf(mode, entry2, modules, outFile) {
   const entryStem = outFile !== void 0 ? (0, import_node_path2.basename)(outFile, (0, import_node_path2.extname)(outFile)) : import_node_path2.posix.basename(entry2.name);
   const others = modules.filter((m) => m !== entry2);
   if (mode === "single") return [{ path: `${entryStem}${extension}`, modules: [entry2, ...others] }];
-  if (mode === "modules") {
-    const pathOf = (m) => `${m.name.split("/").map((part) => part === ".." ? "__" : part).join("/")}${extension}`;
-    return [entry2, ...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();
@@ -3364,16 +3643,75 @@ function layoutOf(mode, entry2, modules, outFile) {
   return files;
 }
 function loadPath(entryPath, file, byPath) {
-  const path = import_node_path2.posix.relative(import_node_path2.posix.dirname(entryPath), file);
-  if (!byPath) return path;
+  return byPath ? requirePath(entryPath, file) : import_node_path2.posix.relative(import_node_path2.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 (0, import_parser7.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 = (0, import_node_path2.resolve)(path);
+  return process.platform === "win32" ? full.toLowerCase() : full;
+}
+function requirePath(from, to) {
+  const path = import_node_path2.posix.relative(import_node_path2.posix.dirname(from), to);
   const bare = path.slice(0, path.length - import_node_path2.posix.extname(path).length);
   return bare.startsWith("../") ? bare : `./${bare}`;
 }
+function tiluaFiles(folder) {
+  const found = [];
+  const walk2 = (at) => {
+    let entries;
+    try {
+      entries = (0, import_node_fs3.readdirSync)(at, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of entries) {
+      if (item.name.startsWith(".")) continue;
+      const path = (0, import_node_path2.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 = (0, import_node_path2.relative)(folder, file);
+  return path === "" || path.startsWith("..") || (0, import_node_path2.isAbsolute)(path);
+}
 function mapRegistration(G, file, map) {
   const extension = import_node_path2.posix.extname(file.path);
   const parts = file.path.slice(0, file.path.length - extension.length).split(/[/.]/).filter((part) => part !== "");
   const entry2 = `${G}.sources[#${G}.sources + 1]`;
-  return (0, import_luau_parser2.parse)([
+  return (0, import_luau_parser3.parse)([
     `${entry2} = { { ${parts.map(import_parser7.luauString).join(", ")} }, ${map}, ${(0, import_parser7.luauString)(extension.slice(1))} }`,
     ...file.modules.map((module2) => `${G}.maps[${(0, import_parser7.luauString)(module2.name)}] = ${G}.sources[#${G}.sources][2]`)
   ].join("\n")).body.statements;
@@ -3399,7 +3737,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]) => `[${(0, import_parser7.luauString)(name)}] = ${(0, import_parser7.luauString)(file)}`).join(", ");
   return `
 local ${G}
@@ -3407,7 +3746,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
@@ -3575,32 +3914,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]
@@ -3706,7 +4109,7 @@ var moduleAnalyses = /* @__PURE__ */ new Map();
 function analyzeModules(modules, config2) {
   const out2 = [];
   const analyses = /* @__PURE__ */ new Map();
-  const libraries = config2 ? (0, import_parser7.resolveTypeLibraries)(config2) : { files: [], lowerings: [], problems: [] };
+  const libraries = config2 ? (0, import_parser7.resolveTypeLibraries)(config2) : { files: [], lowerings: [], options: [], problems: [] };
   for (const p of libraries.problems) out2.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 = config2?.noLib ?? false;
@@ -3745,7 +4148,7 @@ function analyzeModules(modules, config2) {
       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();
@@ -3802,7 +4205,16 @@ function analyzeModules(modules, config2) {
     analyses.set(module2.file, types);
     out2.push(...diagnostics);
   }
-  return { types: analyses, diagnostics: out2, lowerings: [...libraries.lowerings] };
+  const exportsOf = (file) => {
+    const cached = exportsCache.get(file);
+    if (cached) return cached;
+    const module2 = byFile.get(file);
+    const { types, scopes } = analyzeModule(file, module2.program);
+    const exports2 = (0, import_parser7.moduleExports)(module2.program, scopes, types, resolverFor(file));
+    exportsCache.set(file, exports2);
+    return exports2;
+  };
+  return { types: analyses, diagnostics: out2, lowerings: [...libraries.lowerings], exportsOf };
 }
 function allStatements(statements) {
   const out2 = [];
@@ -3822,25 +4234,35 @@ function allStatements(statements) {
 }
 
 // src/cli.ts
-var usage = "usage: tilua <entry> [--out <file>] [--output single|chunks|modules] [--config <tilua.config.json>] [--noCheck]";
+var usage = "usage: tilua [<entry>] [--out <file>] [--output single|chunks|files] [--config <tilua.config.json>] [--noCheck] [--noLineMap] [--minify] [--watch]\n       tilua init";
 var args = process.argv.slice(2);
 var entry;
 var out;
 var config;
 var typeCheck = true;
+var lineMap;
+var minify;
 var output;
+var watching = false;
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
   if (arg === "--out") out = args[++i];
   else if (arg === "--config") config = args[++i];
   else if (arg === "--noCheck") typeCheck = false;
+  else if (arg === "--noLineMap") lineMap = false;
+  else if (arg === "--minify") minify = true;
+  else if (arg === "--watch" || arg === "-w") watching = true;
   else if (arg === "--target") {
     console.error(`--target is gone: the output runs on Lua 5.1 to 5.4, LuaJIT and Luau, and a library says what more its Lua has \u2014 add "luau" to the config's 'types'`);
     process.exit(2);
   } else if (arg === "--output") {
     const value = args[++i];
-    if (value !== "single" && value !== "chunks" && value !== "modules") {
-      console.error(`--output must be 'single', 'chunks' or 'modules', not '${value}'`);
+    if (value === "modules") {
+      console.error("--output modules is gone: --output files writes one file per module, each of which returns its exports");
+      process.exit(2);
+    }
+    if (value !== "single" && value !== "chunks" && value !== "files") {
+      console.error(`--output must be 'single', 'chunks' or 'files', not '${value}'`);
       process.exit(2);
     }
     output = value;
@@ -3849,38 +4271,162 @@ for (let i = 0; i < args.length; i++) {
     process.exit(0);
   } else entry = arg;
 }
-if (!entry) {
-  console.error(usage);
-  process.exit(2);
+var shown = (path) => (0, import_node_path3.relative)(process.cwd(), path) || ".";
+function init() {
+  const folder = process.cwd();
+  for (const name of ["tilua.config.json", "tilua.config.jsonc"]) {
+    if ((0, import_node_fs4.existsSync)((0, import_node_path3.join)(folder, name))) {
+      console.error(`${name} is already here`);
+      process.exit(1);
+    }
+  }
+  let rootDir = "src";
+  const project = (0, import_node_path3.join)(folder, "default.project.json");
+  if ((0, import_node_fs4.existsSync)(project)) {
+    const paths = [];
+    const walk2 = (node) => {
+      if (!node || typeof node !== "object") return;
+      const path = node.$path;
+      const named = typeof path === "string" ? path : path?.optional;
+      if (typeof named === "string" && !/\.\w+$/.test(named)) paths.push(named);
+      for (const [key, child] of Object.entries(node)) if (!key.startsWith("$")) walk2(child);
+    };
+    try {
+      walk2(JSON.parse((0, import_node_fs4.readFileSync)(project, "utf8")).tree);
+    } catch (error) {
+      console.error(`default.project.json: ${error.message}`);
+      process.exit(1);
+    }
+    const split = paths.map((path) => path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "").split("/"));
+    const shared = [];
+    for (let i = 0; split.length && split.every((parts) => parts.length > i && parts[i] === split[0][i]); i++) shared.push(split[0][i]);
+    if (split.length) rootDir = shared.join("/") || ".";
+  } else {
+    console.error('No default.project.json here: rootDir is "src". Change it if the project reads its files from elsewhere.');
+  }
+  const written = { types: ["roblox"], output: "files", rootDir };
+  (0, import_node_fs4.writeFileSync)((0, import_node_path3.join)(folder, "tilua.config.json"), JSON.stringify(written, null, 4) + "\n");
+  console.log("tilua.config.json: a .luau beside each .tilua under " + rootDir);
+  console.log("Next: npm i -D @tilua/compiler @tilua-types/roblox, then run `npx tilua --watch` beside `rojo serve`.");
+  process.exit(0);
+}
+function writtenByTilua(folder) {
+  const found = [];
+  const walk2 = (at) => {
+    let items;
+    try {
+      items = (0, import_node_fs4.readdirSync)(at, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const item of items) {
+      if (item.name.startsWith(".") || item.name === "node_modules") continue;
+      const path = (0, import_node_path3.join)(at, item.name);
+      if (item.isDirectory()) walk2(path);
+      else if (/\.luau?$/.test(item.name) && isTilua(path)) found.push(path);
+    }
+  };
+  walk2(folder);
+  return found;
+}
+function isTilua(path) {
+  try {
+    const text = (0, import_node_fs4.readFileSync)(path, "utf8").trimEnd();
+    return text.slice(text.lastIndexOf("\n") + 1).startsWith(WRITTEN_BY_TILUA);
+  } catch {
+    return false;
+  }
 }
-async function main(from) {
-  const found = resolveConfig(config, (0, import_node_path3.resolve)(from)).config;
+async function build(from) {
+  const found = resolveConfig(config, (0, import_node_path3.resolve)(from ?? "tilua.config.json")).config;
   const mode = output ?? found?.output ?? "single";
-  const entryFile = mode === "modules" ? void 0 : out ?? from.replace(/\.tilua$/, "") + ".luau";
-  const folder = entryFile !== void 0 ? (0, import_node_path3.dirname)(entryFile) : out ?? found?.directory ?? (0, import_node_path3.dirname)(from);
+  if (mode !== "files" && from === void 0) {
+    console.error(usage);
+    process.exit(2);
+  }
+  const perFile = mode === "files";
+  const entryFile = perFile || from === void 0 ? void 0 : out ?? from.replace(/\.tilua$/, "") + ".luau";
+  const folder = (0, import_node_path3.resolve)(entryFile !== void 0 ? (0, import_node_path3.dirname)(entryFile) : out ?? found?.outDir ?? process.cwd());
   const result2 = await bundle({
-    entry: from,
+    entry: perFile ? void 0 : from,
     config,
     typeCheck,
     output: mode,
+    lineMap,
+    minify,
+    outDir: perFile ? out : void 0,
     outFile: entryFile !== void 0 ? (0, import_node_path3.basename)(entryFile) : void 0
   });
   for (const d of result2.diagnostics) {
-    console.error(`${(0, import_node_path3.relative)(process.cwd(), d.file)}:${d.line}:${d.column} ${d.severity === "warning" ? "warning: " : ""}${d.message}`);
+    console.error(`${shown(d.file)}:${d.line}:${d.column} ${d.severity === "warning" ? "warning: " : ""}${d.message}`);
   }
   if (result2.code === void 0) {
-    console.error("no bundle written");
-    process.exit(1);
-  }
-  for (const file of result2.files) {
-    const target = (0, import_node_path3.join)(folder, file.path);
-    (0, import_node_fs4.mkdirSync)((0, import_node_path3.dirname)(target), { recursive: true });
-    (0, import_node_fs4.writeFileSync)(target, file.code);
-    console.log(`${target}: ${file.modules.length} module${file.modules.length === 1 ? "" : "s"}`);
+    console.error("no output written");
+    return false;
+  }
+  const targets = result2.files.map((file) => ({ ...file, target: (0, import_node_path3.join)(folder, file.path) }));
+  if (perFile) {
+    const theirs = targets.filter((file) => (0, import_node_fs4.existsSync)(file.target) && !isTilua(file.target));
+    for (const file of theirs) {
+      console.error(`${shown(file.target)}: this file was not written by tilua, and a .tilua would replace it \u2014 rename or remove one of them`);
+    }
+    if (theirs.length) return false;
+  }
+  for (const file of targets) {
+    if ((0, import_node_fs4.existsSync)(file.target) && (0, import_node_fs4.readFileSync)(file.target, "utf8") === file.code) continue;
+    (0, import_node_fs4.mkdirSync)((0, import_node_path3.dirname)(file.target), { recursive: true });
+    (0, import_node_fs4.writeFileSync)(file.target, file.code);
+    console.log(`${shown(file.target)}: ${file.modules.length} module${file.modules.length === 1 ? "" : "s"}`);
+  }
+  if (perFile) {
+    const kept = new Set(targets.map((file) => (0, import_node_path3.resolve)(file.target)));
+    for (const stale of writtenByTilua(folder)) {
+      if (kept.has((0, import_node_path3.resolve)(stale))) continue;
+      (0, import_node_fs4.rmSync)(stale);
+      console.log(`${shown(stale)}: removed, its .tilua is gone`);
+    }
   }
-  process.exit(result2.diagnostics.some((d) => d.severity !== "warning") ? 1 : 0);
+  return !result2.diagnostics.some((d) => d.severity !== "warning");
+}
+async function watchAndBuild(from) {
+  const found = resolveConfig(config, (0, import_node_path3.resolve)(from ?? "tilua.config.json")).config;
+  const folder = found?.directory ?? (from !== void 0 ? (0, import_node_path3.dirname)((0, import_node_path3.resolve)(from)) : process.cwd());
+  let running = false;
+  let again = false;
+  let timer;
+  const run = async () => {
+    if (running) {
+      again = true;
+      return;
+    }
+    running = true;
+    const ok = await build(from).catch((error) => {
+      console.error(error instanceof Error ? error.message : error);
+      return false;
+    });
+    console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] ${ok ? "built" : "built with errors"}; watching ${shown(folder)}`);
+    running = false;
+    if (again) {
+      again = false;
+      await run();
+    }
+  };
+  await run();
+  (0, import_node_fs4.watch)(folder, { recursive: true }, (_event, name) => {
+    if (!name) return;
+    const path = name.toString();
+    if (path.split(import_node_path3.sep).includes("node_modules")) return;
+    if (!/\.tilua$|tilua\.config\.jsonc?$|\.project\.json$/.test(path)) return;
+    clearTimeout(timer);
+    timer = setTimeout(() => void run(), 100);
+  });
+}
+async function main() {
+  if (entry === "init") init();
+  if (watching) return watchAndBuild(entry);
+  process.exit(await build(entry) ? 0 : 1);
 }
-main(entry).catch((error) => {
+main().catch((error) => {
   console.error(error instanceof Error ? error.message : error);
   process.exit(1);
 });