@tilua/compiler 3.1.0 → 5.0.0

package/dist/{chunk-VANZBLCL.js → chunk-3J2QMA4W.js}

@@ -172,6 +172,77 @@ var plugin = {
 };
 var languageLowering = { plugin, from: "tilua" };
 
+// src/standard.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { isFunctionType, luauString as luauString2 } from "@tilua/parser";
+var read2 = (name) => readFileSync2(new URL(`../runtime/${name}`, import.meta.url), "utf8");
+var console = read2("console.luau");
+var result = read2("result.luau");
+var place = (at) => luauString2(at.file === void 0 ? `line ${at.line}` : `${at.file}:${at.line}`);
+var tag = (at) => luauString2(`[${at.file === void 0 ? `line ${at.line}` : `${at.file.replace(/\.tilua$/, "")}:${at.line}`}]:`);
+function consoleMeta(args) {
+  const fields = [];
+  args.forEach((argument, index2) => {
+    if (argument.spread || argument.typeText === void 0 || !isFunctionType(argument.type)) return;
+    const written = argument.declaration ?? argument.source;
+    fields.push(`[${index2 + 1}] = { ${luauString2(argument.typeText)}, ${luauString2(written)} }`);
+  });
+  return fields.length ? `{ ${fields.join(", ")} }` : "nil";
+}
+var CONSOLE_METHODS = /* @__PURE__ */ new Set(["log", "warn", "error"]);
+var REPLACED = /* @__PURE__ */ new Map([
+  ["pcall", "pcall"],
+  ["xpcall", "xpcall"],
+  ["ypcall", "pcall"],
+  ["coroutine.resume", "resume"],
+  ["string.find", "find"],
+  ["string.match", "match"],
+  ["string.gsub", "gsub"],
+  ["string.byte", "byte"],
+  ["math.modf", "modf"],
+  ["math.frexp", "frexp"],
+  ["next", "next"],
+  ["select", "select"],
+  ["unpack", "unpack"],
+  ["table.unpack", "unpack"],
+  ["loadstring", "loadstring"],
+  ["pairs", "pairs"],
+  ["ipairs", "ipairs"],
+  ["string.gmatch", "gmatch"]
+]);
+var plugin2 = {
+  runtime: { console, result },
+  methodCall({ method, receiverGlobal, at, arguments: args, use }) {
+    if (receiverGlobal === "console" && CONSOLE_METHODS.has(method)) {
+      return {
+        callee: `${use("console")}.${method}`,
+        prepend: [tag(at), consoleMeta(args)],
+        passReceiver: false
+      };
+    }
+    return void 0;
+  },
+  // `print(x)` and `warn(x)` are left exactly as written: the place a line
+  // came from is what `console:log` / `console:warn` are for. `error` has to
+  // put the place inside the message it raises, so it goes through the
+  // runtime.
+  globalCall({ name, at, use }) {
+    if (name === "error") return { callee: `${use("console")}.raise`, prepend: [place(at)] };
+    const replaced = REPLACED.get(name);
+    if (replaced) return { callee: `${use("result")}.${replaced}` };
+    return void 0;
+  },
+  // Read as a value there is no call site to write down; the runtime finds
+  // one on the stack.
+  globalValue({ name, use }) {
+    if (name === "error") return `${use("console")}.raiseValue`;
+    const replaced = REPLACED.get(name);
+    if (replaced) return `${use("result")}.${replaced}`;
+    return void 0;
+  }
+};
+var standardLowering = { plugin: plugin2, from: "tilua (standard library)" };
+
 // src/lower.ts
 function lower(program2, scopes, options = {}) {
   return new Lowerer(program2, scopes, options).run();
@@ -210,11 +281,11 @@ var Lowerer = class {
   origins = /* @__PURE__ */ new WeakMap();
   run() {
     const body = this.options.module ? this.module(this.options.module) : this.topLevel(this.source.body.statements);
+    const scriptArgs = this.usesScriptArgs && !this.options.module ? [local(["scriptArgs"], [this.array(table([{ type: "TableFieldPositional", value: vararg() }]))])] : [];
     const helpers = this.helperDefinitions();
     const captured = [...this.builtins].map(([global, local2]) => local([local2], [identifier(global)]));
-    const scriptArgs = this.usesScriptArgs && !this.options.module ? [local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: vararg() }])])] : [];
     return {
-      statements: [...scriptArgs, ...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
+      statements: [...captured, ...helpers, ...scriptArgs, ...this.classRuntimeStatements(), ...body],
       exportsName: this.exportsName,
       module: this.info,
       diagnostics: this.diagnostics,
@@ -261,14 +332,43 @@ var Lowerer = class {
     }
     return identifier(local2);
   }
+  /** `table.move`. Lua 5.1 has none, and gets a function that does the same. */
+  move() {
+    return this.lua51 ? this.helper("move") : member(this.builtin("table"), "move");
+  }
   helper(kind) {
     let name = this.helpers.get(kind);
     if (!name) {
-      name = this.names.fresh(`tilua_${kind}`);
+      name = this.names.fresh(`tilua_${kind === "array" ? "asArray" : kind}`);
       this.helpers.set(kind, name);
     }
     return identifier(name);
   }
+  // `typeof v` tells an array from an object, which Luau cannot: both are
+  // tables. So every array the program makes — `[a, b]`, a rest parameter,
+  // what `:map` answers — is written down as one, in a table that holds its
+  // keys weakly, and `typeof` looks there. A table nothing wrote down (one a
+  // Lua library made) is told by its type where that says, and by its shape
+  // where it does not.
+  /** `value`, a new array, written down as one. */
+  array(value) {
+    const marked = call(this.helper("array"), [value]);
+    this.marked.add(marked);
+    return marked;
+  }
+  /** The calls `array` made: each answers the one table it was given. */
+  marked = /* @__PURE__ */ new WeakSet();
+  /** Luau reaching the record of arrays: the bundle's, or this file's own. */
+  arrays() {
+    return this.options.module?.arrays ?? this.helper("arrays").name;
+  }
+  typeofExpression(node) {
+    const known = this.options.types?.typeofTables.get(node);
+    let argument = node.argument;
+    while (argument.type === "ParenthesizedExpression") argument = argument.expression;
+    const value = this.expression(argument);
+    return call(this.helper("typeof"), known ? [value, string(known)] : [this.keptToOne(value)]);
+  }
   /** The local a library's runtime table gets in this file, emitting it the
    *  first time something asks. Keyed by library and by the key the library
    *  itself chose, so two libraries' tables never collide. */
@@ -358,7 +458,11 @@ var Lowerer = class {
   /** The language's own lowering, then each library's, in load order. A
    *  runtime is named by its lowering's place here (`loweringRuntime`). */
   get lowerings() {
-    return this.allLowerings ??= [languageLowering, ...this.options.lowerings ?? []];
+    return this.allLowerings ??= [
+      languageLowering,
+      ...this.options.noLib ? [] : [standardLowering],
+      ...this.options.lowerings ?? []
+    ];
   }
   allLowerings;
   /** What `receiver:method(...)` becomes, when Luau alone would not run it.
@@ -372,22 +476,28 @@ var Lowerer = class {
    *  (`console:log`), the last library loaded first. No answer leaves an
    *  ordinary Luau method call: `text:upper()` reaches Lua's own. */
   loweredMethodCall(node) {
+    return this.loweredMethod(node.method.name, this.options.types?.methodSources.get(node), node.object, node.arguments, node.method, node);
+  }
+  /** `loweredMethodCall`, for a method named `method` of what `object`
+   *  holds — called with `:` on it, or read off it with `.` and handed its
+   *  `self` like any other argument. `args` are the arguments after the
+   *  receiver; a read that is not called has none. */
+  loweredMethod(method, source, object2, args, name, node) {
     const lowerings = this.lowerings;
-    const source = this.options.types?.methodSources.get(node);
     const asked = source?.origin === "language" ? [0] : source?.origin === "library" ? lowerings.flatMap((l, i) => l.library === source.library ? [i] : []) : source?.origin === "program" ? [] : lowerings.map((_, i) => i).slice(1).reverse();
     if (!asked.some((i) => lowerings[i].plugin.methodCall)) return void 0;
-    const receiver = this.options.types?.typeOf.get(node.object);
-    const receiverGlobal = this.globalName(node.object);
-    const info = this.lazyArguments(node.arguments);
+    const receiver = this.options.types?.typeOf.get(object2);
+    const receiverGlobal = this.globalName(object2);
+    const info = this.lazyArguments(args);
     for (const i of asked) {
-      const plugin2 = lowerings[i].plugin;
-      if (!plugin2.methodCall) continue;
-      const answer = plugin2.methodCall({
-        method: node.method.name,
+      const plugin3 = lowerings[i].plugin;
+      if (!plugin3.methodCall) continue;
+      const answer = plugin3.methodCall({
+        method,
         receiver,
         receiverGlobal,
-        argumentCount: node.arguments.length,
-        at: this.callSite(node.method),
+        argumentCount: args.length,
+        at: this.callSite(name),
         get arguments() {
           return info();
         },
@@ -411,9 +521,9 @@ var Lowerer = class {
     if (name === void 0) return void 0;
     const info = this.lazyArguments(node.arguments);
     for (let i = lowerings.length - 1; i >= 0; i--) {
-      const plugin2 = lowerings[i].plugin;
-      if (!plugin2.globalCall) continue;
-      const answer = plugin2.globalCall({
+      const plugin3 = lowerings[i].plugin;
+      if (!plugin3.globalCall) continue;
+      const answer = plugin3.globalCall({
         name,
         at: this.callSite(node.callee),
         get arguments() {
@@ -463,6 +573,114 @@ var Lowerer = class {
   }
   helperDefinitions() {
     const out = [];
+    const runtimes = this.runtimeDefinitions();
+    if (this.helpers.has("concat")) this.helper("array");
+    if (this.helpers.has("concat")) this.move();
+    const move = this.helpers.get("move");
+    if (move) {
+      out.push(...parseLuau(`
+local function ${move}(from, first, last, at, to)
+	for i = first, last do
+		to[at + i - first] = from[i]
+	end
+	return to
+end`).body.statements);
+    }
+    const each = this.helpers.get("each");
+    if (each) {
+      out.push(...parseLuau(`
+local function ${each}(source, ...)
+	if ${this.builtin("type").name}(source) == "function" then
+		return source, ...
+	end
+	local meta = ${this.builtin("getmetatable").name}(source)
+	if meta ~= nil and meta.__iter ~= nil then
+		return meta.__iter(source)
+	end
+	return ${this.builtin("next").name}, source
+end`).body.statements);
+    }
+    const marker = this.helpers.get("array");
+    const typeOf = this.helpers.get("typeof");
+    if (marker || typeOf) {
+      const arrays = this.arrays();
+      const own = this.helpers.get("arrays");
+      if (own) {
+        out.push(...parseLuau(`local ${own} = ${this.builtin("setmetatable").name}({}, { __mode = "k" })`).body.statements);
+      }
+      if (marker) {
+        out.push(...parseLuau(`
+local function ${marker}(t)
+	${arrays}[t] = true
+	return t
+end`).body.statements);
+      }
+      if (typeOf) {
+        out.push(...parseLuau(`
+local function ${typeOf}(value, known)
+	local name = ${this.builtin(this.lua51 ? "type" : "typeof").name}(value)
+	if name ~= "table" then
+		return name
+	end
+	if known ~= nil then
+		return known
+	end
+	if ${arrays}[value] then
+		return "array"
+	end
+	if ${this.builtin("getmetatable").name}(value) ~= nil then
+		return "object"
+	end
+	if #value > 0 then
+		return "array"
+	end
+	return "object"
+end`).body.statements);
+      }
+    }
+    const instanceOf = this.helpers.get("instanceof");
+    if (instanceOf) {
+      out.push(...parseLuau(`
+local function ${instanceOf}(value, class)
+	if ${this.builtin("type").name}(value) ~= "table" then
+		return false
+	end
+	local current = value.ClassObject
+	while current ~= nil do
+		if current == class then
+			return true
+		end
+		current = current.ParentClass
+	end
+	return false
+end`).body.statements);
+    }
+    const accessors = this.helpers.get("accessors");
+    if (accessors) {
+      out.push(...parseLuau(`
+local function ${accessors}(target, getters, setters)
+	return ${this.builtin("setmetatable").name}(target, {
+		__index = function(self, key)
+			local get = getters[key]
+			if get ~= nil then
+				return get(self)
+			end
+			return nil
+		end,
+		__newindex = function(self, key, value)
+			local set = setters[key]
+			if set ~= nil then
+				set(self, value)
+				return
+			end
+			if getters[key] ~= nil then
+				${this.builtin("error").name}("Cannot assign to '" .. ${this.builtin("tostring").name}(key) .. "': it has a getter and no setter", 2)
+			end
+			${this.builtin("rawset").name}(self, key, value)
+		end,
+	})
+end`).body.statements);
+    }
     const assign2 = this.helpers.get("assign");
     if (assign2) {
       out.push(localFunction(assign2, functionBody(["target"], [
@@ -477,28 +695,14 @@ var Lowerer = class {
         returns([identifier("target")])
       ], true)));
     }
-    for (const { index: index2, runtime: runtime2, name } of this.loweringUsed) {
-      const { plugin: plugin2, from } = this.lowerings[index2];
-      const source = plugin2.runtime?.[runtime2];
-      if (source === void 0) {
-        this.diagnostics.push({
-          message: `'${from}' asked for a runtime it does not have: '${runtime2}'`,
-          line: 1,
-          column: 1
-        });
-        continue;
-      }
-      const lines = this.options.module?.lines ?? "nil";
-      const fail = this.options.module?.fail ?? "nil";
-      out.push(...parseLuau(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail)).body.statements);
-    }
+    out.push(...runtimes);
     const concat = this.helpers.get("concat");
     if (concat) {
       out.push(localFunction(concat, functionBody([], [
-        local(["result"], [table([])]),
+        local(["result"], [this.array(table([]))]),
         numericFor("i", number(1), selectCount(this.builtin("select")), [
           local(["part"], [call(this.builtin("select"), [identifier("i"), vararg()])]),
-          callStatement(call(member(this.builtin("table"), "move"), [
+          callStatement(call(this.move(), [
             identifier("part"),
             number(1),
             unary("#", identifier("part")),
@@ -511,6 +715,26 @@ var Lowerer = class {
     }
     return out;
   }
+  /** The runtime tables the file's libraries were asked for. */
+  runtimeDefinitions() {
+    const out = [];
+    for (const { index: index2, runtime: runtime2, name } of this.loweringUsed) {
+      const { plugin: plugin3, from } = this.lowerings[index2];
+      const source = plugin3.runtime?.[runtime2];
+      if (source === void 0) {
+        this.diagnostics.push({
+          message: `'${from}' asked for a runtime it does not have: '${runtime2}'`,
+          line: 1,
+          column: 1
+        });
+        continue;
+      }
+      const lines = this.options.module?.lines ?? "nil";
+      const fail = this.options.module?.fail ?? "nil";
+      out.push(...parseLuau(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail).replace(/__ARRAY__/g, () => this.helper("array").name)).body.statements);
+    }
+    return out;
+  }
   // --------------------------------------------------------
   // Modules
   // --------------------------------------------------------
@@ -591,6 +815,7 @@ var Lowerer = class {
           names.push("default");
           break;
         case "ExportNamedStatement": {
+          if (statement.typeOnly) break;
           if (statement.source) {
             const key = resolve3(statement.source);
             if (key === void 0) break;
@@ -674,6 +899,26 @@ var Lowerer = class {
     for (let i = 0; i < locals.length; i += 100) declarations.push(local(locals.slice(i, i + 100), []));
     return [...declarations, ...hoisted, ...requires, ...body];
   }
+  /** `import("./x")`: the bundle's `import`, called with the module's name.
+   *  It answers the module's exports table — what `import * as` names. */
+  importExpression(node) {
+    const context = this.options.module;
+    if (!context) {
+      this.report(node, "import() needs a bundle: build the project with @tilua/compiler");
+      return nil();
+    }
+    const source = node.source;
+    if (source.type !== "StringLiteral") {
+      this.report(source, "import() takes a string literal: which module it loads is decided when the project is built");
+      return nil();
+    }
+    const key = context.resolve(source.value, true);
+    if (key === void 0) {
+      this.report(source, `Cannot find module '${source.value}'`);
+      return nil();
+    }
+    return call(context.import ?? context.require, [string(key)]);
+  }
   isRewritten(node) {
     const binding = this.bindingByDeclaration.get(node);
     return binding !== void 0 && this.rewrites.has(binding.id);
@@ -820,7 +1065,7 @@ var Lowerer = class {
       case "VariableDeclaration":
         return this.variableDeclaration(node, "declare");
       case "FunctionDeclaration":
-        return [{ ...localFunction(this.name(node.name.name), this.functionBody(node.func)), attributes: node.attributes }];
+        return [{ ...localFunction(this.name(node.name.name), this.functionBody(node.func)), attributes: this.lua51 ? void 0 : node.attributes }];
       case "FunctionDeclarationStatement":
         return [this.functionDeclarationStatement(node)];
       case "ClassDeclaration":
@@ -851,8 +1096,13 @@ var Lowerer = class {
       // kept — Lua has no expression statement — and it cannot run
       // anything, since a call is a `CallStatement` instead, so dropping
       // it changes nothing but the noise.
-      case "ExpressionStatement":
-        return [];
+      case "ExpressionStatement": {
+        let expression = node.expression;
+        while (expression.type === "ParenthesizedExpression") expression = expression.expression;
+        if (expression.type !== "ImportExpression") return [];
+        const call2 = this.importExpression(expression);
+        return call2.type === "CallExpression" ? [this.from(callStatement(call2), node)] : [];
+      }
       case "DoStatement":
         return [{ type: "DoStatement", body: this.block(node.body), ...spanOf(node) }];
       case "WhileStatement":
@@ -904,7 +1154,11 @@ var Lowerer = class {
         let source = this.expression(node.iterator);
         if (form.viaIter) source = methodCall(source, "__iter", []);
         const variables = form.walks === "values" ? [this.names.fresh("_"), item] : [item];
-        const iterators = form.walks === "iteration" ? [call(this.builtin("unpack"), [source, number(1), number(3)])] : [source];
+        let iterators = form.walks === "iteration" ? [call(this.builtin("unpack"), [source, number(1), number(3)])] : [source];
+        if (this.lua51 && form.walks === "values") {
+          const kind = form.viaIter ? void 0 : this.options.types?.typeOf.get(node.iterator)?.kind;
+          iterators = [call(kind === "array" || kind === "tuple" ? this.builtin("ipairs") : this.helper("each"), [source])];
+        }
         return [genericFor(
           variables,
           iterators,
@@ -1157,7 +1411,8 @@ end
       },
       isMethod,
       func,
-      attributes: node.attributes,
+      // `@native` and the like are Luau's.
+      attributes: this.lua51 ? void 0 : node.attributes,
       ...spanOf(node)
     };
   }
@@ -1258,12 +1513,12 @@ end
         if (element) bind(element.value, index(source, number(i + 1)), element.default);
       });
       if (pattern.rest) {
-        const elements = call(member(this.builtin("table"), "move"), [
+        const elements = call(this.move(), [
           source,
           number(pattern.elements.length + 1),
           unary("#", source),
           number(1),
-          table([])
+          this.array(table([]))
         ]);
         const rest = this.restTarget(pattern.rest, elements, mode, after);
         after.push(...rest.then);
@@ -1317,7 +1572,7 @@ end
     const names = [];
     for (const p of params) {
       if (p.rest) {
-        prelude.push(local([this.name(p.name)], [table([{ type: "TableFieldPositional", value: vararg() }])]));
+        prelude.push(local([this.name(p.name)], [this.array(table([{ type: "TableFieldPositional", value: vararg() }]))]));
         continue;
       }
       const name = p.pattern ? this.names.fresh("arg") : this.name(p.name);
@@ -1369,12 +1624,20 @@ end
       case "ArrayExpression":
         return this.arrayExpression(node);
       case "BinaryExpression": {
+        if (node.operator === "??") return this.nullish(node);
         const left = this.expression(node.left);
         const right = this.expression(node.right);
+        if (node.operator === "in") {
+          return parenthesized(binary("~=", index(this.keptToOne(right), this.keptToOne(left)), nil()));
+        }
+        if (node.operator === "instanceof") {
+          return call(this.helper("instanceof"), [this.keptToOne(left), this.keptToOne(right)]);
+        }
         if (this.lua51 && node.operator === "//") return this.floorDivide(left, right);
         return binary(node.operator, left, right);
       }
       case "UnaryExpression":
+        if (node.operator === "typeof") return this.typeofExpression(node);
         return unary(node.operator, this.expression(node.argument));
       case "SuperExpression":
         return this.superClassReference(node);
@@ -1396,6 +1659,8 @@ end
       }
       case "ParenthesizedExpression":
         return parenthesized(this.expression(node.expression));
+      case "ImportExpression":
+        return this.importExpression(node);
       // Types only: the value is the expression itself.
       case "TypeAssertionExpression":
       case "SatisfiesExpression":
@@ -1429,7 +1694,7 @@ end
    *  kept to one there, `f((g()))`. Every value is taken only where the
    *  program asks for them, as an array's last element: `[g()]`. */
   keptToOne(value) {
-    return expandsToMany(value) ? parenthesized(value) : value;
+    return expandsToMany(value) && !this.marked.has(value) ? parenthesized(value) : value;
   }
   /** Is this `scriptArgs` the language's own, not a name the file declared? */
   isLanguageGlobal(node) {
@@ -1449,7 +1714,7 @@ end
       const last2 = list.length - 1;
       return lowered.length && !many.has(list[last2]) ? [...lowered.slice(0, -1), this.keptToOne(lowered[last2])] : lowered;
     }
-    const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
+    const unpack = (value) => call(this.lua51 ? this.builtin("unpack") : member(this.builtin("table"), "unpack"), [value]);
     const last = list[list.length - 1];
     if (spreads.length === 1 && last.type === "SpreadElement") {
       return [...list.slice(0, -1).map((a) => this.expression(a)), unpack(this.expression(last.argument))];
@@ -1463,11 +1728,21 @@ end
   /** One link of an access chain, read from `object`. */
   link(node, object2) {
     switch (node.type) {
-      case "MemberExpression":
+      case "MemberExpression": {
+        if (this.options.types?.lengths.has(node)) return unary("#", object2);
+        const source = this.options.types?.methodReads.get(node);
+        const lowered = source && this.loweredMethod(node.property.name, source, node.object, [], node.property, node);
+        if (lowered) {
+          const forwarded = call(calleePath(lowered.callee), [...lowered.prepend, vararg()]);
+          return functionExpression(functionBody(lowered.passReceiver ? [] : ["_"], [returns([forwarded])], true));
+        }
         return member(object2, node.property.name);
+      }
       case "IndexExpression":
         return index(object2, this.expression(node.index));
       case "CallExpression": {
+        const method = this.methodCalled(node);
+        if (method) return method;
         const lowered = this.loweredGlobalCall(node);
         const args = this.arguments(node.arguments);
         if (!lowered) return call(object2, args);
@@ -1490,6 +1765,24 @@ end
       }
     }
   }
+  /** `names.filter(names, f)`: a method of the value's metatable, read with
+   *  `.` and handed its `self` as the first argument. Written as a call of
+   *  the function the method really is — `array.filter(names, f)` — where
+   *  whoever declared the metatable says so; `undefined` leaves an ordinary
+   *  call, which is right for a string's Lua methods (`text.upper(text)`
+   *  reaches Lua's own `string.upper`). */
+  methodCalled(node) {
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression") return void 0;
+    const source = this.options.types?.methodReads.get(callee);
+    if (!source) return void 0;
+    const spreads = node.arguments.map((a, i) => a.type === "SpreadElement" ? i : -1).filter((i) => i >= 0);
+    if (!node.arguments.length || spreads.includes(0) || spreads.some((i) => i !== node.arguments.length - 1)) return void 0;
+    const lowered = this.loweredMethod(callee.property.name, source, callee.object, node.arguments.slice(1), callee.property, node);
+    if (!lowered) return void 0;
+    const [self, ...rest] = this.arguments(node.arguments);
+    return call(calleePath(lowered.callee), [...lowered.prepend, ...lowered.passReceiver ? [self] : [], ...rest]);
+  }
   // --------------------------------------------------------
   // Optional chains
   // --------------------------------------------------------
@@ -1535,7 +1828,7 @@ end
     const segments = this.segments(chain);
     const base = this.expression(chain.base);
     const last = chain.links[chain.links.length - 1];
-    if (base.type === "Identifier" && segments.length === 1 && last.type !== "CallExpression" && last.type !== "MethodCallExpression") {
+    if (!this.lua51 && base.type === "Identifier" && segments.length === 1 && last.type !== "CallExpression" && last.type !== "MethodCallExpression") {
       return {
         type: "IfElseExpression",
         clauses: [{ condition: binary("==", base, nil()), body: nil() }],
@@ -1556,6 +1849,32 @@ end
     const func = functionExpression(functionBody([], statements, passesVarargs));
     return call(parenthesized(func), passesVarargs ? [vararg()] : []);
   }
+  /** `a ?? b`: `a`, or `b` where `a` is nil — read only then. A `false`
+   *  stays, which is what sets it apart from `a or b`. A name is tested
+   *  in place; anything else is read once, into a local. */
+  nullish(node) {
+    const left = this.keptToOne(this.expression(node.left));
+    const right = this.keptToOne(this.expression(node.right));
+    if (!this.lua51 && left.type === "Identifier") {
+      return {
+        type: "IfElseExpression",
+        clauses: [{ condition: binary("~=", left, nil()), body: left }],
+        alternate: right,
+        line: left.line,
+        column: left.column
+      };
+    }
+    const ref = this.names.fresh("value");
+    const at = identifier(ref);
+    const statements = [
+      local([ref], [left]),
+      ifThen(binary("~=", at, nil()), [returns([at])]),
+      returns([right])
+    ];
+    const passesVarargs = statements.some(usesVararg);
+    const func = functionExpression(functionBody([], statements, passesVarargs));
+    return call(parenthesized(func), passesVarargs ? [vararg()] : []);
+  }
   /** `` `${a} any` `` -> `("%s any"):format(tostring(a))` */
   interpolatedString(node) {
     let format = "";
@@ -1637,12 +1956,12 @@ end
     }));
     const alternate = this.expression(node.alternate);
     if (clauses.every((c) => alwaysTruthy(c.body))) {
-      let result = alternate;
+      let result2 = alternate;
       for (let i = clauses.length - 1; i >= 0; i--) {
         const { condition, body } = clauses[i];
-        result = binary("or", binary("and", condition, body), result);
+        result2 = binary("or", binary("and", condition, body), result2);
       }
-      return parenthesized(result);
+      return parenthesized(result2);
     }
     const statement = {
       type: "IfStatement",
@@ -1699,18 +2018,27 @@ end
           current = [];
           parts.push(this.expression(f.argument));
           break;
+        case "TableFieldAccessor":
+          break;
       }
     }
-    if (parts.length === 0) return table(current);
-    if (current.length) parts.push(table(current));
-    return call(this.helper("assign"), [table([]), ...parts]);
+    let made;
+    if (parts.length === 0) made = table(current);
+    else {
+      if (current.length) parts.push(table(current));
+      made = call(this.helper("assign"), [table([]), ...parts]);
+    }
+    const accessors = node.fields.filter((f) => f.type === "TableFieldAccessor");
+    if (!accessors.length) return made;
+    const table2 = (kind) => table(accessors.filter((f) => f.kind === kind).map((f) => field(f.key.type === "Identifier" ? f.key.name : f.key.value, functionExpression(this.classFunctionBody(f.func)))));
+    return call(this.helper("accessors"), [made, table2("get"), table2("set")]);
   }
   /** `[1, ...xs, 2]`. Without a spread it is a Luau sequence; with one, the
    *  runs of plain elements and the spread arrays are joined by `concat`. */
   arrayExpression(node) {
     const elements = packs(node.elements).items;
     if (!elements.some((e) => e.type === "SpreadElement")) {
-      return table(elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
+      return this.array(table(elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) }))));
     }
     const parts = [];
     let current = [];
@@ -1967,15 +2295,15 @@ async function loadLowerings(modules) {
   for (const module of modules) {
     try {
       const loaded = await import(pathToFileURL(module.file).href);
-      const plugin2 = loaded.default;
-      if (!plugin2 || typeof plugin2 !== "object") {
+      const plugin3 = loaded.default;
+      if (!plugin3 || typeof plugin3 !== "object") {
         problems.push({
           file: module.file,
           message: `'${module.from}' lowering module has no default export`
         });
         continue;
       }
-      lowerings.push({ plugin: plugin2, from: module.from, library: module.library });
+      lowerings.push({ plugin: plugin3, from: module.from, library: module.library });
     } catch (error) {
       problems.push({
         file: module.file,
@@ -1987,8 +2315,8 @@ async function loadLowerings(modules) {
 }
 
 // src/bundle.ts
-import { readFileSync as readFileSync2, statSync } from "fs";
-import { dirname, relative, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync3, statSync } from "fs";
+import { basename, dirname, extname, posix, relative, resolve as resolve2 } from "path";
 import {
   parse,
   analyzeScopes,
@@ -1996,17 +2324,18 @@ import {
   moduleExports,
   resolveModulePath,
   resolveTypeLibraries,
+  importExpressions,
   directivesOf,
   applyDirectives,
   UNUSED_EXPECT_ERROR,
   ParseError,
   LexError,
-  luauString as luauString3
+  luauString as luauString4
 } from "@tilua/parser";
 import { parse as parseLuau2, parseExpressionFromSource as parseExpressionFromSource2, print } from "luau-parser";
 
 // src/linemap.ts
-import { luauString as luauString2 } from "@tilua/parser";
+import { luauString as luauString3 } from "@tilua/parser";
 function statementsOf(node) {
   const out = [];
   const visit = (value) => {
@@ -2039,7 +2368,7 @@ function buildLineMap(emitted, printed, origins) {
 }
 function lineMapSource(map) {
   const entries = [...map.entries()].sort((a, b) => a[0] - b[0]);
-  const quoted = (s) => luauString2(s.replace(/\\/g, "/"));
+  const quoted = (s) => luauString3(s.replace(/\\/g, "/"));
   return `{${entries.map(([line, o]) => `[${line}]={${quoted(o.file)},${o.line}}`).join(",")}}`;
 }
 
@@ -2059,16 +2388,17 @@ async function bundle(options) {
     const file = queue.shift();
     if (sources.has(file)) continue;
     const parsed = parseFile(file, diagnostics, directives);
-    if (!parsed) return { modules: [], diagnostics };
+    if (!parsed) return { files: [], modules: [], diagnostics };
     const { program: program3, text } = parsed;
-    const scopes = analyzeScopes(program3);
+    const scopes = analyzeScopes(program3, { noLib: config?.noLib });
     for (const d of scopes.diagnostics) {
       diagnostics.push({ file, message: d.message, line: d.node.line.start, column: d.node.column.start, category: "scope" });
     }
     sources.set(file, { file, name: nameOf(file), text, program: program3, scopes });
-    for (const specifier of importedSpecifiers(program3)) {
-      const target = resolveModulePath(file, specifier, config);
-      if (target && !target.endsWith(".d.tilua")) queue.push(target);
+    const dynamic = importExpressions(program3).flatMap((node) => node.source.type === "StringLiteral" ? [node.source.value] : []);
+    for (const specifier of [...importedSpecifiers(program3), ...dynamic]) {
+      const target2 = resolveModulePath(file, specifier, config);
+      if (target2 && !target2.endsWith(".d.tilua")) queue.push(target2);
     }
   }
   const analysis = analyzeModules([...sources.values()], config);
@@ -2080,6 +2410,9 @@ async function bundle(options) {
   const names = Names.from(...[...sources.values()].map((s) => s.program));
   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 target = options.target ?? config?.target ?? "luau";
   const modules = /* @__PURE__ */ new Map();
   const origins = /* @__PURE__ */ new WeakMap();
   const pending = [entry];
@@ -2088,37 +2421,48 @@ async function bundle(options) {
     if (modules.has(file)) continue;
     const source = sources.get(file);
     const shown = relative(root, file).replace(/\\/g, "/");
-    const lowered = lower(source.program, source.scopes, {
+    const imports = /* @__PURE__ */ new Set();
+    const dynamicImports = /* @__PURE__ */ new Set();
+    const lowered2 = lower(source.program, source.scopes, {
       names,
       types: analysis.types.get(file),
       lowerings,
-      target: options.target ?? config?.target,
+      target,
+      noLib: config?.noLib,
       source: source.text,
       file: shown,
       module: {
         name: source.name,
         require: requireExpression,
-        lines: `${G}.lines`,
+        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`,
-        resolve: (specifier) => {
-          const target = resolveModulePath(file, specifier, config);
-          if (!target || target.endsWith(".d.tilua") || !sources.has(target)) return void 0;
-          pending.push(target);
-          return sources.get(target).name;
+        arrays: `${G}.arrays`,
+        resolve: (specifier, dynamic) => {
+          const found = resolveModulePath(file, specifier, config);
+          if (!found || found.endsWith(".d.tilua") || !sources.has(found)) return void 0;
+          pending.push(found);
+          const name = sources.get(found).name;
+          (dynamic ? dynamicImports : imports).add(name);
+          return name;
         }
       }
     });
-    for (const d of lowered.diagnostics) diagnostics.push({ file, ...d, category: "module" });
-    for (const statement of allStatements(lowered.statements)) {
-      const line = lowered.origins.get(statement);
+    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 });
     }
     modules.set(file, {
       name: source.name,
-      statements: lowered.statements,
-      exportsName: lowered.exportsName,
-      info: lowered.module,
-      usesScriptArgs: lowered.usesScriptArgs
+      statements: lowered2.statements,
+      exportsName: lowered2.exportsName,
+      info: lowered2.module,
+      usesScriptArgs: lowered2.usesScriptArgs,
+      imports,
+      dynamicImports
     });
   }
   for (const [file, fileDirectives] of directives) {
@@ -2137,57 +2481,175 @@ async function bundle(options) {
   const reported = diagnostics.filter((d) => d.category !== "type" || !moduleProblems.has(`${d.file}:${d.line}:${d.column}:${d.message}`));
   diagnostics.length = 0;
   diagnostics.push(...reported);
-  const moduleNames = [...modules.values()].map((m) => m.name);
+  const lowered = [...modules.values()];
+  const moduleNames = lowered.map((m) => m.name);
   if (diagnostics.some((d) => d.category === "syntax" || d.category === "scope" || d.category === "module")) {
-    return { modules: moduleNames, diagnostics };
-  }
-  const program2 = parseLuau2(runtime(G));
+    return { files: [], modules: moduleNames, diagnostics };
+  }
+  const several = mode !== "single";
+  const layout = layoutOf(mode, modules.get(entry), lowered, options.outFile);
+  const usesScriptArgs = lowered.some((m) => m.usesScriptArgs);
+  const elsewhere = /* @__PURE__ */ new Map();
+  for (const file of layout.slice(1)) {
+    for (const module of file.modules) elsewhere.set(module.name, loadPath(layout[0].path, file.path, target));
+  }
+  const program2 = parseLuau2(runtime(G, {
+    several,
+    target,
+    files: elsewhere,
+    imports: lowered.some((m) => m.dynamicImports.size > 0)
+  }));
   const assignment = program2.body.statements[1];
-  if ([...modules.values()].some((m) => m.usesScriptArgs)) {
+  if (usesScriptArgs) {
     program2.body.statements.unshift(local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: { type: "VarargExpression" } }])]));
+    program2.body.statements.push(...parseLuau2(`${G}.arrays[scriptArgs] = true`).body.statements);
+    if (several) program2.body.statements.push(...parseLuau2(`${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");
-  for (const module of modules.values()) {
-    const { names: exported, links, stars } = module.info;
-    const fields = [];
-    if (exported.length) fields.push(field("names", table(exported.map((n) => field(n, boolean(true))))));
-    if (links.length) {
-      fields.push(field("links", table(links.map((link) => field(link.name, table([
-        { type: "TableFieldPositional", value: string(link.module) },
-        ...link.imported === void 0 ? [] : [{ type: "TableFieldPositional", value: string(link.imported) }]
-      ]))))));
-    }
-    if (stars.length) fields.push(field("stars", table(stars.map((star) => ({ type: "TableFieldPositional", value: string(star) })))));
-    fields.push(field("load", functionExpression(functionBody([module.exportsName], module.statements, true))));
-    modulesTable.fields.push({ type: "TableFieldComputed", key: string(module.name), value: table(fields) });
+  for (const module of layout[0].modules) {
+    modulesTable.fields.push({ type: "TableFieldComputed", key: string(module.name), value: moduleTable(module) });
   }
   const ok = names.fresh("ok");
-  const result = names.fresh("result");
+  const result2 = names.fresh("result");
   const entryStatements = parseLuau2(`
-local ${ok}, ${result} = xpcall(function()
-    return ${G}.require(${luauString3(sources.get(entry).name)})
+local ${ok}, ${result2} = xpcall(function()
+    return ${G}.require(${luauString4(sources.get(entry).name)})
 end, ${G}.fail)
 if not ${ok} then
-    error(${result}, 0)
+    error(${result2}, 0)
 end
-${modules.get(entry).info.exports ? `return ${result}` : ""}
+${modules.get(entry).info.exports ? `return ${result2}` : ""}
 `).body.statements;
   program2.body.statements.push(...entryStatements);
   const map = buildLineMap(program2, parseLuau2(print(program2)), origins);
-  if (map.size) {
-    program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, assign(
+  if (map.size || several) {
+    const mapStatements = [assign(
       [member(identifier(G), "lines")],
       [parseExpressionFromSource2(lineMapSource(map))]
-    ));
+    )];
+    if (several) mapStatements.push(...mapRegistration(G, layout[0], `${G}.lines`));
+    program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, ...mapStatements);
+  }
+  const files = [{ path: layout[0].path, code: print(program2) + "\n", modules: layout[0].modules.map((m) => m.name) }];
+  for (const file of layout.slice(1)) {
+    const body = [];
+    if (file.modules.some((m) => m.usesScriptArgs)) body.push(...parseLuau2(`local scriptArgs = ${G}.scriptArgs`).body.statements);
+    for (const module of file.modules) {
+      body.push(assign(
+        [index(member(identifier(G), "modules"), string(module.name))],
+        [moduleTable(module)]
+      ));
+    }
+    const chunk = program([returns([functionExpression(functionBody([G], body))])]);
+    const lines = buildLineMap(chunk, parseLuau2(print(chunk)), origins);
+    body.push(...mapRegistration(G, file, lineMapSource(lines)));
+    files.push({ path: file.path, code: print(chunk) + "\n", modules: file.modules.map((m) => m.name) });
+  }
+  return { code: files[0].code, files, modules: moduleNames, diagnostics };
+}
+function moduleTable(module) {
+  const { names: exported, links, stars } = module.info;
+  const fields = [];
+  if (exported.length) fields.push(field("names", table(exported.map((n) => field(n, boolean(true))))));
+  if (links.length) {
+    fields.push(field("links", table(links.map((link) => field(link.name, table([
+      { type: "TableFieldPositional", value: string(link.module) },
+      ...link.imported === void 0 ? [] : [{ type: "TableFieldPositional", value: string(link.imported) }]
+    ]))))));
+  }
+  if (stars.length) fields.push(field("stars", table(stars.map((star) => ({ type: "TableFieldPositional", value: string(star) })))));
+  fields.push(field("load", functionExpression(functionBody([module.exportsName], module.statements, true))));
+  return table(fields);
+}
+function layoutOf(mode, entry, modules, outFile) {
+  const extension = outFile !== void 0 && extname(outFile) || ".luau";
+  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();
+    const stack = [root];
+    while (stack.length) {
+      const name = stack.pop();
+      if (seen.has(name)) continue;
+      seen.add(name);
+      stack.push(...byName.get(name)?.imports ?? []);
+    }
+    return seen;
+  };
+  const inEntry = reach(entry.name);
+  const roots = [...new Set(modules.flatMap((m) => [...m.dynamicImports]))].filter((root) => !inEntry.has(root));
+  const reached = new Map(roots.map((root) => [root, reach(root)]));
+  const groups = /* @__PURE__ */ new Map();
+  for (const module of others) {
+    if (inEntry.has(module.name)) continue;
+    const by = roots.filter((root) => reached.get(root).has(module.name));
+    const key = by.join("\n");
+    if (!groups.has(key)) groups.set(key, { roots: by, modules: [] });
+    groups.get(key).modules.push(module);
+  }
+  const files = [{ path: `${entryStem}${extension}`, modules: modules.filter((m) => inEntry.has(m.name)) }];
+  const taken = /* @__PURE__ */ new Set([entryStem]);
+  for (const group of groups.values()) {
+    const label = group.roots.length === 1 ? group.roots[0].replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "chunk" : "shared";
+    let stem = `${entryStem}_${label}`;
+    for (let n = 2; taken.has(stem); n++) stem = `${entryStem}_${label}_${n}`;
+    taken.add(stem);
+    files.push({ path: `${stem}${extension}`, modules: group.modules });
+  }
+  return files;
+}
+function loadPath(entryPath, file, target) {
+  const path = posix.relative(posix.dirname(entryPath), file);
+  if (target === "lua51") return path;
+  const bare = path.slice(0, path.length - posix.extname(path).length);
+  return bare.startsWith("../") ? bare : `./${bare}`;
+}
+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 !== "");
+  const entry = `${G}.sources[#${G}.sources + 1]`;
+  return parseLuau2([
+    `${entry} = { { ${parts.map(luauString4).join(", ")} }, ${map}, ${luauString4(extension.slice(1))} }`,
+    ...file.modules.map((module) => `${G}.maps[${luauString4(module.name)}] = ${G}.sources[#${G}.sources][2]`)
+  ].join("\n")).body.statements;
+}
+function loader(G, target) {
+  if (target === "lua51") {
+    return `
+        -- From beside this file, wherever that is: its own path says where.
+        local folder = ""
+        if debug ~= nil and debug.getinfo ~= nil then
+            local at = debug.getinfo(${G}.load, "S").source
+            if at:sub(1, 1) == "@" then
+                folder = at:match("^@(.*[/\\\\])") or ""
+            end
+        end
+        local chunk, problem = loadfile(folder .. file)
+        if chunk == nil then
+            error(problem, 0)
+        end
+        chunk()(${G})`;
   }
-  return { code: print(program2) + "\n", modules: moduleNames, diagnostics };
+  return `
+        require(file)(${G})`;
 }
-function runtime(G) {
+function runtime(G, options) {
+  const { several } = options;
+  const files = [...options.files].map(([name, file]) => `[${luauString4(name)}] = ${luauString4(file)}`).join(", ");
   return `
 local ${G}
 ${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" }),
     -- 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
@@ -2228,7 +2690,7 @@ ${G} = {
             return message
         end
         local lines = ${G}.lines
-        if lines == nil then
+        if lines == nil ${several ? `and #${G}.sources == 0 ` : ""}then
             return message .. (trace or "")
         end
         -- The bundle's name, as a position in a message spells it: where this
@@ -2248,6 +2710,81 @@ ${G} = {
                 chunk = info.short_src
             end
         end
+${several ? `
+        -- A position in this file is read by this file's map. One in another
+        -- of the bundle's files is read by that file's: the one whose name
+        -- the position ends with, by the most folders where several do. A
+        -- message says nothing about which file it starts in, so nothing is
+        -- guessed from it here.
+        local prefix = nil
+        if chunk ~= nil then
+            prefix = chunk:gsub("%p", "%%%0")
+        end
+        local function place(line)
+            local origin = lines ~= nil and lines[tonumber(line)] or nil
+            if origin == nil then
+                return nil
+            end
+            return origin[1] .. ":" .. tostring(origin[2])
+        end
+        local function elsewhere(at, line)
+            -- Already a place in the project.
+            if at:sub(-6) == ".tilua" then
+                return nil
+            end
+            local parts = {}
+            for part in at:gmatch("[^/\\\\%.]+") do
+                parts[#parts + 1] = part
+            end
+            local map, most, tied = nil, 0, false
+            for _, source in ipairs(${G}.sources) do
+                local names = source[1]
+                local last = #parts
+                if parts[last] == source[3] then
+                    last = last - 1
+                end
+                local same = 0
+                while same < #names and same < last and names[#names - same] == parts[last - same] do
+                    same = same + 1
+                end
+                if same > most then
+                    map, most, tied = source[2], same, false
+                elseif same == most then
+                    tied = true
+                end
+            end
+            -- Two files it could as well be: a wrong place is worse than none.
+            local origin = map ~= nil and not tied and map[tonumber(line)] or nil
+            if origin == nil then
+                return nil
+            end
+            return origin[1] .. ":" .. tostring(origin[2])
+        end
+        local mapped = message
+        if prefix ~= nil then
+            mapped = mapped:gsub(prefix .. ":(%d+)", function(line)
+                return place(line)
+            end)
+        end
+        mapped = mapped:gsub("(%S+):(%d+)", elsewhere)
+        local frames = {}
+        for frame in (trace or ""):gmatch("[^\\n]+") do
+            local at = nil
+            if prefix ~= nil then
+                local line = frame:match(prefix .. ":(%d+)")
+                if line ~= nil then
+                    at = place(line)
+                end
+            end
+            if at == nil then
+                for source, line in frame:gmatch("(%S+):(%d+)") do
+                    at = elsewhere(source, line)
+                    if at ~= nil then
+                        break
+                    end
+                end
+            end
+            if at ~= nil then` : `
         if chunk == nil then
             chunk = message:match("^(.-):%d+:")
         end
@@ -2269,8 +2806,9 @@ ${G} = {
         for frame in (trace or ""):gmatch("[^\\n]+") do
             local line = frame:match(prefix .. ":(%d+)")
             local at = line ~= nil and place(line) or nil
-            if at ~= nil then
-                local name = frame:match("function ([%w_.:]+)")
+            if at ~= nil then`}
+                -- Luau writes \`function name\`; Lua 5.1, \`function 'name'\`.
+                local name = frame:match("function ([%w_.:]+)") or frame:match("function '([^']+)'")
                 frames[#frames + 1] = "    at " .. at .. (name ~= nil and (" (" .. name .. ")") or "")
             end
         end
@@ -2279,13 +2817,36 @@ ${G} = {
         end
         return mapped .. "\\n" .. table.concat(frames, "\\n")
     end,
-    records = {},
+    records = {},${several ? `
+    -- The file each module outside this one is in, as \`load\` is handed it.
+    files = { ${files} },
+    loaded = {},
+    -- Every file's line map: by the module, and by the file's name.
+    maps = {},
+    sources = {},
+    -- 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.target)}
+    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)
+    end,` : ""}
     require = function(name)
         local record = ${G}.records[name]
         if record ~= nil then
             return record.exports
         end
-        local module = ${G}.modules[name]
+        local module = ${G}.modules[name]${several ? `
+        if module == nil then
+            ${G}.load(${G}.files[name])
+            module = ${G}.modules[name]
+        end` : ""}
         local initialized = {}
         local exports = setmetatable({}, {
             __index = function(_, key)
@@ -2304,7 +2865,7 @@ ${G} = {
                     return source[link[2]]
                 end
                 if module.stars ~= nil and key ~= "default" then
-                    for _, star in module.stars do
+                    for _, star in ipairs(module.stars) do
                         local value = ${G}.require(star)[key]
                         if value ~= nil then
                             return value
@@ -2345,7 +2906,7 @@ function parseFile(file, diagnostics, directives) {
   }
   let text;
   try {
-    text = readFileSync2(file, "utf8");
+    text = readFileSync3(file, "utf8");
   } catch {
     diagnostics.push({ file, message: "Cannot read file", line: 1, column: 1, category: "module" });
     return void 0;
@@ -2379,7 +2940,7 @@ function parsedLibrary(file) {
   }
   const cached = libraryCache.get(file);
   if (cached && cached.stamp === stamp) return cached.program;
-  const program2 = parse(readFileSync2(file, "utf8"));
+  const program2 = parse(readFileSync3(file, "utf8"));
   libraryCache.set(file, { stamp, program: program2 });
   return program2;
 }
@@ -2390,6 +2951,8 @@ function analyzeModules(modules, config) {
   const libraries = config ? resolveTypeLibraries(config) : { files: [], lowerings: [], 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;
+  const checked = libs.length > 0 || !noLib;
   const globals = libs.flatMap((lib) => lib.body.statements.flatMap((s) => s.type === "DeclareStatement" ? [s.name] : []));
   const byFile = new Map(modules.map((m) => [m.file, m]));
   const exportsCache = /* @__PURE__ */ new Map();
@@ -2402,12 +2965,12 @@ function analyzeModules(modules, config) {
     const done = analyzed.get(file);
     if (done) return done;
     const remembered = moduleAnalyses.get(file);
-    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read2, stamp]) => stampOf(read2) === stamp)) {
+    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read3, stamp]) => stampOf(read3) === stamp)) {
       analyzed.set(file, remembered.result);
       readWhile.set(file, remembered.read);
       return remembered.result;
     }
-    const scopes = analyzeScopes(program2, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
+    const scopes = analyzeScopes(program2, { builtinGlobals: globals, reportUndeclared: checked, noLib });
     const said = [];
     for (const d of scopes.diagnostics) {
       if (d.kind !== "undeclared") continue;
@@ -2417,34 +2980,35 @@ function analyzeModules(modules, config) {
     const types = analyzeTypes(program2, scopes, {
       libs,
       resolveModule: resolverFor(file),
-      reportUnknownTypes: libs.length > 0
+      noLib,
+      reportUnknownTypes: checked
     });
     for (const d of types.diagnostics) {
       const at = d.node;
       said.push({ file, message: d.message, line: at.line.start, column: at.column.start, category: "type" });
     }
-    const result = { types, diagnostics: said };
+    const result2 = { types, diagnostics: said };
     if (partials === before) {
-      analyzed.set(file, result);
-      const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      analyzed.set(file, result2);
+      const read3 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
       const own = stampOf(file);
-      if (own !== void 0) read2.set(file, own);
-      readWhile.set(file, read2);
-      if ([...read2.values()].every((stamp) => stamp !== void 0)) {
-        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read: read2, result });
+      if (own !== void 0) read3.set(file, own);
+      readWhile.set(file, read3);
+      if ([...read3.values()].every((stamp) => stamp !== void 0)) {
+        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read: read3, result: result2 });
       }
     }
-    return result;
+    return result2;
   };
   const resolverFor = (file) => (specifier) => {
     const target = resolveModulePath(file, specifier, config);
     if (!target) return void 0;
     const noteRead = () => {
-      const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
-      readWhile.set(file, read2);
+      const read3 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      readWhile.set(file, read3);
       const stamp = stampOf(target);
-      if (stamp !== void 0) read2.set(target, stamp);
-      for (const [below, belowStamp] of readWhile.get(target) ?? []) read2.set(below, belowStamp);
+      if (stamp !== void 0) read3.set(target, stamp);
+      for (const [below, belowStamp] of readWhile.get(target) ?? []) read3.set(below, belowStamp);
     };
     if (inProgress.has(target)) {
       partials++;
@@ -2458,15 +3022,15 @@ function analyzeModules(modules, config) {
     let program2 = byFile.get(target)?.program;
     if (!program2) {
       try {
-        program2 = parse(readFileSync2(target, "utf8"));
+        program2 = parse(readFileSync3(target, "utf8"));
       } catch {
         return void 0;
       }
     }
     inProgress.add(target);
     try {
-      const scopes = analyzeScopes(program2, { builtinGlobals: globals });
-      const types = byFile.has(target) ? analyzeModule(target, program2).types : analyzeTypes(program2, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
+      const scopes = analyzeScopes(program2, { builtinGlobals: globals, noLib });
+      const types = byFile.has(target) ? analyzeModule(target, program2).types : analyzeTypes(program2, scopes, { libs, noLib, resolveModule: resolverFor(target), diagnostics: false });
       const exports = moduleExports(program2, scopes, types, resolverFor(target));
       exportsCache.set(target, exports);
       noteRead();